►
Description
Introduction to Jakarta Commons.
- Common components for Jakarta EE specifications
- What are the drivers to propose this new specification project, what should be in scope for the first release, and what are the ideas for the future.
A
A
B
Thank
you
very
much
good
afternoon
or
whatever
time
of
the
day
is
your
time
zone.
I
will
try
to
introduce
the
ideas
why
I
propose
jakarta
commons
and
also
show
us
short
example
of
one
of
the
areas
that
are
of
interest.
So,
let's
start
so.
Why
did
we
or
did
I
decide
in
the
end,
to
go
for
it
and
try
to
get
people
behind
this
idea?
B
B
B
B
B
B
I
will
show
a
small
example
on
that,
after
I
finish
with
the
slides
support
for
java
package
for
for
java
module
system,
this
needs
to
require
some
analysis,
but
there
are
certain
things
that
are
repetitive
when
it
comes
to
package
package
to
modules.
So,
for
example,
how
can
you
expose
a
class
that
you
have
to
a
specification
rather
than
to
the
implementation,
and
still
the
implementation
can
access
its
internal
types?
B
So
this
this
will
require
some
work
to
find
out
if
there
is
actually
anything
we
can
really
nicely
do,
but
you
know
that's
definitely
an
area
that
could
improve,
so
we
will
see
what
can
be
done
there.
Another
area
that
is
very
important
for
me
is
consistency,
and
this
comes
to
feature
consistency
on
design
patterns.
B
So
if,
for
example,
builder
pattern
is
accepted
by
you
know
the
whole
jakarta
ee
environment,
it
would
be
great
if
there
was
some
support
for
it
in
the
common
module,
for
example,
an
interface
defining
the
basic
methods
of
a
builder.
And
again
we
already
have
some
ideas.
This
needs
to
go
through
discussions,
but
that's
that's
one
area
that
is
interesting.
B
Priority
handling
we
currently
as
part
of
the
config
specification.
We
reopened
the
discussion
on
on
priorities
and
their
handling
and
again
it
would
be
great
if
we
managed
to
find
some
way
how
to
how
to
define
a
consistent
handling
that
could
be
then
easily
reused
by
other
specs,
rather
than
redefining
what
it
means
for
every
specification,
as
it
is
right
now,.
B
The
last
feature
we
talked
about
is
language
model.
This
is
coming
from
mostly
from
cdi
light
specification
where
there
is
a
need
to
to
do
some
processing
at
compile
time.
You
know
it's
expected
that
at
build
time
you
will
create
some
kind
of
metamodel
that
then
will
be
reused
at
runtime,
so
you
don't
need
to
do
reflection.
B
This
comes
obviously
with
a
need
to
define
a
model
that
will
describe
the
java
classes
and
interfaces
and
annotations
and
so
on,
and
this
model
right
now
is
part
of
cdi
and
again.
You
know
we
saw
already
when
we
were
talking
about
it,
that
there
probably
will
be
need
by
other
specifications
to
do
something
similar.
B
B
Probably
there
are,
these
are
links
that
you
can
have
a
look
at,
so
there
is
the
proposal
for
jakarta
commons
that's
available
on
eclipse,
and
the
discussion
is
a
link
to
a
google
document
where
you
can
also
see
some
comments
from
others.
When
I
first
created
the
document-
and
I
asked
for
others
to
comment
so
if
you
are
interested
in
the
development
of
that,
you
can
have
a
look
on
that.
B
Okay,
so
the
last
part
is.
I
want
to
show
one
of
the
reasons
why
I
think
this
is
needed,
so
here
our
four
I'll
make
it
slightly
bigger.
If
I
can,
these
are
actually
four
statements
that
are
using
data.
Mostly
the
same,
we
are
trying
to
create
an
instance
of
something
of
a
meta
information
or
for
a
type.
B
So,
for
example,
you
can
ask
cdi
to
select
a
list
of
strings
or
you
can
ask
jax
rs
to
give
you
a
list
of
strings
or
you
can
ask
inheritance.
Example,
configuration
to
give
you
a
list
of
strings,
so
it's
exactly
the
same
semantically,
the
same
code,
but
you
can
see
that
we
have
four
different
types
coming
from
different
either
specifications
or
implementations,
but
all
of
these
are
depending
on
one
or
the
other
specification
of
jakarta.
B
B
B
B
A
Okay,
I
don't
see
any
questions
here,
so
if
anyone
has
any
questions,
please
feel
free
to
drop
them
in
the
chat
or
at
the
bottom.
Under
the
ask
a
questions
tab
and
while
we
wait
for
that,
I
will
just
wrap
up
so
our
next
jakarta
tech
talk
happens
january
12th
with
reza
raham.
As
he
presents
applied
domain
driven
design
blueprints
for
jakarta
ee.