Julia 1.12, la dernière version du langage de programmation, est officiellement disponible, apportant des améliorations significatives en termes de performances, de multithreading et de productivité des développeurs. Cette version introduit notamment une nouvelle fonctionnalité expérimentale --trim pour des binaires de plus petites tailles et des temps de compilation plus rapides, un multithreading amélioré avec un thread interactif dédié, la redéfinition des structures, des builds optimisés par l'outil BOLT et des capacités étendues de gestion des packages.Julia est un langage de programmation de haut niveau, performant et dynamique conçu pour le calcul scientifique et les applications de calcul numérique. Sa syntaxe est familière aux utilisateurs d'autres environnements de développement tels que MATLAB, R, Scilab, et Python. Julia est connue pour sa vitesse et ses capacités avancées en termes de calcul parallèle et de gestion de données volumineuses. Julia combine les avantages des langages compilés (tels que C et Fortran) avec la flexibilité des langages dynamiques.
Bien qu'étant un langage généraliste dans sa conception, Julia est majoritairement utilisé dans le monde scientifique. On le retrouve notamment dans des domaines tels que la science des données, la modélisation numérique, la statistique, l'apprentissage automatique ou encore la biologie et la climatologie. Les utilisateurs du langage sont en majorité des ingénieurs, des chercheurs ou des étudiants, qui l'utilisent pour faire de la recherche scientifique ou comme un passe-temps. Certains utilisateurs trouvent dans Julia un langage avec une syntaxe simple comme Python tout en ayant des performances élevées.
Julia 1.12 vient de sortir. Cette version stable apporte des améliorations du langage et des corrections de bogues, mais elle devrait également être entièrement compatible avec le code écrit dans les versions précédentes de Julia. Certaines des fonctionnalités et améliorations introduites dans cette dernière version de Julia sont présentées ci-dessous. La liste complète des modifications est disponible ici.
Nouvelle fonctionnalité --trim
Julia dispose désormais d'une nouvelle fonctionnalité expérimentale --trim. Lorsque vous compilez une image système avec ce mode, Julia supprime statiquement le code inaccessible, ce qui améliore considérablement les temps de compilation et la taille des fichiers binaires. Pour l'utiliser, vous devez également passer le drapeau --experimental lors de la création de l'image système.
Pour pouvoir l'utiliser, tout code accessible depuis les points d'entrée ne doit comporter aucun dispatch dynamique, sinon le trimming ne sera pas sûr et une erreur se produira lors de la compilation.
La manière prévue pour l'utiliser est via le package JuliaC.jl, qui fournit une CLI et une API programmatique.
Voici par exemple un package simple avec une fonction @main :
| Code julia : | Sélectionner tout |
1 2 3 4 5 6 7 8 | module AppProject function @main(ARGS) println(Core.stdout, "Hello World!") return 0 end end |
| Code julia : | Sélectionner tout |
juliac --output-exe app_test_exe --bundle build --trim=safe --experimental ./AppProject
| Code julia : | Sélectionner tout |
1 2 3 4 5 | ./build/bin/app_test_exe Hello World! ls -lh build/bin/app_test_exe -rwxr-xr-x@ 1 gabrielbaraldi staff 1.1M Oct 6 17:22 ./build/bin/app_test_exe* |
Redéfinition des constantes (structures)
Les liaisons participent désormais au mécanisme « world age » précédemment utilisé pour les méthodes. Cela permet de redéfinir correctement les constantes et les structures. Par exemple :
| Code julia : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | # Define a struct and a method on that struct: julia> struct Foo a::Int end julia> g(f::Foo) = f.a^2 g (generic function with 1 method) julia> g(Foo(2)) 4 # Redefine the struct (julia pre-1.12 would error here) julia> struct Foo a::Int b::Int end # Note that functions need to be redefined to work on the new `Foo` julia> g(Foo(1,2)) ERROR: MethodError: no method matching g(::Foo) The function `g` exists, but no method is defined for this combination of argument types. Closest candidates are: g(::@world(Foo, 39296:39300)) # <- This is syntax for accessing the binding in an older "world" @ Main REPL[2]:1 julia> g(f::Foo) = f.a^2 + f.b^2 g (generic function with 2 methods) julia> g(Foo(2,3)) 13 |
Des travaux sont également en cours dans Revise.jl pour redéfinir automatiquement les fonctions sur les liaisons remplacées. Cela devrait réduire considérablement le nombre de redémarrages de Julia nécessaires lors de l'itération sur certains morceaux de code.
Nouveaux indicateurs de suivi et macros pour inspecter ce que Julia compile
--trace-compile-timing est un nouvel indicateur de ligne de commande qui complète --trace-compile en affichant la durée (en millisecondes) de chaque méthode compilée avant la ligne precompile(...) correspondante. Cela permet de repérer plus facilement les compilations coûteuses.
De plus, deux macros permettant un suivi ad hoc sans redémarrer Julia ont été ajoutées :
- @trace_compile expr exécute expr avec --trace-compile=stderr --trace-compile-timing activé, en émettant des entrées precompile(...) chronométrées uniquement pour cet appel.
- @trace_dispatch expr exécute expr avec --trace-dispatch=stderr activé, en signalant les méthodes qui sont dispatchées dynamiquement.
Voici un exemple :
| Code julia : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | julia> @trace_compile @eval rand(2,2) * rand(2,2) #= 79.9 ms =# precompile(Tuple{typeof(Base.rand), Int64, Int64}) #= 4.4 ms =# precompile(Tuple{typeof(Base.:(*)), Array{Float64, 2}, Array{Float64, 2}}) 2×2 Matrix{Float64}: 0.302276 0.14341 0.738941 0.396414 julia> f(x) = x julia> @trace_dispatch map(f, Any[1,2,3]) precompile(Tuple{Type{Array{Int64, 1}}, UndefInitializer, Tuple{Int64}}) precompile(Tuple{typeof(Base.collect_to_with_first!), Array{Int64, 1}, Int64, Base.Generator{Array{Any, 1}, typeof(Main.f)}, Int64}) 3-element Vector{Int64}: 1 2 3 |
Nouvelles fonctionnalités multithreading
Un thread interactif par défaut
Julia démarre désormais avec un thread interactif par défaut (en plus du default thread). Cela signifie que, par défaut, Julia s'exécute avec une configuration multithreading comprenant 1 thread par défaut et 1 thread interactif.
Le pool de threads interactifs est l'endroit où s'exécutent le REPL et les autres opérations interactives. En les séparant du pool de threads par défaut (où @spawn et @threads planifient le travail lorsqu'aucun pool de threads n'est spécifié), le REPL peut effectuer des opérations telles que les requêtes d'autocomplétion en parallèle avec l'exécution du code utilisateur, ce qui se traduit par une expérience interactive plus réactive.
Comportements clés :
[LIST][*] Par défaut : Julia démarre avec -t1,1 (1 thread par défaut + 1 thread interactif)[*] -t1 explicite : si vous demandez explicitement 1 thread avec -t1, Julia vous donnera exactement cela — aucun thread interactif supplémentaire ne sera ajouté (ce qui donne -t1,0)[*] Threads multiples : -t2 ou -tauto vous donnera les threads par défaut demandés plus 1 thread...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.