Build automation con Gradle

3 ottobre 2014

Quando si inizia a programmare, si identifica nel codice la principale chiave di successo del proprio lavoro. La sua qualità è sicuramente un elemento imprescindibile. Un approccio più professionale, però, suggerisce l’adozione di ulteriori strumenti che aumentino la produttività di un programmatore: ambienti di sviluppo, un buon debugger, sistemi di controllo della versione ma anche tool di build automation. Proprio in quest’ultima categoria rientra Gradle, software multipiattaforma e gratuito, tra i più avanzati attualmente disponibili nell’ambito della build automation.

In questo articolo introdurremo alcuni concetti fondamentali, comuni a tutti i tool di questo tipo, per poi approfondire l’utilizzo di Gradle.

Cos’è la build automation

Le fasi di sviluppo di un software sono contornate da una serie di attività accessorie, a volte preliminari, a volte attuate a posteriori, spesso organizzate durante lo sviluppo. Tra queste attività possiamo evidenziare le principali:

  • compilazione: si tratta del procedimento di trasformazione dei sorgenti (scritti dal programmatore) in codice binario (il formato riconosciuto dalla macchina);
  • packaging dei binari: il risultato della compilazione deve assumere una forma compatta ed una chiara connotazione in base al suo scopo: eseguibile, libreria da esportare, etc.;
  • esecuzione di test automatizzati: un software vero non può semplicemente essere “provato”. Non basta inserire qualche dato a caso con le proprie mani e sentirsi soddisfatti dei risultati ottenuti. Per evitare bug nascosti, è necessario attuare una fase di sperimentazione che dimostri l’affidabilità del software in ogni sua sfaccettatura, cercando di verificarne le funzionalità in ogni possibile situazione. Per seguire una strategia di test del genere, non è più sufficiente un essere umano di buona volontà ma è necessaria una macchina, un software appositamente programmato per eseguire test completi;
  • deployment della soluzione: una volta che il software è pronto e testato, deve essere installato e configurato sui sistemi per i quali è stato implementato;
  • documentazione del progetto: i software prodotti sono spesso piuttosto complessi e vivono, attraverso le versioni pubblicate, una vera e propria evoluzione. Data la complessità dei prodotti informatici, la redazione di opportuni documenti che ne spieghino l’utilizzo e le funzionalità è fondamentale. Ovviamente la documentazione prenderà la forma più consona al tipo di progetto e al target di utilizzatore.

I prodotti di build automation sono tool pensati proprio per automatizzare tutte le fasi appena elencate. La loro importanza è notevole, al punto che hanno popolato la storia dell’informatica. Se i programmatori per tanti anni si sono affidati a Make, gli esperti del mondo Java si sono spesso confrontati con Ant e Maven, entrambi basati su file di configurazione in XML. Nonostante le differenze che li distinguono, i tool di build automation a volte presentano tratti comuni, quali ad esempio:

  • il build file: le operazioni che devono essere svolte per trasformare il progetto sorgente nella soluzione finale vengono raccolte in un file principale, che a volte fa riferimento o include altri file secondari;
  • il task: è il concetto che definisce la singola operazione da svolgere all’interno delle fasi del procedimento di build. Spesso i task sono divisi in micro-azioni e vengono contestualizzati assegnando loro precedenze e dipendenze da altri task. Così facendo viene definito il flusso di svolgimento dell’intero processo di build;
  • le dipendenze del software da altri progetti: a livello professionale, non si inizia a programmare “da zero” ma ci si basa su framework, librerie o altri progetti, che rappresentano le fondamenta del nostro lavoro. Fare in modo che nelle varie fasi di build il progetto abbia a disposizione tutto il necessario è un compito doloroso per il programmatore. Un grande merito dei tool di questa categoria al giorno d’oggi è quella di automatizzare il soddisfacimento delle dipendenze del progetto in maniera automatica, attraverso la rete, mettendo a disposizione le versioni aggiornate delle dipendenze, o quelle meglio compatibili con le nostre necessità.

In definitiva, un progetto informatico prende vita grazie ad una serie di fasi, a volte complesse, la cui automazione solleva il programmatore da notevoli responsabilità ed riduce la possibilità che si verifichino errori di distrazione o stanchezza.

Gradle: iniziamo ad usarlo

Strumenti di build automation come Ant e Maven, ricchi di funzionalità ed espandibili, hanno spesso dimostrato una certa rigidità di configurazione dovuta per lo più all’utilizzo del formato XML. Gradle si propone come uno dei tool di gestione dei software più avanzato del momento. Esso trae vantaggio dall’utilizzo di configurazioni svolte in un linguaggio dichiarativo: Groovy. Si tratta di un linguaggio di scripting che nasce in seno alla tecnologia Java. Appartiene all’ambito della programmazione orientata agli oggetti e il suo codice è compilato on-the-fly, ed assume la forma di bytecode per la Java Virtual Machine.

Gradle è progetto multipiattaforma e può essere scaricato dal sito di riferimento www.gradle.org. Seguendo il link Downloads è possibile scaricarne i sorgenti, i binari o un pacchetto che li includa entrambi con l’aggiunta della documentazione. Scegliamo di scaricare la versione con i binari e, una volta scompattato l’archivio in formato .zip, otterremo il contenuto parzialmente visibile nella figura seguente.

Tra le varie cartelle, ce ne sono due di maggiore interesse per i nostri scopi:

  • bin: contiene gli eseguibili. Serviranno per attivare il programma da riga di comando;
  • lib: raccoglie molti archivi jar che permetteranno a Gradle di svolgere il proprio lavoro. Un rapido sguardo all’interno di questa directory ci fa notare alcuni nomi che dimostrano su quali solide basi poggi Gradle e quanto affondi le proprie radici nel mondo Java: ant, log4j, groovy, diversi commons di Apache e molto altro ancora.

Una volta scompattato l’archivio .zip, Gradle è già pronto all’uso. Per funzionare, esso non richiede altro che un JDK o una JVM correttamente configurati nel sistema. Per provarne le funzionalità, utilizziamo subito il comando gradle, direttamente da riga di comando:

gradle -v

Su Ubuntu, l’output mostrato è il seguente:

------------------------------------------------------------
Gradle 2.1
------------------------------------------------------------

Build time:   2014-09-08 10:40:39 UTC
Build number: none
Revision:     e6cf70745ac11fa943e19294d19a2c527a669a53

Groovy:       2.3.6
Ant:          Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM:          1.7.0_21 (Oracle Corporation 23.21-b01)
OS:           Linux 3.5.0-23-generic amd64

Come si vede, il comando appena digitato mostra la versione di Gradle (2.1 in questo caso) e di tutti i componenti che esso ha a disposizione: JVM, groovy, ant e sistema operativo.

La sintassi

Visto che un vantaggio importante di Gradle consiste nella flessibilità del linguaggio utilizzato, vediamolo subito al lavoro. Creiamo un file di build, che possiamo denominare build.gradle, apriamolo con un editor di testo e scriviamo il seguente codice al suo interno:

import java.text.SimpleDateFormat
SimpleDateFormat simple=new SimpleDateFormat("HH:mm:ss")
task proviamoGradle {
	for(int i=1;i<20;i++)
		if (i%2==0) println i+" è pari..."
			println 'Operazioni terminate alle'+simple.format(new Date())
}

Da riga di comando digitiamo:

gradle proviamoGradle

ottenendo il seguente output:

2 è pari...
4 è pari...
6 è pari...
8 è pari...
10 è pari...
12 è pari...
14 è pari...
16 è pari...
18 è pari...
Operazioni terminate alle 12:33:35

In pratica, abbiamo realizzato un programma, il cui cuore è collocato nel task denominato proviamoGradle, in cui vengono stampati i numeri pari compresi tra 1 e 20, seguiti dall'informazione oraria del termine delle operazioni. La cosa più interessante di ciò, però, è il fatto che il codice che abbiamo utilizzato non è altro che Java.

Le classi Date e SimpleDateFormat che abbiamo utilizzato sono esattamente quelle appartenenti al JDK, for e if sono i costrutti di controllo che conosciamo bene e println è l'istruzione per richiedere la stampa a console di una singola riga.

L'esempio dimostra come l'uso di Groovy all'interno di Gradle conferisca non solo flessibilità alle istruzioni, ma tutta la ricchezza delle funzionalità del mondo Java.

Se vuoi aggiornamenti su Build automation con Gradle inserisci la tua e-mail nel box qui sotto:
 
X
Se vuoi aggiornamenti su Build automation con Gradle

inserisci la tua e-mail nel box qui sotto:

Ho letto e acconsento l'informativa sulla privacy

Acconsento al trattamento di cui al punto 3 dell'informativa sulla privacy