L'équipe de développement de Julia a publié la première version admissible de Julia 1.7
mais elle n'est pas prête pour la production comme c'était le cas avec les précédentes RC

Julia est un langage de programmation open source et un écosystème pour le calcul scientifique de haute performance (High performance computing). Il est mis à jour régulièrement et la publication de la version 1.6 remonte à mars dernier. La première version candidate (Release candidate - RC) de Julia 1.7 est désormais disponible pour les tests sur Linux, BSD, macOS et Windows. Elle est livrée avec plusieurs nouvelles fonctionnalités et quelques améliorations.

Traditionnellement, les versions candidates de Julia sont proches du produit fini, et la plupart des utilisateurs qui souhaitent travailler avec les nouvelles fonctionnalités peuvent télécharger sans risque les binaires de Julia 1.7rc1 depuis le site de Julia dans la section "upcoming release". Cependant, l'équipe a déclaré que cette RC n'est pas "prête pour la production", ajoutant qu'elle accueille volontiers les rapports de bogues sur le traqueur de problèmes GitHub. Cet article décrit certains des changements et des nouvelles fonctionnalités du langage et de ses bibliothèques qui arrivent dans la version 1.7.

Modifications de la syntaxe

Comme pour toutes les modifications apportées au langage depuis la version 1.0, rien dans la version 1.7 ne devrait créer de rupture, sauf dans de rares cas. Cela dit, une nouvelle forme de concaténation de tableaux constitue l'un de ces rares cas. Auparavant, le point-virgule était utilisé pour la concaténation le long de la première dimension, et il conserve cette signification.

Nom : ddfc1e00-6638-11e9-9b80-0fe7b9aedd72.png
Affichages : 702
Taille : 725,0 Ko

Mais les points-virgules répétés étaient traités comme un seul point-virgule, et ils ont désormais une nouvelle signification. Cela ne devrait casser que les programmes où un point-virgule répété est présent en tant que faute de frappe. Actuellement, l'opérateur point-virgule fonctionne comme suit :

Code Julia : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
 
v1 = [1, 2, 3]
v2 = [4, 5, 6]
[v1; v2]   # results in [1, 2, 3, 4, 5, 6]

Cependant, l'opérateur est étendu dans la version 1.7 : n points-virgules concatène maintenant le long de la nième dimension. De nouvelles dimensions sont créées si nécessaire. Par exemple, le résultat de [v1;; v2] est de créer une nouvelle deuxième dimension et de la joindre le long de celle-ci, produisant la matrice 3×2 :

Code Julia : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
 
    1 4
    2 5
    3 6

La nouvelle syntaxe des opérateurs nous permet de créer une troisième dimension de manière concise : [v1;;; v2] donne un tableau 3×1×2, avec :


comme premier plan et :


comme deuxième plan.

Raffinements d'Unicode

Julia continue à affiner son acceptation d'Unicode comme partie de la syntaxe. Depuis le début, Julia a permis à la juxtaposition de signifier la multiplication dans les cas où elle n'était pas ambiguë, donc si y = 7, alors 2y était 14. Elle a également permis aux symboles Unicode de racine carrée et cubique d'avoir leur signification mathématique familière. Vous pouvez maintenant combiner la juxtaposition avec ces symboles, comme l'illustre cette session REPL (read-execute-print-loop) :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
    julia> x = 64
    64
 
    julia> √x
    8.0
 
    julia> 3√x
    24.0
 
    julia> ∛x
    4.0
 
    julia> 3∛x
    12.0
Les opérateurs infixes dans Julia sont simplement des fonctions qui peuvent être utilisées avec une syntaxe alternative. Par exemple, l'opérateur plus est en réalité une fonction : 3 + 4 est la même chose que +(3, 4). Le programmeur peut utiliser une grande variété de symboles Unicode comme noms de fonctions, mais en général ces noms ne peuvent pas être utilisés comme opérateurs infixes à moins que le langage ne leur accorde un traitement spécial. Julia 1.7 définit deux nouveaux symboles qui peuvent être utilisés de cette façon : ⫪ et ⫫, qui peuvent être entrés dans le REPL en utilisant \Top et \Bot suivis par TAB.

Ils ont la même précédence que les opérateurs de comparaison tels que >. Comme petit exemple de ce que l'on pourrait faire avec cela, la session REPL suivante définit une fonction qui teste si la valeur absolue de son premier argument est plus grande que la valeur absolue de son second :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
    julia> function ⫪(a, b)
               return abs(a) > abs(b)
           end
    ⫪ (generic function with 1 method)
 
    julia> ⫪(-8, 3)
    true
 
    julia> ⫪(-9, -12)
    false
 
    julia> -9 ⫪ -12
    false
La dernière entrée montre que ce nouveau symbole peut être utilisé comme un opérateur infixe. En outre, la possibilité d'utiliser l'Unicode pour les noms et les opérateurs aide à faire en sorte que les programmes Julia ressemblent plus aux mathématiques. Cependant, Unicode est connu pour contenir des caractères distincts qui semblent identiques, une circonstance qui a conduit directement à une classe de vulnérabilités de noms de domaine. Avoir des caractères différents qui sont visuellement indiscernables peut évidemment être une source de bogues sérieux.

Une façon pour Julia de prévenir ce problème est de s'assurer que de tels caractères visuellement identiques ont une sémantique identique. La version 1.7 définit trois points centrés Unicode, avec les points de code U+00b7, U+0387, et U+22c5 (ils ressemblent tous à ceci : -) comme fonctionnellement identiques. Ils peuvent être utilisés comme opérateurs infixes. La nouvelle version introduit également le signe moins Unicode (U+2212, ou \minus dans le REPL) pour signifier la même chose que le trait d'union ASCII que nous utilisons généralement pour la soustraction.

Nouvelles fonctionnalités du REPL

Selon l'équipe, le REPL dispose depuis longtemps d'une fonctionnalité appelée "mode collage", qui permet à l'utilisateur de coller une session d'exemple directement dans le REPL. Celui-ci élimine automatiquement les invites, reconnaît les entrées de l'utilisateur et fait généralement ce qu'il faut. Ce système a été étendu à tous les modes du REPL (pkg, shell et help) en plus du mode normal ; il change même de mode automatiquement en fonction de la chaîne d'invite dans le texte collé.

Le mode help présente la documentation principalement en formatant les doctrines fournies par le programmeur au niveau de la fonction ou du module. Maintenant, dans le cas où un module n'a pas de docstring (ce qui n'est pas rare, surtout avec les petits paquets), help cherchera dans le répertoire du paquet un fichier README et imprimera celui qui est le plus proche du module en question. Dans tous les cas, il affichera la liste des noms exportés. Une fonctionnalité similaire existait dans certaines versions de Julia antérieures à la version 1.0, il s'agit donc plus d'une renaissance que de quelque chose de nouveau.

Si l'utilisateur du REPL fait quelque chose qui retourne un grand tableau, le REPL imprimera une forme abrégée, en utilisant des ellipses pour indiquer les éléments sautés. Cependant, jusqu'à présent, le REPL affichait implacablement toute chaîne énorme qu'on lui demandait d'afficher. Dans la version 1.7 de Julia, les longues chaînes de caractères sont élidées de la même manière que les longs tableaux. Le REPL imprimera les trois premières lignes et demie environ, suivies d'une notation comme ⋯ 13554 bytes ⋯, puis les trois dernières lignes et demie. La fonction show() peut être utilisée pour voir la chaîne entière.

Si l'utilisateur tente d'importer un paquet non installé, le REPL offre maintenant quelques conseils :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
 
    julia> using Example
    │ Le paquet Example n'a pas été trouvé, mais un paquet nommé Example est disponible dans un registre.
    │ registre. 
    │ Installer le paquet ?
    │ (@v1.7) pkg> add Example 
    └ (y/n) [y] :
Répondre "y" suffit, alors qu'auparavant les utilisateurs devaient savoir entrer en mode paquetage et utiliser la commande add. Selon l'équipe, cela devrait être particulièrement utile pour les débutants.

Changements dans la bibliothèque standard

La fonction bien établie [C=Julia]deleteat!(v, i)[/B] mute le vecteur v en supprimant les éléments aux indices de la liste i. La nouvelle version de Julia ajoute sa jumelle, keepat!(v, i), qui est aussi une fonction mutante comme indiqué par la convention "!". Elle supprime effectivement les éléments pour tous les indices non présents dans i.

Selon l'équipe, auparavant, rediriger à la fois l'erreur standard et la sortie standard dans une session Julia était un exercice de verbosité nécessitant quatre niveaux d'imbrication. Maintenant, il y a une nouvelle fonction de la bibliothèque qui rend cela beaucoup plus facile :

Code Julia : Sélectionner tout - Visualiser dans une fenêtre à part
redirect_stdio(p, stdout="stdout.txt", stderr="stderr.txt")

Cette fonction appelle la fonction p() et redirige ses instructions d'impression vers les chemins fournis. Cette nouvelle fonction devrait être plus pratique lorsqu'elle est utilisée avec un bloc do, qui crée une fonction anonyme et la passe comme premier argument à un appel de fonction. De cette façon, vous pouvez inclure tout ce que vous voulez dans la fonction redirect_stdio() :

Code Julia : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
    redirect_stdio(stdout="stdout.txt", stderr="stderr.txt") do
               println("Julia a des nombres rationnels :")
               println(1//5 + 2//5)
    end

Ensuite, l'équipe note que la fonction replace() existante peut effectuer une seule substitution sur une chaîne de caractères. Elle a été améliorée pour accepter un nombre quelconque de motifs de remplacement, qui sont appliqués de gauche à droite et "simultanément". Les notes de version utilisent le terme "simultanément", ce qui signifie simplement que les sous-chaînes remplacées ne sont pas soumises à d'autres remplacements. Voici un exemple :

Code Julia : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
 
     julia> s = "abc"
    "abc"
 
    julia> replace(s, "b" => "XX", "c" => "Z")
    "aXXZ"
 
    julia> replace(s, "c" => "Z", "Z" => "WWW")
    "abZ"
 
    julia> replace(s, "ab" => "x", "bc" => "y")
    "xc"

Selon l'équipe, cette nouvelle fonction est à la fois pratique et nettement plus rapide que les techniques d'expression régulière auxquelles les gens ont généralement recours. Les deux derniers exemples montrent comment la fonction fonctionne en présence de plusieurs correspondances possibles.

Par ailleurs, des améliorations significatives liées à la génération de nombres pseudo-aléatoires arrivent avec la version 1.7. Le générateur par défaut a été remplacé par un générateur plus performant en matière de temps, de consommation de mémoire et de propriétés statistiques. Le nouveau générateur rend également plus facile l'exécution de calculs parallèles reproductibles. Julia supporte plusieurs types de calculs parallèles et concurrents. La plupart des calculs parallèles dans Julia sont organisés autour de tâches, qui sont similaires aux coroutines dans d'autres langages.

Le nouveau générateur de nombres aléatoires est "task local", ce qui signifie que, pendant un calcul parallèle, chaque tâche obtient sa propre instance du générateur. La même séquence de nombres pseudo-aléatoires sera générée sur chaque tâche, indépendamment de l'allocation aux threads. Cela permet de réaliser des simulations reproductibles à l'aide de nombres aléatoires, même avec des algorithmes qui créent dynamiquement des tâches pendant l'exécution.

Selon l'équipe, cela introduit l'une des avancées les plus significatives arrivant avec la nouvelle version. Auparavant, dans un calcul multithread, une fois qu'une tâche était assignée à un thread, elle était bloquée sur ce thread pour toujours. La version 1.7 de Julia introduit la migration des tâches. Maintenant, le planificateur peut déplacer les tâches entre tous les threads disponibles, ce qui peut aider à équilibrer la charge et l'efficacité parallèle.

Source : Julia 1.7rc1

Et vous ?

Que pensez-vous des nouveautés introduites par Julia 1.7rc1 ?

Voir aussi

La version 1.6 du langage Julia est disponible, elle apporte une réduction de la latence des compilateurs et supprime les recompilations inutiles

Le langage de programmation Julia serait capable de lire les fichiers CSV dix à vingt fois plus vite que Python et R, selon une étude

Le langage de programmation Julia gagne de plus en plus en popularité au sein de la communauté scientifique depuis janvier 2018

Les raisons de l'adoption accélérée du langage Julia : un langage polyvalent, mais plus scientifique, supporte l'introspection et la métaprogrammation, selon Lee Phillips