Groovy: Java Scripting (NL)

Dit is de Nederlandse vertaling van een artikel dat ik een tijdje terug in het engels schreef. Bedankt Vicky voor de vertaling!

Een paar dagen geleden struikelde ik over een artikel dat bij onjava.com Groovy introduceert. Groovy is een scripting taal voor Java, dit betekent dat de groovy-scripts kunnen worden uitgevoerd zonder dat ze eerst moeten worden gecompileerd. Dit maakt het zeer gemakkelijk om kleine scriptjes te schrijven die vanaf de commandoregel of van binnenin een Java-applicatie kunnen worden uitgevoerd.

Groovy is niet de enige scripting taal voor Java. Andere zijn onder andere Beanshell, Jython, JRuby en etc. Een aardig overzicht kan hier worden gevonden. De mensen die jEdit gebruiken zullen zeker al van Beanshell gehoord hebben aangezien het de taal is die door jEdit wordt gebruikt Macro's te schrijven.

Zowel Groovy als Beanshell gebruiken een syntaxis die op Java wordt gebaseerd, maar hun doelstellingen zijn een beetje verschillend. Beanshell probeert normale Java documenten te vertalen en lijkt dit zeer goed te doen. Door Beanshell te gebruiken zou het in principe mogelijk moeten zijn om een echte Java-applicatie uit te voeren door de broncode door Beanshell te duwen, in plaats van hen te compileren naar .class-bestanden. Het doel van Groovy is een makkelijk te gebruiken scripting taal te zijn, door wat "suikercode" toe te voegen, om het gemakkelijker te maken om mee te ontwikkelen.

Een voorbeeld: System.out.println("this is a foobar!");
println "this is another foobar!" Beide lijnen zijn geldige groovy-Syntaxis en doen precies hetzelfde: een lijn op het scherm afdrukken. Nochtans is de tweede lijn, in "groovy-Stijl" veel gemakkelijker dan de eerste lijn, die de normale syntaxis van Java gebruikt.

Een ander voorbeeld van suikercode is een ander soort 'foreach' die gebruikmaak van 'closures': l = [1,2,"foo"];

l.each {
println "item ${it}";
}; Wat in deze code gebeurt is het volgende: eerst wordt een lijst ' l ' gecre?erd met elementen 1, 2 en een string "foo". Voor ieder element van de lijst wordt er een regel naar het scherm afgedrukt, wat resulteert in: item 1
item 2
item foo (en het illustreert ook autoboxing).

Twee andere aardige dingen over Groovy zijn dat Het is mogelijk om Groovy-scripts in naar standaard Java-code te compileren (.class-files). Dit geeft klassen die in om het even welke Java-applicatie kunnen worden gebruikt.

Het is zeer gemakkelijk om Groovy-scripten vanop de commandoregel te gebruiken. Eenvoudig typen $ groovy myscript.groovy lanceert het script. Wanneer u een *nix omgeving gebruikt (cygwin onder andere) is het nog gemakkelijker: begin de scriptfile met #!/usr/bin/env groovy en je kan het script starten met $ ./myscript.groovy

Iets anders dat speciaal aan Groovy is, is dat het als JSR wordt goedgekeurd. Het verwonderd me waarom Beanshell geen JSR heeft, aangezien het veel dichter bij Java lijkt te staan dan Groovy.

De reden waarom het artikel bij onjava.com mijn aandacht trok was dat ik een paar maanden geleden al over Groovy had gelezen. Nochtans was dat in een volledige andere context: een open brief van Cedric Beust (die een interessant blog heeft btw ) aan de belangrijkste ontwikkelaar van Groovy. In de brief zegt Cedric dat de ontwikkelaar er een knoeiboel van aan het maken was, door geen roadmap te gebruiken en altijd nieuwe eigenschappen toe te voegen in plaats van eerst een versie 1.0 af te werken. Dit gaf me een eerder negatief gevoel over Groovy en gaf me het gevoel dat Beanshell een betere keuze was dan Groovy. Maar nu ik een beetje met Groovy heb gespeeld, hou ik er ook van en denk ik dat het gewoon 'anders' is dan Beanshell.

Als eindgebruiker ben ik zeer gelukkig met wat ik van Groovy tot nu toe heb gezien. Maar natuurlijk maakt deze negatieve kritiek me een beetje ongerust. Ik investeer liever geen tijd in het leren van een taal die in toekomst dood zal zijn. Tot nu toe denk ik dat ik beide talen zal leren, Beanshell om macro's te schrijven in jEdit (hoewel dat ook mogelijk is met Groovy) en Groovy om scripts te schrijven voor de commandoregel (en dit is ook mogelijk met Beanshell)