Ruby

Fiche logiciel validé
  • Création ou MAJ importante : 27/02/12
  • Correction mineure : 24/07/12
Mots-clés

Ruby : langage de script orienté objet

Description
Fonctionnalités générales

Ruby est un langage de programmation généraliste interprété. Il demande d'adopter une approche de conception dite "orientée objet". Bien qu'existant depuis 1995, il a été récemment popularisé par un framework pour le développement d'applications Web : Ruby On Rails (RoR).

Héritier de plusieurs langages comme Perl, Eiffel, Lisp ou Smalltalk, Ruby est totalement orienté objet. C'est-à-dire que l'activité du programmeur Ruby consiste toujours en l'envoi de messages à des objets. De ce fait, une fois ce seul mécanisme compris, l'utilisateur profite de cette unité interne au langage qui, lui évitant les surprises, facilite son activité de développement. Ce dernier point le distingue en particulier du langage interprété Python.
La syntaxe de Ruby se veut proche de celle du langage naturel et la plus homogène possible.

Des capacités de méta-programmation faciles et intégrées distinguent Ruby d'autres langages. La méta-programmation consiste à considérer le code d'un programme comme une donnée pouvant être manipulée par un autre programme. Rappelons que dans le cas du langage LISP le langage lui-même est un type de donnée, cette capacité réflexive rend la méta-programmation omniprésente (c'est la notion de macro). Dans le cas de Ruby (comme pour Smalltalk ou Perl avec l'extension Moose, etc.), la réflexivité provient d'un système objet omniprésent et total : tout est objet.

Prenons l'exemple de la modélisation d'objets de type "voiture". Nous définissons une classe Voiture avec un attribut couleur et un accesseur / mutateur pour cet attribut :

class Voiture
def couleur
@couleur
end

def couleur=(couleur)
@couleur = couleur
end
end

Nous aimerions définir de la même manière les attributs : moteur, marque et modèle ... mais éviter d'écrire quatre fois à peu près la même chose ! Nous allons donc écrire un bout de code qui générera pour nous le code redondant. Nous profitons de ce que toutes les classes héritent de la classe Object :


class Object
def self.attr_accessor(*attributes)
attributes.each{|attribute|
# nous définissons un accesseur générique
define_method(attribute) do
instance_variable_get("@#{attribute}")
end
# nous définissons un mutateur générique
define_method("#{attribute}=") do |var|
instance_variable_set("@#{attribute}", var)
end
}
end
end

Nous pouvons maintenant écrire :


class Voiture
attr_accessor :couleur, :moteur, :marque, :modele
end

Nous avons illustré un aspect du langage Ruby sans expliquer tout ce qui est nécessaire pour comprendre le code présenté : l'objectif était de donner un aperçu concret du type de programmation que permettait le langage.

Un autre point essentiel tient à ce que Ruby ne possède pas, au contraire de JAVA, de notion d'interface. Par contre, une notion puissante de "module" permet de factoriser efficacement le code. Par exemple, si l'on veut écrire une classe qui modélise des couples :

class Couple
attr_accessor :premiere_composante, :deuxieme_composante
# ... etc.

def <(autre_couple)
(premiere_composante < autre_couple.premiere_composante) ||
(premiere_composante == autre_couple.premiere_composante &&
deuxieme_composante < autre_couple.deuxieme_composante)
end
def >(autre_couple)
autre_couple < self
end
# idem pour ==, <=, >=
end

On voit que le coeur  du code correspond à l'implémentation de l'opération "inférieur à" (noté : "<"). Beaucoup d'objets peuvent être comparables au moyen des opérations <, >, <=, >= etc. une fois que la seule opération < est implémentée. Ainsi, on peut remplacer le code précédent par celui ci-dessous, bien plus générique grâce à l'emploi de la notion de module :

module ComparableAvecInferieur
def >(autre)
autre < self
end
# idem pour ==, <=, >=
end

class Couple
include ComparableAvecInferieur
attr_accessor :premiere_composante, :deuxieme_composante
# ... etc.

def <(autre_couple)
(premiere_composante < autre_couple.premiere_composante) ||
(premiere_composante == autre_couple.premiere_composante &&
deuxieme_composante < autre_couple.deuxieme_composante)
end
end
Autres fonctionnalités

Le langage bénéficie d'une forte communauté qui le soutient, la documentation est de bonne qualité, et de nombreuses bibliothèques sont disponibles et installables facilement via l'utilitaire RubyGems et le site RubyForge.
Il est très simple d'écrire des extensions en utilisant le langage C grâce à une API bien pensée dont la documentation est accessible à cette adresse : http://www.ruby-doc.org/.

Dans le cas de Ruby on Rails, mentionnons également la présence sur le Web de nombreuses vidéos (screencast) dédiées à l'apprentissage de différents aspects de ce framework.

Contexte d'utilisation dans mon laboratoire/service

Je m'en sers personnellement pour développer de petites applications (moins de 100 lignes de code source), le préférant à d'autres alternatives (Perl, Awk, Bash, Python, ...) pour sa lisibilité qui facilite la maintenance du code et améliore sa pérennité.
Une raison plus technique me fait aussi apprécier ce langage, il a en effet repris à Smalltalk la notion élégante de bloc qui permet une programmation d'un haut niveau d'abstraction, c'est-à-dire considérer les fonctions comme des objets à part entière qui peuvent donc être passés en paramètre d'un message, retournés par un message, ... ceci correspond à la notion de fonction anonyme des langages fonctionnels (Lisp, Haskell, Erlang, Javascript, ...).
Ruby on Rails permet également de développer rapidement la maquette d'une application Web.

Limitations, difficultés, fonctionnalités importantes non couvertes

Le framework Ruby On Rails fait le choix de favoriser l'usage de conventions pour diminuer les besoins de configuration. Si ce choix me semble intéressant et même justifié lorsqu'il s'agit d'accélérer le développement d'une application Web "classique" ; il demande un temps d'adaptation pour se familiariser aux conventions et trouve ses limites lorsque l'on cherche à développer une application moins classique (ce qui fut mon cas pour une application qui demande d'utiliser RDF plutôt qu'une base de données relationnelle).

Environnement du logiciel
Distributions dans lesquelles ce logiciel est intégré
  • Debian-like, Ubuntu (apt-get)
  • Redhat-like, SLC, Fedora (yum ou rpm)
  • Mac/OSX (Fink ou Macport)
  • Gentoo (emerge ruby ruby-mode)
Plates-formes

Mac OSX, Windows, Linux

Logiciels connexes
Autres logiciels aux fonctionnalités équivalentes

Python (licence compatible GPL)
Squeak (libre : http://www.squeak.org/SqueakLicense/)
Perl (GPL ou Artistic) : fiche PLUME : http://www.projet-plume.org/fiche/perl

Environnement de développement
Type de structure associée au développement
Eléments de pérennité
Environnement utilisateur
Liste de diffusion ou de discussion, support et forums
Documentation utilisateur
Divers (astuces, actualités, sécurité)
Contributions