Mysiga Groovy

När det kommer till programmeringsspråk, så är min favorit helt klart språket Groovy. Man skulle kunna uttrycka det som att Groovy är Java++. Precis som för 20-år sedan, då C-programmerare gradvis övergick till C++, så går Java-programmerare gradvis över till Groovy. Skälet är enkelt; man kan börja med en Java klass, byta namn på filändelsen från '.java' till '.groovy', kompilera med Groovy kompilatorn och sen stegvis göra koden mer "groovy".

Ett Groovy program, exekverar i Java-motorn (JVM) på samma sätt som ett Java program och det är hur enkelt som helst att blanda och mixa Java med Groovy i samma applikation. Det finns flera JVM-språk att välja på nu för tiden förvisso (Groovy är äldst), men inget av alternativen smälter så lätt samman med Java kod.

Här är ett exempel som visar styrkan i Groovy och användandet av closures (lambda uttryck). Antag att vi av något outgrundligt skäl vill kvadrera alla tal mellan 1 och 100, samt summera ihop dessa. Så här kan man göra i Groovy:
Först skapar vi en Range för talen 1 till 100. En range uppträder som en lista, utan att representera talen explicit. Sen anropar vi funktionen collect, som löper i genom alla element och applicerar en closure, som kvaderar sitt argument. Resultatet från collect är nu en lista (med kvadrerade heltal). Slutligen anropar vi funktionen inject, som ackumulerar alla talen mha ytterligare en closure. Resultatet visas i GroovyConsole, som är en utmärkt testlåda för både Groovy och vanlig Java kod.

Här är ett annat exempel, där jag använder Spread operator (*.). Häng med!
Först ber vi system klassen om alla konfigurations variabler. Det som returneras är en Map, som kan liknas vid en uppslagstabell eller associativ array.

Sen applicerar vi funktionen getKey() på varje Map.Entry object, med hjälp av spread-operatorn och det faktum att en getter kan uttryckas som access av en egenskap (property). Resultatet blir nu en lista av nyckel-värden (det finns totalt 62 stycken).

Efter det filtrerar vi ut alla nycklar som börjar med 'os'. Slutligen, sammanställer vi en lista med text strängar som innehåller "nyckel=värde" för de filtrerade system egenskaperna.

Fortfarande inte imponerad? OK, låt mig få sätta in det tunga artilleriet. Här ser du ett litet Groovy program, där jag delat upp det i några få funktioner för att öka läsbarheten. I korta drag läser programmet ned HTML sidan http://java.sun.com/j2se/1.5.0/download-pdf.html och extraherar ut alla (relativa) PDF länkar och presenterar dem som en HTML lista.
Själva huvudprogrammet ser du på raderna 12-15. Vi börjar med att ladda ned ett tredje-parts bibliotek från Maven Central Repository (rad 1), vilket sedan cache:as  till efterföljande gånger vi kör scriptet.

Funktionen fetch() använder biblioteket TagSoup för att tolka den HTML fil som laddas ned.

Funktionen extract() tar sedan en träd-representation av HTML koden och filtrerar ut alla A-taggar i BODY. För varje A-tag, så hämtas värdet för HREF-attributet ut, om det slutar med '.pdf'. Resultatet är nu en lista med relativa länkar såsom "../1.5/pdf/JPS_PDF.pdf".

Funktionen normalize() använder Java:s egen URL klass för att skapa absoluta URL:er, dvs börjar med 'http:...'. Slutligen, loopar vi över alla URL:er och printar ut var och en som ett HTML list-element (LI).

Är det häftigt, eller är det häftigt :-)

Passa på att boka din Groovy kurs på Informators kurssida.

2 kommentarer

Tycker att man även bör nämna något om Groovys svagheter, nämligen att det är ett dynamiskt typat språk och att man därför inte får någon "compile time check" samt att koden tolkas i runtime och därför exekveras väsentligt långsamare (runt en faktor 10) än Java. Tycker personligen att Scala är ett betydligt bättre språk, med en syntax och funktionalitet liknande Groovy men utan Groovys nackdelar.

Svara

Att Groovy är dynamiskt typat utgör en av dess stora styrkor och fördelar. Det brukar kallas för "Duck Typing".

Det är detta som gjort språket så flexibelt och skapat möjligheten för exempelvis builders såsom MarkupBuilder, SwingBuilder, AntBuilder med flera. Dessa bildar sedan grunden för dynamiska ramverk såsom Grails för webbapplikationer, Griffon för skrivbordsapplikationer, Gradle som ersättare för Ant/Maven för generell programbyggnation och många fler.

I allt väsentligt talar vi om olika programmeringsparadigmer. Under vissa perioder har statisk typning varit mest efterfrågat och under andra perioder dynamisk typning. Sedan mitten av 2000-talet (runt 2005) har dynamisk typning blivit mer och mer populärt, i efterdyningarna efter Ruby och dess Rails webbramverk, som gjorde dundersuccé vid den tiden.

Andra språk med dynamisk typning som är populära är t.ex. Clojure och Erlang. Clojure bygger på språket LISP, vilket daterar sig bak ända till slutet på 1950-talet och Erlang är en intressant smältdegel av Prolog, ML och SmallTalk, vilka daterar sig till tidigt 1980-tal.
Clojure och porteringen Erjang kör båda på JVM:en.

Scala har en annan bakgrund och utvecklingstradition och bygger på idéér från bl.a. Ada och Eiffel, båda språk med mycket stark (statisk) typning. Till detta kommer en modern mix av språkliga element hämtade från funktionella språk.

Prestanda mässigt evolverar alla språk. Går vi tillbaka till 1990-talet var Java (och därmed JVM:en) betraktat som ett långsamt språk. Med kombinationen av (a) införandet av HotSpot JVM och gradvisa förbättringar av densamma och (b) bättre hårdvara, har Java/JVM blivit betydligt bättre och för server-applikationer i vissa stycket bättre än C/C++.

Java 7 (JVM:en) har en ny byte code instruktion 'invokeDynamic', som förväntas ge en mycket stor prestanda förbättring av alla dynamiskt typade språk på JVM:en, i takt med att de anpassas för Java 7.

För just språket Groovy, finns det ett projekt med namn Groovy++, som analyserar koden och transformerar lämpliga delar som inte utnyttjar dynamisk typning till statisk typning. Därmed kan man både äta och ha kakan kvar. Groovy++ involveras stegvis i vanliga Groovy just nu och förväntas, tillsammans med invokeDynamic, medföra ännu bättre prestanda i Groovy 2.

Ett gemensamt drag, vi kan se i all programspråks-utveckling är att först kommer egenskaperna sedan kommer prestandan. Ett bra bevis på detta är just Erlang och Java var för sig, som båda startade som hopplöst långsamma språk, men 20 år senare tillhör världseliten vad beträffar prestanda och skalbarhet.

Slaget om Java's efterföljare står mellan Groovy och Scala. Vilket av dessa man väljer handlar nog mycket om hur man ser på programmering och var man väljer att lägga tonvikten. Båda är eminenta språk, men skiljer sig i programmerings-filosofi.

Intressant nog så inspirerar de varandra också, både språk-mässigt och biblioteks-/ramverks-mässigt. En kul observation i det sammanhanget, är att Groovy's upphovsman James Strachan också är en stor 'contributor' till Scala. Så troligtvis, kommer vi se en gradvis konvergens mellan dessa språk under ett antal år framöver.

Svara

Skicka en kommentar

Trevligt att du vill dela med dig av dina åsikter! Tänk på att hålla på "Netiketten" och använda vårdat språk.