+ Répondre à la discussion Actualité déjà publiée
Page 2 sur 3 PremièrePremière 123 DernièreDernière
  1. #21
    Membre éclairé

    Homme Profil pro
    Écrivain public
    Inscrit en
    août 2005
    Messages
    105
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : France, Ille et Vilaine (Bretagne)

    Informations professionnelles :
    Activité : Écrivain public
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : août 2005
    Messages : 105
    Points : 871
    Points
    871
    Billets dans le blog
    16

    Par défaut Augmenter le verbiage des sources permet de mieux vérifier les erreurs de compilation.

    L'utilisation d'un "=>" pour le match du case, anciennement ":" pour le C peut sembler fastidieuse à l'utilisation, donc inutile.
    Mais cela permet peut-être de mieux trouver les erreurs pour le développeur. Est-ce vrai ?

    L'intérêt par rapport au Pascal semble donc le temps gagné, si c'est le cas, une jolie présentation, l'utilisation facilitée des objets dans les boucles.
    Matthieu Giroux - Rennes - 13 Rue François Tanguy Prigent A 15
    Livres : editions.liberlog.fr/
    Contact : liber.log.bzh
    Tous les liens : www.agoravox.tv/auteur/matthius
    Dons : www.tipeee.com/coaching-creatif-et-programmation-libre

  2. #22
    Expert éminent Avatar de Uther
    Homme Profil pro
    Inscrit en
    avril 2002
    Messages
    3 544
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : avril 2002
    Messages : 3 544
    Points : 8 296
    Points
    8 296

    Par défaut

    Le ":" sert déjà à annoter le type en Rust, donc il n'aurait pas vraiment été adapté au match. Utiliser deux caractères par élément de match, c'est vraiment pas ce que j'appelle de la lourdeur. D'ailleurs la syntaxe reste quand même plus légère que celle du C vu que l'on a pas à mettre "case" à chaque élément. De plus le fait que le match utilise le pattern matching permet également de simplifier pas mal de cas qui seraient beaucoup plus complexes en C.

    Le "match" a moins de risque d'erreur que le "switch" en C, mais ce n'est pas à cause du "=>". C'est surtout du au fait que le "match" se doit d'être exhaustif : si un match ne capture pas tous les cas possibles, le programme refusera de compiler. De plus le fait que l'on utilise des blocs et pas, comme en C, une suite d’instruction qu'il faut généralement terminer par un break permet de diminuer le risque d'erreur.

  3. #23
    Expert éminent
    Avatar de _skip
    Homme Profil pro
    Développeur d'applications
    Inscrit en
    novembre 2005
    Messages
    2 872
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : Suisse

    Informations professionnelles :
    Activité : Développeur d'applications
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : novembre 2005
    Messages : 2 872
    Points : 7 254
    Points
    7 254

    Par défaut

    Je suis ce projet depuis ses débuts, je suis plutôt bien disposé à l'idée d'avoir un langage "moderne" positionné quelque part entre java et C++.
    Si quelqu'un a des retours sur un usage en production ou même un projet interne, je suis preneur.

  4. #24
    Chroniqueur Actualités

    Homme Profil pro
    Webmaster
    Inscrit en
    janvier 2014
    Messages
    735
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Webmaster
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : janvier 2014
    Messages : 735
    Points : 16 729
    Points
    16 729

    Par défaut Rust 1.5 est disponible en version stable

    Rust 1.5 est disponible en version stable
    avec une nouvelle commande permettant au gestionnaire de package d’installer des packages localement

    La Fondation Mozilla vient d’annoncer la disponibilité de Rust 1.5 en version stable. Pour cette nouvelle version, il faut compter environ 700 changements et de nombreux correctifs de bogues.

    Nom : mozillarust.jpg
Affichages : 4707
Taille : 14,9 Ko

    Parmi les nouvelles fonctionnalités, le point le plus important demeure l’introduction de la nouvelle commande « Cargo install » permettant d’installer localement sur le système les packages d’application hébergés sur la plateforme crates.io.

    Nous rappelons que cette fonctionnalité a été depuis longtemps réclamée par les développeurs afin de pouvoir installer des packages qui sont hors du manifest. En réponse, Mozilla avait intégré la mise en œuvre de cet outil dans sa feuille de route couvrant les futures fonctionnalités de Rust.

    Dans cette présentation, trois axes avaient été définis parmi lesquels l’implémentation de fonctionnalités permettant au gestionnaire de packages Cargo d’installer des binaires. Cela aurait pour avantage d’offrir aux développeurs Rust des moyens plus aisés pour partager les applications Rust.

    Avec cette nouvelle itération, les développeurs peuvent utiliser la nouvelle commande Cargo install pour installer des applications, mais également pour installer de nouvelles sous-commandes pour cargo lui-même. Comme nouvelles sous-commandes disponibles pour étendre les fonctionnalités de Cargo, nous avons par exemple :

    • cargo-count : qui permet d’afficher les statistiques telles que le code, les commentaires, les compteurs concernant les projets ;
    • cargo-graph : cette sous-commande permet de construire les fichiers GraphViz DOT des graphes de dépendance ;
    • cargo-edit : qui permet d’ajouter une fonctionnalité à Cargo afin d’éditer des dépendances pour un projet à partir d’une ligne de commande ;
    • cargo-readme : permettant de générer du contenu README.md à partir des commentaires de la documentation ;
    • cargo-check : permettant de vérifier un projet de manière statique sans toutefois produire de binaire ;
    • cargo-script : qui permet d’exécuter des scripts Rust assez facilement en se servant de l’écosystème de package de Rust ;
    • Cargo-watch : qui permet de réexécuter une commande de Cargo lorsque des modifications sont effectuées dans le projet ;
    • cargo-extras : est une collection de sous-commandes de Cargo ;
    • cargo-outdated : est une sous-commande de Cargo pour l’affichage lorsque les dépendances sont obsolètes.


    À côté de ces fonctionnalités, Rust 1.5 connait également un certain nombre de stabilisations au niveau des API de bibliothèques. À ce sujet, nous avons de manière non exhaustive les API suivantes qui ont été améliorées : BinaryHeap::from, BinaryHeap::into_sorted_vec, FileTypeExt::is_block_device, FileTypeExt::is_char_device, Formatter::alternate, Formatter::fill, Iterator::cmp, Iterator::eq, Path::canonicalize, Path::exists, Utf8Error::valid_up_to, Vec::resize, VecDeque::as_mut_slices, slice::split_first_mut, slice::split_first, str::MatchIndices, str::RMatchIndices.

    En outre, lorsque vous créez des packages, les dépendances d’un crate sont associées à des contraintes qui exigent de définir les versions de dépendances avec lesquelles ce crate est compatible. Ces versions de dépendances peuvent être de l’ordre d’une seule version précisée de cette manière (=1.2.3), de plusieurs versions (^1.2.3, ~1.2.3, >= 1.2.3, < 3.0.0) ou de toutes les versions de dépendance matérialisées par le caractère générique (*).

    Nous rappelons en outre qu’un crate est une unité de compilation qui peut servir à générer une bibliothèque ou un package. Et pour cette nouvelle version de Rust, le processus RFC (Request For Comments) de la communauté Rust a proposé la mise à jour de crates.io afin de rejeter les publications de crates utilisant une contrainte de version générique pour définir les dépendances de compilation et de construction de build associées au projet.

    En conséquence, les crates utilisant les dépendances avec le caractère générique (*) dans cette version 1.5 déclencheront des avertissements à la publication. Et pour la version 1.6, il ne sera plus possible de publier des crates associant des dépendances avec le caractère générique (*).

    Enfin, Mozilla annonce dans cette nouvelle mouture des améliorations au niveau du temps de compilation et une réduction des métadonnées de crate d’environ 20 %. Plusieurs autres améliorations et nouvelles fonctionnalités sont disponibles au niveau du langage, de bibliothèques, des divers et bien d’autres encore.

    Source : Blog Rust

    Et vous ?

    Que pensez-vous des nouvelles fonctionnalités de Rust 1.5 ?

    Quelles sont les améliorations que vous souhaitez voir dans les prochaines versions de Rust ?

    Voir aussi

    Forum Autres langages
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  5. #25
    Chroniqueur Actualités
    Avatar de Michael Guilloux
    Homme Profil pro
    Consultant
    Inscrit en
    juillet 2013
    Messages
    1 617
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 27
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Consultant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juillet 2013
    Messages : 1 617
    Points : 46 726
    Points
    46 726
    Billets dans le blog
    2

    Par défaut Rust 1.6 est disponible en version stable

    Rust 1.6 est disponible en version stable
    La bibliothèque libcore du langage de programmation de Mozilla est maintenant stable

    Rust, le langage de programmation compilé multiparadigme de Mozilla est disponible en version 1.6 avec un accent mis sur la stabilisation des bibliothèques. La plus grande nouveauté annoncée dans la nouvelle version du langage de programmation des systèmes axés sur la sécurité, la rapidité et la concurrence est sans doute le fait que la bibliothèque libcore est maintenant stable.

    La bibliothèque standard de Rust est à deux niveaux avec libcore, qui est une bibliothèque minimaliste de base sur laquelle est construite la bibliothèque standard complète libstd. La bibliothèque de base libcore fournit les types de données et fonctions les plus fondamentaux pris en charge par Rust, et est indépendante de la plateforme. La bibliothèque libstd, quant à elle, vient ajouter à libcore le support pour l’allocation de la mémoire, les entrées/sorties, et la concurrence.

    La bibliothèque libcore est préférée pour l’embarqué utilisant Rust et l’écriture de systèmes d’exploitation, mais cette bibliothèque a depuis toujours été instable. La stabilisation de libcore permet donc au langage de programmation orienté bas niveau de se rapprocher de l’accomplissement de l’une des principales missions pour lesquelles il a été initialement conçu, c’est-à-dire permettre aux développeurs de construire des logiciels niveau système. « Stabiliser libcore est une étape majeure vers la capacité d’écrire les plus bas niveaux de logiciels en utilisant Rust stable », explique l’équipe Rust qui ajoute encore que « cela permettra de développer un écosystème de bibliothèque autour de libcore ».

    Dans cette nouvelle version de Rust, on note aussi une trentaine de fonctions et méthodes de bibliothèque qui ont été stabilisées et environ 1100 correctifs.

    Un changement a été également apporté à crates.io, la plateforme officielle pour rechercher et installer les paquets Rust. Jusqu’à la version 1.5 de Rust, pour définir les versions des dépendances d’un crate, il était possible d’utiliser le métacaractère (*). Un crate est l’équivalent Rust pour « bibliothèque » ou « paquet » dans d’autres langages. L’utilisation du métacaractère (*) indique que votre projet marche avec toutes les versions de la dépendance citée, « ce qui est hautement improbable pour être vrai », d’après l’équipe Rust qui ajoute encore que cela est à l’origine d’un certain nombre de ruptures inutiles dans l’écosystème.

    Dans la version 1.5, une mise à jour de Crates.io a donc été proposée afin de rejeter les publications de crates utilisant le métacaractère pour définir les dépendances associées au projet. L’équipe Rust avait donc introduit des avertissements qui se déclenchent à la publication d’un crate utilisant les dépendances avec le caractère générique (*). Dans la version 1.6, il n’est plus possible de publier des crates dont les versions des dépendances sont définies avec le métacaractère (*). Il faudra désormais spécifier une version ou un intervalle de versions. Autrement dit, la spécification suivante ne sera plus acceptée :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    [dependencies]
    regex = " * "
    Il faudra utiliser les options ^, ~ ou =.

    De nombreux autres petits changements ont été apportés dans Rust 1.6. On peut par exemple noter que plusieurs fonctions de minuterie qui utilisent les millisecondes sont maintenant obsolètes. Le parser vous avertira également si une erreur a été causée par des caractères Unicode qui se ressemblent, mais sont interprétés différemment.

    Sources : Blog Rust, Notes de version Rust 1.6

    Et vous ?

    Que pensez-vous des nouveautés dans cette nouvelle version stable de Rust ?

    Voir aussi :

    Rust se lance à la conquête des développeurs C/C++, Mozilla publie la première version stable de son langage de programmation multiparadigme
    En 2016, Firefox pourrait accueillir du code Rust et des composants de Servo, le moteur de rendu web sécurisé de Mozilla
    Rust : Mozilla dévoile ses projets pour l'année à venir, et entend améliorer Crates, réduire les erreurs et emmener Rust sur de nouveaux territoires
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  6. #26
    Chroniqueur Actualités

    Homme Profil pro
    Webmaster
    Inscrit en
    janvier 2014
    Messages
    735
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Webmaster
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : janvier 2014
    Messages : 735
    Points : 16 729
    Points
    16 729

    Par défaut Mozilla annonce la disponibilité de Rust 1.7 en version stable

    Mozilla annonce la disponibilité de Rust 1.7 en version stable
    avec un accent mis sur la stabilisation des méthodes et fonctions des bibliothèques

    Un peu plus d’un mois après la sortie de la version 1.6, l’équipe de Rust vient d’annoncer la disponibilité de la version stable de Rust 1.7. Tout comme la version 1.6, un accent particulier a été mis sur les fonctionnalités des bibliothèques Rust.

    Pour cette nouvelle version, environ 40 fonctions et méthodes ont été rendues stables. Au nombre de celles-ci, l’on a par exemple la fonction relative_from permettant de retourner un chemin, qui a été dépréciée et renommée en strip_prefix. La méthode is_loopback(&self) retourne la valeur « vrai » si l’adresse à vérifier est une adresse Loop back selon le registre RFC 6890.

    Par ailleurs, pour copier les données d’un slice (une vue dans une région de mémoire) afin de l’insérer dans un autre slice, il faut utiliser la méthode <[T]>::clone_from_slice(). En ce qui concerne CString, plusieurs améliorations ont été également apportées afin d’utiliser du code C à partir de l’interface FFI.

    Mais au-delà de ces éléments, le point le plus important pour ce qui est de la stabilisation des fonctions et méthodes, c’est le support des algorithmes de hachage personnalisé contenu dans le type HashMap<K, V> de la bibliothèque standard de Rust. Il faut rappeler qu’auparavant tous les dictionnaires de hachage utilisaient l’algorithme de hachage SipHash pour assurer la protection par défaut contre les attaques par déni de service. Toutefois, cet algorithme présente des inconvénients en matière de performance lorsqu’il s’agit de hacher de petites clés.

    Pour résoudre le problème, vous pouvez basculer sur l’algorithme de hachage FNV qui montre des performances meilleures en matière de hachage de ce type de clés. En outre, il est bon de savoir que ce gain de performance se fait au détriment de la protection contre les attaques par déni de service. Si cela ne vous pose aucun problème, vous pouvez alors adopter ce dernier, suggère l’équipe de Rust.

    En dehors du point d’honneur qui a été mis sur les fonctions et les méthodes, l’on a quelques améliorations au niveau des fonctionnalités de Cargo, le gestionnaire de package. Ainsi, il a été introduit des ajouts permettant d’avertir le gestionnaire lorsque des changements surviennent au niveau des dépendances. Cela a l’avantage de déclencher une réexécution des scripts de construction seulement lorsque des changements ont eu lieu dans les dépôts des dépendances et non de manière aléatoire.

    À ces différents changements, il faut ajouter la modification de la sous-commande rustc afin de pouvoir compiler les objets ciblés dans plusieurs profils disponibles (dev, brench, test). À côté de ces éléments, il faut souligner que la collection BTreeMap a été réécrite afin d’utiliser moins de mémoire et améliorer les performances des insertions et des itérations.

    De nombreuses autres améliorations ont été implémentées dans cette nouvelle version et environ 1300 correctifs ont été intégrés.

    Source : Blog Rust

    Et vous ?

    Que pensez-vous de cette nouvelle version de Rust ? Est-elle à la hauteur de vos attentes ?

    Voir aussi

    Forum Autres langages
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  7. #27
    Chroniqueur Actualités

    Homme Profil pro
    Webmaster
    Inscrit en
    janvier 2014
    Messages
    735
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Webmaster
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : janvier 2014
    Messages : 735
    Points : 16 729
    Points
    16 729

    Par défaut Rust 1.8 est disponible

    Rust 1.8 est disponible
    avec la possibilité de surcharger les opérateurs d’affectation à travers les traits et un nouveau projet pour remplacer Make

    L’équipe de Rust vient d’annoncer la sortie de la version 1.8 de ce langage de programmation. Dans cette nouvelle version, plusieurs améliorations ont été introduites. Un nombre important de bibliothèques ont été rendues stables, les performances du compilateur ont été améliorées et Cargo, le gestionnaire de package, s’est doté de nouvelles fonctionnalités.

    De manière détaillée, on note qu’il est maintenant possible de surcharger les opérateurs d’affectation (+= et -=) à travers les traits. Nous rappelons qu’un trait est un outil du langage Rust qui offre au compilateur des informations sur les fonctionnalités qu’un type doit fournir. Étant donné qu’il peut être associé à un autre type, ces traits peuvent être utilisés pour définir d’avance le comportement d’un type dans un cas précis. D’autres personnes pourront également exploiter cet avantage pour limiter les types que leurs fonctions génériques acceptent. Et pour ce qui concerne cette nouvelle fonctionnalité permettant de surcharger les opérateurs d’affectation, il faut ajouter qu’il est également possible d’utiliser des types différents de part et d’autre de l’opérateur.

    À côté de cela, Mozilla a validé l’écriture d’un struct sans accolades. Avant la version 1.8 de Rust, un struct sans aucun champ ne devait pas posséder d’accolades, comme le code suivant :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    struct Foo; // fonctionne
    struct Bar { } // erreur
    À partir de cette version 1.8, le second code ne génère plus de message d’erreur.

    En plus de ces nouveautés, un clin d’œil a été également fait aux utilisateurs Windows. En effet LLVM, l’infrastructure de compilateur a été améliorée afin de détecter les nouvelles instructions de gestion des exceptions pour les builds 32 bits issues de l’environnement de développement intégré pour les langages de programmation C et C++ (MSVC).

    Toujours à propos des nouveautés de cette nouvelle version de Rust, l’équipe de Rust informe que des travaux sont en cours afin de mettre sur pied un nouvel outil pour construire les fichiers Rust. Depuis toujours, Make a été l’outil privilégié pour construire les programmes et bibliothèques Rust. Mais avec le succès de Cargo, un nouveau projet écrit avec Rust et basé sur Cargo a vu le jour avec pour objectif de remplacer Make dans la construction des fichiers et programmes Rust.

    Abordant le volet de Cargo, l’on note quelques nouvelles mises à jour comme la commande cargo init qui peut être utilisée pour démarrer un projet Cargo dans le répertoire en cours d’utilisation au lieu de créer un nouveau sous-répertoire. Pour récupérer des données concernant un projet, les développeurs peuvent utiliser la nouvelle sous-commande cargo metadata. Enfin, les utilisateurs de Cargo peuvent configurer l’outil en mode verbeux ou mettre la couleur en mode automatique en utilisant les nouvelles options -v et --color.

    En dehors de ces points, il faut retenir également dans cette nouvelle version que 1400 correctifs ont été appliqués et environ une vingtaine de méthodes et fonctions de bibliothèques ont été rendues stables.

    Notes de version

    Source : Blog Rust

    Et vous ?

    Que pensez-vous des nouvelles fonctionnalités de Rust ?

    Quelles sont les fonctionnalités que vous souhaiteriez voir dans les prochaines versions ?

    Voir aussi

    Forum Autres langages
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  8. #28
    Expert éminent Avatar de Uther
    Homme Profil pro
    Inscrit en
    avril 2002
    Messages
    3 544
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : avril 2002
    Messages : 3 544
    Points : 8 296
    Points
    8 296

    Par défaut

    Citation Envoyé par Olivier Famien Voir le message
    Toujours à propos des nouveautés de cette nouvelle version de Rust, l’équipe de Rust informe que des travaux sont en cours afin de mettre sur pied un nouvel outil pour construire les fichiers Rust. Depuis toujours, Make a été l’outil privilégié pour construire les programmes et bibliothèques Rust. Mais avec le succès de Cargo, un nouveau projet écrit avec Rust et basé sur Cargo a vu le jour avec pour objectif de remplacer Make dans la construction des fichiers et programmes Rust.

    Abordant le volet de Cargo, l’on note quelques nouvelles mises à jour comme la commande cargo init qui peut être utilisée pour démarrer un projet Cargo dans le répertoire en cours d’utilisation au lieu de créer un nouveau sous-répertoire. Pour récupérer des données concernant un projet, les développeurs peuvent utiliser la nouvelle sous-commande cargo metadata. Enfin, les utilisateurs de Cargo peuvent configurer l’outil en mode verbeux ou mettre la couleur en mode automatique en utilisant les nouvelles options -v et --color.
    Ce point de l'article est très confus.

    L'outil standard pour construire les projets en Rust existe déjà et marche très bien : c'est Cargo et il était déjà disponible quelque mois avant la sortie de la version 1.0 de Rust. Depuis que Rust est officiellement disponible, Cargo a toujours été l'outil privilégié pour construire et gérer les dépendances des applications et des bibliothèques écrites en Rust.

    Le problème est juste au niveau de la compilation du compilateur Rust lui même. Il a été réécrit en Rust (la première version était en OCaml), des années avant l'arrivée de Cargo, le système de construction a donc été basé sur les makefiles. Le compilateur étant assez complexe, l'adapter pour utiliser Cargo est un très gros travail qui n'était pas considéré comme prioritaire et n'a donc réellement commencé que récemment. Il n'y a pas de nouvel outil : Il s'agit juste de mettre a jour le compilateur pour utiliser l'outil standard que quasiment tous les autres projets Rust utilisent déjà.

  9. #29
    Chroniqueur Actualités

    Homme Profil pro
    Webmaster
    Inscrit en
    janvier 2014
    Messages
    735
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Côte d'Ivoire

    Informations professionnelles :
    Activité : Webmaster
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : janvier 2014
    Messages : 735
    Points : 16 729
    Points
    16 729

    Par défaut Rust 1.13.0 est disponible

    Rust 1.13.0 est disponible,
    avec des optimisations du compilateur et un nouvel opérateur « ? » pour mieux gérer les exceptions

    Rust, le langage de programmation multi-paradigme soutenu par la fondation Mozilla est disponible en version 1.13.0. Dans cette nouvelle version, l’on note l’arrivée tant attendue de l’opérateur ?. Avec cet opérateur, il est plus facile et élégant de gérer les erreurs. En guise d’illustration, l’équipe de Rust propose une comparaison entre un bloc de code sans le nouvel opérateur et un second bloc de code avec le nouvel opérateur ?.

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    fn read_username_from_file() -> Result<String, io::Error> {
        let f = File::open("username.txt");
        let mut f = match f {
            Ok(file) => file,
            Err(e) => return Err(e),
        };
        let mut s = String::new();
        match f.read_to_string(&mut s) {
            Ok(_) => Ok(s),
            Err(e) => Err(e),
        }
    }
    Un bloc de code sans le nouvel opérateur ?

    Dans le bloc de code ci-dessus, on a deux erreurs qui peuvent se produire. En lisant le fichier et en ouvrant ce dernier. Pour retourner une erreur à partir de la fonction read_username_from_file, il faut utiliser le mot clé match pour associer les différentes opérations aux résultats. Bien que le résultat puisse paraître satisfaisant pour certains, l’équipe de Rust montre qu’avec le nouvel opérateur ?, le code s’avère plus concis.

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    fn read_username_from_file() -> Result<String, io::Error> {
        let mut f = File::open("username.txt")?;
        let mut s = String::new();
        f.read_to_string(&mut s)?;
        Ok(s)
    }
    Un bloc de code avec le nouvel opérateur ?

    Comme on le constate ci-dessus, avec le nouvel opérateur, on n’a plus besoin de faire correspondre les différentes opérations aux résultats en utilisant le mot clé match qui peut être perçu comme Switch qui est utilisé dans le langage C. En mettant ? devant les différents cas, l’opérateur retourne la valeur du résultat si c’est OK ou sinon retourne une erreur.

    Pour certains développeurs, ce nouvel opérateur pourrait ne rien apporter de nouveau, car il n'est en rien différent de la macro try!. Face à ces arguments, l’équipe de Rust rétorque dans certains cas, le code avec ? s’avère plus élégant expose moins à des erreurs qu’en utilisant try!. Par exemple, des deux blocs de code ci-dessous, celui avec l’opérateur ? est plus facile à lire que le code avec try!.

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    foo()?.bar()?.baz()? // Code avec ? plus lisible
     
    try!(try!(try!(foo()).bar()).baz()) // Code avec try! Moins lisible

    À côté de l’apparition de ce nouvel opérateur, nous avons des optimisations au niveau du compilateur. Par exemple, pendant la génération du code LLVM IR, le compilateur ne retraite plus les instances des types associés à chaque fois qu’elles sont demandées, mais réutilise les valeurs précédemment calculées. En outre, nous avons une autre optimisation qui affecte positivement les performances du temps de compilation. Cette optimisation se situe au niveau des crates qui exportent plusieurs fonctions qui sont dotées du mot clé inline. Nous rappelons qu’un crate est une unité de compilation en Rust. Il s’apparente aux bibliothèques ou aux packages dans les autres langages.

    Aussi, lorsqu’une fonction est #[inline], le compilateur stocke sa représentation MIR (mid-level IR) dans le crate rlib, qui est une bibliothèque statique régulière contenant des métadonnées supplémentaires. Ensuite, il traduit la fonction en code LLVM IR dans chaque crate qui l'appelle. Cette implémentation permet de soulager le compilateur de convertir les fonctions avec le paramètre inline en code LLVM IR pour ensuite le convertir en langage machine.

    En plus de ces éléments, il faut noter dans la nouvelle mouture de Rust, des mises à jour de sécurité pour Cargo qui s’appuie sur Curl et OpenSSL. Ces deux outils ont été mis à jour par leurs auteurs et l’équipe de Rust a rendu ces nouvelles mises à jour compatibles avec cette version de Rust.

    En dehors des éléments cités, nous avons plusieurs stabilisations au niveau du langage et des bibliothèques ainsi que l’ajout de fonctionnalités à Cargo, le gestionnaire de packages Rust.

    Source : Rust

    Et vous ?

    Utilisez-vous Rust ? Que pensez-vous de cette nouvelle version ?

    Voir aussi

    Forum Rust
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  10. #30
    Chroniqueur Actualités

    Homme Profil pro
    Administrateur de base de données
    Inscrit en
    mars 2013
    Messages
    3 113
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Administrateur de base de données

    Informations forums :
    Inscription : mars 2013
    Messages : 3 113
    Points : 70 561
    Points
    70 561

    Par défaut Mozilla annonce la disponibilité de Rust 1.16

    Mozilla annonce la disponibilité de Rust 1.16
    qui s'accompagne de la sous-commande cargo check

    L’équipe responsable du développement de Rust a annoncé la disponibilité de la version stable 1.16. L’un des ajouts majeurs apportés au langage de programmation est la sous-commande cargo check laquelle, selon l’équipe, devrait vous aider à accélérer votre flux de travail dans bien des cas.

    Que fait-elle exactement ? Avant d’y parvenir, il faut d’abord s’intéresser à la façon dont rustc compile votre code. Il existe de nombreuses étapes distinctes par lesquelles le compilateur passe entre votre code source et la production du binaire final. Pour observer ces étapes, et surtout combien de temps et de mémoire elles prennent, vous pouvez lancer la commande -Z time-passes à un compilateur nightly.

    rustc .\hello.rs -Z time-passes
    time: 0.003; rss: 16MB parsing
    time: 0.000; rss: 16MB recursion limit
    time: 0.000; rss: 16MB crate injection
    time: 0.000; rss: 16MB plugin loading
    time: 0.000; rss: 16MB plugin registration
    time: 0.049; rss: 34MB expansion
    <snip>

    Comme vous pouvez le constater avec cet exemple, il y a plusieurs étapes. Cependant, nous pouvons les regrouper en deux grandes catégories :
    • tout d'abord, rustc effectue toutes ses vérifications de sécurité, il s'assure que votre syntaxe est correcte, etc. ;
    • ensuite, une fois qu'il a terminé ses routines de vérification, il produit le code binaire réel que vous finissez par exécuter.

    Il s’avère que cette seconde grande étape prend beaucoup de temps qui n'est pas souvent nécessaire. Autrement dit, lorsque vous travaillez sur un code Rust, de nombreux développeurs vont procéder comme suit :
    1. Écrire une portion de code ;
    2. Exécuter cargo build pour s'assurer qu'il n’y a pas d’erreurs de compilation ;
    3. Répéter les étapes 1 et 2 si nécessaire ;
    4. Exécutez cargo test pour s'assurer qu’il n’y pas d’erreurs dans les tests ;
    5. Retour à l’étape numéro 1.

    En réalité, une fois rendu à l’étape 2, il n’est pas vraiment question de lancer l’exécution de votre code : il s’agit d’avoir un feedback du compilateur, mais pas dans l’optique d’exécuter le binaire. C’est dans ce cas d’utilisation que cargo check intervient : il exécute toutes les vérifications du compilateur, mais ne produit pas le binaire final.

    Alors concrètement de quel pourcentage de vitesse les développeurs vont-ils bénéficier ? Les ingénieurs indiquent que, comme c'est le cas avec les questions de performance, la réponse est « ça dépend ». Toutefois, ils ont fourni un benchmark permettant de comparer des gains de vitesse sur différentes catégories.

    Fonctionnalités de cargo

    En plus de cargo check, Cargo et crates.io ont été retravaillés. Par exemple, cargo build et cargo docsupportent désormais le flag --all pour construire et documenter tous les “crate” dans votre espace de travail en une commande.

    Pour rappel, Rust a deux termes distincts qui se rapportent au système de module : 'crate' et 'module'. Un crate est synonyme d'une « bibliothèque » ou d'un « paquet » dans d'autres langages. Par conséquent, "Cargo”, en tant que nom de l'outil de gestion de paquets de Rust, permet de diffuser les “crate” à d’autres avec Cargo. Les “crate” peuvent produire un exécutable ou une bibliothèque, selon le projet.

    Autres améliorations

    Afin de supporter cargo check, rustc fournit désormais un nouveau type de fichier : .rmeta. Ce fichier contient uniquement des métadonnées sur un “crate” en particulier. cargo check en a besoin pour vos dépendances afin de laisser le compilateur vérifier par exemple les types.

    Source : blog Rust
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  11. #31
    Membre averti
    Homme Profil pro
    Technicien réseau
    Inscrit en
    décembre 2014
    Messages
    88
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Technicien réseau

    Informations forums :
    Inscription : décembre 2014
    Messages : 88
    Points : 330
    Points
    330

    Par défaut corrections

    [B]cargo check[/C]

    " Alors concrètement de quel pourcentage de vitesse les développeurs vont-ils bénéficier ? " C'est assez mal rédigé, non ?

  12. #32
    Expert éminent Avatar de Uther
    Homme Profil pro
    Inscrit en
    avril 2002
    Messages
    3 544
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : avril 2002
    Messages : 3 544
    Points : 8 296
    Points
    8 296

    Par défaut

    Oui, c'est un traduction assez moyenne de l'article.

    Niveau vitesse ça dépend du type de code, certains type de code sont plus couteux que d'autres a compiler. Sur mes programmes, la différence par rapport entre une vérification seule et une compilation (sans optimisation) est de l'ordre de 3 à 6 fois plus rapide.

    Après "make check" ne sert que a vérifier s'il y a des erreur de compilation. Si on veut tester, il faudra quand même faire une construction complète après.

  13. #33
    Rédacteur/Modérateur

    Avatar de Songbird_
    Homme Profil pro
    Bidouilleur
    Inscrit en
    juin 2015
    Messages
    353
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 19
    Localisation : France

    Informations professionnelles :
    Activité : Bidouilleur
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : juin 2015
    Messages : 353
    Points : 2 622
    Points
    2 622
    Billets dans le blog
    3

    Par défaut Rust 1.17.0 est désormais disponible en version stable !

    Rust 1.17 est désormais disponible en version stable,
    et apporte, avec elle, de nombreuses améliorations

    Ce 27 avril, l'équipe Rust a annoncé la sortie de la version 1.17 de Rust avec son lot de (bonnes !) surprises.
    Avant de vous pencher sur les fonctionnalités de cette toute dernière version stable, n'oubliez pas que rustup vous permet d'installer cette dernière simplement (si vous ne disposez pas de rustup sur votre poste, n'hésitez pas à le télécharger).

    Code bash : Sélectionner tout - Visualiser dans une fenêtre à part
    rustup update stable

    Quoi de neuf dans la 1.17.0  ?

    Cette version est principalement axée sur la souplesse de la syntaxe, les raccourcis et l'intelligibilité des erreurs.

    Lifetime des constantes

    Avant la 1.17.0, les références constantes devaient être annotées manuellement de la durée de vie 'static, sans quoi le compilateur risquait de vous renvoyer une erreur.


    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    struct Foo;
    const BAR: &'static Foo = &Foo;
     
    // ou pour reprendre les exemples du billet
     
    const NAME: &'static str = "Ferris";
    static NAME: &'static str = "Ferris";
     
    // L'annotation commence à devenir relativement lourde
    const NAMES: &'static [&'static str; 2] = &["Ferris", "Bors"];


    Pour remédier à cela, la nouvelle version propose de ne plus préciser cette durée de vie dans le type, mais de laisser le compilateur le faire à notre place (puisque, quoi qu'il arrive, une constante devrait avoir une durée de vie équivalente à celle de l'exécution du programme), allégeant drastiquement les annotations.


    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    struct Foo;
    const BAR: &Foo = &Foo;
     
    // ou pour reprendre les exemples du billet
     
    const NAME: &str = "Ferris";
    static NAME: &str = "Ferris";
     
    // L'annotation commence à devenir relativement lourde
    const NAMES: &[&str; 2] = &["Ferris", "Bors"];


    Code MIR de la constante BAR:


    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    const BAR: &'static Foo = { // le compilateur ajoute bien la lifetime
        let mut _0: &'static Foo;            // return pointer
        let mut _1: &'static Foo;
        let mut _2: Foo;
     
        bb0: {
            _2 = Foo::{{constructor}};       // scope 0 at <anon>:2:20: 2:23
            _1 = &_2;                        // scope 0 at <anon>:2:19: 2:23
            _0 = &(*_1);                     // scope 0 at <anon>:2:19: 2:23
            return;                          // scope 0 at <anon>:2:1: 2:24
        }
    }


    Assignation des champs raccourcie

    Précédemment, les assignations effectuées sur les champs d'un objet lors de sa construction se faisaient de cette manière :


    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    struct Foo{
    	x: f64,
    	y: f64,
    	z: f64,
    }
     
    fn main() -> (){
        let x = 10f64;
        let y = 15f64;
        let z = 20f64;
    	let bar = Foo{
            x: x,
            y: y,
            z: z,
        };
    }


    Vous pouvez désormais omettre x:, y: et z:.


    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    struct Foo {
        x: f64,
        y: f64,
        z: f64,
    }
    fn main() {
        let bar = Foo { x, y, z };
        // l'ordre importe peu, exemple:
     
        let bar = Foo { z, x, y };
        println!("x:{0},y:{1},z:{2}", bar.x, bar.y, bar.z);
        // affiche: x:10,y:15,z:20
    }


    Dans le billet, l'équipe Rust explique que ce raccourci est inspiré de celui proposé par l'ECMAScript 6.

    L'opérateur +

    En tant que débutant, il pourrait être aisé de croire qu'une concaténation entre deux primitifs &str s'effectue avec l'opérateur +, ce qui n'est bien entendu pas le cas. Pour épauler ces nouveaux utilisateurs, le message d'erreur a été réécrit.

    (Exemple tiré du billet)
    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    // code
    "foo" + "bar"
     
    // Ancien message d'erreur
    error[E0369]: binary operation `+` cannot be applied to type `&'static str`
     --> <anon>:2:5
      |
    2 |     "foo" + "bar"
      |     ^^^^^
      |
    note: an implementation of `std::ops::Add` might be missing for `&'static str`
     --> <anon>:2:5
      |
    2 |     "foo" + "bar"
      |     ^^^^^
     
    // Nouveau message d'erreur
    error[E0369]: binary operation `+` cannot be applied to type `&'static str`
     --> <anon>:2:5
      |
    2 |     "foo" + "bar"
      |     ^^^^^
      |
      = note: `+` can't be used to concatenate two `&str` strings
    help: to_owned() can be used to create an owned `String` from a string
    reference. String concatenation appends the string on the right to the string on
    the left and may require reallocation. This requires ownership of the string on
    the left.
      |     "foo".to_owned() + "bar"


    À propos de Cargo

    Comme vous le savez, Cargo est le système de build natif du langage Rust. Pour cette version, il a également subi quelques modifications.

    Jusqu'ici, lorsque nous avions besoin de personnaliser le processus de compilation (pour compiler des sources non-Rust, par exemple), il était nécessaire de renseigner l'option build suivie du chemin du fichier chargé d'aller chercher les ressources désirées. Toutefois, une grande majorité des utilisateurs de cargo se contentent de créer le fichier build.rs à la racine du projet, ce qui rend (dans ce cas) l'option inutile. En réponse à cela, désormais, si aucun chemin n'est renseigné dans le manifest Cargo.toml, Cargo ira chercher le fichier à la racine du projet.

    Note : vous pouvez toutefois annuler cette convention, si vous le souhaitez, en assignant build = false.

    Deux autres flags ont également été ajoutés aux commandes check et run. Respectivement, l'une supporte le flag --all (i.e. qui permet de vérifier la syntaxe des sources, sans les compiler, de tous les packages se trouvant dans votre espace de travail), l'autre supporte le flag --package <arg1, arg2, argn> (i.e. qui permet d'empaqueter le binaire du (ou des) package que vous lui renseignerez).

    Enfin, un nouveau paquet est disponible sur crates.io pour la rédaction de la documentation de vos projets : mdbook !
    C'est, en quelque sorte, un équivalent à gitbook qui vous permet de générer un site en markdown en vous proposant divers outils tels que la commande test (qui vous permet de repérer les liens morts, les fichiers inutilisés), un gestionnaire de thèmes ou encore l'expression {{#playpen your_file.rs}} qui vous permet d'intégrer du code source (qui sera compilé par le playpen) à exécuter par l'utilisateur, dans votre documentation.

    À propos de rustup

    Dernière nouvelle, mais pas des moindres : rustup télécharge pour vous l'intégralité de la documentation officielle de Rust sur votre poste lorsque vous installez une nouvelle version du langage. Celui-ci embarquera le livre officiel de la version stable, le Rustonomicon et la documentation des versions encore instables du langage.

    Pour y accéder depuis votre terminal, il vous suffit de taper rustup doc.

    En vous souhaitant une bonne lecture !


    Notez toutefois que d'autres fonctionnalités ont été ajoutées dans cette version, n'hésitez pas à vous rendre sur le billet relatif à l'annonce.

    Source : Rust Core Team blog

    Et vous ?

    Quelle(s) fonctionnalité(s) souhaiteriez-vous voir apparaître dans les prochaines versions  ?

    Voir aussi

    Mozilla annonce la disponibilité de Rust 1.16, qui s'accompagne de la sous-commande cargo check

    Rust 1.13.0 est disponible, avec des optimisations du compilateur et un nouvel opérateur « ? » pour mieux gérer les exceptions

    FAQ sur la programmation en langage Rust
    Avant de poster: FAQ Rust(WIP); FAQ Dart; FAQ Java; FAQ JavaFX.
    Vous souhaiteriez vous introduire au langage Rust ? C'est par ici ou ici !
    Une question à propos du langage ? N'hésitez pas à vous rendre sur le forum !

    N'hésitez pas à contribuer ou nous faire part de vos retours !
    Release Rust FAQ #7


    Ninja Gaiden meets Metal.

  14. #34
    Rédacteur/Modérateur

    Avatar de Songbird_
    Homme Profil pro
    Bidouilleur
    Inscrit en
    juin 2015
    Messages
    353
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 19
    Localisation : France

    Informations professionnelles :
    Activité : Bidouilleur
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : juin 2015
    Messages : 353
    Points : 2 622
    Points
    2 622
    Billets dans le blog
    3

    Par défaut Rust 1.18 est disponible en version stable

    Rust 1.18 est disponible en version stable
    et apporte une optimisation sur l'alignement mémoire

    EDIT: 13/06/2017
    Une issue sur le dépôt de Cargo a été ouverte, et les nouveaux flags annoncés pour ce dernier dans le billet de la version 1.18 étaient en fait prévus pour la 1.19. Ne soyez donc pas étonnés si vous ne parvenez pas à les utiliser dans votre version actuelle.
    Quoi de neuf dans la 1.18 ?

    Cette version est un agrégat de fonctionnalités venant fignoler ce qui avait été ajouté dans les versions précédentes, comme nous allons le voir plus bas, et ce n'est pas pour nous déplaire !

    Réécriture du livre officiel

    Commençons par les ressources gravitant autour du langage.

    L'équipe Rust a annoncé la réécriture du livre officiel "The Rust Programming Language" jugeant, après ces deux dernières, que de nouvelles explications devaient être apportées à propos des concepts abordés dans le livre.
    Vous êtes, bien entendu, invité à consulter la seconde édition sur le site de la documentation officielle, mais gardez tout de même à l'esprit que vous lisez une ébauche et que de nouveaux chapitres seront apportés dans la version 1.19 de Rust.

    Notez aussi qu'une version papier sera proposée, lors de la publication finale du livre.

    Extension du mot-clé pub

    Comme nous le savons, toutes les ressources d'un module rust sont, par défaut, privées et le mot-clé pub permet de remédier à cela.
    Avec la 1.18, pub gagne en précision:




    Il est désormais possible grâce aux () de définir le contexte dans lequel une ressource (e.g. structures, énumérations, fonctions) peut être visible. En l'occurrence, lorsque vous utilisez le mot-clé crate, vous établissez la restriction suivante: bar est visible pour tous les composants du package, mais pas en-dehors.
    Ces restrictions peuvent vous faciliter la tâche, si vous souhaitez user d'une API qui ne devrait communiquer qu'avec les composants de votre package.

    Vous pouvez également spécifier un chemin comme ceci:

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    pub(in a::b::c) foo;

    Vous rendez donc visible cette ressource dans la hiérarchie a::b::c, mais nulle part ailleurs.

    a, b et c doivent être, en revanche, des modules parents de foo.

    Pour plus d'informations à propos de cette fonctionnalité, je vous invite à consulter sa RFC et la documentation officielle.

    Support du flag /SUBSYSTEM

    Pour les utilisateurs Windows, la 1.18 apporte l'attribut #![windows_subsystem]. Voici un exemple d'utilisation :

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    #![windows_subsystem(console)]
    #![windows_subsystem(windows)]


    Ces arguments vous permettent de contrôler le flag /SUBSYSTEM et de choisir l'environnement dans lequel sera exécuté votre programme. Ils peuvent donc être utiles, par exemple, lorsque vous développez une application supportant une interface graphique et que vous ne souhaitez plus voir la console clignoter au lancement de votre programme. Vous utiliserez donc windows pour régler ce problème.
    Pour le moment, seuls les environnements console et windows sont supportés par Rust.

    Nom : rust-logo-256x256.png
Affichages : 1692
Taille : 36,2 Ko

    Rustc

    Optimisation de l'alignement mémoire

    Il est possible d'aligner des données pour réduire le temps des accès (i.e. lecture/écriture) sur ces dernières. Toutefois, lorsqu'elles ne le sont pas (alignées), le compilateur tentera de le faire à notre place, au prix d'une consommation de mémoire plus importante.


    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    struct Suboptimal(u8, u16, u8);

    Dans les versions précédentes de Rust, sur une plateforme x86_64, cette structure consommait six octets. Pourtant, en visionnant le code source, vous n'en comptez que quatre.
    Les deux autres octets viennent de la compensation effectuée par le compilateur; sachant que nous avons un entier u16 ici, il devrait être aligné sur une adresse paire.
    On « décale » alors le premier entier u8 d'un octet, et, pour aligner correctement la structure, on fait de même pour le dernier u8. Ce qui nous donne: 1 + 1 (compensation) + 2 + 1 + 1 (compensation) = 6 octets.

    Quid de cette structure, dans ce cas ?


    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    struct Optimal(u8, u8, u16);


    Celle-ci est correctement alignée, l'entier u16 se trouve sur une adresse paire, l'intégralité de la structure est alignée, aucune compensation n'est requise. Ce qui nous donne : 1 + 1 + 2 = 4 octets.

    Avec la 1.18, le compilateur est capable d'aligner (si possible) une structure sans compensation (i.e. d'appliquer la signature de Optimal à SubOptimal, en quelque sorte), épargnant la mémoire par la même occasion.

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    // compilé avec rustc 1.18
    use std::mem;
     
    struct Optimal(u8, u8, u16);
    struct Suboptimal(u8, u16, u8);
     
    fn main() -> (){
        println!("size of Optimal:{}bytes", mem::size_of::<Optimal>());
        println!("size of Suboptimal:{}bytes", mem::size_of::<Suboptimal>());
    }
    Résultat:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    size of Optimal:4bytes
    size of Suboptimal:4bytes
    Note: Il est possible de désactiver cette fonctionnalité avec l'annotation #[repr(C)], si vous travaillez avec des composants écrits en C.

    Vous n'êtes pas très familier avec cette optimisation ? Vous trouverez des liens en bas de l'article, si vous souhaitez vous documenter.

    Nouveau flag pour l'argument `--emit`

    Pour examiner la MIR (Mid-level Intermediate Representation) d'un morceau de code, il était nécessaire, jusqu'ici, de consulter le compilateur en ligne. Ce n'est plus le cas !
    Une fois votre compilateur mis à jour, il vous suffit de vous rendre dans le répertoire de votre choix et compiler le fichier désiré :


    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    rustc hello.rs --emit mir


    Vous trouverez un fichier nommé hello.mir dans le répertoire courant, contenant la MIR :


    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
     
    // WARNING: This output format is intended for human consumers only
    // and is subject to change without notice. Knock yourself out.
    fn main() -> () {
        let mut _0: ();                      // return pointer
        scope 1 {
            let _1: &str;                    // "foo" in scope 1 at hello.rs:3:6: 3:9
        }
     
        bb0: {
            StorageLive(_1);                 // scope 0 at hello.rs:3:6: 3:9
            _1 = const "Hello, there!";      // scope 0 at hello.rs:3:12: 3:27
            _0 = ();                         // scope 1 at hello.rs:2:10: 4:2
            StorageDead(_1);                 // scope 0 at hello.rs:4:2: 4:2
            return;                          // scope 0 at hello.rs:4:2: 4:2
        }
    }

    Cargo

    Pijul

    Le système de contrôle de version Pijul est désormais supporté par cargo !
    Pour pouvoir créer un projet avec ce VCS, il vous suffit de taper la commande cargo new myAwesomeProject --vcs=pijul.

    Pour plus d'informations, rendez-vous sur la pull request #3842.

    Nouveaux flags

    Le flag --all permet de compiler tous types de sources pouvant se trouver dans votre projet (i.e. exemples, sources du programme, tests, benchmarks). Vous pouvez maintenant cibler uniquement le type de sources que vous souhaitez compiler grâce aux quatre flags fraîchement débarqués :

    1. --bins: Compile toutes les sources;
    2. --examples: Compile tous les exemples;
    3. --tests: Compile tous les tests;
    4. --benches: Compile tous les benchmarks du projet.


    Pour utiliser ces nouvelles fonctionnalités, il vous faudra mettre à jour cargo à la version 0.21.0.

    Haiku et Android

    Enfin, Cargo supporte Haiku et Android dans sa chaîne de build !


    Le principal est ici, mais n'hésitez pas à consulter le billet de blog officiel si vous souhaitez vous rendre sur la release note ou encore les RFC de la version.


    Source

    Le blog du langage Rust
    Fonctionnement de l'annotation #[repr(C)]

    Ressources sur l'alignement mémoire

    Vous n'êtes pas obligé de visiter tous les liens proposés pour comprendre ce qui a été rédigé. Chaque lien aborde simplement, d'une manière différente, ce concept.

    Définition de l'alignement mémoire (en français)
    Fonctionnement de l'alignement mémoire (en anglais)
    Article d'IBM sur la manière dont le processeur gère la mémoire (en anglais)
    Alignement mémoire avec C (en anglais)
    Avant de poster: FAQ Rust(WIP); FAQ Dart; FAQ Java; FAQ JavaFX.
    Vous souhaiteriez vous introduire au langage Rust ? C'est par ici ou ici !
    Une question à propos du langage ? N'hésitez pas à vous rendre sur le forum !

    N'hésitez pas à contribuer ou nous faire part de vos retours !
    Release Rust FAQ #7


    Ninja Gaiden meets Metal.

  15. #35
    Membre actif
    Homme Profil pro
    Développeur informatique
    Inscrit en
    février 2016
    Messages
    111
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : février 2016
    Messages : 111
    Points : 228
    Points
    228

    Par défaut

    Rust c'est tout de même plusieurs choses, amha.

    Un langage pour répondre aux problèmes de ces prédécesseurs.
    Un toolset autour du langage pour vivre avec.
    Un esprit définitivement progressiste et tourné vers l'avenir.

    De cet ensemble, je suis très satisfait,
    c'est un changement appréciable car il est plus proche des utilisateurs,
    en comparaison, pendant longtemps les avancées que l'on pouvait lire à propos des langages
    concernaient des questions très théorique de la théorie des langages (preuves formelles etc)
    qui finalement aboutissaient à peu de changement concret/applicable pour l'utilisateur final lambda.

    J'apprécie beaucoup cela, pour autant est ce que j'aime ce langage,
    bein pas trop en fait,
    comme tout le monde, j'aime bien sa théorie et sa mise en pratique,
    mmmmmeeeeehhhhhh
    la syntaxe est bien trop complexe pour mon goût personnel.

    Je ne doutes pas que je finirais par en faire,
    mais aujourd'hui à cet instant, la chose n'est pas évidente pour moi
    et je préfère encore me tourner vers d'autres langages
    partageant certains points commun avec celui ci.

  16. #36
    Membre chevronné
    Avatar de imperio
    Homme Profil pro
    Étudiant
    Inscrit en
    mai 2010
    Messages
    812
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mai 2010
    Messages : 812
    Points : 1 927
    Points
    1 927

    Par défaut

    la syntaxe est bien trop complexe pour mon goût personnel.
    Ah ? Voilà qui est intéressant ! Venant des langages C/C++, j'ai trouvé la syntaxe de rust nettement plus simple. De quel(s) langage(s) viens-tu du coup ?
    Il y a 10 sortes de gens : ceux qui comptent en binaire et les autres.

    "Premature optimization is the root of all evil" --Donald Knuth
    traduction : "L'optimisation prématurée est la racine de tous les maux" -- Donald Knuth

    Si vous voulez apprendre à développer en Rust, un tuto (en français) est disponible ici.
    Si vous voulez voir mes projets, c'est sur github que ça se passe.

  17. #37
    Rédacteur/Modérateur

    Avatar de Songbird_
    Homme Profil pro
    Bidouilleur
    Inscrit en
    juin 2015
    Messages
    353
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 19
    Localisation : France

    Informations professionnelles :
    Activité : Bidouilleur
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : juin 2015
    Messages : 353
    Points : 2 622
    Points
    2 622
    Billets dans le blog
    3

    Par défaut


    Je ne doutes pas que je finirais par en faire,
    mais aujourd'hui à cet instant, la chose n'est pas évidente pour moi
    et je préfère encore me tourner vers d'autres langages
    partageant certains points commun avec celui ci.
    Qu'est-ce qui te paraît peu évident ? Tes questions et remarques sont les bienvenues.

    Concernant la syntaxe, c'est précisément ce qui me donne envie d'étudier Rust (si l'on ne parle que d'elle), car la syntaxe me semble moins... éparpillée que le C++. Cela reste très personnel, bien entendu.
    D'ailleurs, si quelque chose te rebute dans la syntaxe, des ressources existent pour expliquer littéralement ce que signifie telle ou telle expression.

    Très bonne journée !
    Avant de poster: FAQ Rust(WIP); FAQ Dart; FAQ Java; FAQ JavaFX.
    Vous souhaiteriez vous introduire au langage Rust ? C'est par ici ou ici !
    Une question à propos du langage ? N'hésitez pas à vous rendre sur le forum !

    N'hésitez pas à contribuer ou nous faire part de vos retours !
    Release Rust FAQ #7


    Ninja Gaiden meets Metal.

  18. #38
    Membre actif
    Homme Profil pro
    Développeur informatique
    Inscrit en
    février 2016
    Messages
    111
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : février 2016
    Messages : 111
    Points : 228
    Points
    228

    Par défaut

    D'une manière générale, même si le C est la référence pour les performances,
    pour TOUT les autres domaines c'est le pire des environnements, de ce que j'en connais.
    Je ne crois pas qu'il est très utile de continuer de comparer les nouveaux langages
    avec ces dinosaures qui ont souffert d'avoir été les premiers sur leurs terrain de jeux.

    Par exemple comparer C / Go pour moi,
    selon les sujets comparés,
    cela peut revenir à comparer une vieilles carriole à cheval avec la dernière F40.

    Du coup la F40 gagne tout le temps, les améliorations possible ne sont plus considérés
    et c'est dommage.

    Citation Envoyé par imperio Voir le message
    Ah ? Voilà qui est intéressant ! Venant des langages C/C++, j'ai trouvé la syntaxe de rust nettement plus simple. De quel(s) langage(s) viens-tu du coup ?
    Ah oui, j'ai moi aussi déjà décrit cela autre part.

    J'ai un parcours top-bottom, en gros, perl->php->nodejs->go

    Du coup les langages à typages forts tels que java ou c++,
    bah je ne les ai jamais pratiqué,
    les syntaxes ubuesques, très peu pour moi.

    Lorsque appris go, j'ai souffert (sisi : ),
    maintenant que j'ai passé le cap, très content de l'avoir fait par ailleurs,
    je n'ai pas envie d'une syntaxe beaucoup plus complexe / riche comme le propose rust.
    Là j'ai un compromis qui me plaît bien, il y a juste deux trois ajustements à opérer (generics?), selon moi.

    La syntaxe rust a beaucoup de subtilités, a raison pour ce qu'il veut résoudre,
    mais il reste tout de même ce genre d'exemple

    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    fn read_username_from_file() -> Result<String, io::Error> {
        let f = File::open("username.txt");
        let mut f = match f {
            Ok(file) => file,
            Err(e) => return Err(e),
        };
        let mut s = String::new();
        match f.read_to_string(&mut s) {
            Ok(_) => Ok(s),
            Err(e) => Err(e),
        }
    }

    Je lis ce code, je crois comprendre, mais non, il reste des questions.

    Je ne vois pas où est construit le retour Result<...>.

    y a bien un return,
    mais c'est pas au bon endroit (de ce que je crois savoir, évidemment!),
    et le type ne correspond pas.
    Alors il y a bien ces deux appels à Ok et Err, mais cela reste opaque.

    Détail me direz vous, mais je déteste ce let, un appendice disgracieux et fort répétitif.

    Toujours dans cet exemple s est mutable (2 fois!), car read_to_string doit pouvoir modifier le contenu,
    mais a froid comme ça, je me demandes si Result<String, io::Error> est immutable,
    ce qui amène à d'autres questions.

    Le but de ces remarques n'est pas nécessairement d'obtenir une réponse précise,
    mais plutôt de partager mon sentiment.

  19. #39
    Membre régulier
    Homme Profil pro
    Inscrit en
    juillet 2013
    Messages
    44
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : juillet 2013
    Messages : 44
    Points : 89
    Points
    89

    Par défaut

    Mh-cbon : ton approche top => bottom est bonne : beaucoup ne font pas l'effort et du coup progresse peu à mon sens.
    Le passage à un typage fort est douloureux mais au final nécessaire car le gain est juste énorme : tu évites une paire de bug à l’exécution, le code est plus cohérent, t'as de meilleurs perfs etc.

    Tu mets C et C++ dans le panier des vieux langages mais tu remarqueras que Go ne les remplace pas vraiment car il utilise un Garbage collector et une VM.
    Pour moi, Go est un Java bis avec une syntaxe minimaliste, des gros avantages sur la programmation concurrente et des temps de compilation plus court.
    Bref, rien de bien novateur à mon sens.

    La réalité est que C et C++ sont pour l'instant encore indétrônable dans tous les domaines ou les perfs et la gestion de la mémoire sont critiques.
    Rust étant plus ambitieux et par conséquent plus complexe est un réel candidat pour les remplacer.

    Je dirais, pour ma part que le cap à passer pour Rust n'était pas vraiment la syntaxe (que je trouve élégante et intuitive) mais plus le borrowing. (et dans une moindre mesure les macros et closures)

    Mais, comme tous les langages, il a des zones implicites qui nécessite apprentissage.
    Ton exemple et ton incompréhension proviennent de là :

    * la variable "f" et "let mut f" : f est dans un premier temps immutable : si le match réussi (passe par le Ok), cette variable est écrasé par le résultat et est converti en une variable mutable.
    * le type Result est un peu particulier : il attend soit un objet succès ("Ok") avec le résultat (ici typé en String car on désire récupérer le contenu du fichier mais ça pourrais être n'importe quoi d'autre dans un autre contexte) ou un objet d'échec ("Err").
    * le premier match (qui vérifie l'accès en lecture du fichier) a un retour explicite qui précise que si il détecte une erreur, il sort directement de la fonction (et par conséquent la variable mutable f n'est pas alimenté, la variable s n'est pas créé et le dernier match non executé.
    * let permet de déclarer une variable, je ne vois pas trop ce qui te choques. (tu remplaces "var" par "let" dans ton passage de Go à Rust ou de NodeJS à Rust)
    * en rust si la dernière ligne d'une fonction ne se termine pas par ";", on retourne implicitement le résultat.
    C'est ce qui se passe dans le dernier match.
    * s n'est pas déclaré 2 fois, elle est passé par référence dans la fonction "read_to_string".
    * read_username_from_file renvoi une valeur qui peut parfaitement être mutable ou non selon la déclaration de ta variable de récupération :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    let username_immutable = read_username_from_file();
    // ou
    let mut username_mutable = read_username_from_file();

  20. #40
    Expert éminent Avatar de Uther
    Homme Profil pro
    Inscrit en
    avril 2002
    Messages
    3 544
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : avril 2002
    Messages : 3 544
    Points : 8 296
    Points
    8 296

    Par défaut

    Citation Envoyé par mh-cbon Voir le message
    Je ne vois pas où est construit le retour Result<...>.
    Result est un cas particulier vu que comme c'est un élément central du langage, ses variant OK et Err sont inclus dans le prélude, ce qui fait que l'on peut les utiliser directement. Comme le type Result est utilisé partout, n'importe qui avec un minimum d'expérience dans le langage reconnais ça du premier abord.

    Cependant, si tu tient à ce que ce soit clair que Ok et Err sont des variants du type énuméré Result, tu peux faire :
    Code Rust : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
        let mut f = match f {
            Result::Ok(file) => file,
            Result::Err(e) => return Result::Err(e),
        };

Discussions similaires

  1. Réponses: 1
    Dernier message: 06/10/2017, 11h25
  2. Réponses: 0
    Dernier message: 27/03/2015, 03h38
  3. Réponses: 0
    Dernier message: 18/03/2015, 16h03
  4. Réponses: 0
    Dernier message: 26/09/2009, 13h36
  5. Réponses: 0
    Dernier message: 07/02/2009, 16h05

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo