Sabato scorso si è tenuto a Milano, presso il Dipartimento di Informatica dell’Università, lo Scala Day Italia, il primo evento in Italia dedicato a Scala e a ciò che gli ruota intorno. Questo post ne è un breve resoconto informale per chi fosse curioso di sapere di cosa si è parlato e perché Scala è così promettente.

Scala è in giro già da un po’ di tempo ed apparso anche qui sulla di CoseNonJaviste. E’ la prima volta però che in Italia viene organizzato un evento dedicato esclusivamente a questo linguaggio. Gli organizzatori si aspettavano non più di una quarantina di partecipanti (sabato? 25 maggio? facciamo 30 :-)) eppure la risposta è stata tale da occupare tutti i 120 posti disponibili e alla fine, contandosi, eravamo più di 100. Segno che c’è un interesse crescente per Scala, che ancora non è linguaggio mainstream, ma che sicuramente cavalca un trend positivo (qui sotto alcune aziende “sconosciute ai più” che già utilizzano Scala).

Scala: Semplificare lo sviluppo del software

Questa tendenza è stata riportata anche da di TypeSafe il quale ha aperto la giornata con un fast track sulle caratteristiche salienti del linguaggio. Il talk di Mirco non poteva, ovviamente, essere esauriente su tutte le features presenti, ma è stato utile per ribadire che Scala si basa più su principi che regole e che il design del linguaggio è tale che permette di far crescere il linguaggio secondo le proprie esigenze: pochi costrutti ma con alto potere espressivo. Un particolare accenno è stato dato al confronto tra Scala e Java in ambito collections dove l’eleganza e la stringatezza di Scala la “vincono facile”. Riporto parte di un esempio delle per rendere l’idea.

case class Time(hours: Int, minutes: Int = 0)

definisce una classe Time con due member variable per ora e minuti (e costruttore con default per il secondo parametro, getter e setter).

val times = List(Time(1), Time(2), Time(12,30), Time(16,15))

definisce una lista con quattro istanze di Time, infine

times.filter(time => time.hours >= 12)

filtra la collezione times restituendo una nuova collezione con solo le istanze di Time che hanno il campo ore maggiore di 12. Si provi ad immaginare quanto sia esteso il codice Java equivalente. Infine una citazione più o meno a memoria: “Scala non è un linguaggio che si impara in due settimane perché è profondo ma dopo due/quattro settimane l’investimento si è già ripagato in termini di produttività”.

Reflection in Scala: cosa, perché e come

Il secondo intervento è stato tenuto da Walter Cazzola del Dipartimento di Informatica dell’Università di Milano e ha riguardato la reflection in Scala. Fino alla versione 2.9, usare la reflection in Scala voleva dire appoggiarsi sul package java.lang.reflect; quindi non poter accedere alle caratteristiche specifiche di Scala (i ad esempio) e limitarsi solo alla reflection runtime. La reflection runtime è una caratteristica ben consolidata anche in Java e consente ispezionare il tipo di un particolare oggetto, istanziare nuovi oggetti, accedere o invocare membri di uno specifico oggetto.

Le cose cambiano con la versione 2.10 grazie ad una nuova API che consente la reflection runtime su tutte le caratteristiche di Scala e la reflection compile-time attraverso le macro; un programma Scala può quindi modificarsi durante la compilazione attraverso la manipolazione dei suoi Abstract Syntax Tree. Cosa interessante è notare che reflection runtime e compile time condividono parte delle librerie, tuttavia Scala non è ancora ai livelli dei template C++. Questo è stato sicuramente un talk molto denso di contenuti e i suoi argomenti meritano di essere approfonditi a partire dalle .

Scalatra comparison with SpringMVC

Il terzo talk della giornata è stato dedicato a Scalatra, un piccolo ma potente web application framework scritto completamente in Scala. ha messo a confronto SpringMVC con Scalatra in tipiche situazioni di sviluppo: CRUD HTML,REST, JSON, Routing, Template, Security. Anche in questo caso la compattezza di Scala(tra) la fa da padrona, dalle l’esempio Rest in Scalatra:

class JellyBeans extends ScalatraServlet {
   get("/jellybs/:id") { ... }
   post("/jellybs") { ... }
   put("/jellybs/:id") { ... }
   delete("/jellybs/:id") { ... }
}

e il verboso equivalente in SpringMVC:

@Controller
public class JellyBeansController{
   @RequestMapping(value = "/jellybs/{id}", method = RequestMethod.GET)
   @ResponseStatus(HttpStatus.OK) //Http 200
   public @ResponseBody JellyB getItem(@PathVariable("id") Integer id) {...}

   @RequestMapping(value = "/jellybs", method = RequestMethod.POST) //Http 201
   @ResponseStatus(HttpStatus.CREATED) //Http 201
   public void createJelly(HttpServletRequest req, HttpServletResponse res, @RequestBody JellyB item) { ... }
   
   @RequestMapping(value = "/jellybs/{id}", method = RequestMethod.PUT)
   @ResponseStatus(HttpStatus.NO_CONTENT) //Http 204
   public void updateItem(@RequestBody JellyB item, @PathVariable("id") Integer id){ ... }

   @RequestMapping(value = "/items/{id}", method = RequestMethod.DELETE)
   @ResponseStatus(HttpStatus.NO_CONTENT)//204
   public void deleteItem(@PathVariable("id") String id) { ... }}

Ma non solo stringatezza, ma anche eleganza e semplicità del codice che si va a scrivere. Peccato il tempo sia stato tiranno con questo ottimo intervento.

Scala in pratica

ha presentato “Scala in pratica”, cioè la sua esperienza di sviluppo in Scala per il progetto MoneyFarm. Questo talk è stato molto interessante perché ha dato un’idea di cosa vuol dire adottare oggi Scala. La sintassi più coincisa, il type inference, le closures sono solo alcuni degli aspetti di Scala che hanno migliorato la produttività. Inoltre Scala è ben supportato da tools, da una community attiva e dalla stessa Typesafe.

Tuttavia questo linguaggio è più complesso di altri e quindi richiede team più preparati e che comunichino e interagiscano strettamente, soprattutto perché è più facile scrivere il codice in maniera “creativa”. Altre interessanti considerazioni sono contenute nelle , una sola molto importante riporto ancora (e che è la stessa espressa da Mirco al termine del primo talk), lavorare con Scala è divertente e stimolante, oltre che essere produttivo.

Scala, il linguaggio dei linguaggi

Infine il talk di , autore di un Rule Engine scritto in Scala che ha parlato di Domain Specific Language, ovvero di linguaggi creati con lo scopo di risolvere un problema specifico, tipicamente legato ad un dominio di business. Questi posso essere esterni cioè hanno una sintassi distinta dal linguaggio che li implementa (si pensi ad esempio a SQL) oppure interni cioè scritti nello stesso linguaggio con cui si programma. Scopo di questi linguaggi è quello di permettere prima ancora che l’esecuzione, la comunicazione tra due soggetti distinti. Come ha posto in evidenza Mario, un DSL può essere utilizzato tra analista e programmatore non tanto perché l’analista scriva, ma piuttosto per leggere e quindi validare l’algoritmo scritto dal programmatore. Scala consente di implementare sia DSL esterni che interni, ma proprio di quest’ultimo caso voglio riportare velocemente l’esempio visto allo ScalaDay perchè dimostra come il codice scritto con Scala minimizzi il rumore sintattico a fronte delle informazioni che trasmette, mentre per un esempio di Hammurabi e di DSL esterno rimando alle .

Due caratteristiche sono fondamentali in Scala per creare dei DSL interni: le conversioni implicite (la possilità di definire una conversione tra tipi senza doverla richiamare esplicitamente) e le higher-order functions cioè funzioni che prendono funzioni come parametri. Partiamo da queste ultime, definendo una funzione che applica due volte la funzione che gli viene passata come parametro:

def twice(f: => Unit): Unit = { f; f }

e che può essere invocata così, visto che println è una funzione:

 twice {
    println("Hello!")
  }

ora generalizziamola al caso n con la funzione times scritta così:

def times(n: Int)(f: => Unit) {
  if (n > 0) {
    f; times(n - 1)(f)
  }
}

che possiamo richiamare adesso combinandola con quella precedente:

times(3) {
 println("tre")
}

twice {
  times(4) {
    println("otto")
  }
}

Già visto così, il codice pare quasi leggibile in inglese (parlo dell’invocazione delle funzioni, non della loro definizione), ma grazie alle conversioni implicite si può fare di meglio, tipo scrivere 4 times println("otto"). Aggiungiamo quindi una classe chiamata Loop e un metodo di conversione da Int.

class Loop(n: Int) {
  def times(f: => Unit) {
    FirstDSL.times(n)(f)
  }
}

implicit def intToLoop(n: Int): Loop = new Loop(n)

e guardiamo il nostro frammento di DSL scritto in Scala.

twice {
  3 times {
    println("six")
  }
}

Conclusioni

Complimenti davvero agli organizzatori dello ScalaDay, hanno organizzato un evento ricco di contenuti e agli speaker che hanno dato il meglio di se stessi. Un’ultima chicca: c’è stato anche un momento improvvisato di dibattito su Scala e la sua diffusione tra i primi due talk che sicuramente è stato interessante. Ci auguriamo di partecipare a breve ad un altro evento organizzato da Scala User Group – Italy che, visto l’ottimo lavoro fatto agli esordi, sicuramente saprà proporre una nuova entusiasmante conferenza.