Groovy - Christian-Albrechts

Groovy
– Die in Vergessenheit geratene Suche nach
der eleganten Lösung –
Autorin: Christina Brüning
Betreuer: Frank Huch
Seminarausarbeitung Wintersemester 2012/2013
Christian Albrechts Universität zu Kiel
Institut für Informatik
Abgabe am: 22.02.2013
Zugehöriger Vortrag am: 04.03.2013
1
Inhaltsverzeichnis
2 Einleitung ...................................................................................................... 3 3 Einordnung .................................................................................................... 4 4 Anwendungsgebiet ...................................................................................... 5 4.1 Warum wurde Groovy entwickelt? .............................................................................................. 5 4.2 Aktuelle Entwicklungen ..................................................................................................................... 6 5 Konzepte und Struktur ................................................................................ 7 5.1 „Hello World!“ - Ein kurzes Beispiel ............................................................................................ 7 5.2 Features .................................................................................................................................................... 8 5.3 SystemProperties - Ein komplexeres Beispiel ...................................................................... 9 6 Technische Unterstützung ........................................................................ 13 6.1 Entwicklungsumgebung & Portabilität .................................................................................... 13 6.2 Werkzeuge und Bibliotheken ...................................................................................................... 13 7 Diskussion und Zusammenfassung ....................................................... 14 8 Literaturliste ................................................................................................ 15 2 Seite
2 Einleitung
Wenn man heutzutage etwas über die Programmiersprache Groovy erfahren
möchte, so ist man leider auf lediglich einige wenige Werke angewiesen. Es
ist verwunderlich, dass diese Sprache heute aus dem Blickfeld der
Programmierung verschwunden ist. Dabei sind die Artikel, die man über
Groovy finden kann, voll mit dem größten Lob für diese Neuerung in der Welt
der Programmiersprachen. Das Buch „Groovy in Action“, oder in deutschen
Ausgabe „Groovy im Einsatz“, vom deutschen Dierk König, ist als die heilige
Schrift der Groovy-Community zu verstehen und ist auch in dieser
Ausarbeitung stützender Pfeiler. Die Entstehung von Groovy fundiert auf der
Suche nach einer einfachen und
komplexen Sprache, welche
Unabhängigkeit bietet und vergleichsweise wenig spezifisches Wissen
erwartet. Daher sollte sich Groovy auf den (Programm-) Inhalt konzentrieren
und nicht maßgeblich mit der (Entwicklungs-) Umgebung. James Strachan
und Bob McWriter begannen 2003 mit der Entwicklung ihrer Idee zu einer
dynamischen Skriptsprache die auf Java beruhen sollte, bis schließlich im
Januar 2007 das finale Release 1.0 vorstellt werden konnte. Schwerpunkte
bei der Verwirklichung dieses Projektes waren Adaption und Kooperation mit
Java. Bereits im Mai 2007 war Groovy preisgekrönt!1 Es bleibt zu vermuten,
dass sämtliche Wünsche, Ziele und Hoffnungen für und in Groovy auch das
Ende dieser so freudig erwarteten Programmiersprache bildeten. Groovy hat
das vereinfacht was zuvor in Java und anderen Sprachen noch
verhältnismäßig unstrukturiert war und ist elegant sowie in hohem Maße
lesbar. Mann kann Groovy in fast jeder Umgebung nutzen und einbeziehen.
Aber leider muss man auch sagen, dass die Entwicklung von Groovy andere
Sprachen so weit vorangebracht hat, dass diese verständlicher,
benutzerfreundlicher, komplexer und universeller wurden. Groovy hat mit
seinem eigenen Erfolg die Konkurrenz angespornt und ist durch die dortigen
Entwicklungen zu den gleichen Idealen, selbst (in gewisser Weise) auf der
Strecke geblieben und heute kaum noch bekannt.
1 http://de.wikipedia.org/wiki/Groovy 3 Seite
3 Einordnung
Groovy wird als dynamische, objektorientierte Skriptsprache geführt.
Irreführend ist jedoch, dass Groovy formal gesehen nicht den Anforderungen
einer Skriptsprache entspricht. Eine konforme Sprache hätte keinen
separaten Kompilierungsschritt 2 . Die Kompilierung in Bytecode kann in
Groovy aber entweder bewusst veranlasst werden oder wird bei einer
Ausführung des Quellcodes verdeckt und automatisch im Hintergrund
durchgeführt. In jedem Fall besteht die Möglichkeit, den Code erst in (Java-)
Bytecode zu kompilieren, bevor er ausgeführt werden kann. Dies bringt den
Vorteil, dass auch jedes andere Java-Programm Zugriff auf z.B. die mit
Groovy formulierten Methoden hat und umgekehrt Groovy auch Bytecode
anderer Java-Programme ausführen kann. Bei einer „reinen“ Skriptsprache
dürfte es also nach der obigen Definition diesen Kompilierungsschritt nicht
geben, aber da die Funktionsweise trotzdem analog einer Skriptsprache
genutzt werden kann, wird Groovy als eben solche geführt. Groovy grenzt
sich bei der Ausführung von weiteren Programmiersprache ab, denn ein
Groovy Programm kann sowohl als Skript, als auch in kompilierter Form
gestartet werden3. Die Dynamik in Groovy entsteht dadurch, dass Groovy nur
mit Objekten arbeitet, statt mit bestimmten festgelegten Ausgabetypen. Hier
entspricht das Verfahren genau den Richtlinien, was bei vielen anderen
„dynamischen“ Sprachen oft nicht der Fall ist. Dort wird dann vielmals nur das
dynamische Typisieren unterstützt.
2 http://www.oio.de/public/java/groovy/groovy-­‐einfuehrung.htm 3 http://de.wikibooks.org/wiki/Groovy:_Programme_kompilieren_und_starten 4 Seite
4 Anwendungsgebiet
4.1 Warum wurde Groovy entwickelt?
James Strachan und Bob McWriter wollten eine Programmiersprache
erschaffen, welche die Vorteile der JavaVirtual-Maschine nutzen kann, dabei
aber eleganter arbeitet als die bereits existierenden ca. 200 dynamischen
Sprachen. 4 Das diese Idee so weit vorangebracht wurde ist auch als ein
Mitverdienst von Java zu deuten. Denn obwohl Groovy eine Alternative zu
Java schaffen wollte, haben diese Sprachen und ihre Anhänger und
Vorantreiber nie miteinander in Konkurrenz gestanden. Im Gegenteil: Groovy
wurde sogar zur zweiten „Sprache“ für die virtuelle Maschine von Java. Der
Antrag darauf selbst wurde von Richard Monson-Haefel eingereicht und
vorangetrieben. Selbst Sun Microsystems unterstützte diesen Antrag5 und er
stieß auf keine nennenswerte Gegenwehr. Er wurde bereits 2004 bewilligt,
also somit nur ein Jahr nach dem Start der Idee und noch deutlich bevor die
erste Version veröffentlicht werden sollte. In der Dokumentation arbeitete
Dierk König, als einer der ersten Verfolger der neuesten Entwicklungen an
dieser Sprache, an einer Art Betriebsanleitung. Mit Hilfe von weiteren
Entwicklern und Förderern von Groovy, konnte er auch diese Anleitung
veröffentlichten. „Groovy im Einsatz“ ist bis heute das Standardwerk dieser
objektorientierten Skriptsprache und Tutorium, Beispiel und Geschichtsbuch
in einem. Doch auch dieses Werk konnte Groovy auf Dauer nicht bei den
etablierten Programmiersprachen, seien es Compiler- oder Skriptsprachen,
festigen. Gibt es eine Vielzahl an Werken zu den verschiedensten Sprachen,
zum Beispiel zu C oder Java, so ist Groovy in kaum einer Bibliothek noch
vertreten. Nur diejenigen, die sich in der kurzen aber intensiven Phase von
Groovy mit dieser Sprache befasst haben und in Groovy die Möglichkeiten
zur Vereinfachung von Programmcode und somit auch die Einsparung von
Ressourcen sahen, werden dieses Buch noch immer wohl gehütet in ihren
Bücherregalen verwahren. An der rasanten Entwicklung der großen
Programmiersprachen und den regelmäßig erscheinenden Releases lässt
sich erkennen, dass es zeitnah kein Groovy Comeback geben wird. Jedoch
wird der erfahrene Groovy Anhänger auch aktuell immer wieder feststellen,
dass Teile von Groovy nun in den Java-Releases auftauchen.
4 http://www.oio.de/public/java/groovy/groovy-­‐einfuehrung.htm 5 JSR 241 5 Seite
Beispiel:
Zur Vereinfachung von Patterns konnte man in Groovy mit Closures arbeiten.
Diese Vereinfachung wurde nun von den Java-Entwicklern neu entdeckt und
wird höchstwahrscheinlich in Java 8 adaptiert werden.6
4.2 Aktuelle Entwicklungen
Groovy wird und wurde immer schon kostenlos zur Verfügung gestellt, wenn
auch das Team seit der damaligen Euphorie deutlich schrumpfte und
konsequenterweise weniger Ressourcen zur Verfügung stehen. Jedoch sollte
man nicht außer Acht lassen, dass es nicht nur das „neue“ Groovy gab,
sondern auch die Konkurrenz hatte gute Ideen zur Verbesserung und
Vereinfachung bekannter Entwicklungsmethoden. So verließ James Strachan
noch vor der ersten öffentlichen Freigabe von Groovy bereits das Team. Er
wechselte zu ActiveMQ und erachtete fortan Scala als sinnvolle Alternative,
um die Ideen von Groovy fortzuführen7. Im Allgemeinem war dies jedoch nur
ein kleiner Rückschritt auf dem für die kurze Zeit sehr steilen Erfolgsweg von
Groovy. Die erste Veröffentlichung war ein großer Erfolg und die Verleihung
des JAX Innovation Award8 2007 brachte auch noch einmal einen Schritt zur
größeren Beachtung.
„Groovy beweist auf hervorragende Weise, zu welch substanzieller
Innovation die Java-Community auch im Jahre 12 nach ihrer
Gründung fähig ist.[...]Es stellt eine überzeugende Antwort auf den
aktuellen Trend hin zu agilen, dynamischen Programmiersprachen
dar und hilft den Anwendern, ihre getätigten Investitionen in die
Java-Plattform zu sichern“9
Leider hat sich dieser steile Weg nach oben nicht dauerhaft fortsetzen
können und die Entwicklungssprünge von Groovy waren bis Ende 2012, im
Vergleich zum Projektstart, deutlich verhaltener. Es konnten allerdings
Groovy 2.1.0 -beta-1 und Groovy 2.0.6 10 zum Ende des Jahres 2012
6 http://de.wikibooks.org/wiki/Groovy:_Closures#Einfache_Closures 7 http://macstrac.blogspot.de/2009/04/scala-­‐as-­‐long-­‐term-­‐replacement-­‐
for.html 8 Den Jax Innovation Award erhält man für den besten europäischen Beitrag zu Java, Eclipse und SOA 9 http://jax-­‐award.de/jax_award07/gewinner_de.php 10 Release war jeweils der 21.12.2012 6 Seite
veröffentlicht werden. Es gibt einen kleinen Kern um Guillaume Laforge, der
noch immer an der Weiterentwicklung von Groovy für The Codehaus arbeitet
und einen Evolutionssprung bis 2014 zu Groovy 4.0 anstrebt. Inhalte
realisierter und geplanter Neuerungen werden der Öffentlichkeit auf einer
Roadmap präsentiert11. Auch für weitere Releases stehen hier eine Vielzahl
von potenziell interessanten Neuerungen bereit, sodass auch ein MajorRelease 5 wahrscheinlich erscheint.
5 Konzepte und Struktur
5.1 „Hello World!“ - Ein kurzes Beispiel
Betrachtet man das einfachste und gängigste Beispiel „Hello World!“, so
werden bereits signifikante Eigenschaften von Groovy in der Praxis deutlich:
1 println ‚HelloWorld!’
Es fällt sofort ins Auge, dass diese eine Codezeile im Vergleich zu bekannten
Varianten von „Hello World!“ in anderen Programmiersprachen sehr kurz ist.
Positiv ist, dass die Aussage des Programmes für alle Nutzer, auch für
diejenigen mit geringen Programmierkenntnissen, ersichtlich und verständlich
ist. Da Groovy projektorientiert aufgebaut ist, mag es zuerst verwundern,
dass keine „main“-Methode erforderlich ist. Dies ergibt sich daraus, dass
Groovy-Skripte nicht vom Entwickler, sondern vom Compiler verpackt und mit
eben dieser „main“-Methode versehen werden. Dadurch verringert sich der
Programmieraufwand und die Lesbarkeit wird erhöht, beides sind elementare
Ziele dieser Programmiersprache! Die Definition eines Ausgabetyps entfällt,
da Groovy (im Gegensatz zu Java) nur mit Objekten arbeitet. Dazu gehört
auch, dass Befehle wie zum Beispiel „System.out.println(„Hello World!“);“ aus
Java abgekürzt zu „println 'Hello World!' werden. Auch die Klammern und das
Setzen eines Semikolons am Ende einer Zeile fallen weg. Dies reduziert
natürlich auch die Fehleranfälligkeit in diesem Bereich und macht den
Gesamteindruck der Programmiersprache eleganter. Abschließend bleibt zu
zu diesem Beispiel zu sagen, dass man ein Java-Programm von ca. 5 Zeilen
mit nur einer einzigen, kurzen und deutlichen Groovy-Codezeile
implementieren kann. Dies ist natürlich nicht ausreichend für Vermutungen
zur Darstellung von komplexeren Programmen, aber ein guter Einblick in die
Ziele und Schwerpunkte von Groovy.
11 http://groovy.codehaus.org/Roadmap 7 Seite
5.2 Features
Von Java kennt man die Vorschrift, dass Klassenname und Dateiname für die
fehlerfreie Ausführung identisch sein müssen. Dies ist in Groovy nicht er Fall.
Dadurch können auch mehrere Klassen in einer Datei enthalten sein.
Ausnahme sind hier allerdings Dateien, in denen sich nicht nur Klassen
sondern auch ungebundener Code befindet. Diese Dateien dürfen dann nicht
den gleichen Namen wie die Klassen innerhalb der Datei haben, da sonst die
Namensvergabe durch Groovy Probleme mit sich bringt. Da Groovy-Klassen
standardmäßig als public definiert sind, kann diese Definition in der
Implementierung weggelassen werden. Lediglich bei einer anderen
Sichtbarkeit, wie zum Beispiel protected, muss dies als Attribut vor der Klasse
eingefügt werden. 12 Die Klasse „class erstesBeispiel{}“ ist also public und
somit für alle anderen Packages verwendbar. Die Klasse „protected class
zweitesBeispiel{}“ kann nicht anderweitig verwendet werden. Um Klassen
auch ausführen zu können sind nach unserem bisherigen Kenntnisstand
„main“-Methoden nötig. Da Groovy auf Java aufbaut sind Klassen mit „main“Methode dort also ebenfalls ausführbar. Allerdings ist diese Methode in
Groovy nicht zwingend! Sie kann auch durch die Implementierung eines
Interfaces für Runnable ausführbar gemacht werden. Hat das Groovy-Skript
nur ungebundene Ausdrücke kann das Programm ebenfalls ausgeführt
werden. Als Beispiel für die komplexen Möglichkeiten in Groovy nennt Falk
Slippach in seinem Artikel „Einführung in Groovy“ die package private
Attribute aus Java-Programmen, welche in Groovy zu Properties werden13.
Also entsteht bei der Übersetzung von Java zu Groovy aus den JavaAttributen Groovy-Getter und Setter. Weitere Unterschiede von Groovy zu
Java sind, dass im Vorfeld keine Informationen darüber benötigt werden, ob
einem Objekt in Zukunft numerische Werte oder beispielsweise lange
Zeichenketten zugewiesen werden (Typisierung). Außerdem kann auf viele
Importanweisungen, welche die Lesbarkeit des Quellcodes stören, bevor die
ersten „richtigen“ Programmzeilen zu erkennen sind, in Groovy verzichtet
werden (Einfache Einbindung von Codezeilen). Wegen der einfachen Syntax
von Groovy werden keine Separatoren benötigt und eine „return“-Anweisung
kann bei der Rückgabe von Statements entfallen. Groovy liefert beim Fehlen
des „return“-Ausdruckes automatisch die letzte Anweisung zurück14 (Einfache
Lesbarkeit).
12 http://www.oio.de/public/java/groovy/groovy-­‐einfuehrung.htm 13 http://www.oio.de/public/java/groovy/groovy-­‐einfuehrung.htm 14 http://www.oio.de/public/java/groovy-­‐closures-­‐artikel.htm 8 Seite
5.3 SystemProperties - Ein komplexeres Beispiel
Betrachten wir nun ein komplexeres Beispiel für ein Groovy-Programm. Die
Aufgabe des Programms sollte dabei sein, dass aus einer mitgegebenen
Quelle bestimmte Einträge gefiltert werden, welche alle mit einem
gegebenem Schlüssel beginnen. Es müssen also alle Einträge auf einen
bestimmten Prefix hin untersucht, beziehungsweise sortieren werden. Eine
mögliche Implementierung in Java könnte dabei mit Array-Listen arbeiten und
wie folgt aussehen:
1 import java.util.*;
2 public class SystemProperties {
3 public static void main (Sring[] args) {
4
String prefix = args.length > 0 ? args[0] : ““ ;
5
ArrayList entries = new ArrayList ();
6
for (Map.Entry e : System.getProperties().entrySet()) {
7
if (e.getKey().toString().startsWith(prefix)) {
8
entries.add(e);
9
}
10
}
11
Collections.sort(entries,new MeinComperator());
12
for (Object e : entries) {
13
System.out.println(e);
14
}
15
}
16
}
17 class MeinComperator implements Comperator {
18
public int compare(Object o1, Object o2) {
19
return ((Map.Entry)o1).getKey().toString()
.compareTo((Map.Entry)o2)
.getKey().toString());
20
}
21
}
Auffällig ist hierbei, dass wir ein solches Programm für gewöhnlich
ausschließlich als Java-Programm identifizieren würden. Tatsächlich ist
dieses Beispiel aber gleichzeitig auch ein Groovy-Programm. Daraus
erkennen wir, worin eine der größten Stärken von Groovy besteht: Jedes
Java-Programm ist auch als Groovy-Programm mit den gleichen Ergebnissen
und Ausgaben lauffähig!
9 Seite
Die Besonderheit von Groovy ist allerdings nicht, dass dort auch
gewöhnlicher Java-Code läuft. Vielmehr gilt es zu beachten, dass der Code
auch noch stark verkürzt und somit einfacher dargestellt werden kann.
Groovy kann also die gleiche Funktionalität eines Programms sehr viel
kompakter ausdrücken. Im normalem Implementierungsalltag ist es nicht
üblich, erst einen Java-Code zu haben und diesen dann in einen GroovyCode umzuwandeln, doch zum besseren Verständnis möchte ich nun so mit
unserem Beispiel verfahren. Dabei verzichte ich zunächst auf eine Erklärung
der Funktionsweise für den gesamten Code, sondern erkläre die Funktionen
und Möglichkeiten schrittweise. Wir wissen bereits, dass alle Bibliotheken von
Java in Groovy genutzt werden können, ohne dass diese explizit aufgeführt
werden müssen. Dies hat den Vorteil, dass beim nachträglichem Einfügen
von Befehlen aus anderen Bibliotheken diese nicht neu am Anfang
eingebunden werden müssen und beim versehentlichen Vergessen oder
einfachem Weglassen bei Groovy kein Fehler entsteht. Daher können wir
Zeile 1 unseres Beispiel-Codes ersatzlos streichen. Diese Eigenschaft von
Groovy vereinfacht den Programmieraufwand und erleichtert außerdem die
Lesbarkeit. Die Zeilen 2 und 3 beginnen mit der Definition der Sichtbarkeit
des Codes, die in diesem Fall auf „public“ gesetzt sein soll. Groovy geht
automatisch von dieser Einstellung aus und erwartet eine explizite Angabe
nur, falls die Sichtbarkeit nicht auf „public“ gesetzt werden soll. In unserem
Beispiel müssen wir also überhaupt keine Angaben zur Sichtbarkeit
vornehmen. Im weiteren Verlauf definiert Zeile 2 den Code als Klasse. Da wir
in Groovy aber keine Kapselung in Klassen vornehmen müssen, sondern
direkt mit unserem Skript beginnen können kann diese Zeile komplett
gestrichen werden (und infolge dessen auch Zeile 16, wo die Klasse
abgeschlossen werden würde). Mit Zeile 3 können wir ähnlich verfahren, da
wir in Groovy keine „main“-Methoden benötigen. In Zeile 4 erfolgt die
Deklaration der Variable als String. Auch dies kann in Groovy entfallen, da es
keine Typisierung für Variablen, sondern nur für Objekte gibt. Durch diese
dynamische Typisierung können in einem bestehenden Programm leicht
Änderungen an Zuweisungen durchgeführt werden, ohne dass man sich auch
noch die Deklarierung vornehmen muss. Als Beispiel kann man anführen,
dass die Zuweisungen:
variable = „abc“
variable = 42
ohne weitere Zuweisungen genauso hintereinander lauffähig sind. Die erste
Zuweisung der Variablen variable mit dem String abc wird von Groovy mit der
Zuweisung mit dem Integerwert 42 einfach überschrieben. Die Reihenfolge ist
10 Seite
dabei irrelevant und beliebig zu wählen. Zurück in unserem aktuellen
Beispiel-Code kann die Abfrage, ob die Argumentenlänge größer Null ist
(„>0“) weggelassen werden, da wir hier alle Werte als boolsche Ausdrücke
erkennen können. Daher haben wir für alle Werte der Länge außer Null ein
true in dieser Abfrage. Diese Kürzung wäre auch in Java zulässig und erfolgt
für uns nur um den Code weiter zu komprimieren. Abschließend können wir
für diese Zeilen das Semikolon am Ende der Zeile entfernen, da Groovy auf
starr vorgegebene Separatoren verzichtet und den Zeilenumbruch als
Trennung von Befehlen erkennt. Die Zeile könnte also in Groovy wie folgt
aussehen:
4
prefix = args.length ? args[0] : ““
In Zeile 5 des Programms werden die Einträge einer ArrayList definiert und
dafür eine ebensolche mit dem Namen „entries“ neu angelegt. Analog zum
„String“ von oben kann hier das erste „ArrayList“ gestrichen werden und auch
die Definition erfolgt durch einfachere Syntax mit „[]“, statt mit dem Anlegen
einer neuen „ArrayList“:
5
entries = []
Mit dem Ziel der Vereinfachung können wir uns nun auch die Bedingung der
for-Schleife ab Zeile 6 ansehen. Die Definition, dass e ein Map.Entry sein soll
können
wir
weglassen
und
der
Ausdruck
„System.getProperties().entrySet()“ kann zu einem verständlicheren „in
System.properties“ verkürzt werden. In der folgenden if-Abfrage in Ziele 7
kann ebenso das get gestrichen werden, wie auch das toString(), da Groovy
diese Zuweisungen eigenständig deklariert. Außerdem ist die Syntax von
Groovy in soweit gekürzt funktionsfähig, dass gerade leere
Klammerausdrücke, also „()“ komplett entfallen können. Wir erhalten also die
deutlich lesbarere Version:
6
for ( e in System.properties) {
7
if (e.Key. startsWith(prefix)) {
8
entries.add(e);
9
}
10
}
In dem gegebenen Java-Beispiel verwenden wir in Zeile 11 eine andere
Klasse um die Einträge vergleichen zu können („MeinComperator“). Ziel der
Verwendung des Comperators ist es, die Entries nach einem gegebenen
Prefix-Schlüssel zu filtern. In unserem Beispiel-Code verwenden wir
Collections.sort dafür. Der Klasse MeinComperator können wir entnehmen,
dass wir je die zwei Einträge o1 und o2 dafür nutzen wollen. Dazu setzen wir
jeden der Einträge mit „(...)getKey().toString()“ zusammen, bevor wir die
beiden Ausdrücke vergleichen. Unser Groovy-Code hingegen kann direkt im
11 Seite
eigentlichen Programm mit „entries.sort“ starten, ohne den Aufwand einer
zusätzlichen Klasse. Wir können uns auch die zusätzlich definierten Objekte
sparen und verwenden daher sofort e1 und e2. Die Funktion aus dem
Comperator
können
wir
als
anonyme
Funktion
„e1.key.compareTo(e2.key)“ angewendet auf e1 und e2 direkt der Sortierung
selbst mitgeben. Dieses Feature ist vergleichbar mit den Lambda-Funktionen
die uns bereits aus Scheme bekannt sind. Für diese Zeile (und die Zeilen 17
bis 21) erhalten wir also insgesamt folgende verkürzte Version:
11
entries.sort { e1,e2 -> e1.key.compareTo(e2.key) }
Hier ist auffällig, dass unser Code, wie bereits vorangegangen beschrieben,
nun keine „return“-Anweisung mehr enthält. Zeile 12 des gegebenen BeispielCodes sagt nun aus, dass dieser Vergleich über alle Einträge erfolgen soll.
Hier ist die Änderung zum Groovy-Code minimal, denn es wird nur das
„Objekt e“ mit „entry“ bezeichnet und der Doppelpunkt wird zu einem lesbaren
„in“ im Groovy-Programm. Es bleibt noch die Ausgabe. Diese erfolgt in Java
mit dem „System.out.println“-Befehl aus Zeile 13 und wird in Groovy wie folgt
angegeben:
19
println entry
Dabei ist zu beachten, dass wir kein System.out.println“ verwenden müssen
(vergl. Beispiel „Hello World!“), und die Aussage der Zeile daher noch
offensichtlicher wird. Diese ganzen Kürzungen und Änderungen können wir
nun wie folgt zusammensetzen:
1
2
3
4
prefix = args.length ? args[0] : ““
5
entries = []
6
for ( e in System.properties) {
7
if (e.Key.startsWith(prefix)) {
8
entries.add(e)
9
}
10
}
11
entries.sort { e1,e2 -> e1.key.compareTo(e2.key) }
12
for (entry in entries) {
13
println entry
14
}
Zusammengefasst kann man also sagen, dass hier ein Groovy Code von 11
Zeilen ausreichen würde, um den Java-Code von 21 Zeilen auszudrücken.
Dabei ist die kürzere Version aber auch noch deutlich lesbarer und als ein
einziges Skript (ohne Zusatzklasse) ausführbar. Ein geübter GroovyEntwickler könnte den Code natürlich sofort in Groovy implementieren, dies
wurde hier nur zum Vergleich mit Java und dem besserem Verständnis für die
Ziele und Möglichkeiten von Groovy angewendet.
12 Seite
6 Technische Unterstützung
6.1 Entwicklungsumgebung & Portabilität
Nachdem Groovy als Standardsprache für die virtuelle Maschine von Java
anerkannt wurde, könnte man sie überall dort finden, wo auch Java lauffähig
ist. Groovy ist also in hohem Maße plattformunabhängig und kann als
Release 2.0 als Zusatz zu Java (für JDK 7) über „The Codehaus“ frei
bezogen werden15. Alternativ kann Groovy auch als Plugin für Eclipse oder
ähnliche Entwicklungsumgebungen installiert werden.16 So ist eine sehr hohe
Portabilität gegeben. Außerdem ist Groovy-Code sehr schnell zu erschließen
und so auch von fremden Entwicklern in seiner Funktionalität leicht zu
erfassen. Das Auslesen des Codes ist also nicht einmal an einzelne
Entwicklerteams gebunden, sondern ist auch dort in hohem Maße flexibel.
Die Verbreitung von verschiedenen, komplexeren Groovy-Projekten ist in der
Java-Welt ebenfalls kein Hindernis, da „[...] auf der Bytecode-Ebene, [...]
Groovy gleich Java ist, sodass sich beide Sprachen nahtlos integrieren
lassen.“17
6.2 Werkzeuge und Bibliotheken
Nach Dierk König ist Groovy eine Weiterentwicklung von Java, mit nützlichen
Zusätzen und ohne überflüssige Formalitäten. Da Groovy als Sprache für die
JVM anerkannt wurde, ist es wohl nicht verwunderlich, dass alle Bibliotheken
aus Java auch für Groovy verwendet werden können. Die nötige
Umwandlung ist dabei nicht einmal vom Anwender selbst vorzunehmen
sondern erfolgt automatisch vom Compiler. Java hatte bereits 2007 Zugriff auf
ausführliche Klassenbibliotheken und auch heute noch sind die Bibliotheken
von Java das Grundgerüst von Groovys Bibliotheken. Es werden also alle
Möglichkeiten von Java übernommen und sogar noch erweitert. Dies gilt auch
für sämtliche Werkzeuge aus Java, wie zum Beispiel Profiler und Debugger.
Sie können sofort in Groovy übersetzt und analog zu Java verwendet werden.
Da Java in vielen Bereichen Einsatz findet, kann man zumindest ansatzweise
erfassen, in welchen Umfang Groovy samt Werkzeugen und Bibliotheken zur
Verfügung stehen könnte.
15 http://groovy.codehaus.org 16 http://groovy.codehaus.org/Eclipse+Plugin 17 Dierk König in „Groovy im Einsatz“ 13 Seite
7 Diskussion und Zusammenfassung
Möchte man abschließend über Groovy allgemein und den Einsatz von
Groovy im Speziellen diskutieren, so ist der wohl wichtigste Punkt die Zeit. Es
hat wohl nie die richtige Zeit für Groovy gegeben und es ist sehr
unwahrscheinlich, dass sie noch kommen wird. Zum Start von Groovy waren
die Ideen und Visionen zu dieser Programmiersprache ihrer Zeit noch voraus.
Es wurden Möglichkeiten angestrebt, die sich manche kaum vorstellen
konnten und die so fantastisch klangen, dass man an ihre Verwirklichung
noch gar nicht glauben wollte oder konnte. Zur heutigen Zeit ist Groovy
jedoch nicht mehr präsent. Sicherlich haben einige Wenige schon einmal von
dieser Sprache gehört und verfolgen ihre Entwicklung noch heute. Aber
Groovy hat in seiner vergleichsweise kurzen Existenz von 2003 bis heute
seine einflussreichste Zeit bereits hinter sich gebracht und das noch bevor sie
überhaupt richtig begonnen hatte. Sicherlich klingen auch nach der
Einarbeitung in diese Sprache die Vorteile und Ideale verlockend, aber es
fehlt die ausreichende Förderung durch Dritte. Als jemand, der nicht von
Groovys Anfang an dabei gewesen ist, ist der Einstieg in diese Materie,
meiner Meinung nach, nur im Selbststudium empfehlenswert, denn so wird
einem die Komplexität der Möglichkeiten durch die virtuelle Maschine von
Java noch deutlicher. Sicherlich gibt Groovy auch einen guten Einblick in die
Möglichkeiten von Java, sozusagen als Java-Pseudocode-Mash-Up. Aber
betrachtet man beispielsweise das heutige Studium der Informatik, so könnte
ich keinen ausreichend großen Platz nennen, der für Groovy geeignet ist.
Sicherlich sollte die Existenz von Groovy nicht verschwiegen werden, wenn
man Java betrachtet, aber es wäre wohl nicht sinnvoll damit ganze Module zu
belegen und anderen aktuelleren Sprachen ihren Platz streitig zu machen.
Abschließend bleibt für mich festzuhalten:
Die Zeit von Groovy ist nicht heute und wohl auch nicht morgen, vielleicht
wird die Idee des programmierbaren Pseudocodes nochmal aufgegriffen,
aber diesen Termin kann und muss sich heute noch niemand im Kalender
anstreichen.
14 Seite
8 Literaturliste
Groovy Homepage
http://groovy.codehaus.org/
Dierk König u. a.:
„Groovy im Einsatz“
2007
Carl Hanser Verlag GmbH & CO.KG
ISBN 978-3-446-41238-5
Falk Sippach:
„Einführung in Groovy“
http://www.oio.de/public/java/groovy/groovyeinfuehrung.htm
„Groovy Closures“
http://www.oio.de/public/java/
groovy-closures-artikel.htm
Artikel zu Groovy:
http://de.wikipedia.org/wiki/Groovy
http://de.wikibooks.org/wiki/Groovy:_
Quellprogramme_direkt_ausführen
http://de.wikibooks.org/wiki/Groovy:_
Closures#Einfache_Closures
http://jax-award.de/jax_award07/gewinner_de.php
James Strachans Blog:
http://macstrac.blogspot.de/2009/04/scala-aslong-term-replacement-for.html
15 Seite