Scala und Lift

09.04.2023

Scala und LiftFelix Müller

09.04.2023 Scala und Lift2

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]


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

09.04.2023

ScalaEine 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 // immutablevar maybeImportantNumber: Double = 3.14 // mutable

// Methodedef printNumber(number: Int) { println("Number: " + number)}

// Funktiondef 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 // immutablevar maybeImportantNumber: Double = 3.14 // mutable


// Funktiondef incNumber(number: Int) : Int = { number + 1 // entspricht: number.+(1)}



Typinferenz

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

val meaningOfLife = 42 // immutablevar maybeImportantNumber = 3.14 // mutable


// Funktiondef incNumber(number: Int) = { number + 1 // entspricht: number.+(1)}



Klassen und Objekte

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

// einfache Scala Klasse, ist immutable// Konstruktor und “Getter” werden automatisch generiertclass Person(val name: String, val surname: String)

// greeting ist ein privater Wert, kein Zugriff von außenclass HelloWorld(greeting: String) {

def sayHelloTo(p: Person) = println(greeting+p.name)}

// Ausgabe: Hallo Felixval felix = new Person("Felix", "Müller")new HelloWorld("Hallo ").sayHelloTo(felix)


Klassen und Objekte

► Zur Übersicht: Umwandlung von Klasse HelloWorld zum Objekt


// greeting ist ein privater Wert, kein Zugriff von außenclass HelloWorld(greeting: String) {

def sayHelloTo(p: Person) = println(greeting+p.name)}

// Ausgabe: Hallo Felixval 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


object HelloWorld {

// greeting ist public (Standard-Scope in Scala) val greeting = "Hallo " def sayHelloTo(p: Person) = println(greeting+p.name)}

// Ausgabe: Hallo Felixval 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änztval 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 Personobject 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 Persontrait 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.nameclass 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 typisierttrait 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 Objektnew Function[Int, Int]() { def apply(i: Int) = i - 1 }

// Zuweisung des Funktionsliterals zu einem Wertval decFunction = (i: Int) => i – 1

// macht beim Aufruf keinen Unterschiedprintln(dec(2)) // Ausgabe: 1println(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 andef 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) Companionprintln(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: -10println(subTowWith { val five = 5 val seven = 7 five + seven})


Eigene Kontrollstrukturen deluxe

► Java 7 Auto-Closeable mit Scala nachgebaut

// Java 7: close() wird automatisch aufgerufentry (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 Fruchtcase class Apfel(sauer: Boolean) extends Fruchtcase 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 importiertimport ListExtensions._

// durch Implicit Conversion kann headOr auf List// aufgerufen werden

// Ausgabe: 1println(List(1,2,3).headOr(0))// println(new ListExtensions(List(1, 2, 3)).headOr(0))

// Ausgabe: 0println(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

09.04.2023


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

09.04.2023

LiftVorstellung 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?

Fu

ll-S

tack

W

eb-F

ram

ewo

rk


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

09.04.2023


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

09.04.2023

AusblickWeitere 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



09.04.2023

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

http://scala-boss.heroku.com/

http://scala-boss.heroku.com/

http://www.slideshare.net/Odersky/fosdem-2009-1013261

http://www.slideshare.net/Odersky/fosdem-2009-1013261

http://www.mate.it/en/component/content/article/84-perche-scala

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://www.scala-lang.org/node/1658

http://scala.sygneca.com/patterns/pimp-my-library

Go and start coding Scala!

[email protected]

http://www.adesso.de/

mailto:[email protected]

Scala und Lift

Documents

Transcript of Scala und Lift