Ruby

Ruby 3.3

Soumis par fredericmazue le

Le projet Ruby vient de publier une mise à jour importante du langage : Ruby 3.3. Ruby 3.3 est doté par défaut du nouvel analyseur (parser) Prism qui est maintenant prêt pour la production. Prim vient remplacer l'ancien analyseur Ripper.

Le projet Ruby a fait d'important travaux concernant la performance du langage, notammet au niveau des compilateurs JIT. Ainsi YJIT bénéficie d'améliorations majeures de performances, et arrive le compilateur RJIT, en version expérimentale pour le moment. RJIT, qui est destiné à remplacer à terme MJIT, prend en charge uniquement l'architecture x86-64 sur les plates-formes Unix à ce jour. Il est à remarquer que RJIT, contrairement à MJIT, ne nécessite pas de compilateur C au moment de l'exécution.

On remarque encore l'introduction du planificateur de threads M:N. Avec lui, les threads M Ruby sont gérés par N threads natifs (threads OS), ce qui réduit les coûts de création et de gestion des threads. En revanche, le projet Ruby signale que cela peut rompre la compatibilité des extensions C.

Toutes les nouveautés de Ruby 3.3 peuvent être retrouvées dans sa note de version.

Sortie de Ruby 3.0 en version finale

Soumis par fredericmazue le

Après une version Release Candidate publiée fin décembre 2020, le projte Ruby annonce la sortie de Ruby 3.0 en version finale. Cette nouvelle version est l'aboutissement d'une évolution entamée ne 2015.

L'équipe est fière du travail accompli et souligne que Ruby 3.0 est trois fois plus rapide que Ruby 2.0. Ceci selon le benchmark Optcarrot. https://github.com/mame/optcarrot

Hormis l'aspect performance, Ruby 3.0 est une évolution importante du langage Ruby. Parmi les nouveautés majeures, remarquons tout d'abord l'arrivée de RBS. RBS est un langage pour décrire les types dans les programmes Ruby. Les vérificateurs de type, y compris TypeProf et d'autres outils prenant en charge RBS, comprendront beaucoup mieux les programmes Ruby avec les définitions RBS, assure le projet Ruby.

RBS prend en charge les modèles couramment rencontrés dans les programmes Ruby et il permet aussi d'écrire des types avancés, y compris les types d'union, la surcharge de méthode et les génériques. Il prend également en charge les types d'interface. Ruby 3.0 est donc livré avec rbs gem. Voici un petit exemple de RBS avec des définitions de classe, de module et de constante.

module ChatApp
  VERSION: String
  class Channel
    attr_reader name: String
    attr_reader messages: Array[Message]
    attr_reader users: Array[User | Bot]              # `|` means union types, `User` or `Bot`.
    def initialize: (String) -> void
    def post: (String, from: User | Bot) -> Message   # Method overloading is supported.
            | (File, from: User | Bot) -> Message
  end
end

Ruby 3.0 apporte aussi des évolutions en ce qui concerne la programmation concurrente. Tout d'abord avec l'introduction d'un ordonnanceur, le 'Planificateur de fibres', ou Fiber Scheduleur en anglais. Celui-ci est présenté comme pouvant intercepter les opérations bloquantes, ce qui permet d'obtenir une concurrence légère sans modification du code existant. Les classes et méthodes actuellement supportées par Scheduleur sont :

  • Mutex#lock, Mutex#unlock, Mutex#sleep
  • ConditionVariable#wait
  • Queue#pop, SizedQueue#push
  • Thread#join
  • Kernel#sleep
  • IO#wait, IO#read, IO#write et les méthodes relatives telles #wait_readable, #gets, #puts and so on).

A remarquer : IO#select n'est pas supporté.

Toujours en ce qui concerne la programmation concurrente, vient également Ractor, qui est au stade expérimental pour le moment. Ractor est une abstraction de programmation concurrente conçue pour fournir une fonctionnalité d'exécution parallèle sans problèmes de sécurité des threads. Sécurité des threads signifie que ceux-ci ne peuvent pas partager des objets classiques. Le travail se fait avec des objets Ractor qui communiquent entre eux via un mécanisme de messages. Le projet Ruby souligne que la spécification et l'implémentation ne sont pas matures et peuvent être modifiées à l'avenir. C'est pourquoi cette fonctionnalité est marquée comme expérimentale. Voici un petit exemple de calcul de nombres premiers en parallèle avec deux racteurs. Le projet Ruby indique que l'exécution du programme est environ x2 fois plus rapide par rapport au programme séquentiel.

require 'prime'
# n.prime? with sent integers in r1, r2 run in parallel
r1, r2 = *(1..2).map do
  Ractor.new do
    n = Ractor.recv
    n.prime?
  end
end
# send parameters
r1.send 2**61 - 1
r2.send 2**61 + 15
# wait for the results of expr1, expr2
p r1.take #=> true
p r2.take #=> true

Site : ruby-lang.org

Ruby 3.0 est disponible en version Release Candidate

Soumis par fredericmazue le

Après une préversion sortie fin septembre, le projet Ruby vient d'annoncer le disponibilité du langage en version 3.0 release Candidate.

Ruby 3.0 est une évolution importante du langage Ruby. Parmi les nouveautés majeures, remarquons tout d'abord l'arrivée de RBS. RBS est un langage pour décrire les types dans les programmes Ruby. Les vérificateurs de type, y compris TypeProf et d'autres outils prenant en charge RBS, comprendront beaucoup mieux les programmes Ruby avec les définitions RBS, assure le projet Ruby.

RBS prend en charge les modèles couramment rencontrés dans les programmes Ruby et il permet aussi d'écrire des types avancés, y compris les types d'union, la surcharge de méthode et les génériques. Il prend également en charge les types d'interface. Ruby 3.0 est donc livré avec rbs gem. Voici un petit exemple de RBS avec des définitions de classe, de module et de constante.

module ChatApp
  VERSION: String
  class Channel
    attr_reader name: String
    attr_reader messages: Array[Message]
    attr_reader users: Array[User | Bot]              # `|` means union types, `User` or `Bot`.
    def initialize: (String) -> void
    def post: (String, from: User | Bot) -> Message   # Method overloading is supported.
            | (File, from: User | Bot) -> Message
  end
end

Ruby 3.0 apporte aussi des évolutions en ce qui concerne la programmation concurrente. Tout d'abord avec l'introduction d'un ordonnanceur, le 'Planificateur de fibres', ou Fiber Scheduleur en anglais. Celui-ci est présenté comme pouvant intercepter les opérations bloquantes, ce qui permet d'obtenir une concurrence légère sans modification du code existant. Les classes et méthodes actuellement supportées par Scheduleur sont :

  • Mutex#lock, Mutex#unlock, Mutex#sleep
  • ConditionVariable#wait
  • Queue#pop, SizedQueue#push
  • Thread#join
  • Kernel#sleep
  • IO#wait, IO#read, IO#write et les méthodes relatives telles #wait_readable, #gets, #puts and so on).

A remarquer : IO#select n'est pas supporté.

Toujours en ce qui concerne la programmation concurrente, vient également Ractor, qui est au stade expérimental pour le moment. Ractor est une abstraction de programmation concurrente conçue pour fournir une fonctionnalité d'exécution parallèle sans problèmes de sécurité des threads. Sécurité des threads signifie que ceux-ci ne peuvent pas partager des objets classiques. Le travail se fait avec des objets Ractor qui communiquent entre eux via un mécanisme de messages. Le projet Ruby souligne que la spécification et l'implémentation ne sont pas matures et peuvent être modifiées à l'avenir. C'est pourquoi cette fonctionnalité est marquée comme expérimentale. Voici un petit exemple de calcul de nombres premiers en parallèle avec deux racteurs. Le projet Ruby indique que l'exécution du programme est environ x2 fois plus rapide par rapport au programme séquentiel.

require 'prime'
# n.prime? with sent integers in r1, r2 run in parallel
r1, r2 = *(1..2).map do
  Ractor.new do
    n = Ractor.recv
    n.prime?
  end
end
# send parameters
r1.send 2**61 - 1
r2.send 2**61 + 15
# wait for the results of expr1, expr2
p r1.take #=> true
p r2.take #=> true

Site : ruby-lang.org

Sortie de RubyMine 2020.3

Soumis par fredericmazue le
IDE
Image
Image

JetBrains a publié une nouvelle version de son environnement de développement intégré dédié au langage Ruby : RubyMine 2020.3.

Il s'agit d'une mouture riche dans laquelle on remarque en premier lieu la prise en charge de la nouvelle syntaxe de Ruby 3, telle que définie dans cette préversion du langage. La plupart des nouvelles fonctionnalités de langage sont prises en charge, comme par exemple les définitions de méthodes sans mot-clé end. Toutefois JetBrains souligne que le support de Ruby 3 n'est pas finalisé. Notamment, des fonctionnalités telles que l'assistance au codage et la prise en charge de RBS ne seront totalement implémentées qu'après la sortie de Ruby 3 en version définitive.

A remarquer encore, si vous travaillez sur plusieurs projets, il est possible que ceux-ci utilisent des versions différentes de Ruby. L’émulateur de terminal intégré de RubyMine utilise désormais la version de Ruby sélectionnée pour le projet en cours. Il précise également quelle est la version utilisée lorsque vous lancez une instance de terminal.

En ce qui concerne le travail avec Rails, JetBrains a simplifié l'utilisation de routes.rb. Une combinaison de touches permet de naviguer entre une route dans routes.rb et ses modèles, vues et contrôleurs associés. Une autre combinaison de touches appliquée sur une méthode dans routes.rb permet d'accéder directement à la méthode associée dans un contrôleur.

Du côté de Git, RubyMine prend désormais en charge le staging des modifications directement dans l'IDE. Vous pouvez ajouter ou retirer des fichiers à la zone de staging en cliquant sur les icônes + et - dans la vue Commit. Vous pouvez également gérer le staging depuis la gouttière ou dans la vue Diff.

Toutes les nouveautés apportées par RubyMine 2020.3 sont présentées dans ce billet de JetBrains.

Sortie de Ruby 3.0 Preview 1

Soumis par fredericmazue le

Le projet Ruby vient d'annoncer la première préversion de Ruby 3.0. Une version qui se fait remarquer par la description des types via RBS et par des fonctionnalités de programmation parallèle.

RBS est un langage pour décrire les types de programmes Ruby. Les vérificateurs de type, y compris le profileur de type et d'autres outils prenant en charge RBS, comprendront beaucoup mieux les programmes Ruby avec les définitions RBS, selon l'équipe Ruby..

RBS décrit la définition des classes et des modules: méthodes définies dans la classe, variables d'instance et leurs types, et relations d'héritage / mix-in. L'objectif de RBS est de prendre en charge les modèles couramment observés dans les programmes Ruby.  Il permet d'écrire des types avancés, notamment des types d'union, une surcharge de méthode et des génériques.

Voici un exemple d'utilisation de RBS donné sur ruby-land.org

module ChatApp
  VERSION: String

  class Channel
    attr_reader name: String
    attr_reader messages: Array[Message]
    attr_reader users: Array[User | Bot]              # `|` means union types, `User` or `Bot`.

    def initialize: (String) -> void

    def post: (String, from: User | Bot) -> Message   # Method overloading is supported.
            | (File, from: User | Bot) -> Message
  end
end

Vient également Ractor, qui est au stade expérimental pour le moment. Ractor est une abstraction de programmation concurrente conçue pour fournir une fonctionnalité d'exécution parallèle sans problèmes de sécurité des threads. Sécurité des threads signifie que ceux-ci ne peuvent pas partager des objets classiques. Le travail se fait avec des objets Ractor qui communiquent entre eux via un mécanisme de messages.

Vient encore Scheduler, également au stade expérimental. Scheduler est présenté comme pouvant intercepter les opérations bloquantes, ce qui permet d'obtenir une concurrence légère sans modification du code existant. Les classes et méthodes actuellement supportées par Scheduleur sont :

  • Mutex#lock, Mutex#unlock, Mutex#sleep
  • ConditionVariable#wait
  • Queue#pop, SizedQueue#push
  • Thread#join
  • Kernel#sleep
  • IO#wait, IO#read, IO#write et les méthodes relatives telles #wait_readable, #gets, #puts and so on).

A remarquer : IO#select n'est pas supporté.

Les responsables de Ruby soulignent que ces nouvelles fonctionnalités expérimentales sont susceptibles d'être modifiées dans la prochaine mouture du langage.

Site : ruby-lang.org

GitHub raconte son passage à Ruby 2.7

Soumis par fredericmazue le

Le service d'hébergement de code en ligne GitHub fonctionne avec le langage Ruby sous le capot. Les évolutions de ce langage ont donc des impacts sur tout le service. GitHub vient de mettre à niveau vers Ruby 2.7 et raconte que ce ne fut pas une petite affaire.

En effet, pour Ruby 2.7, l'équipe Ruby Core a déprécié le comportement des arguments de mot-clé. Avec cette évolution, les futures versions de Ruby n'accepteront plus les passages d'arguments hachés lorsqu'une méthode attend des arguments mot-clé.

Or GitHub tenait a exécuter son application sans obsolescence, notamment pour éviter de prendre du retard sur les futures mises à niveau. Cela a nécessité la correction de 11 000 avertissements dans les 400 000 lignes de code de l'application, mais aussi au sein de bibliothèques externes.

Pour effectuer tout ce travail, une stratégie a été nécessaire. Notamment GitHub a configuré son application pour qu'elle soit à double amorçage sur Ruby 2.6 et Ruby 2.7 en utilisant une variable d'environnement. Cela a facilité la tâche d'effectuer des modifications rétrocompatibles, de les fusionner dans la branche principale et d'éviter de conserver une longue branche pour la mise à niveau. 

Beaucoup de travail donc, à cause d'une évolution d'un langage de programmation... Mais pour GitHub cela présente aussi des côtés positifs. Ainsi l'application démarre désormais en 70 secondes contre 90 auparavant et elle a une empreinte mémoire plus faible avec 668k allocations d'objets contre 780k auparavant.

Sortie de Ruby 2.7

Soumis par fredericmazue le

Le langage Ruby vient de sortir en version 2.7 stable.

On y remarque principalement l'introduction du filtrage de motif à titre expérimental. Le filtrage de motif, ou pattern matching, est une fonctionnalité très répandue en programmation fonctionnelle, mais plus rare dans les langages impératifs et/ou orientés objet.

Le filtrage par motif est la vérification de la présence de constituants d'un motif dans un programme. Le filtrage par motif permet de vérifier si l'objet du filtrage possède une structure donnée, s'il s'y trouve telle ou telle sous-structure spécifique et laquelle, pour y retrouver des parties par l'organisation de leur contenu, et/ou éventuellement pour substituer quelque chose d'autre aux motifs reconnus. (Wikipedia).

Le filtrage de motif est très apprécié en programmation fonctionnelle car il apporte de la clarté et de la concision au code. Peut-on en dire autant pour Ruby ? Ce n'est pas certain à en juger par cet exemple de code.

require "json"

json = <<END
{
  "name": "Alice",
  "age": 30,
  "children": [{ "name": "Bob", "age": 2 }]
}
END

case JSON.parse(json, symbolize_names: true)
in {name: "Alice", children: [{name: "Bob", age: age}]}
  p age #=> 2
end

Aux développeurs expérimentés en Ruby d'en juger toutefois.

A remarquer aussi, l'amélioration de la boucle d'évaluation interactive (REPL pour Read Eval Print Loop). Le nouvel environnement interactif permet notamment d'éditer du code multi lignes.

A remarquer encore l'arrivée de la capacité du ramasse-miettes à défragmenter de la mémoire fragmentée et ainsi limiter l'empreinte mémoire des applications ou la dégradation de leurs performances.

Une porte dérobée découverte dans 11 gems Ruby

Soumis par fredericmazue le

Comme tous les langages de programmation, Ruby dispose d'un écosystème de bibliothèques dites gems. Ces gems, ou composants logiciels, sont gérés via le gestionnaire de paquet RubyGems.

Depuis le 14 août dernier, les responsables du projet RubyGems ont découvert une, puis 10 autres gems corrompues par une porte dérobée (backdoor). Ces portes dérobées ayant pour principale vocation d'injecter dans des applications du code Ruby faisant du minage de cryptomonnaie.

Les gems corrompues sont (au moins) :

  • rest-client: 1.6.10, 1.6.11, 1.6.12 et 1.6.13
  • bitcoin_vanity: 4.3.3
  • lita_coin: 0.0.3
  • coming-soon: 0.2.8 
  • omniauth_amazon: 1.0.1 
  • cron_parser: 0.1.4,
  • coin_base: 4.2.1 et 4.2.2 
  • blockchain_wallet: 0.0.6 et 0.0.7 
  • awesome-bot: 1.18.0 
  • doge-coin: 1.0.2 
  • capistrano-colours: 0.5.5

Comment le ou les cybercriminels ont-ils procédé ? Tout simplement (à l'exception de rest-client) en prenant une gem existante et propre sur elle, en y ajoutant le code malveillant, puis en l’uploadant sur RubyGems sous un nouveau nom.

Les cybercriminels se sont faits repérer lorsque l'un d'eux a réussi à se connecter au compte RubyGems de l'un des développeurs de rest-client, pour y déposer quatre versions malveillantes de rest-client sur RubyGems.

rest-client est une gems téléchargée 113 millions de fois. C'était évidemment un gros coup pour les cybercriminels. Mais pour eux aussi le mieux peut être l'ennemi du bien.

Sortie de Ruby 2.6, doté d'un nouveau compilateur JIT

Soumis par fredericmazue le
Image

L'équipe de développement de Ruby a annoncé la sortie de la version 2.6 stable de ce langage. Cette mouture se fait essentiellement remarquer par l'arrivée d'un nouveau compilateur Just-in-Time (JIT) expérimental.

Il est souvent reproché à Ruby ses performances médiocres, c'est pourquoi l'équipe de développement travaille la question. Ce nouveau compilateur JIT expérimental est différent de la plupart des compilateurs à la volée, qui sont des processus travaillant uniquement en mémoire.

Le compilateur JIT expérimental de Ruby 2.6 génére du code optimisé sous la forme de code C qui est écrit sur le disque du système, après quoi il lance un compilateur pour produire du code natif.

Ce compilateur JIT étant expérimental, il n'est pas activé par défaut. Il convient de l'activer explicitement en spécifiant le commutateur --jit sur la ligne de commande ou dans la variable d'environnement $RUBYOPT.

Par ailleurs, ce compilateur JIT ne peut fonctionner que si RUBY a été compilé avec GCC, Clang ou Microsoft VC++ et que le compilateur en question est accessible au runtime de JIT au moment de l'exécution.

Selon l'équipe de Ruby, le langage est 1.7 fois plus rapide grâce à ce compilateur JIT pour des travaux gourmands en CPU (benchmark Optcarrot). Mais ils font remarquer que ce compilateur JIT peut ne pas améliorer les performances d'applications du monde réel, telles que des applications web.

Un compilateur JIT arrive pour le langage Ruby

Soumis par fredericmazue le

Ruby 2.6.0-preview2 vient de sortir. Cette mouture se distingue par l'arrivée d'un compilateur JIT (Just-in-Time) pour ce langage, qui offrira donc de ce fait de bien meilleures performances à l'exécution.

Généralement un compilateur JIT génère à la volée du code natif en mémoire, à partir du code source ou d'un code-byte. Chaque fois qu'une application est chargée, le compilateur JIT se remet et travail et effectue la même opération.

Le compilateur JIT de Ruby se distingue par un mode de fonctionnement différent. Il génére, la première fois que l'application est lancée, un code C qui est écrit sur le disque du système, puis il lance un compilateur C qui va ensuite générer le code natif une fois pour toutes.

Pour activer ce tout nouveau compilateur JIT de Ruby, il suffit de donner le commutateur -jit dans la ligne de commande qui lance l'application, ou bien d'ajouter cette valeur dans la variable d'environnement $RUBYOPT. Sachant toutefois que, pour le moment, le compilateur JIT ne peut fonctionner que si votre environnement d'exécution Ruby a été compilé avec GGC ou Clang. Il faut aussi, bien évidemment, que le compilateur soit disponible au moment de l'exécution.

Ce billet tehnique détaille le fonctionnement du compilateur JIT de Ruby.