Java 8: a New Beginning

Copyright © 2013 Russel Winder 1

Java 8A New Beginning

Russel Winder

email: [email protected]: [email protected]

twitter: @russel_winderWeb: http://www.russel.org.uk

mailto:[email protected]


Aims, Goals and Objectives

● Investigate why Java 8 is the greatest revolution in Java since 1995.

● Investigate why some idioms from Java 0–7 lead to bad code in a post-Java 7 world.

● Show what some of the idioms of Java 8 and beyond are likely to be.


Structure

A Beginning

A Middle

An End


Interstitial Advertisement

?


A Beginning


Many people are still using Java 1.4.


They see no reason to move to anylater version of Java:

no real benefit, for too much pain.


Java 5 is a barrier too far for them.


The Java 7 Java 8 change→is an even more disruptive change.


This possibly means Javais now a legacy language?


No, it's an opportunity to stopprogramming using 1970s techniques

and start using 1930s ones.


Alonzo ChurchStephen Kleene

J B RosserAlan Turing


Another Beginning


What's New in Java 8

● Simon Ritter gave a talk about 55 things that are new in Java 8 at DevoxxUK 2013: http://www.devoxx.com/display/UK13/55+New+features+in+Java+SE+8

● The video will appear on Parleys once encoded.

http://www.devoxx.com/display/UK13/55+New+features+in+Java+SE+8


What's (Quite) Interesting in Java 8?

● G1 garbage collector.● Nashorn.● JavaFX.

● Lambda expressions.● Enhanced collections.


G1 garbage collector is now the standard:

No more PermGen.


Nashorn comes as standard:

Server-side JavaScript without Rhino.


JavaFX in the distribution and the classpath:

You probably want to use GroovyFX though.


Lambda expressions, and associatedcollections enhancements.


Closures


A closure is a function with an associated environment containing values for all the free

variables in the function.


Integer f(final Integer x) { return x * y ;}

Free variable.

A Function


A closure should be referentially transparent.

Whenever function f is evaluated on the same value,a say, then the same value is returned.

f(a) = b


Java has had things (sort of) like thissince (almost) the beginning…


A closure can be realized as an instance ofa class with a single method and

single assignment fields.


public class ClosureClass { private final Integer multiplier; public ClosureClass(final Integer m) { multiplier = m; } public Integer call(final Integer i) { return multiplier * i; }}

No free variables in call.


final ClosureClass multiplyBy5 = new ClosureClass(5);

multiplyBy5.call(4)


Alternatively, using anonymous classes…


public interface ClosureInterface<T> { T call(T t);}

final ClosureInterface<Integer> multiplyBy5 = new ClosureInterface<Integer>() { public Integer call(final Integer i) { return 5 * i; } };

multiplyBy5.call(4)


Java has accreted a reputation for being verbose.


Unlike Groovy, Scala, Kotlin, Ceylon, etc.


Or Python, D, C++ (!), etc.


final multiplyBy5 = {5 * it}

multiplyBy5(4)

multiplyBy5.call(4)

final multiplyBy5 = {i -> 5 * i}


def multiplyBy5(i: Int): Int = 5 * i

multiplyBy5(4)


How to do all this stuff in Java whilstkeeping backward compatibility?



Do not use anonymous classes.



We have method handles…


…and invokedynamic.


final ClosureInterface<Integer> multiplyBy5 = i -> 5 * i;

multiplyBy5.call(4)

public interface ClosureInterface<T> { T call(T t);}


Lambda Expressions

● Functional interfaces – previously known as single abstract method (SAM) types.

● Call site type inference.● No classes: JVM byte code synthesis, method

handles and invokedynamic.


Nothing much revolutionary here,just a bit of syntactic sugar…


…true (sort of), but that isn't all there is…


A Middle


It all about where the iteration is.


Explicit iteration

vs.

Implicit iteration


Work with a (trivial) example:


Calculate the sum of the squares of the numbers between 0 and 100 that are

divisible by 7.


int sum = 0;for (int i = 0; i < 100; ++i) { if (i % 7 == 0) { sum += i * i; }}


(for (i <- 0 until 100; if i % 7 == 0) yield i * i).sum


sum({for (i in 0..100) if (i % 7 == 0) i * i})


sum(i * i for i in range(100) if i % 7 == 0)


(0 until 100).filter(i => i %7 == 0).map(i => i * i).sum


0.rangeTo(100).iterator().filter{i -> i % 7 == 0}.map{i -> i * i}.reduce{a, b -> a + b}


sum((0..100).filter((Integer i) => i % 7 == 0).map((Integer i) => i * i))


(0..100).findAll{i -> i % 7 == 0}.collect{i -> i * i}.sum()


(0..100).findAll{it % 7 == 0}.collect{it * it}.sum()


Streams.intRange(0, 100).filter(i -> i % 7 == 0).map(i -> i * i).sum()


Higher Order Functions


Functions that take functions as parameters and/or return functions as result.


Some may be thinking:

Why do I give a f###?


After all nothing good has happenedin Java since Java 1.4.2.



Because all computers arenow parallel computers.



We have to move to an attitude where we assume our software is not uniprocessor.


We have to actually do object-orientedand functional programming.


Instead of just saying we write code usingJava, C++, etc. and so must be

doing object-oriented programming.


Streams.intRange(0, 100).filter(i -> i % 7 == 0).map(i -> i * i).sum()

From earlier…


Streams.intRange(0, 100).parallel().filter(i -> i % 7 == 0).map(i -> i * i).sum()


Data parallelism with a single method call.


GParsPool.withPool { (0..100).findAllParallel{it % 7 == 0}.collectParallel{it * it}.sum()}


GParsPool.withPool { (0..100).parallel.filter{it % 7 == 0}.map{it * it}.sum()}


def value = (0..100)ParallelEnhancer.enhanceInstance(value)value = value.parallel.filter{it % 7 == 0}.map{it * it}.sum()


def value = (0..100)ParallelEnhancer.enhanceInstance(value)value = value.findAllParallel{it % 7 == 0}.collectParallel{it * it}.sum()


GPars and Groovy give you Java 8 styleapproach and parallelism today

for Java with JDK6 or JDK7.


Guava, TotallyLazy, and FunctionalJava can be usedtoday to practice the functional approach using Java.


Using Scala is an option fordoing functional programming*.

*And just ignore Java altogether.


(0 until 100).par.filter(i => i %7 == 0).map(i => i * i).sum


Or just install the JDK8 Lambda release.




What is the Value of ?

Easy, it's known exactly.

It's .

Obviously.


It's simples Александр Орлов 2009


Approximating

● What is it's value represented as a floating point number?● We can only obtain an approximation.● A plethora of possible algorithms to choose from, a

popular one is to employ the following integral equation.

4=∫0

1 1

1x2dx


One Possible Algorithm

● Use quadrature to estimate the value of the integral – which is the area under the curve.

=4n∑i=1

n 1

1i−0.5n

2

With n = 3 not much to do, but potentially lots of error. Use n = 107 or n = 109?

Embarrassingly parallel.


Because addition is commutative andassociative, expression can be

decomposed into sums of partial sums.


a + b + c + d + e + f

=

( a + b ) + ( c + d ) + ( e + f )


Scatter – Gather

map reduce


Code!


An End


Java is about to get the functional programming approach.


Scala, Groovy, Kotlin, Ceylon,Python, D, C++, etc.

already have object-orientedand functional*.

* Well Scala has.


It's all about how your data evolves.

It's not about the flow of control.


Closures the next “big thing” in Java?


Yes*.

*But will everyone ignore it?


No.


It is not the lambda expressions in Java 8 that is the disruptive revolution.

It's the change to the Java library that is.

It's all about those default methods*.

* Aka defender methods, virtual extension methods.


Interstitial Advertisement

?


The End


Java 8A New Beginning

Russel Winder

email: [email protected]: [email protected]

twitter: @russel_winderWeb: http://www.russel.org.uk/

mailto:[email protected]

Technology

Java 8: a New Beginning