Introduzione a Scala Meeting Jug Ancona 23-10-2010

1. Jug Ancona
Onofrio Panzarino
Twitter: @onof80
onofrio.panzarino@gmail.com
http://it.linkedin.com/in/onofriopanzarino
http://www.google.com/profiles/onofrio.panzarino

2. Agenda
Scala
 Scopo del linguaggio
 Caratteristiche principali
 Demos
 Vantaggi vs Java
 Scala in practice
 Swing
 Web

3. 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

4. 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

5. Java developer’s frustrations
 Value types e Reference types
 Collections
 Verbosità
 getFoo(), setFoo()
 add(), remove(), register(), unregister()
 XML
 Casting
 NullPointerException
 Equals e ==
 Operatori? 
 Multithreading

6.  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

7. 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

8. 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

9. Let’s go!
object Program {
def main(args: Array[String]): Unit = {
println(“Hello world!”)
}
}

10. 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.

11. 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

12. 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, …)

13. 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

14. 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

15. Class e Object
Java e Scala a confronto con le collection

16. 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: oggetti
immutabili
 Ritornare sempre un valore (nota: tuple)

17. Trasformare un algoritmo da stile imperativo in funzionale

18. 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.

19. 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!

20. 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
}

21. Realizzare un semplificatore e valutatore di espressioni
matematiche
Ricerca in una lista

22. 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 +"@"+ domain
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@“
if (parts.length == 2) Some(parts(0), parts(1)) else None
}
}

23. Utilizzare un extractor per valutare un’espressione

24. operators = methods
 Identificatore
 Uno o più simboli Unicode o ASCII printable characters
tranne lettere, cifre, parentesi, underscore, semicolon
(;), comma (,), punto (.)
 Esempi
 + ++ ::: <?> :-> <::
 Si definiscono come normali metodi
 Anche unari prefissi
 unary_-

25. Aggiungere un operatore agli interi
Utilizzo di mappe
Il supporto di Scala per XML

26. 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/

27. 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