►
From YouTube: The Future of Serverless Java - Chad Arimura, OracleSDCC
Description
Join us for Kubernetes Forums Seoul, Sydney, Bengaluru and Delhi - learn more at kubecon.io
Don't miss KubeCon + CloudNativeCon 2020 events in Amsterdam March 30 - April 2, Shanghai July 28-30 and Boston November 17-20! Learn more at kubecon.io. The conference features presentations from developers and end users of Kubernetes, Prometheus, Envoy, and all of the other CNCF-hosted projects
The Future of Serverless Java - Chad Arimura, OracleSDCC
12 million developers across 80% of the enterprise, run Java. It is the number one language in the world, yet when it comes to serverless, you won’t find Java anywhere near the top of the rankings. Why is this?
In this session, I will review some of the recent enhancements made over the last year to the language, platform, and ecosystem, as well as offer a glimpse into some of the features in development that will impact how Java-based serverless applications should be built. I will include code samples and multiple tips on how Java developers can get serverless today!
The audience should come away with confidence that their skills in Java can be applied to the next generation of serverless workloads.
A
Okay,
let's
see
so
sorry,
if
my
I
screwed
up
the
schedule,
my
flight
was
delayed
for
three
hours
out
of
San
Francisco
I.
We
had
two
plane
and
then
D
plane,
and
then
we
planed
again
I
I,
didn't
think
I
was
gonna,
make
it.
I
was
a
half
step
out
the
nope,
the
point
of
no
return
security
where
I
was
gonna
head
back
home
and
I
called
Naomi,
and
she
magically
moved
the
schedule
around.
A
So
thanks
for
accommodating
Doug,
okay,
so
my
name
is
Chad
re,
Mira
and
I
work
on
the
Java
platform
group,
so
currently
I
lead
developer
relations.
My
talk
today
is
probably
gonna,
be
a
little
bit
different.
It's
a
bit
of
a
detour
of
what
I've
done
for
most
of
my
career,
but
I'm
merging
two
worlds
together
and
I.
Think
for
good
reason.
So
I'll
talk
about
that
in
just
a
minute.
You've
probably
seen
this
before
it's
what
says.
A
I
work
at
Oracle
basically
says:
don't
make
buying
decisions
based
off
what
I
say
today
a
little
bit
about
me.
So
I'm
I've
been
an
entrepreneur
for
startup
guy.
For
most
of
my
career,
I
was
formerly
the
co-founder
and
CEO
of
a
company
by
the
name
of
iron
IO
and
at
that
company
we
we've
been
doing
sort
of
service
computing
for
a
long
time.
So
around
2009
2010,
we
created
a
product
called
simple
worker,
which
became
iron
worker
and
we
started
calling
it
serverless
around
2010-11
timeframe.
A
Here's
a
couple
articles
that
we
wrote
the
future
of
software
and
applications
is
serverless.
We
thought
it
was
like
a
really
cool,
just
like
a
cool
idea,
we'd
liked
the
idea
of
not
having
to
think
about
infrastructure,
and
so
we
thought
it
was
like
this
buzzy
term.
We
had
no
idea
that
it
was
going
to
be
this
whole
thing
and
it's
pretty
cool
to
see
that
it's
become
this
whole
thing
granted.
A
So
I'm
gonna
talk
briefly
about
Java
and
I'm
gonna
pose
a
question
to
the
audience,
and
hopefully
this
gets
you
thinking
a
little
bit
about
what
does
Java
mean
to
service?
What
does
Java
mean
to
cloud
cloud
native?
So
first,
what
is
Java?
Well,
it's
a
programming
language
right.
It's
been
around
for
almost
a
quarter
of
a
century
25
years.
That's
a
pretty
powerful
concept.
It's
been
around
for
a
very
long
time.
It
consists
of
the
specification,
that's
managed
by
the
JCP
Java
community
process
and
implementations.
The
leading
the
implementation
today
is
called
open.
A
Jdk
100%,
open-source
gplv2
with
class
passing
exception,
open
source.
You
can
go
you
can
you
can
commit
to
open
JDK.
You
can
become
an
author.
You
can
check
out
the
mailing
list,
everything
that
happens
in
quote-unquote
Java,
including
the
java
virtual
machine,
happens
inside
of
open
JDK
and
there's
a
reference
implementation
at
open,
JDK
and
then
there's
many
other
implementations
as
well.
You
know
by
a
lot
of
accounts.
Java
is
the
number
one
programming
language
in
the
world.
I
know
that
you
know.
Stat
statistics
are
kind
of
what
you
make
of
them.
A
A
The
ecosystem
is
quite
large,
it
might
be
pretty
small
to
see,
but
Oracle
is
one
so
Oracle
acquired
Sun
in
2010
and
it's
one
of
the
largest
contributors
to
open
JDK
today,
but
there's
a
bunch
of
other
companies,
many
of
which
are
in
this
room
today
that
care
very
much
about
Java.
If
you
look
at
the
list,
you've
got
Google
s,
ap
IBM,
Intel,
Red,
Hat,
JetBrains,
Amazon,
arm
Twitter
and
for
good
reason,
just
recently,
Bruno
Borges
from
Microsoft
posted
that
they
count
very
heavily
on
Java
at
Microsoft.
A
In
fact,
just
recently
they
joined
the
open
JDK
project
as
official
committers
on
the
Commuter
team,
so
Microsoft
obviously
finds
Java.
Quite
important.
Amazon
has
their
own
openjdk
distribution
called
amazon
careto
at
devoxx,
belgium
apple
talked
about
their
usage
of
java
and
in
fact
one
of
the
quotes
was,
if
you're,
using
an
Apple
device.
Today,
you're
hitting
a
JVM,
which
is
a
lot
of
people.
A
So
I
posed
a
question
if
only
5%
of
functions
that
are
written
today
are
in
Java
only
5%.
You
know,
according
to
the
statistic
put
out
by
surrealist
Inc
a
year
ago,
only
5%,
if
80
or
90%
of
the
world
is
using
Java
and
only
5%
of
functions
are
ran
in
Java
and
the
trend
is
not
going
in
the
right
direction.
Why
is
this?
The
question
is:
why
is
that
and
I'm
opposed
that?
It's
an
important
question
to
ask
because
of
12
million
plus
developers
no
Java
if
80%
enterprise
is
using
it.
A
If
it
is
one
of
the
largest
ecosystems
of
the
world
with
over
two
decades
of
history
and
most
companies
become
Java
shops
when
they
grow
up,
I
think
it's
important
that
we
talk
about
this,
especially
at
a
conference
like
this,
where,
if
you
know
you
once
you
leave
this
conference,
you'd
think
there's
some
existential
crisis
with
go
or
Kotlin
or
type
scripts
becoming
the
number
one
language
in
the
world
when
the
reality
is
quite
different.
Behind
the
scenes,
I
mean
so
that's
part
of
what
I
want
to
talk
about,
and
how
do
we
fix
it?
A
Ok,
I'm
you've
seen
a
bunch
of
talk
today
and
you're
gonna
see
it
much
more
and
you're
gonna
see
a
bunch
of
definition,
so
I'm
gonna
skip
the
definitions
and
I'm.
Just
gonna
put
one
slide
up
there,
which
you
know
even
with
this
definition,
it's
debatable,
but
I
really
think
that
serverless
is
about
doing
less.
That's
why
less
is
in
the
name
of
server
list.
You
want
to
think
about
things
less.
You
want
to
do
less
stuff.
A
You
want
to
spend
more
time
on
writing
the
code
that
matters
to
you
in
your
organization,
so
it's
the
only
slide,
I'm
going
to
put
up
there,
but
the
experience
of
using
server
lists.
In
fact,
this
should
probably
be
called
like
the
server
characteristics
of
a
server
list.
Workload
maybe
is
like
I
have
an
alternative
title
to
this:
no
servers
to
manage
pay-as-you-go,
etc,
etc.
You
have
fast
startup
time.
Okay,
of
course,
they're.
Not
all
use
cases
where
it's.
A
This
is
necessary,
but
I
think
generally
acceptable
fast,
startup
time,
small
footprint,
meaning
you
know
like
traditionally
big
monoliths,
we're
really
big,
and
you
don't
just
take
that
and
turn
it
into
a
function
or
a
service
environment.
It
takes
some
work
and
then
fast
time
to
value
and
I'm
gonna
spend
most
of
my
time
at
fast
time
to
value.
But
I'm
gonna
talk
briefly
about
the
about
the
other
two.
Now
the
first
one,
it
kind
of
comes
with
the
platform,
so
I'm
gonna
skip
that.
A
So,
if
you
think
about
the
JDK,
the
JDK
or
the
JVM
has
something
called
economics
and
ergonomics
is
essentially
how
things
are
tuned
to
a
particular
workload.
If
you
think
about
what
you
want
your
workload
to
be,
you
wanted
to
start
extremely
fast.
You
want
there
to
be
no
latency
whatsoever.
You
want
the
footprint
to
be
very
small
and
you
want
the
throughput
to
be
really
high
and
that's
the
orange
line
at
the
top.
A
But
you
know
what
a
lot
of
the
times
twenty
years
ago
the
JVM
was
started,
maybe
wants
to
every
six
months
when
you
did
a
deployment,
that's
obviously
not
the
case
anymore,
so
the
ergonomics,
the
JVM,
doesn't
align
with
the
characteristics
of
what
server
list
thinks
about
today.
But
out
of
the
box,
the
JVM
or
the
JDK
was
optimized
for
for
other
types
of
characteristics,
so
I'm
going
to
introduce
a
few
things
that
are
happening
in
the
Java
ecosystem.
That's
sort
of
tailored
more
towards
the
way
we
think
about
service
workloads.
A
Class
data
sharing
is
something
that
was
introduced
in
Java
5
and
basically,
what
that
does
is
takes
your
your
class
data
and
then
turns
that
into
metadata
files,
our
kyv
files-
that
can
then
be
loaded
up
into
memory
very
quickly.
So
it
takes
something
that
traditionally
takes
the
JVM
awhile.
Let's
start
up
turns
it
into
a
format
that
the
JVM
can
understand,
so
you
get
faster
startup
time.
A
That's
essentially
what
class
data
sharing
is,
and
it's
been
around
for
a
while,
but
it's
this
thing
that
you
know
there's
some
steps
you
have
to
take
in
order
to
utilize.
It
and
you
can
see
with
CD
s,
we
actually
turned
it
on
in
Java
12
by
default.
So
before
that
it
was
like
you
have
have
it
enabled
or
you
don't
it's
enabled
by
default,
starting
in
12,
and
you
can
see
the
startup
time
shrinking.
A
This
is
enabled
by
default
on
many
of
the
platforms.
I
know,
lambda
has
enabled
by
default.
I,
don't
know
if
some
of
the
other
ones
do
and
then
just
to
give
you
a
my
going
to
go
into
detail
here.
But
if
you
look
at
the
versions
of
Java
the
enhancements
we've
made
to
class
data,
sharing,
we've
actually
extended
that
to
your
application
classes
as
well.
A
So
now
you
can
take
your
application
classes
from
your
code,
turn
that
into
a
format,
that's
easily
readable
by
memory
and
then
make
that
so
every
time,
for
example,
a
function
starts,
it
doesn't
have
to
load
up
a
whole
JVM
and
do
this
kind
of
whole
bytecode
mapping
of
class
data
to
to
memory,
and
so
that's
all
been
happening
for
many
versions
now
and
that
will
continue
to
get
easier
and
easier
and
out
of
the
box.
So
that's
one
area
to
take
to
keep
an
eye
on
another
project.
That's
really
exciting
and
commendable.
A
Oracle
labs
called
the
crawl
VM
project.
You
know
if
you
read
reddit
or
hacker
news,
you've
guaranteed.
You
have
seen
something
about
Graul
Grall
is
a
girl.
Vm
is
a
number
of
things.
One
of
them
is
a
JIT
compiler,
a
just-in-time
compiler,
that's
written
in
Java.
That's
part
of
the
JDK
today
I'm.
Another
piece
of
that
is
what
we
call
what
was
called
truffle,
which
is
like
a
polyglot,
a
polyglot
interpreter
that
can
run
any
language
on
top
of
the
JVM,
so
you
can
run
Ruby,
LLVM
languages
or
or
node,
etc.
A
On
top
of
the
JVM,
which
is
actually
really
powerful,
part
of
which
many
organizations
are
using
today,
for
example,
if
you
have
some
R
code-
and
you
have
a
bunch
of
Java
JVMs,
you
can
actually
do.
Inline
are
all
just
alongside
your
java
code,
which
is
which
is
pretty
neat
and
then
the
third
piece
of
girl
vm,
is
what's
called
native
image
or
ahead-of-time
compilation,
and
that's
basically
taking
your
job
application
and
compiling
it
well
ahead
of
time
into
a
native
binary
that
doesn't
need
the
JVM
anymore
and
I
could
start
really
really
fast.
A
There's
some
drawbacks
to
that
today,
where
you
know
things
like
reflection,
become
very
complicated
or
invokedynamic
or
a
bunch
of
other
kind
of
behind
the
scenes.
Things
they're
very
complicated
to
do
with
with
native
image.
But
this
is
a
very
promising
technology
to
keep
an
eye
on,
to
show
you
the
ergonomics
of
äôt
or
ahead
of
time,
compilation
I
showed
you
the
ergonomics
of
git,
which
is
just
in
time.
You
can
see
it's
optimized
for
throughput.
A
So
if
you
look
at
Java,
eight
eight
to
nine
was
actually
a
regression
because
of
the
modularity
system,
but
from
9
to
13.
You
can
see
that
it's
almost
halved
the
time
that
it
takes
to
spin
up
a
Java
in
this
case.
I
guess:
I
have
a
function,
you'd
call
it
and
then,
of
course
the
platform
is
going
to
do
a
bunch
of
stuff
for
you
in
terms
of
hot
functions,
etc.
Cold,
you
know,
cold
start.
A
Time
is
a
big
thing
in
the
industry,
but
this
is
just
part
of
what
you
get
from
upgrading
your
JDK.
Ok,
so
that
covers
fast
startup.
Let's
go
into
small
footprint,
your
application
code.
I
mean
this
is
really
important,
because
traditional
Java
applications
are
based
off
pretty
pretty
heavy
frameworks.
You
know,
for
example,
I,
don't
know
if
you
I,
don't
wanna
pick
on
spring,
because
it's
great,
but
it's
pretty
heavy.
It's
not
intended
to
be
kind
of
turned
into
a
small
function,
but
you
want
to
use
smaller
dependencies.
A
So
the
in
Java
9
by
the
way,
we're
on
13
and
I'll
talk
a
little
bit
about
the
history
of
Java
at
the
end,
maybe
I
should
have
put
that
at
the
beginning,
but
in
Java
9
a
few
years
ago,
which
was
released,
there
was
something
called
the
modular
system
and
there
was
a
lot
of
very
great
reasons
for
doing
that.
I
would
side
of
the
scope
with
this
talk,
but
this
is
what
the
SC
modules
look
like
today.
Most
applications
aren't
using
all
these
modules.
A
The
JDK
itself
is
through
over
300
Meg's,
so
just
to
run
a
Java
program,
you
needed
the
Java
development
kit,
which
included
the
JVM,
which
is
over
three
hundred
Meg's,
but
your
application
may
only
use
you
know,
may
run
a
line
of
sequel
and
it
may
use
Java
activation
to
do
something
kind
of
Java
beanie.
If
you're
using
those
two
modules,
then
we
have
a
tool
called
Jade
EPS,
which
will
give
you
the
dependencies
of
those.
A
And
then
you
can
use
something
called
J
link
which
you
can
actually
take
all
those
dependencies
together
using
Jade
app
and
then
you
could
J
link
them
into
your
own
custom
runtime
now,
which
brings
the
JDK
down
to
30,
Meg's
or
less,
and
you
can
do
even
better
than
that.
But
this
is
sort
of,
for
all
intents
and
purposes,
probably
the
smallest
jdk
you're
gonna
get
in
Java
9
going
forward
again.
A
A
lot
of
this
stuff
may
not
apply
to
you
if
you're
using
you
know,
Amazon
lambda,
Google
Cloud
functions,
but
if
you're
using
containers
using
FN
project
using
open
fast,
which
I
think
you
heard
from
Alex
I
think
I
saw
him
somewhere
here
talked
earlier
about
open
fads
and
other
stuff,
if
you're
using
containers
the
contract.
Those
are
some
of
the
things
you
want
to
think
about
the
size
of
your
jdk
or
the
size.
Your
container,
so
there's
a
lot
of
work
to
decrease
the
size
of
the
jdk.
A
Okay,
the
JVM
there's
some
technical
things
here.
Most
of
this
is
about
again
containers.
If
you're
using
a
containerized
environment,
you
want
to
be
a
good
citizen
in
a
multi-tenant
environment.
Until
recently,
the
JVM
wasn't
even
very
good,
even
adhering
to
the
container
contract,
so
things
like
heap
size,
GC
region
sizes.
These
are
things
that
were
not
optimized
for
containers,
starting
with
8,
9
and
10
moving
forward.
There's
a
lot
of
work
going
into
Java
to
make
it
much
more
container
friendly,
in
fact,
until
Java,
I,
believe,
8
or
maybe
9
it
didn't.
A
Even
it
didn't
honor
the
CPU
quota
or
CPU
period.
So
if
you
tried
to
contain
your
application
inside
of
a
container
and
only
use
a
certain
number
of
procs,
it
had
a
hard
time
understanding
that
it
would
sort
of
break
out
to
all
of
the
CPUs
and
would
starve
other
containers
that
were
running
in
a
multi-tenant
environment
again.
This
applies
to
containers.
I,
don't
want
to
sit
up
here
and
debate,
whether
containers
are
serve
us
or
not.
Sometimes
they
are
sometimes
there
whatever,
but
if
you're,
using
docker
or
some
other
container
system.
A
This
is
pretty
important
to
think
about,
and
then
here
is
a
bunch
of
bugs
in
our
bug
tracker
that
most
of
them
have
been
solved
10
in
version
10,
11
11.
A
couple
of
them
are
open
all
about
making
it
Java
more
aware
of
the
container
space
that
it's
running
in
very,
very
important
stuff
all
happening
and
we're
thinking
a
lot
about
this.
A
A
Ok,
I'm,
gonna,
move
on
to
fast
time
about
fast
time
to
value,
because
I
think
the
other
two
things
are
important.
Platforms
are
working
on
it's
getting
better.
It
will
continue
to
get
better,
but
I
think
faster
time
to
value
is
one
of
the
most
important
areas
and
as
a
you
know,
former
developer,
myself
or
sometimes
developer
myself
time
to
value
is
really
important.
A
In
fact,
the
reason
we
built
simple
worker,
which
is
now
ironworker,
is
because
we
didn't
want
to
deal
with
anything
outside
of
the
logic
that
we
wanted
to
write,
and
so
we
really
literally
wanted
to
write
a
piece
of
code
and
we
wanted
to
hit
an
API
and
we
wanted
that
code
to
just
run
and
that's
what
for
out
ironworker.
In
fact,
the
real
story
is
that
iron
worker
was
not
the
first
product
that
we
launched
at
my
former
company.
A
We
had
like
five
other
products
that
we
tried
to
bring
to
market
before
that,
and
we
weren't
really
excited
about
any
of
this
is
before
you
know,
VC's
and
all
that.
But
then
we
looked
at
what
the
most
important
piece
of
that
entire
infrastructure
was.
It
was
actually
this
iron
worker
piece
that
was
running
code
behind
the
scenes,
and
so
that's
why
we
felt
it
was
really
important
to
bring
out
and
that's
what
enabled
us
to
bring
a
bunch
of
products
to
market
really
quickly.
A
There's
really
three
components
here
that
pertain
to
Java
about
fast
time
to
market
or
fast
time
to
value
simplicity,
which
I'll
talk
about
perception
of
modernity.
So
you
know,
typically,
when
you
say
Java,
you
think
Enterprise
e,
slow,
old,
antiquated
that
move
you
fast.
These
are
some
of
the
things
that
you
hear,
which
is
actually
not
true
at
all.
I'll
talk
a
little
bit
about
that
and
then
the
ecosystem
and
those
are
the
three
things
I
think
sort
of
help
you
get
to
value
faster.
A
Okay,
so
there's
a
desire
for
simplicity
right
now,
in
fact,
I
think,
there's
a
big
desire
for
simplicity,
even
at
this
conference
itself,
just
the
other
day
open
up
Accra
news
and
of
course
the
top
hit
was
the
value
and
gos
simplicity.
That's
neat,
you
know
go
is
simple:
it's
been
around
a
lot.
It's
got
a
much
shorter
lifetime.
A
Then
then,
Java
does
and
they've
done
pretty
good
and
keeping
the
language
simple
and
to
the
point,
and
it
was
one
of
the
top
guides
and
then,
if
you
scroll
down
a
little
bit
to
number
six,
you
get
the
configuration
complexity.
Curse
complexity
is
a
curse.
Literally.
The
language
that
we
use
is
is
inherent
to
complexity
being
a
bad
thing,
and
it
really
is
complexity,
slows
us
down.
A
So
here's
your
typical
four
four
lines
of
Java
you've
got
your.
You
declare
your
variable,
you
you
define
it
and
then
you
have
your
expression
and
then
you
you
say
what
you
want
to
call
them
on
the
right
side
of
the
expression
and
you
and
you
set
the
variable.
As
you
can
see
here,
a
lot
of
Java
is
sort
of
redundant
and
so
local
type
local
variable
type
inference.
A
Is
it
basically
inferring
the
type
of
the
variable
from
the
right
side
of
the
expression
and
we
introduce
something
called
the
VAR
keyword
and
that
might
seem
really
simple
other
languages.
Do
this?
It's
very
nice
there's
a
reason
why
Java
takes
a
while
to
do
things
like
this
because
of
course,
20
years
of
history,
we
spend
a
lot
of
I
mean
the
language.
Architects
spend
an
enormous
amount
of
time,
ensuring
that
Java
code
that
you
wrote
20
years
ago
still
runs
on
the
JVM
today.
A
That's
one
of
the
reasons
that
Java
is
so
popular
today
is
that
we
we
care
very
much
about
compatibility
over
time,
I'm.
So
introducing
something
like
this
is
not
a
light,
not
a
light
project,
but
what
this
does
is
it
not
only
makes
you
know
so
you
have
to
type
you
know,
10
less
characters
or
20
less
characters,
but
you
actually
turn
the
focus
of
the
language
onto
the
variable
naming
itself.
So
you
can't
name
crappy
variables.
A
Now
we
can't
stop
you,
and
probably
none
of
you
do
this,
but
a
lot
of
developers
are
really
bad
at
naming
variables.
What
happens
now
is
it
makes
your
code
really
confusing
to
read,
but
by
exposing
the
variable
here
it
brings
it
front
and
center,
and
now
you
can
think
about
how
you
name
your
variables.
So
this
is
just
something:
that's
simple
and
powerful
in
and
of
itself,
and
if
you
think
about
some
sort
of
you
know,
bufferedreader
inputstreamreader
lines
of
java,
it
sort
of
makes
you
as
a
college
student.
Looking
at
java
going.
A
A
When
you
look
at
the
language,
the
language
designers
for
Java
looked
across
the
board
and
said
you
know,
it
looks
like
most
people
who
are
ready
to
switch
statements
actually
want
to
ride,
switch
expressions,
and
so
most
most
switch
statements.
Did
something
like
this?
You
have
a
variable
at
the
top.
You
have
a
bunch
of
cases
where
you
set
it
you
break
from
each
of
those
and
at
the
end
you
have
a
default
case
and
then
at
the
end
you
have
a
value.
A
That's
set
to
something
that
you
want,
but
when
you
wrote
this
code,
what
you're?
Actually
thinking
is
something
like
this,
which
is
what
switch
Express
in
expressions
introduced.
So
now
you've
got
the
nice
lambda
symbol,
which
is
by
lambda
e
and
Java.
Lambda
is
the
dash
greater
than
symbol,
and
you
can
take
an
enumerator.
You
don't
have
to
have
a
default
case.
A
You
don't
have
to
have
a
break
because
you've
covered
all
the
cases
here
and
if
you
don't
cover
all
the
cases
of
the
enumerator,
then
you
you
throw
an
exception
and
you
can
see
when
you
wrote
this
code.
You
were
actually
thinking
about
this
and
it
makes
it
much
more
simple
and
much
more
readable
and
much
less
error-prone.
A
There's
way
less
places
for
bugs
to
hide
in
this
code.
If
you
forget
a
break
in
the
previous
code,
who
knows
what's
gonna
happen,
so
these
are
small
things
that
we
continue
to
bring
to
market,
to
make
the
language
more
simple,
but
powerful
records
is
something
that
still
I
believe
in
early
access,
I'm,
actually
not
totally
sure
I
think
early
access
today,
but
it's
not
available
just
yet.
You
can
try
in
an
early
access,
build
of
Java
and
the
JDK.
This
is
a
very,
very
typical
class.
A
As
a
Java
developer,
it's
basically
just
a
place
to
hold
data,
there's
nothing
special
about
it.
You've
got
getters
and
setters,
you've
got
to
string
equals
and
hashcode
you've
got
a
compare
method.
These
are
just
things
that
you
implement
an
extend
object
and
you've
got
a
place
to
store
data.
You
don't
really
need
100
of
the.
A
If
you
have
a
hundred,
you
know
things
you
want
to
hold
data
buckets
in
what
records
does
interest
terms,
this
code,
which
is
actually
much
longer
than
probably
this
into
this,
and
now
you've
got
something
which
is
very,
very
powerful.
In
fact,
you
can
extend
this
to
bring
more
kind
of
custom
functions
into
there.
You
do
give
up
some
functionality
of
like
your
traditional
Java
object,
but
you
get
simplicity
if
you
are
sort
of
want
to
work
within
those
constraints.
So
that's
what
records
brings
to
the
language
and
that's
coming
out?
A
Five
minutes
is
out.
That
means
excellent.
Okay,
let's
cruise
along
here
perception
of
modernity,
now
I
said
I
would
talk
a
little
bit
about
Java
history,
and
hopefully
this
has
been
semi
educational
for
you.
If
you
know
any
Java
developers,
you
work
in
an
organization
that
has
Java
but
there's
a
particular
reason
why
Java
is
looked
at
as
slow-moving,
because
in
a
way
it
has
felt
very
slow.
If
you
look
at
Java
one
which
came
out
in
97
and
five
and
then
you
fast
forward
to
Java
nine,
which
was
2017
look
at
the
red.
A
If
you
can
read
that
the
idea
was
every
two
years
to
come
out
with
a
new
version
and
in
1995
when
you
had
waterfall
methods
and
that's
kind
of
how
software
was
shipped
every
two
years
made
sense.
But
then
look
at
Java,
seven,
eight
and
nine
five
years,
three
years
three
years
it
took
literally
eleven
years
between
two
versions
of
Java
to
produce
new
code
for
developers
to
use
inside
their
applications.
A
There
are
a
bunch
of
reasons
for
this.
The
acquisition,
the
Sun,
was
one
reason
bah
bah
blah
blah
blah
lambdas
took
a
long
time
to
get
right,
so
they
actually,
you
know,
delayed
it
by
a
year
and
there's
a
reason.
Alam
does
looks
very
natural
today
because
it
took
a
long
time
to
deliver.
However,
this
model
no
longer
works
anymore,
to
get
new
features
in
the
hands
of
developers.
Now,
let's
look
at
Jabba
nine,
ten,
eleven,
twelve
thirteen
and
soon-to-be
fourteen
six
months.
A
The
release
cadence
of
Java
has
changed
so
that
it
is
time
bound
now
for
seen
every
six
months,
a
new
version
to
come
out.
So
what's
in
the
JDK
or
what's
in
that
version,
will
ship
what's
not
ready,
gets
pushed
for
six
more
months,
but
that's
okay,
because
you
didn't
have
to
wait
three
to
five
years
to
get
it
done
to
get
it
out
there.
So
imagine
what
happened
when
you
were
approaching.
The
deadline
and
you
had
to
get
you
something
into
the
JDK
and
that
ship
date
was
coming.
A
You
had
a
small
feature:
that's
been
sitting
behind
lambda's
for
three
years:
you're
gonna
rush
it
in
there
and
then
people
would
wait
a
year
anyways
to
implement
that
new
version.
So
everything
has
changed
in
Java
in
the
past
couple
years
and
then,
finally,
a
couple
more
things:
projects
Cara,
is
actually
moving
open,
JDK
development
into
github
itself.
It's
taking
all
the
workflow
that
used
to
happen
in
mercurial,
mailing
lists,
etc,
etc.
A
Things
that
a
lot
of
people
really
really
love
but
modeling
that
in
it
get
workflow
style
and
then
mirroring
that
between
the
traditional
workflow
of
working
with
mailing
lists,
etc,
and
that's
happening
with
projects
Cara
there's
a
very
heated
conversation
going
on
right
now
in
the
open,
JDK
mailing
lists
about
whether
this
is
the
right
time
to
introduce
this.
If
you
care
come
on,
take
a
look
subscribe
to
the
mailing
list
for
SCARA.
A
Finally,
three
last
things
in
the
two
minutes
that
I
have
ecosystem
is
incredibly
important.
Java
has
a
rich,
rich
ecosystem
ready
to
be
to
use
for
sort
of
less
applications.
One
thing
that's
really
important
is
using
interfacing
with
native
code
native
code
is
really
fast
because
it
is
native
you're
not
doing
and
translating
a
byte
code
into
native
code
and
doing
compilation
at
the
time.
Sometimes
you
just
need
to
go
native
to
get
to
do
things
like
GPUs
to
use
CUDA
or
OpenCL
OpenGL
OpenSSL.
A
A
It
is
very
ugly,
in
fact
j
and
I
you
know,
I'm
gonna
skip
it,
but
there's
a
bunch
of
yeah
yeah
yeah.
Thank
you.
There's
a
bunch
of
stuff!
Oh
hey!
What's
up,
there's
a
bunch
of
steps.
We
eliminate
that
with
panama,
so
that
there's
really
only
one
step
and
you
don't
actually
have
to
write
C++
to
get
to
work
with
c++.
So
take
a
look
at
project,
panama.
If
you
want
okay
cloud
platform
support
and
one
minute
I
have,
I
think
this
is
mostly
accurate.
A
A
2016,
c-sharp
and
node
just
last
year,
I
believe
dat,
a
Java
8
support,
9
10,
11
12,
13
14,
not
available,
yet,
of
course,
unless
you're
using
containers
or
custom
runtimes,
some
CD
s
support
today,
no
app
CD
s
if
you're
not
using
Java,
9
or
above
no
need
of
j-link.
All
the
language
features
I
talked
about
are
not
available.
This
is
one
of
the
reasons
that
Java
is
held
back
server
list
is.
A
Finally,
late
lighter
work
frameworks,
there's
a
bunch
of
interesting
ones
out
there
to
take
a
look
at
these
are
kind
of
more
for
micro
services,
but
if
you
take
a
lot
held
on
micro
profile,
these
are
the
implementations
of
micro
profile
held
on
core
curious
micro,
not
there's
a
couple
others
to
take
a
look
at,
but
there
is
a
lot
of
work
happening
to
make
Java
faster
to
make
it
smaller
to
make
it
work
for
suitable
workloads
like
machine
learning
and
and
serverless.
So
that's
my
entire
talk.