Julia (langage)

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

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.

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, les statistique, l'apprentissage automatique^[3] ou encore la biologie^[4] et la climatologie^[5]. Les utilisateurs du langage sont en majorité des ingénieurs, des chercheurs ou des étudiants^[6], 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^[5].

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.

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^[7], 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.

#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^[8], 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^[9],[10]. 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)

Julia a été conçu pour avoir des performances élevées tout en étant un langage de haut niveau^[11]. 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))^[12].

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^[13]). Ce problème d'optimisation conduit à une baisse notable en performance, ce qui a pour effet de surprendre les nouveaux utilisateurs^[14],[15]. Une page entière de la documentation officielle du langage est dédiée à donner des techniques qui résolvent ce problème^[16].

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)^[17], 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 inférés 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.

En Julia, tout est objet. Cependant, Julia ne possède pas de classe comme la vision classique de la programmation orientée objet. À la place, la création de nouveaux objets avec le mot clé (en)struct et de nouveaux objets abstraits avec abstract type combiné au dispatch multiple suffit. Par exemple :

abstract type ObjetSpatial end

function collision(x::ObjetSpatial, y::ObjetSpatial)
    if taille(x) > 100 && taille(y) > 100
        return "Explosion !"
    else
        return collision_avec(x, y)
    end
end

struct Asteroide <: ObjetSpatial
    rayon::Float64
end
taille(a::Asteroide) = 2 * a.rayon

struct Vaisseau <: ObjetSpatial
    taille::Float64
end
taille(v::Vaisseau) = v.taille

collision_avec(a::Asteroide, v::Vaisseau) = "a/v"
collision_avec(v::Vaisseau, a::Asteroide) = "v/a"
collision_avec(a::Asteroide, a2::Asteroide) = "a/a"
collision_avec(v::Vaisseau, v2::Vaisseau) = "v/v"

println(collision(Asteroide(101), Vaisseau(300)))  # "Explosion !"
println(collision(Asteroide(101), Vaisseau(50)))   # "a/v"
println(collision(Asteroide(10), Asteroide(10)))   # "a/a"

Julia permet également de rendre le concept de méthode d'extension (en) très naturel. Par exemple, pour rajouter un nouvel objet Planete à l'exemple précédent :

struct Planete <: ObjetSpatial
    rayon::Float64
end
taille(p::Planete) = 2 * p.rayon

collision_avec(p::Planete, a::Asteroide) = "p/a"
collision_avec(a::Asteroide, p::Planete) = "a/p"
collision_avec(p::Planete, v::Vaisseau) = "p/v"
collision_avec(v::Vaisseau, p::Planete) = "v/p"

println(collision(Planete(1_000), Vaisseau(30)))  # "p/v"

Avec le concept de classe, il aurait fallu écrire la méthode collision_avec(a::Asteroide, p::Planete) à l'intérieur de la classe Asteroide. En Julia, il suffit simplement d'écrire des nouvelles méthodes.

Cette programmation objet particulière se basant sur le dispatch multiple est similaire à celle du langage Common Lisp (Common Lisp Object System). Cependant, Julia ne possède pas de concept d'héritage des objets concrets. En général, la composition combinée à la programmation générique ne nécessite pas un besoin d'héritage. La documentation officielle précise^[18] (traduit de l'anglais) :

Il s’avère que pouvoir hériter du comportement est beaucoup plus important que pouvoir hériter de la structure, et hériter des deux entraîne des difficultés importantes dans les langages orientés objet traditionnels.

Pour rendre le code plus robuste, des patrons de conception spécifiques à la conception de Julia qui ne demandent pas l'utilisation de classes sont couramment utilisés et documentés^[19],[20].

Reprenant les concepts de la programmation fonctionnelle, les objets sont immuables par défaut. Pour rendre un objet mutable, il faut le préciser avec le mot-clé mutable struct à la place de struct.

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

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.

• 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é.

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.

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.

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

• Portail de la programmation informatique
• Portail des probabilités et de la statistique
• Portail des logiciels libres