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

 

Seite  2  

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  

 

Seite  3  

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  

 

Seite  4  

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  

 

Seite  5  

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  

 

Seite  6  

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  

 

Seite  7  

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 Major-Release 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  

 

Seite  8  

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 Java-Attributen 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  

 

Seite  9  

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!

 

Seite  10  

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 Groovy-Code 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

 

Seite  11  

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

 

Seite  12  

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 Beispiel-Codes 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 Groovy-Entwickler 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.

 

Seite  13  

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“  

 

Seite  14  

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.

 

Seite  15  

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/groovy- einfuehrung.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-as-

long-term-replacement-for.html