Introduzione a scala prima parte

864 views

Published on

Introduzione a Scala

Meeting Jug Ancona 23-10-2010

Published in: Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
864
On SlideShare
0
From Embeds
0
Number of Embeds
11
Actions
Shares
0
Downloads
13
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Introduzione a scala prima parte

  1. 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. 2. Agenda Scala  Scopo del linguaggio  Caratteristiche principali  Demos  Vantaggi vs Java  Scala in practice  Swing  Web
  3. 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. 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. 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. 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. 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. 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. 9. Let’s go! object Program { def main(args: Array[String]): Unit = { println(“Hello world!”) } }
  10. 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. 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. 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. 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. 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. 15. Class e Object Java e Scala a confronto con le collection
  16. 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. 17. Trasformare un algoritmo da stile imperativo in funzionale
  18. 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. 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. 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. 21. Realizzare un semplificatore e valutatore di espressioni matematiche Ricerca in una lista
  22. 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. 23. Utilizzare un extractor per valutare un’espressione
  24. 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. 25. Aggiungere un operatore agli interi Utilizzo di mappe Il supporto di Scala per XML
  26. 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. 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

×