Julia (langage)

Julia
Date de première version	23 août 2009
Paradigme	Dispatch multiple
Dernière version	1.11.0 (7 octobre 2024)
Typage	dynamique
Influencé par	MATLAB, R, Ruby, Perl, Python
Écrit en	Julia
Système d'exploitation	Multi-plateformes
Licence	Licence MIT
Site web	julialang.org
Extension de fichier	.jl

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 exceptionnelle et ses capacités avancées en termes de calcul parallèle et de gestion de données volumineuses.

Caractéristiques

Julia combine les avantages des langages compilés (tels que C et Fortran) avec la flexibilité des langages dynamiques. Ses caractéristiques principales comprennent :

• Performance : Julia est conçue pour offrir des performances proches de celles du code natif compilé. Elle utilise un compilateur JIT (Just-In-Time) pour optimiser les performances à l'exécution.
• Syntaxe Similaire à MATLAB : Sa syntaxe est simple et similaire à celle de MATLAB, ce qui facilite la transition pour les utilisateurs de MATLAB et d'autres langages scientifiques.
• Typage Dynamique : Le langage utilise un système de types dynamique qui permet une grande flexibilité tout en offrant la possibilité de faire des optimisations à la compilation.
• Dispatch Multiple : Julia utilise le dispatch multiple pour la résolution de fonctions en fonction des types d'arguments, permettant une surcharge de fonction puissante et flexible.
• Interopérabilité : Julia peut interagir directement avec des bibliothèques C, Fortran, et Python, facilitant l'intégration avec des outils existants.
• Parallélisme et Concurrence : Le langage prend en charge le calcul parallèle et la gestion des tâches concurrentes, permettant des performances accrues pour des calculs intensifs.

Syntaxe

Julia s'est inspiré des langages avec une syntaxe épurée tels que Python ou Ruby. Un code Julia est structuré en blocs d'expressions qui commencent par un mot clé (en) comme function ou if et finit par end. Par convention, une indentation de 4 espaces est faite pour chaque nouveau bloc, mais elle n'est pas obligatoire. Les caractères sont indiqués par le caractère croissillon (#). Julia propose de nombreux outils de syntaxe optionnels qui permettent de rendre le code plus concis.

Exemple de code en C

Exemple de code en Julia

#include <stdio.h> // Pour printf #include <stdlib.h> // Pour la fonction abs int max_valeur_absolue(int nombres[], int taille) { int max_abs = 0; for (int i = 0; i < taille; i++) { if (abs(nombres[i]) > max_abs) { max_abs = abs(nombres[i]); } } return max_abs; } int main() { int nombres[] = {3, -7, -1, 5}; int taille = sizeof(nombres) / sizeof(nombres[0]); printf("%d\n", max_valeur_absolue(nombres, taille)); // Affiche 7 return 0; }

function max_valeur_absolue(nombres) max_abs = 0 for n in nombres if abs(n) > max_abs max_abs = abs(n) end end return max_abs end # syntaxe concise max_valeur_absolue(nombres) = maximum(abs.(nombres)) println(max_valeur_absolue([3, -7, -1, 5])) # Affiche 7

Julia supporte le standard Unicode, ce qui peut être pratique pour des calculs scientifiques. Cependant pour son possible manque de lisibilité et de support par certains éditeurs, son utilisation est controversée. Par exemple, la fonction xi de Riemann peut être implémentée comme suit :

using SpecialFunctions: gamma as Γ, zeta as ζ

ξ(s) = 1/2 * s * (s-1) * π^(-s/2) * Γ(s/2) * ζ(s)

Performances

Julia a été conçu pour avoir des performances élevées tout en étant un langage de haut niveau. Pour ce faire, il compile à la volée (JIT) le code Julia en code machine optimisé à l'aide de LLVM. La conception de Julia étant faite pour exploiter au mieux cette compilation à la volée, il en résulte des performances proches de celles de langages bas niveau (comme C ou Rust) et meilleures que d'autres langages JIT (comme Pypy ou LuaJIT (en)).

Julia étant dynamique, aucune erreur ne sera lancée si le compilateur n'a pas assez d'information pour optimiser efficacement le code, notamment sur le type des variables (type instability). Ce problème d'optimisation conduit à une baisse notable en performance, ce qui a pour effet de surprendre les nouveaux utilisateurs. Une page entière de la documentation officielle du langage est dédiée à donner des techniques qui résolvent ce problème.

Polymorphisme

Le modèle de Julia s'appuie principalement sur le polymorphisme ad-hoc (aussi appelé dispatch multiple ou multi méthodes) et le polymorphisme paramétré ou de type (aussi appelé programmation générique). Pour Julia, une fonction est un simple nom, qui peut posséder plusieurs méthodes. Une méthode est une implémentation spécifique de la fonction selon le nombre et le type de chaque paramètres de celle-ci. De cette manière, il est possible de créer une implémentation complètement différente pour chaque combinaison de types possibles. Par exemple :

ma_fonction(x) = "x peut être de n'importe quel type"
ma_fonction(x::Real) = "x est un nombre réel"
ma_fonction(x::Integer) = "x est un entier de n'importe quelle taille"
ma_fonction(x::UInt8) = "x est un entier non signé de 8 bits"

ma_fonction(x, y) = "x et y sont de n'importe quel type"
ma_fonction(x::T, y::T) where {T} = "x et y sont du meme type qui est $T"

println(ma_fonction("bonjour"))  # x peut être de n'importe quel type
println(ma_fonction(π))  # x est un nombre réel
println(ma_fonction(3))  # x est un entier de n'importe quelle taille
println(ma_fonction(0x01))  # x est un entier non signé de 8 bits

println(ma_fonction(3.14, 1))  # x et y sont de n'importe quel type
println(ma_fonction(3.14, 1.0))  # x et y sont du meme type qui est Float64

Un autre exemple plus classique est celui de l'addition. Pour Julia, la simple opération 1+2 est traduite en +(1, 2), ou +est la fonction et +(::Int, ::Int) la méthode, spécifique et optimisée pour des nombres entiers. Il existe alors une méthode générique (en)+(::Number, ::Number) ou même +(::Real, ::Complex). La liste de toutes les méthodes pour une fonction donnée peut s'obtenir avec methods(nom_de_la_fonction).

Les variables n'ont généralement pas besoin d'être typées grâce à la compilation à la volée, les types étant souvent connus lors de la compilation. Si ce n'est pas le cas, Julia utilise un dispatch dynamique (en) pour garder un typage dynamique. C'est ce dispatch dynamique qui différencie le dispatch multiple de la surcharge de fonction (comme en C++ ou en Java).

Cette implémentation du polymorphisme en Julia se rapproche de celles des langages Common Lisp, Dylan ou Fortress.

Exemple de Code

Voici un exemple de programme Julia qui affiche "Hello, world !" :

println("Hello, world!")

Pour calculer la somme des carrés des nombres de 1 à 10 en Julia, vous pouvez utiliser le code suivant :

function somme_des_carres(n)
   somme = 0
   for i in 1:n
       somme += i^2
   end
   return somme
end
println(somme_des_carres(10))  # Affiche 385

Histoire

Le développement de Julia a débuté en 2009 par Jeff Bezanson, Stefan Karpinski, Viral B. Shah, et Alan Edelman. Le langage a été officiellement lancé le 14 février 2012 avec la publication d'un article de blog expliquant sa mission. Julia visait à combiner la rapidité des langages compilés avec la flexibilité des langages dynamiques. En 2018, Julia a atteint sa version 1.0, marquant une étape importante dans sa maturité et sa stabilité.

Depuis son lancement, la communauté Julia a considérablement grandi. La conférence annuelle JuliaCon attire des milliers de participants chaque année et offre une plateforme pour les développeurs et les utilisateurs de Julia pour partager leurs travaux et innovations.

Versions

• Julia 0.7 et 1.0 : Lancements en août 2018, marquant une étape importante dans la stabilisation du langage.
• Julia 1.6 : Introduit des améliorations significatives, y compris une précompilation parallèle pour accélérer le chargement des packages.
• Julia 1.9.0 : Lancée en mai 2023, elle comprend de nombreuses améliorations de performance, y compris des optimisations significatives pour le code précompilé.

JuliaCon

Depuis 2014, JuliaCon est l'événement majeur pour la communauté Julia, offrant une plateforme pour des présentations, des ateliers et des discussions sur le langage. La conférence a eu lieu dans divers lieux, y compris le MIT et l'Université du Maryland à Baltimore. JuliaCon 2020 et 2021 se sont déroulées virtuellement en raison de la pandémie, attirant un public mondial de plus de 43 000 participants uniques et plus de 300 présentations.

Compagnie Julia

La société JuliaHub, Inc., fondée en 2015 sous le nom de Julia Computing, Inc., a été créée pour soutenir le développement et la diffusion de Julia. Les fondateurs incluent plusieurs des créateurs du langage Julia, tels que Viral B. Shah et Alan Edelman.

Liens externes

• Site officiel de Julia
• Découverte de Julia
• Présentation de Julia sur Zeste de Savoir