Les fonctionnalités de Julia 1.0 seront arrêtées le 15 décembre

Julia est un langage de programmation de haut niveau, dynamique, mais orienté applications de haute performance (surtout pour le calcul scientifique). Malgré son jeune âge (il est apparu pour la première fois au grand public en 2012), il a déjà réussi à fédérer une certaine communauté (on estime à 250 000 son nombre d’utilisateurs en 2017).

Il s’apprête à voir sa première version finale, numérotée 1.0, après de longues années de développement. Toutes les fonctionnalités ne sont pas encore implémentées, mais cela ne devrait tarder : plus aucune ne sera acceptée dès le 15 décembre. À cette date, la première préversion Alpha de la 0.7 sera disponible, six mois après la 0.6. Julia 0.7 et 1.0 devraient être disponibles dans deux mois, si tout va bien.

Bon nombre d’évolutions attendues font leur apparition, comme la macro @isdefined pour déterminer si une variable locale existe ou encore un conteneur de type dictionnaire pour les arguments passés par nom à une fonction (en réalité, des tuples nommés, une autre nouveauté). Les valeurs manquantes, très utilisées en science des données, font leur apparition au sein même du langage (auparavant, elles l’étaient dans les paquets qui en avaient besoin). La macro @nospecialize est utilisée pour indiquer que le compilateur ne peut pas spécialiser une fonction sur le type d’un argument.

Certaines constructions peu lisibles ne sont plus acceptées dans le langage : 1.+2 pouvait être compris comme la somme d’un nombre à virgule flottante (1.) et d’un réel (2) ou bien comme la somme élément par élément entre listes (d’un côté, 1, de l’autre, 2 : 1 .+ 2) ; la juxtaposition de nombres en notation binaire, octale et hexadécimale ne pouvait être qu’illisible (0xapi était compris comme 0xa * pi). La bibliothèque standard a été considérablement allégée, en suivant un mouvement lancé depuis belle lurette : les fonctionnalités moins souvent utilisées (ou qui mériteraient d’être mises à jour plus souvent que le compilateur) ont été déplacées dans des paquets.

La sortie de la version 1.0 se fera en deux temps : tout d’abord, la version 0.7, qui aura exactement les mêmes fonctionnalités, mais avec des avertissements pour ceux qui utiliseraient d’anciennes syntaxes maintenant déconseillées ou supprimées ; très rapidement après, la 1.0, expurgée de ces messages. Ainsi, il sera conseillé de migrer son code vers la version 0.7 pour profiter des messages d’avertissement plus nombreux ; ensuite, le passage à la 1.0 se fera instantanément. Pour les nouveaux, par contre, seule la version 1.0 sera mise en avant.

Toutes les fonctionnalités souhaitées pour Julia 1.0 ne sont pas encore implémentées, toutefois. Si les développeurs ont le temps, tout ce qui sera possible sera implémenté d’ici au 15 décembre, pour laisser le temps aux tests avant la version finale. Les autres fonctionnalités seront ajoutées lors du cycle de vie de Julia 1.x, quitte à laisser des syntaxes indésirables acceptées : elles ne seront supprimées que lors du passage à Julia 2.0.

Voir aussi : la liste des changements apportés jusqu’à présent à Julia 0.7.0.

Source : 1.0 Feature Freeze Dec 15th.

Advertisements

Sortie de Julia 0.6

Julia est un langage de programmation de haut niveau, dynamique, mais orienté applications de haute performance (surtout pour le calcul scientifique). Malgré son jeune âge (il est apparu pour la première fois au grand public en 2012), il a déjà réussi à fédérer une certaine communauté (on estime à 250 000 son nombre d’utilisateurs en 2017), dans bon nombre de domaines.

Sa version 0.6 est sortie, un peu moins d’un an après la précédente. Elle marque le dernier jalon avant la version finale : la 0.7 et 1.0 sortiront presque simultanément, la seule différence étant la gestion d’anciennes syntaxes et l’émission de messages correspondants pour la 0.7 (ce dont la 1.0 ne s’alourdira pas).

Le plus gros changement de Julia 0.6 concerne le moteur d’inférence des types, qui a été complètement réécrit pour être plus rapide, donner des résultats plus précis (ce qui permet d’optimiser le code exécuté) et permettre de nouvelles fonctionnalités. Ainsi, en définissant un nouveau type avec des paramètres (comme une classe générique dans bon nombre d’autres langages), on peut faire référence aux types des paramètres précédents. Par exemple, avec struct Foo{R<:Real, A<:AbstractArray{R}}, on définit un type Foo par rapport à un type particulier de nombres réels (comme Float64) et un tableau (dont les éléments doivent avoir le même type que mentionné précédemment).

Au niveau syntaxique, les mots clés pour définir des types ont été changé pour promouvoir par défaut des valeurs immuables : le code généré est bien souvent plus rapide, cela réduit le risque d’erreur lors de l’écriture du code, avec un impact souvent minime sur l’utilisateur. Ainsi, type devient mutable struct tandis que immutable devient simplement struct.

Pour la performance, les opérateurs et fonctions sont tous vectorisés automatiquement à l’aide d’un point : a .⨳ b est la syntaxe équivalente à l’application de l’opérateur  entre tous les éléments de a et de b. L’avantage principal est que ce mécanisme est géré au niveau du langage, il n’y a plus de traitement particulier des opérateurs vectorisés. Grâce à ce changement, l’écriture de code très optimisé sur des vecteurs devient très facile : pour évaluer une expression utilisant une série d’opérateurs vectorisés, Julia n’exécute qu’une seule boucle à travers les opérandes.

Voir aussi : les notes de version de Julia 0.6.

Sortie de Julia 0.5

Julia est un langage de programmation assez récent (son développement a commencé en 2012), mais il a déjà réussi à attirer une assez grande communauté autour de lui. Initialement, il est prévu pour le calcul scientifique, en fournissant un langage dynamique et facile à utiliser (comme Python ou MATLAB) tout en gardant une très bonne performance (digne d’un langage compilé : Julia est très proche du C ou du Fortran dans les temps d’exécution).

La version 0.5 vient de sortir, un an après la précédente… et avec pas loin de trois mois de retard sur le programme. Elle ne se focalise pas exclusivement sur la performance, mais plutôt sur les fonctionnalités : certains changements syntaxiques préparent le terrain pour des améliorations de performance pour les prochaines versions du langage. Ses développeurs cherchent à stabiliser le langage dès que possible pour favoriser son adoption : la première version finale, la 1.0, ne devrait plus tarder (courant 2017).

Dans les nouveautés intéressantes pour bon nombre de programmeurs, les expressions de la forme f(i) for i in 1:n sont maintenant des génératrices : elles correspondent à des itérateurs sur les valeurs demandées. Ainsi, pour calculer la somme de toutes ces valeurs, il n’est plus nécessaire de créer un tableau à cette occasion : sum(f(i) for i in 1:n) au lieu de sum([f(i) for i in 1:n]) précédemment (les crochets ne sont plus nécessaires). Toujours au niveau des génératrices, il devient possible d’ajouter des conditions avec le mot clé if et d’effectuer des boucles imbriquées en utilisant plusieurs fois for.

Les opérateurs avec point existent depuis un certain temps et servent à effectuer une opération sur chaque élément séparément (par exemple, a .+ b effectue la somme de chaque élément de a et de b). Désormais, ce point est généralisé pour toutes les fonctions ; l’interpréteur se charge alors d’appeler la fonction broadcast. Dans le futur, ces nouvelles possibilités syntaxiques seront utilisées pour optimiser le code, en fusionnant ces opérations.

Julia étant prévu pour le calcul scientifique, le parallélisme est une thématique très importante. Certaines facilités syntaxiques existent déjà depuis longtemps pour la communication entre processus, mais les développeurs cherchent depuis un certain temps la meilleure approche pour la programmation multifil (c’est-à-dire à mémoire partagée). Les idées convergent vers une implémentation disponible dès cette version 0.5, mais la syntaxe pourrait encore évoluer. Pour exploiter les différents cœurs d’une machine, il suffirait d’utiliser une macro @threads sur chaque boucle à paralléliser, sans plus d’action requise de la part de l’utilisateur.

Un débogueur fait maintenant son apparition dans Julia. Il n’est pas livré avec l’interpréteur, mais est très facile à installer. Gallium est en développement depuis de nombreux mois et est aussi intégré dans l’environnement de développement Juno.

Cette version regorge de modifications en tout sens pour donner plus de cohérence à la bibliothèque standard et pour alléger son cœur (de telle sorte qu’il reste possible d’utiliser Julia dans n’importe quelle situation). Ces optimisations sont, par exemple, utiles dans l’embarqué ; à ce sujet, l’exécution sur des plateformes ARM (généralement utilisées dans l’embarqué) a été largement améliorée ; de même, l’architecture IBM POWER est maintenant gérée.

Source : Julia v0.5.0 Release Notes.

Juno, un EDI pour Julia

Julia est un langage très récent : sa première version date de 2012 et il est actuellement en version 0.4. Il est de plus en plus utilisé de par le monde, avec un public assez divers : quelques programmeurs dont c’est le métier, mais surtout des scientifiques, des ingénieurs, des analystes financiers, des statisticiens qui développent les bibliothèques de fonctions qui leur sont utiles. Pour que plus de gens utilisent le langage, il est nécessaire de fournir un environnement de développement complet et accessible pour ce public, avec de l’autocomplétion intelligente, l’intégration de graphiques, le débogage, etc. Cet environnement prend le nom de Juno.

Le développement est parti d’un composant proposé par GitHub, Atom, un éditeur de texte prévu pour être facile à personnaliser. Il a la particularité d’être basé exclusivement sur des technologies Web, c’est-à-dire qu’il est codé en HTML, CSS et JS, avec une architecture très modulaire (Juno est implémenté comme une série de modules, relativement indépendants les uns des autres, ce qui devrait faciliter leur réutilisation dans d’autres projets, comme Ink, celui chargé des composants graphiques d’un EDI). Il reste cependant accessible comme une application de bureau traditionnelle, en dehors du navigateur, par Electron (ex-Atom Shell).

La prochaine priorité sera le fignolage de l’utilisation interactive, plus particulièrement tout ce qui a trait au multimédia, aux graphiques interactifs. Ainsi, avec un seul téléchargement, les nouveaux utilisateurs pourront rapidement commencer à écrire quelques lignes de code Julia, à créer des graphiques très rapidement avec les paquets fournis de base. Ensuite, la documentation et le débogueur seront inclus (même si ce dernier doit encore être finalisé du côté Julia : les fonctionnalités sont actuellement au stade de prototype et ne sont pas incluses de base), avec un outil d’analyse de la performance du code.

Pour le téléchargement de la nouvelle version 1.1.0, direction le site de Julia. (La version sur le site de Juno est dépassée et ne fonctionne pas avec les versions actuelles de Julia et des paquets requis.)

Source : Julia IDE work in Atom.

Sortie de Julia 0.4

À peine un mois après la sortie de sa RC 1, plus d’un an après sa dernière version mineure (0.3 en août 2014), la version finale de Julia 0.4 est sortie. Ce langage de programmation assez récent est principalement prévu pour le calcul scientifique. Similaire à MATLAB au niveau de la syntaxe, il est de très haut niveau et dynamique, tout en atteignant une performance comparable aux langages statiques comme C ou Fortran.

Pour les utilisateurs, les nouveautés principales de cette version mineure concernent la performance : la compilation incrémentale des paquets, ce qui réduit fortement le temps de chargement des plus lourds d’entre eux ; le ramasse-miette est passé à une implémentation par générations, ce qui améliore la performance dans les cas les plus fréquents par rapport à l’implémentation traçante précédente ; des canaux de communication entre tâches plus rapides. Les types des tuples ont complètement changé, passant de (A,B) à Tuple{A,B}, ce qui est plus cohérent ; de plus, cette refactorisation autorise la graphie field::NTuple{N,T} pour désigner des tuples de N éléments d’un même type.

Les développeurs de paquets se réjouiront de la finalisation d’autres fonctionnalités, comme la surcharge des appels de fonction (y compris les constructeurs) pour n’importe quel objet (et pas seulement la fonction elle-même) ; en particulier, il devient possible de définir des constructeurs pour des types abstraits. Les fonctions générées donnent un contrôle bien plus grand sur la spécialisation des fonctions lors de la compilation : ces fonctions retournent un code en fonction du type des paramètres (et non une valeur en fonction des valeurs des paramètres pour les fonctions traditionnelles).

De manière générale, Julia 0.4 a aussi été l’occasion d’améliorer la performance (réduction des vérifications effectuées lors de l’adressage tout en garantissant le même niveau de sécurité) et la flexibilité des tableaux à plusieurs dimensions, des vues sur ces tableaux (SubArray) et de l’itération (avec par exemple la fonction eachindex() pour itérer sur tous les éléments d’un tableau, peu importe le nombre de dimensions, en garantissant une performance optimale) ; les changements implémentés sont listés dans un métaticket. Plus de changements sont prévus pour Julia 0.5, détaillés dans le métaticket Arraypocalypse.

La communauté Julia a aussi gagné en maturité depuis l’instant de mise à disposition de la version 0.3. Notamment, une série de paquets ont atteint une belle maturité : JuliaOpt pour l’optimisation ; JuliaStats pour les statistiques et l’apprentissage automatique ; JuliaGPU pour l’accès au GPU ; IJulia, une interface en feuilles de calcul basée sur IPython ; Images.jl pour le traitement d’images ; Gadfly et Winston pour les graphiques ; Juno comme environnement de développement.

Source : Julia 0.4 Release Announcement.

Merci à Claude Leloup pour ses corrections.

Sortie de Julia 0.4 RC1

Julia est un langage de programmation assez récent prévu pour le calcul scientifique (sa première version est sortie en 2009). Similaire à MATLAB au niveau de la syntaxe, il est de très haut niveau et dynamique, mais sa conception même lui permet d’atteindre une performance comparable aux langages statiques comme C ou Fortran, par l’utilisation de la compilation juste à temps (JIT). Selon les tests de performance publiés sur le site officiel, il peut être plus rapide que le C ou jusque deux fois plus lent — son principal concurrent, MATLAB, pouvant être plusieurs milliers de fois plus lent. Pour y arriver, l’interpréteur n’utilise pas la programmation orientée objet, mais un concept dérivé : la fonction à appeler est déterminé en fonction du type des arguments (multiple dispatch) ; au besoin, il peut aussi directement appeler du code C ou Fortran, directement depuis la bibliothèque standard (des modules externes permettent de faire la même chose pour C++ et Python).

En tant que langage spécifiquement prévu pour le calcul scientifique, un bon nombre de bibliothèques sont d’ores et déjà disponibles dans le domaine pour former une bibliothèque standard plus que conséquente, principalement pour l’algèbre linéaire, la génération de nombres aléatoires et le traitement du signal. Notamment, toutes les fonctions de BLAS existent, mais sont également intégrées dans la syntaxe du langage (* pour la multiplication matricielle, pour la résolution de systèmes linéaires, ⋅ pour le produit scalaire, × pour le produit vectoriel, etc.). Ces opérateurs utilisent les symboles habituels dans la littérature (de même, tout caractère Unicode peut être utilisé comme nom de variable).

Contrairement à bon nombre de langages, le parallélisme est pris en charge directement dans la syntaxe du langage. Par exemple, pour mener un grand nombre d’expériences de pile ou face sur des grappes de calcul, le code est extrêmement simple :

nheads = @parallel (+) for i=1:100000000
int(randbool())
end

Parmi les fonctionnalités très attendues de cette nouvelle version 0.4 RC1, la précompilation évite de compiler les modules importés à chaque exécution d’un script : ils sont convertis en code binaire une fois pour toutes, ce qui améliore fortement les temps de chargement (dans certains cas, d’une dizaine de secondes à moins d’une). De plus, cette fonctionnalité ne réduit pas la performance du code à l’exécution : le même moteur de compilation est utilisé (LLVM), il est seulement moins souvent appelé.

La documentation des modules pour la version 0.3 se faisait par le module Docile.jl et est maintenant intégrée directement au niveau du langage. Le texte écrit en Markdown et est accessible depuis l’invite de commande. Cette fonctionnalité est incrémentale, de telle sorte que, si un fichier est modifié, seules les méthodes ayant subi des changements seront recompilées.

Un autre point fort du langage est la métaprogrammation, avec des macros très similaire à l’esprit de LISP : ces macros peuvent prendre du code en argument, représenté comme une structure de données (arbre syntaxique abstrait), manipulable à l’envi, afin de générer du code à l’exécution. Ces fonctionnalités sont très pratiques pour développer des langages dédiés (comme JuMP pour la programmation mathématique), intégrés directement dans le code Julia. À ce sujet, cette version 0.4 utilise la métaprogrammation pour définir des fonctions générées : son implémentation travaille uniquement sur le type des variables, la valeur retournée étant l’expression à évaluer lors de l’appel effectif de cette fonction sur des valeurs données — sans que le code qui appelle cette fonction soit conscient de ces détails.

La version finale de Julia 0.4 est attendue assez rapidement, une fois les derniers défauts corrigés. Les nouvelles fonctionnalités seront ajoutées dans la branche Julia 0.5, qui pourrait également apporter quelques changements qui casseront la compatibilité avec le code existant. Une nouveauté attendue sera la gestion du débogage interactif (actuellement implémenté dans un module externe, qui nécessite d’instrumenter le code : Debug.jl).

Source : Julia v0.4.0 Release Notes.