►
Description
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
Okay,
so
another
studio
session
yeah,
it
is.
B
A
Is
going
pretty
well
we're
still
very
energetic
and
enthusiastic
about
the
the
conference?
We're
not
tired
at
all.
It's
been
quite
a
day,
yeah
and
super
excited
to
actually
have
david
crow
here
with
us.
So
welcome
david,
hey,
hello,.
A
Yeah
yeah
so
so
happy
to
have
you,
and
today
we
will
talk
about
jason,
processing
and
binding.
He
is
also
one
of
the
oracle
guys,
so
we
will
be
happy
to
hear
about
what
is
the
purpose
of
jsonp
or
jsonb,
and
what
problem
does
it
solve?.
C
Right
all
right,
so
I
will.
I
will
start
sharing
my
presentation
here.
Thank
you,
okay,
okay,
so
let
me
select
it.
Do
you
see
it?
Yes,
all
right,
great
stuff,
all
right
so
well!
My
name
is
david
crowl
and
I
work
in
oracle
on
project
halidon,
but
I'm
also
the
member
of
different
jakarta
ee
specifications
such
as
jersey,
jason,
p,
jason
b,
or
the
reference
implementation
of
the
jason
b.
Yason
yeah.
That's
that's
about
me.
C
I
guess,
and
let's
take
a
look
into
the
json
processing
and
json
binding.
What
is
it
good
for?
Well,
some
of
you
might
know
jxp
or
jxb
libraries.
There
are
basically
the
libraries
for
handling
the
dxml
files
and
jsonp
and
json
b
is
exactly
for
the
the
same
purpose,
but
in
terms
of
the
json.
C
So
jsonp
itself
is
well
json
processing,
it's.
It
provides
us
the
way
to
process
the
json
itself
and
or
or
generate
it.
So
we
you
can
parse
it
or
or
generate
it,
but
it's
not
very
flexible
in
terms
of
making
any.
C
Instances
of
concrete
classes
which
you
would
like
to
which
you
would
like
to
use
so
for
that
purpose
there
is
a
json
binding
which
allows
you
to
basically
process
your
created
instance
into
the
json
and
vice
versa.
So
you
can
have
a
json
and
you
will
say
that
you
want
to
handle
it
as,
for
example,
I
don't
know
car
class
and
the
json,
the
json,
binding
or
better
to
say
its
implementation
will
handle
it
for
you
and
the
an
instance
of
the
of
the
car
would
be
provided
to
you.
C
So
you
can
use
it
in
your
code
as
you
are
used
to
do
with
any
other
instance.
So
that's
basically
the.
A
C
Of
it
how
it
is,
what
for
it,
is
used
and
that's
answers
that
answers
your
question,
and
now
we
can
take
a
look
into
what
are
actual
changes
in
the
new
releases
of
the
json
p
and
json
b
and
we'll
start
with
the
json
processing.
Here
most
of
the
changes
are
quality
of
life
improvements
like
minor
changes,
which
were
implemented
based
upon
the
user
feedback
and
and
stuff
like
that.
C
But
there
is
one
huge
change
and
that's
actually
that
we
have
split
the
api
and
the
implementation
jsonp
used
to
have
the
implementation
and
the
api.
In
the
same
repository
repository
and
now
it's
been
split
into
the
separate
represent
repositories.
C
Why
is
it
good
for
us
to
do
it
or
what
what's
benefit
for
us
is
this
provides
a
better
vendor
neutrality,
so
the
user
now
will
have
only
the
api
and
can
choose
whatever
implementation
of
the
jsonp.
He
desires
basically,
and
one
can
use
it
this
way
until
the
time
the
jsonp
used
to
have
also
the
built-in
default
implementation
and
another
major
stuff,
which
I
think
is
a
step
of
a
big
step
for
us.
C
There
is
actually
a
standalone
tck
that
we
have
separated
this
dc
case
from
the
whole
bundle
of
dc
case,
and
now
we
are
able
to
greatly
improve.
This
allows
us
to
greatly
improve
the
overall
maintenance
of
the
tcks.
C
We
can
very
easily
change
them,
because
it's
under
our
control,
we
can
do
it
ourselves
or
we
can
just
add
a
new
ones
and
stuff
like
that,
and
also
it's
not
only
benefit
for
us,
but
also
for
our
implementers,
because
they
can
very
easily
verify
their
implementations
that
they
are
actually
compatible
with
the
tcks
without
the
need
of
setting
some
unnecessary
stuff
or
some
stuff
which
are
sometimes
hard
to
hard
to
set.
This
is
very
easy.
C
This
is
just
these
are
just
the
junit
tests
which
you
can
run
against
your
implementation
and
that's
a
great
benefit
there
other
than
as
I've
mentioned,
those
those
changes
in
the
2
2.1
version
are
more
or
less
the
quality
of
life
improvements.
A
And
it
is
great
just
a
comment:
it
is
great
to
see
that
we're
having
more
vendor
neutrality
approach
and
we're
enabling
others
to
get
involved.
C
Yeah
exactly
we
also
thought
this
is
something
we
we
had
to
do,
because
this
is
a
great
step
to
do
and
all
right.
Then,
then
there
is
a
json
binding
in
terms
of
json
binding.
We
have
done
the
or
better
to
say
we
will
do
it
eventually,
in
a
few
days
or
weeks,
let's
say
we
will
try
to
make
the
tck
stand
alone.
Also.
I
think
there
will
be
no
problem
with
that.
So
that's
one
one
of
the
stuff,
but
in
terms
of
jason
b,
I
don't
think
this.
C
This
is
actually
the
the
largest
stuff
because
we
are
adding.
Finally
polymorph
polymorphism
support.
That's
something
would
be.
We
have
been
asked
a
lot
of
times
by
our
users
to
provide,
because
currently,
if
you
have
an
interface
and
you
have
a
different
classes
and
you
wanted
to
deserialize
the
json
into
the
instance,
you
actually
had
to
specify
every
time
the
correct
class
which
you
want
to
visualize
into.
C
So,
for
example,
if
you
had
an
interface,
animal
and
then
dog
cat
and
and
stuff
like
that,
the
classes
which
implements
these
implement
the
this
interface.
You
have
to
every
time,
specify
the
the
dog,
the
code
and
and
basically
exactly
the
class
you
want
to
handle,
and
this
will
finally,
a
user,
a
tool
where
one
will
be
able
to
say.
C
How
this
polymorphic
class
should
be
handled,
and
that
means,
for
example,
we
are
providing
it
in
a
way
that
another
property
will
be
added
into
the
json,
with
some
some
polymorphic
value,
for
we
call
it
alias
it's,
for
example,
a
dog
and
then
when
user
will
visualize
it
or
the
the
implementation
will
decentralize
it.
We
will
map
these
alias
against
the
class
and
we
will
create
an
instance
from
it
we
will
create.
C
We
will
fill
the
dog
instance
and
we
will
return
it
even
though,
when
user
has
asked
for
a
generic
animal,
so
we
will
be
able
to
do
such
a
such
an
improvement
there,
and
I
think
that's
that's
actually
a
pretty
huge
one
and
the
second
one,
which
I
see
as
one
of
the
best
best
improvements
we
are
doing
there
in
the
3.0
version,
is
that
we
are
actually
making
all
of
the
parameters
of
the
jsonp
creator.
C
C
With
different
parameters
and
stuff,
like
that,
until
this
point,
it's
been
required
that
all
of
those
parameters
has
to
be
in
the
json
which
is
being
deserialized,
but
now
we
are
easing
the
spec
and
or
relaxing
the
spec,
and
now
we
are
basically
changing
the
default,
and
now
we
will
not
require
those
values
to
be
present
in
the
json.
C
So
if
one
will
deserialize
and
all
of
the
parameters
will
not
be
in
the
json,
the
implementation
will
not
be
required
to
fail
now
and
the
the
instance
will
be
created
using
the
creator.
Anyway,
we
have
sold
it
the
way
we
have
solved
it.
The
way
that,
if
it's
a
regular
object,
the
value
will
be
now
if
it's
a
primitive
type.
C
Well
it
the
the
default
value
provided
to
the
missing
parameters
will
be
based
upon
which
value
is
present
in
the
in
the
primitive
java
types
when
not
when
there
was
not
assigned
into
those,
and
so
so,
for
example,
for
integer
it
will
be
zero
and
stuff
either
and
also
in
terms
of
optionals.
I
know
it
looks
weird,
but
if
anyone
uses
optionals
in
their
parameters,
now
will
not
be
provided
there,
but
optional,
empty
or
or
any
any
type
like
this.
C
Basically
optionals
are
are
handled
not
as
null
mouse
but
empty
instances,
and
I
think
this.
This
is
also
great
great
addition,
there
yeah
and
yeah,
and
for
those
who
want
to
stick
with
the
previous
behavior.
There
is
also
a
switch
for
to
our
config,
where
you
can
switch
it
to
the
previous
behavior
and
in
india
son.
We
will
be
adding
also
a
system
property
switch
which
will
allow,
which
will
allow
already
existing
applications
to
still
stick
with
the
previous
behavior.
C
If
they
are
in
some
way
needs
this
behavior
to
be
the
same,
so
they
will
be
able
to
do
that,
yeah
and
basically,
that's
more
or
less
it.
I
just.
C
I
might
just
mention
one
related
thing
here
that
in
terms
of
yason,
we
have
been
working
for
some
for
quite
some
time
on
completely
reworking
some
parts
of
the
of
the
framework,
the
the
sterilization
and
visualization
parts,
and
I'm
happy
to
say
that
with
the
new
api
we
will
be
also
releasing
partially
because
it's
not
completely
from
from
scratch
rewritten.
C
But
we
will
be
releasing
also
new
yason,
which
will
provide
very
significant
performance
boost
to
to
the
previous
state,
and
we
are
talking
here
about
multiple
times
numbers.
So,
let's
hope,
let's
hope
it
will
be,
as
I
hope
it
will,
and
there
will
no
be.
There
will
be
no
problems
with
the
new
version
of
the
awesome.
C
But
if
anyone
is
interested
in
testing
it
as
soon
as
we
will
add
it
into
the
master
branch
feel
free
to
test
it,
and
because
we
will
be
making
milestones
and
we
will
be
very
happy
if
you
can
provide
us
any
feedback
to
it.
C
For
example,
if
you
will,
if
you'll
find
any
any
bug
in
the
current
implementation,
I
mean
in
the
new
implementation
or
or
something
or
stuff
like
that,
so
that
yeah,
that's
that's
something
we
have
been
working
on
and
it's
tightly
bound
to
the
json
b,
json
b
itself,
because
it's
the
reference,
implementation
and
yeah.
A
Go
ahead
that
is
great,
that
you're
inviting
people
to
test
it
and
participate
log
issues,
if
you,
if
they
see
any
and
and
kind
of
get
involved,
because
we
need
a
lot
of
helping
hands.
Yeah.
C
A
Yes,
and
and
anyone
who
is
interested,
please
do
look
up
the
jason
b
and
jason
p
projects
and,
and
and
and
the
mailing
list
there
sign
up.
Thank
you
for
for
moving
on
to
the
next
slide.
C
Yeah,
that's
those
are
the
apis,
the
jsonp
one
and
the
json
b1
and
yeah.
I
forgot
at
the
yason
repository
here,
but
since
the
presentation
wasn't
about
it,
I
basically
skipped
that
I
think
this
is.
This
is
all
right.
Basically,
if
you
will
search
for
the
reference
implementation
of
the
jsonp
api,
there
should
be
even
link
in
the
gsba
api
and
you
will
get
there.
A
Yeah,
we'll
just
call
them
compatible
implementations
but
yeah.
Absolutely.
A
That
that
is
great
because
we're
inviting
as
many
implementations
as
possible
to
be
to
become
compatible
so.
B
Kind
of
maybe
related
to
the
next
version
of
the
json
binding,
but
I
I
sense
there
is
a
wish
in
the
community
to
have
support
for
records
in
bindings.
So
so
so
will
you
kind
of
make
a
way
to
go
around
the
kind
of
requirement
for
for
java
bean
patterns.
C
Yeah
together
yeah
in
terms
of
the
records
itself
to
address
this
question
first,
I
spoke
about
it
with
with
colleagues
already,
but
we
have
talked
about
it.
The
way
that
currently
we
are
supporting
the
java
11
and
we
do
not
want
it
to
be
present
on
the
spec
level,
because
the
spec
is
java
11
officially,
but
the
implementations
are
obviously
free
to
do
so
and
again,
yeah.
B
And,
and
for
for
for
the
next
version
of
of
jason
binding,
the
level
will
probably
be
java
17
and
you
can
incorporate.
C
A
Okay,
well,
I
guess
we
need
to
move
along,
but
thank
you
david,
so
much.
It
was
a
pleasure
having
you
today.
A
A
Talk
right,
we
look
at
these
micro
services,
so
bruno
bautista
is
from
from
talk.
Desk
will
be
in
the
next
session
and
he'll.
Let
us
know
about:
what's
going
on
with
microservices.