scala und lift

Scala und Lift Felix Müller

21.09.11

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 Scala und Lift 2

Erwartungen und Ziele

Eure Erwartungen

►  Scala sehen und verstehen

►  Feeling für Scala entwickeln

►  Ideen für die Anwendung von Scala bekommen

►  Lift kennenlernen

►  Einsatzszenarien für Lift erfahren

Meine Ziele

►  eure Erwartungen erfüllen ;-)

►  den Spaß an Scala vermitteln

►  praktische Einführung in Scala geben

21.09.11 Scala und Lift 3

Agenda

Scala

Lift

Ausblick 21.09.11 Scala und Lift 4

21.09.11

Scala Eine ausführliche Einführung

Agenda – Scala

Was, warum und wo?

Einführung in die Sprache

Scala im Vergleich zu Java

Beispielanwendung

Tool Chain

Fazit

21.09.11 Scala und Lift 6

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

►  seit Version 2.9: Enterprise Kontext durch Typesafe (Martin Odersky, James Gosling, Doug Lea, Heiko Seeberger u.a.)

21.09.11 Scala und Lift 7

Martin Odersky, Scala Erfinder

Top Java Ambassador, JAX Innovation Awards 2011

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 Scala und Lift 8

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 Scala und Lift 9

Warum Scala?

Entwicklersicht

►  statisch typisierte Sprache mit vielen Vorteilen von dynamisch typisierten

►  keine Java-Krücken, aber die reiche Spielwiese von Java (Libraries)

►  „Jedes Jahr eine neue Sprache“ (Pragmatic Programmers)

►  („Weil wir es können…“)

Managementsicht

►  weniger Code à weniger Fehler à weniger Aufwand

►  „Faster Time to Market“

►  100 % Java Kompatibilität à Integration mit bestehender Codebasis

►  Attract smarter programmer

21.09.11 Scala und Lift 10

Warum Scala?

Java Scala Groovy JRuby Clojure Typisierung statisch statisch dynamisch dynamisch dynamisch Paradigma OO OO/FP OO OO FP

21.09.11 Scala und Lift 11

►  Vergleich der wichtigsten JVM-Sprachen

Warum Scala?

Java Scala Groovy JRuby Clojure Typisierung statisch statisch dynamisch dynamisch dynamisch Paradigma OO OO/FP OO OO FP

21.09.11 Scala und Lift 12

►  Vergleich der wichtigsten JVM-Sprachen

Warum Scala?

21.09.11 Scala und Lift 13

►  Stackoverflow Rankings als Relevanzindikator (Stand: 5. Juli 2011)

Tag Anzahl Fragen mit dem Tag java 136920 scala 4635 groovy 2388 clojure 1742 jruby 685

Wo wird Scala eingesetzt?

21.09.11 Scala und Lift 14

Hands on! Spracheinführung in Scala

►  Deklaration und Definition von Werten, Variablen, Methoden und Funktionen

21.09.11 Scala und Lift 15

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

Typinferenz

►  Viele Typangaben sind überflüssig. Der Compiler leitet sie eh selbst her!

21.09.11 Scala und Lift 16

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

Typinferenz

►  In der Tat: die meisten Typangaben können entfallen.

21.09.11 Scala und Lift 17

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

Klassen und Objekte

►  Ihr kommt nicht drumrum: ein HelloWorld-Beispiel, aber ein schönes

21.09.11 Scala und Lift 18

// 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)

Klassen und Objekte

►  Zur Übersicht: Umwandlung von Klasse HelloWorld zum Objekt

21.09.11 Scala und Lift 19

// 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)

Klassen und Objekte

►  Jetzt ist HelloWorld ein Singleton Objekt à Scalas Ersatz für Java‘s Statics

21.09.11 Scala und Lift 20

// 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)

Companion Objekte

►  Klassen können einen Gefährten haben: Companion Objekte

21.09.11 Scala und Lift 21

// 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) } }

Traits

►  Traits sind wie Java Interfaces, aber mit Implementierung

21.09.11 Scala und Lift 22

// 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 }

Traits

►  Traits sind Mixins und gestatten eine sichere Mehrfachvererbung

21.09.11 Scala und Lift 23

// 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" }

Self-Type Annotationen

►  ermöglichen weitere Modularisierung und einfache Dependency Injection

21.09.11 Scala und Lift 24

// 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 { // ... }

Funktionen

►  Funktionen sind in Scala First-Class Citizens

21.09.11 Scala und Lift 25

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

Funktionen höherer Ordnung

►  Funktionen, die andere Funktionen als Parameter oder Rückgabewert haben

21.09.11 Scala und Lift 26

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)

Currying

►  Mehr ist immer besser: Scala unterstützt mehrere Parameterlisten

21.09.11 Scala und Lift 27

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?

Eigene Kontrollstrukturen

►  Currying + partiell angewandte Funktionen + Syntactic Sugar

21.09.11 Scala und Lift 28

def sub(x: Int)(y: Int) = x – y def subTowWith = sub(2) _ // Ausgabe: -10 println(subTowWith { val five = 5 val seven = 7 five + seven })

Eigene Kontrollstrukturen deluxe

►  Java 7 Auto-Closeable mit Scala nachgebaut

21.09.11 Scala und Lift 29

// 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() }

Eigene Kontrollstrukturen deluxe

►  Java 7 Auto-Closeable mit Scala nachgebaut

21.09.11 Scala und Lift 30

// 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() } }

Case Klassen

►  Abstrakte Datentypen durch Case Klassen

21.09.11 Scala und Lift 31

// 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)

Pattern Matching

►  Switch auf Steroiden

21.09.11 Scala und Lift 32

// 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) }

Implicit Conversions

►  selbstdefinierte Typumwandlungen (ermöglichen das Pimp my Library Pattern)

21.09.11 Scala und Lift 33

// 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) }

Implicit Conversions

►  Anwendung der definierten Implicit Conversion

21.09.11 Scala und Lift 34

// 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))

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

21.09.11 Scala und Lift 35

►  u.a. durch Scala Standardbibliothek implementiert: enums, break, continue

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 –  Vorteil v.a. bei Typparametern (Generics)

>  Implizite Konvertierungen

21.09.11 Scala und Lift 36

You've got the best of both worlds, don't you?

All our strengths, none of our weaknesses.

Beispielanwendung

Rewrite einer Java Applikation in Scala

21.09.11

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:

21.09.11 Scala und Lift 38

Scala Eclipse IDEA Netbeans 2.8 2.9 ?

Fazit

Pro

►  Scala unterstützt FP ohne dabei mit der OOP zu brechen.

►  Scala ermöglicht verständlicheren Code als Java.

►  Scala ist weniger komplex als Java.

►  Scala ist besonders gut geeignet für:

> Datenverarbeitung > Nebenläufige Programmierung > Domain Specific Languages

Contra

►  Tool Chain >  (schlechte) Integration mit Java Tooling >  im Vergleich zu Java schlechter IDE-

Support >  jedoch positiver Trend zu erkennen

►  viele Sprachfeatures sind für Library-Designer gedacht à seltene Verwendung in Applikationsentwicklung

21.09.11 Scala und Lift 39

21.09.11

Lift Vorstellung des funktionalen Scala Full-Stack Web-Frameworks

Agenda – Lift

Was, warum und wo?

View-First-Konzept

Snippets

Persistenz

Beispielanwendung

Fazit

21.09.11 Scala und Lift 41

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)

21.09.11 Scala und Lift 42

David Pollak, Lift Initiator und Maintainer

Was ist Lift?

21.09.11 Scala und Lift 43

Full-

Stac

k W

eb-F

ram

ewor

k

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 Scala und Lift 44

Wo wird Lift eingesetzt?

21.09.11 Scala und Lift 45

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 Scala und Lift 46

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 Scala und Lift 47

Persistenz

21.09.11 Scala und Lift 48

►  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

Beispielanwendung

Twitter nachgebaut mit Lift von Heiko Seeberger

21.09.11

Fazit

Pro

►  Alleinstellungsmerkmale:

> Comet Support >  JavaScript und Ajax Abstraktion

►  herausragende Community

►  gut geeignet für:

> Echtzeit Web-Apps >  typische Web 2.0 Apps > Social Networks

Contra

►  Vermischung von Schichten

►  enge Kopplung zwischen Komponenten

►  keine Komponentenbibliothek (nur einige Widgets)

►  kein Mehrwert für typische Enterprise-Anwendungen

21.09.11 Scala und Lift 50

21.09.11

Ausblick Weitere interessante Themen

Ausblick – What‘s next?

Scala

►  (Advanced) Sprachfeatures:

>  implizite Argumente und vieles mehr

>  DSLs erstellen

►  Akka als Middleware Framework

►  Spring Integration Scala DSL

►  Play Web-Framework mit Scala Modul

►  CloudFoundry Integration

Lift

►  Web-Services mit Lift

►  BigTop als Lift Extension

►  Komponentenbibliothek

►  Squeryl Anbindung

21.09.11 Scala und Lift 52

Ausblick – Buchtipps

Scala Lift

21.09.11 Scala und Lift 53

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 Scala und Lift 54

21.09.11

Vielen Dank für eure Aufmerksamkeit. Fragen?

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 Scala und Lift 56

Go and start coding Scala!

www.adesso.de

felix.mueller@adesso.de