Die Präsentation führt in die Programmiersprache Scala und das Web-Framework Lift ein.

1. Scala und Lift
Felix Müller
21.09.11

2. Mein Background
► 7 Jahre Java, 2 Jahre C# und andere Sprachen
► 4 Monate Scala
► 3 Monate Lift
► Studentischer Mitarbeiter
► Bachelorarbeit bei adesso zum Thema: „Vergleich des Scala Web-Frameworks
Lift mit dem Java EE Programmiermodell “
► Twitter: @fmueller_bln
► Mail: felix.mueller@adesso.de
21.09.11 2 Scala und Lift

3. Erwartungen und Ziele
Eure Erwartungen Meine Ziele
► Scala sehen und verstehen ► eure Erwartungen erfüllen ;-)
► Feeling für Scala entwickeln ► den Spaß an Scala vermitteln
► Ideen für die Anwendung von Scala ► praktische Einführung in Scala geben
bekommen
► Lift kennenlernen
► Einsatzszenarien für Lift erfahren
21.09.11 3 Scala und Lift

4. Agenda
Scala
Lift
Ausblick
21.09.11 4 Scala und Lift

5. Scala
Eine ausführliche Einführung
21.09.11

6. Agenda – Scala
Was, warum und wo?
Einführung in die Sprache
Scala im Vergleich zu Java
Beispielanwendung
Tool Chain
Fazit
21.09.11 6 Scala und Lift

7. Was ist Scala?
► eine objektfunktionale Programmiersprache
► Programmiersprache für die JVM (und .Net)
► 2003 in Version 1 veröffentlicht à aktuell: 2.9
► ursprünglich akademischer Kontext: entwickelt an
École polytechnique fédérale de Lausanne Martin Odersky,
Scala Erfinder
Top Java Ambassador,
► seit Version 2.9: Enterprise Kontext durch Typesafe JAX Innovation Awards 2011
(Martin Odersky, James Gosling, Doug Lea, Heiko Seeberger u.a.)
21.09.11 7 Scala und Lift

8. Was ist Scala?
Scala ist…
► vollständig objektorientiert, funktional und imperativ.
► eine Skript- sowie moderne Applikationssprache.
► interoperabel mit Java und ein aufgeräumtes Java.
► ein Toolkit zum Erstellen von eigenen Sprachen (DSLs).
► das was Java schon lange sein sollte, aber vielleicht erst in 10 Jahren ist.
21.09.11 8 Scala und Lift

9. Was ist Scala?
Was kann man mit Scala?
► Beliebige Problemstellungen ausdrücken und per Typsystem prüfen
► Für jeden Anwendungsfall einen optimalen Kontext schaffen
► Vorhandenen Code zu jeder beliebigen Zeit flexibel und sicher erweitern
► Direkt auf der JVM aufsetzen und beliebige Java-Libraries nutzen
► Einfache Aufgaben erledigen, komplexe einfach machen
► Mit den Aufgaben und Anforderungen wachsen  Scalable
21.09.11 9 Scala und Lift

10. Warum Scala?
Entwicklersicht Managementsicht
► statisch typisierte Sprache mit vielen ► weniger Code à weniger Fehler à
Vorteilen von dynamisch typisierten weniger Aufwand
► keine Java-Krücken, aber die reiche ► „Faster Time to Market“
Spielwiese von Java (Libraries)
► „Jedes Jahr eine neue ► 100 % Java Kompatibilität à Integration
Sprache“ (Pragmatic Programmers) mit bestehender Codebasis
► („Weil wir es können…“) ► Attract smarter programmer
21.09.11 10 Scala und Lift

11. Warum Scala?
► Vergleich der wichtigsten JVM-Sprachen
Java Scala Groovy JRuby Clojure
Typisierung statisch statisch dynamisch dynamisch dynamisch
Paradigma OO OO/FP OO OO FP
21.09.11 11 Scala und Lift

12. Warum Scala?
► Vergleich der wichtigsten JVM-Sprachen
Java Scala Groovy JRuby Clojure
Typisierung statisch statisch dynamisch dynamisch dynamisch
Paradigma OO OO/FP OO OO FP
21.09.11 12 Scala und Lift

13. Warum Scala?
► Stackoverflow Rankings als Relevanzindikator (Stand: 5. Juli 2011)
Tag Anzahl Fragen mit dem Tag
java 136920
scala 4635
groovy 2388
clojure 1742
jruby 685
21.09.11 13 Scala und Lift

14. Wo wird Scala eingesetzt?
21.09.11 14 Scala und Lift

15. Hands on! Spracheinführung in Scala
► Deklaration und Definition von Werten, Variablen, Methoden und Funktionen
val meaningOfLife: Int = 42 // immutable
var maybeImportantNumber: Double = 3.14 // mutable
// Methode
def printNumber(number: Int) {
println("Number: " + number)
}
// Funktion
def incNumber(number: Int) : Int = {
number + 1 // entspricht: number.+(1)
}
printNumber(meaningOfLife)
printNumber(incNumber(meaningOfLife))
21.09.11 15 Scala und Lift

16. Typinferenz
► Viele Typangaben sind überflüssig. Der Compiler leitet sie eh selbst her!
val meaningOfLife: Int = 42 // immutable
var maybeImportantNumber: Double = 3.14 // mutable
// Methode
def printNumber(number: Int) {
println("Number: " + number)
}
// Funktion
def incNumber(number: Int) : Int = {
number + 1 // entspricht: number.+(1)
}
printNumber(meaningOfLife)
printNumber(incNumber(meaningOfLife))
21.09.11 16 Scala und Lift

17. Typinferenz
► In der Tat: die meisten Typangaben können entfallen.
val meaningOfLife = 42 // immutable
var maybeImportantNumber = 3.14 // mutable
// Methode
def printNumber(number: Int) {
println("Number: " + number)
}
// Funktion
def incNumber(number: Int) = {
number + 1 // entspricht: number.+(1)
}
printNumber(meaningOfLife)
printNumber(incNumber(meaningOfLife))
21.09.11 17 Scala und Lift

18. Klassen und Objekte
► Ihr kommt nicht drumrum: ein HelloWorld-Beispiel, aber ein schönes
// einfache Scala Klasse, ist immutable
// Konstruktor und “Getter” werden automatisch generiert
class Person(val name: String, val surname: String)
// greeting ist ein privater Wert, kein Zugriff von außen
class HelloWorld(greeting: String) {
def sayHelloTo(p: Person) = println(greeting+p.name)
}
// Ausgabe: Hallo Felix
val felix = new Person("Felix", "Müller")
new HelloWorld("Hallo ").sayHelloTo(felix)
21.09.11 18 Scala und Lift

19. Klassen und Objekte
► Zur Übersicht: Umwandlung von Klasse HelloWorld zum Objekt
// einfache Scala Klasse, ist immutable
// Konstruktor und “Getter” werden automatisch generiert
class Person(val name: String, val surname: String)
// greeting ist ein privater Wert, kein Zugriff von außen
class HelloWorld(greeting: String) {
def sayHelloTo(p: Person) = println(greeting+p.name)
}
// Ausgabe: Hallo Felix
val felix = new Person("Felix", "Müller")
new HelloWorld("Hallo ").sayHelloTo(felix)
21.09.11 19 Scala und Lift

20. Klassen und Objekte
► Jetzt ist HelloWorld ein Singleton Objekt à Scalas Ersatz für Java‘s Statics
// einfache Scala Klasse, ist immutable
// Konstruktor und “Getter” werden automatisch generiert
class Person(val name: String, val surname: String)
object HelloWorld {
// greeting ist public (Standard-Scope in Scala)
val greeting = "Hallo "
def sayHelloTo(p: Person) = println(greeting+p.name)
}
// Ausgabe: Hallo Felix
val felix = new Person("Felix", "Müller")
HelloWorld.sayHelloTo(felix)
21.09.11 20 Scala und Lift

21. Companion Objekte
► Klassen können einen Gefährten haben: Companion Objekte
// wird zu Person.apply(“Felix”, “Müller”) ergänzt
val felix = Person("Felix", "Müller")
class Person(val surname: String, val name: String,
age: Int) {
require(age >= 18, "age must not be less than 18")
}
// beinhaltet alle Statics u. apply-Funktionen für Person
object Person {
def apply(name: String, surname: String) = {
new Person(name, surname, 18)
}
}
21.09.11 21 Scala und Lift

22. Traits
► Traits sind wie Java Interfaces, aber mit Implementierung
// Traits ermöglichen flache u. breite Klassenhierarchien
// Beispiel: Zutaten für eine glückliche Person
trait Person {
val name: String
}
trait HasHobby {
def myHobby: String
}
trait HasFoundMeaningOfLife {
val meaningOfLife = "5"
def calculateMeaningOfLife = 2 + 3
}
21.09.11 22 Scala und Lift

23. Traits
► Traits sind Mixins und gestatten eine sichere Mehrfachvererbung
// Konstruktor-Parameter name implementiert Person.name
class HappyPerson(val name: String) extends Person
with HasHobby with HasFoundMeaningOfLife {
// in Scala gibt es kein @Override, sondern ein
// Schlüsselwort für das Überschreiben
override val meaningOfLife = "42"
override def calculateMeaningOfLife = 42
// hier ist override optional, da in HasHobby keine
// Implementierung vorhanden ist
def myHobby = "Programming in Scala"
}
21.09.11 23 Scala und Lift

24. Self-Type Annotationen
► ermöglichen weitere Modularisierung und einfache Dependency Injection
// this ist in Analyzer mit Backend typisiert
trait Analyzer { this: Backend =>
// Analyzer hat Zugriff auf alle Member von Backend
}
// Ergebnis:
// à Analyzer kann Backend erweitern um Funktionen
// à Analyzer definiert Abhängigkeit zu Backend
trait Backend extends Analyzer {
// ...
}
21.09.11 24 Scala und Lift

25. Funktionen
► Funktionen sind in Scala First-Class Citizens
def dec(i: Int) = i – 1 // Signatur: Int => Int
// dec als Funktionsliteral
(i: Int) => i – 1
// der Compiler macht daraus ein Objekt
new Function[Int, Int]() { def apply(i: Int) = i - 1 }
// Zuweisung des Funktionsliterals zu einem Wert
val decFunction = (i: Int) => i – 1
// macht beim Aufruf keinen Unterschied
println(dec(2)) // Ausgabe: 1
println(decFunction(3)) // Ausgabe: 2
21.09.11 25 Scala und Lift

26. Funktionen höherer Ordnung
► Funktionen, die andere Funktionen als Parameter oder Rückgabewert haben
def dec(i: Int) = i – 1 // Signatur: Int => Int
// wendet eine Funktion auf alle Listenelemente an
def doWithListOfNumbers(list: List[Int],
function: Int => Int) = {
// map ist nur eine Funktion der reichhaltigen
// Collection API von Scala
list.map(function)
}
// dec kann als Wert einfach übergeben werden
// List(1, 2, 3) wird zu List.apply(1, 2, 3) à Companion
println(doWithListOfNumbers(List(1, 2, 3), dec))
// Ausgabe: List(0, 1, 2)
21.09.11 26 Scala und Lift

27. Currying
► Mehr ist immer besser: Scala unterstützt mehrere Parameterlisten
def sub(x: Int)(y: Int) = x – y
println(sub(2)(3)) // Ausgabe: -1
// Das ist keine Magie! Anders definiert werden:
def sub(x: Int) = (y: Int) => x – y
// Aber: Wozu?
21.09.11 27 Scala und Lift

28. Eigene Kontrollstrukturen
► Currying + partiell angewandte Funktionen + Syntactic Sugar
def sub(x: Int)(y: Int) = x – y
def subTowWith = sub(2) _
// Ausgabe: -10
println(subTowWith {
val five = 5
val seven = 7
five + seven
})
21.09.11 28 Scala und Lift

29. Eigene Kontrollstrukturen deluxe
► Java 7 Auto-Closeable mit Scala nachgebaut
// Java 7: close() wird automatisch aufgerufen
try (InputStream is = new FileInputStream("File.txt")) {
// Daten vom Stream lesen und verarbeiten
// z.B. is.read();
}
// Wir wollen sowas auch in Scala haben!
// try als Schlüsselwort ist schon besetzt,
// also using wie in C# à Das Ziel:
using(new FileInputStream("File.txt")) { stream =>
// Daten vom Stream lesen und verarbeiten
// z.B. stream.read()
}
21.09.11 29 Scala und Lift

30. Eigene Kontrollstrukturen deluxe
► Java 7 Auto-Closeable mit Scala nachgebaut
// Volle Scala Power:
// à Statisches Ducktyping mit strukturellen Typen
// à Currying
// à Funktionen höherer Ordnung
def using[T <: { def close() }](resource: T)
(block: T => Unit) {
try {
block(resource)
} finally {
if (resource != null)
resource.close()
}
}
21.09.11 30 Scala und Lift

31. Case Klassen
► Abstrakte Datentypen durch Case Klassen
// Case Klassen haben automatisch ein Companion Objekt
// mit passender apply-Funktion
// equals, hashCode und toString werden ebenfalls
// automatisch generiert
abstract sealed class Frucht
case class Apfel(sauer: Boolean) extends Frucht
case class Birne(sorte: String) extends Frucht
// mit einer abstrakten, versiegelten Klasse kann der
// Scala Compiler sichere Typchecks machen (z.B. beim
// Pattern Matching)
21.09.11 31 Scala und Lift

32. Pattern Matching
► Switch auf Steroiden
// Switch-ähnlich, aber mehr Möglichkeiten:
// à Mustervergleich nach Werten, Typen, Tupeln,
// regulären Ausdrücken
// à Formulierung von Mustern, z.B: (1, _, x:
Double)
// à Wildcard, der Unterstrich _
def welcheFrucht(frucht: Frucht) = frucht match {
case Apfel(true) => println("Saurer Apfel.")
case Apfel(false) => println("Nicht saurer Apfel.")
case Birne(sorte) => println("Birnensorte: " + sorte)
}
21.09.11 32 Scala und Lift

33. Implicit Conversions
► selbstdefinierte Typumwandlungen (ermöglichen das Pimp my Library Pattern)
// List wird um headOr Funktion erweitert („gepimpt“)
class ListExtensions[A](list : List[A]) {
def headOr(f: => A): A = list match {
case h :: _ => h
case Nil => f
}
}
object ListExtensions {
implicit def listExtensions[A](list : List[A]) =
new ListExtensions(list)
}
21.09.11 33 Scala und Lift

34. Implicit Conversions
► Anwendung der definierten Implicit Conversion
// Implicit Conversion wird in den Scope importiert
import ListExtensions._
// durch Implicit Conversion kann headOr auf List
// aufgerufen werden
// Ausgabe: 1
println(List(1,2,3).headOr(0))
// à println(new ListExtensions(List(1, 2,
3)).headOr(0))
// Ausgabe: 0
println(Nil.asInstanceOf[List[Int]].headOr(0))
21.09.11 34 Scala und Lift

35. Scala im Vergleich zu Java
Scala fügt hinzu… Scala entfernt…
Vollständige Objektorientierung Statics
Operator-Überladung Primitive Typen
Funktionen höherer Ordnung Kontrollstrukturen: switch, break,
continue, do-while, ternärer Operator
Mixin Komposition durch Traits Wildcards
Abstrakte Datentypen Raw Typs
Pattern Matching Enums
► u.a. durch Scala Standardbibliothek implementiert: enums, break, continue
21.09.11 35 Scala und Lift

36. Scala im Vergleich zu Java
► Scala’s Typsystem ist stark und statisch.
► Es sind viel mehr Ausdrücke prüfbar als in Java:
> einfaches Refactoring
> ermöglicht guten IDE-Support
► Scala Code wirkt dynamisch
> Typangaben entfallen meist
– Ausnahme: Schnittstellen You've got the best of both
– Vorteil v.a. bei Typparametern (Generics) worlds, don't you?
All our strengths, none of
> Implizite Konvertierungen our weaknesses.
21.09.11 36 Scala und Lift

37. Beispielanwendung
Rewrite einer Java Applikation in Scala
21.09.11

38. Tool Chain
► Maven Plugin für Scala
► alle Scala Libraries lassen sich mit Maven (und Ant) integrieren
► Scala hat eigenes Build- und Deployment Tool: SBT, Simple Build Tool
► SBT ist eine goldene Mischung aus Maven und Ant
> deklarativ und imperativ zugleich (ähnlich zu Gradle)
> nutzt Scala für die Konfiguration à viele Möglichkeiten für Anpassungen ohne
XML-Hölle
► Scala Plugins für Eclipse, IDEA und Netbeans:
Scala Eclipse IDEA Netbeans
2.8
2.9 ?
21.09.11 38 Scala und Lift

39. Fazit
Pro Contra
► Scala unterstützt FP ohne dabei mit der ► Tool Chain
OOP zu brechen. > (schlechte) Integration mit Java Tooling
> im Vergleich zu Java schlechter IDE-
Support
► Scala ermöglicht verständlicheren Code
als Java. > jedoch positiver Trend zu erkennen
► Scala ist weniger komplex als Java. ► viele Sprachfeatures sind für Library-
Designer gedacht à seltene Verwendung
in Applikationsentwicklung
► Scala ist besonders gut geeignet für:
> Datenverarbeitung
> Nebenläufige Programmierung
> Domain Specific Languages
21.09.11 39 Scala und Lift

40. Lift
Vorstellung des funktionalen Scala Full-Stack
Web-Frameworks
21.09.11

41. Agenda – Lift
Was, warum und wo?
View-First-Konzept
Snippets
Persistenz
Beispielanwendung
Fazit
21.09.11 41 Scala und Lift

42. Was ist Lift?
► funktionales Web-Framework für Scala
► seit 2007 in Entwicklung, aktuell: Version 2.4-M1
► Full-Stack: deckt Frontend- und Backend-Belange ab
► unterstützte als eines der ersten Frameworks Comet
(Ajax-Push, in HTML5: WebSocket) David Pollak,
Lift Initiator und Maintainer
21.09.11 42 Scala und Lift

43. Was ist Lift?
Full-Stack Web-Framework
21.09.11 43 Scala und Lift

44. Warum Lift?
► Standard für Web-Entwicklung mit Scala
► setzt auf der Java EE Plattform auf
► interessante Konzepte
► vereint viele Ideen anderer Frameworks
► wird in „richtigen“ Projekte eingesetzt à läuft produktiv und skaliert gut
21.09.11 44 Scala und Lift

45. Wo wird Lift eingesetzt?
21.09.11 45 Scala und Lift

46. View-First-Konzept
► Seitenbeschreibungen in Standard XHTML-Tags
► Ziel:
> Designer friendly Templates
> keine Logik im View
► kein MVC, eigenes Entwurfsmuster: View-ViewModel-Model
21.09.11 46 Scala und Lift

47. Snippets
► Snippets sind das ViewModel
► Snippets sind Funktionen, die XML-Knoten transformieren:
> NodeSeq => NodeSeq
> XML-Prozessoren, die das Markup direkt verändern
► Snippets sorgen für dynamische Seiteninhalte und Anbindung des Backends
► Snippets können zustandsbehaftet sein
21.09.11 47 Scala und Lift

48. Persistenz
► 2 Persistenz-Bibliotheken: Mapper und Record
► Mapper baut auf JDBC auf und ist Quasi-Standard in Lift
► Record ist Abstraktionsschicht für andere ORM-Frameworks
21.09.11 48 Scala und Lift

49. Beispielanwendung
Twitter nachgebaut mit Lift von Heiko Seeberger
21.09.11

50. Fazit
Pro Contra
► Alleinstellungsmerkmale: ► Vermischung von Schichten
> Comet Support
> JavaScript und Ajax Abstraktion ► enge Kopplung zwischen Komponenten
► herausragende Community ► keine Komponentenbibliothek (nur einige
Widgets)
► gut geeignet für:
► kein Mehrwert für typische Enterprise-
> Echtzeit Web-Apps
Anwendungen
> typische Web 2.0 Apps
> Social Networks
21.09.11 50 Scala und Lift

51. Ausblick
Weitere interessante Themen
21.09.11

52. Ausblick – What‘s next?
Scala Lift
► (Advanced) Sprachfeatures: ► Web-Services mit Lift
> implizite Argumente und vieles mehr
> DSLs erstellen ► BigTop als Lift Extension
► Akka als Middleware Framework ► Komponentenbibliothek
► Spring Integration Scala DSL ► Squeryl Anbindung
► Play Web-Framework mit Scala Modul
► CloudFoundry Integration
21.09.11 52 Scala und Lift

53. Ausblick – Buchtipps
Scala Lift
21.09.11 53 Scala und Lift

54. Ausblick – Scala vs. Java
► Und wo ist jetzt der Java Rant?!
► Hier, aber in zivilisierter Form:
https://www.adesso.de/wiki/index.php/Datei:Scala%C3%9Cbersicht.pdf
21.09.11 54 Scala und Lift

55. Vielen Dank für eure Aufmerksamkeit.
Fragen?
21.09.11

56. Quellen
► http://scala-boss.heroku.com
► http://www.slideshare.net/Odersky/fosdem-2009-1013261
► http://www.mate.it/en/component/content/article/84-perche-scala
► https://www.adesso.de/wiki/index.php/Datei:Scala_Pr
%C3%A4sentation_Nightsession.ppt
► http://www.scala-lang.org/node/1658
► http://scala.sygneca.com/patterns/pimp-my-library
21.09.11 56 Scala und Lift

57. Go and start coding Scala!
felix.mueller@adesso.de
www.adesso.de