Tech-Talk: Python vs. Ruby

Python vs. Ruby

Tobias Schlauch <[email protected]>Tech-Talk, DLR Braunschweig, 23.03.2010

Folie 2The DLR Software Engineering Network > Schlauch, T.

Übersicht

MotivationDie Kontrahenten im ÜberblickSyntaxSpracheigenschaftenObjektorientierungStringsWerkzeugunterstützung PerformanceVerwendungFazit


Motivation

Eine Vielzahl so genannten Skriptsprachen – existiertBeispiele: Python, Ruby, Groovy, Perl, PHP, LISP, Tcl, …Gemeinsamkeiten:

Implizite VariablendeklarationDynamische TypisierungInterpretiertAutomatische Speicherbereinigung

Welche Sprache ist für mich die richtige?Hängt von der Anforderungen ab und erfordert Kenntnisse der jeweiligen Spezifika.Deshalb hier ein Vergleich der populären Skriptsprachen Python und Ruby


Die Kontrahenten im ÜberblickPython (1/2)

Entwicklung Anfang der 1990er Jahre durch Guido van Rossum am Zentrum für Mathematik und Informatik in Amsterdam als Ersatz der Programmierlehrsprache ABC

Philosophie - Auszug aus dem Python-Zen:Explicit is better than implicit.Simple is better than complex.Readability counts.There should be one -- and preferably only one --obvious way to do it.If the implementation is hard to explain, it's a bad idea.


Die Kontrahenten im ÜberblickPython (2/2)

Weiterentwicklung der Referenzimplementierung durch die Python Software FoundationReferenzimplementierung: CPythonAktuelle Version: 3.1.2 (21. März 2010)

2.6.5 (19. März 2010)

Weitere Implementierungen: Jython, IronPython, PyPy,Parrot, Stackless Python

Lizenz: Python License

Projektseite: http://python.org/


Die Kontrahenten im ÜberblickRuby (1/2)

Entwicklung Mitte der 1990er Jahre aus Unzufriedenheit über verfügbare Skriptsprachen durch Yukihiro Matsumoto

Verbreitung zunächst nur in Japan, seit 2000 Bemühungen zur Verbreitung über Japan hinaus ausgeweitet

Philosophie: Principle of Least Surprise

„ Ruby is two parts Perl, one part Python, and one part Smalltalk” - Colin Steele


Die Kontrahenten im ÜberblickRuby (2/2)

Weiterentwicklung durch Yukihiro Matsumoto und andere EntwicklerReferenzimplementierung: CRubyAktuelle Version: 1.9.1-p378 (10. Januar 2010)

1.8.7-p249 (10. Januar 2010)

Weitere Implementierungen: JRuby, IronRuby, Rubinius, Cardinal, MacRuby, Ruby Enterprise Edition, …

Lizenz: Ruby License, GPL

Projektseite: http://www.ruby-lang.org/de/


SyntaxGemeinsamkeiten

Anweisungen enden ohne Semikolon

Viele Schlüsselworte sind ähnlich

Erzeugung von Listen per []

Erzeugung von Hashes/Dictionaries per {}

Kürzere Quelltexte als vergleichbare Java/C++-Programme


Syntax„Hello World!“ - Python

knownGreetings = {"german": ["Hallo Welt!", "Super hier!"],"english": ["Hello World!", "Cool here"]}

def extendedGreetings(language):result = ""if language in knownGreetings:

for greet in knownGreetings[language]:result += greet + " "

return result

print extendedGreetings("german") liefert: "Hallo Welt! Super hier!"

print extendedGreetings("english") liefert: "Hello World! Cool here"print extendedGreetings("unknown") liefert: ""


Syntax„Hello World!“ - Ruby

$knownGreetings = {"german" => ["Hallo Welt!", "Super hier!"],"english" => ["Hello World!", "Cool here"]}

def extendedGreetings(language)result = ""if $knownGreetings.has_key? language$knownGreetings[language].each do |greet|result += greet + " "

endendresult

end

puts extendedGreetings("german") liefert: "Hallo Welt! Super hier!"

puts extendedGreetings("english") liefert: "Hello World! Cool here"puts extendedGreetings("unknown") liefert: ""


SyntaxUnterschiede zu Python

Einrückung ist freiwillig => Beendung mehrzeiliger Anweisungen durch end

Flexibel einsetzbare Code-BlöckeAufruf von Methoden ohne KlammernAlles ist ein AusdruckImplizites return

Erzwungene Namenskonventionen für Klassen, Variablen, …true, false, nil entspricht True, False, None

Nur nil und false werden negativ in Bedingungen ausgewertetKeyword-Argumente werden durch Hashes emuliertVerknüpfung von Namesspaces durch den ::-Operator


SpracheigenschaftenGemeinsamkeiten

MultiparadigmenunterstützungProzedural, Funktional, Objektorientiert

Durch und durch objektorientiert - Alles ist ein Objekt!Variablen sind Referenzen auf ObjekteDynamische, starke Typisierung – a.k.a „Duck Typing“Beliebige Erweiterbarkeit von KlassenDefinition von Methoden auf Klassen- und ObjektebeneUnterstützung von Introspektion und MetaprogrammierungException-Unterstützung (andere Syntax)


SpracheigenschaftenUnterschiede zu Python

Starke Unterscheidung der Realisierung der Konzepte Klasse, Attributund MethodeZugriff erfolgt ausschließlich auf Methoden

Python-artige Properties durch optionale KlammerungEinschränkung der Sichtbarkeit durch public, protected, private

Mixins anstatt von MehrfachvererbungUnterstützung von globalen Variablen - $globalVar

Existenz eines Listentyps, der als Tupel, Liste, Queue, Stack verwendet wirdModul- und Pakethierarchien existieren nur per Konvention


ObjektorientierungKlassen, Attribute, Methoden in Python (1/2)

class Test(object):

classVar = 1

def __init__(self, instanceVar):

self.__instanceVar = instanceVar

def doSomething(self):

print "I do it.. %i" % self.__instanceVar

self.__class__.classVar += 1

def _doSomething(self):

print "I am protected."

def __doSomething(self):

print "I am private."


ObjektorientierungKlassen, Attribute, Methoden in Python (2/2)

t1 = Test(1)

t2 = Test(2)

print Test.classVar liefert: "1"

t1.doSomething() liefert: "I do it.. 1"


print Test.classVar, Test.classVar liefert: "3, 3"

t1._doSomething() liefert: "I am protected."

t1.__doSomething() liefert: "AttributeError: 'Test' object has no attribute '__doSomething'"


ObjektorientierungKlassen, Attribute, Methoden in Ruby (1/2)

class Test@@classVar = 1

def initialize(instanceVar)@__instanceVar = instanceVar

end

def doSomethingputs "I do it.. %i" % @__instanceVar@@classVar += 1

end

def _doSomethingputs "I am protected."

endprotected :_doSomething

...


ObjektorientierungKlassen, Attribute, Methoden in Ruby (2/2)

def __doSomething

puts "I am private."

end

private :__doSomething

def self.classVar

@@classVar

end

end

t1 = Test(1)

t2 = Test(2)

print Test.classVar liefert: "1"



print Test.classVar, Test.classVar liefert: "3\n3"

t1._doSomething() liefert: "protected m...(NoMethodError)"

t1.__doSomething() liefert: "private m...(NoMethodError)"


ObjektorientierungMehrfachvererbung in Python

class A(object):def a(self):

print "Instance of A"

class B(object):def b(self):

print "Instance of B"

class C(A, B):def c(self):

self.a()self.b()

c = C()c.c() liefert: "Instance of A\nInstance of B"


ObjektorientierungEinfachvererbung und Mixins in Ruby

class Adef aputs "Instance of A"

endendmodule B

def bputs "Instance of B"

endendclass C < A

include Bdef cab

endendc = C.newc.c() liefert: "Instance of A\nInstance of B"

Mixin


Objektorientierung„Duck Typing“ in Python (1/2)

class Bird(object):

def __init__(self, name):self.name = name

def __str__(self):return self.name

class Duck(Bird):def quak(self):

print "quak"


Objektorientierung„Duck Typing“ in Python (2/2)

for duck in [Bird("Tweety"), Duck("Dagobert"), object()]:

try:

duck.quak()

except AttributeError:

print "Is not a duck: ", duck

Liefert:

Is not a duck: Tweety

quak

Is not a duck: #<Object:0xd1329>


Objektorientierung„Duck Typing“ in Ruby (1/2)

class Birddef initialize(name)

@name = nameend

def to_s@name

endend

class Duck < Birddef quak

puts "quak"end

end


Objektorientierung„Duck Typing“ in Ruby (2/2)

[Bird.new("Tweety"), Duck.new("Dagobert"), Object.new()].each do |duck|

begin

duck.quak

rescue NoMethodError

puts "Is not a duck: %s" % duck

end

end

Liefert:

Is not a duck: Tweety

quak

Is not a duck: #<Object:0xd1329>


Strings

PythonUnterscheidung von 8-Bit-(binär)- und Unicode-StringsStrings sind generell immutableUnicode-Support ist nativ implementiert

RubyUnterscheidung von Strings (mutable) und Symbols (immutable)Ab Version 1.9 encoding-Methode hinzugefügt und Behandlung von Strings mit unterschiedlichen Encodings verbessertSeparater Unicode-Support (Typ) als Zusatzmodul prototypisch realisiert


WerkzeugunterstützungLieferumfang der Referenzimplementierung

PythonInteraktiver Interpreter (python) – GIL!Umfangreiche Standardbibliothek (+)pydoc als Dokumentationswerkzeug (kaum akzeptiert)

Alternativen: Doxygen, EpydocDistutils als Paketverwaltungswerkzeug

Alternative: setuptoolsRuby

Interaktiver Interpreter (irb) – GIL, Garbage Collector!Umfangreiche StandardbibliothekRDoc und ri als Dokumentationswerkzeuge (+)RubyGems (gems) als Paketverwaltungswerkzeug mit Versionierungsunterstützung (+)


WerkzeugunterstützungIntegrierte Entwicklungsumgebungen

Für Python und Ruby existieren Integrationen in Eclipse, Netbeans, Komodo sowie weitere Thrid-Party-IDEs existierenTest der Eclipse-Plugins

Python (PyDev)Performance höherAutovervollständigung präziserDebugger-HandlingInteraktive Konsole

Ruby (Aptana RadRails)Refactoring-Unterstützung kompletterUnittest-Integration grafisch unterstützt

Insgesamt für beide zur professionellen Entwicklung geeignet


WerkzeugunterstützungUnittests / Code-Coverage / Code-Style

UnittestsEingebaute Unittest-Frameworks sind vorhanden und machen einen guten Eindruck

Code-CoverageVerschiedene Projekte existieren/existierten in Python

coverage.py mit Unterstützung von C0- und C1-Coverage und der Ausgabe in verschiedene Formate ist derzeit die beste Wahl

rcov mit Unterstützung der C0-CoverageCode-Style

Für Python ist derzeit pylint die beste WahlFür Ruby konnte ich kein Werkzeug finden

Hier aber ein paar „ähnliche“ Werkzeuge: http://devver.net/blog/2008/10/ruby-tools-roundup/


Performance

Generell ist die Performance von Python 2.X ähnlich einzuschätzen als die von Ruby 1.X bzgl. der Referenzimplementierung

Python 3.X verspricht weitere OptimierungSiehe auch: http://www.testfreaks.com/blog/news/python-and-ruby-performance/Und: http://blog.ianbicking.org/ruby-python-power.html#performance-environment

Für beide existieren JIT-Compiler zur OptimierungPython: psychoRuby: Ludicrous JIT Compiler

Performancekritische Programmbereiche können von beiden z.B. in C/ C++ ausgelagert werden


Verwendung und Verbreitung

PythonNutzung in Webframeworks: Django, Pylons, Zope, …Skriptsprache für C++-Programme100-Dollar-LaptopPyPi: 9382 Pakete

RubyWebframework: Ruby on RailsRubyForge und Ruby Application Archive: 7000

TIOBE Programming Community Index (März 2010):http://www.tiobe.com/index.php/content/paperinfo/tpci/index.htmlPython auf Platz 7Ruby auf Platz 11


Fazit (1/2)

Generell nehmen sich beide Sprachen nicht viel bzgl. ihrer grundlegenden „Ausdruckskraft“Ruby verletzt die Regeln des Python-Zen und kann Perl ähnlich sehen, was viele Pythonisten abschreckt. Bei genauerem Hinsehen wird deutlich, dass beide Sprache sehr ähnliche Ziele verfolgen, diese aber mit unterschiedlichen Mitteln erreichen. Die Communities von Python und Ruby sind deshalb oft in produktivem Kontakt.http://www.ruby-lang.org/de/documentation/ruby-from-other-languages/to-ruby-from-python/

Lesbarkeit und Wartbarkeit ist meiner Meinung nach bei Python wesentlich höher ausgeprägt!!


Fazit (2/2)

Werkzeugunterstützung ist ähnlich gutVorteil Ruby: Es gibt so etwas wie Standardwerkzeuge zur Dokumentation und PackagingVorteil Python: Stärkere Standardbibliothek und bessere Unterstützung im QS-Bereich (pylint!)

Performance ist in den Referenzimplementierungen ähnlich einzuschätzen

Vorteile in der Verwendung und Verbreitung liegen bei Python


Vielen Dank!Fragen??

Weitere Quellen:http://de.wikipedia.org/wiki/Python_%28Programmiersprache%29http://de.wikipedia.org/wiki/Ruby_%28Programmiersprache%29

Documents

Tech-Talk: Python vs. Ruby