Julia language maintainers announced the availability of Julia 1.6 on March 24. She is billed as an exception, as she is likely to become Julia’s next Long Term Support (LTS) release. Additionally, the version has been regression tested against all registered open source packages and any issues discovered have been fixed. The final decision on whether Julia 1.6 will become the next long-term support release will be made after it has been tested by the developers.

Julia is a programming language designed by researchers at MIT in 2009 and first unveiled to the general public in 2012. It is a high-level, high-performance and dynamic programming language for scientific computing, with a syntax familiar to users of other similar development environments. Julia has experienced tremendous growth since its release, and some even say it is the ideal language for scientific computing, data science, and research projects. The language became popular when the project became open source in 2012. It is currently available under the MIT license.

Basically, its designers wanted a language with a free license and containing many advantages, especially for the scientific community. “We want an open source language, with a free license. We want a language that combines the speed of C with the dynamism of Ruby. In fact, we want a homoiconic language, with real macros like Lisp and with obvious and familiar mathematical notation like MATLAB. We want something as usable for general programming as Python, as easy for statistics as R, as natural for string handling as Perl, as powerful for linear algebra as Matlab, and as good for binding programs as the shell. We want it to be both interactive and compiled, ”they said in 2012.

Most versions of Julia are timed and therefore not planned around specific features, but according to the people in charge of Project Julia, version 1.6 is an exception, as it is likely to become the next LTS version of Julia. For this reason, they took longer to develop the release to ensure that the features that are necessary for the ecosystem to evolve are included in the release. Additionally, the version has been regression tested against all registered open source packages and the issues have been investigated and fixed. Below are some of the improvements and features brought by Julia version 1.6.

  • Parallel precompilation
  • Executing all of the instructions in a module often involves compiling a large amount of code, Julia creates precompiled caches of the module to reduce this time. In version 1.6, this module precompilation is faster and occurs before the end of pkg> mode.

  • Compilation time
  • According to Julia’s designers, this is a small change that should help newcomers understand one of Julia’s quirks. Now the @time synchronization macro and the detailed version @timev now indicate if any part of the reported time was spent compiling.

  • Remove unnecessary recompilations
  • One of Julia’s most powerful characteristics is its extensibility: you can add new methods to previously defined functions, and use previously defined methods on new types. Sometimes these new entities force Julia to recompile the code to account for the changes in the version. This happens in two steps: first, the “obsolete” code is invalidated, marking it as unfit for use; then, if necessary, the code is compiled again from scratch, taking into account the new methods and types.

  • Reduced compilation latency
  • In this release, there is no major advance in reducing the latency of compilers, but modest improvements have been made thanks to the work on the data structure of the method tables. Ambiguous methods were also identified during insertion, in the hope of avoiding repeating the work for each future request. Unfortunately, sorting a partial order requires squared time, and this time manifests itself prominently during the loading of the package (when the methods of a package need to be inserted into the active method tables).

  • Acceleration of loading
  • While Julia’s strategy has always been to prioritize reliability and reproducibility over all other concerns, for designers in the past this has come at a cost. The solution to the reliability and reproducibility issues was to isolate the installed binaries more completely and compile them using the BinaryBuilder.jl framework. Libraries built from BinaryBuilder.jl are most often used through so-called JLL packages which provide a standardized API that Julia packages can use to access the provided binaries.

    Related Articles
    Leave a Reply

    Your email address will not be published. Required fields are marked *