jvm functional language battle - oio-die java … › m › konf › vortraege ›...

Orientation in Objects GmbH

Weinheimer Str. 68

68309 Mannheim

www.oio.de

[email protected]:

JVM Functional

Language Battle

1.0

JVM Functional Language Battle© Orientation in Objects GmbH

Ihr Sprecher

Architektur

Agile Softwareentwicklung

Codequalität

Trainer, Berater, Entwickler

Falk Sippach (@sippsack)

2

Co-Organisator


Java, XML und Open Source seit 1998

) Competence Center)) Object Rangers )

• Schulungen, Coaching,

Weiterbildungsberatung,

Train & Solve-Programme

• Methoden, Standards und

Tools für die Entwicklung

von offenen, unternehmens-

weiten Systemen

• Unterstützung laufender

Java Projekte

• Perfect Match

• Rent-a-team

• Coaching on the project

• Inhouse Outsourcing

• Schlüsselfertige Realisierung

von Java Software

• Individualsoftware

• Pilot- und Migrationsprojekte

• Sanierung von Software

• Software Wartung

) Software Factory )

3


Abstract

4

Funktionale Programmierung soll so viel ausdrucksstärker sein, aber

leider ist dieses Programmier-Paradigma nicht ganz kompatibel zu der

prozedural- und objektorientierten Denkweise von uns Java-Entwicklern.

Anhand eines kleinen Algorithmus werden wir uns verschiedene Lösungen

zunächst im klassischem imperativen Java (vor Java 8) und als Vergleich

dazu in alternativen JVM-Sprachen (Groovy, Frege, ggf. Scala bzw.

JavaScript) anschauen und die verschiedenen Lösungen diskutieren.

Herauskommen soll eine saubere und verständlichere Struktur, die zu

besser les- und wartbarem Code führen wird. Die gewonnenen

Erkenntnisse wollen wir dann letztendlich in Java 8 mittels Streams und

Lambda-Ausdrücken umsetzen, so dass jeder Zuhörer die Grundideen der

funktionalen Programmierung mit in seine tägliche Arbeit nehmen kann.

Es sind keine speziellen Vorkenntnisse in den angesprochenen

alternativen Sprachen notwendig, ein solides Verständnis für die

Programmiersprache Java genügt.

JVM Functional Language Battle© Orientation in Objects GmbH 5

Einführung Imperativ DeklarativFunctional

Java

Agenda

<x>

<y/>

</x>


Experiment


Java

GroovyHaskell

ScalaClojure

Frege

FunktionalImperativ


Imperative Programmierung (lat. imperare

‚anordnen‘, ‚befehlen‘) ist ein

Programmierparadigma, nach dem „ein

Programm aus einer Folge von

Anweisungen besteht, die vorgeben, in

welcher Reihenfolge was vom Computer

getan werden soll“.

Imperative Programmierung

https://de.wikipedia.org/wiki/Imperative_Programmierung


Funktional

DeklarativImperativ


Funktionale Programmierung ist

ein Programmierparadigma, bei dem

Programme ausschließlich aus Funktionen

bestehen. Dadurch wird bewusst auf die aus

der imperativen Programmierung

bekannten Nebenwirkungen verzichtet.

Funktionale Programmierung

https://de.wikipedia.org/wiki/Programmierparadigma

https://de.wikipedia.org/wiki/Imperative_Programmierung

https://de.wikipedia.org/wiki/Wirkung_(Informatik)


Problemstellung


?


Luhn-Algorithmus;

Luhn-Formel;

"Modulo 10"-Algorithmus;

Double-Add-Double-Methode

Prüfsummen-Berechnung


Validierung von Kreditkarten

• Luhn Algorithmus

• Kreditkartennummern können sich selbst prüfen

• Berechnung einer Prüfsumme aus den einzelnen Ziffern

• wenn Prüfsumme modulo 10

– = 0 => valide

– <> 0 => nicht valide

14

rein clientseitige

Prüfung möglich


Wie funktioniert die Validierung genau

1. (Umwandlung in Ziffern)

2. Reihenfolge vertauschen

3. jede zweite Zahl verdoppeln

4. einzelne Zahlen zusammenaddieren

– bei Zahlen größer 9 werden die einzelnen Ziffern aufaddiert

5. valide, wenn die Summe modulo 10 == 0

15


Beispiel

"4716347184862961"4 7 1 6 3 4 7 1 8 4 8 6 2 9 6 1

1 6 9 2 6 8 4 8 1 7 4 3 6 1 7 4

1 12 9 4 6 16 4 16 1 14 4 6 6 2 7 8

1 1 2 9 4 6 1 6 4 1 6 1 1 4 4 6 6 2 7 8

1 3 9 4 6 7 4 7 1 5 4 6 6 2 7 8

1 + 3 + 9 + 4 + 6 + 7 + 4 + 7 + 1 + 5 + 4 + 6 + 6 + 2 + 7 + 8

80

80 % 10 == 0

gültig


Java klassisch – Variante 1

19


Java klassisch – Variante 2

20


Java klassisch mit sprechenden Methodennamen

21


Demo

Kreditkarten-Nummer prüfen mit Java:

public static void main(String[] args) {

System.out.println(isValid("4716347184862961"));

}

22


Programm: Folge von elementaren Schritten

Typischer Schritt ist die Wertzuweisung

Speicherung von Daten erfolgt in Variablen

Kontrollstrukturen:

• Sequenzen (…; …;)

• Alternativen (if, switch)

• Schleifen (for, while, do…while)

• Sprünge und Unterprogrammaufrufe (goto)


Imperativ vs. Deklarativ

24

Imperativ: Wie erreiche ich mein Ziel?

Deklarativ: Was will ich erreichen?


Funktional

Imperativ


Java klassisch – Spaghetti-Code

26

Aufspalten in Ziffern

Jede 2. Ziffer verdoppeln

Aufsummieren

Validierungsprüfung

Reihenfolge drehen


Und in anderen Sprachen?


Groovy

• objektorientiert

• dynamisch und/statisch typisiert

• ausdrucksstarke/prägnante Syntax

• sehr gute Integration mit Java (JVM, Bibliotheken, Vererbung, …)

• Metaprogrammierung, Closures, Operatorüberladung

28


Demo

Kreditkarten-Nummer prüfen mit Groovy

groovy> isValid 4716347184862961

true

29


JavaScript

• objektorientierte Skriptsprache

• aber klassenlos (Prototyp-basiert)

• dynamisch typisiert

• Funktionen sind First-Class-Citizens

• Client (Browser) und Server (Node.js, Nashorn auf JVM)

30


Demo

Kreditkarten-Nummer prüfen mit JavaScript

> isValid(4716347184862961)

true

31


Scala

• funktional und objektorientiert

• statisch typisiert (Typinferenz)

• Funktionen als First-Class-Citizens

• Pattern Matching

• Java-Integration

32


Demo

Kreditkarten-Nummer prüfen mit Scala

scala> isValid(4716347184862961)

true

33


Frege

• Haskell for the JVM

• rein funktionale Programmiersprache

• statisch typisiert mit Typinferenz und Typvariablen

• frei von Nebeneffekten

• Monaden zur Kapselung von imperativen Konstrukten

• Pattern Matching

• Typklassen

34


Demo

Kreditkarten-Nummer prüfen mit Frege (Haskell)

frege> isValid 4716347184862961

True

35


Algorithmus in Frege

36

isValid n =

(sumDigits (double2nd (toDigitsRev n))) % 10 == 0

Validierungs-

funktion

Teilbar

durch 10?

Ziffern

rückwärts

Verdoppeln

jede 2. Ziffer

Summe

der Ziffern

Kreditkarten-

nummer


Haskell/Frege

toDigits n = toDigits (n `div` 10) ++ [(n `mod` 10)]

toDigitsRev n = reverse (toDigits n)

double2nd = zipWith (*) (cycle [1, 2])

sumDigits xs = sum (concat (map toDigits xs))

isValid n =

mod (sumDigits (double2nd (toDigitsRev n))) 10 == 0

37

isValid n =

(sumDigits (double2nd (toDigitsRev n))) % 10 == 0


Keine veränderbaren Zustände

Seiteneffekt-frei

Referentielle Transparenz

First-Class-Citizens

Higher-Order Functions

Lambdas/Closures

Lazy Evaluation

Rekursion


Funktionen

39


Warum Funktionale Programmierung

• einfach zu testen, zu debuggen

• einfach zu verstehen durch einfache Abstraktionen und referentielle

Transparenz

• seiteneffektfrei, lässt sich leicht parallelisieren

• modularisierbar und einfach wieder zusammenführbar

• erhöht Code-Qualität

40


OO vs. Funktional

41


Ist Java 8 funktional?


"Funktional Programmieren" mit Java 8

• Lambdas: Funktionsliterale als First-Class-Citizens

• Higher-Order Functions

• Currying und Funktionskomposition

• Streams

• Erweiterungen Collections mit Default-Methoden

• (Rekursion)

43


Java 8: Currying und partielle Funktionsaufrufe

44

Currying: Konvertierung einer Funktion mit n Argumenten

in n Funktionen mit jeweils einem Argument.


Java 8: Funktionskomposition

45


Luhn-Algorithmus in Java 8 – Variante 1

46


Was fehlt Java 8 zur besseren funktionalen

Unterstützung?

• Erzwingen von Immutability

• persistente Datenstrukturen

• Vermeidung von Seiteneffekten

• referentielle Transparenz

• Lazy Evaluation

• funktionale Bibliotheksfunktionen

47


Immutable Klassen

• genau ein Zustand

– keine Prüfung von Invarianten und von Zustandsübergänge (API-Doc)

– abgeleitete Größen können in Cache gehalten werden

• Thread-safe

– keine Zustandsänderung

– keine Synchronisation

• gemeinsame Nutzung von Instanzen

– public Konstanten

– Instanzkontrolle durch statische Factories

– keine defensive Copies

• gemeinsame Nutzung innerer Zustände

– BigInteger#negate()

– String#subString()

48


Funktionale Erweiterungen für Java

49

Project Lombok


Project Lombok

• Compile-Time Metaprogrammierung

• Reducing Boilerplate Code durch Annotationen

• Generation des Immutable-Gerüsts mit @Value

• Lazy Evaluierung mit @Getter(lazy = true)

50


private, final,

keine Setter,

Argument-Konstruktor

equals/hashcode

Lazy-Evaluierung


FunctionalJava

• funktionale Programmierbibliothek für Java

• Lernplattform für funktionale Programmierung mit der gewohnten

Sprache

• unterstützt Java 6+ (mit Retro Lambda)

• Basis Datenstrukturen (Funktionen, partielle Funktionen, Unit, Void,

Option, Either, …

• Immutable Collections (Array, List, Stream, Set, Map, …

• Monaden, Zipper

52


Demo

Kreditkarten-Nummer prüfen mit Java 8 + FunctionalJava:

public static void main(String[] args) {

System.out.println(isValid("4716347184862961"));

}

54


Javaslang

• "Javaslang is a functional library for Java 8+ that provides persistent

data types and functional control structures."

• Persistent Data Structures

– LinkedList, Queue, Sorted Set, Stream

• Tuple

• Functions, CheckedFunctions

55


Javaslang: Tuple (bis Tuple8)

56


Javaslang: Partielle Funktionsaufrufe und

Komposition

57


Javaslang: Currying

58


Javaslang: Function Lift (Fangen von Exceptions)

59


Links

• Learn You a Haskell for Great Good!

– http://learnyouahaskell.com/chapters

• LYAH (Learn You a Haskell) adaptions for Frege

– https://github.com/Frege/frege/wiki/LYAH-adaptions-for-Frege

• Project Lombok

– https://projectlombok.org/

• Functional Java

– http://www.functionaljava.org/

• Javaslang

– http://www.javaslang.io/

60

http://learnyouahaskell.com/chapters

https://github.com/Frege/frege/wiki/LYAH-adaptions-for-Frege

https://projectlombok.org/

http://www.functionaljava.org/


Literaturhinweise

61

• Functional Programming in Java: Harnessing the Power Of Java 8 Lambda Expressions

– Venkat Subramaniam

– The Pragmatic Programmers, Erscheinungsdatum: Februar 2014

– ISBN: 978-1-93778-546-8

– Sprache: Englisch

• Mastering Lambdas– Maurice Naftalin

– Oracle Press

– Erscheinungsdatum: Oktober 2014

– ISBN: 0071829628



Literaturhinweise

62

• Learn You a Haskell for Great Good!: A Beginner's Guide

– Miran Lipovaca

– No Starch Press, Erscheinungsdatum: April 2011

– ISBN: 978-1593272838


• Real World Haskell

– Bryan O'Sullivan und John Goerzen

– O'Reilly, Erscheinungsdatum: 2010

– ISBN: 978-0596514983



Weinheimer Str. 68

68309 Mannheim

www.oio.de

[email protected]

? ?

??

?Fragen ?

63


Weinheimer Str. 68

68309 Mannheim

www.oio.de

[email protected]

Vielen Dank für Ihre

Aufmerksamkeit !

jvm functional language battle - oio-die java … › m › konf › vortraege ›...

Documents