//No Comment - Ceylon 1.3 & Julia 0.5.0
Written by Mike James   
Thursday, 22 September 2016

• Ceylon 1.3.0 Released

 

• Julia Release 0.5.0 Available

 nocommentlanguages

nocomment

Sometimes the news is reported well enough elsewhere and we have little to add other than to bring it to your attention.

No Comment is a format where we present original source information, lightly edited, so that you can decide if you want to follow it up. 

 

 

ceylonsept

Ceylon 1.3.0 Released

Ceylon is a modern, modular, statically typed programming language for the Java and JavaScript virtual machines created by Red Hat.

The language has a flexible and very readable syntax, a static type system, a module architecture and IDE supporting both IntelliJ IDEA and the Eclipse platform.

Ceylon enables the development of cross-platform modules that execute portably in both virtual machine environments. Alternatively, a Ceylon module may target one or the other platform, in which case it may interoperate with native code written for that platform.

This is the first release of Ceylon which supports Android development, the Node Package Manager (npm), andWildfly Swarm. It also is now supported by an IntelliJ plugin which also works with Android Studio. 

ceylonintellij

Changes

Enhancements to the language and command-line distribution include: 

  • support for developing Android applications
  • support for importing modules from npm and for publishing Ceylon modules to npm
  • support for developing microservices with WildFly Swarm
  • cross-platform services, abstracting the Java service loader
  • addition of the fat-jar tool for packaging a Ceylon program and its dependencies into a single assembly
  • much slimmer runtime
  • destructuring for parameters of anonymous functions
  • destructuring in cases of a switch
  • addition of the CorrespondenceMutator interface
  • addition of Collection.combinations()
  • small and since annotations
  • many minor improvements to interoperation with Java
  • experimental support for Java APT processors
  • improved behavior for is tests with generic Java types
  • correct typing for things annotated @Nullable/@NotNull in Java
  • full support for Java 8
  • reduced typechecker memory footprint

 

Docker images for Ceylon are now available, making it very easy to try Ceylon out. 

 

 julialogo

Julia Release 0.5.0 Available

The latest release of the Julia "scientific" language is available for download from Github. 

New language features

  • Generator expressions:f(i) for i in 1:n. This returns an iterator that computes the specified values on demand. This is useful for computing, e.g. sum(f(i) for i in 1:n) without creating an intermediate array of values.
  • Generators and comprehensions support filtering using `if` and nested iteration using multiple `for` keywords
  • Fused broadcasting syntax: ``f.(args...)`` is equivalent to ``broadcast(f, args...)`` and nested `f.(g.(args...))` calls are fused into a single `broadcast` loop  Similarly, the syntax `x .= ...` is equivalent to a `broadcast!(identity, x, ...)` call and fuses with nested "dot" calls; also, `x .+= y` and similar is now equivalent to `x .= x .+ y`, rather than `x =x.+y`
  • Macro expander functions are now generic, so macros can have multiple definitions (e.g. for different numbers of arguments, or optional arguments). However note that the argument types refer to the syntax tree representation, and not to the types of run time values.
  • Varargs functions like `foo{T}(x::T...)` may now restrict the number of such arguments using `foo{T,N}(x::Vararg{T,N})`  'x ∈ X` is now a synonym for `x in X` in `for` loops and comprehensions, as it already was in comparisons
  • The `PROGRAM_FILE` global is now available for determining the name of the running script
  • The syntax `x.:sym` (e.g. `Base.:+`) is now supported, while using `x.(:sym)` or `x.(i)` for field access are deprecated in favor of `getfield`
  • Function return type syntax `function f()::T` has been added. Values returned from a function with such a declaration will be converted to the specified type `T`.
  • Many more operators now support `.` prefixes (e.g. `.≤`). However, users are discouraged from overloading these, since they are mainly parsed in order to implement backwards compatibility with planned automatic broadcasting of dot operators in Julia 0.6. Explicitly qualified operator names like `Base.≤` should now use `Base.:≤` (prefixed by `@compat` if you need 0.4 compatibility via the `Compat` package).
  • User-extensible bounds check elimination is now possible with the new `@boundscheck` macro. This macro marks bounds checking codeblocks, which the compiler may remove when encountered inside an `nbounds` call.

There is a list of breaking and other changes on the website. 

Julia has lots of competition with many users still preferring Python, R and Matlab/Octave. Some even cling to FORTRAN. 

 

nocomment

 

To be informed about new articles on I Programmer, sign up for our weekly newsletter,subscribe to the RSS feed and follow us on, Twitter, FacebookGoogle+ or Linkedin.

Banner


Google Has A Network More Like The Brain
22/09/2019

Our current neural networks work wonders, but they are very far from mimicking the biological brain that they are based on. Now Google Research has some breakthrough results with a more biologically p [ ... ]



Transformers Offers NLP For TensorFlow and PyTorch
07/10/2019

A Python library offering Natural Language Processing for TensorFlow 2.0 and PyTorch has been released by HuggingFace.


More News

juliaceylon

graphics

 



 

Comments




or email your comment to: comments@i-programmer.info

 

 

 

Last Updated ( Thursday, 22 September 2016 )