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.
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
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.
One of developers who worked on the Flutter team at Google has created an open-source form of the framework. Matt Carroll says Flock will be "Flutter+", will remain constantly up to date with Flutter, [ ... ]
Amongst the many Java related conferences, this one flew under the radar. A real shame because it had many great sessions. JavaZone might not be that famous internationally, but it still is the bi [ ... ]
