Ruby (langage de programmation)

Ruby est un langage de programmation interprété de haut niveau à usage général . Il a été conçu en mettant l'accent sur la productivité et la simplicité de la programmation. Dans Ruby, tout est un objet , y compris les types de données primitifs . Il a été développé au milieu des années 1990 par Yukihiro « Matz » Matsumoto au Japon .

Ruby est typé dynamiquement et utilise la récupération de place et la compilation juste à temps . Il prend en charge plusieurs paradigmes de programmation, notamment la programmation procédurale , orientée objet et fonctionnelle . Selon le créateur, Ruby a été influencé par Perl , Smalltalk , Eiffel , Ada , BASIC , Java et Lisp .

Matsumoto a déclaré que Ruby a été conçu en 1993. Dans un message de 1999 sur la liste de diffusion ruby-talk , il décrit certaines de ses premières idées sur le langage :

Je discutais avec mon collègue de la possibilité de créer un langage de script orienté objet. Je connaissais Perl (Perl4, pas Perl5), mais je ne l'aimais pas vraiment, car il avait l'air d'un langage jouet (c'est toujours le cas). Le langage orienté objet semblait très prometteur. Je connaissais Python à l'époque. Mais je ne l'aimais pas, car je ne pensais pas que c'était un véritable langage orienté objet – les fonctionnalités OO semblaient être des ajouts au langage. En tant que maniaque des langages et fan d'OO depuis 15 ans, je voulais vraiment un véritable langage de script orienté objet, facile à utiliser. J'en ai cherché un, mais je n'en ai pas trouvé. J'ai donc décidé de le créer.

Matsumoto décrit la conception de Ruby comme étant comme un simple langage Lisp à sa base, avec un système d'objets comme celui de Smalltalk, des blocs inspirés des fonctions d'ordre supérieur et une utilité pratique comme celle de Perl.

Le nom « Ruby » est né lors d'une session de chat en ligne entre Matsumoto et Keiju Ishitsuka le 24 février 1993, avant que le code du langage n'ait été écrit. Au départ, deux noms ont été proposés : « Coral » et « Ruby ». Matsumoto a choisi ce dernier dans un e-mail ultérieur à Ishitsuka. Matsumoto a plus tard noté un facteur dans le choix du nom « Ruby » : c'était la pierre de naissance d'un de ses collègues.

La première version publique de Ruby 0.95 a été annoncée sur les groupes de discussion japonais le 21 décembre 1995. Par la suite, trois autres versions de Ruby ont été publiées en deux jours. La sortie a coïncidé avec le lancement de la liste de diffusion ruby-list en japonais , qui était la première liste de diffusion pour la nouvelle langue.

À ce stade de développement étaient déjà présentes de nombreuses fonctionnalités familières dans les versions ultérieures de Ruby, notamment la conception orientée objet , les classes avec héritage, les mixins , les itérateurs , les fermetures , la gestion des exceptions et le garbage collection .

Après la sortie de Ruby 0.95 en 1995, plusieurs versions stables de Ruby ont été publiées au cours de ces années :

• Ruby 1.0 : 25 décembre 1996
• Ruby 1.2 : Décembre 1998
• Ruby 1.4 : août 1999
• Ruby 1.6 : septembre 2000

En 1997, le premier article sur Ruby a été publié sur le Web. La même année, Matsumoto a été embauché par netlab.jp pour travailler sur Ruby en tant que développeur à temps plein.

En 1998, Matsumoto a lancé Ruby Application Archive, ainsi qu'une page d'accueil simple en anglais pour Ruby.

En 1999, la première liste de diffusion en anglais Ruby-Talk a été lancée, ce qui témoigne d'un intérêt croissant pour cette langue en dehors du Japon. Cette même année, Matsumoto et Keiju Ishitsuka ont écrit le premier livre sur Ruby, The Object-Oriented Scripting Language Ruby (オブジェクト指向スクリプト言語 Ruby), qui a été publié au Japon en octobre 1999. Il sera suivi au début années 2000 par une vingtaine de livres sur Ruby publié en japonais.

En 2000, Ruby était plus populaire que Python au Japon. En septembre 2000, le premier livre en anglais Programming Ruby a été imprimé, puis diffusé gratuitement au public, élargissant encore l'adoption de Ruby parmi les anglophones. Début 2002, la liste de diffusion en anglais ruby-talk recevait plus de messages que la liste en japonais ruby-list , démontrant la popularité croissante de Ruby dans le monde non japonais.

Ruby 1.8 a été initialement publié en août 2003, est resté stable pendant une longue période et a été retiré du marché en juin 2013. Bien qu'il soit obsolète, il existe encore du code basé sur lui. Ruby 1.8 n'est que partiellement compatible avec Ruby 1.9.

Ruby 1.8 a fait l'objet de plusieurs normes industrielles. Les spécifications du langage Ruby ont été développées par le Centre de promotion des normes ouvertes de l'Agence de promotion des technologies de l'information (une agence gouvernementale japonaise ) pour être soumises au Comité des normes industrielles japonaises (JISC) puis à l' Organisation internationale de normalisation (ISO). Elle a été acceptée comme norme industrielle japonaise (JIS X 3017) en 2011 et comme norme internationale (ISO/IEC 30170) en 2012.

Vers 2005, l'intérêt pour le langage Ruby a augmenté parallèlement à Ruby on Rails , un framework Web écrit en Ruby. Rails est souvent crédité de la notoriété croissante de Ruby.

À compter de Ruby 1.9.3, publié le 31 octobre 2011, Ruby est passé d'une double licence sous la licence Ruby et la licence GPL à une double licence sous la licence Ruby et la licence BSD à deux clauses. L'adoption de la version 1.9 a été ralentie par les changements de la version 1.8 qui ont nécessité la réécriture de nombreux joyaux tiers populaires. Ruby 1.9 introduit de nombreux changements significatifs par rapport à la série 1.8. En voici quelques exemples :

• variables locales de bloc (variables locales au bloc dans lequel elles sont déclarées)
• une syntaxe lambda supplémentaire :f=->(a,b){putsa+b}
• une syntaxe littérale de hachage supplémentaire utilisant des deux points pour les clés de symbole :{symbol_key:"value"}=={:symbol_key=>"value"}
• les codages de caractères par chaîne sont pris en charge
• nouvelle API de socket [ prise en charge IPv6 ]
• require_relativesécurité des importations

Ruby 2.0 était censé être entièrement rétrocompatible avec Ruby 1.9.3. À la date de la sortie officielle de la version 2.0.0 le 24 février 2013, il n'existait que cinq incompatibilités (mineures) connues. Ruby 2.0 a ajouté plusieurs nouvelles fonctionnalités, notamment :

• Arguments du mot-clé de la méthode
• Une nouvelle méthode, Module#prepend, pour étendre une classe
• Un nouveau littéral pour créer un tableau de symboles
• Nouvelle API pour l'évaluation paresseuse des énumérables
• Une nouvelle convention d'utilisation de #to_h pour convertir des objets en hachages

À partir de la version 2.1.0, la politique de versionnage de Ruby a changé pour être plus proche de la versionnage sémantique .

Ruby 2.2.0 inclut des accélérations, des corrections de bogues et des mises à jour de bibliothèque et supprime certaines API obsolètes. Plus particulièrement, Ruby 2.2.0 introduit des modifications dans la gestion de la mémoire : un ramasse-miettes incrémental, la prise en charge de la collecte des miettes de symboles et l'option de compiler directement avec jemalloc. Il contient également une prise en charge expérimentale de l'utilisation de vfork (2) avec system() et spawn(), et une prise en charge supplémentaire de la spécification Unicode 7.0. Depuis la version 2.2.1, les performances de Ruby MRI sur PowerPC64 ont été améliorées. Les fonctionnalités qui ont été rendues obsolètes ou supprimées incluent callcc, la bibliothèque DL, Digest::HMAC, lib/rational.rb, lib/complex.rb, GServer, Logger::Application ainsi que diverses fonctions API C.

Ruby 2.3.0 inclut de nombreuses améliorations de performances, mises à jour et corrections de bogues, notamment des modifications apportées à Proc#call, à l'utilisation des mots-clés d'exception dans Socket et IO, à la gestion de Thread#name, aux connexions Net::FTP passives par défaut et à la suppression de Rake de stdlib. D'autres changements notables incluent :

• La possibilité de marquer tous les littéraux de chaîne comme gelés par défaut avec une augmentation conséquente des performances dans les opérations de chaîne.
• Comparaison de hachage pour permettre la vérification directe des paires clé/valeur au lieu des simples clés.
• Un nouvel opérateur de navigation sécurisé &. qui peut faciliter la gestion de nil (par exemple, au lieu de , nous pouvons utiliser ).ifobj&&obj.foo&&obj.foo.barif obj&.foo&.bar
• Le gemme did_you_mean est désormais fourni par défaut et requis au démarrage pour suggérer automatiquement des correspondances de noms similaires sur une NameError ou une NoMethodError .
• Hash#dig et Array#dig pour extraire facilement des valeurs profondément imbriquées (par exemple , étant donné que la valeur Foo Baz peut désormais être récupérée par ).profile={social:{wikipedia:{name:'Foo Baz'}}}profile.dig(:social, :wikipedia, :name)
• .grep_v(regexp)qui correspondra à tous les exemples négatifs d'une expression régulière donnée en plus d'autres nouvelles fonctionnalités.

Ruby 2.4.0 inclut des améliorations de performances pour la table de hachage, Array#max, Array#min et l'accès aux variables d'instance. D'autres changements notables incluent :

• Binding#irb : démarrer une session REPL similaire à binding.pry
• Unifier Fixnum et Bignum dans la classe Integer
• La chaîne prend en charge les mappages de casse Unicode, pas seulement ASCII
• Une nouvelle méthode, Regexp#match ?, qui est une version booléenne plus rapide de Regexp#match
• La détection de blocage des threads affiche désormais les threads avec leur trace et leurs dépendances

Quelques changements notables dans Ruby 2.5.0 incluent les instructions rescue et ensure qui utilisent automatiquement un bloc do-end environnant (moins de besoin de blocs begin-end supplémentaires ), le chaînage de méthodes avec yield_self , la prise en charge de la couverture de branche et de la mesure de couverture de méthode, et des transformations de hachage plus faciles avec Hash#slice et Hash#transform_keys. En plus de cela, de nombreuses améliorations de performances sont apportées, comme un passage de bloc plus rapide (3 fois plus rapide), des mutex plus rapides, des modèles ERB plus rapides et des améliorations sur certaines méthodes de concaténation.

Quelques changements notables dans Ruby 2.6.0 incluent un compilateur juste-à-temps expérimental (JIT) et RubyVM::AbstractSyntaxTree (expérimental).

Quelques changements notables dans Ruby 2.7.0 incluent la correspondance de motifs (expérimentale), les améliorations de REPL, un GC de compactage et la séparation des arguments de position et de mot-clé.

Ruby 3.0.0 est sorti le jour de Noël 2020. Il est connu sous le nom de Ruby 3x3, ce qui signifie que les programmes s'exécuteraient trois fois plus rapidement dans Ruby 3.0 par rapport à Ruby 2.0. et certains avaient déjà été implémentés dans des versions intermédiaires sur la route de 2 à 3. Pour atteindre 3x3, Ruby 3 est livré avec MJIT, et plus tard YJIT, des compilateurs juste-à-temps, pour rendre les programmes plus rapides, bien qu'ils soient décrits comme expérimentaux et restent désactivés par défaut (activés par des indicateurs lors de l'exécution).

Un autre objectif de Ruby 3.0 est d'améliorer la concurrence et deux autres utilitaires, Fibre Scheduler et Ractor expérimental, facilitent cet objectif. Ractor est léger et thread-safe car il est obtenu en échangeant des messages plutôt que des objets partagés.

Ruby 3.0 introduit le langage RBS pour décrire les types de programmes Ruby pour l'analyse statique . Il est séparé des programmes Ruby généraux.

Ruby 3.0 comporte également quelques améliorations de syntaxe et modifications de bibliothèque.

Ruby 3.1 est sorti le 25 décembre 2021. Il inclut YJIT, un nouveau compilateur expérimental Just-In-Time développé par Shopify , pour améliorer les performances des applications commerciales du monde réel. Un nouveau débogueur est également inclus. Cette version contient quelques améliorations de syntaxe et d'autres améliorations. Les bibliothèques réseau pour FTP , SMTP , IMAP et POP sont déplacées des gemmes par défaut vers les gemmes groupées.

Ruby 3.2 est sorti le 25 décembre 2022. Il prend en charge l'exécution dans un environnement WebAssembly via une interface WASI. Les expressions régulières reçoivent également quelques améliorations, notamment un algorithme de correspondance plus rapide et mémorisé pour se protéger contre certaines attaques ReDoS , et des délais d'attente configurables pour la correspondance des expressions régulières. Des fonctionnalités de débogage et de syntaxe supplémentaires sont également incluses dans cette version, qui incluent la suggestion de syntaxe, ainsi que la mise en évidence des erreurs. Le compilateur MJIT a été réimplémenté en tant que module de bibliothèque standard, tandis que YJIT, un compilateur JIT basé sur Rust , prend désormais en charge davantage d'architectures sous Linux.

Ruby 3.3 est sorti le 25 décembre 2023. Ruby 3.3 apporte des améliorations significatives et des améliorations de performances au langage. Les principales fonctionnalités incluent l'introduction de l'analyseur Prism pour une analyse portable et maintenable, l'ajout du compilateur JIT purement Ruby RJIT et des améliorations majeures des performances du compilateur YJIT. De plus, les améliorations de l'utilisation de la mémoire, l'introduction d'un planificateur de threads M:N et les mises à jour de la bibliothèque standard contribuent à un écosystème Ruby plus efficace et plus convivial pour les développeurs.

Matsumoto a déclaré que Ruby est conçu pour la productivité et le plaisir des programmeurs, en suivant les principes d'une bonne conception d'interface utilisateur . Lors d'un Google Tech Talk en 2008, il a déclaré : « J'espère voir Ruby aider tous les programmeurs du monde à être productifs, à apprécier la programmation et à être heureux. C'est le but premier du langage Ruby. » Il souligne que la conception des systèmes doit mettre l'accent sur les besoins humains plutôt que sur les besoins informatiques :

Souvent, les gens, en particulier les ingénieurs en informatique, se concentrent sur les machines. Ils pensent : « En faisant ceci, la machine fonctionnera plus vite. En faisant cela, la machine fonctionnera plus efficacement. En faisant cela, la machine fera quelque chose. » Ils se concentrent sur les machines. Mais en fait, nous devons nous concentrer sur les humains, sur la façon dont les humains se soucient de faire de la programmation ou d'utiliser les applications des machines. Nous sommes les maîtres. Ils sont les esclaves.

Matsumoto a déclaré que son objectif principal de conception était de créer un langage qu'il aimerait utiliser lui-même, en minimisant le travail du programmeur et la confusion possible. Il a déclaré qu'il n'avait pas appliqué le principe de moindre étonnement (POLA) à la conception de Ruby ; dans une discussion de mai 2005 sur le groupe de discussion comp.lang.ruby, Matsumoto a tenté de distancier Ruby du POLA, expliquant que comme tout choix de conception sera surprenant pour quelqu'un, il utilise une norme personnelle pour évaluer la surprise. Si cette norme personnelle reste cohérente, il y aura peu de surprises pour ceux qui connaissent la norme.

Matsumoto l'a défini ainsi dans une interview :

Chacun a un parcours personnel. Quelqu'un peut venir de Python, quelqu'un d'autre de Perl, et ils peuvent être surpris par différents aspects du langage. Puis ils viennent me voir et me disent : « J'ai été surpris par telle fonctionnalité du langage, donc Ruby viole le principe de moindre surprise. » Attendez. Attendez. Le principe de moindre surprise ne s'adresse pas qu'à vous. Le principe de moindre surprise signifie le principe de moindre surprise . Et cela signifie le principe de moindre surprise après avoir très bien appris Ruby. Par exemple, j'étais un programmeur C++ avant de commencer à concevoir Ruby. J'ai programmé exclusivement en C++ pendant deux ou trois ans. Et après deux ans de programmation en C++, cela me surprend toujours.

Ruby est orienté objet : chaque valeur est un objet, y compris les classes et les instances de types que de nombreux autres langages désignent comme des primitives (comme les entiers , les booléens et « null »). Comme tout dans Ruby est un objet, tout dans Ruby a certaines capacités intégrées appelées méthodes. Chaque fonction est une méthode et les méthodes sont toujours appelées sur un objet. Les méthodes définies au niveau supérieur deviennent des méthodes de la classe Object. Comme cette classe est un ancêtre de toutes les autres classes, ces méthodes peuvent être appelées sur n'importe quel objet. Elles sont également visibles dans toutes les portées, servant effectivement de procédures « globales ». Ruby prend en charge l'héritage avec des méthodes de répartition dynamique , des mixins et des méthodes singleton (appartenant à et définies pour une seule instance plutôt que d'être définies sur la classe). Bien que Ruby ne prenne pas en charge l'héritage multiple , les classes peuvent importer des modules en tant que mixins.

Ruby a été décrit comme un langage de programmation multi-paradigme : il permet la programmation procédurale (la définition de fonctions/variables en dehors des classes les rend partie intégrante de l'objet racine, « self »), avec une orientation objet (tout est un objet) ou une programmation fonctionnelle (il possède des fonctions anonymes , des fermetures et des continuations ; les instructions ont toutes des valeurs et les fonctions renvoient la dernière évaluation). Il prend en charge l'introspection , la programmation réflexive , la métaprogrammation et les threads basés sur un interpréteur . Ruby propose un typage dynamique et prend en charge le polymorphisme paramétrique .

Selon la FAQ Ruby, la syntaxe est similaire à celle de Perl et la sémantique est similaire à celle de Smalltalk , mais la philosophie de conception diffère grandement de celle de Python .

• Entièrement orienté objet avec héritage , mixins et métaclasses
• Typage dynamique et typage canard
• Tout est une expression (même les instructions ) et tout est exécuté de manière impérative (même les déclarations )
• Syntaxe succincte et flexible qui minimise le bruit syntaxique et sert de base aux langages spécifiques à un domaine
• Réflexion dynamique et altération des objets pour faciliter la métaprogrammation
• Fermetures lexicales , itérateurs et générateurs , avec une syntaxe de bloc
• Notation littérale pour les tableaux , les hachages , les expressions régulières et les symboles
• Incorporation de code dans des chaînes ( interpolation )
• Arguments par défaut
• Quatre niveaux de portée variable ( global , classe , instance et local ) indiqués par des sigils ou leur absence
• Collecte des ordures
• Des suites de première classe
• Règles de coercition booléennes strictes (tout est vrai sauf falseet nil)
• Gestion des exceptions
• Surcharge de l'opérateur
• Prise en charge intégrée des nombres rationnels , des nombres complexes et de l'arithmétique de précision arbitraire
• Comportement de répartition personnalisé (via method_missinget const_missing)
• Fils natifs et fibres coopératives (les fibres sont une fonctionnalité 1.9/ YARV )
• Prise en charge d' Unicode et de plusieurs encodages de caractères .
• API de plug-in natif en C
• Interactive Ruby Shell, un interpréteur de ligne de commande interactif qui peut être utilisé pour tester rapidement du code ( REPL )
• Gestion centralisée des packages via RubyGems
• Implémenté sur toutes les principales plateformes
• Grande bibliothèque standard, comprenant des modules pour YAML , JSON , XML , CGI , OpenSSL , HTTP , FTP , RSS , curses , zlib et Tk
• Compilation juste à temps

La syntaxe de Ruby est globalement similaire à celle de Perl et de Python . Les définitions de classes et de méthodes sont signalées par des mots-clés, tandis que les blocs de code peuvent être définis par des mots-clés ou des accolades. Contrairement à Perl, les variables ne sont pas obligatoirement préfixées par un sigil . Lorsqu'il est utilisé, le sigil modifie la sémantique de la portée de la variable. Pour des raisons pratiques, il n'y a pas de distinction entre les expressions et les instructions . Les sauts de ligne sont significatifs et considérés comme la fin d'une instruction ; un point-virgule peut être utilisé de manière équivalente. Contrairement à Python, l'indentation n'est pas significative.

L'une des différences avec Python et Perl est que Ruby conserve toutes ses variables d'instance complètement privées pour la classe et les expose uniquement via des méthodes d'accès ( attr_writer, attr_reader, etc.). Contrairement aux méthodes « getter » et « setter » d'autres langages comme C++ ou Java , les méthodes d'accès dans Ruby peuvent être créées avec une seule ligne de code via la métaprogrammation ; cependant, les méthodes d'accès peuvent également être créées de manière traditionnelle en C++ et Java. Comme l'invocation de ces méthodes ne nécessite pas l'utilisation de parenthèses, il est trivial de transformer une variable d'instance en une fonction complète, sans modifier une seule ligne de code d'appel ou avoir à effectuer une quelconque refactorisation pour obtenir des fonctionnalités similaires aux membres de propriété C# et VB.NET .

Les descripteurs de propriétés de Python sont similaires, mais impliquent un compromis dans le processus de développement. Si l'on commence en Python en utilisant une variable d'instance exposée publiquement, puis que l'on modifie ultérieurement l'implémentation pour utiliser une variable d'instance privée exposée via un descripteur de propriété, le code interne à la classe peut devoir être ajusté pour utiliser la variable privée plutôt que la propriété publique. La conception de Ruby oblige toutes les variables d'instance à être privées, mais fournit également un moyen simple de déclarer setdes getméthodes. Cela est conforme à l'idée selon laquelle dans Ruby, on n'accède jamais directement aux membres internes d'une classe depuis l'extérieur de la classe ; on passe plutôt un message à la classe et on reçoit une réponse.

L' interpréteur Ruby d'origine est souvent appelé interpréteur Ruby de Matz ou MRI. Cette implémentation est écrite en C et utilise sa propre machine virtuelle spécifique à Ruby .

L' implémentation standardisée et abandonnée de Ruby 1.8 a été écrite en C , en tant que langage interprété en un seul passage .

À partir de Ruby 1.9 et en continuant avec Ruby 2.x et au-dessus, l'interpréteur Ruby officiel a été YARV (« Yet Another Ruby VM »), et cette implémentation a remplacé la machine virtuelle plus lente utilisée dans les versions précédentes de MRI.

En 2018 , il existe un certain nombre d'implémentations alternatives de Ruby, notamment JRuby , Rubinius et mruby . Chacune adopte une approche différente, JRuby et Rubinius fournissant une compilation juste à temps et mruby fournissant également une compilation anticipée .

Ruby dispose de trois principales implémentations alternatives :

• JRuby , une implémentation mixte Java et Ruby qui s'exécute sur la machine virtuelle Java . JRuby cible actuellement Ruby 3.1.x.
• TruffleRuby, une implémentation Java utilisant le framework d'implémentation du langage Truffle avec GraalVM
• Rubinius , une machine virtuelle de bytecode C++ qui utilise LLVM pour compiler en code machine lors de l'exécution. Le compilateur de bytecode et la plupart des classes de base sont écrits en Ruby pur. Rubinius cible actuellement Ruby 2.3.1.

D'autres implémentations de Ruby incluent :

• MagLev , une implémentation Smalltalk qui s'exécute sur la machine virtuelle GemStone/S de GemTalk Systems
• mruby , une implémentation conçue pour être intégrée dans le code C, dans la même veine que Lua . Elle est actuellement développée par Yukihiro Matsumoto et d'autres
• RGSS , ou Ruby Game Scripting System, une implémentation propriétaire utilisée par la série de logiciels RPG Maker pour la conception de jeux et la modification du moteur RPG Maker
• julializer, un transpileur (partiel) de Ruby vers Julia . Il peut être utilisé pour une accélération importante par rapport aux implémentations Ruby ou JRuby par exemple (peut être utile uniquement pour le code numérique).
• Topaz, une implémentation Ruby écrite en Python
• Opal, un interpréteur Web qui compile Ruby en JavaScript

D'autres implémentations de Ruby aujourd'hui disparues étaient :

• MacRuby , une implémentation Mac OS X sur l' environnement d'exécution Objective-C . Son homologue iOS s'appelle RubyMotion
• IronRuby une implémentation sur le .NET Framework
• Cardinal, une implémentation pour la machine virtuelle Parrot
• Ruby Enterprise Edition , souvent abrégé en ree , une implémentation optimisée pour gérer des projets Ruby on Rails à grande échelle
• HotRuby , une implémentation JavaScript et ActionScript du langage de programmation Ruby

La maturité des implémentations Ruby est généralement mesurée par leur capacité à exécuter le framework Ruby on Rails (Rails), car il est complexe à implémenter et utilise de nombreuses fonctionnalités spécifiques à Ruby. Le moment où une implémentation particulière atteint cet objectif est appelé « la singularité Rails ». L'implémentation de référence, JRuby et Rubinius sont toutes capables d'exécuter Rails sans modification dans un environnement de production.

Matsumoto a initialement développé Ruby sur le système d'exploitation Sony NEWS-OS 3.x basé sur 4.3BSD , mais a ensuite migré son travail vers SunOS 4.x, et enfin vers Linux . En 1999, Ruby était connu pour fonctionner sur de nombreux systèmes d'exploitation différents . Les versions et implémentations modernes de Ruby sont disponibles sur tous les principaux systèmes d'exploitation de bureau, mobiles et basés sur serveur. Ruby est également pris en charge sur un certain nombre de plates-formes d'hébergement cloud telles que Jelastic , Heroku , Google Cloud Platform et d'autres.

Des outils tels que RVM et RBEnv facilitent l'installation et le partitionnement de plusieurs versions de Ruby et de plusieurs « gemsets » sur une seule machine.

RubyGems est le gestionnaire de paquets de Ruby. Un paquet Ruby est appelé un « gem » et peut être installé via la ligne de commande. La plupart des gemmes sont des bibliothèques, bien qu'il en existe quelques-unes qui sont des applications, comme les IDE . Il existe plus de 100 000 gemmes Ruby hébergées sur RubyGems.org.

De nombreuses bibliothèques Ruby nouvelles et existantes sont hébergées sur GitHub , un service qui propose un hébergement de référentiel de contrôle de version pour Git .

Les archives d'applications Ruby, qui hébergeaient des applications, de la documentation et des bibliothèques pour la programmation Ruby, ont été maintenues jusqu'en 2013, date à laquelle leur fonction a été transférée à RubyGems.