Raku en 2020

44
22
nov.
2020
Perl

Perl 6 Raku est un langage puissant et mature qui fut assez difficile à mettre en œuvre (ce qui sera abordé dans la deuxième partie de la dépêche).

Divers goodies Raku

Raku est né « Perl 6 », mais n’est pas/plus la prochaine version de Perl 5 (qui sera Perl 5.34 ou Perl 7, voire la dépêche annonce de Perl 7). Raku a, d’ailleurs, été renommé en 2019 pour clarifier ce positionnement. Raku partage en effet avec Perl 5 :

  • des caractéristiques techniques (proche du langage naturel, sigils…) ;
  • la même fondation ;
  • les mêmes conférences ;
  • en partie leurs communautés (Damian Conway, Larry Wall…) ;
  • certains évènements (Perl Weekly Challenge…).

Sommaire

À propos de Raku

Préambule

Raku est (devenu) bien trop « différent » de Perl 5. On peut à présent dire tout simplement « Perl » pour désigner Perl 5 ou Perl 7 et on préférera « Raku » en toutes circonstances pour parler de Perl 6. Il fut un temps où la communauté Perl 6 était plutôt contre le changement de nom, mais l’opinion générale a changé et le renommage a pu se faire en douceur entre 2018 et 2019 (voir plus loin pour les détails).

Vous pouvez suivre l’actualité du langage en vous abonnant à la newsletter Rakudo Weekly News.

Raku possède une petite communauté et quelques « killer apps » :

  • Cro, une boîte à outils pour le Web (applications, services) ;
  • Sparrow un cadriciel d’automatisation, ainsi que ses modules ;
  • son IDE « Comma » ;
  • un (petit) CPAN.

Avant d’aller plus loin, voici quelques liens vers des contenus LinuxFr.org autour du même sujet :

Une fois n’est pas coutume, parlons un peu de Raku, sa communauté et ses « news » :D.

Quelques personnalités importantes du monde Raku

Avant de rentrer plus en détail dans le processus de renommage et dans les versions de Raku, mettons à l’honneur quelques personnalités du monde Raku :

  • Jonathan Worthington : Lead développeur actuel de Rakudo (interview Jonathan Worthington)
  • Elizabeth Mattijsen : très impliquée dans Perl 6 ;
  • Patrick Michaud : ancien lead développeur de Rakudo, NQP, etc. ;
  • Audrey Tang : actuellement ministre du numérique à Taïwan (!), anciennement développeuse principale de Pugs (implémentation de Perl 6 en Haskell, voir vieille interview ou encore cette interview) ;
  • Damian Conway : enseignant, orateur, porte‑parole et développeur prolifique ;
  • Larry Wall : créateur de Perl (BDFL) et initiateur de Raku. Plus besoin de le présenter ! En 2020, plus vraiment impliqué ;
  • Moritz Lenz : écrivain et gros contributeur ;
  • Flavio S. Glock : développeur principal de Perlito.

Tous ne sont pas encore actifs et la liste n’est pas exhaustive !

La communauté Raku a décidé récemment de mettre en place un comité décisionnaire.

Le processus de changement de nom : Perl 6 → Raku

Un langage de programmation qui change de nom, ça n’arrive pas souvent !

Il y a peu, Raku a donc fêté sa première année (ou ses 21 ans !). Voici comment s’est déroulé le renommage :

  1. Larry Wall a tout d’abord proposé un alias ;
  2. alias demandé par des personnes de la communauté Perl 6 ;
  3. validé ensuite par Larry à la conférence Raku à Riga ;
  4. plus tard, une des membres de la core team (Elizabeth Mattijsen) ouvre un ticket sur le GitHub officiel de Raku pour un renommage : Rapport de bogue d’Elizabeth
  5. Elizabeth ouvre ensuite une demande d’intégration sur le dépôt Git officiel de Raku (avec demande de vote des mainteneurs) : Demande d’intégration Git d’Elizabeth
  6. les votes sont positifs (ou des abstentions), puis vient la « bénédiction » de Larry Wall : Commentaire de Larry Wall
  7. renommage entériné, souhaitons la bienvenue à Raku !

Le processus de renommage en liens :

Versions de Raku(do)

Depuis 2015, l’implémentation de Raku est « complète » et les travaux autour du compilateur et de la VM sont plus orientés vers les performances.

Raku a connu plusieurs versions officielles (dont la plus « marquante » était en 2015) :

  • première version publique de Rakudo * en juillet 2010 (version majeure mais incomplète, encore basée sur Parrot donc Rakudo + Parrot) ;
  • 6.c « Christmas » en 2015 (annonce) (Rakudo + MoarVM) ;
  • 6.d « Diwali » en novembre 2019 (détails des nombreux changements) (Rakudo + MoarVM) ;
  • 6.e sera la prochaine version majeure (Rakudo + MoarVM).

D’où provient ce schéma de versions ?

Tout simplement d’une blague récurrente sur la date de sortie de Raku. Il était coutume de répondre « ça sera prêt pour Noël » comme une blague ou une pirouette :D En plus de ces versions majeures, l’équipe derrière Raku produit des versions mineures mensuelles.

Quelques livres

Avant d’attaquer les détails du langage, voici quelques livres qui vous permettront d’en apprendre plus sur Raku :

La partie technique commence ici, vous êtes prêts ? :D

Les qualités intrinsèques de Raku

On ne se refait pas ! Grâce aux qualités de linguiste de son créateur Larry Wall, Raku est très influencé par le langage naturel. Raku est multi‑paradigmes (procédural, fonctionnel, programmation concurrente et orienté objet).

Comme son cousin Perl 5 :

  • c’est un langage riche et qui a une notion de « contexte » ;
  • ses expressions rationnelles sont très puissantes et il intègre même une gestion des grammaires directement dans le langage !
  • il possède un CPAN.

Contrairement à lui :

  • l’interfaçage avec le code natif est très simple ;
  • la programmation orientée objet est native (cadriciel + types objets) ;
  • le langage est résistant à la concurrence ;
  • Unicode est pris en charge « par défaut ».

Pour des détails techniques supplémentaires, voici le glossaire de Raku mais également une comparaison des fonctionnalités entre les compilateurs (qui donne un bon aperçu des fonctionnalités du langage). Dans les prochains paragraphes, les qualités/fonctionnalités de Raku seront expliquées plus en détail.

Le typage

  • Typage graduel (typage dynamique et statique) :
# Dynamique 
my Cool $var = 42;

# Statique 
my Str $var = "Raku";
  • Annotation dans les signatures :
sub ab(Int $a, Int $b) { return $a+$b; }; 
say ab(1,1);
  • Inférence de type
  • Allomorphs (et évaluation polymorphique) : IntStr $foo
  • Les jonctions :
my $jonction = 1|2|3;
$jonction += 4; # jonction maintenant égale à 5|6|7
$jonction += (1&2); # jonction maintenant égale à (6|7|8)&(7|8|9)
  • Sous‑ensembles : permet d’étendre les classes isomorphes, servir de contrainte, tout en étant résolu à l’utilisation :
subset Even where * %% 2;  
say 1 ~~ Even; # False
sub i-cast(Int() $n) { say $n.^name } ; 
i-cast "42";

Contrainte + coercition (« je veux un objet chaîne et je caste en objet entier ») :

sub f(Int(Str) $want-int, Str() $want-str) { } ;
f '10', 10;

Ou contrainte conditionnelle (« mon argument doit être objet entier ou objet chaîne ») :

sub xyz($n where $_ ~~ Int | Str ) { say +$n }
  • Types natifs :
my int8 $verysmall = 42; 
say $verysmall;
  • Auto‑boxing : conversion automatique de type natif vers les types objets
  • Auto‑vivification dans les hash/arrays :
my %a; 
%a{'autovivication'}++; 
say %a{'autovivication'};
my @list = (1, 1, * + * ... *).grep({ $_.is-prime });
say @list[4]; # This generates elements 0..4. 
# Elements 5..∞ haven't been generated yet

Routines

  • Nommées (argument) :
sub plus2($foo) { return $foo+2; }
  • Typées :
sub mul3(Int $foo) { return $foo*3; }
  • Avec attribut rw ou copy :
sub make42($foo is rw) { $foo = 42; }
  • Multi‑dispatch :
multi sub sayit( Int $n ) { say "Number: $n"; } 
multi sub sayit( Str $s ) { say "String: $s"; }

Le dispatch se base sur le nombre d’arguments, les types, les contraintes (on peut même en jouer avec les fonctions nextsame, nextwith, callsame, callwith). Voir aussi « Proper narrowness analysis » pour la résolution du meilleur candidat.

  • Gobage gourmand des arguments restants et aplatissement des arguments (comme en Perl 5).

Opérateurs

  • Raku possède une grande quantité d’opérateurs, voyez plutôt : Tableau périodique des opérateurs
  • Raku peut être facilement étendu (voir doc opérateurs) ;
  • opérateurs natifs (inline optimisations ou explicite) ;
  • les opérateurs peuvent être en UTF‑8 ;
  • opérateurs natifs.

Async, parallélisme et concurrence

Une boîte à outils plus que complète de fonctionnalités pour gérer l’asynchrone, le parallélisme et la concurrence :

Programmation Orientée Objet et Programmation Meta Objet

Possibilité de définir ses propres opérateurs (vu plus haut) et fonctionnalités. La prise en charge du meta object programming est gérée en partie dans la machine virtuelle :

  • héritage simple ou multiple ;
  • introspection ;
  • « éditer » une classe après instanciation une classe après déclaration/instanciation ;
  • composer/encapsuler des méthodes ;
  • Trust relationship qui permet d’accéder à des méthodes privées d’une autre classe (parente) sans les faire rentrer dans l’héritage ;
  • délégations has $.base is rw handles <meth1 meth2> ;
  • type whatever « * » (qui a d’ailleurs donné son nom a la distribution « Rakudo star »).

Grammaires

Une gestion des grammaires (grammar, token, rule, regex) dans le langage !

grammar Calculator {
    token TOP { <calc-op> }

    proto rule calc-op          {*}
          rule calc-op:sym<add> { <num> '+' <num> }
          rule calc-op:sym<sub> { <num> '-' <num> }

    token num { \d+ }
}

class Calculations {
    method TOP              ($/) { make $<calc-op>.made; }
    method calc-op:sym<add> ($/) { make [+] $<num>; }
    method calc-op:sym<sub> ($/) { make [-] $<num>; }
}

say Calculator.parse('2 + 3', actions => Calculations).made;

Interfaçage

La prise en charge du langage natif est vraiment très facile !

  • Interfaçage facile avec les langages natifs (Native Call) :
use NativeCall; sub fork() returns int32 is native {};
use Inline::Perl5;
my $p5 = Inline::Perl5.new;
$p5.call('print', 'Hello World');
$p5.use('Test::More');
$p5.call('Test::More::plan', tests => 1);

Unicode traité au niveau graphème

Très haut niveau de gestion d’Unicode, notamment grâce à des primitives dans la machine virtuelle MoarVM.

Les opérateurs du langage eux‑mêmes peuvent être en UTF‑8 (comme ceux que l’on crée).

Autres fonctionnalités en vrac

my $cube = -> $x {$x ** 3};
say $cube(3); # 27

Par ordre alphabétique :

my $pow = {$^x ** $^y};
say $pow(3, 4); # 81

Ou alors :

for 0..9 {
    say "$^n2, $^n1";
}

Ou avec nommage :

my $pow = {$:base ** $:exp};
say $pow(:base(25), :exp(2)); # 625

Compilateurs, cadriciels et machines virtuelles

Dans cette seconde partie, nous allons détailler les mises en œuvre du langage Raku. Préparez‑vous, les acronymes arrivent !

Lettre de scrabbleLicence Creative Commons CC0 1.0

Quelle implémentation « officielle » ?

Réponse courte : Rakudo et MoarVM.

Au départ il fut décidé qu’aucune implémentation ne serait définie comme « officielle » pour Raku mais plutôt que « Raku est quelque chose qui réussit la suite de tests officiels ». En réalité, depuis 2012, il existe une implémentation officielle de facto qui est Rakudo + MoarVM.

Avant ça, il y eut le cadriciel Parrot (2002 - 2012) ainsi que Pugs (2005 - 2007) ou encore divers autres compilateurs et environnements d’exécution (Mildew, Niecza, Yapsi…). Cette partie technique et historique sera abordée en fin de dépêche. Mais revenons en arrière pour parler des débuts.

La toute première annonce de la création de Raku date du 19 juillet 2000. L’idée de Larry Wall était d’en faire un projet ultra communautaire jusque dans la conception du langage, et il commencera donc par demander de contribuer aux spécifications. Il en découlera en tout 361 RFC, dont Larry wall produira des apocalypses qui seront expliquées ensuite par Damian Conway dans les exégèses puis encore détaillées dans les synopses.

RFC Apocalypses Synopses

Des liens pour les historiens ou les curieux :

Parrot

Créés en 2002, le cadriciel et la machine virtuelle Parrot ont longtemps été au centre de l’implémentation de Raku (ce n’est plus le cas aujourd’hui). Parrot est né d’un poisson d’avril annonçant l’unification de Perl et Python et même la sortie prochaine d’un livre sur le sujet :

Annonce de l’unification de Perl et Python

Pourquoi construire une nouvelle VM ?
La JVM fut étudiée en 2001, mais jugée peu adaptée aux langages dynamiques (elle ne l’était d’ailleurs toujours pas en 2010, quid de 2020 ?).

Compilation

Parrot offre bien plus d’une machine virtuelle, Parrot est un cadriciel de création, compilation et exécution de langage. Ce cadriciel permet de construire facilement et rapidement des langages de haut niveau (HLL). Il a été mis en pratique par Rakudo pendant longtemps.

PCT

PCT signifie Parrot Compiler Tools. Son but est de permettre la création de compilateur et d’environnement d’exécution de langages de haut niveau (HLL).

PCT

PCT est écrit en PIR (voir plus loin section assemblage).

PAST

PAST signifie Parrot Abstract Syntax Tree : représentation interne d’un arbre syntaxique.

HLL

HLL signifie High Level Language.

PGE

Au départ appelé P6GE, PGE signifie Perl Grammar Engine. Se base sur HLLCompiler. Une règle PGE ressemble à ça :

rule term   { <number> | \( <expr> \) }
rule number { \d+ }
rule expr   { <term> ( '+' <term> )* }

PGE était utilisé par Pugs, un autre compilateur Raku (voir plus loin).

TGE

TGE signifie Tree Grammar Engine.

PACT

PACT signifie Parrot Alternate Compiler Toolkit. Une alternative à PCT qui était considéré comme trop limité.

Assemblage

PASM

PASM signifie Parrot assembly language (PASM). Le code bas niveau prêt à être converti et exécuté par Parrot VM. Du code PASM ressemble à ça :

  set     I1, 1
REDO:
  gt      I1, 10, END
  print   I1
  print   " "
  inc     I1
  branch  REDO
END:
  print "\n"
  end

Références :

IMCC

IMCC signifie Intermediate Code Compiler. C’est un outil alternatif pour créer et exécuter du bytecode Parrot.

IMCC apporte son propre langage, communément appelé Parrot Intermediate Language (PIR). IMCC embarque le l’environnement d’exécution Parrot, donc IMCC peut compiler du PIR vers PASM, puis du PASM vers PBC, puis exécuter ce bytecode. IMCC peut également faire des optimisations, même s’il ne le fait pas par défaut.

PIR

D’abord appelé IMC, PIR est une surcouche de PASM sans être pour autant un langage de haut niveau. Les fichiers contenant du code PIR portent le suffixe « .imc »

Voici à quoi ressemble PIR :

.sub loopy
        .local int counter
        counter = 0
LOOP:   if counter > 10 goto DONE
        print counter
        print " "
        inc counter
        goto LOOP
DONE:
        print "\n"
        end
.end

Vous pouvez en apprendre plus grâce à cette intro IMCC ou cet article sur comment écrire du PIR. Voir ici des exemples PIR ou encore la documentation détaillée des mongueurs FR sur PIR.

Exécution

NCI

NCI signifie Native Call Interface.

PMC

PMC signifie PolyMorphic Container ou Parrot Magic Cookies (la façon de représenter les données dans la machine virtuelle).

PBC

BC signife Parrot Byte Code

La VM Parrot

La VM Parrot est une machine virtuelle à base de registre, ce qui n’est pas la « norme » (par exemple JVM).

Voici quelques fonctionnalités de la VM Parrot :

  • capable de gérer les langages statiques et dynamiques ;
  • Copy On Write ;
  • gère les continuations et closures ;
  • peut être embarqué dans du code C ;
  • PolyMorphic Container (souplesse du stockage des types).

Il est facile d’inclure Parrot dans du code C ou d’appeler du C dans Parrot (Native Call Interface).

Implémentation Raku basée sur Parrot (2002 - 2012)

PCT IMCC ParrotVM

Ou avec une étape IMCC et Parrot fusionnée (plus tard car IMCC contient Parrot) :
PCT IMCC

Ci‑dessous un schéma encore plus détaillé/technique (tiré d’une documentation Parrot) :
Fonctionnement de Parrot

De nombreux détails sont disponibles dans le Parrot Design Document.

Problèmes avec Parrot

Si au départ Parrot était au centre de Raku, cela a changé au cours du temps :

  • 2008 : « While Parrot is the most solid solution to deploy Perl 6 in the long term, on the other hand, the challenges Parrot has accepted had proven to consume more time and resources than previously expected. » (Perl foundation news) ;
  • 2013 : « The latest news is that Parrot Virtual Machine is no longer the only one enjoying Rakudo’s exclusivity. » (all about Perl 6) ;
  • des problèmes de communication ;
  • Parrot s’est petit à petit éloigné de Perl 6 (en devenant plus généraliste).

Petit à petit, le compilateur Rakudo s’est émancipé de Parrot et cible à présent une nouvelle machine virtuelle.

Rakudo Star (à partir de 2010)

La première version majeure de Rakudo Star (ou « Rakudo * ») se basait sur Parrot (PCT + ParrotVM), mais nous passerons sous silence cette version pour nous concentrer sur l’implémentation actuelle (Rakudo + MoarVM).

Compilation (Rakudo)

Rakudo est un compilateur pour Raku qui implémente la totalité du langage et peut cibler plusieurs différentes VM (la principale étant MoarVM). La majeure partie de Rakudo est écrite en Raku simplifié (NQP). Rakudo implémente également la précompilation pour optimiser ses performances. En plus de ça, Rakudo améliore l’arbre syntaxique à l’aide de plusieurs méthodes d’optimisations dont voici quelques exemples :

  • les itérations range converties sont en boucles natives ;
  • dé‑virtualisation de méthodes privées avec résolution à la compilation ;
  • suppression de code (statiquement) mort ;
  • anonymiser une variable ;
  • réduire la portée d’une variable ;
  • dépliage des jonctions.

NQP

NQP est un compilateur comme MiniPerl pour Perl 5. C’est un outil de bootstrapping qui aide à compiler les parties en Raku de Rakudo) et compiler les bibliothèques avant d’avoir compilé les bibliothèques. Contrairement à MiniPerl pour Perl 5 (qui est un interpréteur sans toutes les piles : c’est‑à‑dire sans les modules mélangeant code Perl et code natif), NQP ne sait compiler qu’un « Raku simplifié ». NQP designe aussi bien le compilateur que le code source contenu dans des fichiers portant l’extension « .nqp ». Du code NQP ressemble à ça :

method symtable() {
    %!symbol := nqp::hash() if nqp::isnull(%!symbol);
    %!symbol
}

method evaluate_unquotes(@unquotes) {
    my $result := self.shallow_clone();
    my $i := 0;
    my $elems := nqp::elems(@(self));
    while $i < $elems {
        $result[$i] := self[$i].evaluate_unquotes(@unquotes);
        $i := $i + 1;
    }
    $result
}

NQP fait partie de Rakudo et semble avoir été inspiré par MiniPerl6/KindaPerl6.

Exécution (MoarVM)

MoarVM signifie Metamodel On A Runtime VM (site officiel). C’est une machine virtuelle basée sur les registres comme Parrot. Jonathan Worthington est le fondateur et architecte de MoarVM.

Voici quelques caractéristiques de MoarVM :

  • représentation interne plus proche de Raku (par rapport à Parrot) (« On the other hand, there are features that are hard to implement efficiently if the VM doesn’t support it. », d’après une interview de Flavio Glock) ;
  • superbe gestion d’Unicode, avec les chaînes de caractères représentées au niveau graphème ;
  • gestion de la programmation asynchrone et concurrente avec des structures de contrôles pour la programmation concurrente, les sockets synchrones, minuteurs, processus, sémaphores, files bloquantes, etc.
  • ramasse‑miettes précis, générationnel (jeunes → semispace et vieux → gros buckets) et gérant la concurrence ;
  • capable de gérer les continuations ;
  • bounded serialization, sérialiser le code des modules chargés pour plus tard et gagner du temps de démarrage en évitant de reconstruire les représentations intermédiaires de ce code ;
  • runtime loading of code ;
  • optimisations : tail call éliminations (ne pas empiler dans la pile d’appel si le retour de fonction est dans l’appel), dispatch, élimination de code mort, on stack replacement (remplacement sur la pile de routine non optimisée par une routine optimisée), escape analysis (transformer des allocations de tas en allocation sur la pile ou même dans un registre) et scalar replacement (élimine des allocations mémoire) ;
  • JIT compilation ;
  • profilage de la pile d’appel et des allocations ;
  • heap snapshotting V : principalement pour analyses ultérieures (investigation et amélioration du ramasse‑miettes, par exemple).

Je conseille également la lecture de cette introduction de MoarVM.

MAST

MAST signifie MoarVM AST (arbre de syntaxe abstraite).

MBC

MBC signifie MoarVM Byte Code. Voici à quoi ressemble MBC :

; Grab value out of Scalar
decont r4, r1 

; Grab type ; de-Scalar if needed
wval r5, 1, 34
decont r3, r5  

; Ensure arg is an Int
istype r6, r4, r3
assertparamcheck r6

Implémentation basée sur Rakudo + MoarVM (depuis 2012)

MoarVM ne possède pas d’assembleur.

Rakudo Moar

Ci‑dessous un autre schéma d’architecture tiré d’une présentation sur les optimisations Rakudo/MoarVM (2014) :
Architecture Rakudo

Pugs (2005 - 2007)

À partir d’ici on commence l’archéologie, la vraie.

Dans sa courte existence, Pugs a exploré de nombreux choix d’architecture. Pugs désigne l’interpréteur, le compilateur, l’environnement d’exécution et la suite de tests. Le compilateur peut compiler en Haskell, JavaScript, Perl 5 ou PIR (pour Parrot, donc, si vous vous souvenez).

Pusg compilation flow

Pugs est écrit en Haskell et tombe en sommeil après 2007.

Compilation

Voici les notions de compilations autour de l’implémentation Pugs.

PCR

PCR signifie Pugs Compiler Rules. C’est une implémentation en Perl 5 du moteur d’expressions rationnelles de Raku. PCR a remplacé PGE dans Pugs.

LREP

LREP a évolué en Pugs::Compiler, puis, plus tard, MiniPerl6.

Pugs::Compiler

Pugs::Compiler est un ensemble de modules Perl 5 pour compiler Raku.

MiniPerl6

Faisait partie de Pugs mais dans un répertoire séparé. MiniPerl6 est devenu KindaPerl6 puis Perlito6.

KindaPerl6

KindaPerl6 ou KP6 est une implémentation Raku de la grammaire en Raku avec un bootstrap en Perl 5. KindaPerl6 est construit à partir de MiniPerl6.

Exécution

PIL

PIL signifie Pugs Intermediate Langage. PIL n’est pas un format lisible par les humains mais plutôt un arbre syntaxique abstrait interne à Pugs.

PIL-Run

Pugs PIL Perl

PIL-Run a été construit sur un ensemble de modules Perl 5 qui lisent et exécutent PIL. PIL-Run était le back‑end en Perl 5 de Pugs… au début.

Implémentations basées sur Pugs

Pugs + back‑ends variés

« Pugs compile et exécute »
Pugs compile et exécute

« Pugs compile pour Parrot (PIR) »
Pugs PIR

La compilation vers PIR se fait en deux temps, petit zoom dessus :
Pugs PIL PIR

« Pugs compile (transpile ?) vers du JavaScript »
Pugs JS

« Perl compile (transpile ?) vers du Perl 5 »
Pugs Perl 5

v6

v6-pugs puis v6-alpha et à présent v6.pm est une réécriture complète de Pugs, utilisant un mélange de Raku (Pugs::Compiler et les modules associés) et Perl 5. Il réutilise du code de l’environnement d’exécution de PIL-Run et « la moitié du CPAN ». À présent v6 est distribué dans Perlito6. v6.pm est le frontal de Perlito et Pugs en Perl 5.

Perlito

Le projet Perlito est mené par Flavio S. Glock. Le projet Perlito contient en fait plusieurs compilateurs pour plusieurs langages dans plusieurs langages ciblant des back‑ends variés :

  • compiler du Perl 5 vers du code source Java ;
  • exécuter du Perl 5 directement dans la JVM ;
  • compiler du Perl 5 vers du code source JavaScript, exécute Perl 5 directement dans le navigateur ou Node.js ;
  • compiler du Raku vers du code source JavaScript, exécute Perl 6 directement dans le navigateur ou Node.js ;
  • compiler du Perl 5 vers Perl 5 ;
  • compiler du Raku vers Perl 5 ;
  • compiler du Raku vers Python 2.6 ;
  • compiler du Perl 5 vers Perl 6 (en cours) ;
  • compiler du Raku vers Ruby 1.9 (en cours) ;
  • compiler du Raku vers Go (en cours) ;
  • compiler du Raku vers Common Lisp (SBCL) (en cours).

Une chose qu’il ne sait pas faire, c’est traduire du Perl 5 en Raku.

MiniPerl6 et KindaPerl6 forment Perlito6. Perlito5 est un portage de Perlito6 en Perl 5. C’est « Perl 5 implémenté en Perl 5 ». Perlito5 lui‑même est écrit en Perl. Perlito6, quant à lui, est écrit en Raku.

Perlito implémente seulement un sous‑ensemble de Raku nommé le « sous‑ensemble utile » et qui :

  • nʼa pas de contexte de liste ;
  • nʼa pas d’héritage ;
  • nʼa pas de paresse ;
  • a des closures mais pas de coroutines ou de continuations ;
  • nʼa pas de multis.

Autres compilateurs, environnements d’exécution et machines virtuelles

Dans cette partie, nous allons continuer notre tour des initiatives autour des compilateurs, environnements d’exécution et machines virtuelles historiques.

STD et viv

STD et viv sont des œuvres de Larry Wall.

On trouve dans STD la grammaire de Raku… écrite en Raku (qui n’avait pas de compilateur à l’époque ! C’est le début des problèmes de bootstrapping :D).

VIV ou littéralement en chiffres romains « VI → V » (et donc « 6 vers 5 ») était un module capable de convertir du Perl 6 vers du Perl 5.

SMOP

D’abord appelé YAP6, SMOP signifie Simple Meta Object Programming.

SMOP est un compilateur et environnement d’exécution écrit en C pour Raku, mais on dit parfois SMOP pour désigner seulement l’environnement d’exécution (qui peut être ciblé par d’autres compilateurs).

SMOP YAP6

SMOP n’est pas une machine virtuelle mais un environnement d’exécution qui ressemble à celui de Perl 5, tout en possédant des fonctionnalités pour gérer Raku.

Mildew

Mildew était un compilateur STD vers SMOP

Mildew SMOP

Il utilise directement la grammaire STD.

Elf

Elf était un compilateur écrit en Raku avec une grammaire en Ruby. Il pouvait émettre du Perl 5 ou du Lisp. Il n’a jamais été complété. Il était prévu qu’Elf puisse cibler SMOP.

Ponie

Ponie signifie Perl On a New Internal Engine. Il s’agissait de faire tourner Perl 5 dans la machine virtuelle Parrot. Arrêté en 2006.

Ponie

Punie

Punie (référence directe à Ponie) était un compilateur Perl 1 vers Parrot.

Yapsi

Yapsi pour Yet Another Perl Six Implementation est une implémentation du compilateur et de ses environnements d’exécution et machines virtuelles Raku en Raku.

Yapsi

SIC signifie (S??) Instruction Code, c’est du byte code propre à Yapsi.

Niecza

Niecza est un compilateur Raku écrit en C# qui cible CLR (Mono).

Niecza Mono

Ouf ! C’était le dernier, on a fini. :)

Conclusion

Après une longue période de gestation, le langage Raku est à présent complet et mature et a donc été publié. Raku fait preuve d’une grande expressivité et d’une grande puissance. On trouve de nombreux concepts intéressants dans Raku comme dans son histoire et celle de ses implémentations (même si la plupart font partie d’un monde disparu) qui méritaient qu’on s’y penche un peu.

J’espère que cette dépêche aura su lever le brouillard autour des méandres d’implémentations de Raku et mettre en valeur les concepts du langage.

Aller plus loin

  • # Qui de Raku ou de Perl

    Posté par  . Évalué à 2 (+3/-2).

    Perl 7 et Raku restent assez proche et touchent une part décroissante de programmeurs. Cette division sur un langage qui est plutôt en perte de vitesse risque de les tuer tous les 2. Ils entrent en concurrence avec Python, PHP et bien d autres plus clair dans leur principes et cibles. Il faut arrêter l un et se concentrer sur l autre non?

    Je ne connais pas bien mais je trouve Raku verbeux au moins pour la déclaration de variable "my Str $var". Le dollars pour dire que c est une variable, le my pour dire la même chose et le Str pour préciser la ou tout les autres se contentent d un seul des 3.

    • [^] # Re: Qui de Raku ou de Perl

      Posté par  . Évalué à 5 (+4/-0).

      je trouve Raku verbeux au moins pour la déclaration de variable "my Str $var"

      Tu as lu en diagonale, non ? :-)

      • my indique une portée, ce n'est pas réservé aux variables
        • on peut écrire my $var comme my @list ou my %hash ou …
      • Str est un type facultatif
      • c'est $var qui indique une variable
    • [^] # Re: Qui de Raku ou de Perl

      Posté par  . Évalué à 5 (+4/-0).

      Perl 7 et Raku restent assez proche et touchent une part décroissante de programmeurs. Cette division sur un langage qui est plutôt en perte de vitesse risque de les tuer tous les 2. Ils entrent en concurrence avec Python, PHP et bien d autres plus clair dans leur principes et cibles. Il faut arrêter l un et se concentrer sur l autre non?

      Tu arrives après la bataille ; la communauté a débattu tous les points possibles et imaginables dessus 😉
      Perl 7 sera le successeur de Perl 5 (on saute une version comme PHP) …qui n'est pas vraiment en perte de vitesse à mon avis.
      Raku est une autre bête qui se fait sa place doucement. Son côté caméléon fait qu'il n'entre pas vraiment en concurrence avec les autres ; il va plutôt les remplacer progressivement 😁 Merci à cette dépêche pour la liste de livres ; je suis preneur de commencer à dompter le truc pour ne plus avoir à basculer entre divers interpréteurs (si je me suis pas perdu en cours de route dans la dépêche)

      -- en mode weekend.

      • [^] # Re: Qui de Raku ou de Perl

        Posté par  . Évalué à 8 (+5/-0).

        Dans quel genre de code Raku est utilisé ? Qui l'utilise ? Y'a-t-il déjà une killer App en Raku comme Docker l'est pour Go ?

        "La première sécurité est la liberté"

        • [^] # Re: Qui de Raku ou de Perl

          Posté par  . Évalué à 1 (+1/-1).

          Dans quel genre de code Raku est utilisé ?
          

          Partout où ses utilisateurs le jugent utile, je pense.
          En tout cas pas là ou la vitesse d'exécution est un bottleneck.

          Qui l'utilise ?
          

          Eux
          Eux autre lien

          Y'a-t-il déjà une killer App en Raku comme Docker l'est pour Go ?
          

          Non, pas à l'échelle de Docker.
          Pourquoi ? C'est important ?

    • [^] # Re: Qui de Raku ou de Perl

      Posté par  (site Web personnel) . Évalué à 5 (+3/-0).

      Perl 7 et Raku restent assez proche et touchent une part décroissante de programmeurs. Cette division sur un langage qui est plutôt en perte de vitesse risque de les tuer tous les 2. Ils entrent en concurrence avec Python, PHP et bien d autres plus clair dans leur principes et cibles. Il faut arrêter l un et se concentrer sur l autre non?

      Ben dis-donc tu commences fort la semaine !

      Perl 7 c'est juste le nouveau nom de Perl 5.32, donc dans la continuité du bien connu Perl. Le saut de la version 5 vers 7 est une excellente, amha, clarification : Ce qu'est Raku était nommé Perl 6, il y a pas mal de temps déjà, mais vu les grosses différences avec la version 5 il a été décidé de changer de nom, car Raku est quand même sacrement différent de Perl 5. Tu dis toi-même que tu ne connais pas bien.

      Il faut ajouté que choisir de changer de version majeur pour Perl (5 vers 7) a été choisi pour imposer inclure de bonnes pratiques pour ce langage : le mode strict par exemple.

      un langage qui est plutôt en perte de vitesse

      T'inquiètes Perl's not dead.

      « Il vaut mieux mobiliser son intelligence sur des conneries que mobiliser sa connerie sur des choses intelligentes. »

      • [^] # Re: Qui de Raku ou de Perl

        Posté par  (site Web personnel) . Évalué à 4 (+2/-0).

        Souvent on annonce un langage comme mort, mais si le pourcentage descend, la valeur absolue pas forcément !

        awk, tcl… ne sont pas mort. Et il y a peut-être plus d'utilisateur en 2020 que dans les années 80. Bref, une perte de vitesse n'est pas forcément gênante. En tant qu'admin système, j'aime bien que mes scripts écrits il y a 20 ans tournent toujours quasi tel quel car ils étaient bien écrits et fonctionne toujours très bien.

  • # Questions suivantes: shell, types, déploiement… ?

    Posté par  . Évalué à 5 (+3/-0).

    Salut,

    Merci pour toutes ces infos.

    Pour aller au-delà de la syntaxe: la vie d'un développeur Raku est-elle confortable ? Le shell interactif est-il bien interactif ? (entre IPython et Lisp peut-etre ?) Le typage donne-t-il de bonnes informations ? (et si on ne type pas, a-t-on des warnings du compilateur malgré tout ?) Est-ce que déployer une application ou la livrer à un utilisateur est plus plaisant qu'avec Python ? (stabilité de l'écosystème, outils de déploiement… peut-on construire un exécutable ?)

    • [^] # Re: Questions suivantes: shell, types, déploiement… ?

      Posté par  . Évalué à 3 (+2/-0).

      N'étant qu'un modeste utilisateur du langage, mes réponses seront tout autant modestes:

      Pour aller au-delà de la syntaxe: la vie d'un développeur Raku est-elle confortable ?
      

      Il n'y a pas beaucoup de devs pros à plein temps sur Raku, à part ici https://www.edument.se/, pour le reste (dont moi qui scriptouille "for fun") voilà tout ce que je peux dire: l'IDE est de bonne qualité (il y a aussi des modules de syntaxe pour vim, emacs et nano), la communauté est sympa, et le langage est activement développé.

      Pour le typage, vu qu'il est "dynamique", je ne type mes variables qu'une fois mon script finit et testé, pour l'information sur les types la méthode .WHAT est très utile.
      D'après les docs la vérif de typage se fait au runtime et au compile type (je n'ai pas été plus loin que ça).

      Exemple de typage et retours d'erreurs sur le REPL (hors du REPL l'erreur renvoie la ligne et le module):

      > my Str $chaîne = 42
      Type check failed in assignment to $chaîne; expected Str but got Int (42)
        in block <unit> at <unknown file> line 1
      > my Rat $rat = 1/10
      0.1
      > $rat / 10
      0.01
      > say "$rat / 10"
      0.1 / 10
      > say "{$rat / 10}"
      0.01
      > "{$rat / 10}".WHAT
      (Str)
      > {$rat / 10}.WHAT
      (Block)
      > ($rat / 10).WHAT
      (Rat)
      

      La conversion à la volée de type est assez logique et est en train d'être améliorée (cf ici)

      Le REPL n'est pas finit et a encore pas mal de bugs, mais pour tester du code vite fait il est largement suffisant (pour moi).

      Pour le déploiement en binaire, c'est pas possible et je pense que ce n'est pas à l'ordre du jour.

      Les quelques apps Raku en bundle sont distribuées dans des containers Docker.

      En ce qui concerne la comparaison avec Python, je peux pas dire (en dehors de quelques scripts codés dans du venv, mon Python est assez pauvre).

      Voilà !

  • # JVM et langages dynamiques

    Posté par  . Évalué à 1 (+0/-0).

    La JVM fut étudiée en 2001, mais jugée peu adaptée aux langages dynamiques (elle ne l’était d’ailleurs toujours pas en 2010, quid de 2020 ?).

    C'est vieux 2001 :-) Mais en 2010, il y avait déjà Groovy (2003) et Clojure (2007). Je les cite mais je ne sais pas si on peut compter Jython (1997) et JRuby (2001) ?

    Par contre, c'est vrai que Golo n'était pas encore prêt (2012) !

    Je ne pense pas être en mesure de comprendre un article expliquant pourquoi les gens de Parrot ont estimé que la JVM n'était pas adaptée aux langages dynamiques (probablement un peu trop technique pour moi). Je vais donc me contenter d'exprimer mon étonnement. Et constater que tout le monde n'avait pas l'air d'accord avec eux à cette époque :-)

    Rakudo est un compilateur pour Raku qui implémente la totalité du langage et peut cibler plusieurs différentes VM (la principale étant MoarVM).

    La JVM est une des cibles, si j'ai bien lu Wikipédia :-)

    • [^] # Re: JVM et langages dynamiques

      Posté par  . Évalué à 2 (+0/-0).

      C'est vrai la jvm n'était pas très pratique pour les langages dynamiques jusqu'à l'arrivée dynvoke dynamic pour java8. Il y avait des langages dynamiques avant, mais ils subissaient un peu.

Envoyer un commentaire

Suivre le flux des commentaires

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