//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



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. 




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. 



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. 



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. 




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.


Apache Releases NetBeans 22

Apache NetBeans 22 has been released. This release has a new Gradle Wizard, upgrades to Java 22 javac, and a number of UI changes.

Paul Allen's Living Computer Museum Going, Going, Gone

The Seattle-based Living Computer Museum, founded in 2012 by Paul Allen to preserve vintage and heritage computers for posterity has closed and its collection will be sold at auction by Christies in S [ ... ]

More News


kotlin book



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




Last Updated ( Thursday, 22 September 2016 )