Mozilla Sortie de la version 0.1 de Rust

Posté par (page perso) . Édité par Xavier Claude et Lucas Bonnet. Modéré par baud123. Licence CC by-sa
36
22
jan.
2012
Mozilla

Mozilla a annoncé le 20 janvier la sortie de la version 0.1 du compilateur pour Rust, sous une licence de type MIT. Rust est un langage de programmation système fortement typé. L'accent est mis sur la sûreté des accès mémoire et la concurrence. Il fonctionne actuellement sur les plateformes GNU/Linux, OSX et Windows.

Voici un exemple d'Hello World :

use std;
import std::io;

fn main() {
    for i in [1, 2, 3] {
        io::println(#fmt("hello %d\n", i));
    }
}

Rust est un langage proche de Go, il partage d'ailleurs une inspiration commune venant de Newsqueak, Alef et Limbo. Toutefois, les développeurs de Rust ont commencé leur travail avant l'annonce de Go et ne sont pas satisfaits par la sémantique adoptée par Go (état partagé mutable, Ramasse-miettes global, pointeurs NULL, absence de destructeurs).

Plus d'informations en seconde partie.

Syntaxe

Rust est un langage dont la syntaxe peut faire penser au C. Mais Rust n'est pas juste une évolution du C, sa sémantique est réellement différente sur de nombreux aspects.

Notons quelques différences avec le C : les types viennent après l'identifiant, les parenthèses sont optionnelles pour les conditions des if, while et for, et tout ce qui n'est pas une déclaration est une expression :

// is_four est une fonction qui prend un entier et renvoie un booléen
fn is_four(x: int) -> bool { x == 4 }

// On peut assigner le retour d'if à une variable car c'est une expression
let x = if the_stars_align() { 4 }
        else if something_else() { 3 }
        else { 0 };

Chaînes de caractères

Par défaut, les chaînes de caractères sont en UTF-8. Et de manière très traditionnelle, elles s'écrivent avec des guillemets doubles :

let s = "Une chaîne";

Typage

Il y aurait beaucoup à dire sur le typage dans Rust. Je vous invite donc à consulter le tutoriel à ce sujet. Je vais essayer de juste présenter l'essentiel.

Le typage est statique. Les types de base sont () (avec juste la valeur nulle), bool (deux valeurs possibles : true et false), les entiers (int, uint, etc.) les flotants (float, f32, f64), les caractères (char) et les chaînes (str). Ces types de base peuvent ensuite être composés dans des types composites : vecteurs ([T]), vecteurs mutables ([mutable T]), tuples ((T1, T2)), enregistrements ({field1: T1, field2: T2}), fonctions (fn(arg1: T1, arg2: T2) -> T3) et pointeurs (@T, ~T, *T). Il est également possible de créer de nouveau type avec le mot-clé type :

type monster_size = uint;

Les variables locales bénéficient de l'inférence de types (leur type peut être omis, le compilateur saura le déduire) :

// Le compilateur saura deviner le type de ce vecteur
let x = [];
// On peut aussi être explicite
let y: [int] = [];

Rust possède également la notion de types génériques :

fn map<T, U>(v: [T], f: fn(T) -> U) -> [U] {
    let acc = [];
    for elt in v { acc += [f(elt)]; }
    ret acc;
}

Pattern Matching

Juste pour le plaisir, un petit exemple de pattern matching :

alt my_number {
  0       { std::io::println("zero"); }
  1 | 2   { std::io::println("one or two"); }
  3 to 10 { std::io::println("three to ten"); }
  _       { std::io::println("something else"); }
}

Modules

L'espace de noms de Rust est séparé en modules. Chaque fichier source commence son propre module. Il est aussi possible d'avoir des modules locaux.

Interfaces

Les interfaces sont le moyen de faire le polymorphisme en Rust. Elles se déclarent avec le mot-clé iface et les implémentations avec impl :

iface to_str {
    fn to_str() -> str;
}

impl of to_str for int {
    fn to_str() -> str { int::to_str(self, 10u) }
}
impl of to_str for str {
    fn to_str() -> str { self }
}

Tâches

L'approche utilisée pour la concurrence en Rust est les tâches (tasks) et est similaire à de nombreux systèmes d'acteurs. Les tâches se lancent avec spawn, ne partagent aucune donnée et communiquent entre elles via des ports et canaux :

let port = comm::port::<int>();
let chan = comm::chan::<int>(port);
let child_task = task::spawn {||
    let result = some_expensive_computation();
    comm::send(chan, result);
};
some_other_expensive_computation();
let result = comm::recv(port);

Tests

Rust permet d'écrire des tests directement dans le code, en les annotant avec #[test] :

use std;

fn twice(x: int) -> int { x + x }

#[test]
fn test_twice() {
    let i = -100;
    while i < 100 {
        assert twice(i) == 2 * i;
        i += 1;
    }
}

Ramasse-miettes

La mémoire est libérée à l'aide d'un ramasse-miettes. Celui-ci est capable de travailler sur une seule tâche à la fois, évitant le problème du « bloquer le monde » pendant qu'il se lance.

  • # Rush in Rust ?

    Posté par (page perso) . Évalué à  7 .

    Rust est un langage proche de Go,

    Tu peux me dire en quoi il est proche de Go ?
    Car il a au contraire un design franchement différent de go : syntaxe à la OCaml, support des templates, memory management manuel, Support complet de l'OO, inférence de types, immutabilité ...

    Il se veut complet et puissant ("programming in the large") à la C++, un peu tout l'opposé de Go qui se veut minimaliste et pythonien en fait.

    Il a été annoncé publiquement peu de temps aprés Go, d'où les quelques "Go vs Rust" du wiki, mais est Trés TRES different de Go.

    • [^] # Re: Rush in Rust ?

      Posté par (page perso) . Évalué à  6 .

      Tu peux me dire en quoi il est proche de Go ?

      Oui, Go et Rust sont deux langages système typé statiquement avec une syntaxe héritée du C, avec un garbage collector (ce qui rare pour les langages système), pas de notions de classe, avec des contextes légers (goroutines ou tasks), privilégiant la communication entre ces contextes plutôt que le partage mémoire. Je pourrais également citer l'encodage en UTF-8 par défaut et le fonctionnement des modules, mais c'est du détail ;-)

      Après, je ne nie pas qu'il y ait des différences. Et je ne suis pas un expert en Rust, donc je peux n'avoir qu'une vision très incomplète de Rust.

      syntaxe à la OCaml

      « Rust is a curly-brace language in the tradition of C, C++, and JavaScript. » -- http://doc.rust-lang.org/doc/tutorial.html#first-impressions

      support des templates

      Oui (ça s'appelle generics pour ceux qui chercheraient dans la doc).

      memory management manuel

      Pas du tout, c'est un garbage collector comme en Go.

      Support complet de l'OO

      Tu veux dire quoi par là ? Rust n'a pas de classes. Le polymorphisme se fait avec les interfaces, exactement comme en Go.

      inférence de types

      Uniquement pour les variables locales, et ça n'est pas très différent de foo := 0 en Go.

      immutabilité

      C'est effectivement une différence fondamentale avec Go.

      Il se veut complet et puissant ("programming in the large") à la C++

      Non. https://github.com/mozilla/rust/wiki/Doc-project-FAQ indique clairement que ce n'est pas un objectif : « To cover the complete feature-set of C++, or any other language. » dans la partie non-goals.

      • [^] # Re: Rush in Rust ?

        Posté par . Évalué à  2 .

        Pas du tout, c'est un garbage collector comme en Go.

        Non, pas comme en Go. Celui de Go est global, alors que pour Rust :

        Garbage collection

        optional, per-task, only "shared" types

        • [^] # Re: Rush in Rust ?

          Posté par (page perso) . Évalué à  4 .

          Oui, je sais bien, je l'ai marqué dans la dépêche. Ce que je voulais dire, c'est que la mémoire n'est pas libérée manuellement avec des free() mais qu'un ramasse-miettes s'en occupe.

      • [^] # Re: Rush in Rust ?

        Posté par . Évalué à  9 .

        Juste une question : c'est quoi, un "langage système" ? Un langage qui se compile en code natif ? Ou juste un langage avec des accolades à la C ?

        The cake is a lie.

        • [^] # Re: Rush in Rust ?

          Posté par . Évalué à  10 .

          Un langage pas assez ambitieux pour rendre aisée la programmation d'applications haut-niveau.

  • # Back to the future

    Posté par (page perso) . Évalué à  10 .

    Inférence de types, types algébriques avec polymorphisme, clôtures, garbage collection, message-passing...

    Scoop : « le programmeur lambda vient de découvrir la programmation fonctionnelle ! »

    • [^] # Re: Back to the future

      Posté par . Évalué à  10 . Dernière modification : le 22/01/12 à 17:47

      Les programmeurs de chez Mozilla ne sont pas des "programmeurs lambda"; un monde dans lequel tous les programmeurs seraient aussi cultivés que les gens qui font Rust aujourd'hui serait un paradis, relativement parlant.

      Ce que tu vois c'est plutôt l'effet lent des gens qui ont fait un peu de recherche (par exemple une thèse) dans des domaines proches des langages de programmation, qui atteignent l'industrie, et qui y font des marques. Les gens de mozilla sont assez ouverts aux expériences de ce genre (cf. leur travail sur l'analyse statique de C++) et on y retrouve donc beaucoup d'idées qui viennent de ces milieux -- cf. par exemple Chris Double, qui fait du Dylan, Factor, ATS...

      Qui sait, peut-être qu'un jour, on trouvera des preuves Coq dans les dépôts de source Mozilla ?

      • [^] # Re: Back to the future

        Posté par (page perso) . Évalué à  2 .

        Il va encore falloir améliorer les perfs avant cela. Enfin évidemment ça dépend de l'usage, mais j'ai par exemple fait une présentation qui portait sur les travaux visant à fournir des implémentations plus rapides des réels (avec une fiabilité à un epsilon donné).

        Et bien il y a eu des gros progrès ces derniers temps, mais on est encore loin de résultats utilisables dans des solutions temps réel (sachant que coq on te le vend comme la solution pour éviter que tes fusées elles explosent à cause d'une erreur d'arrondi dont l'exception n'a pas été attrapée/gérée).

        Enfin bref, ça me semble pas irréaliste que « un jour… », mais c'est pas encore demain. :)

      • [^] # Re: Back to the future

        Posté par (page perso) . Évalué à  -9 .

        Les programmeurs de chez Mozilla ne sont pas des "programmeurs lambda"

        Mozilla ? Ce sont des gens qui commencent sérieusement à confondre Internet et Web, au point de se figurer que leur mission est d'améliorer le Web et qu'une extension à la Mozilla, c'est forcément une extension pour Firefox.

        • [^] # Re: Back to the future

          Posté par . Évalué à  3 .

          Je ne comprends pas ton commentaire dans ce contexte. Quel est le lien entre Rust, Internet et le web, et Firefox ?

          • [^] # Re: Back to the future

            Posté par (page perso) . Évalué à  -8 .

            Pas grand chose, seulement le fait que j'accorde peu de crédit aux idées de quelqu'un qui manque de culture informatique au point de confondre Web et Internet. Cela témoigne soit d'un désintérêt, soit d'une grande ignorance, soit d'une volonté nuisible. Dans les trois cas, ce n'est pas bon, surtout de la part d'un organisme comme Mozilla.

            • [^] # Re: Back to the future

              Posté par (page perso) . Évalué à  -6 .

              En fait pour être précis, ce qui relie tout ça à Rust, c'est ce que je pense du fait que ce langage aurait été bien pensé puisque conçu par des gens de chez Mozilla, qui a priori s'y connaissent vachement : Mozilla, le jour où ils comprendront ou cesseront de faire semblant de ne pas savoir qu'Internet n'est pas le Web, je considérerai peut-être qu'ils savent de quoi ils parlent. Pour l'instance, non.

            • [^] # Re: Back to the future

              Posté par . Évalué à  4 .

              Mais à quoi penses-tu en particulier ? Je ne vois pas où quelqu'un a confondu les deux dans la présente discussion. Dans tous les cas je trouverais dommage de ne pas écouter quelqu'un seulement parce qu'il fait une erreur de la sorte, même des gens intéressants peuvent se tromper. Enfin bon si c'est ton dada, tant mieux, mais il me semble normal d'accepter que ça n'intéresse pas tout le monde (et je pense que quelqu'un qui n'est pas sur ça peut tout de même apporter quelque chose à Mozilla ou à toute organisation).

              • [^] # Re: Back to the future

                Posté par (page perso) . Évalué à  -6 .

                Je pense à l'attitude générale de Mozilla, qui indique régulièrement qu'ils sont là pour défendre le Web, ou qu'ils travaillent pour un Web meilleur, par exemple.

                • [^] # Re: Back to the future

                  Posté par . Évalué à  1 .

                  Et en quoi cela montre qu'ils amalgame web et internet ?

                  Je suis dans ma tour d'ivoire (rien à foutre des autres, dites moi un truc pour moi), si je ne pose pas explicitement une question pour les 99%, les kévin, les Mm Michu alors c'est que je ne parle pas d'eux.

    • [^] # Re: Back to the future

      Posté par . Évalué à  5 .

      Scoop : « le programmeur lambda vient de découvrir la programmation fonctionnelle ! »

      Lambda ? Mais Haskell c'est déjà du fonctionnel !

    • [^] # Re: Back to the future

      Posté par . Évalué à  4 .

      Le SCOOP c'est pas le programmateur fonctionnel qui vient de découvrir la programmation orienté objet ? ( pun intended :P )

  • # Pour quoi faire?

    Posté par (page perso) . Évalué à  10 .

    De nombreux langages se présentent comme un inventaire à la Prévert de fonctionnalités à la mode. J'applaudis l'effort d'innovation, mais je ne peux m'empêcher de me demander l'intérêt de l'approche.

    Je préfère de beaucoup que l'on me dise: "Tiens, voilà un super produit! Malheureusement, aucun langage ne répondait à nos besoins pour le développer, nous avons donc créé le nôtre.", que "Tiens, voilà un super langage! On ne sait pas trop quoi faire avec, par contre. Des idées?".

    Existe-t-il donc des applications écrites en Rust et qui bénéficient des fonctionnalités du langage?

    • [^] # Re: Pour quoi faire?

      Posté par . Évalué à  -1 .

      Existe-t-il donc des applications écrites en Rust et qui bénéficient des fonctionnalités du langage?

      J'ai trouvé un parser HTML5 écrit en Rust, c'est petit mais ça devrait donner déjà une petite idée concrète : https://github.com/brson/rust-html

      ;; elf32

      • [^] # Re: Pour quoi faire?

        Posté par . Évalué à  3 .

        Heu... Moi je vois trois débuts de code source Rust dans un dépôt, c'est loin d'être un parser... Pour l'instant, ça a autant de fonctionnalités qu'un Hello World.

    • [^] # Re: Pour quoi faire?

      Posté par . Évalué à  -1 .

      Dans la FAQ du langage :

      Are there any big programs written in it yet? I want to read big samples.

      The Rust compiler, 40,000+ lines at the time of writing, is written in Rust. See the src/comp/ directory.

      • [^] # Re: Pour quoi faire?

        Posté par (page perso) . Évalué à  7 .

        Oui, mais ça répond pas tellement à la question. Y avait-il un projet qui les a amené à concevoir ce langage ? Parce que bon, on n'avait besoin de créer un nouveau langage pour écrire le compilateur de notre nouveau langage, ça se mort un peu la queue. :)

    • [^] # Re: Pour quoi faire?

      Posté par . Évalué à  6 .

      J'ai cru comprendre, en bavardant avec un type de Mozilla, qu'à terme le but serait d'utiliser rust pour les gros projets du style firefox. Actuellement ils utilisent C++, et ça leur posent de gros problèmes d'erreurs de gestion de la mémoire et concernant la concurrence.

      The cake is a lie.

      • [^] # Re: Pour quoi faire?

        Posté par (page perso) . Évalué à  4 .

        Je confirme. Au summit Mozilla de 2008, Rust avait été présenté, par son créateur et par Brendan Eich (le créateur de JS). Ils évoquaient déjà la possiblité, dans un futur lointain, d'utiliser Rust au lieu de C++, si le langage allait répondre à toutes les problèmatique de Mozilla.

        Trois ans et demi après, Rust a bien avancé, il y a pas mal de contributeurs (en tout cas, pour un truc aussi peu connu que ça).

        Bon maintenant, il faut pas non plus s'attendre à voir le C++ remplacé par Rust demain dans Firefox. Il y a des millions de lignes, ça va prendre quelques années à recoder Gecko. Et cela si un jour ils décident de passer à Rust dans Firefox...

        Mon avis est que Rust ne remplacera jamais tout le C++ dans Gecko. il y a vraiment trop de code. Cela va se faire seulement sur quelques composants à mon avis. Et pas forcément dans le coeur. Et puis passer de C++ à Rust va prendre pas mal de temps (apprentissage pour les développeurs internes et les contributeurs, la réécriture etc). Je vois mal comment ils pourront avoir les ressources pour à la fois continuer à suivre la course dans la browser war actuelle, et réécrire du code... Sauf si ils arrivent à faire une moulinette C++ -> rust, mais ce serait je pense pas optimum...

        Bref, je pense que Rust sera utilisé plus dans des nouveaux projets que dans les projets actuels (Firefox &co)...

        • [^] # Re: Pour quoi faire?

          Posté par . Évalué à  2 .

          Sauf si ils arrivent à faire une moulinette C++ -> rust, mais ce serait je pense pas optimum...

          Cela peut être pas mal pour débuter la conversion de code.

          "La liberté de tout dire n'a d'ennemis que ceux qui veulent se réserver le droit de tout faire". "La question n'est pas de savoir si vous avez quelque chose à cacher. La question est de savoir si c'est nous qui contrôlons le gouvernement ou l'inverse

          • [^] # Re: Pour quoi faire?

            Posté par . Évalué à  6 .

            Un langage qui se veut générique de toute utilisation doit développer des idiomes propres, qui font l'intérêt d'un langage. Et ces idiomes ne sont pas que des idiomes locaux mais peuvent changer complètement la conception du code. Si une conversion automatique transformait le C++ en Rust, ce ne serait qu'une transformation de syntaxe, ce qui n'apporterait donc strictement rien.
            D'ailleurs, découvrir les nouvelles possibilités et usages de Rust va prendre un certain temps, comme pour tout langage. Passer directement Firefox à Rust — que ce soit par conversion automatique ou par réécriture par des humains — dès Rust inventé ne serait rien de plus qu'une expérience, qui à mon avis se solderait par de mauvais résultats dus à la méconnaissance (forcée) de Rust.

            • [^] # Re: Pour quoi faire?

              Posté par . Évalué à  3 .

              C'est vrai mais le but est aussi de réutiliser le code déjà écrit, qui marche bien. Le nouveau langage apporterait surtout un plus pour le développement du nouveau code. Porter le code ancien a moins d'intérêt, si ce n'est celui de mieux s'intégrer avec le nouveau.

              "La liberté de tout dire n'a d'ennemis que ceux qui veulent se réserver le droit de tout faire". "La question n'est pas de savoir si vous avez quelque chose à cacher. La question est de savoir si c'est nous qui contrôlons le gouvernement ou l'inverse

    • [^] # Re: Pour quoi faire?

      Posté par . Évalué à  1 .

      Je préfère de beaucoup que l'on me dise: "Tiens, voilà un super produit! Malheureusement, aucun langage ne répondait à nos besoins pour le développer, nous avons donc créé le nôtre.", que "Tiens, voilà un super langage! On ne sait pas trop quoi faire avec, par contre. Des idées?".

      Gambas ? (voir le pourquoi Benoît Minisni à créé ce langage)

    • [^] # Re: Pour quoi faire?

      Posté par (page perso) . Évalué à  7 .

      Le langage a l'air puissant. Tout comme les 1001 langages puissants sans IDE, ni debugger, ni système de build...

      Newton Adventure est sur Lumière Verte : http://steamcommunity.com/sharedfiles/filedetails/?id=187107465

      • [^] # Re: Pour quoi faire?

        Posté par (page perso) . Évalué à  3 .

        Le langage est en version 0.1 et il s'adresse donc à des early adopters (on traduit ça comment en français ?).

        Coté IDE, il y a des plugins pour vim et emacs sur https://github.com/mozilla/rust/tree/master/src/etc . Je n'ai rien vu pour le debugger et, pour le système de build, make n'est pas suffisant ? Il y aussi cargo, un gestionnaire de packages mais je n'ai pas du tout regardé ce qu'il faisait.

        • [^] # Re: Pour quoi faire?

          Posté par (page perso) . Évalué à  1 .

          Par système de build, je pensais au très complet Maven, cad qui sert à la fois de make, de gestionnaire de paquet et de fichiers de description de projet pour un IDE.

          Le problème des nouveaux langages, c'est qu'aujourd'hui une plateforme de développement doit disposer de tous ces outils, même pour une adoption en avance de phase (traduction approximative).

          Newton Adventure est sur Lumière Verte : http://steamcommunity.com/sharedfiles/filedetails/?id=187107465

        • [^] # Re: Pour quoi faire?

          Posté par (page perso) . Évalué à  5 .

          adepte/adhérent/souscripteur hâtif/précoce

          Personnellement je préfère adhérent hâtif, qui colle le plus à la sémantique que j'attache à early adopter. J'ai préféré éviter de mettre adopteur qui constituerait un néologisme, pour autant que je sache.

        • [^] # Re: Pour quoi faire?

          Posté par . Évalué à  3 .

          (on traduit ça comment en français ?).

          Si tu ne connais pas encore, va faire un tour sur le http://www.granddictionnaire.com/ C'est le dictionnaire de l'Office québécois de la langue française, qui fournit les définitions et traductions français/anglais/latin de la terminologie technique (toutes disciplines confondues).

  • # ADA

    Posté par . Évalué à  3 .

    L'accent est mis sur la sûreté des accès mémoire et la concurrence. Il fonctionne actuellement sur les plateformes GNU/Linux, OSX et Windows.

    Tiens une dépêche qui parle d'ADA ?

    Je suis dans ma tour d'ivoire (rien à foutre des autres, dites moi un truc pour moi), si je ne pose pas explicitement une question pour les 99%, les kévin, les Mm Michu alors c'est que je ne parle pas d'eux.

    • [^] # Re: ADA

      Posté par . Évalué à  1 .

      Tiens une dépêche qui parle d'ADA ?

      Bah non: je doute que Rust arrive à la cheville d'Ada sur bien des sujets, un exemple: dans leur doc de "référence", ils ne parlent même pas de ce qui se passe en cas de débordement entier, je suppose que la sémantique du C/C++ est tellement imprimé chez eux qu'ils n'envisagent même pas d'avoir un autre comportement..
      Pourtant avoir des entiers avec un comportement sain (big int ou exception en cas d'overflow par défaut, débrayable pour les cas ou il faut 100% des perfs du CPU) dans un langage conçu au 21ème siècle ça ne serait pas un mal..

      • [^] # Re: ADA

        Posté par . Évalué à  6 .

        je suppose que la sémantique du C/C++ est tellement imprimé chez eux qu'ils n'envisagent même pas d'avoir un autre comportement..

        Surprise, les développeurs de Rust ne sont pas les vieux beaufs que tu nous décris, ils ont en fait pensé au problème et regardé ce que la littérature de recherche dit à ce sujet, comme le montre la discussion mailing-list suivante que tu aurais pu trouver très facilement en faisant une recherche:
        Patrick Walton: Integer overflow checking

        Je n'ai pas spécialement d'avis sur Rust, ni en bien ni en mal (même si j'en attends plus que de Go), mais je suis un peu agacé par le mépris que l'on peut lire dans vos réponses. Rust n'a pas la maturité d'Ada, c'est clair, mais il s'intéresse aussi à d'autres points non traités par Ada, qui n'est d'ailleurs pas le seul langage pensé pour être sûr.

        • [^] # Re: ADA

          Posté par (page perso) . Évalué à  3 .

          Non mais il soulève une problématique intéressante:
          Combien de programmeurs peuvent se vanter de connaître TOUS les langages existants au point de justifier la création d'un énième?

          Je ne doute pas des qualités de Rust, mais bon... j'ai du mal à croire qu'il soit tellement innovant qu'on ne puisse pas utiliser l'existant, quitte à l'améliorer un peu, à la place de réinventer la roue.

          • [^] # Re: ADA

            Posté par . Évalué à  0 .

            Comme implémenter un ramasse miette pour C++ ?

            Please do not feed the trolls

        • [^] # Re: ADA

          Posté par . Évalué à  2 .

          OK, j'y suis peut-être aller un peu fort. Mais bon la doc de "référence" ne parle pas du sujet (quand même assez fondamental) alors j'ai quelque excuse non?

    • [^] # Re: ADA

      Posté par . Évalué à  6 .

      Mouais, à lire leur doc, c'est beaucoup plus proche d'un CaML (inférence de type, ordre supérieur, clôtures, références gardées, variables non-mutables par défaut, ...) avec une syntaxe à la C que d'Ada ou assimilé.

      Évidemment ce n'est pas non plus CaML, vu que les facilités syntaxiques encouragent plus un style procédural que fonctionnel, mais avec la possibilité de faire du fonctionnel, du quasi-objet, et un peu de tout, y compris de la programmation concurrente modulaire genre Ada.
      En fait, le cœur du langage semble très riche (d'où la comparaison avec C++), en tout cas pour une version 0.1 !

  • # Objectif

    Posté par . Évalué à  6 .

    Soyons clair qu'elle est la finalité de ce langage ?

    Mozilla cherche t'il à le rendre utilisable pour quelqu'un d'autre que les gens de Mozilla ?
    C'est assez important quand on voit ce qu'ils font de Gecko.

    Un autre point important c'est quel va être le cycle de développement de ce langage ? Ont-ils l'intention de faire comme les langages récents qui évolue très vite ou comme les langages plus anciens qui prennent plus de temps. De la même manière c'est assez important pour savoir si on est dans un mode proche de ce qu'ils font pour leur navigateur ou pas.

    Enfin comment s'organise la gouvernance du langage ? Cherchent ils à rester seuls, à créer un consortium/commité autour de ce langage ?

    Au vu des caractéristiques mises en avant pour ce langage il me semble qu'il serait opportun d'avoir un mode de développement lent et réalisé en partenariat avec d'autres organismes. En effet c'est un langage qui se veut sûr, donc particulièrement pertinent pour des applications critiques dont l'évolution doit fiables et maîtrisées (on prend souvent comme exemple les applications faite pour l'énergie, les banques, etc).

    Enfin le dernier point qui m'intéresse est le lien avec les deux compilateurs du libres les plus connus : gcc et llvm. Sont-ils en liens avec ceux-ci à fin d'intégrer Rust à ceux-ci, cela permet de capitaliser les optimisations pour la génération de code sur un tas d'architectures.

    Je suis dans ma tour d'ivoire (rien à foutre des autres, dites moi un truc pour moi), si je ne pose pas explicitement une question pour les 99%, les kévin, les Mm Michu alors c'est que je ne parle pas d'eux.

    • [^] # Re: Objectif

      Posté par . Évalué à  3 .

      Mozilla cherche t'il à le rendre utilisable pour quelqu'un d'autre que les gens de Mozilla ?
      C'est assez important quand on voit ce qu'ils font de Gecko.

      Quelle mauvaise langue, alors que les utilisateurs de XUL sont comblés.

    • [^] # Re: Objectif

      Posté par . Évalué à  1 .

      En effet c'est un langage qui se veut sûr, donc particulièrement pertinent pour des applications critiques dont l'évolution doit fiables et maîtrisées (on prend souvent comme exemple les applications faite pour l'énergie, les banques, etc).

      En effet, tout le monde souhaite avoir ce type langage (Ada), c'est vraiment frustrant que ça n'existe pas encore (Ada) un langage conçu par un groupe de gens (Ada) pour des applications critiques (Ada) dont l'évolution doit fiables et maîtrisées (Ada), mais je suis sûr que dès qu'un langage comme ça existera (Ada), ça sera un grand succès :-( :-(

      J'espère que ce langage supportera la programmation par contrat (Ada 2012), un concept intéressant (Eiffel) pour améliorer la maintenabilité des programmes.

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.