Julia (langage de programmation) - Julia (programming language)

Julia
Julia langage de programmation Logo.svg
Paradigme Multi-paradigme : envoi multiple (paradigme primaire), procédural , fonctionnel , méta , multi - étages
Conçu par Jeff Bezanson , Alan Edelman , Stefan Karpinski , Viral B. Shah
Développeur Jeff Bezanson , Stefan Karpinski , Viral B. Shah et d'autres contributeurs
Première apparition 2012 ; il y a 9 ans ( 2012 )
Version stable
1.6.3  Modifiez ceci sur Wikidata / 23 septembre 2021 ; il y a 25 jours ( 23 septembre 2021 )
Version préliminaire
1.7.0-rc1 / 12 septembre 2021 ; Il y a 36 jours et 1.7-rc2 et 1.6.4 en cours de travail et 1.8.0-DEV avec des mises à jour quotidiennes ( 2021-09-12 )
Discipline de frappe Dynamique , fort , nominatif , paramétrique , optionnel
Langage d'implémentation Julia, C , C++ , Scheme , LLVM
Plate-forme Niveau 1 : GPU x86-64 , IA-32 , CUDA /Nvidia
Niveau 2 : ARM 64 bits , Windows 32 bits (le 64 bits correspond au niveau 1)
Niveau 3 : GPU ARM 32 bits , PowerPC , AMD. Prend
également en charge les GPU oneAPI /Intel et les TPU de Google , prend en charge les navigateurs Web (pour JavaScript et WebAssembly ) et peut fonctionner sous Android . Pour plus de détails, voir "Plateformes prises en charge" .
Système d'exploitation Linux , macOS , Windows et FreeBSD
Licence MIT (noyau), GPL v2 ; une option makefile omet les bibliothèques GPL
Extensions de nom de fichier .jl
Site Internet JuliaLang.org
Influencé par

Julia est un langage de programmation dynamique de haut niveau , hautes performances . Bien qu'il s'agisse d'un langage à usage général et qu'il puisse être utilisé pour écrire n'importe quelle application, bon nombre de ses fonctionnalités sont bien adaptées à l'analyse numérique et à la science informatique .

Les aspects distinctifs de la conception de Julia incluent un système de types avec polymorphisme paramétrique dans un langage de programmation dynamique ; avec l' envoi multiple comme paradigme de programmation de base . Julia prend en charge simultanée , (composable) parallèle et distribué de calcul (avec ou sans l' aide de MPI ou le haut-correspondant à « OpenMP les threads »), et l' appel direct de C et Fortran bibliothèques sans code de colle . Julia utilise un compilateur juste-à-temps (JIT) appelé " juste-à-temps " (JAOT) dans la communauté Julia, car Julia compile tout le code (par défaut) en code machine avant de l'exécuter.

Julia est ramassée , utilise une évaluation rapide et inclut des bibliothèques efficaces pour les calculs à virgule flottante , l'algèbre linéaire , la génération de nombres aléatoires et la correspondance d' expressions régulières . De nombreuses bibliothèques sont disponibles, y compris certaines (par exemple, pour les transformées de Fourier rapides ) qui étaient auparavant fournies avec Julia et sont maintenant séparées.

Plusieurs outils de développement prennent en charge le codage dans Julia, tels que les environnements de développement intégrés (par exemple, Visual Studio Code de Microsoft , avec des extensions disponibles ajoutant la prise en charge de Julia aux IDE, par exemple en fournissant une prise en charge du débogage et du linting ) ; avec des outils intégrés, par exemple un profileur (et un support de graphe de flamme disponible pour celui intégré), un débogueur et le package Rebugger.jl "prend en charge le débogage à exécution répétée " et plus encore.

Histoire

Le travail sur Julia a commencé en 2009, par Jeff Bezanson, Stefan Karpinski , Viral B. Shah et Alan Edelman , qui ont entrepris de créer un langage libre à la fois rapide et de haut niveau. Le 14 février 2012, l'équipe a lancé un site Web avec un article de blog expliquant la mission de la langue. Dans une interview accordée à InfoWorld en avril 2012, Karpinski a déclaré à propos du nom « Julia » : « Il n'y a aucune bonne raison, vraiment. Cela semblait juste être un joli nom. Bezanson a déclaré qu'il avait choisi le nom sur la recommandation d'un ami, puis des années plus tard, il a écrit :

Peut-être que Julia signifie « Le lisp peu commun de Jeff est automatisé » ?

Depuis le lancement de 2012, la communauté Julia s'est agrandie et, en 2020, « Julia a été téléchargée par les utilisateurs de plus de 10 000 entreprises et est utilisée dans plus de 1 500 universités » avec plus de 29 millions de téléchargements en juillet 2021, en hausse de 87 %. en un an, et l'écosystème du package Julia compte plus de 11,8 millions de lignes de code (y compris les documents et les tests). La conférence académique JuliaCon pour les utilisateurs et les développeurs de Julia a lieu chaque année depuis 2014 avec JuliaCon2020 accueillant plus de 28 900 téléspectateurs uniques, puis JuliaCon2021 battant tous les records précédents (avec plus de 300 présentations JuliaCon2021 disponibles gratuitement sur YouTube, contre 162 l'année précédente) , et 43 000 téléspectateurs uniques pendant la conférence.

La version 0.3 a été publiée en août 2014, la version 0.6 en juin 2017. Julia 0.7 et la version 1.0 ont toutes deux été publiées le 8 août 2018. Le travail sur Julia 0.7 était une « énorme entreprise » (par exemple, à cause d'un « tout nouvel optimiseur »), et quelques changements ont été apportés à la sémantique, par exemple l' interface d' itération a été simplifiée ; et la syntaxe a un peu changé (avec la syntaxe maintenant stable, et idem pour 1.x et 0.7).

La release candidate de Julia 1.0 (Julia 1.0.0-rc1) est sortie le 7 août 2018, et la version finale un jour plus tard. Julia 1.0.x est la version la plus ancienne encore prise en charge, ayant une prise en charge à long terme (LTS), sinon seule la dernière version, à chaque instant, est prise en charge. Julia 1.1 est sortie en janvier 2019 avec, par exemple, une nouvelle fonctionnalité de langage "pile d'exceptions". Les versions de correctifs étaient attendues environ une fois par mois, pour les versions 1.4.x et 1.0.x et Julia 1.0.1 jusqu'à 1.0.5 suivaient ce calendrier. Julia 1.2 est sortie en août 2019, et elle a par exemple une prise en charge intégrée des navigateurs Web (pour tester si elle s'exécute dans une machine virtuelle JavaScript ). Julia 1.3 a ajouté, par exemple, un parallélisme multithread composable et un système d'artefacts binaires pour les packages Julia.

Julia 1.4 a permis une meilleure syntaxe pour l'indexation des tableaux afin de gérer, par exemple , les tableaux basés sur 0 , avec A[begin+1]pour le deuxième élément du tableau A. Le modèle de mémoire a également été modifié. La version mineure 1.4.2 a corrigé, par exemple un problème de Zlib , doublant la vitesse de décompression.

Julia 1.5 publiée en août 2020 a ajouté la prise en charge du débogage d'enregistrement et de relecture , pour l' outil rr de Mozilla . C'est une grosse version, avec un comportement modifié dans le REPL (portée souple), identique à celui utilisé dans Jupyter , mais entièrement compatible pour le code non-REPL. La plupart des API de thread ont été marquées comme stables et, avec cette version, "les objets immuables arbitraires, qu'ils aient des champs faisant référence à des objets mutables ou non, peuvent désormais être alloués par pile", réduisant les allocations de tas, par exemple, viewsne sont plus allouées . Toutes les versions ont travaillé sur les performances, mais surtout sur les performances de Julia 1.5 ciblées sur les performances dites "time-to-first-plot", en général, la vitesse de compilation elle-même (par opposition aux performances du code généré), et ajoute des outils pour que les développeurs améliorent le chargement des packages. Julia 1.6 améliore encore davantage ces performances.

Les packages qui fonctionnent dans Julia 1.0.x doivent fonctionner dans 1.1.x ou plus récent, activés par la garantie de syntaxe de compatibilité ascendante . Une exception notable était les bibliothèques d'interface en langue étrangère comme JavaCall.jl (pour les langages JVM comme Java ou Scala ) et Rcall.jl ( langage R ) en raison de certains changements liés au thread (à une époque où toutes les fonctionnalités de thread dans Julia étaient marqué expérimental). Le problème était particulièrement compliqué pour la JVM de Java, car elle a des attentes particulières quant à la façon dont l' espace d'adressage de la pile est utilisé. Une solution de contournement appelée a JULIA_ALWAYS_COPY_STACKSété publiée pour Julia 1.3.0, tandis qu'un correctif complet pour Java est en attente et n'a pas de date d'échéance définie. De plus, les versions JVM depuis Java 11 ne présentent pas ce problème.

Julia 1.6 était la plus grande version depuis 1.0, plus rapide sur de nombreux fronts, par exemple, a introduit une précompilation parallèle et un chargement plus rapide des packages, dans certains cas "une accélération de 50x des temps de chargement pour les grands arbres d'artefacts binaires", et est susceptible de devenir la prochaine version longue- version de support à terme (LTS) de Julia. Le jalon pour 2.0 n'a actuellement pas de date d'échéance définie.

Julia 1.6.3 est sortie le 23 septembre 2021 (et 1.6 deviendra la prochaine version LTS), et Julia 1.7 et 1.8 sont les prochaines étapes, avec 1.7 reportée au 1er juin 2021 (c'est-à-dire que depuis lors, la 1.7 est en gel des fonctionnalités ) et comme de la version 1.7, le développement de Julia est de retour aux versions basées sur le temps .

Utilisations notables

Julia a attiré des utilisateurs de haut niveau, du gestionnaire d'investissement BlackRock , qui l'utilise pour l' analyse de séries chronologiques , à l'assureur britannique Aviva , qui l'utilise pour les calculs de risque . En 2015, la Federal Reserve Bank de New York a utilisé Julia pour créer des modèles de l'économie des États-Unis, notant que le langage rendait l'estimation du modèle « environ 10 fois plus rapide » que sa précédente implémentation MATLAB . Les cofondateurs de Julia ont créé Julia Computing en 2015 pour fournir des services d'assistance, de formation et de conseil payants aux clients, bien que Julia reste libre d'utiliser. Lors de la conférence JuliaCon 2017, Jeffrey Regier, Keno Fischer et d'autres ont annoncé que le projet Celeste utilisait Julia pour atteindre "des performances de pointe de 1,54  pétaFLOPS en utilisant 1,3 million de threads" sur 9300 nœuds Knights Landing (KNL) du supercalculateur Cori II (Cray XC40). (alors 6ème ordinateur le plus rapide au monde). Julia rejoint ainsi C, C++ et Fortran en tant que langages de haut niveau dans lesquels des calculs petaFLOPS ont été réalisés.

Trois des co-créateurs de Julia sont lauréats du Prix James H. Wilkinson 2019 pour les logiciels numériques (remis tous les quatre ans) "pour la création de Julia, un environnement innovant pour la création d'outils performants permettant l'analyse et solution de problèmes de science informatique." De plus, Alan Edelman, professeur de mathématiques appliquées au MIT, a été sélectionné pour recevoir le prix Sidney Fernbach 2019 de l'IEEE Computer Society "pour des percées exceptionnelles dans le calcul haute performance, l'algèbre linéaire et la science informatique et pour ses contributions au langage de programmation Julia. "

En 2019, Julia Computing a annoncé « la disponibilité du langage de programmation Julia en tant que conteneur pré-packagé sur le registre de conteneurs NVIDIA GPU Cloud (NGC) » et un article de blog sur le site de Nvidia indique « Déployez facilement Julia sur x86 et Arm [.. ] Julia propose un package pour un écosystème HPC complet couvrant l'apprentissage automatique, la science des données, divers domaines scientifiques et la visualisation."

De plus, « Julia a été sélectionnée par la Climate Modeling Alliance comme seul langage de mise en œuvre pour leur modèle climatique mondial de prochaine génération. Ce projet de plusieurs millions de dollars vise à construire un modèle climatique à l'échelle de la Terre donnant un aperçu des effets et des défis du changement climatique. "

Julia est utilisée par la NASA , par exemple pour modéliser la dynamique de séparation des engins spatiaux (15 000 fois plus rapide qu'avant avec Simulink/MATLAB) et l' INPE brésilien pour la planification de missions spatiales et la simulation de satellites . Un autre effort est de travailler sur un projet embarqué pour contrôler un satellite dans l'espace en utilisant Julia pour le contrôle d'attitude .

JuliaCon

Depuis 2014, la communauté Julia organise une conférence Julia annuelle axée sur les développeurs et les utilisateurs. La première JuliaCon a eu lieu à Chicago et a donné le coup d'envoi à l'événement annuel de la conférence. Depuis 2014, la conférence a eu lieu dans un certain nombre d'endroits, dont le MIT et l'Université du Maryland à Baltimore. L'audience de l'événement est passée de quelques dizaines de personnes à plus de 28 900 participants uniques lors de la JuliaCon 2020, qui s'est déroulée virtuellement. La JuliaCon 2021 aura lieu virtuellement entre le 28 et le 30 juillet 2021 avec les discours principaux de Jan Vitek, Xiaoye Sherry Li et Soumith Chintala.

Communauté Julia

La communauté Julia est présente sur plusieurs plateformes : Twitter, LinkedIn, Facebook, Slack, Zulip, Discord, Discourse, Stack Overflow, YouTube, etc. Depuis mai 2017, Julia Language emploie un community manager ; premier Alex Arsland qui a servi jusqu'à la fin de 2019 et actuellement Logan Kilpatrick.

Commanditaires

Le langage Julia est devenu un projet parrainé fiscalement par NumFOCUS en 2014 dans le but d'assurer la durabilité à long terme du projet. Le Dr Jeremy Kepner du MIT Lincoln Laboratory a été le sponsor fondateur du projet Julia à ses débuts. De plus, les fonds de la Gordon and Betty Moore Foundation , de la Alfred P. Sloan Foundation , d' Intel et d'agences telles que NSF , DARPA , NIH , NASA et FAA ont été essentiels au développement de Julia. Mozilla , le fabricant du navigateur Web Firefox, avec ses subventions de recherche pour le premier semestre 2019, a parrainé "un membre de l'équipe officielle Julia" pour le projet "Bringing Julia to the Browser", c'est-à-dire Firefox et d'autres navigateurs Web. Le langage Julia est également soutenu par des donateurs individuels sur GitHub.

Société d'informatique Julia

Julia Computing, Inc. a été fondée en 2015 par Viral B. Shah, Deepak Vinchhi, Alan Edelman, Jeff Bezanson, Stefan Karpinski et Keno Fischer .

En juin 2017, Julia Computing a levé 4,6  millions de dollars américains en financement de démarrage de General Catalyst et Founder Collective , le même mois, la Fondation Alfred P. Sloan a accordé « 910 000 $ pour soutenir le développement open source de Julia, dont 160 000 $ pour promouvoir la diversité dans le Julia. communauté", et en décembre 2019, la société a obtenu un  financement de 1,1 million de dollars du gouvernement américain pour "développer un outil d' apprentissage automatique des composants neuronaux pour réduire la consommation totale d'énergie des systèmes de chauffage, de ventilation et de climatisation (CVC) dans les bâtiments". En juillet 2021, Julia Computing a annoncé avoir levé une série A de 24 millions de dollars dirigée par Dorilton Ventures, qui possède également l' équipe de Formule 1 Williams Racing , qui s'est associée à Julia Computing. Le directeur commercial de Williams a déclaré : « Investir dans des entreprises qui développent une technologie cloud de pointe est un axe stratégique pour la plate-forme polyvalente de Dorilton et Julia, dotée de capacités révolutionnaires en matière de simulation et de modélisation, est extrêmement pertinent pour notre entreprise. Nous sommes impatients d'intégrer Julia L'informatique dans le sport le plus avancé au monde sur le plan technologique".

Caractéristiques linguistiques

Julia est un langage de programmation à usage général , tout en étant également conçu à l'origine pour le calcul numérique/technique. Il est également utile pour la programmation de systèmes de bas niveau , en tant que langage de spécification , et pour la programmation Web à la fois côté serveur et côté client.

Selon le site officiel, les principales caractéristiques de la langue sont :

  • Répartition multiple : offrant la possibilité de définir le comportement de la fonction à travers de nombreuses combinaisons de types d'arguments
  • Système de type dynamique : types pour la documentation, l'optimisation et l'expédition
  • Des performances proches de celles des langages à typage statique comme le C
  • Un gestionnaire de paquets intégré
  • Lisp -comme les macros et autres métaprogrammation installations
  • Appelez directement les fonctions C : pas de wrappers ni d' API spéciales
  • Capacité d'interface avec d'autres langages, par exemple Python avec PyCall, R avec RCall et Java/Scala avec JavaCall
  • De puissantes capacités de type shell pour gérer d'autres processus
  • Conçu pour l'informatique parallèle et distribuée
  • Coroutines : filetage vert léger
  • Les types définis par l'utilisateur sont aussi rapides et compacts que les éléments intégrés
  • Génération automatique de code efficace et spécialisé pour différents types d'arguments
  • Conversions et promotions élégantes et extensibles pour les types numériques et autres
  • Prise en charge efficace d' Unicode , y compris, mais sans s'y limiter, UTF-8

La répartition multiple (également appelée multiméthodes en Lisp) est une généralisation de la répartition unique  - le mécanisme polymorphe utilisé dans les langages de programmation orientés objet (OOP) courants - qui utilise l' héritage . Dans Julia, tous les types concrets sont des sous - types de types abstraits, directement ou indirectement des sous-types du Anytype, qui est le sommet de la hiérarchie des types. Les types concrets ne peuvent pas eux-mêmes être sous-typés comme ils le peuvent dans d'autres langues ; composition est utilisée à la place (voir aussi héritage vs sous-typage ).

Par défaut, l'environnement d'exécution Julia doit être pré-installé lors de l'exécution du code source fourni par l'utilisateur. Alternativement, un exécutable autonome qui n'a pas besoin de code source Julia peut être construit avec PackageCompiler.jl .

Les macros syntaxiques de Julia (utilisées pour la métaprogrammation ), comme les macros Lisp, sont plus puissantes que les macros de substitution de texte utilisées dans le préprocesseur de certains autres langages tels que C, car elles fonctionnent au niveau des arbres de syntaxe abstraite (AST). Le système macro de Julia est hygiénique , mais prend également en charge la capture délibérée lorsque cela est souhaité (comme pour les macros anaphoriques ) à l'aide de la escconstruction.

Julia s'inspire beaucoup de divers dialectes de Lisp, y compris Scheme et Common Lisp , et partage de nombreuses fonctionnalités avec Dylan , également un langage dynamique orienté distribution multiple (qui présente une syntaxe infixe de forme libre de type ALGOL plutôt qu'un Lisp- comme la syntaxe du préfixe, alors que dans Julia "tout" est une expression ), et avec Fortress , un autre langage de programmation numérique (qui comporte plusieurs envois et un système de type paramétrique sophistiqué). Bien que Common Lisp Object System (CLOS) ajoute plusieurs envois à Common Lisp, toutes les fonctions ne sont pas des fonctions génériques.

Dans Julia, Dylan et Fortress, l'extensibilité est la valeur par défaut et les fonctions intégrées du système sont toutes génériques et extensibles. Dans Dylan, la répartition multiple est aussi fondamentale que dans Julia : toutes les fonctions définies par l'utilisateur et même les opérations intégrées de base comme +sont génériques. Le système de types de Dylan, cependant, ne prend pas entièrement en charge les types paramétriques, qui sont plus typiques de la lignée des langages ML . Par défaut, CLOS n'autorise pas la répartition sur les types paramétriques de Common Lisp ; une telle sémantique de répartition étendue ne peut être ajoutée qu'en tant qu'extension via le protocole de méta-objet CLOS . De par sa conception convergente, Fortress propose également plusieurs envois sur des types paramétriques ; contrairement à Julia, cependant, Fortress est typé statiquement plutôt que dynamiquement, avec des phases de compilation et d'exécution séparées. Les caractéristiques du langage sont résumées dans le tableau suivant :

Langue Système de types Fonctions génériques Types paramétriques
Julia Dynamique Défaut Oui
Lisp commun Dynamique S'inscrire Oui (mais pas d'envoi)
Dylan Dynamique Défaut Partielle (pas d'envoi)
Forteresse Statique Défaut Oui

Un exemple de l'extensibilité de Julia, le package Unitful.jl ajoute la prise en charge des unités de mesure à la langue.

Interaction

La distribution officielle de Julia comprend une boucle de lecture-évaluation-impression (REPL) en ligne de commande interactive , avec un historique consultable, une complétion par tabulation et des modes d' aide et de shell dédiés , qui peuvent être utilisés pour expérimenter et tester le code rapidement. Le fragment suivant représente un exemple de session où les chaînes sont concaténées automatiquement par println : 

julia> p(x) = 2x^2 + 1; f(x, y) = 1 + 2p(x)y
julia> println("Hello world!", " I'm on cloud ", f(0, 4), " as Julia supports recognizable syntax!")
Hello world! I'm on cloud 9 as Julia supports recognizable syntax!

Le REPL permet à l'utilisateur d'accéder au shell du système et au mode d'aide, en appuyant sur ;ou ?après l'invite (précédant chaque commande), respectivement. Il conserve également l'historique des commandes, y compris entre les sessions. Code qui peut être testé dans la section interactive de Julia ou enregistré dans un fichier avec une .jlextension et exécuté à partir de la ligne de commande en tapant : 

 $ julia <filename>

Julia est pris en charge par Jupyter , un environnement interactif en ligne de "carnets" et Pluto.jl , un " carnet réactif " (où les carnets sont enregistrés en tant que fichiers Julia purs), un remplacement possible pour le premier type.

Utiliser avec d'autres langues

Julia est en pratique interopérable avec de nombreuses langues (par exemple, la majorité des 10 à 20 langues les plus courantes). Le ccallmot - clé de Julia est utilisé pour appeler individuellement des fonctions de bibliothèque partagée C-exportées ou Fortran, et des packages pour permettre d'appeler d'autres langages, par exemple Python, R, MATLAB, Java ou Scala. Et les paquets pour d' autres langues, par exemple Python (ou R ou Ruby), c. -à- pyjulia, d'appeler à Julia.

Julia prend en charge le dernier Unicode 13.0, avec UTF-8 utilisé pour les chaînes (par défaut) et pour le code source Julia (autorisant uniquement l'UTF-8 légal dans la dernière version), ce qui signifie également permettre en option des symboles mathématiques communs pour de nombreux opérateurs , comme ∈ pour l' inopérateur.

Julia a des packages prenant en charge les langages de balisage tels que HTML (et aussi pour HTTP ), XML , JSON et BSON , et pour les bases de données et l'utilisation du Web en général.

Système d'emballage

Julia dispose d'un gestionnaire de packages intégré et inclut un système de registre par défaut. Les packages sont le plus souvent distribués sous forme de code source hébergé sur GitHub , bien que des alternatives puissent également être utilisées. Les packages peuvent également être installés en tant que binaires, à l'aide d'artefacts. Le gestionnaire de packages de Julia est utilisé pour interroger et compiler des packages, ainsi que pour gérer des environnements. Les registres de packages fédérés sont pris en charge, ce qui permet d'ajouter localement des registres autres que l'officiel.

Mise en œuvre

Le noyau de Julia est implémenté en Julia et C , avec C++ pour la dépendance LLVM . L'analyse et la réduction du code sont implémentées dans FemtoLisp, un dialecte Scheme . Le projet d'infrastructure du compilateur LLVM est utilisé comme back-end pour la génération de code machine optimisé 64 bits ou 32 bits en fonction de la plate-forme sur laquelle Julia s'exécute. À quelques exceptions près (par exemple, PCRE ), la bibliothèque standard est implémentée dans Julia. L'aspect le plus notable de l'implémentation de Julia est sa vitesse, qui est souvent d'un facteur deux par rapport au code C entièrement optimisé (et donc souvent d'un ordre de grandeur plus rapide que Python ou R ). Le développement de Julia a commencé en 2009 et une version open source a été publiée en février 2012.

Plateformes actuelles et futures

Alors que Julia a une prise en charge macOS de niveau 1 , c'est-à-dire pour les Mac à processeur Intel, les tout nouveaux Mac à base d' Apple M1 n'ont qu'une prise en charge expérimentale, avec une prise en charge complète, pas encore une plate-forme prise en charge de niveau 1 (ni Windows sur ARM ). Cependant, Julia est censée fonctionner "correctement" sur les Mac M1 (à des performances réduites) grâce à l'utilisation (automatique) de Rosetta 2 (qui doit émuler Julia). Le travail sur la prise en charge native de M1 à pleine vitesse (c'est-à-dire sans émulation) est principalement effectué, et de nombreux programmes peuvent fonctionner si une telle version de Julia est utilisée, car tous les tests Julia sauf un réussissent (sauf pour "Trop de fichiers ouverts").

Puisque Julia utilise JIT, Julia génère directement du code machine natif, avant qu'une fonction ne soit exécutée pour la première fois (c'est-à-dire une approche différente de la compilation en bytecode , que vous distribuez par défaut, à exécuter sur une machine virtuelle (VM), comme par exemple Java/ JVM ; puis traduit à partir du bytecode lors de l'exécution, comme le faisait Dalvik sur les anciennes versions d'Android).

Julia a quatre niveaux de support. Tous les processeurs IA-32 implémentant complètement la sous- architecture i686 sont pris en charge et les processeurs 64 bits x86-64 (aka amd64 ), c'est-à-dire tous âgés de moins d'une décennie environ sont pris en charge. Les processeurs ARMv8 ( AArch64 ) sont pris en charge sur le deuxième niveau, et ARMv7 et ARMv6 (AArch32) sont pris en charge avec quelques mises en garde (niveau inférieur) pour Julia 1.0.x et avaient également des exécutables officiels pour les versions ultérieures, tandis que le support ARM 32 bits a été rétrogradé plus tard au niveau 3 (cependant, des binaires non officiels sont disponibles pour Julia 1.5.1). CUDA (c'est-à-dire les GPU Nvidia ; implémentation de PTX ) prend en charge le niveau 1, à l'aide d'un package externe. Il existe également des packages prenant en charge d'autres accélérateurs, tels que les TPU de Google et certains GPU Intel (intégrés), via oneAPI.jl , et les GPU d'AMD prennent en charge, par exemple, OpenCL ; et la prise en charge expérimentale de la pile AMD ROCm . La page de téléchargement de Julia fournit des exécutables (et des sources) pour toutes les plates-formes officiellement prises en charge.

Sur certaines plates-formes, Julia peut avoir besoin d'être compilé à partir du code source (par exemple, le Raspberry Pi d'origine ), avec des options de construction spécifiques, ce qui a été fait et des binaires pré-construits non officiels (et des instructions de construction) sont disponibles. Julia a été construite sur plusieurs plates-formes ARM. PowerPC (64 bits) prend en charge le niveau 3, ce qui signifie qu'il "peut ou non se construire". Julia est maintenant prise en charge dans Raspbian tandis que la prise en charge est meilleure pour les Pis plus récents, par exemple, ceux avec ARMv7 ou plus récent ; le support Julia est promu par la Fondation Raspberry Pi .

Il existe également une prise en charge des navigateurs Web/ JavaScript via JSExpr.jl ; et le langage alternatif des navigateurs Web, WebAssembly , a une prise en charge minimale de plusieurs projets Julia externes à venir. Julia peut compiler vers ARM ; ainsi, en théorie, les applications Android peuvent être créées avec le NDK , mais pour l'instant Julia n'a été conçue pour fonctionner sous Android qu'indirectement, c'est- à- dire avec un chroot Ubuntu sur Android.

Voir également

Remarques

Les références

Lectures complémentaires

Liens externes