Sortie de Julia 1.0 et 0.7
Julia est un langage novateur à certains points de vue : il atteint une vitesse d’exécution comparable au C, au C++ et à Fortran ; il est flexible et dynamique comme Ruby ou Python (pas de typage statique obligatoire, possibilité de définir de nouveaux types à l’exécution, etc.), tout en disposant d’un système de macros très puissant inspiré de LISP (qui permet de réécrire complètement du code). Sa syntaxe est prévue pour facilement écrire des mathématiques, y compris très avancées (ainsi, tout caractère Unicode peut servir pour les noms de variable ou de fonction, sauf rare exception, comme α, x² ou ∇, un grand nombre de caractères peut aussi être utilisé comme opérateurs, comme ∪, ∨, ±, ⊗ ou encore ⋉), tout en gardant un langage générique (à l’instar de Python) — on compte, par exemple, plusieurs frameworks Web (Genie.jl, Mux.jl). Sa licence est aussi extrêmement permissive, la grande majorité du code étant disponible sous MIT (seules quelques dépendances utilisent la GPL, mais elles peuvent être désactivées à la compilation).
Après six ans de développement public (et près de deux millions de téléchargements) — neuf depuis le début de la conception du langage —, voici venu le temps de Julia 1.0, la première version qualifiée par les développeurs de stable. La principale nouveauté par rapport aux versions précédentes est l’assurance qu’il n’y aura plus de changement de syntaxe pendant tout le cycle de versions 1.x : le langage continuera à évoluer, sa bibliothèque standard aussi, mais sans casser l’existant. Les développeurs ne rejettent pas l’idée d’une version 2.0, mais celle-ci prendra probablement plusieurs années à venir : toutes les fonctionnalités qui pouvaient poser problème et qui ont été accumulées sur les années de développement ont été désapprouvées avec la version 0.7. À ce niveau, Julia 1.0 est un nouveau départ plus propre pour la suite du développement.
Une autre nouveauté majeure est le remplacement du gestionnaire de paquets. Pkg2 officiait depuis plusieurs années et montrait quelques limites. La nouvelle itération, simplement nommée Pkg (anciennement Pkg3), fonctionne avec la notion d’environnements, qui peuvent coexister sur un même système sans interférer dans les versions des bibliothèques d’autres environnements (tout comme les environnements virtuels de Python).
Pour la gestion des données, Julia dispose maintenant d’une représentation canonique, comme NA en R. Le type d’une variable dont la valeur peut manquer est représenté par une union : Union{Missing, T}, c’est-à-dire que la valeur peut être soit missing (qui indique une valeur manquante), soit une valeur normale. Cette représentation fonctionne désormais très bien (elle est autorisée depuis les premières versions de Julia), grâce à de nombreuses optimisations au niveau du compilateur. Ainsi, Julia atteint la vitesse d’exécution de systèmes conçus d’une manière plus spécifique, tout en gardant une très grande flexibilité.
La gestion des chaînes de caractères évolue à nouveau (c’était déjà l’un des grands changements de Julia 0.4), avec le type String. Celui-ci peut stocker n’importe quelle suite d’octets, pas forcément des codes Unicode valides : toutes les données sont préservées, mais Julia indique quels octets correspondent à des valeurs autorisées selon Unicode.
Au niveau de la bibliothèque standard, un gros effort de modularisation a été mené : elle a été divisée en plus petits paquets qui sont toujours livrés avec Julia, mais qu’il faut importer soi-même (auparavant, ces fonctionnalités étaient disponibles d’office). L’objectif est que, à terme, ces modules puissent avoir un versionnage complètement indépendant de Julia et évoluer bien plus vite que le langage. En parallèle, toutes les fonctions ont été revues pour assurer un plus grand niveau de cohérence : ordre des arguments, nommage des fonctions (notamment pour éviter des noms hérités du C et qui n’ont plus de sens dans un langage moderne).
Ces évolutions et d’autres ont permis l’évolution de l’écosystème de Julia. Notamment, missing est à l’origine d’une réécriture de certains paquets de gestion des données. Cassette.jl est un paquet extrêmement puissant (mais complexe à utiliser dans la même mesure) qui permet d’effectuer des transformations du code juste avant sa compilation (d’une manière plus flexible que les macros). Ce dernier continuera à évoluer avec les prochaines versions de Julia, notamment au niveau de la performance, pour atteindre le même niveau de performance que d’autres approches de la programmation générique (par exemple, pour la différentiation automatique ou l’analyse dynamique de code).
Julia 1.0 sort en même temps que la version 0.7. Au niveau des fonctionnalités, les deux sont identiques : la 0.7 est prévue pour aider à la migration depuis Julia 0.6, grâce à de nombreux messages d’avertissement ; ainsi, le même code peut fonctionner soit avec Julia 0.6 et 0.7, soit avec la 0.7 et la 1.0. Julia 1.0 est ainsi plus léger, vu qu’il ne doit plus gérer la syntaxe antérieure (ce qui ralentit aussi l’exécution du code). Ainsi, pour les nouveaux utilisateurs du langage, il vaut mieux commencer directement par la version 1.0.
Néanmoins, cette sortie de Julia 1.0 ne fait pas l’unanimité dans la communauté. En effet, les dernières versions sont sorties dans la précipitation : en mois de deux semaines, la 0.7 a eu trois préversions RC (dont une qui n’a jamais été annoncée à cause de problèmes majeurs trouvés rapidement) et une pour la 1.0. De plus, certains utilisateurs ont la sensation que l’écosystème n’est pas encore vraiment prêt pour une version 1.0 : certains paquets absolument nécessaires pour des tâches courantes (comme l’accès aux bases de données) ne sont absolument pas au niveau, d’autres devraient avoir une petite mise à jour avant d’être pleinement compatibles avec Julia 0.7 et 1.0.
Voir aussi : la liste des nouveautés depuis Julia 0.6.
Télécharger Julia 1.0 et 0.7.
Source : Julia 1.0.
