Questo blog è un personale block notes nell' esplorazione del linguaggio Scala, uno dei tanti linguaggi di programmazione emersi negli ultimi anni con la peculiarità di unire alle caratteristiche di semplicità, facilità di sintassi dei linguaggi dinamici di scripting come Ruby, Phyton, Groovy alla robustezza dei linguaggi compilati quali Java e C#.
Una meteora o il prossimo protagonista del mainstream ?
Scala sta per scalable language , un linguaggio progettato per sviluppare applicazioni, appunto, scalabili e cioè in grado di adattarsi a girare in modo trasparente su hardware distribuito e a consumare risorse che aumentano all’ aumentare della richiesta di utilizzo da parte degli utenti, .
Scala è un linguaggio staticamente tipato e multi paradigma, Object Oriented puro e Funzionale, gira su una JVM ed è stato ideato e sviluppato da Martin Odersky, già autore dei Java Generics e del compilatore javac per Java7.
Programmazione Funzionale (FP)? Probabilmente tutti conoscono cosa è la programmazione orientata agli oggetti, e sanno quali sono i suoi vantaggi in termini di gestione della complessità, tra i principali motivi della sua diffusione a partire dagli anni '80, un pò meno diffusa al di fuori di ambienti accademici e nicche di mercato è invece la FP.
La FP è un paradigma di programmazione in cui le funzioni sono entità di prima classe, nella FP l'operazione fondamentale è l'applicazione di funzioni, ogni programma è fondamentalmente una funzione che si applica ai parametri di ingresso e da in output qualcosa, questa funzione è definita in termini di altre funzioni e così via fino ad arrivare a qualche primitiva del linguaggio. La caratteristica fondamentale dei linguaggi funzionali puri è un ossimoro... le variabili sono immutabili o_O. Ebbene si, le variabili in FP non possono avere assegnazioni a parte il momento in cui vengono definite, questo implica che in generale, in un programma funzionale applicando una funzione su un insieme di parametri non ci sarà mai un effetto collaterale sui parametri, l'unico effetto collaterale è la produzione di un risultato, in questo modo valori e variabili possono essere scambiati in qualsiasi momenento e qualsiasi espressione può essere valutata in ogni momento senza possibilità di errori, tale proprietà viene denominata trasparenza referenziale. Un approccio del genere ha un impatto pesante sulla quantità di memoria consumata durante l'esecuzione di un' applicazione FP ed è sicuramente uno dei fattori che in passato hanno limitato l'adozione del paradigma funzionale. Un effetto collaterale della immutabilità delle variabili è che nativamente un programma funzionale non deve occuparsi di tutte le problematiche di acesso concorrente in scrittura e coerenza dei dati tipici rompicapo in ogni applicazione non banale Object Oriented.
Niente paura, Scala non è un linguaggio funzionale puro anche se incoraggia a essere utilizzato come tale, lascia la liberta di utilizzare lo stile classico OO, o meglio lo stile giusto per la necessità contingente.
La sintassi di Scala ha qualcosa di magico, da scoprire un pò alla volta, ma che a prima vista sembra incarnare tutto quello che uno sviluppatore ha sempre desiderato. Unisce i vantaggi dei linguaggi fortemente tipati , come java a la sintassi coincisa dei moderni linguaggi dinamici, questo accade grazie alla inferenza di tipo che il compilatore scala effettua, permettendo una sintassi essenziale e leggibile.
val greet: String ="Hello Scala";
var age = 27
val name = "Maria";
val e var, sono le due modalità per dichiarare le variabili in scala, val precede la dichiarazione delle variabili immutabili in stile FP, var invece è la parola chiave per la dichiarazione di variabili che possono ricevere ri-assegnazioni.
tutte e tre le sintassi dell' esempio sono corrette, l'analizzatore sintattico del compilatore scala quando può inferisce il tipo dal contesto, in java ad esempio avremmo dovuto scrivere
String name = new String("Maria");
come notiamo dal primo esempio , anche in scala la sintassi è molto simile a parte l' assenza della ripetizione di tipo, ma è molto più diretto utilizzare la più coincisa sintassi degli esempi successivi in cui omettiamo completamente il tipo che verrà indovinato dal compilatore a partire dai valori assegnati.
I più pignoli avranno notato l'assenza del punto e virgola dopo la seconda dichiarazione, anche questo è opzionale in scala quando non crea ambiguità.
Un' altro esempio della sintassi coincisa di scala , vediamo una definizione di classe in Java e la corrispondente Scala.
<java>
class Persona{
private int id;
private String nome;
private String indirizzo;
public Persona( int id, String nome, String indirizzo){
this.id=id;
this.nome=nome;
this.indirizzo=indirizzo;
}
}
</java>
<scala>
class Persona (id: int, nome: String, indirizzo: String)
</scala>
il compilatore scala data questa ultima riga di codice genera l' equivalente della classe java precedente compreso un costruttore che accetta in ingresso le proprietà definite per la classe.
Molti accorgimenti sintattici rendono la scrittura di codice Scala molto coincisa e quindi meno soggetta ad errori, ma la caratteristica del linguaggio che aiuta maggiormente a diminuire le righe di codice è sicuramente l'introduzione dei tratti (traits) insieme alla possibilità di estendere il linguaggio con librerie che potranno essere utilizzate come se fossero parte del linguaggio anche per quanto riguarda la sintassi. Tutto questo sarà l' oggetto della nostra indagine nelle prossime puntate.
Nessun commento:
Posta un commento