Jug Ancona

Onofrio PanzarinoTwitter: @onof80

onofrio.panzarino@gmail.comhttp://it.linkedin.com/in/onofriopanzarino

http://www.google.com/profiles/onofrio.panzarino

AgendaScala

Scopo del linguaggio

Caratteristiche principali

Demos

Vantaggi vs Java

Scala in practice

Swing

Web

why Processori sempre più multi-core Le applicazioni devono supportare sempre più

parallelismo per sfruttare la CPU

L’avvento di Web 2.0 porta ad un numero di interazioni tra sistemi sempre più elevato Le applicazioni devono essere sempre più SCALAbili

Soluzioni Sviluppare applicazioni sempre più multi-thread Lock, Shared Memory, Thread Pools, …

Utilizzare paradigmi che supportano scalabilità e parallelismo naturalmente

why (2) Functional Programming (1930s!)

Oggetti immutabili

Thread safe: no lock

Predicibilità: parallelizzazione

Collaborazione tramite messaggi

No shared memory

Funzioni = oggetti che operano su oggetti

Thread safe: no side effects

Java developer’s frustrations Value types e Reference types

Collections

Verbosità getFoo(), setFoo()

add(), remove(), register(), unregister()

XML

Casting

NullPointerException

Equals e ==

Operatori?

Multithreading

SCAlable LAnguage

Martin Odersky

“Designed to grow with demands of its users”

“Runs on JVM”

“All Java libraries”!

A blend of OOP and FP in statically typed language

Statically typed!

… but explicit types in just the right spaces

what

how Scala = OOP + FP

OOP Objects are responsible for themselves

Class - Trait - Object

Mixin composition

Ogni cosa è un oggetto(anche il nulla!)

FP Le funzioni sono oggetti

Strutture dati immutabili

No side effects

how (2) Compatibile

Conciso

High level

Statically typed

Meno errori run-time

Meno unit testing (Testing proves presence of errors, not their absence)

Generics

Type inference

Refactoring made easy

Let’s go!object Program {

def main(args: Array[String]): Unit = {

println(“Hello world!”)

}

}

object – class - trait Scala supporta le classi class

Scala supporta i singleton nativamente object

Le classi figlie devono specificare esplicitamente i metodi ridefiniti con la keyword override.

I trait sono simili alle interfacce ma ammettono implementazioni parziali o totali

Si possono aggiungere anche molti trait. La risoluzione dei metodi avviene attraverso uno specifico algoritmo.

val Scala favorisce l’uso di codice scritto in modo

funzionale

Variabili non riassegnabili:

val a : Int = 280

a = 281 // Errore!

val b : MyMutable = new MyMutable(“test”)

b = new MyMutable(“test2”) // Errore!

b.myString = “test2” // Ok

var Ma sono permesse le variabili riassegnabili

Per esempio nei cicli while e do-while

var i = 0

i = i + 1;

O nelle classi mutabili

Si possono e si dovrebbero sempre evitare

se non ci sono specifiche ragioni (performance, interazione con codice Java esistente, …)

collections Iterable

Seq

Lists (immutable)

Array (mutable)

ListBuffer (mutable)

ArrayBuffer (mutable)

Queue (mutable | immutable)

Stack (mutable | immutable)

String (immutable)

Set

immutable.Set

immutable.HashSet

mutable.Set

mutable.HashSet

Map

immutable.Map

immutable.HashMap

mutable.Map

mutable.HashMap

maps val nums = Map("i" ->3, "ii" -> 2)

Crea una mappa

nums.contains("ii") Interroga la mappa

nums("ii") Ottiene un valore dalla mappa

nums += ("vi" -> 6) Aggiunge un elemento

Se la mappa è immutable ritorna una nuova mappa (var) Altrimenti aggiunge l’elemento alla mappa (val o var)

nums – "ii“ rimuove un elemento dalla mappa

Class e Object

Java e Scala a confronto con le collection

Funzioni Le funzioni sono oggetti

Possono essere passate come parametri

Essere anonime

Per essere scalabili, non devono avere side-effects:

Concentrare le funzioni di I/O in punti ben precisi del programma

Non cambiare lo stato interno degli oggetti: oggettiimmutabili

Ritornare sempre un valore (nota: tuple)

Trasformare un algoritmo da stile imperativo in funzionale

Pattern matching (1) Case classes

case class MyCaseClass(name: String)

Scala fornisce per questo tipo di classi un’implementazione standard:

Un factory method

Tutti gli argomenti della classe sono usati come campi immutabili della stessa

toString, hashCode, equals

Sono un po’ più ingombranti ma forniscono un modo naturale per supportare il pattern matching.

Pattern matching (2) Si usano le keyword match e case

Simile al classico switch – case, tranne che:

L’argomento di match può essere qualsiasi oggetto

È un’espressione (ritorna sempre un valore)

Lancia un MatchError se il caso non è contemplato

Si può usare un’espressione di default (con wildcard)

L’espressione in case (pattern) può essere qualsiasi oggetto, anche parzialmente specificato

In genere è una case class!

Pattern matching (3) Essendo un’espressione

Può essere utilizzata come parametro

Può essere usata come partial function

Esempio

val count = myObjects match {

a : Seq[Int] => a.reduceLeft ( _ + _ )

(x : Int, _ ) => x

_ => 1

}

Realizzare un semplificatore e valutatore di espressioni matematiche

Ricerca in una lista

Extractors Il metodo apply può essere visto come un modo per trattare

un oggetto come una funzione (funtore) Il metodo unapply può essere visto come la funzione

inversa: dato un risultato ottiene gli argomenti Può essere usato per fare pattern matching:

object EMail {def apply(user: String, domain: String)

= user +"@"+ domaindef unapply(str: String): Option[(String, String)] = {

val parts = str split "@“if (parts.length == 2) Some(parts(0), parts(1)) else None

}}

Utilizzare un extractor per valutare un’espressione

operators = methods Identificatore

Uno o più simboli Unicode o ASCII printable characterstranne lettere, cifre, parentesi, underscore, semicolon (;), comma (,), punto (.)

Esempi

+ ++ ::: <?> :-> <::

Si definiscono come normali metodi

Anche unari prefissi

unary_-

Aggiungere un operatore agli interi

Utilizzo di mappe

Il supporto di Scala per XML

Riferimenti http://www.scala-lang.org/

M. Odersky, L. Spoon, B. Venners, Programming in Scala, Artima

Completo, chiaro e dettagliato

scala-user mailing list

http://stackoverflow.com/questions/tagged/scala

Blogs

http://debasishg.blogspot.com/

http://james-iry.blogspot.com/

Riferimenti (2) http://www.artima.com/index.jsp

irc://irc.freenode.net/scala

Le demo:

http://github.com/onof/it.onof.demo.scala

Enjoy with