►
Description
Speaker: Josh Juneau
This talk will focus on the features that were introduced as part Java EE 8, as Jakarta EE 8 will be in feature-parity with that release. The main goal will be to showcase a number of important newer features and enhancements. Coverage will include a wide range of APIs, including both the back-end and user interface enhancements. In the end, the viewer should have a general understanding of the latest inclusions that are part of Jakarta EE 8, as well as some forward-looking features.
///GET SOCIAL!
Subscribe: https://www.youtube.com/user/EclipseFdn
Follow us on Twitter: https://twitter.com/JakartaEE
Follow the conference: https://twitter.com/JakartaOneConf
Like us on Facebook: https://www.facebook.com/JakartaEE/
Become a member of our Jakarta Tech Talks Meetup: https://www.meetup.com/jakartatechtal...
Join us on LinkedIn: https://www.linkedin.com/groups/13597...
Tag us: #JakartaEE #JakartaOneLivestream
C
A
A
C
A
B
This
is
to
create
an
overview
of
features.
Basically,
what
I'm
going
to
do
in
this
session
is
go
over
each
of
the
different
projects
and
specifications
that
are
used
to
compose
that
Jakarta
a
platform.
So
as
we're
going
through
this
session,
you're
going
to
hear
the
new
names
of
the
specifications
and
we
are
going
to
go
over
first,
a
brief
history,
yeah
I'm,
going
to
provide
a
quick
overview.
Each
of
the
specifications
diving
deeper
into
some
of
those
that
have
recently
had
newer
features
added,
while
I'm
going
through
the
different
specifications.
C
B
B
So
this
is
very
important
and
Jakarta
is
then
what
the
new
platform
is
going
to
be
known
as
and
if
you
look
at
the
overall
project,
there
is
a
top-level
project
known
as
EE
4j,
and
this
is
kind
of
the
umbrella
project
for
all
of
the
different
underlying
project.
Jakarta
is
governed
by
the
Jakarta
ee
working
group
and
the
Jakarta
8
release
is
equal
to
Java
EE
8
as
far
as
parody
goes.
B
B
B
Although
the
source
code
has
been
open
source
to
the
Eclipse
Foundation
and
is
being
released
in
parody
to
the
Java
EE,
a
platform
release-
and
there
are
some
significant
changes
that
cannot
be
taken
very
lightly,
as
I
had
mentioned,
as
we
can
see,
the
new
project
naming
the
open
source
TCK
in
Eclipse
class,
so
well,
I
had
mentioned
earlier
about
EE
4j.
So
this
is
a
top-level
project
at
the
Eclipse
Foundation.
All
the
projects
that
create
the
Jakarta
EE
a
platform
are
underneath
this
project
that
Eclipse
EE
Forge.
B
A
project
management
committee
is
responsible
for
maintaining
all
of
the
top-level
project
and
it
will
set
the
standards
and
requirements
for
all
the
different
releases.
All
the
individual
projects
for
the
pledge
card
ee
platform
are
under
this
umbrella
and
together
they
unified
to
form
the
platform.
So
how
do
we
get
started
today?
That's
important
because
we
want
to
go
off
and
develop
applications
on
Jakarta
8.
B
So
first
thing
you
need
to
do
is
download
a
glassfish
5.1
or,
as
I
had
seen
in
the
earlier
session,
like
I
mentioned,
open
Liberty,
and
you
download
that
and
just
start
incorporating
these
specifications
into
your
project.
It
is
released
today,
so
you
can
go
out
and
get
started
right
away.
There's
some
great
examples.
Online
I
have
thrown
a
couple
of
URLs
here
on
screen
and
you'll
also
see
them
in
my
slide
show
so
we're
going
to
go
through
an
overview
of
the
different
specifications.
C
B
Those
are
on
the
screen
and
notices.
Maintenance
releases
have
made
some
for
progression
for
maintenance
purposes,
with
the
release
of
Java,
EE
8
and
2017,
and
I'm
going
to
note
that
each
of
the
projects
in
the
Jakarta
EE
8
platform
have
had
service
releases
in
order
to
make
it
to
Jakarta
a
compliancy.
B
So,
let's
take
a
look
through
each
of
the
projects
to
compose
the
Jakarta
platform,
I'm
going
to
touch
upon
most
of
these
projects,
just
providing
a
brief
explanation.
When
I
come
across
a
project
that
has
had
significant
enhancements
in
the
past
couple
of
years,
then
I'm
going
to
go
into
a
bit
more
detail
on
those
new
features,
so
starting
off
the
Jakarta
annotations
defines
a
collection
of
annotations
representing
common
semantic
concepts
that
enable
a
declarative
style
of
programming.
That
applies
across
a
variety
of
different
Java
technologies.
B
The
standalone
release
of
Jakarta
annotations
uses
that
Java
platform
module
system
are
Mayock
module
name
of
Java
data
annotation
to
match
the
module
name
used
in
JDK
9.
A
future
version
will
include
full
module
metadata,
so
service
release
13.5
is
being
shipped
as
part
of
Jakarta
Jakarta
authentication.
B
This
pertains
to
the
Java
authentication
service
provider,
interface
for
containers
or
a
spec,
as
you
may
know
it.
The
service
provider
interface
by
which
authentication
providers
that
implement
message,
authentication
mechanisms
may
be
integrated
in
client
or
server
message,
processing,
containers
or
runtimes.
So
service
release
as
part
of
Jakarta
ee8
is
one
that
1.3
and
it's
based
upon
jsr
196
java
authentication
service
provider
network
for
containers.
B
B
Jakarta
batch
project
describes
xml-based
a
job
specification,
language
or
JSL
java
programming
model
and
runtime
environment
for
batch
applications
for
the
java
platform.
So
the
specification
ties
together
with
the
Java
API
and
the
JSL,
allowing
a
job
designer
to
compose
a
job
in
xml
form,
job
application,
artifacts
and
conveniently
parameterize
them
with
values
for
an
individual
job.
This
structure
promotes
the
application,
reuse
and
artifacts
across
different
jobs,
so
the
key
features
are
checkpoint,
restart
steps,
XML
configuration
and
partitions
release.
1.0
is
part
of
jakarta
ee,
8.
B
To
cart
a
bean
validation,
so
bean
validation
allows
constraints
to
be
expressed
via
annotations.
It
allows
for
customized
constraints,
provides
api's
for
validating
objects
and
object.
Graphs
provides
KPIs
for
validating
parameters
and
return,
values
of
methods
and
constructors
and
reports
on
the
set
of
violations.
This
also
runs
on
Java
SE
and
released.
2.0
is
part
of
Jakarta
ee8.
B
One
of
my
favorites
Jakarta
concurrency:
it
provides
a
number
of
server-side
resources
for
managing
concurrent
tasks
within
our
app.
Now
we
don't
want
to
have
threads,
you
know
I'm
being
spawned
off
from
our
enterprise
applications.
So
instead
we
pass
processes
off
to
the
manage
executor,
manage
executor
services
that
are
in
the
container
and
they
process
the
test,
and
then
they
will
finish
and
return
the
payload
when
the
process
has
completed.
So
this
allows
our
applications
to
become
more
concurrent
and
release.
B
1.1.2
is
a
service
release
and
it
is
primarily
going
to
contain
the
same
features
as
one.
That's
part
of
Jakarta
ee8
Takata
connectors
overview,
so
the
Jakarta
he
connector
architecture
defines
a
standard
architecture
for
Jakarta
application,
components
to
connect
to
enterprise
information
systems
and
release.
1.73
is
a
service
released
and
as
part
of
Jakarta
ee8.
B
Jakarta
context
and
dependency
injection:
this
is
one
of
the
larger
releases
over
the
past
couple
of
years.
So
Jakarta
context
and
dependency
injection
defines
a
powerful
set
of
complementary
services
to
help
improve
the
structure
and
application
of
your
code,
and
it
is
the
key
technology
for
Jakarta
ee
is.
It
finds
a
well
defined
life
cycle
for
staple
objects
bound
to
lifecycle
context
where.
C
C
B
It
also
has
a
sophisticated
typesafe
dependency
injection
mechanism,
including
the
ability
to
select
dependencies
that
either
development
or
deployment
time
without
verbose
configuration
support
for
Jakarta
modularity
and
the
Jakarta
component
integration
with
the
unified
expression,
language
or
l,
the
ability
to
decorate
injected
objects,
ability
to
associate
interceptors
to
objects
and
a
tie,
shape
type
safe,
interceptor
bindings.
It
has
an
event:
notification
model,
a
web
conversion
context,
in
addition
to
three
standard
web
context
defined
by
the
Jakarta
Jakarta
service,
servlet
specification.
B
It
also
does
have
an
SPI
allowing
portable
extensions
to
integrate
cleanly
with
the
container.
At
least
2.0
is
part
of
Jakarta
ee8.
So,
just
to
take
a
look
at
one
of
the
newer
features
of
cd-I,
it
is
observers
ordering
which
allows
one
to
specify
a
priority
on
the
observer
methods,
so
without
indicating
priority
there
really
is
no
way
to
determine
which
order
the
observers
will
be
initiated
in
the
event
that
more
than
one
exists.
B
So
this
is
a
good
way
to
go
ahead
in
ensure
your
observers
are
running
in
the
correct
order,
and
also
another
new
feature
would
be
a
sync
events.
This
provides
the
ability
for
events
to
process
in
an
asynchronous
manner,
just
annotate
an
observer
method
parameter
with
observes
a
sync
call
upon
the
fire,
a
sync
tune
to
fire
the
event
so
other
important
new
features
and
c-d-I
include
Java
SE
bootstrap.
It's
now
possible
to
harness
the
full
power
of
CDI
in
Java
SC
applications,
while
by
creating
the
SE
container
initialized.
B
B
Around
for
quite
a
number
of
years
now,
but
it's
using
component
based
business
applications,
although
enterprise
beans
have
been
around
for
a
long
time,
they've
matured
quite
a
bit
over
the
past
few
releases
of
Java
EE
and
now
in
Jakarta,
they're,
even
more
powerful
than
ever,
because
they
include
all
the
features
that
came
with
the
last
couple
of
years.
Features
such
as
singleton
asynchronous
and
the
ability
to
create
timers
with
schedule.
B
So
just
about
everything
can
be
done
with
annotations
now,
and
this
really
makes
development
using
Jakarta
enterprise
beans
much
easier
than
the
XML
configurations
we
used
to
have
to
do
in
the
past.
One
can
utilize
staple
and
stateless
annotations
to
generate
staple
and
stateless
session
bean
respectively
and
EG
beans
can
be
injected
into
CDI
beans.
Using
the
eg
Bay
EJB
annotation
service
release,
32.4
is
included
with
Jakarta
ee8.
B
If
we
look
at
the
excuse
me
the
Jakarta
expression
language,
it
provides
a
means
for
enabling
presentation
layers
to
communicate
with
application
logic.
Pl
is
used
by
several
Java
EE
or
Jakarta.
Technologies
such
as
Jakarta
server
faces
technology.
Jakarta
pages
technology
in
CDI
al
can
also
be
used
in
standalone
environments.
Service
releases
30.3
is
included
in
Jakarta
ee8.
B
Jakarta
interceptors
interpose
on
business
method,
indications,
indications
in
specific
events
such
as
lifecycle
events
and
timeout
events
that
occur
in
instances
of
Jakarta,
II
components
or
other
managed
classes.
This
project
implements
jsr
318
enterprise,
javabeans,
3.1
and
interceptors
1.2
spec.
In
this
example,
you
can
see
that
the
interceptor
is
being
applied
to
a
method
which
accepts
text
and
all
that
text
entered
is
going
to
be
modified
into
uppercase,
so
service
release,
1.2
top
4
is
included
with
Jakarta
ee,
8,
Jakarta,
JSON
binding
or
JSON
B.
B
This
was
brand
new
in
Java,
EE
8,
and
so
this
is
a
bigger
release
and
I
will
mention
a
little
bit
more
about
it.
It's
a
standard
way
to
convert
Java
objects
to
end
from
JSON
objects.
This
project
defines
a
default
mapping
algorithm
for
convert
converting
Java
pojos
to
JSON,
so
the
developer
may
also
customize
mapping
via
the
use
of
different
Java
annotations,
and
this,
as
I
mentioned,
was
a
new
release
and
so
service
release.
10.2
is
part
of
Jakarta
y8.
So
let's
take
a
little
dive
into
this,
so
Jakarta.
B
B
B
C
B
Another
biggie
was
Jakarta
JSON
processing,
so
there
were
quite
a
few
new
features
in
the
past
couple
of
years.
With
this,
one
JSON
processing
is
an
API
to
process
JSON
documents.
So
with
this
API
one
can
parse
generate,
transform
query
and
patch
JSON
documents.
The
familiar
API
can
be
used
to
build
Java
object
model
for
JSON
service
release.
B
Anything
in
transformation
of
operations
added
to
the
JSON
object
models
well
in
better
alignment
with
some
of
the
features
that
were
brought
into
Java
SE
8,
so
Jakarta
traits
on
pointers
allows
one
to
point
to
a
particular
value
within
a
JSON
document.
Patrisse
on
pointer
can
be
created
by
calling
upon
json,
dot,
create
pointer
and
then
passing
a
specified
index
and
respective
element
names.
We
call
upon
pointers
that
give
value
to
obtain
the
pointer
and.
B
It's
possible
to
build
a
patch
or
pension
expression
using
the
json
patch
builder
object.
This
is
a
builder
for
constructing
new
json
patch
and
adding
patch
operations.
Incrementally
it's
possible
to
append
a
series
of
patch
operations
to
a
single
patch
builder
and
apply
it
all
at
once.
Very
powerful
Jakarta
JSON
has
a
couple
of
different
ways
to
perform.
B
Json
paths
you
can
utilize
a
JSON
document
or
make
use
of
the
JSON
patch
builder
to
perform
a
programmatic
patch
Catrice
on
pointer
is
used
to
find
the
exact
location
to
which
patch
will
be
applied,
and
then
the
operation
is
performed,
operations
can
consist
of
add,
replace,
remove,
move
copy
or
test
and
they're
applied
in
that
order.
So.
B
Jakarta
male,
everybody
has
used
Java
male
on
the
past
I'm
sure
Jakarta
male
is
a
standard
framework
for
building
mail
and
messaging
applications.
This
framework
can
be
used
to
send
mail
messages.
Well,
I'm
specified
an
application.
One
can
also
send
text.
Html
format
and
attachments
can
be
added
with
E's
service
release.
1.6.4
is
included
with
Jakarta
y8.
B
Jakarta
messaging,
as
an
API
that
allows
software
to
create
edit,
read
and
send
messages
between
three
other
software
applications
or
components.
The
API
allows
resources
to
be
created
with
an
application
server
that
facilitates
messaging
capability
in
various
contexts
and
I
think
I'm,
three
other
applications
or
components.
I
just
meant
all
their
application
components,
the
application,
server
houses,
connection
factory
and
destination
resources,
and
these
resources
are
created
and
maintained
by
the
application.
Server
contain
that
said,
different
application
server
implementations
might
have
minor
variations
in
their
JMS
implementations.
B
In
addition
to
the
basic
messaging
facilities.
Jms
also
provides
the
ability
to
send
messages,
destinations
and
publish
messages
to
subscriptions,
and
we
can
see
how
easy
it
is
to
go
ahead
and
inject
connection,
factories
and
queues
and
resources
using
annotations
with
jacquard
EE
and
a
lot
less
configuration
than
the
old
days.
No
more
need
for
XML
configuration
to
get
Jakarta
messaging
to
work.
There
was
going
to
be
a
good
presentation
on
this
later
today.
Our
service
release
203,
is
included
in
Jakarta,
ee,
8,
Jakarta
persistence,.
B
Persistence
is
otherwise
had
been
known
as
the
java
persistence
api
and
it's
for
management
and
persistence
in
object,
relational
mapping
in
Jakarta
and
Java
SE
environments.
This
includes
many
features
that
were
introduced
with
standard
ORM
strategies
such
as
the
hibernate
in
toplink
JPA
allows
developers
to
choose
from
a
variety
of
different
providers
and
utilize
configuration
that
may
be
most
comfortable
with
for
their
applications,
and
it
doesn't
require
the
need
for
third-party
libraries
to
be
integrated
in
most
cases.
It's
very
easy
to
get
started
with
JPA
and
switch
between
different
implementations.
C
B
C
B
Jakarta
restful,
Web,
Services
server
sent
events.
You
can
create
an
SSE
resource
using
Jakarta,
restful
web
services
and
broadcasts
server
messages
to
connected
clients
at
will.
We
do
this
by
annotating.
The
method
with
produces
and
passing
server
sent.
Events
as
a
produced
type
may
also
pass
text
event
stream
to
the
producers.
B
Imitation
connection
from
the
client
to
the
server
can
remain
open
until
the
client
disconnects
and
the
SSD
interface
is
a
server
entry
point
for
creating
outbound,
SNC
event
and
SSE
broadcaster
inject
the
SSA
interface
into
field,
or
you
can
use
it
as
a
parameter
SSE
event.
Sync
can
be
used
to
send
a
stream
of
messages
acquired
by
injecting
as
a
resource
method
parameter
and
the
SSE
event
is
a
base
event,
class,
outbound,
SSE
event,
packages
and
SSE
event.
B
Jakarta
security,
so
Jakarta
security
allows
developers
to
follow
a
standard
API
for
securing
applications,
including
authentication
authorization,
data
integrity
and
Transport
Security.
The
API
also
defines
a
security
context.
Access
point
for
programmatic
security
service
release.
One
does
0.2
is
included
with
Jakarta
ee8.
This
is
very
important
as.
C
B
The
early
days
of
Java
EE
when
the
platform
was
older,
everybody
had
to
kind
of
create
their
own
implementation
for
Jakarta,
for
excuse
me
for
security
purposes,
for
accessing
application,
authorization,
authentication
and
now
that
can
kind
of
go
away,
and
everyone
can
start
to
follow
a
standardized
API
for
developing
their
security
in
their
application.
For
example,
there's
the
role
mapping
API
one
of
the
most
important
things
is
that
it
does
provide
a
vendor
agnostic
way
to
perform
authentication
and
authorization.
B
This
has
been
project
is
probably
one
of
the
most
popular
MVC
frameworks
for
building
UIs
for
enterprise
applications
written
in
Java.
This
project
has
matured
quite
a
bit
over
the
years
and
the
latest
releases
have
made
it
a
modern
framework
which
really
is
suitable
for
utilization
with
stateless
applications.
B
New
features
I'll
go
over
as
a
WebSocket
integration.
The
WebSocket
tag
enables
support
for
WebSockets
within
JSF
client
views.
This
tag
includes
the
required
channel
attribute,
which
is
a
value
expression
used
to
list
a
channel
on
which
the
WebSocket
client
will
listen.
The
tag
will
also
include
a
required
on
message
attribute,
which
is
also
in
a
value
of
expression.
It's
used
to
list
the
name
of
the
JavaScript
function
that
was
going
to
be
executed
when
the
WebSocket
message
is
received.
B
B
B
Jakarta
server
pages:
this
is
the
technology.
That's
been
long-standing
in
the
enterprise
known
as
JSP
as
well.
It's
extremely
powerful
for
development
of
web
UIs,
because
the
use
of
HTML,
XML
or
other
document
types,
the
JSP
technology,
enabled
developers
to
embed
java
directly
into
a
view
if
needed,
or
to
communicate
with
the
business
logic.
Using
the
expression.
Language
JSP
can
be
enhanced
to
be
made
even
more
useful
by
pairing
it
with
other
technologies
such
as
jakarta
standard
tag
and
Library
Service
released
2.3.5
is
part
of
the
Jakarta
EEA
release.
B
This
is
a
found
technology
for
interacting
with
the
web
in
the
Jakarta
EEE
platform.
Web
frameworks
are
built
on
top
of
the
servlet
API
abstracting
away.
Some
of
the
lower-level
details
of
utilizing
servlets.
However,
servlet
technology
can
be
exceptionally
powerful
when
used
directly,
especially
given
some
of
the
latest
features
that
have
been
added
to
the
technology
service
release
4.0.3
is
being
released
as
part
of
jakarta
y8.
B
B
So,
let's
take
a
look
at
the
push
API.
The
push
builder
interface
was
introduced
with
servlet
4.0.
It's
part
of
the
Jakarta
EEA
platform.
Push
builder
is
used
to
push
a
request
based
on
the
HTTP
servlet
request.
Once
the
push
builder
is
obtained,
it
can
be
used
to
add
resources
via
path
method,
and
these
are
sequentially
pushed
to
the
client
while
the
target
page
is
being
processed.
In
this
example,
a
couple
of
PNG
image
resources
are
added
to
the
path
method.
B
However,
an
application
can
be
coded,
such
that
any
resources,
as
required
by
the
specified
page,
can
be
pushed
preemptively
to
the
client
and
loaded
into
the
browser.
Cached
once
obtained,
push
builder
can
be
used
as
many
times
as
required
and,
after
all,
the
resources
have
been
loaded.
Initiate
that
push
build
or
not
push
method
to
perform
the
push
action.
This
is
great
because
no
longer
do
you
have
to
send
multiple
requests
in
order
to
send
resources
to
the
clients.
B
Jakarta
stable
abis:
this
is
a
project
encompassing
stable
legacy,
API
and
T
sake,
tcks,
which
will
not
be
developed
further
in
the
future.
Some
of
these
API
include
enterprise
deployment,
jacks
are
which
provides
a
single
easy-to-use.
The
abstraction
API
for
accessing
a
variety
of
xml
registries,
jab
AAP,
is
for
XML
based
remote
procedure.
Call
management,
API
and
service
release.
1.0.1
is
included
as
a
part
of
Jakarta
ee8.
B
Takata
stands
tag
library,
J,
STL
is
otherwise
known
as
encapsulates
the
simple
tags
that
are
the
core
functionality
and
common
to
many
web
applications.
J
STL
has
support
for
common
structural
tasks
such
as
iteration
and
conditionals
tags
for
manipulating
XML
documents,
internationalization
tags
and
SQL
tags.
It
also
provides
a
framework
for
integrating
existing
custom
tags
with
J
STL
tags.
B
That
to
adapt
Forest
Park
of
Jakarta
ee8
and,
as
I
mentioned
before,
this
is
one
of
those
api's
that
can
be
paired
with
other
technologies
such
as
JSP
to
make
it
even
more
powerful
to
carve
into
transactions.
This
allows
applications
to
perform
distributed
transactions
that
can
access
and
modify
data
on
disparate
networked
computer
sources.
The
API
consists
of
a
standard
Java
interfaces
between
transaction
manager
and
other
parties
that
are
involved
in
the
system,
including
the
application,
server
container
resource
manager
and
the
application
itself
service.
Release
13.3
is
included
with
Jakarta
ee8.
B
Jakarta
WebSocket,
he
finds
an
API
that
can
be
utilized
for
the
integration
with
WebSockets,
both
on
the
server
side
as
well
as
on
the
client
side.
The
implementation
was
provided
by
the
Eclipse
tyrus
project.
Websocket
endpoints
accept
a
string
base
path
attribute,
and
this
is
used
to
indicate
the
URI
at
which
the
server
is
available
to
receive
client
messages
by
initiating
call
to
that
URI.
The
method
annotated
with
on
message
is
invoked
processing.
The
message
that
was
sent
to
the
client
via
the
client
excuse
me
service
release.
B
Jakarta
ml
Web
Services:
this
is
a
programming
language
API
for
creating
web
services,
particularly
soap
services.
Jakarta
XML,
Web
Services,
is
part
of
the
java
xml
programming
api
is
and
it's
part
of
the
jakarta
ee
platform
and
service
release.
Dot
3.2
is
being
shipped
as
part
of
jakarta
ee
8
so
that
wraps
it
up
for
the
different
specifications
and
projects
that
are
going
to
be
part
of
jakarta
ee
8.
As
you
can
see,
there
are
quite
a
diverse
number
of
specifications.
B
They
will
allow
you
to
develop
custom
enterprise
applications
in
modern
technology
and
taking
modern
ways
using
annotations
lots.
Less
xml
configuration
very
easy
to
develop
cloud-based
applications,
cloud,
ready
and
micro
services
based
applications
alike.
So
let's
take
a
look
into
the
near
future
and
see
what
may
be
coming
down
the
road
for
future
releases
of
Jakarta
EE.
So
we
know,
as
heard
in
the
earlier
session
by
Kevin,
that
the
namespaces
have
been
discussed.
B
There's
been
a
very
large
discussion
in
Jakarta
II
working
group
and
the
community
over
the
renaming
of
spaces
from
Java
X
to
Jakarta
X.
Making
changes
such
as
these
means
that
there
may
be
some
backwards
and
compatibility
down
the
road,
but
regardless
is
the
change,
though,
will
need
to
occur
before
new
code
can
be
released
under
Jakarta
Yi
and
our
Riccardi
working
group
and
community
is
working
out
the
best
ways
to
do
this
so.
B
Looking
ahead
into
something
like
JSF
3.0,
there
is
already
actually
work
underway.
If
you
go
to
the
github
project
on
the
e4j
project,
you
can
see
that
quite
a
bit
of
work
has
been
done
for
JSF
3.0.
Some
of
that
work
involves
removable
concepts
such
as
managed
beans
and
getting
rid
of
JSF
Onix
Russian
language
and
using
the
unified
yell.
Only
we're
moving
more
artifacts
and
been
moved
towards
CDI
were
seeing
that
this
is
kind
of
a
big
movement
throughout
all
of
Jakarta
Yee.
Getting
things
to
work
with
the
CDI
in
a
more
uniform
manner.
B
C
C
B
B
We
take
a
look
at
Jakarta
expression,
language,
3.1
expression,
language
has
included
its
own
implementation
of
streams
and
lambdas,
but
it'd
be
a
good
idea
that
map
job
as
the
implementation
of
these
lambdas
in
the
future.
So
that's
what
we're
hoping
to
do,
and
also
the
ability
to
obtain
even
more
information
from
method
and
value
expressions
would
enable
more
granularity
within
our
boots.
B
So
that
wraps
it
up
for,
what's
included
with
this
brief
overview
of
Jakarta
EE
a
platform.
So
what
we
should
do
now
is
go
in
grab
your
copy
of
claspers,
5.1
or
open
Liberty
or
another
Jakarta
Yee,
compatible
container
download
and
start
to
work
with
the
api's
and
build
your
applications
for
Jakarta
ee8.
B
Are
there
any
plans
for
a
reactive
specification
in
Jakarta
yi,
not
quite
sure
yet
the
next?
Certainly
some
reactive
will
be
coming
to
Jakarta
e-platform
at
some
point
in
future.
I.
Imagine
but
I'm,
not
sure
exactly
when
that
will
occur.
Jakarta
e9
is
going
to
be
big
changes
with
the
namespaces,
so
we're
going
to
have
to
wait
and
see
how
many
new
specifications
or
projects
can
be
brought
into
saqar
de
9.
B
B
C
B
Projects
off
the
ground
and
running
I
believe
that
Eclipse
specification
process
is
going
to
move
projects
along
in
a
quick
fashion.
We're
going
to
be
able
to
see
this
platform
continue
to
evolve
at
a
faster
pace.
Then
Java
EE
did
in
the
past,
and
it's
going
to
be
very
interesting
to
see
I
see
a
question
is
JB
going
to
be
retired.
Certainly
there
are
talks
about
moving
some
vjb
functionality
into
other
other
projects,
such
as
CDI
and
also
as
I
as
I
had
mentioned,
probably
can
moving
some
features
into
concurrency.
B
B
I'm
not
sure
if
jacquard
ee9
is
going
to
be
more
modular,
but
really,
if
you
think
about
it,
a
modularity
can
happen
right
now
with
Jakarta
yi8
right.
We,
when
we
talk
about
modularity
with
enterprise
application,
we're
really
talking
about
micro
services
in
in
a
way
right,
developing
targeted
services
that
will
perform
targeted
tasks
and
when
they
are
orchestrated
together,
then
they
can
create
an
application.
B
One
of
the
things
I
want
to
go
back
to
the
question
about
our
Kilian.
I
really
would
like
to
see
more
standardized
testing
around
the
Jakarta
Yi
platform,
and
so
hopefully
we
can
do
something
with
maybe
our
Kilian
or
or
some
other
testing
strategy
and
make
something
more
standard
that
we
can
apply
to
our
Jakarta
EE
projects.
B
C
B
B
C
D
Fantastic
sorry
about
that
I
see,
you
are
doing
amazing
and
managing
all
the
questions
and
stuff
so
which
is
great.
I
was
just
hoping.
While
you
are
still
answering,
and
we
have
10
more
minutes
to
share
additional
to
share
the
screen
on
my
end
and
have
the
some
accompanying
ads
rolling
for
the
people
sure
go.
B
C
B
Not
quite
sure
yet
because
I
think
it's
too
early
to
tell
about
something
like
that.
There's
old,
certainly
lots
of
discussion
in
the
community
about
micro
profile
and
Jakarta
II,
and
using
these
technologies
together
and
I
can
certainly
see
something
along
the
lines
of
utilizing.
Some
of
the
more
mature
micro
profile
API
is
within
something
like
the
Jakarta
platform.
Pulling
some
of
those
more
mature
api's
into
the
platform
might
make
sense.
Shekhar
de
certainly
would
benefit
from
utilizing
some
of
those
great
features
such
as
config.
B
There's
a
class
about
how
to
sell
Jakarta
to
people
who
use
JBoss
I'm,
not
quite
sure
on
that
one
other
than
just
looking
at
the
future
of
Jakarta.
And
this
platform
is
going
to
be
robust
and
going
into
the
future
for
making
cloud
native
services
and
applications.
And
because
it's
the
future
of
job
and
enterprise.
B
Any
questions
about
any
of
the
projects
that
are
part
of
the
Jakarta
y8
I
know
that
there
are
quite
a
few
I
kind
of
just
briefly
touched
upon
them.
I
know
that
lots
of
these
projects
and
specifications
are
probably
low
level,
so
we
don't
necessarily
program
directly
to
them
when
we're
developing
our
applications,
but
they
are
important
part
of
Jakarta
yet
nonetheless,.
D
C
D
Looking
forward
to
our
next
session,
as
well
as
I,
do
need
to
point
out.
There
is
another
great
conference
that
were
working
on
and
that
is
the
Eclipse
con
Europe
2019.
So
please
have
a
look
register
and
let
us
know
if
you
can
participate
in
the
community
day.
That's
a
community
day.
The
community
day
is
organized
by
community
and
for
the
community.
So
let
us
know
if
you'd
like
to
be
involved
and
check
out
our
pages.
Ok,
I'll
end
the
broadcast
at
this
point
and
I'll
see
you
all
shortly
in
the
next
session.
Josh.