# Julia (langage)

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.

## Utilisation

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.

## 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 commentaires 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 :

### 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 :
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 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.

### Programmation objet

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 :
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 :
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 (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$^,$.
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.

### Programmation fonctionnelle

Julia supporte la création de fonctions d'ordre supérieur (des fonctions qui prennent en paramètres d'autres fonctions) ainsi que de fonctions anonymes. De ce fait, des outils venant de la programmation fonctionnelle sont disponibles :
* Des fonctions d'ordre supérieur comme filter (en) ou map (en).
* Des opérateurs comme l'opérateur pipe qui permet de transformer fonction1(fonction2(x)) en x |> fonction1 |> fonction1 ou l'opérateur ∘ (\circ) pour la composition de fonctions.
* La syntaxe par liste en compréhension, très similaire à celle en Python.

### Vectorisation

Comme la plupart des langages ayant une portée scientifique, Julia fournit une implémentation très complète de tableaux à une ou plusieurs dimensions. Ces tableaux peuvent représenter des vecteurs (une dimension) ou encore des matrices (deux dimensions). Ils permettent également de vectoriser le code (c'est à dire effectuer une même opération sur tout un ensemble d'éléments) à l'aide de la dot syntax (littéralement syntaxe à point). Par exemple:
Cependant et contrairement au langages scientifiques les plus connus comme Python, R ou MATLAB, cette vectorisation n'améliore pas les performances puisque toutes les fonctions et même les tableaux eux mêmes sont écrits en Julia. En Julia, écrire des boucles à la main pour effectuer les opérations une à une est déjà très performant. Par exemple, la fonction suivante ne sera pas plus performante que f.(X):
La vectorisation permet donc simplement de rendre le code plus concis et lisible pour les utilisateurs.

### Réflexivité et métaprogrammation

Reprenant le modèle de Lisp, Julia possède une réflexivité importante. En Julia, il est possible à tout moment de représenter une expression de code en arbre de la syntaxe abstraite (AST pour Abstract syntax tree). Ces expressions de code peuvent facilement être créées ou modifiées dynamiquement. Par exemple pour créer dynamiquement des fonctions pour un type créé par l'utilisateur :
Julia possède également le concept de macro-définition. C'est à dire qu'il facilite l'utilisation de fonctions qui prennent en entrée des expressions et retournent une expression, qui est directement évaluée. Les macros s'écrivent comme des fonctions en remplaçant le mot clé function par macro et s'utilisent en préfixant le nom de la macro par un arobase (@). Par exemple :

## Exemple de Code

Affiche "Hello, world!" :
Pour calculer la somme des carrés des nombres de 1 à 10 :
Une version très concise serait sum((1:10).^2) ou encore sum(i^2 for i in 1:10), qui renvoient le même résultat.
Pour représenter graphiquement un ensemble de Julia en Julia :

## 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.