►
From YouTube: Quarkus - Supersonic Subatomic Java
Description
Dive into the next generation cloud native framework for running Java in microservice oriented cloud platforms. Quarkus focuses on developers and ease of use in modern serverless environments.
It is a Kubernetes Native Java framework tailored for GraalVM and HotSpot, crafted from best-of-breed Java libraries and standards.
A hands on overview of the Quarkus cloud native framework, what it brings to the Java ecosystem and what new concepts and design guidelines it introduces.
Demo presenting Quarkus with focus on:
- Developer joy
- Memory footprint and performance
- Reactive and imperative paradigms
- Libraries and standards
The attendances should have programming experiences with Java and some knowledge around Enterprise Java runtimes and frameworks.
The attendances will get an overview of Enterprise Java challenges in Serverless and Cloud environments and how Quarkus rises up to those challenges. The developer experience that Quarkus provides and various run modes.
Speaker(s):
Anamarija Talijanac (IBM)
A
So
also,
it
enables
like
two
projects
like
using
reactive
or
imperative
paradigm,
so
we
have
full
support
for
event,
driven
architectures
and
reactive
streams
and
reactive
messaging,
and
things
like
that.
It's
not
that
quark
is
restricted
to
such
to
such
type
of
application
environments.
You
can
write
monolithic
applications,
traditional
enterprise
applications,
it's
just
that
the
focus
and
roadmap
of
qarcus
is
designed
around
these
types
of
environments.
A
So
quarkus
is
a
container
first
platform.
Its
main
goal
is
around
low
memory,
footprint
and
low
memory
usage,
but
also
it
brings
up
fast,
startup
time,
boot
up
time,
first
time
to
serve,
which
is
an
ideal
case
for
the
kubernetes
environment,
for
the
cloud
environment
at
all,
because
when
you
have
cloud
environments,
you're
restricted
with
resources
and
if
your
application
is
using
less
memory
and
less
cpu,
that's
that's
a
good
thing,
because
you
can
run
more
containers,
mod,
pods
ins,
with
the
same
memory
as
you
can
with
some
other
java
stack.
A
Another
thing
is
also
the
cloud
migration
from
a
monolithic,
traditional
enterprise,
application
to
a
microservice
application.
So,
like
decoupling,
your
application
into
smaller
pieces
and
also
there's
the
serverless
serverless
case
where
we
want
to
have
called
fast
called
starts
of
our
application,
where
we
basically
are
paying
based
on
the
usage
of
the
time
that
we
use
our
function.
A
So
if
we
look
at
the
evolution
of
java
enterprise
tech,
we
have
here
on
the
left
side,
a
traditional
java
stack,
so
we're
basically
running
on
top
of
an
virtual
machine
or
or
a
hardware
machine
where
we
have
traditional
java
enterprise
application
servers,
that's
run
on
top
of
a
java
virtual
machine
and
that
java
realtor
machine
is
actually
optimized
to
enable
features
inside
the
application.
Server
like
like
using
usage
of
threads
dynamic,
dynamic,
proxies
and
dynamic
behavior
overall,
which
gives
a
lot
of
weight
to
our
whole
setup.
A
Also,
on
top
of
that,
we
often
have
libraries
so
different
application
frameworks
that
also
use
these
kind
of
dynamic
features
and
add
extra
weight.
On
top
of
all
of
that,
which
is
traditionally
a
good
thing,
because
such
libraries
and
application
server
apis
enable
us
to
write
faster
to
speed
up
our
development,
it
has
a
lot
of
stuff
for
us
that
we
usually
would
do
for
ourselves,
and
on
top
of
that,
we
all
we
all,
should
we
often
have
a
multi-application
setup
where
multiple
applications
are
running
inside
that
application
server
and
sharing
the
same
resources.
A
So,
moving
now
more
into
this
microservice
world,
we
have
more
cloud
native
stacks
where
it's
more
lightweight.
We
have
a
java
virtual
machine,
often
on
top
of
which
we
build
different
libraries
and
frameworks
that
are
more
lightweight
so
compared
to
the
traditional
stack
and
we
have
a
single
app.
So
we
have
like
a
closed
world
principle
with
an
environment.
That's
basically
immutable.
It's
not
changing
and
quarkus
on
that
hand,
takes
advantage
advantage
of
such
things.
So
basically
it
says:
okay,
this
is
an
environment
that
won't
change.
This
is
a
closed
world.
B
A
Yeah,
so
I
was
talking
about
this
mainly
so
quarkus
has
these
two
types
of
runtime
modes,
so
it
has
this
native
mode
and
non-native
mode.
So
when
we
talk
about
a
non-native
mode,
we
have
a
java
classic
jar
that
runs
on
top
of
a
java
virtual
machine
like
open,
j9
or
hotspot
or
open,
jdk
or
whatsoever,
but
even
in
this
non-native
mode,
quarkx
does
a
lot
of
optimization
on
top
of
our
application,
to
make
it
more
performant
and
more
optimized
for
the
cloud
environment.
A
So
basically
what
it
does
it
this
native
image
within
it
also
has
a
jvm,
but
it's
like
a
subset
of
the
original
jvm,
with
just
features
that
our
application
needs.
It's
also
optimized
in
the
means
that
it
does
a
lot
of
that
code,
elimination
and
it
throws
out
basically
all
the
things
that
we
don't
need,
which
is,
of
course,
a
good
thing,
and
that
way
we
are
getting
at
the
end,
an
executable
that
has
a
really
low
memory
footprint
and
enables
all
to
have
a
fast
start
up
time.
A
So
here
is
here,
is
a
slide
about
some
performance
diagrams
around
native
quartus
qualification
mode
in
non-native
mode
and
a
traditional
integrational
java
stack.
So
basically,
what
we
can
see
here,
we
can
get
a
boost
in
in
our
performance,
so
like
have
an
application,
that's
10
times
smaller
than
a
traditional
java
enterprise
application
and,
on
the
other
hand,
get
a
performance
in
like
first
response
time.
That's
like
100
times
faster.
A
A
So
what
is
grow
vm
raw
vm
is
a
java
development
kit
that
enables
you
to
run
really
efficient
java
code.
So
it's
basically
enables
you
to
run
java
or
other
blank
java
link,
jvm
compliant
languages
like
scala
or
kotlin,
but
also
dynamic
languages
like
javascript,
r
and
c
c,
plus
plus,
and
it
has
a
lot
of
aspects
like
it-
has
polyglot
support.
It.
Has
this
native
image
compilation
support
which
quarkus
uses
so
basically,
these
red
boxes
are
the
main
thing
for
for
quarkx.
A
So,
for
example,
if
we
took
a
library
like
hibernate
hibernate
has
a
lot
of
hibernate
has
a
lot
of
support
for
different
databases
like
oracle
or
db2
or
other,
but
inside
your
application,
for
example,
you're
just
using
h2.
So
you
really
don't
need
all
of
these
other
supports.
So
what
it
does
actually
throws
out
everything
that
you
really
don't
need,
but
it
has
a
lot
of
constraints
like
for
raw
vm,
dynamic
language
features
are
a
problem.
Reflections
are
a
problem,
so
what
quarkus
does
it
basically
prepares?
A
It
prepares
your
application
for
raw
vm
native
image
compilation,
so
it
gives
all
the
instructions
to
the
compile
the
raw
vm
compiler.
What
what?
What
are
actually
the
reflections
that
you're
using
registering
it?
What
are
the
configurations
that
you're
using
so
it
knows
about
them
so
that
during
native
image
compilation,
it
can
optimize
your
application
efficiency.
A
A
That
gives
you
extra
boost
as
a
develop
boost
as
a
developer,
so
like
it
has
this
thing
called
dev
mode,
which
I
will
show
you
later
on,
but
it
also
has
like,
for
example,
there's
a
lot
of
effort
in
writing.
Nice
error
handlings,
like
getting
nice
exceptions
that
are
descriptive
enough
to
point
you
into
the
right
direction.
A
A
It's
built
on
top
of
well-known
common
libraries.
So,
as
you
can
see
here,
here
are
some
of
them.
It
defines
these
calls
called
extensions.
So
what
it
is?
It's
basically
a
pre-optimized
version
of
those
libraries
that
you
see
here
like
pre-optimized,
in
a
way
that
everything
is
prepared
for
those
libraries
to
be
plugged
in
into
the
native
image
compiler
and
into
the
quarkus
build
processor,
so
basically
defining
if
it
also
has
a
thing
around
configuration.
A
So
if
it
uses
this
zero
config,
which
basically
tells
you
that
it
tries
to
put
all
of
the
configuration
into
one
place,
making
it
easier
for
you
as
developer.
So
looking
at
these
extensions,
it
basically
will
define
configuration
items
for
each
of
them.
That
can
be
that
are
specific
for
each
extensions.
For
for
each
library,
for
example,
for
data
source,
it
will
define
all
the
needed
parameters
that
you
can
successfully
successfully
make
a
database
connection,
but
all
in
the
same
place,
together
with
other
configurations,
qarques
implements
the
micro
profile
specifications.
A
So
this
is
like
this
is
showing
you
how
the
quarkus
build
process
actually
looks
like
so
basically,
quarkus
takes
your
application
and
tries
to
move
as
much
as
things
from
the
runtime
to
the
build
time.
So
during
your
maven
or
gradle
build
it.
Basically,
there
there's
a
phase
within
the
maven,
build
lifecycle
that
quarkus
pulls
in
and
basically
gets
a
view
of
your
whole
application.
A
It
analyzes
your
and
analyzes
your
classes,
it
does
annotation
lookup.
It
basically
tries
to
do
everything
during
builds
time
to
optimize
your
application,
so
like
that
code,
elimination
throughout
things
that
aren't
really
necessary,
but
not
only
at
your
application
level,
but
also
at
the
library
level.
A
So
now
we're
going
to
do
a
little
demo
around
this.
So
since
we
don't
having
a
lot
of
time,
I
actually
prepared
some
sample
applications
more
focusing
on
the
microprofile
microprofile
side
of
quarkx,
so
one
to
first.
The
first
thing
I
want
to
show
you
is
so
the
extension
part.
So
actually,
when
you
start
developing
a
qarcus
application,
a
good
thing
is
maybe
to
start
from
the
code
quarkx
io
page.
So
here
you
can
define
bootstrap
a
simple
creation
of
an
application
with
some
extensions
that
you
want
to
use.
A
For
example,
like
rest
clients,
rest
service
data,
so
basically
hibernate
orm
different
jdbc
driver
like
classic
jdbc
driver
or
reactive
jdbc
drivers.
Also,
it
has
a
lot
of
support
regarding
messaging
microprofile,
reactive,
so
carcass
is
reactive
within
its
core.
It
uses
vertex
and
netty,
but
it
doesn't
enforce
anything
of
that
to
you.
You
can
use
whatever
paradigm
is
easier
for
you.
It
has
a
really
nice
thing
related
to
compatibility.
So
a
lot
of
programmers
are
you
java.
Programmers
are
used
to
use
spring,
so
it
has
this
whole
compatibility
layer
for
spring.
A
So
you
can
basically
take
your
spring
application
and
port
it
into
quarkx
and
it
will
run
basically
so
it
like
speeds
up
the
transition
for
you
to
get
quintet
with
quarkus
and
then
later
on,
maybe
use
the
more
advanced
stuff.
So
we
can.
We
would
first
power
up
this
dev
mode,
so
to
show
you
how
a
development
in
quarkx
would
look
like.
So
the
idea
is
to
basically
to
code
something
and
test
it
right
away.
A
A
It
has
a
simple
rest
controller
yeah
and
I
used
panache
here.
So
again
you
could
use
maybe
spring
data
if
you're
more
used
to
it,
but
panache
is
a
neat
thing
to
to
sp
to
basically
define
entities
and
data
access
objects
around
it,
and
here,
for
example,
we
are
retrieving
a
list
of
accounts.
We
defined
a
database
here
so
like
I'm
using
this
profile,
where
I
have
a
data
source
which
is
described
with
this
url
so
based
on
the
url
quarkus,
will
understand
the
sorry
dev
mode.
A
So
quarkx
will
understand
that
this
is
a
h2
database
that
I'm
using,
and
I
gave
him
some
configurations
like
how
the
data
source
should
look
like
that.
I
want
the
or
the
create
and
drop
feature
of
hibernate
to
be
enabled
and
to
import
some
data.
So
looking
at
the
data,
we
have
some
simple
account,
which
has
a
couple
of
properties
which
we
defined
here.
Of
course.
So
so
looking
here,
quark
is,
is
up.
We
can
go
and
test
our
simple
application
by
swagger
ui,
maybe
whoops.
A
A
A
A
A
A
A
So
it's
based
on
the
again
on
microprofile
and
throughout
this
simple
controller,
this
resource
I
exposed
it
exposed
it,
for
example,
here
for
this,
for
this
endpoint,
so,
okay,
let's
try
it
out.
It's
accounts
and
hello:
oh
close
yeah!
I
think
I
have
swag
okay,
oh
I
didn't
put
it
up.
That's
interesting
also,.
A
A
A
And
I'm
getting
all
of
the
accounts
from
the
other
application.
So
if
we
look
at
the
application
properties,
we
can
see
here
that
I
defined
this
rest
client
using
using
this
configuration.
A
nice
thing
in
the
eclipse
in
the
eclipse,
quarkus
plugin
is
that
it
gives
you
this
autocompletion
regarding
configurations.
A
So
it
kind
of
speed
up
the
process
of
configuring
here.
So
this
that
mode
is
really
neat,
because
you
can
also
use
it
now
in
basically
in
a
remote
way
like
con
connecting
to
an
open
shift
environment,
the
kubernetes
environment,
where
you
can
do
this
dev
mode
on
a
running
container,
which
is
also
nice
and,
for
example.
Here
I
also
did
I
used
a
mini
cube
that
I
have
locally
set
up,
and
I
connected
to
the
ibm
cloud
registry
to
push
my
container
that
it's
defined
to
this
micro
profile
demo.
A
So
you
can
see
the
configuration
here
how
it
is
defined
and
a
good
thing
here
is
that
if
you
just
enable
this
kubernetes
extension,
so
there's
a
lot
of
way
to
a
lot
of
ways
to
add
an
extension.
But
it's
basically
just
adding
something
in
your
pom
xml
and
basically
just
by
adding
this
mini
cube
or
kubernetes
or
openshift
dependency.
Here
this
extension
you,
you
will
have
everything
that
you
need
to
start
deploying
into
a
kubernetes
runtime.
So
what
quarkx
does?
A
Actually
it
generates
all
the
stuff
regarding,
like
the
kubernetes
yamaha
mini,
cube,
ammo
file,
so
services
deployments
it
basically
wraps
everything
up
for
you,
so
that
you
can
have
a
neat
experience
around
this.
Also,
I
used
here
the
docker
builder,
but
there's
other
options
that
you
can
use.
For
example,
one
of
my
actually
favorites
are
is
jib,
so
it
enables
you
to
build
the
docker
image
without
actually
having
a
docker
demon
locally
installed,
which
is
kind
of
nice
yeah.
We
are
think
out
of
time,
so.
A
A
A
Well,
regarding
microprofile
there's
a
spring
so,
for
example,
here
at
the
region
I
work
with.
We
are
having
more
spring
spring
developers,
so
basically
it's
more
in
the
spring
favor.
But
after
what
I
actually
experience
when
people
start
using
quark
is
they
actually
try
to
migrate
to
other
stuff,
mostly
the
reactive
stuff?
I
don't
know
why,
but
it's
like
everything.
Everyone
needs
reactive
things
today,
quercus
with
groovy,
I'm
not
aware
of
that.