scala primi passi

Scala, un linguaggio FOSS

Ugo Landini

Presidente, JUG Roma

Thursday, June 11, 2009

Summary Introduzione Paradigmi e linguaggi Scala, una introduzione light Conclusioni Riferimenti Q&A

Introduzione

Chi è il JUG Roma http://www.jugroma.it Una community con:

tre anni di storia più di 750 membri

Organizzazione dei Javaday a Roma

Linguaggi e paradigmi

Paradigmi Il paradigma è semplicemente un modo

di classificare la conoscenza due grandi classi: linguaggi dichiarativi

ed imperativi i linguaggi funzionali sono dichiarativi:

cosa deve fare il programma I linguaggi Object Oriented sono

imperativi: come deve farlo

Imperativo vs Funzionale Imperativo

da Cobol a Java lavora essenzialmente modificando

variabili, i.e. locazioni di memoria Funzionale

da Lisp a Scala (Erlang e Clojure, ma anche ANTlr, sono esempi recenti) lavorano con espressioni che definiscono

valori

Statico vs Dinamico Un altro modo di catalogare i linguaggi è

la classe “statica” e “dinamica” Linguaggio statico

Sistema di tipi gestito a compile time Tipi associati a variabili

Linguaggio dinamico Sistema di tipi gestito a runtime Tipi associati a valori

SCAlable LAnguage

Storia di Scala Martin Odersky

versione originale di javac per conto di Sun Pizza GJ (Generic Java)

Java Generics progetta Scala nel 2001, all’EPFL, dove

insegna primi tentativi di ibridazione OO/

Funzionale con Funnel

Scala: un ibrido Odersky sostiene che i due paradigmi

OO e funzionale sono complementari Scala è più OO di Java, ma è anche

funzionale invoglia ad usare il paradigma funzionale

ove possibile, ma non vi vincola i due paradigmi convivono in maniera

naturale: in Scala tutto è un oggetto, comprese le funzioni

Scala: perchè Creare un linguaggio che scali. La

scalabilità qui è intesa soprattutto come ambito di utilizzo

Scala è applicabile (con efficacia) a piccoli problemi di scripting o grandi problemi di concorrenza

Non reinventare la ruota Utilizzare Virtual machine esistenti: con

JVM e CLR oggi ha poco senso sviluppare una VM in proprio (LLVM permettendo!)

Scala: perchè Sfruttare al massimo le capacità delle

moderne architetture multi-core Libreria di concorrenza Actor-based

simile ad Erlang Diminuire il codice da scrivere,

massimizzando la concisione Snello come un linguaggio dinamico, ma

veloce come uno statico (type inference) Sviluppare con semplicità DSL interni

DSL (Domain Specific Languages)

Scala: come provarlo Si installa molto facilmente

http://www.scala-lang.org/ Da riga di comando: scala, scalac, fsc

ricalca i tool esistenti in Java Interpretato, da shell: scala

modalità più simile a linguaggi dinamici utile per testare funzionalità del linguaggio

velocemente Il supporto negli IDE più diffusi sta

nascendo oraThursday, June 11, 2009

Un po’ di esempi

(finalmente!)

Hello, scalable world!

println(“Hello, scalable world”)

Notare l’import automatico

Hello, scalable world!

object HelloWorld extends Application {val s = “Si, i ; non ci piacciono”println(“Hello, scalable world”)println(s)

Application ci evita di dichiarare il main. Application è un trait

Scrivere direttamente codice nel body è un idioma comune in scala

Non ci sono ; Val è un valore non modificabile. Notare la type inference in azione.

Fattoriale

def factorial(x: BigInt): BigInt =

if (x == 0) 1 else x * factorial(x-1)

Inizio definizione funzioneLista parametri

Tipo di ritorno

Assegnamento implicito al tipo di ritorno

Non ci sono graffe, è una funzione di una sola riga

Un semplice esempio, da imperativo a

funzionale

Stampa argomenti, Java style

object Args { def main(args: Array[String]) { var i = 0 while (i < args.length) { print(args(i)) print(" ") i += 1 } println }}

Scala, ma Java imperative style

un Var è un valore modificabile. Un var indica di solito la presenza di codice imperativo

Stampa argomenti, 2a versione

object ArgsFor { def main(args: Array[String]) { for (arg <- args) { print(arg) print(" ") } println }}

Ancora imperativo, ma un po’ meno

Notare la type inference

Stampa argomenti, 3a versione

object ArgsFor { def main(args: Array[String]) { args.foreach(arg => print(arg + " ")) println }}

Un iteratore interno a cui viene passato un function literal. La funzione è di fatto un valore, che può essere assegnato ad un val e riutilizzato.

Concisione di Scala L’ultima versione è molto più concisa ed

elegante (quando si comincia ad apprezzarne la sintassi)

val increase = (x: Int) => x+1increase(100)

la funzione increase in questo esempio è un val. Le funzioni sono first class objects in Scala: questo è un aspetto dell’integrazione OO/Funzionale tanto cara a Odersky

Concisione di Scalaobject ListMax { def main(args: Array[String]) {

val numeri = List(-1,2,0,-3,5) numeri.foreach(print) val positivi = numeri.filter((x:Int) => x>0) val negativi = numeri.filter(x => x<0) positivi.foreach(print)

Le Collections hanno moltissime funzioni applicabili: è semplice crearne di nuove. Nell’esempio vediamo anche la short form della funzione (target typing)

Concisione di Scalaobject ListMax { def main(args: Array[String]) {

val numeri = List(-1,2,0,-3,5) numeri.foreach(print) val positivi = numeri.filter( _ > 0) val negativi = numeri.filter( _ < 0) positivi.foreach(print)

}} Lo stesso esempio con la versione

superconcisa (placeholder syntax)

Closure Quando un function literal contiene variabili

non bound (il cui valore è definito al di fuori del function literal stesso), si chiama closure

var more = 10val addMore = (x => x + more)

more è definito all’esterno del function literal e dunque va chiuso prima della valutazione

Scala è Object

Oriented

Tutto è un oggetto

val x = 1.+(2)

Equivalente a 1 + 2i . e le () possono essere omessi in molti casi

+ è un metodo

E tutto è ridefinibile Da grandi poteri, derivano grandi responsabilità

class CrazyInt(n:Int) { val x = n def + (that:CrazyInt):CrazyInt =

new CrazyInt( x - that.x) override def toString = x.toString }

val x = new CrazyInt(43)val y = new CrazyInt(1)println(x + y) // fa 42!

Traits I traits sono una caratteristica molto

interessante di Scala, che amplia notevolmente le possibilità di design

Permettono di combinare (mix-in) diverse funzionalità in una classe in maniera più snella dell’ereditarietà classica

Un Trait è simile ad un’interfaccia Java, ma con metodi concreti e attributi!

Il trucco è che super è bounded a runtime!

Traits Come una classe, ma la parola chiave è trait

trait Mangia { def eat() { println("Munch munch munch...") }}

trait Beve { def drink() { println("lap lap...") }}

trait invece di class

Traits Questo utilizzo dei traits è chiamato “widening

thin interfaces” da Oderskyval mucca = new Mucca with Mangia with Cammina

mucca eat()mucca walk()

val vitello = new Vitello with Mangia with Beve

vitello eat()vitello drink()

equivalente di implements

Traits e Stackable modifications I traits possono anche modificare i metodi di

una classe, e non solo aggiungere Queste modifiche possono essere impilate, in

modo da ottenere delle “stackable modifications”

Il fatto che super sia bounded a runtime è in questo caso fondamentale

I prossimi esempi sono tratti direttamente dal libro di Odersky

Traits e Stackable modificationsabstract class IntQueue { def get(): Int def put(x: Int)}

class BasicIntQueue extends IntQueue { private val buf = new ArrayBuffer[Int] def get() = buf.remove(0) def put(x: Int) { buf += x }}

Traits e Stackable modificationstrait Doubling extends IntQueue {abstract override def put(x: Int)

{ super.put(2 * x) }}

Stiamo ridefinendo un metodo di IntQueue. Che è abstract! Questo si può fare solo per i trait e non per le normali classi

Chi è super? Dipende dall’ordine in cui dichiareremo i with

Traits e Stackable modificationstrait Incrementing extends IntQueue {abstract override def put(x: Int)

{ super.put(x + 1) }}

val queue1 = new BasicIntQueue with Doubling with Incrementing

val queue2 = new BasicIntQueue with Incrementing with Doubling

Traits e Stackable modifications

queue1.put(10)queue1.get() // torna 22

queue2.put(10)queue2.get() // torna 21

L’ordine è significativo, viene eseguito prima il trait più a destra.

Traits e Stackable modifications Le dichiarazioni dei traits vengono linearizzate

secondo alcune regole (approssimativamente, da dx a sx)

E’ quindi possibile aggiungere comportamento con una sintassi molto concisa: in Java avremmo dovuto implementare un Decorator per ottenere qualcosa di simile

Un trait si può chiamare mixin una volta che è stato combinato (ossia super -> bounded)

Scala e concorrenza

Scala: la concorrenza Martin Odersky ultimamente ha affermato che

vuole fare di Scala il miglior linguaggio possibile per la concorrenza, in ambedue le accezioni possibili

Programmazione multithread tradizionalmente difficile con le primitive di Java

Programmazione parallela split di task “grandi”

Scala: la concorrenza Con Scala è molto semplice creare degli

“attori”, ossia classi che agiscono indipendentemente (ie, nel proprio thread)

object myActor extends Actor { def act() { for (i <- 1 to 10) { println("Task inutile") Thread.sleep(1000) } }}

Scala: la concorrenza Oppure - la regola in scala è che c’è sempre

una maniera più concisa - in questo modo

val myActor = actor { for (i <- 1 to 10) { println("Task inutile") Thread.sleep(1000) }

Scala: message passing Gli attori possono comunicare fra loro, senza

usare memoria condivisa o lock

myActor ! “ciao”

Il ! è l’operatore di invio messaggio

Scala: message receiving I messaggi vengono ignorati, a meno che non

ci sia una receive con un match corrispondente

val echoActor = actor { while (true) { receive { case msg => println("Ricevuto: "+ msg) } }

pattern matching in action

Scala: la concorrenza Inviare un messaggio non è blocking per

l’attore Ricevere un messaggio non vuol dire

interrompere i messaggi ricevuti risiedono in una sorta di

casella postale dell’oggetto quando viene chiamato receive i messaggi

vengono scodati ogni attore gestisce uno o più thread nativi per

poter funzionare

Scala: thread reuse Come alternativa è anche possibile utilizzare

il metodo react invece di receive thread reuse: strategia per conservare i thread,

che sono comunque oggetti costosi react non torna dopo il match, per cui è

necessario rientrare nel loop in qualche modo con tutti react al posto dei receive, è idealmente

possibile usare un solo thread

Scala: thread reusedef act() { react { case (name: String, actor: Actor) => actor ! getIp(name) act() case "EXIT" => println("Exit") case msg => println("Ricevuto: " + msg) act() } }

Scala: thread reuse

def act() { loop { case (name: String, actor: Actor) => actor ! getIp(name) case msg => println("Ricevuto: " + msg) } }

In maniera più concisa (questo attore non reagisce però al comando EXIT

Scala e DSL

DSL Domain Specific Languages

in sostanza, un linguaggio ad hoc che risolve un problema in maniera specifica E’ un ottimo strumento, se usato al

momento giusto http://www.martinfowler.com/bliki/

DomainSpecificLanguage.html Le caratteristiche di Scala lo rendono

perfetto per lo sviluppo di piccoli DSL case class pattern matching

DSL Un esempio di interprete Basic

supersemplice in circa 20 righe! Le 20 righe sono piuttosto dense di

concetti Scala... creato da Szymon Jachim

http://www.scala-lang.org/node/1403

class BasicClass { abstract sealed class BasicLine case class PrintLine(num: Int, s: String) extends BasicLine case class GotoLine(num: Int, to: Int) extends BasicLine

val lines = new scala.collection.mutable.HashMap[Int, BasicLine]

case class linebuilder(num: Int) { def GOTO(to: Int) = lines(num) = GotoLine(num, to) def PRINT(s: String) = lines(num) = PrintLine(num, s) }

private def gotoLine(line: Int) { lines(line) match { case PrintLine(_, s) => println(s); gotoLine(line + 10) case GotoLine(_, to) => gotoLine(to) } }

def RUN { gotoLine(lines.keys.toList.first) } implicit def int2linebuilder(i: Int) = linebuilder(i)}

object Main extends BasicClass {

def main(args:Array[String]) = { 10 PRINT "Scala Rulez!" 20 GOTO 10 RUN }

Data la classe precedente, è ora possibile scrivere del semplice codice simil BASIC all’interno di un metodo Scala:

Conclusioni

Scala Potrebbe essere il nuovo NBL (Next Big

Language) dopo Java ma anche no

Investimento rischioso? E’ Open Source (licenza Scala, simil BSD) e

gira sulla JVM: si ha accesso a tutto quello a cui si ha accesso con Java Non è semplice da imparare, soprattutto per

chi non è già addentro il paradigma funzionale

Integrazione con Java Usare Java da Scala è semplicissimo e

straightforward Usare Scala da Java sarà invece più comune

per i progetti che adotteranno scala pian piano (DSL, Actors, ecc.) ma non al 100%

E’ relativamente semplice utilizzare classi e traits Scala da Java, il mapping è diretto nella maggior parte dei casi David Pollack (autore di Lift) dice: Scala in

fondo non è altro che un’altra libreria di Java!

Una scommessa NBL potrebbe non essere ancora nato, ma è

molto probabile che somiglierà più a Scala che a Java

La comunità di Scala è in fermento: molti Alpha geek lo stanno valutando/utilizzando

Twitter, per esempio diversi libri già pubblicati o in beta/roughcut

(nella top ten del JavaOne, ben 3 libri sono su Scala!) Lift (framework web, simil Rails) nuovi framework in uscita

Riferimenti

Link e riferimenti Specifiche

Odersky, Martin. “The Scala Language Specification”, EPFL. http://www.scala-lang.org/docu/files/ScalaReference.pdf

Libri Odersky, Martin. “The Scala Programming Language”.

http://www.artima.com/shop/programming_in_scala Wampler, Dean. “Programming Scala”. http://

programming-scala.labs.oreilly.com/ Landini, Ugo. “Programmare in Scala”. http://

scala.ugolandini.com/

scala primi passi

Technology

component based automation primi passi con simatic imap ·...

primi passi

statistica descrittiva - primi passi-5 - medie, moda,...

primi passi nell'elettronica-ridotto

primi passi su twitter

primi passi di email marketing

09a step7 primi passi s7gs e

uida pediatrica ai primi passi - falcotto.com · ecco...

guida inkscape primi passi con inkscape

primi passi con_la_lim

primi passi - libertàgià

i primi passi nell'analisi tecnica

data driven journalism - i primi passi

algomoocj 02.02. primi passi in javascript

primi passi in libertigià

linea baby: primi passi nel verde

primi passi 1a_tk

lezione1 internet i primi passi

primi passi con kubuntu

primi passi in sicurezza