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: [email protected]

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


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


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


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.


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


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


Warum Scala?

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


►  Vergleich der wichtigsten JVM-Sprachen

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

Wo wird Scala eingesetzt?


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

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

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

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)

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)

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)

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

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 }

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

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

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

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)

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?

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

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

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

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)

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

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

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


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


►  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


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:


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

Lift Vorstellung des funktionalen Scala Full-Stack Web-Frameworks

Agenda – Lift

Was, warum und wo?

View-First-Konzept

Snippets

Persistenz

Beispielanwendung

Fazit


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

Was ist Lift?


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


Wo wird Lift eingesetzt?


View-First-Konzept

►  Seitenbeschreibungen in Standard XHTML-Tags

►  Ziel: >  Designer friendly Templates >  keine Logik im View

►  kein MVC, eigenes Entwurfsmuster: View-ViewModel-Model


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


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

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

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


Ausblick – Buchtipps

Scala Lift


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

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


Go and start coding Scala!

www.adesso.de

[email protected]

scala und lift

Technology