►
From YouTube: OpenShift Commons Briefing Introducing Quarkus: a next-generation Kubernetes Native Java framework
Description
OpenShift Commons Briefing
Introducing Quarkus: a next-generation Kubernetes native Java framework
Guest Speakers: Thomas Qvarnstrom and Jason Greene (Red Hat)
Java was introduced to the open-source community over twenty years ago and to this day, it still remains very popular among developers. In fact, it has never ranked lower than #2 on the TIOBE Index. Java was born in the mid-90s and has nearly twenty years of optimizations for running highly dynamic monolithic applications that assumed sole ownership of (virtualized) host CPU and memory. However, we now live in a world dominated by the cloud, mobile, IoT, and open source, where containers, Kubernetes, microservices, reactive, Function-as-a-Service (FaaS), 12-factor, and cloud-native application development can deliver higher levels of productivity and efficiency. As an industry, we need to rethink how Java can be best utilized to address these new deployment environments and application architectures.
We’d like to introduce you to Quarkus and Supersonic Subatomic Java!
Quarkus is a Kubernetes Native Java framework tailored for GraalVM and HotSpot, crafted from best-of-breed Java libraries and standards. The goal of Quarkus is to make Java a leading platform in Kubernetes and serverless environments while offering developers a unified reactive and imperative programming model to optimally address a wider range of distributed application architectures.
Additional Resources: https://developers.redhat.com/blog/2019/03/07/quarkus-next-generation-kubernetes-native-java-framework/
A
A
Cool
so
today
we're
gonna
talk
about
Quercus
and
Korkis
is
a
kubernetes
native
Java
stack
tailored
for
gravi
and
OpenJDK
hotspot,
and
it's
crafted
from
the
best
of
green
Java
libraries
and
standards,
and
don't
worry
if
you
didn't
understand
that
we're
gonna
go
through
a
bit
more
about
that
means
of
what
the
value
of
Caucasus,
but
before
that
we
want
to
distort
change
the
slides
here.
We
wanted
to
start
by
introducing
what,
but
the
problem
is
that
the
Quercus
are
looking
to
solve
so
course
is
looking
at
evolving
java
for
service
and
container
workloads.
A
So
one
of
the
problems,
for
example,
is
that
not
only
Java
but
a
lot
of
Java
enterprise.
Application
has
originally
been
designed
for
a
three-tier
type
of
application
and
we
used
to
deploying
them
one
single
operating
system
and
they'll
they'll
take
over
basically
all
the
memory
over
the
machine
and
they
will
run
and
they'll
perform
excellent,
but
but
they're
built
they
are
based
and
build
out
of
this
architecture.
That's
it's
been
around
for
a
long
time.
Yeah.
Actually,
what
also
happened
in
a
lot
of
cases
is
that
that
people
actually
deployed
multiple
applications.
A
At
the
platform
like
Eclipse,
vortex
or
in
in
spring
boots
and
etc,
etc,
we
could
actually
mix
and
match
between
those
different
technologies.
But
that's
that,
but
one
of
the
problems
we
should
say
here
is
that
that
Java
has
always
suffered
from
this
fact
that
it's
been
in
design
from
the
beginning
to
be
the
basically
a
server-side
java
application,
writing
and
and
taking
up
a
lot
of
resources
and
reducing
you've,
been
utilizing
their
full
resources
of
the
platform,
and
there
has
been
some
improvements
on
that.
A
But
when
you
put
Java
in
a
container,
it
still
has
some
of
those
limitations
in
there
there's
a
great
block
by
the
way
on
the
reddit
developers
blog
so
later
on.
You
might
want
to
check
that
out.
That
explains,
and
one
of
the
problems
with
running
Java
in
a
container,
for
example.
So
so
what
are
the
problems?
And
one
of
the
complaints
that
we've
been
seeing
is
that
all
Java
is
a
bit
fat,
its
overweight
and
it.
A
A
It's
about
six
point,
one
percent,
and
so
you
can
see
that
that
languages
like
now
or
Python
or
needing
go
so
surprised
to
see,
although
in
here
and
and
I'm,
one
of
the
reason
that
Java
is
still
available
valuable
thing.
You
know
you
actually
see
that
if
you
look
at
particular
this
particular
report
from
sorry
last
column
and
we
actually
see
that
bigger
companies
are
1500,
employees,
etc.
A
That
leaves
us
to
an
introduction
to
what
Quercus
is
and
what
what
we
mean
with
cuba
native
java
here
as
well.
So
first,
let's
start
with
the
name.
What
what
is
a
quark
is
basically
well-well.
Quark
is
any
number
of
a
subatomic
particles
carrying
fractional
and
metric
charges,
and
us
in
terms
of
us
as
a
developer's,
is
the
hardest
problems
to
solve
a
software,
because
collaboration
is
harder
than
anything
else
in
software,
and
so
what
does
Korkis
bring
to
us?
A
The
change
is
going
into
that
we've
also
mentioned
in
the
beginning,
and
it's
based
on
the
standards,
but
it's
not
limited
to
standards,
and
that
means
that
we,
a
lot
of
the
frameworks
and
third-party
libraries
that
that
developers,
love
to
use
are
still
out
there
and
then
ours
are
supported
in
Quercus
and
you
can
use
them
in
Quercus,
but
we're
not
gonna
leave
at
this
point.
We're
not
gonna
limit
us
to
choose
to
certify
on
certain
standards.
We
we
are
all
about
innovating.
At
this
point,
that's
an
important
distinction.
A
So
one
of
the
things
that
I
think
we
can
give
me
better
cover
that
already
it's
one
of
the
things
that
workers
can
do
is
also
to
take
your
job
application
and
render
and
build
a
native
build
applications
of
that
particular
application
and
the
native
applications,
and
those
does
not
require
a
GVM
to
run
on
it
like
traditional
job
applications
does
so
it
can
run
standalone.
It
requires
basically
two
little
libraries
but
then
can
run
standalone
on
any
layer
on
the
operating
system
that
is
currently
supported,
which
is
Mac
and
Linux.
A
Windows
shoot
comes
in
and
run
assume
nothing,
but
so
what
do
we
mean?
We
say
supersonic
and
subatomic.
Well,
here
is
some
internal
testing
that
we
me
doing
some
data
from
some
internal
testing.
You've
been
doing
so
comparing
three
different
type
of
applications
here,
so
I
mentioned
that
you
can
generate
a
native
application
from
Quercus.
That's
what's
called
the
girl,
the
corpus
per
scroll
VM
here
in
this.
A
In
this
particular
picture
we
also
have
Quercus,
plus
open
GDK,
meaning
you
run
a
co-worker's
application
on
in
GBM,
and
then
we
have
a
traditional
cloud
native
stack
that
would
even
use
your
traditional
frameworks
etc
to
run
on,
and
if
you
compare
these
different
use
cases
we
have
one
first
use
case.
There
is
a
rest
application,
so
simple,
rest
application
and
the
second
one
is
a
bit
more
complex.
A
It's
the
rest
of
occasion
calling
to
a
database
using
the
java
persistence
api
returning
there,
the
java
objects
and
then
transforming
that
into
JSON
and
returning
it
to
the
client.
So
if
you
compare
these,
you
can
see
that
we
we
have
in
start
of
time.
We
have
even
more
than
hundred
times
faster
startup
times
when
we're
running
in
native
modes.
A
So
the
startup
time
for
the
rest
example
here,
as
you
can
see,
is
14
milliseconds
and
the
startup
time
for
for
Quercus
robur
for
the
rest
plus
epa
application
is,
is
55
milliseconds,
so
there's
there's
it's
extremely
quick
to
get
started
and
almost
immediately
will
show
that
later
on
in
there
mark
almost
immediately
be
able
to
serve
requests.
And
so
that's
that's
perfect.
Another
good
thing
we
didn't
ativ
application
is
that
it
only
takes
about
10%
of
the
memory
compared
to
the
to
the
traditional
cloud
native
Java
stack.
A
So
the
vertex
team
has
been
heavily
involved
in
in
in
developing
workers
as
well,
and
what
we've
been
able
to
do
is
to
unify
the
traditional
imperative
development
mode
of
Java
and
in
most
programming
language
together
with
the
reactive
mode,
so,
basically,
within
the
same
applications.
You
can
have
both
of
these.
These
rest
endpoints,
where
one
is
serving
you
a
text
explained
saying
hello
and
the
other
one
is
serving
you
server,
events
from
a
Kafka
stream,
for
example,
and
and
oh
yeah,
and
you
can,
you
can
always
so
to
get
access
to
the
reactive
part.
A
You
can
just
inject,
what's
called
an
event
pass
or
the
vertex
context
itself
and
you
can
develop
applications
if
you're
familiar
with
reactive,
you
can
develop
applications
almost
the
same
way,
you've
been
doing
on
vertex,
and
so
that
makes
it
an
able
to
use
what
technology
that
fits.
Your
use
case
there,
because,
from
my
from
my
perspective,
I'm
a
product
manager
for
vertex
as
well
and
and
vertex
is
a
fantastic
product,
but
it
has.
A
So
with
that
I'm
gonna
switch
to
a
demo.
So
what
I'm,
I'm
gonna
go
in
a
while
side
here,
I'm
gonna
start
with
where
a
simplistic
PMO
from
the
command
line
immediately
and
I'm.
Actually
gonna
start
from
the
empty
demo
here.
So
what
I'm
gonna
do
is
I'm
gonna
start
and
generate
a
new
product
and
in
Quercus
that
is
an
easy
as
a
as
actually
executing
the
maven
plug-in
with
tasks
called
crate.
When
you
do
that,
you
get
a
couple
of
questions,
and
so
we
just
kind
of
group
idea.
A
You
want
to
use
artifact
ID
the
version
number,
the
many
cost.
If
you
want
to
create
a
rest
resource
from
the
beginning,
so
let's
do
that
and
what
the
rest
resources
name
would
be
and
its
resource
part
that
you
respond
to.
So
let's,
let's
do
that.
But
now
we
have
an
application
and
I
can
open
the
application.
In
a
code
editor
like
like
Visual
Studio
code,
for
example,
or
IntelliJ,
we
you
can
support
any
any
idea.
That's
that
basically
support
that
understands
Java
or
Gradle,
and
a
maven
or
Gradle
Angela
I
should
say
so.
A
Let's
open
this
particular
applications
that
be
I'm
gonna
try
to
put
the
come
on
line
in
the
in
my
eye
and
I
actually
should
probably
you
won't
do
that
again.
Let's
try
this
again.
I
did
put
an
extra
code
in
there
and,
let's
the
top
teams-
let's
do
this
again,
so
I'm
gonna
use
just
for
the
case
in
this
DM
I'm
gonna
use
Visual
Studio
code.
C
A
As
I
mentioned
use
the
one
you
prefer
so
now
you
can
see
that
I
have
my
job
application.
Configured
I
have
a
whole
file
with
some
basic
settings
around
some
basic
dependencies
that
we
need
to
do
the
rest
of
occasion
that
I
asked
them
austin.
She
generates
and
I
got
this
hello
resource
defined
here.
So
one
of
the
things
I
can
do,
which
is
pretty
nice,
is
that
I
can
I
can
quickly
start
this
application,
so
I'm
gonna,
open
and.
A
A
And
the
application
is
now
started
and
listening
on
port
8080,
if
I
go
here,
you
can
see
it
should
listen
respond
to
the
pot
hello
here.
So
let's
try
that
out
so
I'm
gonna
use.
Let's
do
this.
You
can
see
this
I'm
gonna
do
I'm
gonna
use,
HD,
PI
F
is
called
and
I'm
gonna
call
8080,
slash
hello
when
I
do
that,
I
get
a
response
back,
saying
hello,
that
that
was
easy.
But
what,
if
I
want
to
change
that?
A
Well,
let's
exchange
something
else
a
little
tune
here
and
let's,
let's
save
that
file
awesome,
that's
important,
so
you
can
see
that
whenever
I
have
these
dot
up
here,
it's
not
stained
so
I'll
say
that
far
and
then
I
hit
the
same
endpoints
and
immediately
these
changes
are
reflected.
So
that's
pretty
nice.
What
about
doing
something
more
advanced?
Let's,
let's
say
we
actually
introduced
the
message.
A
It
has
the
name
demo
message
and
we'll
store
that
in
string
old
message
now
what
I
can
do
is
I
can
return
like
this
as
a
message
and
it
will
return
a
message
for
me.
So
let's
check
and
see
if
we
can
get
get
Bonjour
or
if
we
get
hello,
we
get
Bonjour
now.
So
that's
pretty
impressive
and
pretty
pretty
nice.
So
what
I'm
gonna
do
now
is
I'm
gonna
extend
this
even
more
I'm
gonna
try
to
do
more.
Most
example
when
I'm
gonna
create
a
web
sockets
to
do
that.
A
I
actually
need
to
add
a
couple
of
more
entries
in
here.
So
what
I'm
gonna
do
I'm
gonna
stop
my
live,
reload,
I'm
gonna
add
a
couple
of
dependencies
in
here
and
again
there
let's
go
to
the
grid
again.
The
Quercus
plug-in
provides
us
with
a
good
feature
here.
We
can
list
the
available
extensions.
That
is
part
of
the
corpus,
and
you
can
see
we
have
a
number
of
extensions
here
already,
and
this
is
growing
all
the
time,
but
we
can
we're
gonna
go
in
and
we're
gonna
add
a
couple
of
extensions
here.
A
I
need
I
need
multiple
extensions
here,
so
I'm
gonna
do
maven
workers
and
I'm
gonna,
say
and
extension
and
I'm
gonna,
say
reactive
stream.
Scheduler,
yes,
I
need
that
I'm.
Actually
gonna
use
the
vertex
to
get
some
reactive
parts
in
here
and
I.
Think
I
gonna
need
one
more.
Is
it
yes,
I'm
gonna
do
the
WebSockets.
A
A
A
What
I
probably
wonder
if
it
hasn't
really
read
my
maiden
yet?
Oh
here
we
go
server
endpoints
and
it's
going
to
respond
to
slash
des
and
I'm
also
gonna
set
application,
scoped
and
annotation
on
this
application
itself
from
there
we're
now
ready
to
to
create
a
WebSocket
application.
So
I'm
gonna
copy
and
paste
some
code
in
here,
because
it's
boring
watching
you
type,
but
basically
what
this
is
and
let's
see,
if
I
can
organize
the
input.
A
What,
if
what
we
do
here
is
we
when
somebody
connects
the
WebSockets?
We
basically
just
add
it
to
this
vector
and
if
somebody
closes
we're
gonna,
remove
it
from
this
vector
and
when
some
when
we
want
to
broadcast
a
message,
we
can
use
this
method
that
it's
going
to
call
session
and
and
for
each
four
sessions
and
for
each
element
in
that
vector.
It's
gonna,
get
the
indistinct
remote
and
send
that
particular
message
to
the
client.
So
that's
that's
pretty.
A
A
A
A
So
we're
gonna,
connect
like
this
and
I
should
be
seeing
a
server-side
event
every
other
second
here,
I'm
being
pushed
from
the
client
from
the
server
out
to
the
client
using
WebSockets
here.
So
it's
pretty
easy.
But
what,
if
you
want
to
do
something
more
reactive,
let's
say
we're
listening
to
stream
of
events
coming
from
a
message
broker
and
you
want
to
convert
a
limit
and
then
send
it
out
to
the
client,
maybe
recalculate
something
etc.
Well,
that's
pretty
simple
as
well!
A
So
let's,
let's
actually
remove
this
scheduler,
and
even
if
I
save
this
it's
it's
not
only
it
actually
stopped.
It
hasn't
stopped.
But
if
I
now
run
the
way
of
Socrates,
it's
not
now
not
starting
because
I
haven't
scheduled
any
more.
So
what
I'm
gonna
do
here
is
I'm
gonna
inject,
what's
called
and
what's
call
our
event.
A
Bus
I'm
gonna
go
back
up
here
and
we're
gonna
stay
in
here
and
say
inject
and
we're
gonna
say
event
bus
from
the
vertex
pour
here
so
now
what
I
can
do
and
it's
organized
their
inputs
and
now
I'm
going
to
create
a
post
constructor
to
this.
That
actually
could
connect
to
that
particular
event,
bus
and
and
and
it's
going
to
listen
for
a
cue
on
that
event.
Bus
called
vias
clients
and
then
assume
listen.
Trees
receive
the
message.
A
A
And
you
import
the
air,
perfect
school
event,
us
and
then
I'm
gonna
put
the
scheduler
in
here
in
this
class,
just
to
show
that
it's
a
different
class
running
here
and
in
this
scheduler,
and
we
are
in
this
time
we
can
actually
gonna
use
the
same
event.
Bus
named
vias
clients
and
we
gonna
send
server,
sent
events
and
they
say
act
and
their
actual
dates
that
we're
gonna
send
that
I
need
to
import
to
date
as
well.
Now
we
should
be
done
so
again,
I
happen.
I
accidentally
closed,
my
my.
A
A
C
A
A
A
It's
typical
demo,
so
I
probably
made
a
mistake
somewhere
here,
and
you
know
it's
gonna
time
to
look
at
it
right
now.
But
let's
see
if
I
can
solve
that
later,
we
need
some
talks,
but
basically
this
would
then
send
the
messages
that
we'd
get
on
the
event
bus
and
return
it
to
the
through
their
water
to
the
client
again
just
every
other.
A
I
could
do
the
native
compilation
when
it
takes
about
one
to
two
minutes
and
I
want
to
sit
away
from
one
two
minutes.
So
I
have
the
native
application
in
here,
as
well
as
a
java
application.
So
we
can
start
the
same
application
server.
We
could
start
by
using
Java
you're
the
same
application
target,
and
then
we
will
do
my
focus
project
run
or
not.
A
You
are,
and
if
I
do
that
it,
it
comes
up
and
running
in
about
1.3
seconds
and
it's
up
and
running
and
if
I
do
get
the
correct
key
here
if
I
do
web
so
count
here
should
be
able
to
see
server
events
and
message
here
so
every
other.
Second,
it
sends
the
server's
up
message,
so
it
works
here.
I
can
also
do
obviously
the
HTTP
hello
and
we
get
Bonjour
here.
A
So
that
was
pretty
fast,
but
actually,
let's,
let's
see
what
see
what
a
native
a
runner
looks
like
so
I
summoned
again
in
the
target
directory
I
have
my
version
of
this
and
you
notice
that
this
one
doesn't
have
a
job
ending,
it's
basically
a
binary.
The
native
applications
I'm
running
this
outside
is
a
it
doesn't
run
in
Saudi
GBM,
so
I
don't
have
to
issue
jar.
A
Java
you're
come
on
so
we'll
start
that,
and
you
justly
know
that
I
was
very,
very
quick
and
started
in
nineteen
milliseconds
and
let's
test
the
same
thing
so
I
can
do
that
hello,
I
can
do
sorry.
I
did
the
wrong
I
can
do
the
web,
so
cats
here
and
I
get
server,
sent
events
message,
services,
messages,
don't
and
that's
that's
pretty
pretty
non
fast,
90,
milliseconds
and
you're
up
and
running
with
a
full
application,
my
desk
and
and
and
using
pretty
advanced
stuff.
A
So
what's
the
value
of
this
and
why?
Why
is
this
so
important?
Well,
if
you
look
at
the
container
registration
application,
let
it
constrain
registration
on
the
state
on
two
nodes
that
are
similarly
sized
when
you
were
typically
perhaps
only
run
like
four
instances
of
a
cloud
native
Java
stack
with
Quercus,
you
can
run
the
same
application
and
you
will
fit
ten
times
more
in
this
case
forty
instances
on
the
same
node
so
that
obviously
it's
much
better
for
scaling.
A
So
if
you
have
different
application
or
like
a
micro
service,
where
you
have
multiple
different
types
of
applications,
we
can
have
different
might
talked
about
vacations,
deploy
here
and
depending
on
need.
We
can
scale
up
automatically
scale
up
and
scale
down
to
meet
the
number
of
requests
that
that
is
required.
So
if
one
of
our
services
are
more
running
more
heavily,
you
want
CPU
bound
at
such
a
something
like
that.
We
can
automatically
scale
that
up
quicker.
A
It
will
start
very
quickly
and
they
scale
that
up
and-
and
you
have
the
opportunity
to
do
that,
because
you
have
much
more
space
to
do
that
in
the
note,
and-
and
this
will
also,
if
you
go
to
a
public
cloud
provider-
this
video
so
to
save
money,
because
you
don't
need
the
number
of
notes.
So
many
notes
anymore.
So
it
will
save
you
a
lot
of
hosting
costs
in
that.
B
Sure
thanks,
so
one
of
the
things
that
I
think
is
worth
thinking
about
is
when
you
look
at
the
way
Java
is
today
which,
which
Tomas
you
mentioned
earlier
in
the
slides
that
Java
itself
was
really
designed
around
the
notion
of
having
this
very
dynamic
infrastructure
and
platform
and
was
focused
on
optimizing
heavily
for
through
pen
and
usually
the
deployment
model
involved.
You
know
you
would
deploy
to
a
physical
server
and
it
would
consume
the
resources
to
provide
that
maximum
throughput
possible.
B
So
when
you
would
look
at
things
like
language
scores
down
boys,
that's
great
and
of
course,
another
thing
that
developers
really
liked
about
Java
was
with
the
the
dynamic
capabilities
of
the
platform.
Where
anything
could
change.
You
know,
as
far
as
like
using
reflection,
dynamic
code
loading
all
that
type
of
stuff
in
in
using
those
capabilities.
B
Server
and
containers
are
these
these
immutable
constructs,
and
so
you
have
all
this
capabilities
in
the
base
JVM,
which
are
not
really
getting
used,
because
when
you
go
and
you
actually,
you
start
your
java
application,
all
that
work
for
self
introspection
and
analysis
and
the
ability
to
support
loading
the
code.
All
of
that
stuff
is
not
really
necessary,
because
the
end
result
is
always
going
to
be
the
same.
It's
always
going
to
be
the
exact
same
application
being
started.
B
So
what
we
did
is
we
took
a
look
at
at
evolving
the
architecture
to
be
more
in
more
in
line
with
what
is
happening
in
from
the
kubernetes
point
of
view.
So
if
you
look
at
Java
itself
and
think
of
things
as
well,
if
I
can
prepare
everything
in
advance,
then
I
can
have
the
same
capabilities.
I
don't
have
to
give
up
my
api's
and
the
ecosystem
that
I
love
and
I
can
still
get
really
nice
performance,
really
nice
footprint
scale
up
with
density
and
so
on.
B
B
So
if
you
look
at
go
to
the
next
next
slide
that
this
is
made
possible,
as
recently
in
last
year,
a
new
project
in
the
Java
ecosystem,
dravyam
was
released,
and
this
this
project
is
that
it's
a
fairly
overloaded
project
and
it
provides
a
different
set
of
capabilities.
It's
essentially
has
inside
of
it
a
a
VM
that
is
designed
for
standalone
executables,
but
it
also
has
has
other
capabilities
as
well.
B
So
if
we,
if
we
look
into
that
a
little
bit
further,
if
you
go
looking
at
the
next
slide,
there's
there's
a
different
set
of
pieces.
So
you
have
the
notion
of
the
polyglot
capabilities
with
the
truffle
element.
You
have
the
notion
of
a
a
new
compiler
for
translating
Java
bytecode
into
into
machine
code.
Just
in
time,
machine
comes
look
at
the
growl
compiler
and
that's
something
that
you
may
see
other
projects
they
talked
about
using
Gras.
They
could
be
referring
to
different
aspects,
and
it's
not
always
clear.
B
So
you
kind
of
look
at
the
details
a
little
bit,
but
in
the
case
of
how
we're
using
it
we're
the
most
we're
most
interested
in
that
in
that
native
runtime,
which
is
internally
called
substrate,
although
in
community
will
see
referred
to
frequently
as
Gras
VM
native
images.
So
the
thing
that's
interesting
about
this
technology
is
that
it
compiles
the
kay
and
your
actual
Java
code
into
a
native
executable
that
only
composes
what
the
act
it
does
things
like
closed
world
analysis
to
where
it
only
contains
the
actual
elements
of
your
program
that
you're
using.
B
B
However,
the
challenge
is
that
this
technology
works
and
in
any
kind
of
static
compilation
works
only
when
you're
able
to
reason
about
what
is
actually
used
in
the
application
or
not.
So
all
these
really
fancy
dynamic
capabilities
that
have
been
in
Java
frameworks
that
allow
you
to
do
things
like
when
you
saw
Thomas
working
in
a
demo.
There's
all
these
annotations
around
that
that
have
inversion
of
control,
so
there's
decoupling
between
components
and
typically,
that
would
be
resolved
later
runtime
as
to
if
I
inject
an
object
into
another
object.
B
That's
not
it's
not
clear
what
job
because
being
injected
when,
until
it
runtime
based
off
of
a
set
of
rules
that
happens
so
this
is
it
really
useful
for
something
that
does
static
compilation,
and
so
that
makes
using
a
technology
like
this
is
very
difficult
for
Java
applications
where
essentially,
you
have
to
give
up
on
these
rich
programming
models
that
developers
have
loved
in
use
today.
So
looking
at
the
next
slide,
this
is
the
key
problem.
Is
that
if
you
develop
a
java
application
using
this
technology
directly,
it's
a
pretty
painful
experience.
B
So
what
Korkis
is
really
all
about
is
essentially
giving
you
the
same
exact
experience
that
you
would
have
in
a
dynamic
java,
runtime
environment,
but
giving
it
giving
it
in
a
way
to
you
that
you
can
use
it
in
both
the
native
executables
and
running
on
open
JDK
efficiently,
and
so
talk
a
little
bit
more
about
that.
It's
it's
useful
to
look
at
that
the
actual
process
so
on
the
next
slide,
we're
looking
at
the
phases
of
how
Quercus
works.
Actually
can
you
skip
to
the
next
one
and
we'll
go
back?
B
So
what
Korkis
does
is
it
takes
your
application
and
it
determines
all
the
frameworks
that
are
currently
being
used
and
it
augments
them
via
byte
code
transformation,
code,
analysis
and
it
converts
and
resolves
things
such
as
if
I
have,
if
I'm
using
injection
between
two
two
objects,
it's
able
to
resolve
what
that
result
would
be
and
then
change
the
code
to
produce
something
that
is
friendly
to
a
static
compiler.
So,
instead
of
saying,
you
know,
add
inject
foo
that
gets
changed
into
a
direct.
B
You
know
set
this
object
to
be
foo,
and
then
from
that
we
what
we
end
up
with
is
we
end
up
with?
All
of
this
start
up
processing
gone
and
instead
we
end
up
with
a
optimized
executable
in
the
native
fashion
and
then
on
Java
and
we're
running
a
traditional
JDK.
We
also
get
faster
Java
performance
because
there's
less
code
being
loaded
than
less
code
being
executed.
Another
thing
that
we
do
in
quark
is
we.
B
We
actually
persist
the
state
of
heap
to
have
really
amazing
startup
times,
so
we
we
take
advantage
of
certain
capabilities
as
part
of
native
compilation
and
we
take
tasks
that
normally
would
be
performed
when
you're
when
your
system
starts,
and
then
we
actually
build
that
the
in
resulting
memory
state.
So
we
capture
the
memory
straight
so
so
frameworks
that
were
that
were
developed
for
a
runtime
model.
Now
can't
have
the
performance
without
a
drastic
amount
of
change
to
it
in
a
native
execution
model.
So
of
course,
there's
other
optimizations.
We
have
to
do
so.
C
B
Is
a
set
of
things
in
order
to
function
in
this
environment
that
so
anything
that
uses
introspection
has
to
be
handled
in
other
ways.
Anything
which
uses
dependencies
has
to
be
rethought,
because
when
you
run
in
when
you
run
in
a
in
a
trim,
limited
environment,
the
goal
is
to
remove
anything
that
you
might
use
to
determine
what
state
would
run
from
the
process
of
what's
actually
being
executed,
and
then
we
also
want
to
be
very
friendly
for
an
ecosystem.
B
So
we
have
this
notion
of
different
levels
of
authorization,
so
you
have
some
frameworks
that
could
get
incorporated
that
are
based
off
that
are
that
have
very
little
change
at
all
and
in
other
cases
we
would
take
frameworks
that
we
that
we've
worked
on
and
really
optimize
them,
for
this
particular
use
case.
So,
and
this
kind
of
all
builds
up
to
the
architecture
we
have.
B
So
if
we
skip
to
the
architecture
slide,
what
we
end
up
with
is
a
set
of
extensions
which
you
saw
when
Thomas
is
using
the
command
line,
where
you
take
what
extension
you're
using
so
each
frame
work
that
gets
integrated.
You
use
an
extension
for
that
and
then
we
have
a
base
common
core
platform
and
a
whole
set
of
technologies
that
we've
developed
that
are
designed
around
building
these
optimal
images
and
optimal
standalone
java
jar
assemblies
and
so
with
this
technology.
Our
argument
is
skipping
ahead
again
to
the
next
slide.
B
Is
that
using
Korkis
that
you
can
have
a
cloud
native
experience
which
is
optimal
for
both
server
lists
and
container
environments?
And
this
really
changes
the
way
in
which
a
developer
interacts
with
java
c,
you
don't
have
to
switch
technologies
to
and
and
and
start
all
over
and
and
do
something
totally
different
and
lose
the
ecosystem
that
you
have.
You
can
carry
that
forward
and
still
produce
really
lightweight
applications
that
are
that
are
see.
A
A
A
So,
there's
there's
some
pretty
good
guides
in
here
and
we're
working
on
extending
everything
here
as
quickly
as
we
can.
But
there's
there's
a
lot
of
a
lot
of
things
that
we
have
to
do
for
improving
this,
and
we
should
mention
that
this
is.
This
is
still
an
early
version.
Your
own
version
0
12
0,
but
it's
pretty
stable
at
this
point,
but
but
we
would
not
recommend
putting
it
in
production
at
this
point
and
we
will
we
will
in
a
reasonable
time,
release
one
but
Overson
of
this.
So
that's
that's
how
you
get
started.
A
C
Think
a
very
good
job
of
answering
most
of
these
questions
that
I
that
I
sort
of
have
any
any
new
project
to
is
you
know
how
do
people
get
feedback
to
you
and
how
did
you
know
where
can
they
contribute
to
your
project
and
so
maybe
pop
over
to
github
to
the
corpus,
IO
repo
and
show
them
where
they
can
log
an
issue
or
something
that
would
be
great
and
and
in
weather?
What
are
some
of
your
agencies
for
releases
on
this.
A
Yes,
I
think
you
some
less
responded
to
someone
adding
this
chat,
but,
yes,
we
have
a
get
our
product
on
github
that
Collin's
lack
workers
I
also
feel
free
to
open
issues
there.
If
you
have
any
issues
running
Quercus
and
submissions,
we
are
on
a
bi-weekly
cadence
and
not
a
strict
one,
but
we
try
to
release
every
every
other
week
and
adding
more
and
more
capabilities
and
features
to
Corpus.
C
Jason,
do
you
have
anything
else
that
you
want
to
add
to
today's
top
reciate
you
guys
coming
this?
Is
you
know
it's
all
very
new
to
me
and
it's
awesome
to
see
java
boat
clouds
native,
so
I'm
really
pleased
and
welcome
you
gotta
come
back
each
time
you
have
a
new
release
and
tell
us
a
little
bit
more.
If
there's
anything
else,
you
want
to
add
I
just.
B
Want
to
say
that
we're
definitely
looking
for
feedback
on
your
experience,
so
if
you
guys
try
out
the
technology,
let
us
know
what
you
think.
We
definitely
love
to
hear.
That
is
you
guys
just
talked
about
contribution,
so
cut
any
sort
of
community
contribution,
prz
filing
issues,
anything
like
that
really
helpful
and
really
appreciate
it.
We
we
view
this
as
a
really
exciting
opportunity
to
to
make
Java
and
kubernetes
work
incredibly
well
together.
So
your
involvement
in
that
community
is
is
very
much
a
part
of
that.
C
A
C
C
As
this
comes
up
not
seeing
any
other
questions
in
the
chat,
so
I'm
gonna,
let
you
go
and
then,
if
you
can
just
send
me
the
slides,
I'll
post
this
on
our
YouTube
channel
and
on
the
blog
that
is
under
openshift
comm
in
the
next
couple
of
days,
and
we
look
forward
to
again
hearing
more
from
you
soon.
Thank.