Journal Groovy 3.0.3 est dans les bacs

Groovy est un langage dynamique, typé optionnellement, supportant la compilation statique pour la plateforme Java (au même titre que Scala/Kotlin par exemple).

Ces principales qualités :

• concision et lisibilité ;
• apprentissage rapide ;
• intégration aisé aux programmes existant sur la JVM (syntaxiquement compatible avec la syntaxe Java, contrairement à Kotlin) ;
• adapté pour la programmation de scripts (en) (contrairement à Kotlin) ;
• support des DSL (en), avec complétion sur IDE récent ;
• support de la meta-programmation à la compilation ;
• autorise la programmation fonctionnel.

Les plus intéressé pourront consulter la liste des nouveautés (en) de la version 3. La version 3 dispose d'un nouveau parser, le Parrot Parser plus simple à maintenir et à étendre.

Le Parrot parser apporte une plus grande compatibilité avec la syntaxe Java et le bytecode produit est proche de ce qu'il serait avec un code Java syntaxiquement équivalent, si l'on utilise l'annotation @CompileStatic.

@groovy.transform.CompileStatic
def method() {
  assert 'Hi'.transform(String::toUpperCase) == 'HI'
}

Dans cet exemple fonctionnant avec le JDK 12 (utilisation de String.transform), il n'y a plus d'invocation dynamique, les optimisations seront les mêmes que pour Java.

Sans @CompileStatic, on peut toujours faire :

def convertCase(boolean upper, String arg) {
    arg.transform(String::"${upper ? 'toUpperCase' : 'toLowerCase'}")
}
assert convertCase(true, 'Hi') == 'HI'
assert convertCase(false, 'Bye') == 'bye'

Parmis les nouveautés, celles qui ont retenus mon attention qui paraissent peut-être anodine pour certains :

• Support de la syntaxe lambda donc, en plus des closures ;
• Safe indexing :
  array = null; assert null == array?[1] ;
• Nested code blocks (pour moi ça rend le code plus lisible).

Les gros projets utilisant Groovy : Gorm, Grails, Gradle … L'intérêt pour nous de Groovy est d'avoir le même langage, avec les mêmes fonctionnalité, de bonne performance, une grande portabilité (binaire compatible sur toutes les plateformes), aussi bien pour les applications serveur que pour les scripts.

Un dernier mot concernant les scripts : on peut utiliser n'importe quelle dépendance Maven via les annotations @Grape et @Grabe, donc sans compilation, avec juste Groovy installé sur une machine on peut faire littéralement ce que l'on veut. C'est la seule solution existante à ma connaissance permettant cela, une gestion de dépendance portable, quelque soit l'OS.

$ cat toto.groovy

#! /bin/env groovy

@Grab(group = 'com.opencsv', module = 'opencsv', version = '4.1')
import com.opencsv.CSVWriter
@Grab(group = 'net.sourceforge.jtds', module = 'jtds', version = '1.3.1')
import net.sourceforge.jtds.jdbc.Driver as JtdsDriver

import java.sql.Connection
import java.sql.Statement

enum TableSelectERP {
        CurrentStock("""
            SELECT *
            FROM CurrentStock
        """, "CurrentStock.csv")
...
def createCsv(TableSelectU8 tableSelect) {
     Writer writer = new FileWriter(csvFolder + tableSelect.fileName)
     CSVWriter w = new CSVWriter(writer, ',' as char, '"' as char, "\n")
     Statement statement = connection.createStatement()
     w.writeAll(statement.executeQuery(tableSelect.select), true)
     statement.close()
     writer.close()
}