RevolutieFunctioneel Programmeren

Java 8Johan Blok en Bart Barnard

����������

Van$java$8$alleen$functioneel$programmeren

\begin{programma}09.00 - 09.30：Inleiding09.30 - 10.00：sorteer- en filteropdrachten 10.00 - 10.30：terugkoppeling en theorie10.30 - 11.30：uitgebreidere opdrachten 11.30 - 12.00：gevolgen vakgebied en onderwijs\end{programma}

Inleiding

Het probleem

Intel Xeon processor 5600. (http://cdn.phys.org/newman/gfx/news/hires/Westmere-EP-Die.jpg)

http://www.cse.wustl.edu/~jain/cse567-11/ftp/multcore/

Java$richt$zich$meer$op$onderhoudbare$en$leesbare$code$dan$efficiënt$gebruik$van$clock<cycles$Programmacode$met$locks:$complex$en$foutgevoelig$Veel$gebruik$van$java.util.concurrent$Performance$gaat$zelfs$omlaag$naarmate$er$meer$cores$op$de$processor$komen

Imperatief versus FunctioneelImperatief:$reeks$instructies$die$toestand$veranderen

sum$=$0$$$for$$i=1$to$count(x)$ $$$$sum$=$sum$+$x[i]$$ average$=$sum$/$count(x)

Functioneel:$evaluatie$van$(wiskundige)$functies$

$ avg(x):$sum(x,$count(x))$/$count(x)$$ sum(x,$i):$$ $ if$(i>0)$$ $ $ sum(x,$i$–$1)$+$x[i]$$ $ else$0

Theorie: Lambda Calculus

✓ λ<calculus:$Formeel$systeem$ontwikkeld$rond$1930$door$Alonzo$Church$

✓ Hilbert’s$Entscheidungsproblem:$algoritme$dat$bepaalt$of$een$propositie$bewijsbaar$is$

✓ Lambda$Calculus$als$model$voor$berekenbaarheid$✓ 1980’s$typed$lambda$calculus:$constructive$mathematics

✓G.W.$Leibniz$(1646<1716)$✓Binair$getalstelsel$✓1671:$mechanische$rekenmachine$

✓Universele$denkmachine

Voordelen lambda expressies

✓Meer$directe$vertaling$van$de$bedrijfslogica$in$programmacode;$de$nadruk$op$functionaliteit$zorgt$voor$een$betere$flow$die$duidelijker$maakt$wat$er$moet$gebeuren$in$plaats$van$hoe$het$gebeurt.$

✓ Niet$meer$noodzakelijk$om$om$de$haverklap$objecten$te$creëeren$en$heen$en$weer$te$sturen.$$

$ Functies$gebruiken$als$parameters$$ Creëren$van$functies$in$andere$functies$$ Functies$als$return<type$✓ Veel$boilerplate$code$kan$worden$verwijderd:$duidelijkere$er$consistentere$code$

✓ Code$als$data:$objecten$kunnen$worden$gezien$als$data<containers

✓ Lambda$Expression$kan$anonieme$klasse$vervangen$✓ Collections:$filtering$✓ Predicates$✓Map$and$Reduce$✓ Type$inference

Java 8 overzicht http://javarevisited.blogspot.nl/2014/02/10<example<of<lambda<expressions<in<java8.html$

Java 8 Lambda Expression Syntax

button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { System.out.println("button clicked"); }});

new ActionListener() { public void actionPerformed(ActionEvent e) { System.out.println("button clicked"); }}

Anonymous$inner$class$$ ActionListener$heeft$één$methode:$actionPerformed()$$ Code$as$data:$we$sturen$een$object$mee$aan$de$methode$$ Te$veel$boilerplate$code$$ Is$onduidelijk$wat$de$programmeur$hiermee$bedoelt

button.addActionListener(event -> System.out.println("button clicked”));

event$is$de$parameter

->$scheidt$de$parameters$van$de$body$van$de$lambda$expressie

body$van$de$expressie;$in$plaats$van$een$object$geven$we$het$een$stuk$code$mee

Type4inference4javac$bepaalt$het$type$van$event$aan$de$hand$van$de$signature$van$addActionListener()

Java 8 Lambda Expression Syntax

Practicum 1: sorteren en filteren @Override public List<Student> imperative() { List<Student> list = data.getStudents(); list.sort(new Comparator<Student>() { public int compare(Student student1, Student student2) { return student1.getName().compareTo(student2.getName()); } }); return list; }

@Override public List<Student> functional() { List<Student> students = data.getStudents();! // TODO functional implementaton of sort by name! return students; }

Streams

External Iteration

Collection$CodeApplication$code

IterationhasNext()

hasNext

next()

next

Naar Warburton, 2014, p.18

int count = 0;Iterator<Artist> iterator = artists.iterator(); while(iterator.hasNext()) { Artist artist = iterator.next(); if (artist.isFrom("London")) { count++; }}

External Iteration

Internal Iteration

Collection$CodeApplication$code

Iteration

Naar Warburton, 2014, p.19

Build operation

Result

long count = allArtists.stream() .filter(artist -> artist.isFrom("London")) .count();

Internal Iteration

Source$Collection$/$List.stream()$Collection$/$List.parallelstream()$!

Intermediate$Operations$Filter4Map$/$Flatmap$Sorted$

!One$terminal$operation$Foreach$Collect4Reduce

Streams in Java 8

Operations in cursief worden even kort behandeld. Zie voor totaalbeeld Warburton, 2014, pp. 17-41.

Niet$te$verwarren$met$Input/outputstreams

Streams: Collect

List<String> foo = Stream.of("a", "b", "c") .collect(Collectors.toList());

collect(toList()) is$an$eager$operation$that$generates$a$list$from$the$values$in$a$Stream.

Streams: Filter

List<String> startsWithNr = Stream.of("a", "1abc", "abc1") .filter(value -> isDigit(value.charAt(0))) .collect(toList());

Any$time$you’re$looping$over$some$data$and$checking$each$element,$you$might$want$to$think$about$using$the$new$filter method$on$Stream.$

Streams: Map

List<String> foo = Stream.of("a", "b", "hello") .map(string -> string.toUpperCase()) .collect(toList());

If$you’ve$got$a$function$that$converts$a$value$of$one$type$into$another,$map$lets$you$apply$this$function$to$a$stream$of$values,$producing$another$stream$of$the$new$values.

Streams: ReduceIf$you’ve$got$a$function$that$converts$a$value$of$one$type$into$another,$map$lets$you$apply$this$function$to$a$stream$of$values,$producing$another$stream$of$the$new$values.

int count = IntStream.range(1,4) .reduce(0, (acc, element) -> acc + element);

1 2 3 4

1 6 103

initial result

acc

element

Predicates and type inference

public static Predicate<Employee> isAdultMale() {    return p -> p.getAge() > 21 && p.getGender().equalsIgnoreCase("M");}

Predicates

public interface Predicate<T>{ boolean test(T t);}

Type inference

Map<String, Integer> foo = new HashMap<String, Integer>();Map<String, Integer> bar = new HashMap<>();

diamond$notation

old$($java$<$1.8)$method

useHashmap(new HashMap<>());...private void useHashmap(Map<String, String> values);

ook$in$dit$voorbeeld$is$javac$slim$genoeg$om$de$generics$van$de$nieuwe$HashMap$te$achterhalen.

Practicum 2: uitgebreidere voorbeelden

M

D | H

B | C F | G J | K | L

Q | T | X

N | P R | S V | W Y | Z

A B-tree whose keys are the consonants of the alphabet. An internal node x containing n[x] keys has n[x]+1 children. Alle leaves are at the same depths in the tree. The purple nodes are

examined in a search for the letter R.

Cormen et al.2005, p.435

Discussie: Functioneel Programmeren in het Vakgebied van de ICT

Krachtiger$expressies$Verkort$ontwikkeltijd$Minder$code,$minder$bugs$Unit$tests$Verwerking$datastromen$(big$data)$Performance?$Hoe$snel$in$bedrijfsleven$opgenomen?$In$het$nieuwe$curriculum?

LiteratuurCormen,$T.H.,$C.E.$Leiserson,$R.L.$Riverst,$C.$Stein,$2005,$Introduction4to4Algorithms.$Cambridge,$Mass:$MIT$Press$(second$edition).$!Hofstadter,$D.,$1980,$Gödel,4Escher,4Bach:4an4Eternal4Golden4Braid.$Pinguin.$!Michaelson,$G,$2011,$An4Introduction4to4Functional4Programming44Through4Lambda4Calculus,$NY:$Dover$Publications.$!Nagel,$E.$and$J.R.$Newman,$2001,$Gödel’s4Proof.$NYU$Press$!Warburton,$R,$2014,$Java484Lambdas.4Functional4Programming4for4the4Masses.$Sebastopol,$CA:$O’Reilly.