Sortie du langage de programmation Julia 1.8

La version du langage de programmation Julia 1.8 est disponible, combinant des qualités telles que des performances élevées, la prise en charge du typage dynamique et des outils intégrés pour la programmation parallèle. La syntaxe de Julia est proche de MATLAB, empruntant certains éléments à Ruby et Lisp. La méthode de manipulation des chaînes rappelle celle de Perl. Le code du projet est distribué sous licence MIT.

Principales caractéristiques du langage :

• Haute performance : l'un des objectifs clés du projet est d'atteindre des performances proches des programmes C. Le compilateur Julia est basé sur le projet LLVM et génère un code machine natif efficace pour de nombreuses plates-formes cibles.
• Prise en charge de divers paradigmes de programmation, y compris des éléments de programmation orientée objet et fonctionnelle. La bibliothèque standard fournit des fonctions pour les E/S asynchrones, la gestion des processus, la journalisation, le profilage et la gestion des packages, entre autres ;
• Typage dynamique : Le langage ne nécessite pas de définition explicite de types pour les variables, par analogie avec les langages de programmation de scripts. Prend en charge le mode interactif ;
• Possibilité facultative de spécifier explicitement les types ;
• Syntaxe excellente pour les calculs numériques, les calculs scientifiques, les systèmes d'apprentissage automatique et la visualisation de données. Prise en charge de nombreux types de données numériques et outils de parallélisation des calculs.
• Possibilité d'appeler directement des fonctions à partir de bibliothèques C sans couches supplémentaires.

Changements majeurs dans Julia 1.8 :

• Nouvelles fonctionnalités linguistiques
  • Les champs d'une structure mutable peuvent désormais être annotés en tant que constantes pour empêcher leur modification et permettre l'optimisation.
  • Des annotations de type peuvent être ajoutées aux variables globales.
  • Des tableaux vides à n dimensions peuvent être créés en utilisant plusieurs points-virgules entre crochets, par exemple "[;;;]" crée un tableau 0x0x0.
  • Les blocs Try peuvent désormais éventuellement avoir un bloc else, qui est exécuté immédiatement après le corps principal si aucune erreur n'a été générée.
  • @inline et @noinline peuvent être placés dans le corps d'une fonction, vous permettant d'annoter une fonction anonyme.
  • @inline et @noinline peuvent désormais être appliqués à une fonction dans un site d'appel ou un bloc pour forcer l'inclusion (ou la non-inclusion) des appels de fonction correspondants.
  • ∀, ∃ et ∄ sont autorisés comme caractères d'identification.
  • Ajout de la prise en charge de la spécification Unicode 14.0.0.
  • La méthode Module(:name, false, false) peut être utilisée pour créer un module qui ne contient pas de noms, n'importe pas de base ou de noyau et ne contient pas de référence à lui-même.
• Changements de langue
  • Les objets Task nouvellement créés (@spawn, @async, etc.) ont désormais world_age pour les méthodes de la tâche parent lors de leur création, permettant une exécution optimisée. L'option d'activation précédente est disponible à l'aide de la méthode Base.invokelatest.
  • Les directives de formatage bidirectionnel asymétrique Unicode sont désormais interdites dans les chaînes et les commentaires pour éviter les injections.
  • Base.ifelse est désormais défini comme une fonction générique plutôt que comme une fonction intégrée, permettant aux packages d'étendre sa définition.
  • Chaque affectation à une variable globale passe désormais d'abord par un appel à convert(Any, x) ou convert(T, x) si la variable globale a été déclarée comme étant de type T. Avant d'utiliser des variables globales, assurez-vous que l'invariant convert(Any , x) === x est toujours vrai, sinon cela peut conduire à un comportement inattendu.
  • Les fonctions intégrées sont désormais similaires aux fonctions génériques et peuvent être énumérées par programme à l'aide de méthodes.
• Améliorations du compilateur/d'exécution
  • Temps de démarrage réduit d'environ 25 %.
  • Le compilateur basé sur LLVM a été séparé de la bibliothèque d'exécution dans une nouvelle bibliothèque, libjulia-codegen. Il est chargé par défaut, il ne devrait donc y avoir aucun changement lors d'une utilisation normale. Dans les déploiements qui ne nécessitent pas de compilateur (par exemple, les images système dans lesquelles tout le code nécessaire est précompilé), cette bibliothèque (et sa dépendance LLVM) peut simplement être omise.
  • L'inférence de type conditionnelle est désormais possible en passant un argument à une méthode. Par exemple, pour Base.ifelse(isa(x, Int), x, 0) renvoie ::Int même si le type de x est inconnu.
  • SROA (Scalar Replacement of Aggregates) a été amélioré : élimine les appels getfield avec des champs globaux persistants, élimine les structures mutables avec des champs non initialisés, améliore les performances et la gestion des appels getfield imbriqués.
  • L'inférence de type suit divers effets : effets secondaires et non-abandon. La propagation constante est prise en compte, ce qui améliore considérablement les performances au moment de la compilation. Dans certains cas, par exemple, les appels à des fonctions qui ne peuvent pas être intégrées mais qui n'affectent pas le résultat seront ignorés au moment de l'exécution. Les règles relatives aux effets peuvent être écrasées manuellement à l'aide de la macro Base.@assume_effects.
  • La précompilation (avec des directives de précompilation explicites ou des charges de travail spécifiées) enregistre désormais davantage de code défini par type, ce qui entraîne une première exécution plus rapide. Toutes les nouvelles combinaisons méthode/type nécessaires à votre package, quel que soit l'endroit où ces méthodes ont été définies, peuvent désormais être mises en cache dans le fichier de précompilation si elles sont appelées par une méthode appartenant à votre package.
• Modifications des paramètres de la ligne de commande
  • Le comportement par défaut pour surveiller les déclarations @inbounds est désormais l'option auto dans "--check-bounds=yes|no|auto".
  • Nouvelle option "--strip-metadata" pour supprimer les docstrings, les informations d'emplacement source et les noms de variables locales lors de la création d'une image système.
  • Nouvelle option "--strip-ir" pour permettre au compilateur de supprimer la représentation intermédiaire du code source lors de la construction de l'image système. L'image résultante ne fonctionnera que si "--compile=all" est utilisé ou si tout le code requis est pré-compilé.
  • Si le caractère "-" est spécifié à la place du nom du fichier, alors le code exécutable est lu à partir du flux d'entrée standard.
• Modifications de la prise en charge du multithreading
  • Threads.@threads utilise par défaut la nouvelle option de planification :dynamic, qui diffère du mode précédent en ce sens que les itérations seront planifiées dynamiquement sur les threads de travail disponibles plutôt que d'être affectées à chaque thread. Ce mode permet une meilleure répartition des boucles imbriquées avec @spawn et @threads.
• Nouvelles fonctions de la bibliothèque
  • eachsplit(str) pour exécuter split(str) plusieurs fois.
  • allequal(itr) pour tester si tous les éléments d'un itérateur sont égaux.
  • hardlink(src, dst) peut être utilisé pour créer des liens physiques.
  • setcpuaffinity(cmd, cpus) pour définir l'affinité du cœur du processeur avec les processus lancés.
  • diskstat(path=pwd()) pour obtenir les statistiques du disque.
  • Nouvelle macro @showtime pour afficher à la fois la ligne en cours d'évaluation et le rapport @time.
  • LazyString et la macro lazy"str" ​​​​​​ont été ajoutés pour prendre en charge la construction paresseuse de messages d'erreur dans les chemins d'erreur.
  • Correction d'un problème de concurrence dans Dict et d'autres objets dérivés tels que les clés(::Dict), les valeurs(::Dict) et Set. Les méthodes d'itération peuvent désormais être appelées sur un dictionnaire ou un ensemble, tant qu'il n'y a aucun appel modifiant le dictionnaire ou l'ensemble.
  • @time et @timev disposent désormais d'une description facultative, permettant d'annoter la source des rapports de temps, par exemple. @time "Évaluer foo" foo().
  • range prend soit stop, soit length comme seul argument mot-clé.
  • précision et setprecision acceptent désormais base comme mot-clé
  • Les objets socket TCP fournissent désormais une méthode closewrite et prennent en charge l'utilisation du mode semi-ouvert.
  • extrema accepte désormais un argument d'initialisation.
  • Iterators.countfrom accepte désormais tout type qui définit une méthode +.
  • @time alloue désormais le % de temps passé à recompiler les méthodes avec des types modifiés.
• Modifications de la bibliothèque standard
  • Clés avec valeur Nothing sont désormais supprimées de l'environnement dans addenv.
  • Iterators.reverse (et donc dernier) prend en charge chaque ligne.
  • La fonction de longueur pour les plages de certains types ne vérifie plus le dépassement d'entier. Une nouvelle fonction, check_length, est disponible ; elle contient une logique de contrôle de transfert de bits. Si nécessaire, utilisez SaferIntegers.jl pour construire le type de plage.
  • L'itérateur Iterators.Reverse implémente l'inversion de chaque index si possible.
• Directeur chargé d'emballage
  • Nouveaux indicateurs ⌃ et ⌅ à côté des packages au statut « pkg> » pour lesquels de nouvelles versions sont disponibles. ⌅ indique que les nouvelles versions ne peuvent pas être installées.
  • Nouvel argument outdated::Bool pour Pkg.status (--outdated ou -o en mode REPL) pour afficher des informations sur les packages des versions précédentes.
  • Nouvel argument compat::Bool pour Pkg.status (--compat ou -c en mode REPL) pour afficher toutes les entrées [compat] dans Project.toml.
  • Nouveau mode "pkg>compat" (et Pkg.compat) pour définir les entrées de compatibilité du projet. Fournit un éditeur interactif via "pkg>compat" ou un contrôle direct des enregistrements via "pkg>Foo 0.4,0.5", qui peut charger les enregistrements actuels via la complétion par tabulation. C'est-à-dire "pkg> compat Fo " est automatiquement mis à jour vers " pkg>Foo 0.4,0.5 " pour permettre la modification d'une entrée existante.
  • Pkg tente désormais de télécharger des packages à partir d'un serveur de packages uniquement si le serveur surveille le registre contenant le package.
  • Pkg.instantiate émettra désormais un avertissement lorsque Project.toml n'est pas synchronisé avec Manifest.toml. Il le fait sur la base d'un hachage des dépôts et des enregistrements compat du projet (les autres champs sont ignorés) dans le manifeste lors de sa résolution, de sorte que toute modification apportée aux dépôts ou aux enregistrements compat de Project.toml puisse être détectée sans nouvelle résolution.
  • Si "pkg>add" ne trouve pas de package portant le nom donné, il suggérera désormais des packages portant des noms similaires qui peuvent être ajoutés.
  • La version de Julia stockée dans le manifeste n'inclut plus le numéro de build, ce qui signifie que master sera désormais écrit sous la forme 1.9.0-DEV.
  • L'abandon du test "pkg>" sera désormais détecté de manière plus cohérente et sera correctement renvoyé au REPL.
• Utilitaires interactifs
  • Nouvelle macro @time_imports pour signaler le temps passé à importer des packages et leurs dépendances, mettant en évidence le temps de compilation et de recompilation en pourcentage des importations.
• Algèbre linéaire
  • Le sous-module BLAS prend désormais en charge les fonctions BLAS spr! de niveau 2.
  • La bibliothèque standard LinearAlgebra.jl est désormais complètement indépendante de SparseArrays.jl, tant du point de vue du code source que des tests unitaires. Par conséquent, les tableaux clairsemés ne sont plus renvoyés (implicitement) par les méthodes de LinearAlgebra appliquées aux objets Base ou LinearAlgebra. En particulier, cela conduit aux changements de rupture suivants :
    • Les concaténations utilisant des matrices « clairsemées » spéciales (par exemple diagonales) renvoient désormais des matrices denses ; En conséquence, les champs D1 et D2 des objets SVD créés par les appels getproperty sont désormais des matrices denses.
    • La méthode similar(::SpecialSparseMatrix, ::Type, ::Dims) renvoie une matrice nulle dense. En conséquence, les produits de matrices à deux, trois et tridiagonales symétriques conduisent à la génération d’une matrice dense. De plus, la construction de matrices similaires avec trois arguments à partir de matrices spéciales « clairsemées » à partir de matrices (non statiques) échoue désormais en raison de « zéro(::Type{Matrix{T}}) ».
• printf
  • %s et %c utilisent désormais l'argument textwidth pour formater la largeur.
• Profil
  • Le profilage de la charge du processeur enregistre désormais les métadonnées, notamment les threads et les tâches. Profile.print() a un nouvel argument groupby qui vous permet de regrouper les threads, les tâches ou les sous-threads/tâches, les tâches/threads et les arguments de threads et de tâches pour fournir un filtrage. De plus, le pourcentage d'utilisation est désormais signalé globalement ou par thread, selon que le thread est inactif ou non dans chaque échantillon. Profile.fetch() inclut les nouvelles métadonnées par défaut. Pour une compatibilité ascendante avec les consommateurs externes de données de profilage, elles peuvent être exclues en passant include_meta=false.
  • Le nouveau module Profile.Allocs vous permet de profiler les allocations de mémoire. Une trace de pile du type et de la taille de chaque allocation de mémoire est enregistrée, et l'argument sample_rate permet d'ignorer un nombre configurable d'allocations, réduisant ainsi la surcharge de performances.
  • Le profilage du processeur à durée fixe peut désormais être exécuté par l'utilisateur pendant l'exécution des tâches sans charger au préalable le profil, et le rapport sera affiché pendant l'exécution. Sous MacOS et FreeBSD, appuyez sur ctrl-t ou appelez SIGINFO. Pour les autres plateformes, activez SIGUSR1, c'est-à-dire % tuer -USR1 $julia_pid. Ceci n'est pas disponible sous Windows.
• REPL
  • RadioMenu prend désormais en charge des raccourcis clavier supplémentaires pour la sélection directe d'options.
  • La séquence "?(x, y" suivie d'un appui sur TAB affiche toutes les méthodes pouvant être appelées avec les arguments x, y, .... (Un espace au début vous empêche d'entrer en mode aide.) "MonModule.?(x, y " restreint la recherche à "MonModule". Appuyer sur TAB nécessite qu'au moins un argument soit d'un type plus spécifique que Any. Ou utilisez SHIFT-TAB au lieu de TAB pour autoriser toutes les méthodes compatibles.
  • La nouvelle variable globale err vous permet d'obtenir la dernière exception, similaire au comportement de ans avec la dernière réponse. La saisie de err réimprime les informations sur l’exception.
• Tableaux clairsemés
  • Déplacement du code SparseArrays du référentiel Julia vers le référentiel externe SparseArrays.jl.
  • Les nouvelles fonctions de concaténation sparse_hcat, sparse_vcat et sparse_hvcat renvoient un type SparseMatrixCSC quels que soient les types des arguments d'entrée. Cela est devenu nécessaire pour unifier le mécanisme de collage des matrices après avoir séparé le code LinearAlgebra.jl et SparseArrays.jl.
• Journal
  • Les niveaux de journalisation standard BelowMinLevel, Debug, Info, Warn, Error et AboveMaxLevel sont désormais exportés depuis la bibliothèque de journalisation standard.
• Unicode
  • Ajout de la fonction isequal_normalized pour vérifier l'équivalence Unicode sans construire explicitement de chaînes normalisées.
  • La fonction Unicode.normalize accepte désormais le mot-clé charttransform, qui peut être utilisé pour fournir des mappages de caractères personnalisés, et la fonction Unicode.julia_chartransform est également fournie pour reproduire le mappage utilisé lorsque l'analyseur Julia normalise les identifiants.
• Teste
  • '@test_throws "some message" triggers_error()' peut désormais être utilisé pour tester si le texte d'erreur affiché contient une erreur "some message", quel que soit le type d'exception spécifique. Les expressions régulières, les listes de chaînes et les fonctions de correspondance sont également prises en charge.
  • @testset foo() peut désormais être utilisé pour créer un ensemble de tests à partir d'une fonction donnée. Le nom du scénario de test est le nom de la fonction appelée. La fonction appelée peut contenir @test et d'autres définitions @testset, y compris pour les appels à d'autres fonctions, tout en enregistrant tous les résultats de tests intermédiaires.
  • TestLogger et LogRecord sont désormais exportés depuis la bibliothèque Test standard.
• Distribué
  • SSHManager prend désormais en charge les threads de travail avec un wrapper csh/tcsh via la méthode addprocs() et le paramètre shell=:csh.
• Autres changements
  • GC.enable_logging(true) peut être utilisé pour enregistrer chaque opération de garbage collection avec l'heure et la quantité de mémoire collectée.

Source: opennet.ru