►
Description
Jakarta EE 10 offers a new, smaller runtime profile that is targeted to microservices and ahead-of-time compilation. We have a look at the reasoning behind this new profile and the use cases where it can be useful.
We will go into more detail about the changes that are introduced, mainly within CDI to support the goals and explore them using various demos with runtimes that support this new profile.
And lastly, we will have a look at the planned features as this release is only the beginning of this new chapter of Jakarta EE.
-
Jakarta EE gives developers a comprehensive set of vendor-neutral, open specifications that are used for developing modern, cloud native Java applications from the ground up. With Jakarta EE, technology developers and consumers can be confident they have the best technologies for developing cloud native, mission-critical applications. And they can build on decades of Java developer expertise to move existing workloads to the cloud.
Learn more: https://jakarta.ee/
Follow us on Twitter: https://twitter.com/home
Follow us on LinkedIn: https://www.linkedin.com/showcase/jakartaee/
Like us on Facebook: https://www.facebook.com/JakartaEE/
A
A
So
because
that's
an
interesting
one
and
you
will
see
you
can
use
it
to
run
your
application
in
an
entirely
new
way,
which
is
very
nice
and
then
I'll
talk
a
bit
about
modularity
and
then
the
runtimes
that
you
can
use
today
about
for
that
core
profile
or
resistance.
And
if
you
might
have
questions,
please
put
them
in
the
chat.
I
will
answer
them
at
the
end
of
the
presentation.
A
But
first
let's
have
a
discussion
about
why
there
was
a
need
for
that
new
profile
and
what
are
the
typical
use
cases
if
we
look
at
the
evolution
of
java
ee?
Well,
it
starts
with
j2ee
actually
in
1999,
then
that
first
release
contains
around
9
or
10
specifications
that
are
mainly
servlets
at
in
the
gsps
agbs
and
the
remote
method
communication
and
the
messaging
Support
over
time
that
crew
things
were
added
which
were
useful
on
top
of
those
basic
sets
of
specifications.
A
World
change,
that's
where
an
annotations
came
in,
for
instance,
with
Java,
e5s,
mid
CSF
and
jpa
for
database
access,
etc,
etc.
So
in
2009
there
was
already
quite
a
lot
of
space.
Specifications
have
with
the
addition
of
Jack,
Saras
and
CDI
so,
and
it
became
clear
that
not
everyone
needed
all
the
specifications
for
each
application.
There
were
two
large
group
HTTP
based
applications
and
others
where
you
can
use
like
soap
and
remote
calls
Etc.
A
So
then
there
was
a
decision
at
the
first
time
to
make
a
split
for
that
web
profile
so
that
you
have
a
subset
of
all
the
specifications
and
that
you
can
have
a
product.
A
runtime
which
only
offers
that
web
profile
time
runs
by
again
and
we
have
then
Java
ee8.
They
moved
to
Jakarta
The,
Cliffs
foundation
and
the
addition
of
micro
profile
to
cover
for
that
period,
where
there
was
no
opportunity
to
change
those
Java
ee
code
base.
A
So
now
we
are
in
2022
and
we
are
again
at
the
point
where
we
see
that
that
web
profile
should
have
been
splitter
into
different
profile
profiles,
so
a
subset
of
web
profile,
which
is
geared
towards
a
certain
set
of
applications.
So
that's
the
reason
why
we
have
core
profile
now,
because
if
you
see,
for
example,
at
the
micro
profile
specification,
a
this
is
based
on
several
of
the
Jakarta
ones,
the
CDI,
the
rest
ones
and
the
Json
mainly,
and
then
on
top
of
them,
the
micro
performance.
A
So
it
was
a
bit
of
a
different
or
a
difficult
relationship
with
with
web
profile.
It
was
not
easy
to
have
certification
for
micro
profile,
for
example,
because
there
were
no
individual
tests
only
for
the
web
profile
as
a
whole.
So
that's
one
of
the
reasons
why
there
is
now
that
core
profile,
which
is
a
subset
of
the
profile
which
covers
those
specifications
of
the
specifications
that
are
used
within
micro
profile,
so
that
it
can
clearly
be
based
on
something
nicely
aligned.
A
A
A
It
was
a
good
idea
to
also
remove
the
deprecated
Clauses
and
methods
which
were
there
already
for
a
long
time
within
Java
EE,
and
then
we
have
now
again
a
good
basis,
a
bit
to
check
out
the
E10
to
get
started
again.
Now
that
everything
is
cleaned
up
a
bit,
and
you
see
there
on
the
right
that
those
the
column
in
the
right
is
actually
make
up
that
core
profile
specifications.
A
It's
mentioned
that
there
are
CDL
light,
is
a
separate
one,
but
that's
actually
not
true.
So
let's
have
a
look
later
and
more
between
the
relation
between
CDR
light
and
CDI,
because
that
can
be
a
bit
confusing
in
the
beginning,
so
that
subset
then
became
core
profile.
Now
it's
got
a
E10
and
yeah.
As
mentioned.
You
see
there,
the
the
specifications
which
are
using
for
those
typical
rest
applications,
taxes,
3.1.
A
You
have
that
dependency,
injection
and
CDR
light,
and
then
you
have
the
Json,
processing
and
binding
ones.
Few
others
like
annotations
and
interceptors
and
expressing
language
which
I
come
to
that
in
a
moment.
First,
is
there
not
missing?
Maybe
you
stink
well,
where
is
servant,
because
you
need
to
accept
requests
from
the
client
and
route
that
to
the
appropriate
method,
the
appropriate
Java
method
that
will
be
executed
to
prepare
your
response
for
that
request.
So
why
is
there
not
circled?
A
You
have
that
front
that
from
selector,
where
that
servlet,
that
selects
the
correct
method
based
on
the
request
that
comes
in,
but
actually
you
just
need
some
functionality
that
accepts
those
requests
and
the
bottom.
You
don't
need
Circle
for
that.
You
can
Implement
that
without
a
server
so
having
the
entire
server
specification.
Just
for
that
routing
is,
of
course,
a
bit
of
an
overhead.
So
in
my
opinion
that
was
a
good
decision
to
remove
servlet,
because
you
actually
don't
need
it
for
those
typical
rest
applications.
A
But
there
is
something
else
missing
which
is
a
bit
of
a
shame.
If
you
ask
me,
comfy
did
not
make
it.
It
was
not
ready
for
the
release
planner
when
the
release
plan
was
created
and
voted
on.
There
was
coffee
here
so
the
idea
that
at
last
we
would
have
something
like
coffee
in
Jakarta.
It
was
already
started.
Even
in
the
Java
ee
times,
then
it
was
put
on
hold.
A
The
microprofile
came
in
with
the
config
one,
so
that
are
solutions,
but
coffee
is
also,
for
example,
needed
for
expressing
languages,
I
guess
linked
with
jsps
and
JSF,
which
is
not
there
in
in
the
core
profile.
So
why
is
that?
And
they
are
here-
Mark
is
optional,
but
it
is
there
in
the
core
profile.
I'll
explain
that
in
a
moment
then
I
discussed
CDI
and
CDI
light.
Then
that
becomes
clear
where
the
expression
language
is
there.
A
If
we
look
at
the
page,
there
is
a
page
on
the
eclipse
website
which
lists
the
compatible
products.
So
at
the
launch
of
Jakarta
e,
then
there
were
three
products
already
that
passed
all
the
testing.
At
that
time
they
were
I'll
find
better
versions
there
from
open
Liberty
by
our
server
and
wildflame.
A
They
passed
the
tck
test,
so
they
are
listed
at
from
day
one
at
that
page.
They
have,
of
course
not
really.
They
are,
of
course,
not
really
core
products,
because
if
you
look
at
them
they
are
web
profile
based
products
or
even
full,
based
or
not
really
the
core
profile.
So
I'll
explain
that
also
a
bit
more
in
detail
later,
but
from
a
sensor
point
from
those
products.
A
your
CDI
container.
It
provides
bins
for
your
application.
They
that
container
needs
to
get
this
information.
They
have
this
demit,
the
metadata,
which
means
should
it
provide
Etc
somehow,
and
it
does
that
for
the
moment
with
a
CDI
full
or
the
the
current
CDI
implementation.
It
does
that
at
startup
there.
So
it's
does
the
scaling
of
the
Class
part.
A
You
have
the
opportunity,
then,
with
those
producer
methods
for
examples,
and
you
have
also
the
extensions
at
the
extensions
that
you
can
use
to
programmatically-
create
some
beans
or
change
annotations
Etc,
it's
nice
that
works,
but
of
course
it
takes
a
bit
after
I
was
startup
and
in
the
light
of
we
always
need
faster
and
faster
start
times.
Maybe
that
can
be
changed,
that
we
move
that
scanning
that
definition
of
that
of
those
metadata
for
CDI
bins.
We
can
maybe
move
that
to
the
build
phase.
A
We
can
move
to
the
front
so
that
our
application
started
faster.
That
is
possible,
but
of
course
there
is
one
important
rule
about
it
at
build
time
you
need
to
have
then
the
complete
set
of
classes
which
will
be
available
at
runtime
with
the
jvm.
You
can
add
classes
at
the
runtime.
You
can
add
dependencies
at
the
return
runtime,
which
are
not
there
during
build
time,
so
davm
handles
that
perfectly.
A
But
of
course,
if
you
add
in
things
at
runtime,
then
you
need
to
make
sure
that
they
are
also
known
at
build
time
so
that
the
scaling
can
happen
they
have.
The
creation
of
the
metadata
can
be
done
there.
So
CDI
light
was
then
the
idea
of
moving
that
I'll
add
that
identification
of
the
CDI
bins
to
build
stack.
It
can
also
be
used
at
startup,
but
there
is
a
possibility
to
move
that
so
that
the
startup
is
a
little
bit
faster.
A
Initially,
there
was
also
the
mention
that
cdlite
was
needed
for
Native
compilation,
because
that
that
would
make
it
easier,
but
actually
that's
not
a
valid
reason
because,
for
instance,
with
CDF
full,
you
can
be
12
an
implementation
of
the
current
CDI,
a
bit
nine
and
ten.
Now
you
can
already
have
native
compilation.
One
example
is
Celadon,
a
heladon
MP
which,
using
just
a
CDF
full
implementation
with,
allows
you
to
do
Native
compilation,
so
CDL
lights
probably
makes
it
easier
to
have
that
native
compilation
that
you
need.
A
A
Well
everything
everything
that
is
available
in
CDI,
they
split
it
up
in
either
CDI
light
or
CDI.
Full
and
CDF.
Full,
of
course,
contains
everything.
What
is
in
serial
light
and
see
their
light
is
then
the
part
of
CDI
that
makes
sense
in
for
core
profile.
For
example,
what
is
not
in
CDI
light
is
the
session
scope
and
conversation
scope,
which
is
I,
guess
normal,
because
that
the
rest
standpoint
way
of
working,
that's
stateless,
so
you
don't
need
sessions.
You
don't
need
conversations.
A
A
First,
bin
manager,
you
probably
are
familiar
with
the
bin
manager.
At
some
point,
you
always
use
for
some
specific
cases.
The
bin
manager,
not
that
much
as
a
developer,
but
sometimes
you
make
use
of
it
and
all
the
methods
in
that
interface
are
now
split
up.
Some
of
them
are
kept
in
the
bin
manager
and
some
are
moved
to
a
new
interface
which
is
called,
pin,
container
and
Bin
container
extends
bin
manager
so
being
container
contains.
A
All
the
methods
that
are
supported
by
serial
light
pin
manager
is
an
CDF
full
and
so
contains
those
methods
for
CDI
light
and
ctfo.
So
in
manager.
You
should
not
use
it
in
a
core
profile
because
it
might
not
be
implemented
as
I
show
you
in
a
moment,
but
you
can
then
replace
your
access
to
the
pin
manager
through
that
CDI
current.
You
can
just
get
the
bin
container
and
from
that
same
CGI
current
and
then
you
can
launch
the
methods
on
those
on
on
that
interface.
A
Of
course,
it's
not
very
quiet
to
support
it,
because
also
the
usage,
maybe
in
there
are
some
use
cases
that
you
can
make
use
of
it
in
the
config
or
the
upcoming
configure
that
you
are
using
Expressions
there,
but
other
than
that.
The
use
you,
the
usage,
is
rather
Limited
in
a
core
profile.
As
we
know
it
today,.
A
Then
that
build
compatible
extension
is
something
completely
new.
It
replaces
the
extension
which
we
have
still
in
CDI
full,
but
it
develops
in
a
similar
way.
So
with
extensions,
you
had
some
methods
that
you
annotated
when
you
are
have
some
parameters
that
are
annotated
that
observes
those
events,
events
that
happens
during
the
start
of
the
startup
of
the
CDI
container.
A
So
it
is
a
replacement,
but
it's
not
a
one-to-one
replacement,
so
it
is
working
in
a
slightly
different
way
to
allow
those
methods
to
be
executed
during
build
time
and
creation
of
some
metadata
or
even
creation
of
additional
classes.
Synthetic
classes
to
help
the
container
at
startup
to
get
those
things
done
fast.
A
So
what
are
those
five
phases?
First
of
all,
you
have
the
discovery
phase.
It's
not
that
important,
probably
for
most
of
you,
it
just
adds
the
possibility
to
add
a
few
annotations
that
will
be
used
later
on
in
the
discovery
Etc.
For
instance,
you
can
create
an
annotation
which
is
not
a
qualifier,
but
then
you
can
be
indicated
it
that
it
should
be
considered
as
an
annotation
and
those
kind
of
things.
But
the
second
phase
is
more
interesting
at
the
enhancements
phase,
which
allows
you
to
do
some
transformations
of
an
annotations.
A
We
all
know
qualifiers.
For
instance,
we
have
here
an
instrument
interface
and
we
have
the
different
types
of
actual
CDI
bins
which
implemented
interface,
but
all
they
all
have
a
specific
type.
So
we
need
to
use
a
qualifier
here
when
we
inject
this
instrument,
because
there
are
three
or
four
bins
which
matches
so
we
need
to
have
a
discriminator,
a
label
for
that.
For
that
beam,
but
qualifiers
always
mean
we
are
going
to
inject
something.
A
So
the
standard
CDI
specification
requires
that
you
also
annotate
or
make
use
of
the
art
inject
in
combination
with
the
qualifier,
but
qualifier
on
its
own
already
says
that
we
are
going
to
do
an
inject.
So
maybe
we
can
forget
that
inject
here,
in
this
case
of
that
column
of
that
qualifier
by
creating
a
extension
which
you
make
use
of
that
enhancement
space.
A
That's
the
second
phase.
The
third
phase
is
the
registration
phase.
Where
you
get
access,
where
you
can
get
a
notification
of
all
the
CDI
bins,
the
extensions
you
will
see
an
example
of
that.
It's
not
the
most.
It's
not
the
best
example,
because
you
can
also
use,
of
course,
a
CDI
producer
method
for
that,
for
example,
for
creating
a
sla4j
longer
implementation
for
is
certain
being
normally
yeah.
You
do
that
through
statement.
A
longer
Factory
get
longer,
but
you
can
also
then,
of
course
do
that
through
injection
instead
of
a
CDI
producer.
A
You
need
to
define
the
scope
I'm
using
either
dependent
score
because
it,
the
lower,
will
be
different
for
each
injection
point
and
I
need
to
specify
the
Clause
that
will
be
used
to
create
a
bin
so
and
that
class
need
to
be
implementing
a
certain
interface
which
and
has
that
create
method
where
I
can
look
up
in
the
case
of
Independence,
which
is
serial
case.
I
can
look
up
that
injection
point
and
when
I
have
that
injection
point,
I
can
get
the
declaring
clause
and
can
use
it
as
the
logger
name.
A
So
I
can
true
that
this
CDI
system
now
a
bit
also
with
those
extensions
I,
can
create
a
proper
for
my
application.
So
when
I
run
this,
then
it
will
print
out
that
information
that
info
messages
and
also
the
lower
name,
and
you
see
that
he
properly
took
the
class
name
as
the
local
name
if
I
would
have
injected
it
in
another
name
in
another
class,
then
the
enabled
correspond
to
that
class
so
that
I
have
the
proper
levels
of
configuration
for
info
at
debug.
For
instance,
for
my
application.
A
So
you
have
to
rely
on
the
fact
that
you
also
can
send
out
messages
in
the
previous
phases
and
when
you
have
that
error
or
errors
object
as
parameter
for
your
methods,
you
can
also
give
information
and
feedback
to
the
user
at
that
point
in
in
the
in
that
phase.
But
of
course
it
would
be
nicer
if
you
have
that
proper
validation
to
be
useful
here.
So
this
is
not
that
useful
for
the
moment.
Actually
at
least
that's
how
I
understood
it
and
how
I
see
it.
A
So
what
CDI
implementations
are
available
today?
We
have
the
12th
implementation.
This
is
the
typical
CDR
full
already
like
before,
and
there
is
a
work
in
progress
by
the
people
of
micronauts
to
implement
opendi,
which
is
CDI
light
and
I've
put
the
link
there.
So
once
we
have
opened
the
eye,
we
probably
will
have
some
or
other
initiatives
and
we
have
proper
properly
some
runtimes,
which
only
support
CDI
lights
or
real
core
profile
products.
A
So
if
we
compile
our
project
or
application
against
that
API
or
against
that
core
API
of
jigata
ee10,
then
that
works
fine,
but
at
runtime
it
fails
because
maybe
we
are
using,
pin
manager
or
session
scope
and
that's
not
available
in
data
runtime,
and
it's
not
the
fault
of
the
render
that
it
doesn't
provide
it.
It
is
just
because
we
have
one
single
API
for
its
single
API
class
for
CDI
light
and
CDF
full.
A
A
So
you
can
add
to
the
test
scope,
for
instance,
and
then
you
have
one
class
here.
It's
called
test
score
profile.
You
specify
a
package
that
it
needs
to
check
and
you
get
feedback.
If
there
are
violations
in
that
package,
he
has
no
violation,
meaning
that
you
are
that
you
have
used
a
Serie
A,
full
Plus.
A
A
So
it's
not
based
on
Imports
that
I'm
doing
the
checking
I'm
doing
some
other
stuff,
but
it
is
able
to
I,
can
run
the
test
so
that
violation
method
then
return
the
class
names
where
you
have
made
use
of
one
of
the
cdr4
classes,
for
instance.
Also
it
comes
here
with
that
we
did
methods,
so
it
even
finds
that
one
even
a
package
we
have
there
are
no
problems.
A
Then,
of
course
that
is
empty
and
you
can
use
that
piston
to
see
if
you
are
only
using
CDR
light
or
not
so
that
is
available.
I
found
it
useful
in
my
research
and
what
I'm
doing
around
check
out
the
e-core
profile,
so
maybe
you'll
find
it
also
useful,
now
switch
to
the
edge
access
new
features.
There
are
of
I
need
to
speed
up
a
bit.
I
see
as
I
mentioned
already.
A
I
have
too
much
content
overflow
exception,
but
Jack
said
it
says
when,
for
me
one
important
things
and
there
are
of
course
well
buildings
like
multi-part
media,
which
is
Now
supported
by
the
spec
Etc,
but
that
bootstrap
API
for
Java
SE
is
very
interesting
because
you
no
longer
need
a
Wi-Fi.
You
no
longer
need
to
build
your
web
file
and
deploy
it
on
the
runtime.
You
can
directly
run
your
tax
arrest,
implementation
on
Java
SE,
with
the
main
method,
a
public
static
for
its
main
method
with
CDI.
A
You
can
do
that
already
quite
some
time
as
in
CDI
2.0,
which
was
included
in
Java
E8.
So,
actually,
with
this
API
available
on
SE,
textures
and
CDI,
you
can
run
your
application,
as
is
Classics
SE
method,
and
you
are
in
the
do
it
yourself
way
mode
as
you
have
with
Filter
spring
boot,
where
you
also
run
your
application
and
you
build
on
top
of
a
core.
You
would
include
those
dependencies
that
you
need,
so
you
create
your
optimal
environment,
foreign.
A
So
that
you
can
also
play
with
it,
you
have
that
core
API
for
your
classes,
so
that
you
have
all
the
apis
available
and
then
you
need
the
SE
version
of
Jersey
and
weld
they
are
already
combined
in
your
project.
You
need
to,
for
example,
Json,
binding
and
Json
profile
processing
support,
and
then
you
need
something
that
accepts
those
chain.
Those
requests
from
the
client.
Actually,
this
is
done
by
the
jdk
server,
so
an
HTTP
server,
which
is
available
within
the
jdk.
It's
already
there
since
1.6.
A
Not
many
people
know
that,
but
probably
not
the
best
way
to
do
in
production,
but
there
is
already
an
HTTP
server,
and
this
one
is
now
used
here
so
that
I
can
create
an
application
as
I.
Do
it
normally
between
Jakarta
I
have
that
application
class
here
I
have
resources
where
I
can
return,
Json
or
use
the
object
builder
for
Json
processing,
I
can
inject
CDI
classes
and
I
have
just
a
main
method
that
I
can
run.
A
You
need
to
configure
it
so
through
that
bootstrap
configuration,
Builder,
port
and
context
root,
for
example,
and
I
don't
like
to
define
the
accessory
sources
in
the
get
classes,
method
of
that
application,
Clause
so
I'm,
using
something
Jersey
specific.
Where
I
can
just
say
this
package
is
the
root
packet.
So
if
this
or
in
sub
packages,
you
find
all
the
success
resources,
I
can
start
it
just
as
any
other
main
method
as
any
command
line.
A
It
starts
very
fast,
a
few
hundred
Millis
seconds,
of
course,
but
I
have
a
fully
functional
application,
where
I
can
call,
for
instance,
endpoints
for
that
hello
and
character,
one
that
hello
world
one
where
I
have
support
for
Json
when
I
type
it
correctly
and
where
I
also
have
support
for
Json
Pros.
So
that's
all
there
just
on
the
main
method,
which
then
brings,
of
course,
a
lot
of
new
ways
and
possibilities
for
the
users
to
build
their
own
optimized
version
of
what
they
need
and
no
longer
rely
on
runtimes.
A
A
Based
on
that
information
in
the
server
XML
and
the
features
you
can
build
a
runtime
environment
that
only
contains
those
functionality
that
you
have
requested,
for
instance,
the
specific
core
profile
ones
in
beta.
It
was
not
yet
modular
in
the
sense
that
it
copies
also
entire
binary,
but,
for
instance,
for
Jakarta
e
9.1
that
works
already,
and
hopefully
when
it
is
in
production.
They
also
have
a
feature
which
is
called
core
profile,
and
then
you
can
easily
specify
a
runtime
with
open
Liberty,
which
only
has
those
modules
or
can
even
be
modular.
A
So
you
can
even
remove
Json
binding
if
you
are
not
using
it
all.
The
runtimes
I
cannot,
of
course,
give
no
guarantee
at
all.
It
is
just
what
I
see
happening
in
the
world.
I
I
have
no
confirmation
of
or
any
of,
the
maintenance
of
the
next
list
to
it.
I'm
going
to
show
you
if
they
are
going
to
provide
a
core
profile
version
or
not
if
it
will
be
certified
or
not
Etc,
as
mentioned
teledom
Haledon
MP
exists.
Already
today
is
version.
3
is
based
on
Jakarta
e
9.1.
A
A
So
that's
a
very
good
candidate
if
they
maybe
create
a
3.1
which
will
basically
E10,
and
then
you
have
a
highly
modular
native
compilation
available
by
default.
Petitions
on
jdk
17,
core
profile
product
quercus,
announced
a
few
weeks
ago
that
they
have
started
the
development
of
the
version
3,
which
will
have
support
for
this
captain
in
space.
So
I
assume
it
will
be
Jakarta
e
tendon
again
they
are
already
now
very
modular
and
support
native
compilation,
so
that
will
stay
I
guess
and
it
will
run
on
jdk
11.
A
They
announced
so
that's
another
good
candidate
for
core
profile
product
there,
because
also
they
have
their
custom
implementation
of
CDI,
so
that
will
probably
a
CDI
light
one.
So
a
real
core
profile
product
micronauts
I
mentioned
already
with
that
open
the
eye.
So
they
are
working
on
that,
so
I
assume
that
they
will
have
also
at
some
point,
a
version
which
has
done
that
was
a
carton
in
space
and
micro.
A
Note
3
for
the
moment
is
based
on
the
Java
X
namespace,
still
not
Jakarta
ee8
there,
or
at
least
I,
could
not
found,
for
instance,
that
the
GSM
processing
was
supported
so
but
I
assume
that
we'll
add
it
will
be
edited
also.
They
also
have
a
very
modular
approach
and
Native
compilation.
So
that's
also
another
possible
candidate.
A
This
one
brania
clouds
has
already
a
version
available
which
is
called
beranya
Cloud
Core
profile
since
September.
They
support
those
specifications
of
the
core
profile
and
on
jdk
17,
although
it
is
a
single
artifact
which
also
includes
as
part
of
the
server
specification,
El
expression
of
bean
validation.
But
although
it
is
a
single
artifact
that
is
very
small,
so
I
guess
that's
not
a
problem
that
is
not
really
a
modular
one
in
in
that
sense,
okay
and
then,
as
I
mentioned,
my
own
playground.
A
I
just
do
get
to
know
that
core
profile
and
the
capabilities
of
that
running
on
the
as
a
Java
SE
program
right
on
the
public
static
flight,
Main
I
have
a
version
Alpha
available,
which
is
Jakarta
core
profile.
So
E10,
it's
also
highly
modular,
and
there
are
also
no
native
compilation
by
default.
You
can
configure
it,
but
it's
not
provided
by
default.
It
works
on
glk11
and
the
nice
thing
is
that
it
supports
the
entire
Scala
of
that
Jakarta
ee.
A
So
you
can
use
it
as
a
runtime
where
you
point
it
to
a
war
file.
You
can
even
do
remote
deployment
and
like
in
a
server
mode,
but
you
can
also
use
it
in
a
Jarvis
eBay,
where
you
where
it
makes
use
of
the
same
core,
which
is
Pure
service,
loader
and
the
different
modules.
So
there
it
achieves
is
a
highly
modular
functionality
from
it,
and
there
are
extensions
for,
for
example,
config
and
security
already.
A
So
the
conclusion
core
profile
is
typical
for
those
resta
based
applications.
They
should
be
smaller,
modular
and
support
native
compilation.
We
are
not
there
yet,
but
I
guess
that
will
come
in
the
when
there
is
more
experience
and
more
more
development
around
core
profile,
but
you
can
easily
create
your
own
runtime.
So
actually
you
can
do
it
all
yourself.
You
don't
need
those
products
from
those
vendors
anymore.
You
can
do
it
yourself,
but
I'm
expecting
like
something
like
five
to
ten
supporting
products
by
the
end
of
next
year.