Ruby (Programmiersprache)

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche
Ruby
Ruby logo.svg
Offizielles Logo
Basisdaten
Paradigmen: multiparadigmatisch
Erscheinungsjahr: 1995
Entwickler: Yukihiro Matsumoto und andere
Aktuelle Version: 2.1.1  (24. Februar 2014[1])
Typisierung: dynamisch („Duck-Typing“)
Wichtige Implementierungen: Ruby MRI, YARV, JRuby, Rubinius (siehe unten)
Beeinflusst von: Smalltalk, Perl, Python, Lisp, CLU, Eiffel, Ada, Dylan, JavaScript
Beeinflusste: Groovy
Betriebssystem: plattformunabhängig
Lizenz: 2-clause BSD und eigene (siehe Nutzungsbedingungen)
ruby-lang.org

Ruby (englisch für Rubin) ist eine höhere Programmiersprache, die Mitte der 1990er Jahre von dem Japaner Yukihiro Matsumoto entworfen wurde.

Ruby ist objektorientiert, unterstützt aber mehrere weitere Programmierparadigmen (unter anderem prozedurale und funktionale Programmierung sowie Nebenläufigkeit), bietet dynamische Typisierung, Reflexion und automatische Speicherbereinigung. Ein Programm in Ruby wird zur Laufzeit interpretiert. 2012 wurde die Ruby-Spezifikation als internationale Norm ISO/IEC 30170 standardisiert.[2]

Geschichte[Bearbeiten]

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.[3] Den Namen, hergeleitet vom Edelstein Rubin, wählte er als Anspielung auf die Programmiersprache Perl.[4]

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[Bearbeiten]

Programmierparadigmen[Bearbeiten]

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

Objektorientierte Programmierung[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

Bis vor einiger Zeit wurden Mixins als reine Ergänzung zu klassenbasierter Objektorientierung angesehen. Spätestens seit Sprachen wie Python ist aber 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ßen 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[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

Ruby unterstützt Metaprogrammierung, aspektorientierte Programmierung durch Active Support oder AspectR[5] und kontextorientierte Programmierung[6] durch ContextR.[7]

Prinzipien[Bearbeiten]

Prinzip der geringsten Überraschung[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

Besonderheiten[Bearbeiten]

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[Bearbeiten]

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[Bearbeiten]

Interaktive Ruby-Shell[Bearbeiten]

Interactive Ruby (irb) ist eine Read-Eval-Print Loop (REPL), mit welcher der Anwender interaktiv Ruby programmieren kann. Irb wird mit dem Ruby-Interpreter ausgeliefert und 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

RDoc und ri[Bearbeiten]

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[Bearbeiten]

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

Implementierungen[Bearbeiten]

Referenzimplementierung[Bearbeiten]

Die Referenzimplementierung von Ruby (aktuelle Version: 2.0.0) 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) wurde bis Ende Juni 2013 weiter gepflegt, da 1.9.2 nicht kompatibel zu dieser ist und eine Vielzahl von Programmen deshalb noch nicht fehlerfrei auf der neuen Version liefen.

Der offizielle Interpreter läuft auf den folgenden Betriebssystemen:

Alternative Implementierungen[Bearbeiten]

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[8] ü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,[9] IronRuby,[10] Rubinius[11] und die Ruby Enterprise Edition[12] (Stand: September 2010).

Kritik[Bearbeiten]

Kritik an der Sprache wurde aus verschiedenen Gründen geübt:

  • Da Variablen vor Gebrauch nicht deklariert werden müssen, können bei Tippfehlern unerwartete Laufzeitfehler auftreten.
  • Ruby ist nicht immer abwärtskompatibel.[13]
  • Metaprogrammierung und Monkeypatching erlauben es einem Codestück, alle Klassen und Objekte des Prozesses, in dem es ausgeführt wird, zu ändern.[14]

Auch an der Referenzimplementierung bemängeln Kritiker mehrere Aspekte:

Sonstiges[Bearbeiten]

Anwendungen und Bibliotheken[Bearbeiten]

Als Paketverwaltung und zentrales Repository zur Verteilung von Bibliotheken dient RubyGems, das seit Ruby 1.9 Bestandteil der Standardbibliothek von Ruby ist. In Verbindung mit GitHub, wo ein großer Teil der Bibliotheksentwicklung mit Versionskontrolle, Issue-Tracking-System, usw. stattfindet, löst es damit weitgehend RubyForge und das Ruby Application Archive (RAA) als wichtigste Plattformen ab.

Als wichtige Bibliotheken, die auf Ruby basieren, sind die Web-Frameworks Ruby on Rails und Sinatra zu nennen, die auch über die Ruby-Community heraus sehr einflussreich sind. Auf der Anwendungsseite ist Redmine zu nennen, ein beliebtes Tool zum Projektmanagement.

Nutzungsbedingungen[Bearbeiten]

Ruby ist freie Software. Deshalb 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 2-clause BSD-Lizenz nutzbar. Des Weiteren besteht die Möglichkeit, Ruby unter einer eigenen freien Lizenz zu verwenden.[17] Die Ruby-Lizenz ist GPL-kompatibel und wird von der Free Software Foundation als „frei“ akzeptiert.[18]

Ältere Versionen von Ruby (1.9.2 und früher) verwendeten anstatt der BSD-Lizenz die GPL V2. Als Begründung für den Wechsel wurden Inkompatibilitäten der alten Lizenzierung mit der GPL V3 angeführt.[19][20]

Quellen[Bearbeiten]

  1. Ruby 2.1.1 veröffentlicht. ruby-lang.org. Abgerufen am 24. Februar 2014.
  2. http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=59579
  3. RubyConf: History of Ruby
  4. Ein Interview mit dem Schöpfer von Ruby
  5. http://aspectr.sourceforge.net/
  6. http://www.swa.hpi.uni-potsdam.de/cop/
  7. http://contextr.rubyforge.org/
  8. http://rubyspec.org/
  9. http://wiki.jruby.org/wiki/JRuby_on_Rails
  10. http://iunknown.com/2008/05/ironruby-and-rails.html
  11. http://blog.fallingsnow.net/2008/05/17/rails-on-rubinius/
  12. http://www.rubyenterpriseedition.com/
  13. http://www.infoq.com/news/2007/12/ruby-19
  14. http://avdi.org/devblog/2008/02/23/why-monkeypatching-is-destroying-ruby/
  15. http://www.infoq.com/news/2007/05/ruby-threading-futures
  16. http://www.igvita.com/2008/11/13/concurrency-is-a-myth-in-ruby/
  17. Rubys Lizenzbedingungen. Abgerufen am 15. Januar 2012.
  18. Liste der GPL-kompatiblen Lizenzen. Abgerufen am 8. Juli 2012.
  19. Mailinglistendiskussion zum Lizenzwechsel. Abgerufen am 8. Juli 2012.
  20. Beschluss zum Lizenzwechsel auf dem Ruby Developers Meeting 2010. Abgerufen am 8. Juli 2012.

Literatur[Bearbeiten]

Für Einsteiger

Gesamtdarstellungen

  • Dave Thomas: Programming Ruby, Second Edition. Pragmatic Bookshelf, 2004, ISBN 0-9745140-5-5 (englisch)
  • Hal Fulton: The Ruby Way, Second Edition. Addison-Wesley Professional, 2006, ISBN 978-0-672-32884-8 (englisch)
  • David Flanagan, Yukihiro Matsumoto: Die Programmiersprache Ruby. O´Reilly Media, 2008, ISBN 978-3-89721-874-1

Für Fortgeschrittene

Referenzen

Normen und Standards[Bearbeiten]

  • ISO/IEC 30170 (englisch; standardisiert Ruby auf über 317 Seiten). Erste Version April 2012.

Weblinks[Bearbeiten]

 Commons: Ruby – Sammlung von Bildern, Videos und Audiodateien
 Wikibooks: Ruby-Programmierung – Lern- und Lehrmaterialien