Ruby (Programmiersprache)

Ruby
Offizielles Logo
Basisdaten
Paradigmen:	multiparadigmatisch
Erscheinungsjahr:	1995
Entwickler:	Yukihiro Matsumoto und andere
Aktuelle Version:	1.9.3  (31. Oktober 2011[1])
Typisierung:	dynamisch („Duck-Typing“)
wichtige Implementierungen:	Ruby MRI, YARV, JRuby, Rubinius (siehe unten)
Einflüsse:	Smalltalk, Perl, Python, LISP, 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 höhere Programmiersprache, die Mitte der neunziger Jahre von dem 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.^[2] Den Namen, hergeleitet vom Edelstein Rubin, wählte er als Anspielung auf die Programmiersprache Perl.^[3] 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 zu 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 Zeichen.

Ruby unterstützt mehrere Ansätze der Vererbung.

Klassenbasierte Objektorientierung

Eine Klasse kann wie folgt definiert werden:

class Auto
  def beschleunigen
    puts "brumm brumm brumm"
  end
end
 
auto1 = Auto.new
auto1.beschleunigen

Ausgabe:

brumm brumm brumm

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

class Gutes_Auto < Auto
  def bremsen
    puts "quietsch"
  end
end
 
auto2 = Gutes_Auto.new
auto2.beschleunigen
auto2.bremsen

Ausgabe:

brumm brumm brumm
quietsch

Die Klasse Gutes_Auto erbt alle Methoden der Klasse Auto, u. a. auch beschleunigen. Zusätzlich wird für Gutes_Auto 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 "brumm brumm brumm"
end
 
auto1.beschleunigen
 
auto2 = auto1.clone
def auto2.bremsen
  puts "quietsch"
end
 
auto2.beschleunigen
auto2.bremsen

Ausgabe:

brumm brumm brumm
brumm brumm brumm
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 "brumm brumm brumm"
  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

Ausgabe:

Hallo Welt!

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 Variablen 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^[4] und kontextorientierte Programmierung^[5] durch ContextR.^[6]

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, den Typ 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
  buchstaben = text.split "" 
  buchstaben.join " "
end
 
puts sperre "Syntaktischer Zucker!"

Ausgabe:

S y n t a k t i s c h e r   Z u c k e r !

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 Instanz 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 |element|
    ...
end

oder in der Kurzschreibweise

array.each { |element| ... }

iterieren über array, wobei dem Block in jedem Iterationsschritt ein Visitor für das aktuelle Element mit der Bezeichnung element übergeben wird. Mit Blöcken werden elegante Konstruktionen wie 5.times{ ... } oder array.sort_by{|element| element.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.

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

Referenzimplementierung

Die Referenzimplementierung von Ruby (aktuelle Version: 1.9.2) wurde von Yukihiro „Matz“ Matsumoto als Interpreter in C entworfen. Dieser wird meist als MRI (Matz's Ruby Interpreter) oder auch als CRuby oder MatzRuby bezeichnet und ist derzeit am weitesten verbreitet. Den Kern bildet YARV (Yet Another Ruby VM), eine virtuelle Maschine. Statt ein Rubyprogramm direkt auszuführen, wird es 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.2 nicht kompatibel zu dieser ist und eine Vielzahl von Programmen deshalb noch nicht fehlerfrei auf der neuen Version laufen.

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)

Alternative Implementierungen

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 fast vollständig kompatibel zu Ruby 1.8.7, 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 ist nahezu vollständig kompatibel zu Ruby 1.8.7 und hat experimentellen Support für 1.9. Rubinius nutzt die Low Level Virtual Machine (LLVM) und ist kompatibel mit C-Erweiterungen der Referenzimplementierung.
• IronRuby ist eine Implementierung, die Ruby ins .NET-Framework integriert und in C# implementiert ist.
• Cardinal, ein Interpreter für die virtuelle Maschine Parrot.
• MagLev ist eine Implementierung des Unternehmens Gemstone für deren proprietäre 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 Kompatibilität zu Ruby erreicht werden: Zwar soll jedes Programm, das tinyrb ausführen kann, auch von Ruby ausführbar sein, jedoch soll umgekehrt 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. Als einzige der hier aufgeführten Implementierungen ist Blue Ruby derzeit nicht quelloffen.

Die Kompatibilität zur Referenzimplementierung wird durch das RubySpec-Projekt^[7] überprüft, das im Moment von allen genannten Implementierungen, mit Ausnahme von tinyrb und Cardinal, genutzt wird (Stand: November 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.

Mit dem Ruby Version Manager, kurz RVM, steht eine einfache Möglichkeit zur Verfügung, mehrere Ruby-Implementierungen und Gem-Versionen parallel zu betreiben.

Ein wichtiges Merkmal der Implementierungen ist, ob sie in der Lage sind, Ruby On Rails auszuführen. Derzeit können dies neben der Referenzimplementierung nur JRuby^[8], IronRuby ^[9], Rubinius^[10] und die Ruby Enterprise Edition^[11] (Stand: September 2010).

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.^[12]
• Metaprogrammierung und Monkeypatching erlauben es einem Codestück, alle Klassen und Objekte des Prozesses, in dem es ausgeführt wird, zu ändern.^[13]
• 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.^[14] Ein erster Entwurf für eine solche Spezifikation wurde am 27. November 2009 veröffentlicht.^[15]

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.^[16]
• Der Garbage Collector benutzt Mark-And-Sweep, eine einfache, aber ineffiziente Strategie.^[17]
• YARVs Global Interpreter Lock führt dazu, dass mehrere Threads eines Prozesses nicht gleichzeitig auf verschiedenen Prozessoren ausgeführt werden können.^[18][19]

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.^[20]

Quellen

1. ↑ [1]
2. ↑ RubyConf: History of Ruby
3. ↑ Ein Interview mit dem Schöpfer von Ruby
4. ↑ http://aspectr.sourceforge.net/
5. ↑ http://www.swa.hpi.uni-potsdam.de/cop/
6. ↑ http://contextr.rubyforge.org/
7. ↑ http://rubyspec.org/
8. ↑ http://wiki.jruby.org/wiki/JRuby_on_Rails
9. ↑ http://iunknown.com/2008/05/ironruby-and-rails.html
10. ↑ http://blog.fallingsnow.net/2008/05/17/rails-on-rubinius/
11. ↑ http://www.rubyenterpriseedition.com/
12. ↑ http://www.infoq.com/news/2007/12/ruby-19
13. ↑ http://avdi.org/devblog/2008/02/23/why-monkeypatching-is-destroying-ruby/
14. ↑ http://www.ruby-forum.com/topic/169195
15. ↑ http://ruby-std.netlab.jp/
16. ↑ http://blog.beaver.net/2005/03/ruby_gc_and_copyonwrite.html
17. ↑ http://rubyconf2008.confreaks.com/how-ruby-can-be-fast.html
18. ↑ http://www.infoq.com/news/2007/05/ruby-threading-futures
19. ↑ http://www.igvita.com/2008/11/13/concurrency-is-a-myth-in-ruby/
20. ↑ Rubys Lizenzbedingungen

Literatur

Für Einsteiger

• Daniel Bovensiepen: Das Einsteigerseminar Ruby. vmi Buch, Heidelberg 2007, ISBN 978-3-8266-7459-4
• Sascha Kersken: Praxiswissen Ruby. O’Reilly, 2007, ISBN 978-3-89721-478-1 (vergriffen; kostenloser PDF-Download hier)
• 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-9745140-5-5 (englisch)
• Hal Fulton: The Ruby Way. Addison-Wesley Professional, 2006, ISBN 978-0-672-32884-8 (englisch)

Für Fortgeschrittene

• Lucas Carlson, Leonard Richardson: Ruby Cookbook. O’Reilly Media, 2006, ISBN 978-0-596-52369-5 (englisch)
• Russ Olsen: Design Patterns in Ruby. Addison-Wesley Professional, 2007, ISBN 978-0-321-49045-2 (englisch)

Referenzen

• Michael Fitzgerald: Ruby: kurz & gut. O’Reilly, 2007, ISBN 978-3-89721-534-4

Weblinks

 Wikibooks: Ruby-Programmierung – Lern- und Lehrmaterialien

• Offizielle Webseite von Ruby
• Zusammenstellung von Tutorials zu Ruby
• Dokumentationssammlung zu Ruby (englisch)
• Deutsches Rubyforum
• Links zum Thema Ruby im Open Directory Project