Julia est un langage de programmation open-source, multi-plateformes, performant et de haut niveau, dédié au calcul technique.

Julia est propulsé par un compilateur JIT La compilation “Just-In-Time” (au dernier moment) se produit à l’exécution du programme, plutôt que d’être réalisée au préalable. Ceci permet d’offrir la performance d’un code compilé sans sacrifier la flexibilité des langages interprétés. Après une phase d’inférence de types, le compilateur génère une représentation intermédiaire LLVM qui est à son tour compilée sous forme de code natif. basé sur LLVM Low-Level Virtual Machine (LLVM) est une infrastructure de compilation permettant de produire, optimiser et compiler du code sous forme de représentation intermédiaire ou de code binaire natif., ce qui lui permet d’atteindre les mêmes performances que des langages comme C et FORTRAN tout en évitant d’avoir à écrire du code bas-niveau. Comme le code est compilé à la volée, il est possible de l’évaluer dans une console ou REPL Read-Eval-Print-Loop : Boucle de Lecture-Évaluation-Affichage, ce qui fait d’ailleurs partie des modes de développement recommandés.

Julia est un langage à typage dynamique, propose des fonctionnalités de multiple dispatchÉtant donné que le type des arguments passés aux fonctions est déterminé lors de l’exécution, le compilateur peut choisir une implémentation optimale adaptée aux arguments fournis ainsi qu’à l’architecture matérielle ciblée., et a été conçu pour le parallélisme et le calcul distribué.

Julia intègre un gestionnaire de paquets.

Julia intègre aussi une bibliothèque mathématique fournie, comprenant des fonctions spéciales (p.ex. Gamma). Le langage supporte aussi les nombres complexes par défaut.

Julia permet de faire de la méta-programmation et de la génération de code grâce à des macros inspirées des langages LISP.

Julia est né en 2012.

Pour que Julia démarre plus rapidement, de nombreuses fonctionnalités essentielles sont disponibles dans les bibliothèques standard, distribuées et installées avec Julia. Pour appeler les fonctions de ces bibliothèques, utilisez la commande : using PackageName. Nous listons ici quelques bibliothèques standard et fonctions fréquemment utilisées.

Les paquets doivent être enregistrés avant de pouvoir être désignés par leur nom en utilisant le gestionnaire de paquets. La plupart des commandes ci-dessous acceptent aussi une URL de dépôt git pour identifier un paquet non-enregistré. Le gestionnaire de paquets de Julia 1.0 peut être utilisé de deux manières : en tapant using Pkg puis en utilisant les fonctions du module Pkg, ou bien en entrant dans le mode REPL dédié à la gestion des paquets à l’aide de la touche ] (Pour revenir au REPL Julia standard, tapez [BackSpace] dans une ligne vide). NB: les nouvelles fonctionnalités de Pkg arrivent souvent dans le mode REPL interactif, avant d’intégrer l’API du module Pkg.

Utiliser les fonctions de Pkg dans un code Julia

Dans le REPL interactif en mode pkg

Beware of multi-byte Unicode encodings in UTF-8:
10 == lastindex("Ångström") != length("Ångström") == 8

Strings are immutable.

Julia does not automatically check for numerical overflow. Use package SaferIntegers for ints with overflow checking.

Many random number functions require using Random.

For most linear algebra tools, use using LinearAlgebra.

Julia has built-in support for matrix decompositions.

Julia tries to infer whether matrices are of a special type (symmetric, hermitian, etc.), but sometimes fails. To aid Julia in dispatching the optimal algorithms, special matrices can be declared to have a structure with functions like Symmetric , Hermitian , UpperTriangular, LowerTriangular, Diagonal , and more.

Tous les arguments de fonctions sont passés par référence.

Par convention, les fonctions dont le nom se termine par ! changent (mutent) au moins l’un de leurs arguments (en général le premier). Par exemple : sort!(arr).

Les arguments positionnels sont séparés par une virgule. Ils sont obligatoires, sauf si une valeur par défaut est fournie dans la signature de la fonction, au moyen du signe =. A partir du premier argument optionnel, tous les arguments positionnels suivants doivent aussi être optionnels.

Les arguments par mot-clé sont identifiés par leur nom, et listés dans la signature de fonction après un point-virgule :

function func(req1, req2, opt1=dflt1; key1=dflt1, key2=dflt2)
    # do stuff
end

Le point-virgule n’est pas nécessaire pour identifier les arguments par mot-clé lors de l’appel à la fonction :

func(val_req1, val_req2, key1=val_key1)
# opt1 et key2: valeur par défaut

Le mot-clé return est optionnel. S’il n’est pas présent, la valeur de la dernière expression évaluée est renvoyée.

On peut renvoyer plusieurs valeurs en utilisant un Tuple: return (val1, val2)

Les arguments passés à Julia en ligne de commande (julia script.jl arg1 arg2...) peuvent être récupérés dans la constante globale ARGS:

for arg in ARGS
    println(arg)
end

Les fonctions anonymes sont souvent utiles en conjonction avec des fonctions d’ordre supérieur ou des listes en compréhension: x -> x^2.

Les fonctions peuvent accepter un nombre variable d’arguments:

function func(a...)
    println(a)
end

func(1, 2, [3:5]) # tuple: (1, 2, UnitRange{Int64}[3:5])

Les déclarations de fonctions peuvent être imbriquées:

function outerfunction()
    # do some outer stuff
    function innerfunction()
        # do inner stuff
        # can access prior outer definitions
    end
    # do more outer stuff
end

Les fonctions peuvent spécifier un type pour leur arguments ainsi que leur résultat :

# accepte n'importe quel argument sous-typant un nombre,
# et le renvoie sous forme de chaîne de caractères
function stringifynumber(num::T)::String where T <: Number
    return "$num"
end

Les fonctions peuvent être “vectorisées”, (appliquées élément-par-élément) en utilisant la syntaxe “.” :

julia> using Statistics
julia> A = rand(3, 4);

# La soustraction est "broadcastée" ici
julia> B = A .- mean(A, dims=1)
3×4 Array{Float64,2}:
  0.0387438     0.112224  -0.0541478   0.455245
  0.000773337   0.250006   0.0140011  -0.289532
 -0.0395171    -0.36223    0.0401467  -0.165713
julia> mean(B, dims=1)
1×4 Array{Float64,2}:
 -7.40149e-17  7.40149e-17  1.85037e-17  3.70074e-17

Julia génère des versions spécialisées Le dispatch multiple choisit la méthode la plus adaptée aux types d’arguments fournis (dynamiquement, i.e sur la base des types de valeurs constatés lors de l’exécution). A partir du code de la méthode choisie, la spécialisation permet ensuite de générer un code binaire natif optimal pour les types d’arguments fournis. Tout ceci est différent de la surcharge de fonctions, qui s’appuie exclusivement sur les types connus à la compilation. de chaque fonction, pour chaque type de données passées en argument. Quand une fonction est appelée à nouveau pour les mêmes types d’arguments, une version précédemment spécialisée peut être ré-utilisées ce qui évite d’avoir à repasser par une phase de compilation.

Il est possible que l’ensemble des méthodes définies conduisent à des ambiguïtés potentielles, mais réaliser effectivement un appel à une méthode ambiguë provoque une erreur à l’exécution.

Des dépassements de pile (Stack Overflows) peuvent arriver lorsque des appels de fonctions récursives s’imbriquent sur trop de niveaux. Des techniques de trampoline peuvent être mises en place pour émuler l’optimisation de la récursivité terminale (Tail Call Optimization), que Julia ne réalise pas (encore ?) par défaut. Les situations de récursivité terminale peuvent aussi être récrites sous forme de boucle.

Dictionaries are mutable; when symbols are used as keys, the keys are immutable.

Checking whether an element is contained in a set is done in O(1).

Julia n’a pas de classes, et par conséquent pas de méthodes de classe. Les types Julia sont similaires à des classes sans méthode.

Les types abstraits peuvent être sous-typés, mais pas instanciés. Les types concrets ne peuvent être sous-typés.

Par défaut, les structs sont immutables. Les types immutables améliorent la performance et sont thread-safe puisqu’on ne peut accéder à leurs instances qu’en lecture.

Les types Union permettent de représenter un ensemble de types.

Lorsqu’une définition de type inclut un constructeur interne, les constructeurs externes par défaut ne sont plus disponibles. Ils doivent être définis manuellement si nécessaire. Un constructeur interne est utile pour garantir des invariants sur les champs d’un type. (Ces invariants pourront quand même être enfreints par une modification directe des champs, à moins que le type soit immutable). Le mot-clé new utilisé dans un constructeur interne permet de créer un objet du type adéquat.

Les paramètres de type sont invariants, c’est à dire que Point{Float64} <: Point{Real} est faux, alors même que Float64 <: Real. En revanche, les Tuple sont covariants : Tuple{Float64} <: Tuple{Real}.

La représentation interne d’un morceau de code après inférence de types peut être consultée grâce à code_typed(). Ceci est en particulier utile pour identifier les endroits où des expressions de type Any sont manipulées plutôt que du code natif de type spécifique.

Les modules sont des espaces de noms séparés qui groupent des fonctionnalités similaires.

Une fonction foo rendue visible par using Foo ne peut être étendue par une nouvelle méthode qu’explicitement : function Foo.bar(...).

Avec import Foo.bar, l’ajout de méthode peut être non qualifié : function bar(...) suffit.

Julia is homoiconic: programs are represented as data structures of the language itself. In fact, everything is an expression Expr.

Symbols are interned strings Only one copy of each distinct (immutable) string value is stored. prefixed with a colon. Symbols are more efficient and they are typically used as identifiers, keys (in dictionaries), or columns in data frames. Symbols cannot be concatenated.

Quoting :( ... ) or quote ... end creates an expression, just like Meta.parse(str) This form is probably most familiar to people with knowledge of dynamic SQL. The Meta.parse function is similar to Oracle”s and PostgreSQL”s EXECUTE IMMEDIATE statement or SQL Server’s sp_executesql() procedure. , and Expr(:call, ...).

x = 1
line = "1 + $x"         # some code
expr = Meta.parse(line) # make an Expr object
typeof(expr) == Expr    # true
dump(expr)              # generate abstract syntax tree
eval(expr) == 2         # evaluate Expr object: true

Macros allow generated code (i.e. expressions) to be included in a program.

Rules for creating hygienic macros:

• Declare variables inside macro with local .
• Do not call eval inside macro.
• Escape interpolated expressions to avoid expansion: $(esc(expr))

Parallel computing tools are available in the Distributed standard library.

Workers are also known as concurrent/parallel processes.

Modules with parallel processing capabilities are best split into a functions file that contains all the functions and variables needed by all workers, and a driver file that handles the processing of data. The driver file obviously has to import the functions file.

A non-trivial (word count) example of a reducer function is provided by Adam DeConinck.

For dplyr-like tools, see DataFramesMeta.jl.

Many core packages are managed by communities with names of the form Julia[Topic].

The main convention in Julia is to avoid underscores unless they are required for legibility.

Variable names are in lower (or snake) case: somevariable.

Constants are in upper case: SOMECONSTANT.

Functions are in lower (or snake) case: somefunction.

Macros are in lower (or snake) case: @somemacro.

Type names are in initial-capital camel case: SomeType.

Julia files have the jl extension.

For more information on Julia code style visit the manual: style guide .

• Avoid global variables.
• Write type-stable code.
• Use immutable types where possible.
• Use sizehint! for large arrays.
• Free up memory for large arrays with arr = nothing.
• Access arrays along columns, because multi-dimensional arrays are stored in column-major order.
• Pre-allocate resultant data structures.
• Disable the garbage collector in real-time applications: disable_gc().
• Avoid the splat (...) operator for keyword arguments.
• Use mutating APIs (i.e. functions with ! to avoid copying data structures.
• Use array (element-wise) operations instead of list comprehensions.
• Avoid try-catch in (computation-intensive) loops.
• Avoid Any in collections.
• Avoid abstract types in collections.
• Avoid string interpolation in I/O.
• Vectorizing does not improve speed (unlike R, MATLAB or Python).
• Avoid eval at run-time.

• Juno (editor)
• JuliaBox (online IJulia notebook)
• Jupyter (online IJulia notebook)
• Emacs Julia mode (editor)
• vim Julia mode (editor)
• VS Code extension (editor)

• Official documentation .
• Learning Julia page.
• Month of Julia
• Community standards .
• Julia: A fresh approach to numerical computing (pdf)
• Julia: A Fast Dynamic Language for Technical Computing (pdf)

• The 5th annual JuliaCon 2018
• The 4th annual JuliaCon 2017 (Berkeley)
• The 3rd annual JuliaCon 2016
• Getting Started with Julia by Leah Hanson
• Intro to Julia by Huda Nassar
• Introduction to Julia for Pythonistas by John Pearson