Java 21st Century Thinking

© 2015 INTERNATIONAL BUSINESS MACHINES CORPORATION
@spoole167
Java in the 21 Century: Are
you thinking far enough
ahead?
June 2018

@spoole167
About me
Steve Poole
IBM Lead Engineer / Developer advocate
Making Java Real Since Version 0.9
Open Source Advocate
DevOps Practitioner (whatever that means!)
Driving Change

@spoole167
This talk may seem to be about possible futures
for Java and the JVM

This talk is actually about why we have to think differently
about solving the problems of the future
Cloud Data Machine And
Analytics Learning Beyond
?

@spoole167
So really this talk is about your future.

@spoole167
Whatchya thinking
about now?

@spoole167
Thinking Positively about Java?
Still learning about features in Java 8?
Looking at Java 10 or going to Java 11?
Trying to understand the new feature release process?
What does “LTS” mean for Java?
Exploring “Java Platform Module System”?
Trying out Jshell?
Figuring out jlink?

@spoole167It’s easy to focus on now – it’s real and concrete

@spoole167
What about a wider view?
What does it mean for EE now Oracle have donated it to Eclipse?
Why have IBM open sourced their JVM and Application Servers?
What should you be doing with MicroProfile?
Is Spring the right answer?
Should I be learning other programming languages?
Where does Java fit?
Should I use Java at all?

@spoole167Let’s think about what drives us

@spoole167
Economics
Faster, cheaper, easier, better …

@spoole167
For many years Java innovation focused on
performance

@spoole167
Maximize the
opportunities
offered by
Moore’s Law
Forever… https://commons.wikimedia.org/wiki/File:Moores_law_(1970-2011).PNG

@spoole167
We built a walled garden and made it the best
place to run enterprise applications of a certain
kind
https://www.flickr.com/photos/40139809@N00/

@spoole167
Vendor competition and collaboration delivered
• The fastest runtime environments
• The most scalable runtime environments
• The best garbage collectors
• The greatest dynamically re-optimizing compilers
The best environment for long running Java only applications

@spoole167
But the fact is that Java’s innovation is mostly
driven by factors outside our control

@spoole167
Moore’s Law
stalled.
https://commons.wikimedia.org/wiki/File:Moores_law_(1970-2011).PNG
Now it’s about
multi-core
processors
And multi-processor
machines

And don’t forget VMs can scale from the very
smallest to the very largest devices
Tiny
winy
Ginormous
humongous

From the smallest
On the
smart card
Next to the processor (separate IC)
In the processor

@spoole167
Java Card JVM
• Becoming a major IOT edge device type
• Has security physically built in
• Low Power
• Small cost
Writing code in Java
means less chance of
code problems.
no hand crafting
assembler for small
devices
Want to debug a Java
Card in the field?
Want to patch 6
million cards?
Java offers a superior
developer experience

To the very biggest
Slido.io #K100

@spoole167
And then we finally achieved

@spoole167
And then we finally achieved
Compute on Tap

@spoole167
Aka “Cloud”
Faster, cheaper, easier, better …

@spoole167
Economics rules

@spoole167
New rules of the game.
Compute == money

@spoole167
Compute == money
$ == GB/hr

@spoole167
Compute == money
$ == GB/hr
-Xmx: $100

@spoole167
Cloud isn’t going away: in fact its coming to you

@spoole167
Cloud is coming to a data center near you
https://github.com/IBM/deploy-ibm-cloud-private
git clone
vagrant up

@spoole167

@spoole167
New economics requires Java to break out of the
walled garden.
And since we don’t know all the answers – we
need to be able to experiment and innovate faster
https://www.flickr.com/photos/40139809@N00/

@spoole167
We need to go from Very long running, efficient,
monolithic applications
Willing to trade startup time for
throughput
in it for the long haul

@spoole167
Short lived, container based, micro
service oriented, instant-on, always
available, cross server, polyglot
services
Now we also need

@spoole167
0
0.2
0.4
0.6
0.8
1
1.2
1.4
0 1 2 3 4 5 6 7 8 9 101112131415161718
Throughput
Throughput
0
0.5
1
1.5
0 1 2 3 4 5 6
Throughput
Throughput
0
0.5
1
1.5
0 1 2 3 4 5 6
Throughput
Throughput
0
0.5
1
1.5
0 1 2 3 4 5 6
Throughput
Throughput
0
0.5
1
1.5
0 1 2 3 4 5 6
Throughput
Throughput
We need all of these models

Time
demand
Traditional profile
@spoole167

Demand
time
How does your application respond to demand?
@spoole167

Demand
time
One big server running all the time?
@spoole167

Demand
time
One big server running all the time?Look at all that wasted money!
@spoole167

Demand
Smaller compute units are better
@spoole167

Demand
time
Smaller compute units are better
@spoole167

Time
Throughput
Traditional profile
@spoole167

Time
Throughput
Lag Over-Peek usage
Doesn’t fit new model
Costs $ Costs
more $
@spoole167

Time
Throughput
More like this please
@spoole167

@spoole167
And we need it ..

@spoole167
Is to innovate faster – or loose to the competition
The immediate challenge for Java and the JVM

predictable
consistent cadence
easier migration increased innovation
Now you can see why our ecosystem is
repositioning for a faster pace

Every development
team has both
common and unique
problems to solve.
Open source is key
to fast innovation
and adoption
OpenJDK
Eclipse OpenJ9
Open Liberty
Eclipse MicroProfile
Java EE
IBM Cloud
Docker
Kubernetes
Allowing everyone to participate
(and offering multiple starting points)

lambda
streams
modules
reactive streams
panama
valhalla
penrose
amber
Giving Java innovation a faster cadence

Tomcat
Glassfish
Open Liberty
…
OpenJDK + Hotspot
OpenJDK + OpenJ9
J2EE
Micro-profile
And a variety of implementations to
choose from

Container
awareness
Fast native code
interop
Re-optimised JITs
Re-tuned GC’s
AOT
Value Objects
Generating New JVM
technologies
Jit As A Service
<your idea here>

Time
Real data
OpenJDK 9
with Hotspot
@spoole167

Time
Real data
OpenJDK 9
with Hotspot
OpenJDK 9
with OpenJ9
@spoole167

Time
Real data
OpenJDK 9
with Hotspot
OpenJDK 9
with OpenJ9
OpenJDK 9
with OpenJ9
+ AOT
@spoole167

https://adoptopenjdk.net/?variant=openjdk8-openj9@spoole167 Slido.io #K100

Don’t just
take my word
for it
@spoole167
adoptopenjdk.net

IBM donated J9 to Eclipse
because we believe it’s the best
way to move Java forward
• It offers a new place to start
• As the future emerges we can see
that Java needs to handle new
technologies, new hardware.
• Java must adapt or die
• We can’t do it on our own. We have
to do it together
@spoole167

Cloud. So we know what to do.
We know why we need to do it
Cloud makes you think differently
but mostly about footprint, resilience
and scaling
Modularity, Lambdas
J2EE going to Eclipse
That’s not really a big change. …

@spoole167
The future starts here…
?
Data Analytics Machine Learning

@spoole167
But it’s still driven by economics
$

The new problems we face are not ones humans can easily
internalize, visualize or even compute
These drivers are changing the face of computing as we
know it. And it’s barely started
• The reality of data analytics
• The promise of AI

@spoole167
The common challenges
Effective optimization
Visualisation of complex patterns
Extracting meaning from enormous amounts of data.
All things human beings are poor at doing
And so are current computer architectures

@spoole167
Machine Learning etc
• Helps us find reasonable answers to questions.
• No guarantees on it being the best answer.
Organize a group of people at a table.
So that you get the ‘best’ conversation
You decide what
‘best’ means

@spoole167
Two or three people - easy
What about 10? - how many combinations to consider?

@spoole167
What about 10? - how many combinations to consider?
Going to need
some help here3628800

@spoole167
What about 150?

@spoole167
571338395644585459047893286526105400318
955357860112641825483758331798291248453
983931265744886753111453771078787468542
041626662501986845044663559491959220665
749425920957357789293253572904449624724
054167907221184454371222696755200000000
00000000000000000000000000000
Going to need a lot of help
here

@spoole167
It’s this level of scale , complexity and uncertainly
we now have to deal with…

Imagine creating systems that can
Tailor responses to the personalities of your
customers without meeting a single one of them.
improve themselves
over time, learning
from and adapting to
the world around
them.
identify their own inefficiencies-and address them
automatically-in real time.
Uncover patterns, resources, trends and other
competitive advantages invisible to competitors and
their information systems.

@spoole167
Machine Learning works because (mostly)
humans design and teach it
A ML solution can be a significant investment.
It it also a significant business opportunity
That has implications…

@spoole167
1 Lots of “BlackBox” services and APIs that allow the owner to
keep their “secret source” secret
2 Investment in the solution is sticky - it’s hard to create so
moving to a new runtime is less likely
3 Developers will spend more time consuming services into
their own applications and less on bespoke solutions
4 Developers will be creating new forms of applications around
data analytics and machine learning

@spoole167
Which means
1 JVMs need to be able to offer good machine learning and data
analysis capabilities
2 Java Developers will spend more time in transforming data and
thinking about problems in data terms
3 All Developers will be learning new technologies and tools

@spoole167
Lets try to make this more real (time for some
code)

c c e n t u r y b j
m k h l y t n e w t
t c i g a f n n o y
f d h t u s i a o v
i a w a h o h r v e
d i r n v e n y s i
g a p t u a o e x t
q f e a m o j k b o
y i c h r b y p n a
t t n v a e i z h i
Java
In
The
Twenty
First
Century
Are
you
thinking
far
enough
ahead
IBM
Find
which
one of
these
words is
missing

@spoole167
How do you solve this problem?
For each String in the list.
Visit each element in the grid
Check if the string matches in any of the eight directions.
Record if found
Report which of the strings was not found

r c e n t u r y l m
y q h m y t n e w t
j x v g f a s r h h
f u r t u k h o u q
y a m a h o c e k n
s b r p v e n c a t
a y g e u a j e a d
h z g a m o j i p b
h z a e r b y a n n
d m t f g e i v e i
Java
In
The
Twenty
First
Century
Are
you
thinking
far
enough
ahead
IBM

for(y=0;y<side && dir==null;y++) {
for(x=0;x<side && dir==null;x++) {
char c=p.charAt(x, y);
if(c==w.charAt(0)) {
int l=0,dy=y,dx=x;
while(l<w.length() && dy>0 && p.charAt(x,dy)==w.charAt(l)) { l++;dy--; }
if(l==w.length()) { dir="N";break;}
l=0;dx=x;
while(l<w.length() && dx<side && p.charAt(dx,y)==w.charAt(l)) { l++;dx++; }
if(l==w.length()) { dir="E";break;}
l=0;dx=x;dy=y;
while(l<w.length() && dy<side && p.charAt(x,dy)==w.charAt(l)) { l++;dy++; }
if(l==w.length()) { dir="S";break;}
l=0;dx=x;
while(l<w.length() && dx>0 && p.charAt(dx,y)==w.charAt(l)) { l++;dx--; }
if(l==w.length()) { dir="W";break;}
l=0;dx=x;dy=y;
while(l<w.length() && dy<side && dx<side && p.charAt(dx,dy)==w.charAt(l)) {
l++; dy++;dx++; }
if(l==w.length()) { dir="SE";break;}
l=0;dx=x;dy=y;
while(l<w.length() && dy<side && dx>0 && p.charAt(dx,dy)==w.charAt(l)) {
l++;dy++;dx--; }
if(l==w.length()) { dir="SW";break;}

Certainly inefficient use of a CPU
0
10
20
30
40
50
60
70
80
90
100
Java
CPU %
CPU1 CPU2 CPU3 CPU4
BRUTE FORCE?

IntStream is=IntStream.range(0, side*side);
is.parallel().forEach( i -> {
int x=i % side;
int y=i / side;
<do horrible code checking here..
});
}

Good use of a CPU
What about that code?
0
10
20
30
40
50
60
70
80
90
100
Java
CPU %
CPU1 CPU2 CPU3 CPU4
while( l<w.length() && dy>0
&&
p.charAt(x,dy)==w.charAt(l)) {
l++;dy--; }
BETTER?

c c e n t u r y b j
m k h l y t n e w t
t c i g a f n n o y
f d h t u s i a o v
i a w a h o h r v e
d i r n v e n y s i
g a p t u a o e x t
q f e a m o j k b o
y i c h r b y p n a
t t n v a e i z h i
When searching for
“java” we have to
make sure we don’t
run off the edge
while( l<w.length()
&& dy>0 &&
p.charAt(x,dy)==w.
charAt(l)) { l++;dy--
; }

c c e n t u r y b j
m k h l y t n e w t
t c i g a f n n o y
f d h t u s i a o v
i a w a h o h r v e
d i r n v e n y s i
g a p t u a o e x t
q f e a m o j k b o
y i c h r b y p n a
t t n v a e i z h i
Changing the data
reduces our code
Adding a empty
boarder the width
of the largest word
Means we’ll never run
off the end of the array

We can do better. private static int[][] offsets= {
{ 0 , -1 } , // N
{ 1 , -1 } , // NE
{ 1 , 0 } , // E
{ 1 , 1 } , // SE
{ 0 , 1 } , // S
{ -1 , 1 } , // SW
{ -1 , 0 } , // W
{ -1 , -1 } // NW
};
Turning the direction
problem into a data
driven one
+1-1
-1
+1

IntStream is=IntStream.range(0, (side+buffer)*(side+buffer)*8);
is.parallel().forEach( i -> {
int offsets[]=directions[i % 8];
int r = i / 8;
int x = i % r;
int y = i / r;
// loop through word matching each character
for(int i=0;i<word.length;i++) {
. . .
// move to next char in required direction by simply:
x+= offsets[0];
y+= offsets[1];
}
...

o n c i o s u c d q d v p l a a n u s t c z p a a s h x o o g t r g g f l w v d n s j z o e p e e x
i e h f q u o q p r d m r u r w e p a x a a g k m e z t u u k u h r f w f w b z j n w y r s v t m o
w g j k r g u q h x l i j f f n l y f z r z t r p x a h c n h a s c v r y m w m a d o g g z u y g k
c c v s k l m m v t p v e b z c g b i m c r z o b i r s z o s g y e l f l k q v t v r v w d v i i v
w s g x b w u l y p q e r a t e l t e j u o f a k m i q x z p h b h h l h a j k d u n j y b z z e g
o u n a l o s r m b k f j h z f m e l a u j k w o m o g i v s v c l c i u r o s j b e r o z m z l q
r x y t a k q h u t a y v m b a v z s c a k e v m t c v e b s h c b t i j k t m n c o x o c w z n y
s d a y f h n q g b i o z w s j n o j a o o n y q d b l s q f r x n h g z j u v s w q e f q t e d g
f y u i q v k o q c t o h e t o d w q n f f m o s c t v h r e n o y o g f h j w u v w u n u b a s k
z u y u f r h z h g p j g r i q m l k p e j z g h k w r g k v k k w n w x g v p l g e v c o c e j z
v n f m l b k o m q g t y z d n t s e r i i e b n w w b l q x v s i l q a e p e h r j l r e n z m l
m o n w q j s f r g k s e s k o i j d z k y p t s u d p c f e t p f g t t l s h d x f r z p c c n v
o e u a m w u b i z t b k i b o p l s u e p j z w t j x f s s v r b h j c v h m k d k j t l o z b m
x y i m m j l d c k z f k v b q r c l t q e y n e o x f z m w b d w r b g h r j b u f u g z a m c n
l j l b q q o n h n a f k h s r w p l h i m d l u s i s u l t i o g h v q u k n m h z u z u v l d u
q x y m n u m o o j o u i k i d k l w h z v t o g p u d h s n f u i m j q x m x s y g l k k p p l x
j s s e p a r y t o e x t i d b u s l n l y y t i p g d q p z e d z s j k i p a y i n x i l s y y v
y f d o h n j m n l p g m p a n q p b s u l y d a e j m x q b a f a t f q p r z t t w q n s o f e q
g k d s b j a j g v m r n j w k n c v i r i j t z a r a q r e c l t i q r v r t o a t e u t w s h w
d c x r g m r h k c n y r t t s a i t i y c n s b l f s v n v q z u f c b c g o t b w m k f e p x q
q m y x e x p p c r b v z n y b e p l h n k w i z m u h g a f m s u q m b f n j p s y r n g r r u r
v m s a a f e e p c e m k i k t n c c a i x q e z p i k c c i c h b c k l o m z y e j y x u a y u s
j q k z t o a j g z s q h p w i g f k k o n z m a g k y q u k w h e t a t y v h d q h p q u t m p s
r w x t l f g l k t h b k t j d d u x u w c k u o w j l y d l f i j h k v x x n t g g w r y n g n k
k e m g h v w v j p i p j e h g u u t p a x g i a e l m o h r h a u b d x s a t m y v l e v l n m f
j y c n d w g y i z e t o b e e b x c b z e i g n p q u i u f j r h p z o b b d k f c a r t k y q k
o k g k l l f b g b i z x j n n q h k k l w c q s g m o x y q f r m e f n w j f q h p p c z l y b k
f w p e e i d c m w m r k f a q o f k a i b y a l s j u z m s j z v c q x g m p k m j a o k k n l g
q o y r o p s w z z o v d x u k b u m y l e n x q k k l j r s f f n i k v i c s r e x j q c j a t c
c v l k l h r h k c d p l l j e b w g k t y m z d z k x n j p a q e i k f x x y l z m q h a h h y t
w l t r v c e i y w f f h j j l d w r h h e r f g j h z n b x m c l c i d l j o r b m g n j p c v b
y m d p i p i b z r c z p k p b l o q p f w p n e o d n l g v i h a p t h t f i i z f r u h v q d x
q u l e n a s k q a u a h f e n i v o i i s e k h r y n i u q g y z l o x i h j u p h a r o l s o l
Best?
This is ok when you have a “small” amount of data.
What happens when the word grid is big:
Billions of characters?
Millions of words to find?
Multidimensional?
Or the word is very long (making the buffer too expensive)?

a e k j c b a o a j
e j a x l o n d
o
d
n
v n a v a a j v i o
i c
m
e
i e t u p a a
t d a t a j a j k l
i t w i q a y a m h
n u e n x v d v g a
g o d g t f f a u i
o a s o g a g t v c
c i a c h j a i b m
PARTITIONING: Executor
node
Executor
node
Executor
node
Executor
nodeHow do you deal with words
split across the boundaries?

a e k j c b a o a j
e j a x l o n d
o
d
n
v n a v a a j v i o
i c
m
e
i e t u p a a
t d a t a j a j k l
i t w i q a y a m h
n u e n x v d v g a
g o d g t f f a u i
o a s o g a g t v c
c i a c h j a i b m
node
Executor
node
Executor
node
Executor
node
Hint: split words into small 3x3
tiles. Find tiles (map) join
together (reduce)

a e k j c b a o a j
e j a x l o n d
o
d
n
v n a v a a j v i o
i c
m
e
i e t u p a a
t d a t a j a j k l
i t w i q a y a m h
n u e n x v d v g a
g o d g t f f a u i
o a s o g a g t v c
c i a c h j a i b m
node
Executor
node
Executor
node
Executor
node
CPU

a e k j c b a o a j
e j a x l o n d
o
d
n
v n a v a a j v i o
i c
m
e
i e t u p a a
t d a t a j a j k l
i t w i q a y a m h
n u e n x v d v g a
g o d g t f f a u i
o a s o g a g t v c
c i a c h j a i b m
node
Executor
node
Executor
node
Executor
node
CPU
GPU

a e k j c b a o a j
e j a x l o n d
o
d
n
v n a v a a j v i o
i c
m
e
i e t u p a a
t d a t a j a j k l
i t w i q a y a m h
n u e n x v d v g a
g o d g t f f a u i
o a s o g a g t v c
c i a c h j a i b m
node
Executor
node
Executor
node
Executor
node
CPU
GPU
FPGA
ASIC

GPU’s don’t work like CPU’s
They want their data in different forms
They behave differently
You’ll have to think differently too

@spoole167
publicclassCardTrick{
enumSuit{ hearts,clubs,diamonds,spades}
enumValue{ ace,two,three,four,five,six,seven,eight,nine,ten,jack,queen,king}
publicint score(Suits , Value v) {
int points=100;
if(s==Suit.hearts|| s==Suit.diamonds){
switch(v){
casefive : points=100;break;
casesix: points=250;break;
casejack: points=400;break;
casequeen: points=1000;break;
}
}
switch(s){
casehearts: points*=10;break;
caseclubs: points*=20;break;
casediamonds: points*=50;break;
casespades:points*=5;break;
}
returnpoints;
} }

@spoole167
publicclassCardTrick{
enumSuit{ hearts,clubs,diamonds,spades}
enumValue{ ace,two,three,four,five,six,seven,eight,nine,ten,jack,queen,king}
publicint score(Suits , Value v) {
int points=100;
if(s==Suit.hearts|| s==Suit.diamonds){
switch(v){
casefive : points=50;break;
}
}
switch(s){
caseclubs: points*=20;break;
casediamonds: points*=10;break;
}
returnpoints;
} }
1H 5D QS
1000 500 5000

@spoole167
intpoints=100;
if(s==Suit.hearts||s==Suit.diamonds){
switch(v) {
casefive: points=50;break;
casequeen : points=1000;break;
}
}
switch(s) {
caseclubs:points*=20;break;
casediamonds:points*=10;break;
}

@spoole167
intpoints=100;
if(s==Suit.hearts || s==Suit.diamonds) {
switch(v) {
casesix : points=250;break;
}
}
switch(s) {
casehearts :points*=10;break;
caseclubs :points*=20;break;
casediamonds :points*=10;break;
casespades :points*=5;break;
}
intpoints=100;
switch(v) {
}
}
switch(s) {
}
intpoints=100;
switch(v) {
}
}
switch(s) {
}
In standard CPU architectures – every thread has its
own program counter. You have to synchronize
threads to get them to work together

@spoole167
intpoints=100;
switch(v) {
}
}
switch(s) {
}
intpoints=100;
switch(v) {
}
}
switch(s) {
}
intpoints=100;
switch(v) {
}
}
switch(s) {
}
With GPU’s there is only one program counter.
Threads are implicitly synchronized – they are all in
lock step…

@spoole167
publicclassGPUCardTrick{
intpoint_table[][]=newint[][]{… }
enum Suit{hearts,clubs,diamonds,spades}
enum Value{ace,two,three,four,five,six,seven,eight,nine,ten,jack,queen,king}
publicintscore(Suit s, Valuev) {
returnpoint_table[s.ordinal()][v.ordinal()];
}

@spoole167
Using a GPU without understanding how they
work is like driving your car in reverse all the time

IBM + NVIDIA
Improving Java application
performance with GPU
exploitation is available in IBM
SDK for Java 8 and OpenJDK 9
with Eclipse Open9
Standard SE API optimisation as
well as CUDA4J API for explicit
low level control
+

@spoole167
Here’s where everything changes.
• Up to now the JVM has done all the heavy lifting in transforming your
model of an application into the real thing.
Your model Multiple real applications
JVM

@spoole167
From now on – you and your application will have
to change as well
GPUs require you to think differently.
So will AI and Machine Learning..

@spoole167
BTW – what does a server GPU look like?
NVIDIA’s largest graphics card is the DGX-2. It’s 2
petaflops, 512 gigabyte, 10 kilowatts.
It weighs 160 kg
That’s as much as a fully grown panda

@spoole167
Numbers of GPU’s in data centers are growing
Hence why the JVM is working on improved native code interop
http://openjdk.java.net/projects/panama/
And things like value types
http://openjdk.java.net/jeps/169
Breaking down that wall even more
Making Java more attractive for new workloads

@spoole167
Effective native interop requires the JVM to be
able to pass in data in the form that the native
code needs. And do it very fast (bye bye JNI).
old layout
on heap
New
layout on
heap

o n c i o s u c d q d v p l a a n u s t c z p a a s h x o o g t r g g f l w v d n s j z o e p e e x
i e h f q u o q p r d m r u r w e p a x a a g k m e z t u u k u h r f w f w b z j n w y r s v t m o
w g j k r g u q h x l i j f f n l y f z r z t r p x a h c n h a s c v r y m w m a d o g g z u y g k
c c v s k l m m v t p v e b z c g b i m c r z o b i r s z o s g y e l f l k q v t v r v w d v i i v
w s g x b w u l y p q e r a t e l t e j u o f a k m i q x z p h b h h l h a j k d u n j y b z z e g
o u n a l o s r m b k f j h z f m e l a u j k w o m o g i v s v c l c i u r o s j b e r o z m z l q
r x y t a k q h u t a y v m b a v z s c a k e v m t c v e b s h c b t i j k t m n c o x o c w z n y
s d a y f h n q g b i o z w s j n o j a o o n y q d b l s q f r x n h g z j u v s w q e f q t e d g
f y u i q v k o q c t o h e t o d w q n f f m o s c t v h r e n o y o g f h j w u v w u n u b a s k
z u y u f r h z h g p j g r i q m l k p e j z g h k w r g k v k k w n w x g v p l g e v c o c e j z
v n f m l b k o m q g t y z d n t s e r i i e b n w w b l q x v s i l q a e p e h r j l r e n z m l
m o n w q j s f r g k s e s k o i j d z k y p t s u d p c f e t p f g t t l s h d x f r z p c c n v
o e u a m w u b i z t b k i b o p l s u e p j z w t j x f s s v r b h j c v h m k d k j t l o z b m
x y i m m j l d c k z f k v b q r c l t q e y n e o x f z m w b d w r b g h r j b u f u g z a m c n
l j l b q q o n h n a f k h s r w p l h i m d l u s i s u l t i o g h v q u k n m h z u z u v l d u
q x y m n u m o o j o u i k i d k l w h z v t o g p u d h s n f u i m j q x m x s y g l k k p p l x
j s s e p a r y t o e x t i d b u s l n l y y t i p g d q p z e d z s j k i p a y i n x i l s y y v
y f d o h n j m n l p g m p a n q p b s u l y d a e j m x q b a f a t f q p r z t t w q n s o f e q
g k d s b j a j g v m r n j w k n c v i r i j t z a r a q r e c l t i q r v r t o a t e u t w s h w
d c x r g m r h k c n y r t t s a i t i y c n s b l f s v n v q z u f c b c g o t b w m k f e p x q
q m y x e x p p c r b v z n y b e p l h n k w i z m u h g a f m s u q m b f n j p s y r n g r r u r
v m s a a f e e p c e m k i k t n c c a i x q e z p i k c c i c h b c k l o m z y e j y x u a y u s
j q k z t o a j g z s q h p w i g f k k o n z m a g k y q u k w h e t a t y v h d q h p q u t m p s
r w x t l f g l k t h b k t j d d u x u w c k u o w j l y d l f i j h k v x x n t g g w r y n g n k
k e m g h v w v j p i p j e h g u u t p a x g i a e l m o h r h a u b d x s a t m y v l e v l n m f
j y c n d w g y i z e t o b e e b x c b z e i g n p q u i u f j r h p z o b b d k f c a r t k y q k
o k g k l l f b g b i z x j n n q h k k l w c q s g m o x y q f r m e f n w j f q h p p c z l y b k
f w p e e i d c m w m r k f a q o f k a i b y a l s j u z m s j z v c q x g m p k m j a o k k n l g
q o y r o p s w z z o v d x u k b u m y l e n x q k k l j r s f f n i k v i c s r e x j q c j a t c
c v l k l h r h k c d p l l j e b w g k t y m z d z k x n j p a q e i k f x x y l z m q h a h h y t
w l t r v c e i y w f f h j j l d w r h h e r f g j h z n b x m c l c i d l j o r b m g n j p c v b
y m d p i p i b z r c z p k p b l o q p f w p n e o d n l g v i h a p t h t f i i z f r u h v q d x
q u l e n a s k q a u a h f e n i v o i i s e k h r y n i u q g y z l o x i h j u p h a r o l s o l
What about when you don’t know the words you’re searching for?
Do you create a list of every possible word?

NEURAL:
a e k j c b a o a j
e j a x l o n d
o
d
n
v n a v a a j v i o
i c
m
e
i e t u p a a
t d a t a j a j k l
i t w i q a y a m h
n u e n x v d v g a
g o d g t f f a u i
o a s o g a g t v c
c i a c h j a i b m
Teach a Neural Net
about how words are
constructed.
Then let it search the grid
Then work out which words
are ‘real’
Don’t think that’s possible?

http://karpathy.github.io/2015/05/21/rnn-effectiveness/

@spoole167
Neural nets are number crunchers – something
GPU’s are also fantastically good at.
More reasons for Value Types and native interop
Breaking down that wall even more
Making Java more attractive for new workloads

@spoole167
What comes after GPUs?
neuromorphic processors of course

SYNAPSE:
A program to develop a
neuromorphic processor that is a
new kind of cognitive computer
Designed to simulate the neurones
and dendrites of the brain for low
power efficient operation

Event driven, Non Von Neumann Neural Network.
Neural Nets want their data in different forms
They behave differently
You’ll have to think differently too

And beyond?

SEARCH
In 1996 a search algorithm was
defined by Lov Grover. This
algorithm can transform the
problem into an O(√N) search.
On a traditional computer any
search problem is solved in no fewer
than O(N) evaluations

0 - ish
Z Rotation
or ‘phase’
1 - ish
Y Rotation or ‘pha
X Rotation or ‘phase’

QBIT
Microwave resonators

qubitbit
1
0
SEARCH

r c e n t u r y l m
y q h m y t n e w t
j x v g f a s r h h
f u r t u k h o u q
y a m a h o c e k n
s b r p v e n c a t
a y g e u a j e a d
h z g a m o j i p b
h z a e r b y a n n
d m t f g e i v e i
“Java”
Try 1 3,5 -> NE

r c e n t u r y l m
y q h m y t n e w t
j x v g f a s r h h
f u r t u k h o u q
y a m a h o c e k n
s b r p v e n c a t
a y g e u a j e a d
h z g a m o j i p b
h z a e r b y a n n
d m t f g e i v e i
“Java”
Try 1 3,5 -> NE
No – try again

r c e n t u r y l m
y q h m y t n e w t
j x v g f a s r h h
f u r t u k h o u q
y a m a h o c e k n
s b r p v e n c a t
a y g e u a j e a d
h z g a m o j i p b
h z a e r b y a n n
d m t f g e i v e i
“Java”
Try 2 4,4 -> N

r c e n t u r y l m
y q h m y t n e w t
j x v g f a s r h h
f u r t u k h o u q
y a m a h o c e k n
s b r p v e n c a t
a y g e u a j e a d
h z g a m o j i p b
h z a e r b y a n n
d m t f g e i v e i
“Java”
Try 2 4,4 -> N
No – try again

r c e n t u r y l m
y q h m y t n e w t
j x v g f a s r h h
f u r t u k h o u q
y a m a h o c e k n
s b r p v e n c a t
a y g e u a j e a d
h z g a m o j i p b
h z a e r b y a n n
d m t f g e i v e i
“Java”
Try 3 6,3 -> NW

r c e n t u r y l m
y q h m y t n e w t
j x v g f a s r h h
f u r t u k h o u q
y a m a h o c e k n
s b r p v e n c a t
a y g e u a j e a d
h z g a m o j i p b
h z a e r b y a n n
d m t f g e i v e i
“Java”
Try 3 6,3 -> NW
No – try again

QUANTUM:
a e k j c b a o a j
l g m e e t u p a p
l n a v a a j v i o
p c
m
e
i e t u p a a
r d a t a j a j k l
u t w i q a y a m h
d u e n x v d v g a
j o d g t f f a u i
a a s o g a g t v c
z i a c h j a i b m
www.research.ibm.com/ibm-q/

Quantum Computers can and will solve linear equations
break cryptographic systems or model new medicines
In times that are a fraction of what existing computers can
achieve now.
Word searches are easy. But you present the data differently
and get a statistical response.
No more 0&1’s
The question is how to get the JVM talking quantum?

1
3
0
Runtime Language
Type Safe
Bytecode: JIT Compiled
Garbage Collected
Concurrent Threaded
All Platforms
The JVM’s design
characteristics allow
us to imagine taking
it to new places
No other runtime
environment comes
close

The JVM design means that we can easily
imagine running JVM languages on new forms of
processors.
The JVM can take the application model and transform it
to the something suitable for the hardware
The challenge is that you have to change how you think!
.

@spoole167
Java Vendor competition and collaboration delivered
• The fastest runtime environments
• The most scalable runtime environments
• The best garbage collectors
• The greatest dynamically re-optimizing compilers
• And we’re still doing it.

Phew.
• So many ways Java is going
forward…

@spoole167
Java is going places it’s never been before.
The JVM is rising to the challenge – are you?

Java 21st Century Thinking

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Java 21st Century Thinking

Similar a Java 21st Century Thinking (20)

Más de Steve Poole

Más de Steve Poole (20)

Último

Último (20)

Java 21st Century Thinking

Notas del editor