Apache Groovy: differenze tra le versioni
m Bot: fix citazione web (v. discussione) |
m fix Template Webarchive - collegamenti all'Internet Archive |
||
(24 versioni intermedie di 15 utenti non mostrate) | |||
Riga 1: | Riga 1: | ||
{{Nota disambigua|l'album di [[Red Garland]]|Groovy (album)|Groovy}} |
|||
{{S|linguaggi di programmazione}} |
|||
{{Linguaggio di programmazione |
{{Linguaggio di programmazione |
||
|nome = Groovy |
|nome = Apache Groovy |
||
|immagine = Groovy-logo.svg |
|immagine = Groovy-logo.svg |
||
|didascalia = |
|didascalia = |
||
Riga 8: | Riga 8: | ||
|versione = |
|versione = |
||
|utilizzo = [[General purpose]] |
|utilizzo = [[General purpose]] |
||
|paradigmi = |
|paradigmi = [[Programmazione orientata agli oggetti|Orientato agli oggetti]], [[Programmazione imperativa|imperativa]], [[Linguaggio di scripting|scripting]] |
||
|tipizzazione = [[Tipizzazione forte|Forte]], [[Tipizzazione dinamica|Dinamica]] |
|tipizzazione = [[Tipizzazione forte|Forte]], [[Tipizzazione dinamica|Dinamica]] |
||
|specifiche = |
|specifiche = |
||
|estensione = |
|estensione = |
||
|influenzato_da = [[Java (linguaggio di programmazione)|Java]], [[Python]], [[Ruby]], [[Perl]], [[Smalltalk]], [[Objective-C]] |
|influenzato_da = [[Java (linguaggio di programmazione)|Java]], [[Python]], [[Ruby (linguaggio di programmazione)|Ruby]], [[Perl]], [[Smalltalk]], [[Objective-C]] |
||
|ha_influenzato = |
|ha_influenzato = |
||
|implementazione_riferimento = |
|implementazione_riferimento = |
||
|sistema_operativo = [[Multipiattaforma]] |
|sistema_operativo = [[Multipiattaforma]] |
||
|lingua = |
|lingua = |
||
|licenza = [[Licenza Apache]] v. 2.0 |
|licenza = [[Licenza Apache]] v. 2.0 |
||
|sito_web = |
|sito_web = |
||
}} |
}} |
||
'''Groovy''' è un [[linguaggio di programmazione]] [[Programmazione |
'''Apache Groovy''', fino al 2015 solo '''Groovy''', è un [[linguaggio di programmazione]] [[Programmazione a oggetti|a oggetti]] per la [[Piattaforma Java]] alternativo al [[Java (linguaggio di programmazione)|linguaggio Java]]. È un linguaggio sia statico che dinamico, può quindi essere utilizzato sia come linguaggio di programmazione che come [[linguaggio di scripting]]. Presenta caratteristiche simili a quelle di [[Python]], [[Ruby (linguaggio di programmazione)|Ruby]] e [[Smalltalk]]. A volte ci si riferisce a Groovy con il nome alternativo di ''JSR 241''. |
||
== Caratteristiche == |
== Caratteristiche == |
||
Groovy usa una [[sintassi (informatica)|sintassi]] simile a quella di Java, basata su [[parentesi graffa|parentesi graffe]], |
Groovy usa una [[sintassi (informatica)|sintassi]] simile a quella di Java, basata su [[parentesi graffa|parentesi graffe]], viene compilato in [[bytecode]] per la [[Macchina virtuale Java|Java Virtual Machine]], ed interagisce in modo trasparente con altro codice Java e con le librerie esistenti. Il [[compilatore]] di Groovy può essere usato per generare bytecode Java standard che può quindi essere usato da qualsiasi progetto Java. Groovy può anche venire usato come linguaggio di scripting dinamico. |
||
Altre caratteristiche: |
Altre caratteristiche: |
||
* [[Tipizzazione dinamica]] |
* [[Tipizzazione dinamica]] e [[Tipizzazione statica]] |
||
* Sintassi nativa per liste, mappe ed [[espressioni regolari]] |
* Sintassi nativa per liste, mappe ed [[espressioni regolari]] |
||
* [[ |
* [[Closure (informatica)|Chiusure]] |
||
* [[Overloading]] degli operatori |
* [[Overloading]] degli operatori |
||
== Confronto della sintassi == |
== Confronto della sintassi == |
||
;Standard Java (Java 5+) |
;Standard Java (Java 5+) |
||
< |
<syntaxhighlight lang="java"> |
||
for (String item : new String [] {"Rod", "Carlos", "Chris"}) { |
|||
if (item.length() <= 4) System.out.println(item); |
|||
} |
|||
</syntaxhighlight> |
|||
</source> |
|||
;Groovy |
;Groovy |
||
< |
<syntaxhighlight lang="groovy"> |
||
["Rod", "Carlos", "Chris"].findAll { it.size() <= 4 }.each { println it } |
|||
</syntaxhighlight> |
|||
</source> |
|||
== |
== Getter, setter e visibilità == |
||
Rispetto a Java, Groovy consente di ridurre la dimensione del codice scritto generando automaticamente i metodi getter e setter per ogni classe e impostando la visibilità "public" di default, senza richiedere che venga specificata ogni volta. |
|||
Per creare una proprietà in sola lettura sarà sufficiente implementare il metodo getter omettendo il setter. |
|||
Un altro vantaggio è l'assenza del punto e virgola (;) come terminatore di linea. |
|||
;Standard Java (Java 5+) |
|||
<syntaxhighlight lang="java"> |
|||
public class Libro { |
|||
private String titolo; |
|||
private String autore; |
|||
public void setTitolo(String valore) { |
|||
this.titolo = valore; |
|||
} |
|||
public String getTitolo() { |
|||
return this.titolo; |
|||
} |
|||
// La proprietà 'author' non ha un metodo setter |
|||
// ed è quindi in sola lettura |
|||
public String getAutore() { |
|||
return this.autore; |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
;Groovy |
|||
<syntaxhighlight lang="groovy"> |
|||
class Libro { |
|||
String titolo |
|||
String autore |
|||
// La proprietà 'autore' definisce un metodo getter esplicito |
|||
// che la rende in sola lettura |
|||
String getAutore() { |
|||
return autore |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
== Null Safe == |
|||
Groovy definise degli operatori di confronto che riescono a gestire valori Null senza generare una eccezione<ref>[https://docs.oracle.com/en/cloud/saas/applications-common/23d/cgsac/understanding-groovys-null-safe-comparison-operators.html#u30004087 Operatori di confronto Null-Safe]</ref>. Ad esempio: |
|||
<syntaxhighlight lang="groovy"> |
|||
if (100 > null) { |
|||
// Ritorna 'true' ed eseguirà il codice nel blocco |
|||
} |
|||
if (null > 100) { |
|||
// Ritorna 'false' e NON eseguirà il codice nel blocco |
|||
} |
|||
</syntaxhighlight> |
|||
Inoltre con la "Groovy Truth"<ref>[https://groovy-lang.org/semantics.html#the-groovy-truth Groovy Truth]</ref> è possibile semplificare le espressioni che ritornano un valore booleano. Ad esempio le seguenti espressioni daranno come risultato sempre 'false': |
|||
<syntaxhighlight lang="groovy"> |
|||
if (null) { ... // null -> false |
|||
if (0) { ... // 0 -> false |
|||
if ('') { ... // Blank String -> false |
|||
if ([]) { ... // Empty List -> false |
|||
if ([:]) { ... // Empty Map -> false |
|||
</syntaxhighlight> |
|||
== Traits == |
|||
Groovy rende possibile l'ereditarietà multipla attraverso i 'traits'<ref>[https://groovy-lang.org/objectorientation.html#_traits Groovy Traits]</ref> |
|||
<syntaxhighlight lang="groovy"> |
|||
trait Volatile { |
|||
void vola() { |
|||
println 'Sto volando!' |
|||
} |
|||
} |
|||
trait Quadrupede { |
|||
void trotta() { |
|||
println 'Sto trottando!' |
|||
} |
|||
} |
|||
class AnimaleFantastico implements Quadrupede, Volatile { |
|||
void parla() { |
|||
println 'Sto parlando :)' |
|||
} |
|||
} |
|||
def miniPony = new AnimaleFantastico() |
|||
miniPony.trotta() |
|||
miniPony.vola() |
|||
miniPony.parla() |
|||
Esecuzione: |
|||
Sto volando! |
|||
Sto trottando! |
|||
Sto parlando :) |
|||
</syntaxhighlight> |
|||
== Supporto per linguaggi markup == |
|||
Una caratteristica di Groovy che vale la pena sottolineare è il suo supporto nativo per vari [[linguaggio di markup|linguaggi di markup]] come [[XML]] ed [[HTML]]. Questa caratteristica permette di definire e manipolare molti tipi di dati eterogenei con una sintassi ed una metodologia di programmazione uniformi. |
Una caratteristica di Groovy che vale la pena sottolineare è il suo supporto nativo per vari [[linguaggio di markup|linguaggi di markup]] come [[XML]] ed [[HTML]]. Questa caratteristica permette di definire e manipolare molti tipi di dati eterogenei con una sintassi ed una metodologia di programmazione uniformi. |
||
Per esempio il seguente codice Groovy: |
Per esempio il seguente codice Groovy: |
||
< |
<syntaxhighlight lang="groovy"> |
||
import groovy.xml.MarkupBuilder |
import groovy.xml.MarkupBuilder |
||
Riga 64: | Riga 166: | ||
} |
} |
||
println myXMLDoc |
println myXMLDoc |
||
</syntaxhighlight> |
|||
</source> |
|||
Produce questo XML: |
Produce questo XML: |
||
< |
<syntaxhighlight lang="xml"> |
||
<workbook> |
<workbook> |
||
Riga 79: | Riga 181: | ||
</worksheet> |
</worksheet> |
||
</workbook> |
</workbook> |
||
</syntaxhighlight> |
|||
</source> |
|||
== Storia == |
== Storia == |
||
James Strachan parlò per la prima volta dello sviluppo di Groovy sul suo blog nell'agosto [[2003]]<ref>{{en |
James Strachan parlò per la prima volta dello sviluppo di Groovy sul suo blog nell'agosto [[2003]]<ref>{{Cita web |lingua=en |url=http://radio.weblogs.com/0112098/2003/08/29.html |titolo=James Strachan's Weblog |urlarchivio=https://web.archive.org/web/20070405085722/http://radio.weblogs.com/0112098/2003/08/29.html }}</ref>. Diverse versioni furono pubblicate tra il [[2004]] ed il [[2006]]. Dopo l'inizio del processo di standardizzazione [[Java Community Process|JCP]], la numerazione delle versioni fu cambiata e la versione chiamata "1.0" fu pubblicata martedì 2 gennaio [[2007]]. |
||
Dopo varie [[versione beta|versioni beta]] e [[Release (informatica)|release]] candidate numerate come 1.1, il 7 dicembre [[2007]] ''Groovy 1.1 Final'' è stato pubblicato e rinumerato come Groovy 1.5, per evidenziare i grandi miglioramenti fatti rispetto alla precedente versione. |
Dopo varie [[versione beta|versioni beta]] e [[Release (informatica)|release]] candidate numerate come 1.1, il 7 dicembre [[2007]] ''Groovy 1.1 Final'' è stato pubblicato e rinumerato come Groovy 1.5, per evidenziare i grandi miglioramenti fatti rispetto alla precedente versione. |
||
== Versioni<ref>[https://groovy-lang.org/changelogs.html Changelog delle versioni di Apache Groovy]</ref><ref>[https://groovy.apache.org/download.html#requirements Versioni JDK richieste in base alla versione di Groovy]</ref> == |
|||
== Versioni == |
|||
* 1.0 uscita a gennaio 2007, richiede JDK 1.4 |
|||
* 2.0 uscita a giugno 2012, richiede almeno JDK 1.5 e introduce la compilazione statica e il type checking statico. |
|||
* 1.0 2 gennaio 2007<ref>[http://docs.codehaus.org/display/GROOVY/2007/01/02/Groovy+1.0+is+there Groovy 1.0 is there - Groovy - Codehaus<!-- Titolo generato automaticamente -->]</ref> |
|||
* 2.4 uscita a gennaio 2015, richiede almeno JDK 1.6, dalla versione 2.4.4 il linguaggio Groovy viene pubblicato dalla [[Apache Software Foundation]] e diventa Apache Groovy<ref>[https://lists.apache.org/thread/qhr2p2vfbh7fl3vn909fygh9nmg3hqgh Comunicazione ufficiale nella mailing list di sviluppo]</ref> |
|||
* 1.5 7 dicembre 2007<ref>[http://docs.codehaus.org/display/GROOVY/2007/12/07/Groovy+1.5+released Groovy 1.5 released - Groovy - Codehaus<!-- Titolo generato automaticamente -->]</ref> |
|||
* Groovy 2.5 è uscito a maggio 2018, richiede almeno JDK 1.7 |
|||
* 1.6 18 febbraio 2009<ref>[http://docs.codehaus.org/display/GROOVY/2009/02/18/The+final+version+of+Groovy+1.6+is+released The final version of Groovy 1.6 is released - Groovy - Codehaus<!-- Titolo generato automaticamente -->]</ref> |
|||
* Groovy 3.0 è uscito a febbraio 2020, richiede almeno JDK 1.8 e introduce un nuovo parser più flessibile (chiamato "Parrot")<ref>[https://groovy-lang.org/releasenotes/groovy-3.0.html 3.0 Release Notes]</ref> |
|||
* 1.7 22 dicembre 2009<ref>[http://docs.codehaus.org/display/GROOVY/2009/12/22/Groovy+1.7+released Groovy 1.7 released - Groovy - Codehaus<!-- Titolo generato automaticamente -->]</ref> |
|||
* Groovy 4.0 è uscito a gennaio 2022, richiede almeno JDK 1.8, implementa un supporto migliorato per JPMS ed è la prima versione a utilizzare "org.apache.groovy" come coordinata Maven<ref>[https://groovy-lang.org/releasenotes/groovy-4.0.html 4.0 Release Notes]</ref> |
|||
* 1.8 27 aprile 2011<ref>[http://docs.codehaus.org/display/GROOVY/2011/04/27/Groovy+1.8.0+final+is+released Groovy 1.8.0 final is released - Groovy - Codehaus<!-- Titolo generato automaticamente -->]</ref> |
|||
* Dalla versione 5.0 il requisito minimo è JDK 11 <ref>[https://groovy-lang.org/releasenotes/groovy-5.0.html 5.0 Release Notes]</ref> |
|||
* 1.8.5 23 dicembre 2011<ref>[http://docs.codehaus.org/display/GROOVY/2011/12/23/Groovy+1.8.5+and+2.0-beta-2+released Groovy 1.8.5 and 2.0-beta-2 released - Groovy - Codehaus<!-- Titolo generato automaticamente -->]</ref> |
|||
* 2.1.0 25 gennaio 2013<ref>[http://groovy.codehaus.org/Download?nc Groovy 2.1.0 download]</ref> |
|||
* 2.2 18 novembre 2013<ref>[http://glaforge.appspot.com/article/groovy-2-2-released Groovy 2.2 released]</ref> |
|||
* 2.3.0 5 maggio 2014<ref>[http://docs.codehaus.org/display/GROOVY/2014/05/05/Groovy+2.3.0+is+out Groovy 2.3.0 is out] |
|||
</ref> |
|||
<references group="http://docs.codehaus.org/display/GROOVY/2014/05/05/Groovy+2.3.0+is+out" /> |
|||
== Note == |
== Note == |
||
Riga 108: | Riga 205: | ||
* [[Gradle]], sistema di build automation basato su Groovy |
* [[Gradle]], sistema di build automation basato su Groovy |
||
== |
== Altri progetti == |
||
{{interprogetto}} |
|||
== Collegamenti esterni == |
|||
* {{cita web|http://groovy.codehaus.org/|Sito ufficiale|lingua=en}} |
|||
* {{Collegamenti esterni}} |
|||
* {{cita web|url=http://www.jcp.org/en/jsr/detail?id=241|titolo=''JSR 241'', jcp.org|lingua=en}} |
|||
* {{cita web|1=http://groovy.codehaus.org/|2=Sito ufficiale|lingua=en|accesso=17 dicembre 2007|urlarchivio=https://web.archive.org/web/20140302111159/http://groovy.codehaus.org/|dataarchivio=2 marzo 2014|urlmorto=sì}} |
|||
* {{cita web|http://www.ibm.com/developerworks/java/library/j-alj08034.html|''An introduction to Groovy'', ibm.com|lingua=en}} |
|||
* {{cita web|url=https://www.jcp.org/en/jsr/detail?id=241|titolo=JSR 241|lingua=en}} |
|||
* {{Dmoz|Computers/Programming/Languages/Java/Extensions/Groovy}} |
|||
* {{cita web|https://www.ibm.com/developerworks/java/library/j-alj08034.html|An introduction to Groovy|lingua=en}} |
|||
{{portale|informatica}} |
|||
{{Controllo di autorità}} |
|||
[[Categoria:Linguaggi di programmazione]] |
|||
{{portale|informatica}}{{DEFAULTSORT:Apache Groovy}} |
|||
[[Categoria:Piattaforma Java]] |
|||
[[Categoria:Linguaggi di programmazione orientati agli oggetti]] |
|||
[[Categoria:Linguaggi di scripting]] |
|||
[[Categoria:Linguaggi per JVM]] |
|||
[[Categoria:Linguaggi di programmazione imperativi]] |
Versione attuale delle 23:38, 11 set 2024
Apache Groovy linguaggio di programmazione | |
---|---|
Autore | Guillaume Laforge |
Data di origine | 2003 |
Ultima versione | 4.0.23 (9 settembre 2024) |
Utilizzo | General purpose |
Paradigmi | Orientato agli oggetti, imperativa, scripting |
Tipizzazione | Forte, Dinamica |
Estensioni comuni | groovy, gvy, gsh e gy |
Influenzato da | Java, Python, Ruby, Perl, Smalltalk, Objective-C |
Implementazione di riferimento | |
Sistema operativo | Multipiattaforma |
Licenza | Licenza Apache v. 2.0 |
Sito web | groovy-lang.org e groovy.apache.org/ |
Apache Groovy, fino al 2015 solo Groovy, è un linguaggio di programmazione a oggetti per la Piattaforma Java alternativo al linguaggio Java. È un linguaggio sia statico che dinamico, può quindi essere utilizzato sia come linguaggio di programmazione che come linguaggio di scripting. Presenta caratteristiche simili a quelle di Python, Ruby e Smalltalk. A volte ci si riferisce a Groovy con il nome alternativo di JSR 241.
Caratteristiche
[modifica | modifica wikitesto]Groovy usa una sintassi simile a quella di Java, basata su parentesi graffe, viene compilato in bytecode per la Java Virtual Machine, ed interagisce in modo trasparente con altro codice Java e con le librerie esistenti. Il compilatore di Groovy può essere usato per generare bytecode Java standard che può quindi essere usato da qualsiasi progetto Java. Groovy può anche venire usato come linguaggio di scripting dinamico.
Altre caratteristiche:
- Tipizzazione dinamica e Tipizzazione statica
- Sintassi nativa per liste, mappe ed espressioni regolari
- Chiusure
- Overloading degli operatori
Confronto della sintassi
[modifica | modifica wikitesto]- Standard Java (Java 5+)
for (String item : new String [] {"Rod", "Carlos", "Chris"}) {
if (item.length() <= 4) System.out.println(item);
}
- Groovy
["Rod", "Carlos", "Chris"].findAll { it.size() <= 4 }.each { println it }
Getter, setter e visibilità
[modifica | modifica wikitesto]Rispetto a Java, Groovy consente di ridurre la dimensione del codice scritto generando automaticamente i metodi getter e setter per ogni classe e impostando la visibilità "public" di default, senza richiedere che venga specificata ogni volta.
Per creare una proprietà in sola lettura sarà sufficiente implementare il metodo getter omettendo il setter.
Un altro vantaggio è l'assenza del punto e virgola (;) come terminatore di linea.
- Standard Java (Java 5+)
public class Libro {
private String titolo;
private String autore;
public void setTitolo(String valore) {
this.titolo = valore;
}
public String getTitolo() {
return this.titolo;
}
// La proprietà 'author' non ha un metodo setter
// ed è quindi in sola lettura
public String getAutore() {
return this.autore;
}
}
- Groovy
class Libro {
String titolo
String autore
// La proprietà 'autore' definisce un metodo getter esplicito
// che la rende in sola lettura
String getAutore() {
return autore
}
}
Null Safe
[modifica | modifica wikitesto]Groovy definise degli operatori di confronto che riescono a gestire valori Null senza generare una eccezione[1]. Ad esempio:
if (100 > null) {
// Ritorna 'true' ed eseguirà il codice nel blocco
}
if (null > 100) {
// Ritorna 'false' e NON eseguirà il codice nel blocco
}
Inoltre con la "Groovy Truth"[2] è possibile semplificare le espressioni che ritornano un valore booleano. Ad esempio le seguenti espressioni daranno come risultato sempre 'false':
if (null) { ... // null -> false
if (0) { ... // 0 -> false
if ('') { ... // Blank String -> false
if ([]) { ... // Empty List -> false
if ([:]) { ... // Empty Map -> false
Traits
[modifica | modifica wikitesto]Groovy rende possibile l'ereditarietà multipla attraverso i 'traits'[3]
trait Volatile {
void vola() {
println 'Sto volando!'
}
}
trait Quadrupede {
void trotta() {
println 'Sto trottando!'
}
}
class AnimaleFantastico implements Quadrupede, Volatile {
void parla() {
println 'Sto parlando :)'
}
}
def miniPony = new AnimaleFantastico()
miniPony.trotta()
miniPony.vola()
miniPony.parla()
Esecuzione:
Sto volando!
Sto trottando!
Sto parlando :)
Supporto per linguaggi markup
[modifica | modifica wikitesto]Una caratteristica di Groovy che vale la pena sottolineare è il suo supporto nativo per vari linguaggi di markup come XML ed HTML. Questa caratteristica permette di definire e manipolare molti tipi di dati eterogenei con una sintassi ed una metodologia di programmazione uniformi.
Per esempio il seguente codice Groovy:
import groovy.xml.MarkupBuilder
def myXMLDoc = new MarkupBuilder()
myXMLDoc.workbook {
worksheet(caption:"Employees") {
row(fname:"John", lname:"McDoe")
row(fname:"Nancy", lname:"Davolio")
}
worksheet(caption:"Products") {
row(name:"Veeblefeetzer", id:"sku34510")
row(name:"Prune Unit Zappa", id:"sku3a550")
}
}
println myXMLDoc
Produce questo XML:
<workbook>
<worksheet caption='Employees'>
<row fname="John" lname="McDoe" />
<row fname="Nancy" lname="Davolio" />
</worksheet>
<worksheet caption='Products'>
<row name="Veeblefeetzer" id="sku34510" />
<row name="Prune Unit Zappa" id="sku3a550" />
</worksheet>
</workbook>
Storia
[modifica | modifica wikitesto]James Strachan parlò per la prima volta dello sviluppo di Groovy sul suo blog nell'agosto 2003[4]. Diverse versioni furono pubblicate tra il 2004 ed il 2006. Dopo l'inizio del processo di standardizzazione JCP, la numerazione delle versioni fu cambiata e la versione chiamata "1.0" fu pubblicata martedì 2 gennaio 2007.
Dopo varie versioni beta e release candidate numerate come 1.1, il 7 dicembre 2007 Groovy 1.1 Final è stato pubblicato e rinumerato come Groovy 1.5, per evidenziare i grandi miglioramenti fatti rispetto alla precedente versione.
Versioni[5][6]
[modifica | modifica wikitesto]- 1.0 uscita a gennaio 2007, richiede JDK 1.4
- 2.0 uscita a giugno 2012, richiede almeno JDK 1.5 e introduce la compilazione statica e il type checking statico.
- 2.4 uscita a gennaio 2015, richiede almeno JDK 1.6, dalla versione 2.4.4 il linguaggio Groovy viene pubblicato dalla Apache Software Foundation e diventa Apache Groovy[7]
- Groovy 2.5 è uscito a maggio 2018, richiede almeno JDK 1.7
- Groovy 3.0 è uscito a febbraio 2020, richiede almeno JDK 1.8 e introduce un nuovo parser più flessibile (chiamato "Parrot")[8]
- Groovy 4.0 è uscito a gennaio 2022, richiede almeno JDK 1.8, implementa un supporto migliorato per JPMS ed è la prima versione a utilizzare "org.apache.groovy" come coordinata Maven[9]
- Dalla versione 5.0 il requisito minimo è JDK 11 [10]
Note
[modifica | modifica wikitesto]- ^ Operatori di confronto Null-Safe
- ^ Groovy Truth
- ^ Groovy Traits
- ^ (EN) James Strachan's Weblog, su radio.weblogs.com (archiviato dall'url originale il 5 aprile 2007).
- ^ Changelog delle versioni di Apache Groovy
- ^ Versioni JDK richieste in base alla versione di Groovy
- ^ Comunicazione ufficiale nella mailing list di sviluppo
- ^ 3.0 Release Notes
- ^ 4.0 Release Notes
- ^ 5.0 Release Notes
Voci correlate
[modifica | modifica wikitesto]- Grails, framework web basato su Groovy
- ManyDesigns Portofino, web framework basato su Groovy
- Gradle, sistema di build automation basato su Groovy
Altri progetti
[modifica | modifica wikitesto]- Wikimedia Commons contiene immagini o altri file su Groovy
Collegamenti esterni
[modifica | modifica wikitesto]- (EN) Sito ufficiale, su groovy-lang.org.
- Sito ufficiale, su groovy.apache.org.
- Apache Groovy, su packages.debian.org.
- Repository sorgenti di Apache Groovy, su github.com.
- Repository sorgenti di Apache Groovy, su gitbox.apache.org.
- Sito di segnalazione bug, su issues.apache.org.
- (EN) Sito ufficiale, su groovy.codehaus.org. URL consultato il 17 dicembre 2007 (archiviato dall'url originale il 2 marzo 2014).
- (EN) JSR 241, su jcp.org.
- (EN) An introduction to Groovy, su ibm.com.
Controllo di autorità | LCCN (EN) sh2007001244 · J9U (EN, HE) 987007549666405171 |
---|