Ruby (Programmiersprache)

Ruby
Basisdaten
Paradigmen:	multiparadigmatisch
Erscheinungsjahr:	1995
Designer:	Yukihiro Matsumoto
Entwickler:	Yukihiro Matsumoto und andere
Aktuelle Version:	1.9.1  (31. Januar 2009)
Typisierung:	dynamisch („Duck-Typing“)
Wichtige Implementierungen:	Ruby MRI, YARV, JRuby, Rubinius (siehe unten)
Beeinflusst von:	Smalltalk, Perl, Python, LISP, Scheme, CLU, Eiffel, Ada, Dylan, JavaScript
Beeinflusste:	Groovy
Betriebssystem:	plattformunabhängig
Lizenz:	GPL und eigene (siehe Nutzungsbedingungen)
ruby-lang.org

Ruby (engl. für Rubin) ist eine moderne, vielseitige höhere Programmiersprache, die Mitte der Neunziger Jahre vom Japaner Yukihiro Matsumoto entworfen wurde.

Ruby ist interpretiert und objektorientiert, unterstützt aber mehrere weitere Programmierparadigmen (unter anderem Prozedurale und Funktionale Programmierung sowie Nebenläufigkeit), bietet dynamische Typisierung, Reflexion und Automatische Speicherbereinigung.

Geschichte

Der Entwickler von Ruby, Yukihiro Matsumoto.

Aus Unzufriedenheit über verfügbare Skriptsprachen begann Yukihiro „Matz“ Matsumoto 1993, an einer eigenen Sprache zu arbeiten, und gab am 21. Dezember 1995 die erste Version von Ruby, 0.95, frei. Den Namen, hergeleitet vom Edelstein Rubin, wählte er als Anspielung auf die Programmiersprache Perl. Zunächst wurde Ruby mangels englischsprachiger Dokumentation fast ausschließlich in Japan benutzt, wo es einen ähnlichen Stellenwert erlangte wie Perl und Python in Europa und Amerika. Um das Jahr 2000 wurden Aktivitäten gestartet, um Ruby auch außerhalb Japans bekannt zu machen, woraufhin mit der Zeit auch englische Dokumentationen entstanden. Inzwischen gibt es auch dutzende deutschsprachige Bücher zu Ruby im Allgemeinen und speziellen Themen.

Heute wird die Sprache als Open-Source-Projekt weitergepflegt.

Merkmale

Programmierparadigmen

Ruby ist eine objektorientierte Sprache. Die Sprache wurde aber ähnlich wie C++ als „Multiparadigmen-Sprache“ entworfen. Das bedeutet, dass es dem Entwickler offen steht, weitere Programmierparadigmen zur Erstellung seiner Programme zu nutzen. Die verbreitetsten Paradigmen sollen im Folgenden beschrieben werden.

Objektorientierte Programmierung

Ruby ist wie Smalltalk vollständig objektorientiert: Alle Datentypen sind in Ruby Objekte, auch solche, die in vielen anderen Sprachen als primitive Datentypen gelten, wie etwa Zahlen oder Zeichenketten.

Ruby unterstützt mehrere Ansätze der Objektorientierung.

Klassenbasierte Objektorientierung

Eine Klasse kann wie folgt definiert werden:

class Auto
  def beschleunigen
    puts "BrumBrumBrum"
  end
end

auto1 = Auto.new
auto1.beschleunigen

Ausgabe:

BrumBrumBrum

Auto erbt dabei automatisch von der Mutterklasse Object. Eine Klasse, die von einer anderen Klasse als Object erbt, wird so definiert:

class GutesAuto < Auto
  def bremsen
    puts "Quietsch"
  end
end

auto2 = GutesAuto.new
auto2.beschleunigen
auto2.bremsen

Ausgabe:

BrumBrumBrum
Quietsch

Die Klasse GutesAuto erbt alle Methoden der Klasse Auto, u. a. auch beschleunigen. Zusätzlich wird für GutesAuto die Methode bremsen definiert.

Prototypenbasierte Objektorientierung

Ruby unterstützt zudem, ähnlich wie JavaScript oder Io, prototypenbasierte Objektorientierung.

Das obige Beispiel mit Prototypen realisiert:

auto1 = Object.new
def auto1.beschleunigen
  puts "BrumBrumBrum"
end

auto1.beschleunigen

auto2 = auto1.clone
def auto2.bremsen
  puts "Quietsch"
end

auto2.beschleunigen
auto2.bremsen

Ausgabe:

BrumBrumBrum
BrumBrumBrum
Quietsch

Objektorientierung mit Mixins

Bis vor einiger Zeit wurden Mixins als reine Ergänzung zu klassenbasierter Objektorientierung angesehen. Spätestens aber seit Sprachen wie Potion ist klar, dass es sich hierbei um ein eigenes Konzept der Objektorientierung handelt. Dieses wird auch von Ruby unterstützt.

In Ruby sind Mixins Module, die in andere Objekte eingebunden werden. Die Methoden des Beispiels aus den beiden oberen Abschnitten ließe sich zum Beispiel so in Module teilen:

module Gaspedal
  def beschleunigen
    puts "BrumBrumBrum"
  end
end

module Bremse
  def bremsen
    puts "Quietsch"
  end
end

Ein Auto mit Gaspedal und Bremsen ließe sich dann wie folgt zusammenbauen:

auto = Object.new
auto.extend Gaspedal
auto.extend Bremse

Natürlich lässt sich das mit Klassen kombinieren:

class Auto
  include Gaspedal
end

class GutesAuto < Auto
  include Bremse
end

Aber auch mit Prototypen ist es nutzbar:

auto1 = Object.new
auto1.extend Gaspedal

auto2 = auto1.clone
auto2.extend Bremse

Prozedurale Programmierung

Im Gegensatz zu Sprachen wie Java und C# ist es in Ruby nicht notwendig, seine Programme explizit in einer Klasse zu definieren. Da jedes Ruby-Programm in einem globalen main-Objekt erstellt wird, ist dieses sich oft wiederholende Sprachkonstrukt unnötig. Stattdessen kann ein Programm auch aus Prozeduren aufgebaut werden. Folgender Codeabschnitt ist bereits ein vollständig lauffähiges Ruby-Programm:

def gruessen
  puts "Hallo Welt!"
end

gruessen

Funktionale Programmierung

Weil in Ruby jeder Ausdruck einen Wert hat, lassen sich Probleme funktional behandeln.

Im folgenden Beispiel gibt das case-Konstrukt je nach Wert der Variable sprache einen anderen String zurück.

gruss = case sprache
          when "Deutsch"   then "Hallo Welt"
          when "Englisch"  then "Hello, world"
          when "Japanisch" then "konnichiwa sekai"
          else raise "Unbekannte Sprache"
        end

Über ein Lambda-Konstrukt kann man einen Codeblock in einer Funktionsvariablen speichern.

print_function = lambda { |item| print item + 1 }
[1,2,3].each &print_function
# >> 234

Weitere Paradigmen

Ruby unterstützt Metaprogrammierung, aspektorientierte Programmierung durch Active Support oder AspectR und kontextorientierte Programmierung durch ContextR.

Prinzipien

Prinzip der geringsten Überraschung

Ruby folgt dem Prinzip der geringsten Überraschung (kurz POLS für „Principle of least surprise“). Rubys Designer versuchen, die Sprache so zu gestalten, dass Programmierer sie intuitiv nutzen können und möglichst wenig von ihrem Verhalten überrascht werden. Matsumoto gibt an, die Sprache primär auf seine eigenen Bedürfnisse ausgerichtet zu haben:

„Das Prinzip der geringsten Überraschung ist das Prinzip meiner geringsten Überraschung. Und es ist das Prinzip der geringsten Überraschung nachdem Du Ruby sehr gut gelernt hast.“

– Yukihiro „Matz“ Matsumoto

Duck Typing

Die Duck-Typing-Philosophie von Ruby basiert auf der Idee, die Behandlung eines Objekts nicht von dessen Klasse, sondern von dessen Methoden abhängig zu machen.

class Ente
  def beschreibung
    "Eine graue Ente"
  end
  def sprechen
    "Quak!"
  end
end

class Kuh
  def beschreibung
    "Eine dicke Kuh"
  end
  def sprechen
    "Muuuh!"
  end
end

def lass_sprechen tier
  puts tier.beschreibung+" macht "+tier.sprechen
end

lass_sprechen Ente.new
lass_sprechen Kuh.new

Ausgabe:

Eine graue Ente macht Quak!
Eine dicke Kuh macht Muuuh!

Im Beispiel ist es für lass_sprechen unerheblich, von welcher Klasse tier ist, es ist nur wichtig, dass die Methoden beschreibung und sprechen verstanden werden.

Ruby bietet Exceptions, Introspection und andere Mechanismen, um das Duck Typing abzusichern, sofern der Programmierer das wünscht.

Syntax

Besonderheiten

Zeilenumbrüche markieren das Ende einer Anweisung, Semikolons bewirken dasselbe. Sonstiger Whitespace hat keine Bedeutung.

Klammern um Argumente können bei Eindeutigkeit weggelassen werden, sowohl bei der Deklaration einer Methode, als auch beim Aufruf. Der zuletzt berechnete Wert einer Methode ist gleichzeitig ihr Rückgabewert:

def sperre text
  text.split("").join " "
end

puts sperre "Syntaktischer Zucker!"

Ruby unterscheidet fünf verschiedene Gültigkeitsbereiche:

• Normalerweise ist eine Variable lokal und nur innerhalb der umgebenden Methode gültig.
• Ein @ vor Variablen deklariert diese als Attribute, sie werden dann dauerhaft der Klasseninstanz zugeordnet und für diese sichtbar.
• Ein vorangestelltes @@ macht Variablen zu Klassenvariablen, die zur umgebenden Klasse gehören.
• Mit $ werden Variablen global und sind damit im gesamten Programm sichtbar.
• Schließlich gibt es Variablen, die nur innerhalb eines Blocks gültig sind.

Blöcke

Anstatt von For-Schleifen macht man in Ruby häufig Gebrauch von sogenannten Blöcken. Dies sind Codeabschnitte, die nach bestimmten Vorgaben, etwa für alle Elemente einer Datenstruktur, ausgeführt werden. Sie können unter anderem benutzt werden, um Strukturen auszuwerten oder zu manipulieren. Ausdrücke wie

array.each do |i|
    ...
end

oder in der Kurzschreibweise

array.each{|i| ... }

iterieren über array, wobei dem Block in jedem Iterationsschritt ein Visitor für das aktuelle Element mit der Bezeichnung i übergeben wird. Mit Blöcken werden elegante Konstruktionen wie 5.times{ ... } oder array.sort_by{|i| i.size} möglich.

Iteratoren, also Methoden, die Blöcke aufrufen, können auch selbst definiert werden:

def mach_zweimal
    yield
    yield
end

mach_zweimal{ puts "Block aufgerufen!" }

Ausgabe:

Block aufgerufen!
Block aufgerufen!

Bestandteile

Interaktive Ruby-Shell

Interactive Ruby (kurz: irb) ist ein Read-Eval-Print Loop (kurz REPL) für Ruby, mit welchem der Anwender interaktiv Ruby programmieren kann. Er kann zum Analysieren und Testen eingesetzt werden:

irb(main):001:0> (5 + 7) * 2
=> 24
irb(main):002:0> ((5 + 7) * 2).to_s.reverse
=> "42"
irb(main):003:0> "Ein Beispielstring".size
=> 18

Irb wird mit dem Ruby-Interpreter ausgeliefert, kann aber auch mit Hilfe von TryRuby im Browser ausgeführt werden.

RDoc und ri

RDoc ist ein Software-Dokumentationswerkzeug, welches aus Ruby- und C-Quelltexten automatisch HTML-Dokumentationsdateien erstellt. Weiterhin wird eine Datenbank aufgebaut, die mit dem Tool ri durchsucht werden kann. RDoc und ri sind Bestandteil der Standarddistribution und werden zusammen mit dem Interpreter ausgeliefert.

RubyGems

RubyGems (kurz: gems) ist das offizielle Paketsystem für Ruby. Mit ihm hat der Anwender die Möglichkeit mehrere Versionen eines Programmes oder einer Bibliothek kontrolliert zu installieren und wieder zu entfernen. Durch die Versionierung der Pakete können alte und neue Versionen problemlos nebeneinander existieren.

Implementierungen

Die ursprüngliche Referenzimplementierung von Ruby (aktuelle Version: 1.9.1) wurde von Yukihiro „Matz“ Matsumoto als Interpreter in C entworfen. Er wird oft als CRuby, MRI (Matz's Ruby Interpreter) oder MatzRuby bezeichnet und ist derzeit am weitesten verbreitet. Den Kern bildet YARV (kurz für Yet Another Ruby VM), eine virtuelle Maschine. Statt ein Rubyprogramm direkt auszuführen, wird es so zunächst in Bytecode übersetzt und dann von YARV interpretiert, wodurch sich ein Geschwindigkeitsvorteil ergibt. Weiterhin enthält diese Version eine leistungsstarke Regexp-Maschine namens Oniguruma und unterstützt Multibyte-Zeichensätze wie UTF-8. Die Vorgängerversion (1.8.7) wird vorerst weiter gepflegt, da 1.9.1 nicht kompatibel zu dieser ist und eine Vielzahl von Programmen deshalb noch nicht fehlerfrei auf der neuen Version läuft.

Der offizielle Interpreter läuft auf den folgenden Betriebssystemen:

• POSIX-kompatible Systeme (u. a. Linux, BSD und Mac OS X)
• Microsoft Windows (u. a. 2000 und XP)

Inzwischen sind mehrere alternative Implementierungen von Ruby verfügbar, unter anderem:

• JRuby, eine Neuimplementierung des Ruby-Interpreters in Java mit dem Ziel, Ruby nahtlos in die Java-Plattform zu integrieren. JRuby ist vollständig kompatibel zu Ruby 1.8, teilweise auch zu 1.9. JRuby ist zudem kompatibel zu einigen Ruby-Erweiterungen von Rubinius (Foreign Function Interface, Multi-VM-API).
• Rubinius, eine von Smalltalk-80 inspirierte Implementierung. Abgesehen von der virtuellen Maschine ist Rubinius vollständig in Ruby geschrieben. Rubinius wird als vollständig kompatibel zu Ruby 1.8 betrachtet und hat experimentellen Support für 1.9. Die kommende Version von Rubinius (1.0) nutzt die Low Level Virtual Machine (LLVM).
• Microsofts IronRuby und Gardens Point Ruby.NET, die Ruby ins .NET-Framework integrieren sollen und in C# implementiert werden.
• Cardinal, ein Interpreter für die virtuelle Maschine Parrot.
• MagLev ist eine proprietäre Implementierung des Unternehmens Gemstone für deren Smalltalk VM.
• MacRuby ist eine Implementierung in Objective-C von Apple, die bis Version 0.4, wie Ruby 1.9, YARV nutzt, ab Version 0.5 allerdings, wie Rubinius, auf die LLVM setzt. MacRuby ist als einzige Implementierung nur zu Ruby 1.9 kompatibel, nicht mehr zu Ruby 1.8.
• tinyrb ist eine minimalistische Implementierung, angelehnt an die virtuellen Maschinen von Lua und Potion. Es wird keine vollständige Kompatibiblität zu Ruby erreicht werden: Zwar soll jedes Programm, dass tinyrb ausführen kann, auch von Ruby ausführbar sein, jedoch soll tinyrb nicht jedes Rubyprogramm ausführen können.
• Ruby Enterprise Edition ist eine modifizierte Version der Referenzimplementierung, bei der im wesentlichen der Garbage Collector neu implementiert wurde. (Siehe dazu: Kritik)
• Eine auf ABAP aufbauende Neuimplementierung namens Blue Ruby wird im Moment von SAP entwickelt.

Kompatibilität zu Ruby 1.8 einer Implementation meint meist, dass diese zu 1.8.6 kompatibel ist. Es bezieht sich nicht auf die neuste Version der 1.8-Reihe (1.8.7), da in diese Sprachänderungen, wie etwa das Aufrufen von each ohne einen Block zu übergeben, aus 1.9 zurück fließen.

Ein wichtiges Merkmal ist hierbei, ob diese Implementierungen in der Lage sind, Ruby On Rails auszuführen. Derzeit können dies neben der Referenzimplementierung nur JRuby, Rubinius und die Ruby Enterprise Edition (Stand: Februar 2009).

Die Kompatibilität zur Referenzimplementierung wird durch das RubySpec Projekt überprüft, das im Moment von allen genannten Implementierungen, mit Ausnahme von tinyrb und Cardinal, genutzt wird (Stand: Februar 2009). Es stellt dabei sowohl eine Testsuite als auch eine Spezifikation für Ruby 1.8 und 1.9 dar. RubySpec war ursprünglich ein Teil von Rubinius, wurde aber ausgelagert und nun auch von einer Vielzahl anderer Entwickler vorangetrieben.

Kritik

Kritik an der Sprache:

• Da Variablen vor Gebrauch nicht deklariert werden müssen, können bei Tippfehlern unerwartete Laufzeitfehler auftreten.
• Ruby ist nicht immer abwärtskompatibel.
• Metaprogrammierung und Monkeypatching erlauben es einem Codestück alle Klassen und Objekte des Prozesses, in dem es ausgeführt wird, zu ändern.
• Ruby hatte bis vor kurzem keine offizielle Spezifikation. Allerdings wurde RubySpec von Matz als Spezifikation angenommen. Zudem gibt es von Matz und anderen Entwicklern das Bestreben eine weitere Spezifikation zu erstellen mit dem Ziel einen ISO-Standard zu etablieren.

Kritik an der Referenzimplementierung:

• Der Garbage Collector manipuliert die Speichereinträge für Objekte direkt, sodass Copy-On-Write-Mechanismen des Betriebssystems ausgehebelt werden und es möglich ist, dass ein Rubyprogramm nach dem Durchlaufen des Garbage Collectors eventuell mehr Speicher belegt als zuvor.
• Der Garbage Collector benutzt Mark-And-Sweep, was eine relativ simple, aber ineffiziente Strategie darstellt.
• YARVs Global Interpreter Lock führt dazu, dass mehrere Threads eines Prozesses nicht gleichzeitig auf verschiedenen Prozessoren ausgeführt werden können.

Sonstiges

Anwendungen und Bibliotheken

Mit RubyForge und dem Ruby Application Archive (RAA) stehen zwei Repositorien zur Verfügung, die zusammen über 7000 Anwendungen und Bibliotheken beherbergen.

Als derzeit bedeutendste Anwendung, die auf Ruby basiert, ist das Web-Framework Ruby on Rails zu nennen.

Nutzungsbedingungen

Ruby ist freie Software. Aufgrund dessen ist es kostenlos nutzbar und im Quelltext verfügbar. Dadurch ergibt sich die Möglichkeit, die Sprache an seine eigenen Bedürfnisse anzupassen oder sie in eigene Programme einzubinden.

Der Interpreter und die Standardbibliothek von Ruby sind grundsätzlich unter den Bedingungen der GPL nutzbar. Des Weiteren besteht die Möglichkeit, Ruby unter anderen Konditionen zu verwenden.

Literatur

Für Einsteiger

• Daniel Bovensiepen: Das Einsteigerseminar Ruby. vmi Buch, Heidelberg 2007, ISBN 978-3826674594
• Sascha Kersken: Praxiswissen Ruby. O’Reilly, 2007, ISBN 978-3-89721-478-1
• Kevin C. Baird: Das Ruby-Praxisbuch. Franzis, 2008, ISBN 978-3-7723-7904-8

Gesamtdarstellungen

• Dave Thomas: Programming Ruby, Second Edition. Pragmatic Bookshelf, 2004, ISBN 0-974-514-055 (englisch)
• Hal Fulton: The Ruby Way. Addison-Wesley Professional, 2006, ISBN 978-0672328848 (englisch)

Für Fortgeschrittene

• Lucas Carlson, Leonard Richardson: Ruby Cookbook. O’Reilly Media, 2006, ISBN 978-0596523695 (englisch)
• Russ Olsen: Design Patterns in Ruby. Addison-Wesley Professional, 2007, ISBN 978-0321490452 (englisch)

Referenzen

• Michael Fitzgerald: Ruby: kurz & gut. O’Reilly, 2007, ISBN 978-3897215344

Weblinks

Wikibooks: Ruby-Programmierung – Lern- und Lehrmaterialien

• Offizielle Webseite von Ruby
• Zusammenstellung von Tutorials zu Ruby
• Dokumentationssammlung zu Ruby (englisch)
• Deutsches Rubyforum
• Linkkatalog zum Thema Ruby bei curlie.org (ehemals DMOZ)
• Deutsches Magazin für Ruby on Rails