►
Description
Speaker: Arjan Tijms
Jakarta Faces, is the re-invention of JSF. Sacrificing some backwards compatible to shed some of its weight and become a leaner and lighter framework. This talk will describe the planned transformation.
///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
A
Other
my
name
is
Orion
times
and
I'll
be
presenting
what's
coming
to
Jakarta
faces
today,
so
Who
am
I
I'm
a
40
Dutch
developer
from
the
Amsterdam
region
and
obtained
a
Master
of
Science
degree
in
computer
science
from
the
University
of
Leiden,
the
Netherlands.
On
the
picture.
You
see
me
at
one
of
the
Colonel's,
with
a
typical
Dutch
spike,
the
true
pride
of
our
country.
So
what
did
I
do?
That's
relevant
to
this
presentation?
A
I
was
previously
a
JSF
attrition,
eg
member
I'm,
the
product
late,
the
respective
Jakarta
projects,
including
Takara,
faces
API
and
eclipse
Mara
and
I'm
the
cog,
the
area
of
the
Omni
faces
library.
It
was
a
2015
Dux,
Choice,
Award
winner
and
only
face.
It
has
been
quite
influential,
two
phases
itself,
mostly
author
of
two
books,
the
definite
guide
to
JSF
in
Java
and
proceeded
to
in
Java
8,
which
will
be
released
soon.
A
Ok,
so
the
agenda
for
today
is
as
follows:
well,
first,
we
looking
at
better
faces
is
still
relevant,
as
this
is
a
question
that
comes
up
quite
often
after
which
we'll
take
a
look
at
an
exciting
new
run.
Time
to
run
faces
on
well,
thereafter
clarify
some
of
the
first
year
madness
that
has
been
going
on
with
my
dad
recently.
Finally,
we're
going
to
take
a
look
at
that's
coming
in
the
next
version
comes
together
faces.
A
Surfaces
called
JSF
back
on,
but
this
is
a
term
we
can't
longer
use.
I
was
introduced
in
2003
by
coincidence,
almost
together
with
spring
and
think,
even
in
the
same
month,
and
it's
gone
strong
for
over
60
years
now.
This
is
quite
a
bit
longer
than
many
other
frameworks.
So
in
the
beginning
phases,
one
that
acts
focused
primarily
on
things
like
navigation
rules,
post
parks
and
all
component
places,
and
this
kind
of
structure
is
from
HTML
sorry.
A
The
idea
was
to
be
a
bit
swing
like
or
a
bit
like
the
later
fad
in
and
at
some
point
this
was
okay
but
then
later
on
it
wasn't
okay
anymore.
His
people
were
more
wanting
to
use
HTML
and
HTTP
directly,
so
phases
to
introduced
in
2009
massively
responded
to
that
effectively
was
a
major
paradigm
change.
So
all
those
things
I
mentioned
before
the
emphasized,
like
navigation
rules
mostly
and
this
place
came
first-class
support
for
regular
cab
based
links.
So
he
could
do
that
before.
A
You
could
just
use
an
HTML
link
on
a
page,
but
it
wasn't
don't
support
it
and
also
you
could
attach
a
Faraday
to
still
it's
a
little
bit
more
difficult
to
pass
in
parameters.
And
what
have
you
so
with
phases?
Two
phases
got
first-class
support
for
that
same
holes,
for
the
post
redirect
cut
pattern,
which
is
maybe
post
back
to
a
page
and
then
after
the
page,
action
has
been
done.
You
redirect
to
another
page
or
maybe
even
the
same
page.
A
You
should
get
its
means
that
if
you
come
back
to
that
place
using
your
browser's
and
Afghan
control,
you
wouldn't
repost
that
page
again.
So
this
is
a
clean
way
to
do.
First
and
just
I've
got
first-class
support
for
this,
as
well,
mainly
by
using
a
parameter
for
a
navigation
account,
so
the
page
says
diffuse
in
Joseph
the
templates
some
point
in
time.
We
started
the
best
practice
to
make
them
all
components,
based
the
idea
being
a
little
that
he
could
render
them
in
different
technologies.
A
So
there
was
a
lot
of
critique
on
Tessa,
especially
with
the
one
that
X
version.
There
were
quite
a
number
of
issues
with
them,
many
basically
resulting
from
JSF
using
a
JSP
so
that
single
decision
not
to
go
with
its
own
templating
language
from
the
beginning
but
use
reuse.
Yes,
we
had
a
major
impact
and
everything
was
followed.
Jsp
by
itself
is
really
fine
technology,
but,
as
few
templates
for
the
SS
was
like
really
problematic,
they
were
thinking
issues.
Content
was
not
aligned
entire
facing
didn't
quite
work,
so
JSF
has
to
process
in
phases.
A
But
when
you
run
executed,
HP
press,
it
writes
directly
to
the
output.
It
is
not
suited
for
yourself,
but
despite
all
those
issues,
JSF
has
the
basis.
I
have
to
say,
has
always
been
among
the
top
teams
in,
in
most
things
like
surface
number
of
questions
on
Stack
Overflow
number
of
books
written
about
it.
So
I'm
going
to
take
a
little
look
at
some
surface
here.
So
on
your
screen.
Here
we
see
a
survey
from
Jack
Stanton,
so
this
was
in
2004
and
the
shells
JSF
faces
on
the
number
two
position.
A
The
squad
could
play
spring
MVC
interest
for
quite
a
bit
lower
yeah.
Of
course
it
differs
per
per
surface,
so
in
one
survey
I
just
have
might
be
number
three
and
spring
MVC
would
be
number
one,
and
not
a
surfer
yourself
could
be
three
and
four
Dean
could
be
number
four
and
say
whatever
you
did.
Gwt
would
be
number
one,
so
it
did
to
differ
a
little,
but
the
the
main
thing,
the
the
surface
are
in
common,
that
a
surfers
like
always
in
the
top
tears.
Obviously
number
one,
two
or
three
approximately.
A
Okay,
so
this
is
a
more
recent
survey.
This
is
from
Jaffa
magazine
and
the
snake
or
snake
over
a
flea
collars,
and
here
you
see
that
the
surface
was
stuck
out
in
the
surf
and
had
ninety
percent
meaning
it
was
placed
on
number
three,
which
is
still
quite
good
with
you
still
in
the
top
tier.
So
it's
going
down,
you
can't
quite
see.
Tears
in
this
surface
is
still
like
in
top
tier,
but
overall
Jessica
uses
its
calm
down,
but
it's
still
the
quad
coated
still
in
the
top
three
yeah.
A
Okay,
so
what's
the
reason
that
Jeff
went
down
a
little,
so
it
might
not
come
as
a
surprise
to
many
that
the
rise
of
client
science
frameworks
contributed
quite
a
lot
to
this
essentially
started
in
2010
with
angularjs
Energizer's.
Actually,
in
it's
the
way,
it's
felt
the
way
it
felt
to
develop
in
it.
It
did
quite
feel
like
like
JSF
at
the
time.
A
It
was
quite
inspired,
seemingly
by
about
yourself,
then
in
2013
we
saw
a
react
by
Facebook
introduced
in
2014
a
few
and
in
2016
angular
with
the
Spanish
name
is
quite
a
different
framework
from
angularjs,
and
what
we
see
in
the
graph
is,
of
course
quite
clear,
is
a
very
big
rise
in
popularity
of
this.
So
in
this
graph
angular
is
the
blue.
A
One
and
react
is
the
red
one,
so
the
both
rising
quite
rapidly
react
even
more
so
than
angular,
and
this
has
quite
this
has
a
quite
profound
impact
on
surface
science
frameworks
like
JSF.
It's
not
just
the
JSF
that
went
down.
Other
surfaces
frameworks
went
down
as
well,
so
in
general
I
think
it's
fair
to
say
that
client-side
frameworks
are
clearly
the
more
popular
choice.
A
Today,
it's
always
hard
to
to
estimate
exactly
what
to
have
the
exact
numbers
of
users
but
conserved
estimates
with
put
client-side
frameworks
about
810
times
being
more
popular
than
things
like
faces.
Things
like
that,
sir,
but
that's
okay,
it's
especially
in
the
Jakarta
ecosystem,
the
quite
compatible
with
Jakarta
Savage
Jakarta.
He
nor
first
besides
faces
facilities
for
restful
web
services,
and
you
can
arrest
or
specifically,
Jakarta
servlet,
can
provide
the
data
that
planted
frameworks
need
to
operate
on
and
they
do
this
quite
well.
So
you
could
use
CDI
beans
for
business
logic.
A
A
If
you
look
at
some
of
the
actual
numbers
for
the
cutter
faces,
it's
it's
quite
interesting
to
learn
the
prime
face.
It's
got
about
million
dollars
in
2018.
Primefaces
is
a
component
library
for
faces,
so
this
of
course
means
that
every
crime
faces
application.
It's
also
a
faces
application
and
a
million
dollars
really
isn't
that
bad
against
okay.
So
if
you
look
at
some
of
the
other
numbers,
we
see
that
only
faces
got
approximately
a
quarter
of
a
million
dollars
last
year
and
furthermore
exceeded
some
twenty
seven
thousand
projects
and
get
up
dependent
processes.
A
Well
for
emphasis.
That's
almost
four
thousand
the
Eclipse
implementation
phases.
Mara
currently
gets
about
seventy
five
hundred
views
every
month,
which
is
not
as
much
as
it
once
was,
but
it's
also
not
crazy.
Bad
really
quite
important.
The
faces
is
also
still
supported
by
some
key
people
in
the
Jakarta
ee
community.
So,
for
instance,
Marcus
Newberg
recently
said
that
the
sf2
is
just
so
damn
productive.
It's
quite
good
against,
and
specifically
it
says
here
that
Jeff
is
still
rocking
big
time
and
especially
when
it
comes
to
easy
development
of
data-driven.
A
You
eyes,
and
that's
indeed
the
market
that
says
F
is
aiming
for
so
another
way
to
measure
whether
a
given
project
still
has
relevance
is
to
see
if
there's
an
ecosystem
around
it
and
for
faces,
it
seems
to
be
quite
a
carry.
In
the
last
month
alone,
we
cited
leases
of
boots
versus
the
leases
of
a
new
project
called
primefaces
arquillian
and,
despite
the
first
number,
seven
dat.
Oh,
this
is
actually
a
new
product.
We
subprime
crisis,
6
to
23
and
706,
and
this
product
called
joint
faces
only
faces
at
release.
A
A
So,
quite
an
interesting
development.
A
recent
development
is
that
surface
side,
rendering
often
abbreviated
as
SSR,
is
getting
more
and
more
attention.
I
think
so.
This
largely
had
to
do
because
of
the
react
surfaces,
hydration
feature
which
basically
means
that
an
entire
page
could
be
rendered
into
string
and
then,
if
you're
wrong,
they
react
on
the
surface
side,
you
could
send
string
to
the
client,
so
you
have
this
full
page
that
he
sent
but
not
just
react.
It's
also
a
few
that
yes
and
number
for
us
like
that.
A
What's
really
are
the
advantages
of
surface
rendering,
so
for
one
it
generates
ready
to
render
HTML
it's.
Basically,
that's
what
it
says:
it's
it's
email
that
the
client
can
render
right
away.
This
might
be
faster
since,
if
you
just
send
data
to
the
client
and
the
client
still
has
an
entire
client-side
framework
to
run
with
listeners
being
called
events
being
executed,
multiple
layers
of
code
that
you
have
to
go
through,
it
could
potentially
slow
things
down.
A
A
A
Obviously,
if
you
only
use
the
name
of
the
client
and
this
data
is
thrown
away
at
the
client,
you
could
of
course,
set
up
services
where
you
have
some
kind
of
graph
query
language.
We
only
ask
it
to
sent
a
name,
but
those
things
are
generally
quite
complicated
to
that
codes.
For
so
it's
not
always
done.
Did
this
surface
ID
rendering
it
essentially
does
that
automatically.
A
So
I
already
mentioned
that
less
processing
on
the
client
could
happen,
and
this
in
fact
means
that
it's
better
for
battery
life.
So
a
lot
of
devices
these
days
are
mobile,
so
the
more
processing
you
do
on
the
clients,
the
more
it
takes
away
from
that
battery
life
and
the
the
idea
used
to
be
that
a
client
actually
loves
the
CPU
to
be
used,
and
you
save
on
surface
EPO
resources
and
that's
of
course
true.
The
latter,
but
the
first
one
is
acquired
through,
like
in
general
users,
don't
like
their
CPUs
being
used.
A
So
if
there's
a
site
that
uses
a
lot
of
CPU
and
a
similar
side
that
doesn't
use
how
much
CPU
that
it
might
be
the
case
that
users
use
in
the
side
that
requires
less
CPU
and
the
devices
and
even
if
they
are
plugged
in
does
things
like
2
Phi
is
heating
up
and
app
tops
on
your
lab
that
get
quite
hot.
When
the
CPU
is
maxed
out,
you
got
all
the
noise
associated
fans,
spinning
up
which
you
don't
like.
A
Besides
that
there
are
some
potential
advantages,
instead
of
rendering,
with
security
in
a
validation.
So
it's
a
client
frame
versus
be
quite
careful
that
you
don't
do
essential
security
and
validation
on
the
client.
You
can
do
some
pre
validation,
but
not
the
actual
foundation
that
still
have
done
surfing.
A
It's
easy
to
forget
to
its
surface,
rendering
it's
it's
quite
hard
to
forget
this,
then,
with
server-side
rendering
you
can
still
do
partial
page
requests,
so
you
don't
have
to
do
full
base
requests
for
every
data.
You
need,
of
course,
with
PPR
on
the
surface
sides
framework
the
client
frameworks
to
do
able
to
heaven.
It's
depend
it.
So
it's
not
completely
perfect
here,
but
it
does
solve
the
issues
for
a
lot
of
cases,
especially
with
things
like
the
app
soccer
being
added
two
phases
to
the
three
few
years
ago.
A
It
basically
does
as
well
as
client-side
spending
verbs
okay,
so
traditionally
phases
has
been
used
quite
a
lot
with
application
surface,
although
you
could
use
it
with
surface
containers
like
Tomcat
and
jetty.
So,
let's
not
take
a
look
at
a
new
runtime,
a
new
kind
of
environment
to
run
the
faces
in
okay,
so
introducing
Padonia.
A
This
is
a
new
kind
of
run
time
to
run
applications
on
it's
essentially
a
highly
composable
cloud,
targeted
runtime,
which
is
quite
a
lot
of
buzzwords,
but
it
essentially
means
that
it's
small,
it's
a
right
sized
sat
on
includes
the
dependencies
like
he
needs.
It
starts
up
quite
fast.
It's
essentially
a
more
library,
targeted,
runtime,
then
application
so
for
target
runtime,
meaning
that
the
resulting
Java
file.
The
image
is
immutable.
You
don't
deploy
things
to
it.
It
runs
from
the
main
methods
that
initializes
the
entire
application.
A
So
this
also
means
that
things
like
unit
testing
and
peering
is
quite
easy.
Entire
application
that
you
called
kami
set
up
fully
programmatically,
that's
alternative
to
web.xml
in
applications
period.
This
moment
has
its
own
native
service
implementation
and
it
uses
plugins
for
a
lot
of
other
things
like
plug-ins
for
hora.
In
my
face
as
plug-ins
for
wealth
and
WB,
open
web
beans
and
Eddy
can
be
locked
in
a
Chris
Leak
and
collect
as
well
for
HTTP
ancient
surfaces,
and
this
runtime
is
brought
to
you
by
people
about
same
people
behind
Mahara
and
army
faces.
A
Going
forward,
Peter
might
actually
become
the
primary
runtime
that
the
model
developers
are
going
to
use
to
develop
mara
against
the
same
could
hold
for
the
Jakarta
authorization,
a
glibly
implementation,
which
is
upcoming
and
the
Jakarta
each
gives
the
implementation
citerior,
and
this
is
basically
because
running
against
developing
it
and
running
against
the
ranking
is
quite
it's
quite
easy,
so
I
can
quite
easily
code
against
that
quite
easily
configure
it
stirred
it
up.
It's
quite
fast
to
execute
unit
style
tests
against
it.
So
this
might
give
it
an
extra
impulse
come
forward.
A
So
there's
a
lot
of
extended,
tooling
support
coming
up,
so
this
is
basically
things
for
Kellyanne
flex
plugins
for
the
Eclipse
IDE,
and
that
means
what
have
you
so
one
thing
to
notice
is
that
everything
is
still
very
much
under
construction.
So
at
the
moment,
it's
quite
small
still,
but
we
kind
of
intend
to
expand
on
this
see
how
it
works
in
practice.
A
So,
yes,
the
Eclipse
IDE
opens
here
with
the
project
already
check
out,
so
the
project
is
here
and
we
see
that
we
have
all
those
modules
which
are
plugins
to
accommodate
various
pieces
of
functionality.
In
papillion
and
we
have
a
bunch
of
fit
tests
yeah,
so
we're
going
to
the
Mara
test
this
here
and
going
to
take
a
look
at
the
main
unit
test.
It
shows
how
and
fetch
the
application
can
be
run
against
granule.
A
So
if
we
see
this
method
here,
it
starts
with
assembling
an
application
using
the
put
on
your
API.
So
it's
it's
quite
small
here
you
create
a
new
web
application,
add
a
resource
to
it.
We
had
a
more
specific
initializer
just
one
here
and
then
we
start
the
application,
after
which
we
create
request
and
a
response,
and
we
tested.
If
it's
indeed
works.
A
Astonished
funds
are
put
into
this
surface
methods
here,
which
runs
a
request.
Okay.
So
this
default
directory
resource
in
this
case
refers
to
this
directory.
Here,
where
we
see
that
the
application
is
quite
simple:
there's
only
single
file
and
it
prints
out
hello
Mahara.
So
we're
not
going
to
run
this
and
simply
run
as
a
unit
test.
So
it's
run
as
unit
test
and
in
the
console
here
we
see
Mara
being
used
in
initializing
and
we
can
take
a
look
at
the
results
in
the
units.
A
Whew,
so
we
see
it
run,
such
good
has
passed
the
test,
so
the
result
is
indeed
as
we
asserted
here.
It
took
in
this
case
to
this
four
seconds.
It's
bit
on
the
slow
side,
but
it's
like
an
extremely
slow
and
laptop
ten
abusing
to
use
the
demo
is
the
normal
computer
is,
would
be
the
second
0.6
seconds
approximately.
So
this
here
basically
concludes
our
simple
demo.
A
A
A
So,
let's
see
originally,
we
had
just
Imahara
to
the
3x
rolling
brands
of
rhetorical
and
life
is
relatively
simple,
so
we
had
to
take
the
three
versions
there
and
we
release
them
from
these
brands,
and
things
were
quite
easy
so
that
at
some
point
we
use
the
the
master
at
Oracle
to
start
the
setting
for
the
transfer
process,
which
means
which
meant
cleaning
a
lot
of
things.
Things
that's
induced
anymore,
but
also
things
that
were
we're
not
clear.
But
what
you
reaching
of
it
was
for.
The
copyrights
were
not
clear.
A
So
all
those
things
were
deleted
or
the
owners
were
found
and
the
mission
was
ours
for
several
things.
So
this
work
was
done
in
master
and
while
this
work
was
being
done,
they
were
still
the
three
versions
being
released
from
the
rolling
brands.
So
they
seemed
to
be
relatively
clear.
Still
but
unfortunately,
things
they
become
a
bit
more
muddy
as
fast,
so
the
master
was
called.
That's
for
so
basically,
just
as
I
mean
to
distinguish
the
first
in
being
developed.
A
In
hindsight,
this
wasn't
the
best
idea,
probably,
but
things
happened
that
way,
a
sudden
just
before
the
transfer
took
place
to
mark
the
last
mission
from
the
Oracle
brands
to
the
fourth
Oh
was
accidentally
at
least
so.
This
is
a
so-called
but
believes
since
master
parents
palm
should
have
been
released
as
well.
If
this
were
to
be
the
genuine
released,
this
didn't
happened.
Did
the
Mars,
there's
no
specific
packets
coordinates
mean
that's
quite
hard
to
the
lease
for
so
it
couldn't
be
really
fixed,
all
sorts
as
a
result
till
it
for
its
powers.
A
Just
like
this
really
weird.
First,
you
know
maybe
central
we
should
try
to
have
it
removed
at
some
point,
normally
maybe
central
as
this
policy,
where
you
can't
remove
the
laces,
but
this
release
is
like
completely
useless,
so
should
maybe
try
to
the
most
and
then
after
the
transfer
took
place,
not
a
version
was
released,
so
this
was
from
the
Eclipse
he
for
j8
grunts,
and
we
call
this
to
the
3/2
302,
meaning
that
it
was
created
from
you
recall
the
previous
Oricon
master.
A
It
was
tilted
forwards,
oh,
but
that's
for
it
always
actually
branched
off
from
to
the
3.3
to
make
it
a
bit
less
bit
more
confusing,
actually
so
to
the
3/2.
302
was
actually
in
some
way
ahead
of
2
to
3,
to
7
and
in
some
ways
behind.
So
this
was
like
a
really
bad
situation
to
be
in
so
this
was
eventually
solved
all
the
outstanding
things
as
well
into
the
3.7,
but
not
in
to
the
3
to
3
that
102
were
merged
into
the
for
j8
branch,
and
this
became
to
the
3.9.
A
So
this
was
the
initial
version
that
used
the
EG
cutter
faces.
My
friend
coordinates-
and
like
say
this
was
potentially
to
the
3/2
302
product.
Today,
it's
between
3
to
7,
some
cleanings
here
and,
and
things
were
relatively
understandable
again
so
then
it
leaves
foj
8.
It
is
essentially
a
marker
branch
for
the
GlassFish
5.1.
The
release,
which
included
I'm
harder
to
the
3.9
I,
was
branched
into
eclipse
to
the
three
so
from
that
branch
really
still
attend
to
the
tree
there
as
well.
A
Okay,
so
then
morph
enhancer,
today
from
the
same
Eclipse
to
the
tea
brands.
We
release
to
the
treated
13,
and
this
really
special
in
the
sense
that
it's,
the
first
Jakarta
88
certified
version.
Otherwise
it's
not
the
different
with
respect
to
namespace
or
coordinates
it's
just
the
fact
that
this
version
is
officially
Jakarta,
ie8
certified
ins,
the
first
one.
A
So
if
we
take
a
look
at
the
future
releases,
we
have
something
we
probably
canticle
eclipse
they've
stood
at
nine
brands
from
Israel
to
these
Marta
to
that
nine
and
as
the
reason
for
this
version
is
that
the
upcoming
a
namespace
changed,
which
means
the
change
from
Jeff
Fox
to
Jakarta
any
ideas
that
to
that
nine
will
only
consist
of
this
namespace
change
and
nothing
else.
It
will
be
another
one
of
those
special
versions,
sir
than
a
master.
A
A
Okay,
so
let's
now
move
to
the
next
section:
presentation,
Jakarta
phases-
next,
okay,
so
Dakota
phases
next-
will
be
resulting
around
a
couple
of
different
epochs
and
the
most
important
epic
of
this
release
will
be
the
removal
of
deprecated,
slash,
temp
items
and
there's
quite
a
lot
of
deprecated
things
in
new
faces.
So
some
of
those
things
go
back
a
really
really
long
time,
like
the
native
expression
language
that
the
face
is
still
has
so
this
was
deprecated
in
2005,
with
the
release
of
facial
under
it's.
A
Basically,
the
expression
language
on
which
the
unified
expression
language
is
based,
as
wonders,
got
integrated
with
Jakarta
Serpentis.
First
then
split
out
to
its
own
expression
language.
So
this
has
been
Lin
seeing
within
faces
for
a
really
really
long
time
and
I.
Think
it's
not
really
time
to
deprecated
this
and
remove
it.
A
A
A
survey
patches,
support,
I
think
that
used
as
too
few
templating
language,
so
it
was
essentially
deprecated
in
2009
when
the
ones
external
facelets
was
incorporated
in
CSF
ever
since
then,
a
lot
of
things
didn't
support,
GSP,
Takada
server
pages,
so
that's
finally
going
to
be
removed,
then
for
states
I
think
it's
going
to
remove
as
well.
This
is
one
of
those
things
if
faces
that
might
have
been
a
mistake
from
from
day
one.
It
essentially
boils
down
to
that.
A
So
this
it's
finally
time
to
let
go
of
this
and
long
coming
is
the
removal
of
the
native
managed
bean
system
in
phases,
so
the
native
balanced
being
system
is
essentially
one
of
the
things
on
which
City
I
was
based.
So
city
I
started
as
a
project
called
de
beans
that
saw
to
unite
the
two
component
models:
the
dominant
component
models
in
Jakarta.
It
was
eg,
be
in
the
faces
management
system,
so
that
turned
out
to
be
quite
successful
and
in
practice
CDI
beans
that
replaced
faces
in
native
managed
beans
for
a
long
time.
A
For
this,
like
absolutely
no
need
to
to
keep
this
round
so
I'm
going
to
remove
this
in
the
faces
three
and
some
of
the
way
things
that
country
moves
is
the
so
called
fake
faces
to
the
two
mullet.
A
bit
of
a
temp
thing
when
faces
to
the
three
came
around.
There
were
some
concerns
that,
by
switching
things
to
silly
I
like
the
expression,
language
resolvers,
it
wouldn't
be
completely
backwards
compatible,
even
though
it
wasn't
quite
proven
that
it
wasn't.
A
They
were
concerns
raised
so
just
to
be
sure
faces
to
the
three
defaults
to
this
weird
faces
to
the
two
miles,
we're
still
the
olds.
He
never
saw
us
I
use
the
monitors
and
I
get
to
switch
it
over
to
the
three
modes
of
like
real
to
the
tree.
Like
everybody
I'm
excited,
so
this
is
going
to
be
removed
as
well.
The
result
of
this
is
that
face
is
treated
or
not
longer
be
backwards
compatible.
A
So
that's
a
major
change
that,
as
it
happens
often,
but
it's
mostly
the
old
applications,
but
still
use
the
old
things
that
was
failed
to
work,
not
modern
or
modernist
native
apps,
which
is
work.
Alright,
some
of
the
other
things
that
we're
looking
at
is
continue
to
be
basing
it
on
Syria.
Essentially,
I
has
been
introduced,
a
bathtub
ever
since
faces
to
the
to
started
with
flow
scope,
which
was
only
CDI
based.
A
Then,
if
you
had
three,
a
lot
of
things
were
rebased
on
Syria
Michael
furthers
and
the
other
solvers
we're
going
to
continue
this
so
likely.
Cdi
descends,
I
thought
to
be
introduced
then,
might
replace
the
faces
defense,
probably
for
a
while
they
will
live
next
to
each
other.
When
your
face
difference,
they
will
be
deprecated
ii
ctd.
A
A
So
several
features
will
be
split
out
to
their
own
modules,
and
this
could,
for
instance,
be
flows
and
navigation
rules,
contracts
and
maybe
a
few
other
things,
and
practically
this
means
that
an
application
can
only
depend
on
subset
of
the
JSF
API,
so
it
doesn't
have
to
include
the
entire
API,
and
this
might
make
everything
a
bit
leaner.
So
if
you
still
want
everything,
you
can
just
include
the
full
module.
A
So
we
have
compiled
a
small
list
of
things
to
be
considered
in
search,
there's
nothing
sure
yet,
but
these
are
the
things
were
looking
at
at
this
moment,
so
they
are,
for
instance,
extensionists
refuse
by
default,
and
there
might
be
an
option
to
switch
that
off
or
option
to
switch
the
behavior.
So
take
a
look
at
that
in
a
while.
We
might
look
at
a
new
face
or
a
life
cycle
for
MVC
push
which
it
has
quite
often
being
requested.
A
That's
because
the
first
shell,
of
course,
in
MVC
a
pool
first
MVC
push
it's
a
bit
like
programming
language
with
functional
versus
object-oriented.
The
people
have
strong
ideas
about
that,
but
I've
got
to
take
a
look
at
this
in
a
bit.
The
other
thing
that
we
also
get
complaints
about
is
the
the
API
for
studying
faces
message.
A
The
other
thing
we
want
to
look
at
that
has
been
done
a
couple
of
times
in
prototypes,
but
never
included
in
faces
proper,
is
first-class
support
for
creating
fuse
in
Java,
so
currently
most
codes,
most
applications
with
use
facelets
to
do
this,
but
actually
that's
pretty
usable
java
api.
It
isn't
the
same
thing.
Hans
users
take
use
this
for
creating
dynamic
components.
A
Statically
the
dynamically
manipulates
the
few
using
the
de
Java
syntax
to
create
components
to
add
components,
but
you
could
just
as
well
create
interference
by
so
that
API
has
basically
been
there
since
day,
one
in
phases,
but
it
is
therefore
like
a
real
easy
way
to
create
inside
fuse
this
way.
So
we
intend
to
add
something
for
that
and
weapons
other
things.
Small
thing
is
stateless
fuse
as
a
global
option.
A
A
Okay,
so
that's
the
current
progress
for
both
implementations,
mara
and
my
faces
motor
started
with
removing
some
of
detector
deprecated
items
in
the
master
branch,
although
we
did
have
to
do
a
lot
of
work
for
the
future
brands
for
the
recent
Dakota
release.
So
this
has
all
been
done
in
other
branches,
meaning
that
we
can
interface
in
this
situation,
where,
like
one
branch,
is
a
hat
in
one
way
and
the
other
branches
hat
in
another
way.
A
So
we
probably
have
to
consider
that
a
little
bit
and
then
continue
work
in
master,
especially
the
brackets
changed
its
upcoming.
It's
quite
it's
quite
impact
on
the
work
you
learn.
So
we
also
see
that
my
faces
has
started
with
removing
the
JSF
expression,
language
and
the
admins
being
system,
and
they
did
a
big
cleanup
as
well.
So,
for
instance,
emerged
the
public
modules
into
my
faces,
new
plum,
and
this
was
done
because
there's
no
other
dependencies
on
though
so
they
could
just
well
include
them
there
and
it
has
kind
of
quite
a
bit
faster.
A
A
Okay,
so
let's
take
a
look
at
an
example:
what's
removing
the
native
expression
language
details
so,
as
you
see
here
is
the
action
search
in
defense,
which
is
quite
well
known
in
the
faces,
and
they
have
all
these
methods
that
are
related
to
the
old
expression,
language
and
that's
melted,
binding
and
value
binding,
mostly
so.
The
the
problem
with
these
methods
is
that
it
it
takes
time
to
mentally
digest
and
to
notice
it's
deprecated.
A
So
if
you
have
all
these
methods
all
around
the
interfaces,
it
just
makes
it
so
much
harder
to
see
the
actual
methods.
That's
thought
to
be
used,
so
they
don't
really
hurt
the
system
to
be
there,
but
they
just
contribute
Elemental
hopeful,
a
lot
of
developers,
so
methods
like
you
see
here,
are
going
to
be
removed.
A
For
a
second
example,
let's
take
a
look
at
the
extensionists
URLs
by
default
feature.
First,
extensions
URLs
are
URLs
without
any
needless
markers,
and
these
markers
are
useful
mapping
to
to
tell
the
system
essentially
which
serve.
That
is
come
to
me,
you
folks,
to
handle
a
request.
So
these
would
be
things
like
that:
XHTML
much
less
faces
in
the
beginning
of
the
path
other,
of
course,
less
faces
in
the
beginning
of
the
powerful,
technically,
not
pin
extension,
but
it's
a
general
term
being
used
here.
So
an
example
of
this
would
be
the
two
URLs.
A
The
first
one
doesn't
have
the
dots
XHTML
nor
the
second
hash,
and
typically
did
that
this
just
cluttered
the
Urich
al-khalil
so
in
faces
to
the
three
into
this
quite
some
groundwork
to
make
a
stencil
as
urls
possible,
essentially
edit,
my
methods
to
obtain
all
the
fuse
that
are
available
within
the
system.
This
is
PDL
templating
language
specific.
You
can't
really
know
where
video
stores
its
fuse
in
the
general
way.
So
you
have
to
ask
the
video
implementation.
A
The
default
cases
would
be
faceless
where
all
the
URLs
and
sorry,
even
all
the
fuse,
stored
and
two-bit
few
names
they
correspond.
So
we
did
this
grunt
work,
but
then
we
basically
run
out
of
time
and
with
anything
still
it
includes
it's
a
high
level
feature.
So
there's
the
ability
to
grab
the
diffuse
to
map
them,
but
there's
not
a
single
switch
to
turn.
This
on
at
the
moment,
user
application
would
require
quite
a
bit
of
elaborate
code
to
do
this.
A
A
Essentially
you
get
the
face
of
servlets.
You
can
all
diffuse
any
applications,
and
you
add
my
mapping
for
each
view
to
this
servlet
and
that's
essentially
itself
as
very
difficult,
but
still
quite
tedious
to
do.
Okay,
so
we're
actually
looking
at
two
options
to
do
this
option.
One
is
extensionists
by
default
and
option
two
would
be
extensibility
as
an
option,
so
it's
option
one
by
default.
That's
the
Bible
cleanest
way,
but
then
again,
if
you
want
to
preserve
some
kind
of
backwards
compatibility,
this
might
not
be
the
best
option.
A
So
everybody
running
an
existing
application
might
want
to
switch
this
off
for
other
applications
which
which
might
not
be
that
nice,
but
they
could
do
so.
That
would
be
simple
and
faces.
Conflict
annotation
with
extension
list
is
false.
A
set
option
two
would
be
the
exact
opposite,
so
it
would
have
the
same
option
only
if
you
would
want
extension,
as
you
would
start
true.
A
So,
besides
the
simple
on/off
option:
we're
looking
at
some
other
attributes
for
this,
so
this
good,
for
instance,
be
what
to
do
when
the
original
page
is
being
requested.
So
this,
if
you
won't
do
anything,
you
would
get
the
source
of
the
page,
which
would
not,
of
course,
be
what
you
want.
So
we
could
look
at
essentially
two
options.
One
of
them
would
be
to
send
a
404
and
that's
valence
when
the
original
page
is
requested.
A
So
this
will
be
the
one
with
the
extension,
the
other
one
would
be
redirects
to
the
extension
list
version
and
maybe
just
another
option
would
be
to
just
render
dependence,
but
for
this
example
and
for
the
XHTML
they
represent
the
same
contents.
So
that's
a
sure
which
one
we're
going
to
add
this
one
to
default,
which
would
be
the
most
important
decision
to
make
so
still
looking
at
this.
A
Okay.
So
for
the
third
example
can't
look
at
the
embassy
push
proposal
so
faces
started
this
MVC
pool.
It's
also
called
component
based
MVC
and
what
MVC
pulled
us
is.
It
logically
starts
processing
at
the
fume
and
then
a
few
precision
data
from
multiple
place,
multiple
controllers,
if
you
want
to
inject
itself
in
phases,
this
is
technically
not
even
Akali,
since
it
starts
processing
at
the
faceless
servlet,
which
is
the
controller,
and
then
the
controller
caused
a
few.
But
logically
now
people
feel
this
works
is
that
the
few
starts
processing.
A
So,
even
though,
if
you
can
pull
in
data
from
multiple
places,
it's
just
an
expression,
language
reference,
that's
being
used
and
it
can
essentially
put
in
with
it,
but
everyone's
best
practices
for
a
long
time
said
that
only
one
controller
should
be
used,
perfumes.
That
would
be
the
backing
beam
and
the
general
rule
is
they
have
one
backing
beam
per
few,
so
it's
good
still
reference,
some
helper
being
some
help
controllers,
but
essentially
the
main
advice
has
always
been
a
bond
controller,
I'm
backing
being
perfu
so
in
phases
to
delete
in
2009.
A
We
did
already
add
a
couple
of
things
for
MVC
push,
so
this
is
also
called
the
action
oriented
paradigm,
and
these
were
essentially
the
few
param
and
a
few
action.
So
specifically,
the
few
action
disquiets
actually
oriented
that
you
name
to
to
action.
So,
but
these
few
action
does
it
execute
some
action
at
the
start
of
page.
So
you
still
logically
have
the
page
first,
but
the
action
is
essentially
executed
when
the
page
is
requested
in
place
is
loaded-
and
this
has
this
action
oriented
feel
to
it.
A
Ok,
so
there's
a
few
actions
in
yourself
in
phases.
They
can
sometimes
be
a
bit
hacky,
but
I
feel
a
bit
honking.
So,
for
instance,
if
there's
always
a
redirect
to
a
different
view
needed
view,
the
page
template
that
triggers
the
few
action
it's
actually
kind
of
on
the
necessary
it's
just
empty
place,
holder
and
URL
map
in
humans,
so
that
that
feels
a
bit
with
heavyweight
in
that
sense.
A
So
the
proposal
is
to
introduce
an
action
lifecycle
phases,
and
that
means
that
essentially,
the
entire
current
lifecycle,
the
facial
surface,
is
in
fact
it
and
all
those
page
tries
to
see
if
there's
anything
that
needs
to
be
restored.
Children
Citra,
there's
not
going
to
be,
in
fact,
actually
I
could
only
call
a
been
a
city
I-beam
which
could
then
access
the
controller.
A
The
controller
could
help
redirects
or
performs
an
action,
but
have
here
so
it's
important
to
realize
this
is
not
going
to
compete
with
ricotta
MVC,
which
is
the
other
framework
we
have
in
Jakarta.
Jakarta
MVC
is
basically
a
pure
action
based
framework
kind
of
like
spring
MVC,
where
you
have
to
arrest
based
controllers
and
the
entire
and
logical
thing
that
the
entire
components
saying
does
not
exist.
A
So
it's
a
bit
like
programming
languages
again,
where
you
have
pure
functional
languages
like
Haskell
Lisp
and
you
have
pure
object-oriented
languages,
and
then
you
have
languages
that
are
like
a
bit
in
between
like
Scala
a
cuddly
recently
Java,
but
they
do
lean
more
towards
a
certain
spectrum.
So
obviously
Java
has
some
functional
aspects
to
it,
but
it's
only
some.
It's
still
heavenly
leads
leans
toward
the
object
oriented
model,
so
this
would
be
the
same
with
its
faces.
So
it's
bit
of
some
action.
A
Things
like
it
already
has,
but
it's
not
going
to
be
an
action
oriented
framework.
It
remains
a
MVC
pool
framework.
So
this
new
action
lifecycle
is
intended
for
cases
for
currents
faces
applications
with
now
just
use
a
servlet,
so
Esther
floods.
Worse,
of
course,
it's
can
process
a
request
to
do
some
processing
redirect.
So
that's
essentially
fine,
but
the
thing
is
that
the
surf
that
doesn't
have
the
faces
contacts
available,
so
it
runs,
but
it
doesn't
run
within
the
faces
context.
So
some
things
can't
be
used
there,
some
sculpture
on
to
active.
A
Ok,
so
let's
take
a
look
at
some
cards.
Let's
yeah,
this
actually
looks
some
practice.
So
what
we
see
here
is
the
action
beam
and
it's
basically
made
into
an
action
beam
by
having
this
actually
mapping
intersection
method,
and
this
would
reference
a
URL.
So
this
this
beam
is
fully
executed
within
the
faces
context,
but
minute
execute
first
upon
receiving
a
request
for
it.
There's
no
fake
ntp,
it's
loaded,
there's
not
a
action
record
behind
the
scenes,
it's
just
the
servlet
that
is
behind
this,
with
a
focus
being
right
away.
A
So
these
are
the
advantages
of
be
quite
simple,
so
this
can
be
implemented
with
just
a
few
lines
of
code.
Essentially
in
the
implementation.
We
have
a
prototype
available
for
this,
which
is
on
the
URL
shown
below,
and
it's
clear
it's
not
that
much
code.
It's
essentially
a
custom,
a
large
cycle,
custom
servlet
and
it
looks
up
at
being
in
execute.
It
is
not
much
more
than
that,
and
so,
even
though
it's
it's
quite
simple,
this
might
really
really
help
Joseph
okay.
A
So
this
were
most
examples
as
we
were
looking
at
so
we're
coming
to
the
end
of
this
presentation.
As
usual,
you
can
help
help.
Is
a
lot
appreciate
it
and
a
lot
of
people
to
help
at
the
moment?
So
that's
a
big
thing,
big!
Thank
you
to
all
our
contributors
out
there.
The
URLs
are
listed
here
and
if
you
want
to
contact
us,
that's
the
mailing
list
as
well.
So
once
again
thank
you
and
without
coming
to
the
end
of
the
presentation.
Thank
you.