Java 8: a New Beginning

Java 8
A New Beginning

Russel Winder
email: russel@winder.org.uk
xmpp: russel@winder.org.uk
twitter: @russel_winder
Web: http://www.russel.org.uk

Copyright © 2013 Russel Winder 1

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 any
later 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 Java
is now a legacy language?


No, it's an opportunity to stop
programming using 1970s techniques
and start using 1930s ones.


Alonzo Church
Stephen Kleene
J B Rosser
Alan 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.


What's (Quite) Interesting in Java 8?
● G1 garbage collector. ● Lambda expressions.
● Nashorn. ● Enhanced collections.
● JavaFX.


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 associated
collections enhancements.


Closures


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


A Function

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

Free variable.


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 this
since (almost) the beginning…


A closure can be realized as an instance of
a 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 = {i -> 5 * i}

final multiplyBy5 = {5 * it}

multiplyBy5(4)

multiplyBy5.call(4)


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

multiplyBy5(4)


How to do all this stuff in Java whilst
keeping backward compatibility?


Do not use anonymous classes.


We have method handles…


…and invokedynamic.


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

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

multiplyBy5.call(4)


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 happened
in Java since Java 1.4.2.


Because all computers are
now parallel computers.


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


We have to actually do object-oriented
and functional programming.


Instead of just saying we write code using
Java, C++, etc. and so must be
doing object-oriented programming.


From earlier…

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


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 style
approach and parallelism today
for Java with JDK6 or JDK7.


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


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

 1 1
=∫0 dx
4 1x 2


One Possible Algorithm
● Use quadrature to estimate the value of the integral
– which is the area under the curve.
4 n 1
= ∑i=1
n i−0.5 2
Embarrassingly 1 
parallel. n

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


Because addition is commutative and
associative, 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-oriented
and 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 8
A New Beginning

Russel Winder
email: russel@winder.org.uk
xmpp: russel@winder.org.uk
twitter: @russel_winder
Web: http://www.russel.org.uk/


Java 8: a New Beginning

Recommended

Recommended

More Related Content

Similar to Java 8: a New Beginning

Similar to Java 8: a New Beginning (10)

More from Russel Winder

More from Russel Winder (20)

Recently uploaded

Recently uploaded (20)

Java 8: a New Beginning