►
Description
GlassFish has a long history. Previously extremely popular as Sun's Java EE server it saw development decline in previous years. At the Eclipse foundation it has gotten a new life as the Eclipse implementation of Jakarta EE 10 and has become very active once again.
____
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,
I
was
previously
a
jsf
gsr272
expert
group
member
and
I
served
on
the
security
api
as
well
as
on
the
project
need
of
several
projects
at
eclipse.
So
mostly
it's
kind
of
faces,
the
security
projects.
It
includes
character,
security
itself,
authentication
authorization.
What
have
you
and
recently
I've
been
maintaining
and
releasing
classes
quite
a
bit?
A
A
Then
we're
going
to
look
at
the
history
of
classvis.
Look
at
some
of
the
recent
developments
things
that
have
been
going
on
at
eclipse,
mainly
then
we're
going
to
take
a
look
at
the
things
that
go
a
little
bit
beyond
the
pure
server.
There's
the
ecosystem,
the
family
of
classvis
and
we'll
be
looking
at
the
roadmap
of
class
b7,
specifically,
and
particularly
in
relation
to
jakarta,
ee,
10..
A
A
A
I
guess
everybody
knows
what
this
is
for
just
ensure
it's
a
full
stack
web
application
development
framework.
It
provides
apis
for
a
lot
of
things
that
a
lot
of
applications
use,
so
persistence
transactions,
http
handling
servlets
to
that
mvc
security.
So
it
covers
basically
the
entire
spectrum
of
what
most
applications
need.
A
So
one
thing
that's
specific
about
jakarta
ee,
especially
when
you
contrast
it
to
other
frameworks
which
might
offer
similar
functionality
is
that
jakarta
ee
provides
a
very
strict
separation
between
the
api
and
the
implementation.
So
in
other
frameworks
it
might
be
the
case
as
well
that
you
have
an
api.
You
have
any
implementation
codes,
but
it
it
might
not
be
so
strictly
separated.
A
A
A
A
So
what
is
an
application
server?
So
this
is
essentially
a
piece
of
software
that
supports
deployments,
so
you
can
install
you
can
remove
an
application.
It
typically
has
the
ability
to
run
multiple
applications
at
the
same
time
and
there's
there's
like
a
weak
amount
of
isolation
between
them.
So
they're
somewhat
isolated,
but
not
very
strongly,
so
they
typically
include
an
http
server,
so
they're
listening
to
various
ports,
mostly
for
http,
but
it
could
be
some
other
things
like
corba.
A
And
it
typically
supports
clustering
and
some
management
of
the
global
resources
that
are
within
the
application
and
within
the
server.
So
this
kinda
defines
what
an
application
server
is.
So
it's
true
that
recently
recently
for
the
past
couple
of
years,
the
combination
of
darker
kubernetes
it
partially
partially
replaces
the
concept
of
an
application
server.
So
it
essentially
split
out
the
the
application
target
and
the
clustering
bits
and
it
puts
the
apis
in
the
hands
of
the
engineers.
A
A
So
then
people
might
ask:
why
do
you
want
an
application
server
in
the
first
place?
Why
not
just
combine
the
two
in
one
logical
unit,
but
the
thing
is
that
an
application
server
in
docker
can
occupy
one
layer
of
the
docker
units
and
the
application
can
quite
easily
occupy
the
top
layer.
So
you
even
with
a
darker
deployment
where
you
deploy
an
application
server.
You
still
have
this
clean
separation
between
the
framework
logic
and
your
pure
business
united
states
for
the
deployments.
A
I
can
still
be
quite
advantageous.
If
you
have
a
base
image
with
the
application
server
in
it,
then
you
just
deploy
a
layer
with
special
bar
inside
it.
So
other
frameworks
can
do
this
to
some
degree,
but
it's
not
easy.
So
in
those
things,
it's
quite
common
to
have
this,
the
the
libraries
that
you
use
and
the
business
logic
very
tightly
coupled
so
you
can
separate
them,
but
it's
it's
a
bit
more
hassle.
A
A
A
So
this
was
basically
due
to
oracle
having
a
quiet
sun,
and
then
they
already
had
multiple
application
servers
and
at
some
point
they
decided
to
to
transfer
classes
and
java
ee
okay.
So
let's
take
a
look
at
a
few
more
details
here.
So
when
we
look
at
the
glass
which
history
at
the
enterprise
server,
I
keep
one
of
the
first
application
servers
on
the
scene.
So
there
were
some
things
that
you
could
potentially
classify
as
an
application
server
before
that
they
were
in
c
plus.
It's
not
exactly
the
same
thing.
A
A
Okay,
so
now,
let's
take
a
look
at
the
next
step
there,
so
this
happened
when
an
escape
acquired
kifa.
So
this
was
around
1997.,
so
they
released
the
netscape
application
servers,
essentially
kiefer
represented
netscape,
and
the
deal
was
then
at
a
time
around
180
million.
So
it
would
be
approximately
300
million
in
current
day
dollars.
A
A
A
A
A
So,
at
the
time,
son
had
also
acquired
certifical
net
dynamics
and
they
kind
of
planned
to
to
merge
them
in
some
way
and
then
have
this
common
programming
model
between
the
two
that
was
j2ee.
So
he
received
one
of
the
first
pianists
in
the
it
history
where
two
completely
chapter
surfers
were
attempted
to
be
united
or
had
a
common
interface
for
all
those
complicated
things
they
did,
and
that
was
the
jte
specification.
They
didn't
exist
yet,
but
they
were
working
on
it.
A
A
Okay,
so
then
somewhat
confusing
move
part,
the
escape
name
was
dropped
because
this
was
changed
into
iplanets
kind
of
a
generic
name.
Actually,
it's
kind
of
it's
kind
of
it's
stinging
out
in
the
market
that
and
escape
wasn't
that
important
anymore
for
everything
related
to
the
name
and
has
done
done
away
with,
and
this
kind
of
somewhat
meaningless,
iplanet
name
was
introduced,
but
then,
with
in
april
2000,
the
excerpt
was
the
iplanet
the
the
eye
plane
of
the
application
server.
A
A
That
might
be
because
and
that
dynamic
look
at
five
and
they're
both
being
replaced
by
this
new
eye
clinic
applications
so
far
and
specific
for
the
server
was
that
it
was
the
very
first
one
to
be
certified
for
this
new
released
api
specifications
called
a2ee
java
2
enterprise
edition,
so
the
the
price
was
down
to
5000,
so
application
servers
were
getting
cheaper,
so
this
was
2500
to
3500
before
and
it
still
contained
the
number
of
ziploc
plus
components,
so
it
went
through
in
full
java.
Yet
so
it's
somewhat
of
a
messy
install.
A
A
I
think
at
the
time
the
the
consortium
had
like
1100
engineers,
but
it
does
have
like
40
projects.
I
plan
it
wasn't
the
only
server
a
lot
of
other
things
inherited
from
netscape
and
sun
email
servers.
Portal
servers
quite
a
lot
actually,
okay.
So
then
we
begin
with
the
most
difficult
point.
I
think
in
the
classroom's
history
that
was
the
sun1
application
server.
A
So
the
sun1
application
server
was
a
direct
successor
to
iplanet,
but
it
was
mostly
in
major
rewrite,
so
it
wasn't
directly
a
continuation
of
our
planet.
It's
not
totally
clear
how
much
code
was
carried
over
so,
as
we
said,
it
was
based
on
the
existing
ri,
which
is
the
reference
implementation,
the
iplanet
web
server.
This
was
a
separate
product
from
the
application
server
and,
of
course,
the
by
now.
A
A
A
A
A
A
A
A
So
people
who
use
jersey
might
recognize
this
as
well,
since
jersey
has
hk2
and
a
drop
wizard
uses
hkit
too
as
well,
but
otherwise
it's
not
that
much
used.
Psychologist
v3
was
also
the
reference
implementation
for
java
ee-6.
So
before
class
fish
v3,
it
was
a
bit
less
official
for
diversity,
separate
ri
distributions
used
for
reference
purposes,
classes
v3
was
quite
firmly
designated
to
be
the
ri
okay.
A
So
then,
in
2010
mentioned
with
oracle
acquiring
sun,
they
still
released
a
couple
of
last
fish
versions,
treated
one
to
five
and
3.1
brought
back
a
couple
of
high-end
features
like
clustering
and
load
balancing.
They
were
temporarily
removed
from
three.
I
think
they
were
in
two,
but
with
all
the
refactoring
going
on
for
three,
they
were
removed
temporarily
and
there
was
one
under
oracle
brought
them
back
to
such
a
major
contribution
there.
A
But
the
following
up
versions
like
what's
the
treated
1.1,
there's
a
four
for
that
one.
What
have
you
so
they
were
all
quite
small
in
architectural
updates
data.
They
were
mostly
about
new
components
for
jakarta,
ee
or
jaffa
ee.
At
the
time
I
have
to
say-
and
it
focused
more
on
being
the
reference
implementation.
A
A
A
A
So
the
highlights
are
that
we
kind
of
move
to
a
monthly
cadence.
It's
not
exactly
monthly,
it's
more
like
one
and
a
half
months,
one
month,
one
week,
but
it's
about
monthly.
We
also
worked
a
lot
on
the
jdk
11
and
jdk
17
compatibility.
So
that's
something
we
will
talk
about
a
bit
next
and
one
of
the
highlights
of
the
things
we
did
centered
around
building
and
testing.
A
Okay.
So
take
a
look
at
some
of
the
versions
that
we
released
as
they're
shown
on
the
screen
here.
So
we
had,
as
you
can
see,
approximately
every
month
a
release,
and
this
was
kind
of
important
to
us.
Since
previously
I
started
that
class.
This
was
like
really
tied
to
the
jakarta
ee
releases.
It
was
like
quite
difficult
to
release
anything
beyond
the
major
jakarta
updates,
but
this
proved
to
not
be
the
case,
so
we
could
just
release
it
after
testing
and
it
was
just
fine.
A
So
the
eclipse
foundation
has
infrastructure
available
to
do
ci
testing
to
do
tck
testing
and
it's
essentially
a
few
scripts,
a
few
jobs
that
you
run
to
build
class
fields
to
test
it
and
to
push
it
out
to
my
central.
So
this
really
wasn't
that
hard,
but
yeah
before
that.
This
wasn't
proven
here
that
this
was
possible,
but,
as
you
can
see,
it
appears
to
be
and
class,
which
is
now
on
this
approximately
monthly
cadence.
B
A
A
A
So
one
of
the
issues
was
that
many
of
the
combat
sun
references
they
were
moved
or
made
inaccessible,
or
they
were
just
not
there
anymore
energetically
and
then
typically,
we
had
to
find
public
replacements
for
them,
and
so
sometimes
they
weren't
clear
public
replacements
or
they
were
be
quite
different
from
what
classvis
wanted
to
use.
So
we
had
to
write
new
codes
for
these
and,
of
course,
an
important
thing
was
update,
all
the
dependencies
to
jk17
and
before
that,
11
and
and
now
to
18
for
the
current
version,
that's
in
development.
A
So
this
was
not
always
easy
too.
So
sometimes
we
have
to
nudge
the
maintainers
of
such
dependencies
a
little
bit
because
they
weren't
moving
to
17
yet,
and
we
had
to
sometimes
provide
a
pr.
So
we
did
this
for
felix.
For
example,
in
a
few
occasions
we
had
to
create
a
fork
of
a
dependency
and
make
that
jk17
compatible
ourselves.
Of
course,
we
don't
want
to
fork
too
much
and
that's
extra
maintenance
overhead,
but
sometimes
it's
what
you
need
to
do.
A
A
A
That,
obviously
was
very
stretch
goal
and
it
was
to
compile
running
onto
the
k16
2.,
so
that
was
reached
with
jakarta
9.1
and
for
the
k-17
compatibility
we
actually
started
before
the
k-17
was
released.
So
he
tried
this
on
the
early
ea
builds,
and
then
we
incrementally
worked
towards
the
release
of
genetic
17.,
because
we
had
done
the
work
before
for
jdk.
16
compatibility
done
the
verb
before
that
on
jdk
11.
A
A
You
can't
oversee
the
things
that
you
need
to
do,
but
if
you
incrementally
test
all
the
time
on
the
latest
jdks
and
fix
issues
rapidly
and
step
by
step,
then
it's
it's
quite
doable
and
now
currently
for
jdk
18,
which
hasn't
been
released
yet,
but
it
did
went
into
one
of
the
last
phases
recently
we
did
the
same
thing,
so
we
had
done
a
lot
of
things
to
make
it
compatible
with
jdk
18.
So
that's
the
version.
That's
in
development.
Now
that's
62.4.
A
So
we
have
jdk
11.,
and
this
was
mostly
about
modularity,
so
we
had
issues
with
split
packages
packages
in
general
we
had
the
illegal
reflections,
so
one
packets,
doing
and
reflective
operation
for
other
packets,
and
there
were
a
lot
of
issues
with
that.
You
had
to
recode
things.
You
had
to
add
public
apis
for
things
like
you
before
and
used
reflection
with.
So
this
was
mostly
centered
around
that
jdk
17
was
about
the
with
the
jdk
theme
called
strong
encapsulation.
A
This
means
that
a
lot
of
the
sun
types,
the
internal
jdk
types,
are
not
long
or
accessible.
So
one
of
the
first
defender
there
is
probably
some
is
going
to
save.
I
just
used
a
lot
for
things
like
proxies
manual
memory
allocation,
some
compare
and
swap
things
as
well,
so
other
load
level,
things
and
yeah.
So
I
mean
I'll
say
if
it's
not
there
anymore,
it's
not
accessible,
so
we
had
to
find
replacements
for
that.
A
A
A
A
So
that's
what
we
did
for
a
couple
of
those
usages,
but
overall
this
can
be
quite
problematic.
The
databit
database
is
one
that
uses
the
security
message
quite
intensively,
so
luckily
they
had
a
switch
to
not
use
it
because
they
introduced
it
only
a
couple
of
versions
ago,
but
otherwise
it
would
be
quite
difficult
to
actually
spin
off
so
in
general,
about
a
lot
of
what
caused
a
lot
of
problems.
All
the
times
is
that
the
the
class
file
versions
change
so
like
jk
17
is
version
61.
A
A
To
support
the
latest
version,
these
are
things
like
jpa.
They
use
that
quite
a
lot
of
other
things,
hk2
uses
it
too.
I
think
typically,
it's
not
that
difficult
to
do,
but
of
course
you
have
to
you
have
to
do
it
all
right.
So
then,
one
of
the
other
things
we
focused
on
for
classes
at
eclipse
was
building
and
testing.
A
So
there's
a
lot
of
things.
There
we
moved
the
year
unit.
5
was
quite
a
lot
of
work
removed
as
much
as
possible
from
test
ng,
not
that
against
test
ng
in
any
way,
but
you
might
have
a
consistent
build
system
and
test
systems.
So
there
were
some
tests
for
test
ng,
you
change
five,
so
we
made
that
a
bit
more
consistent.
A
And
we'll
continue
to
do
that,
so
I'm
watching
the
time
I
have
to
hurry
up
a
little
bit.
Okay.
So,
let's
briefly
talk
about
class
fizz
beyond
the
server,
so
there's
things
related
to
the
components
of
classvis
as
it's
not
only
a
server.
The
components
are
used
quite
a
lot
independently
and
plus.
This
is
some
kind
of
family,
so
to
speak.
So
we'll
briefly,
take
a
look
at
that.
A
So
here
we
have
a
graph,
of
course,
not
readable
on
the
slides,
but
it
shows
which
surface
used
with
components
the
orange
ones
are.
The
eclipse
class
fits
one
class
fish
ones
and
you
see
they're
used
quite
a
bit,
so
the
the
green
one
is
tommy
e
by
the
way,
which
is
the
only
one
who
uses
components
from
a
single
fender,
although
they
do
offer
their
own
distributions
from
dummy
tribe
and
they
do
use
other
components.
A
Okay,
so
I
quickly
go
for
this
one.
So
we
see
that
jersey
and
mahara
are
used
quite
a
lot.
I
hope
this
light
displays
on
the
screen
already.
So
it's
a
bit
slow
here
and
we
see
that
another
category
of
products,
hello,
don
drop
insurance
and
piranha
clouds
which
are
not
ee
servers
or
ees.
That's
a
fight,
but
they
do
use
a
lot
of
classes,
components.
A
Okay,
so
one
of
the
things
that
we're
working
on
as
well
at
classviews
is
splitting
off
new
components.
So
we
split
off
excusia,
which
is
the
authorization
and
we're
going
to
split
off
two
more
things.
So
elias
is
going
to
be
about
current
authentication
and
transact.
It's
not
clear!
If
that's
going
to
be
the
final
name,
it's
going
to
be
jakarta.
A
A
It
has
some
extended
features,
so
you
can
configure
everything
from
your
palm
and
it
has
things
like
post
boot
commands
from
within
the
arkelian
connector
and
we're
going
to
add
some
new
things
as
well.
For
of
writing
jar
files
in
your
slash
modules,
folder,
which
is
mostly
used
for
tck
testing,
but
could
be
used
by
applications
as
well.
Okay,
so,
very
quickly,
since
the
time
is
running
out
to
classvis
7.