it have David tonight David actually
came to Singapore one year ago he was
actually visiting and speaking for a
conference I think it was for Rocco
waltz if I'm correct yep and yeah and
yeah it was pretty awesome it was really
good
meet up with him and we thought to
invite him again and so today like will
be more talking about coffee features of
Java like what to expect in the future
and what's be having the newest versions
of Java so we're very happy to have
David's eventually today and hope to
have him in person again in the future
thank you David thank you well in yeah
in fact I was supposed to come back I
think in June but yeah anyway thanks for
having me so despite I'm sorry despite
the hard situation I'm very happy to be
able to give these remote presentations
so the title of the session is Java in
the 40 version the thing is that more
and more I realized that given we have
accelerated the currents of the Java
release people are are somehow confused
about what's in Java so today what I
want to share with you is basically what
features will be added in 2020 in the
Java platform why why 40 well I'm
french-speaking and I always confuse 40
and 14 so given that we have just really
in a version 14 of Java this is really
what I'm going to talk today having said
that I will also discuss about Java 15
which is which will come later this year
in 2020 so this is a standard server
what is this camera from Oracle don't
make any process decision based on what
I will say today having said that
everything is open source so we're good
on that side the only thing that you
should you should keep in mind is that
and if anything that I say about Java 15
can in theory still change I mean Java
team will be released in September so
between now and then there might be
change that something that you have to
keep in mind about
disclaimer okay May is a very important
month because we are about to celebrate
the 25th anniversary of Java so Java has
been released the first release has been
released 25 years ago so we were just
about to celebrate that anniversary the
thing is that Java keep evolving since
25 years based on two core principle the
first one developer productivity second
core principle is application
performance this has been done through
the last 25 years in the face of
constantly evolving things such as
programming programming predicts for
example 25 20 years ago we're not really
talking about any kind of functional
programming when it was when it when
were talking about Java
that's something since then that has
been become more and more important
something else that evolved is
application style in the beginning we
were mainly talking about client-server
application we're talking about
Minnelli's application those day
obviously it's more and more about micro
services so this is yet another
revolution that Java has to cope with
deployment styles in the early days we
were deploying in our own data center on
large Java those day we tend to deploy
using containers in the cloud so that's
another big shift when it comes to to
the way we deploy our application and
again Java has to cope with that and
last but not least obviously the other
one is evolving so those day for example
we have more and more course in our
machines we have more and more memory we
have vector support directly built into
general-purpose computers we have
multiple level cache when it comes to
memory and so on and so on
so does blas this is basically out of a
divorce for the last 25 years and this
is how it will continue to evolve so
this is a pretty busy slide I'm not
gonna spend time on this slide this
slide basically lists all the features
that were added in Java 9 and Java 9 was
the special release
in the sense that it was the latest
large release of Java and there's a big
issue with that so every two to three
years we were releasing one Java version
with a bunch of features so when it
comes to adapting those features it was
very difficult because the developers
basically had horror of a sudden access
to a bunch of features so getting a
getting familiar with those features was
very difficult so we decided to change
the way Java is evolving so now it works
this is something that we have put in
place end of 2017 so every six months
does there is a new Java release so it's
called it's called a feature release so
11 12 13
the current Java release is 14 released
in March and in September 2020 we're
gonna release 15 that's a given six
months later
16 and so on and so on now all those
feature release are open source and are
supported until the next release comes
out so 9 was supported at least until 10
cans out and so on and so on so that
means that today 14 will be at least
supported and until 15 comes out and 115
will be released in September the
current release will be 15 and that does
Italy if you're in the open source aisle
you should use that version because
that's the that's the version that is
supported
now we also acknowledge that there are
some user typically enterprise they are
not able to move that rapidly so moving
for 14 to 15 is in itself not a big work
given that they are not demanding that
penny features between all those beliefs
but still there are people there are
there are some type of user that prefer
to stick to one release for many many
years so that's what that's why we are
tricolor I have decided to have
long-term support release so basically a
long-term supporter ease is nothing more
than a given future release that we take
and we maintain for a very long time 11
is the current LTS the next one will be
17 so those release would be supportive
supported for many many years despite
the fact that obvious
we will still have every six months and
new features release so basically it
provides choice either you use the open
JDK build that Oracle is providing they
are free the only thing is that if you
are using those bills well you'd better
keep with the Java release guidance
so right now ideally you want to be on
14 because this is the race that is
supported and that's also the reason
that is getting the security updates if
you are not able to move that quickly
Oracle also sells support for Java
that's the Oracle JDK so when it comes
to buying Oracle support there are two
things that you should look at the price
of that support honestly the price of
the Oracle support for Java is pretty
cheap but I will let you judge that the
only thing that you would need to look
at when you decide where you want to get
your support for Java is basically the
ability that the organization you are
looking at is able to support you and
this slide shows the number of issue
that were fixed in in this particular
example in GDG 14 and we see that Oracle
is clearly the company that contributes
the most to Java so the takeaway here
Java is still free dr bean there has
been a lot of countries and confusions
regarding that but java is and remains
free so now let's quickly discuss about
how can we enable faster innovation
within the platform so the first thing
that we put in place two or three years
ago was this new release guidance where
every six months we have a new release
we also have the just the jep's
mechanism so chip stands for jdk enhance
and enhancements proposal so it's
basically a mechanism that we used to
introduce in the platform new Java
language features new GDK features or
even we're using that process to remove
things from the platform or we are also
using that features for example to
evolve out the open to open JDK project
is manager so it's basically some kind
of lightweight mechanism that clearly
that is clearly documented and tell the
community how things are supposed to
work when it comes to doing something
non-trivial non-trivial in the into the
platform next to that we have also put
in place multiple feedback feedback
mechanism that we are using to get
feedback on non final features so the
thing is that whenever we put something
into the platform as soon as it's final
it's something that is there forever
so it's basically it becomes permanent
so we'd better get it right before we
turn something into a permanent feature
within the platform so for that we have
multiple mechanism that we can use to
basically give to developers non final
features we encourage developer to used
on those non final features and based on
the feedback we can still do adjustments
to those features before we make them
permanent so we have the preview
features mechanism which is used more
for language Java language features will
serve experimental features which we use
mainly for odd spot VM features and then
we have an additional which sorry
additional mechanisms such as encoder
modules
early GDK access built that we use to
basically give access to to prototype of
new capabilities that we are thinking of
adding into the platform and last but
not least we have an ongoing open JDK
project that his name's Karass so the
the goal of SCARA
is to investigate alternative to
mercurial so if you are looking if you
know open JDK you know that for many
years open JDK when in fact since the
beginning open JDK has used a mercurial
as his as its source code management
solution it worked for many years but
honestly material is a bit tough to
learn so if you want to encourage more
contributions
well we'd better look at alternative so
that was the goal of that project look
at our alternatives and the outcome is
skaara selected git as the alternative
so that means that all the open JDK
development is moving to get SCARA has
also looked at Austin get provider
Gaeta has been selected but Kelly
skaara and openjdk is not tied to a get
up so if something goes wrong with
github we can easily switch despite the
size of the project where different gate
providers and last but not least Kara's
also looked at how we can improve the
complete development lifecycle of open
JDK by adding on top of it some
additional tunings
so a bunch of open JDK project I've
already moved to github we have the list
here amber Sierra GMC loom and so on and
so on and all the rest obviously are
planned to move in fact we plan to move
GDK itself hater around I think end of
GDK 15 so that would be still in 2020 or
around early 16 so still in 2020 but
still all the project are ridden alive
read-only
amuro's on the tabs so basically all
those all those barrettes won't give us
the ability to enable faster innovation
within the platform something that we
have already used and we clearly see the
benefit of all of those tools sorry so
delivering faster so we have enabled the
ability to deliver to deliver faster and
well let's look at what we have
delivered recently when I say we it's
really open JDK community obviously
Oracle is a big player in that community
but it's not just a rifle right so Java
10 delivering in March 2018 those are
all the features I'm not going to spend
any time on those release because we're
we already have enough to cover with a
14 and 15 the only thing is that you
might seem that we have two Jet's that
are in kind of yellow orange color those
have been delivered by someone else than
Oracle so the one in blacks are coming
from Oracle and yellow one are coming
from other open JDK members and I
believe those two are coming from reddit
then we had 11 which was a pretty big
release in terms of capability the thing
to keep in mind is that any features
release is driven by the dates so it's
either March or September's they are not
driven by features so if if a feature is
not ready to be included in a given
feature release well it's not an issue
that features will just have to wait the
next feature release 12 March 29 13
September 20 1913 was clearly a
relatively small release but yeah anyway
14 that was released two months ago
basically well cope with the fact that
nothing was really modest but again the
only thing that did drive those release
is the due dates not the content so
today we're gonna discuss us some of
those jabs that have been headed in a
Java 14 again we see that there are two
Jet's coming from know that are not
coming from Oracle non-volatile byte
buffer I think is coming from Reddit and
helpful pointer exception that we're
gonna discuss later is coming from sa P
okay so Java 14 was released in March
2020 everything is open source Sajida GD
k dot java.net slash 14 you can have
access to the open JDK builds of 14 you
can also have access to all the
technicals content for regarding that
release now quickly Java 15 what do we
know about Java 15 well first and
foremost we know that Java 15 will be
released in September 2020 we also know
the schedule so we know that random
phase 1 that's basically when we have
the feature freeze is in 1 months from
now so 1111 of of June so today based on
the information that is available in the
open JDK project we can already discuss
about what's being planned within 15
that's what I'm gonna do today now keep
in mind that things can obviously still
change we can add things at the very
last minute or we can even drop things
at the very last minute depending on
well on some stability
issue or something else things can might
still evolve so that those tunings
basically gives you the content that is
plane 414 so we clearly well it's a very
interesting time for Java because we
clearly have a very rich pipeline when
it comes to features why because my well
quite as well I wouldn't say many years
ago but five to four years ago we have
decided to work on very ambitious
project a multiple project that where
long terms are in the project and they
each had a goal to basically either
fundamentally improve certain aspect of
the Java platform or event reeve revamp
a given aspect of the platform so I'm
going to discuss some of those today the
GCC amber Panama Varela metropolice loom
and so on so very quickly the first one
that I want to discuss is the GC 0 GC so
it's low latency scalable garbage
collector that we started to work on few
years ago it was introduced as
experimental features in Java 11 and the
main goal of the GC is basically gives
you the lowest latency possible so it's
a concurrent GC meaning that all the
heavy lifting work of the GC is done
basically while your Java threads are
being executed so there are a few posts
but they are reduced to about well to
the smallest possible to the smallest
time possible we claim that the post
time should stay below 10 milliseconds
with on with the GC but what we observe
is that most of the time the poles are
more around 2 milliseconds which
obviously is very low
it's callable in the sense that the post
time will not increase as you grow your
Y or your life sets so the 10
millisecond post time is something that
you would get typically on a one
gigabyte it but also on a one terabyte
if so there's no change in that from
judges in the in the early days was
designed for large ships multi terabyte
if but it turns out that they are used
case where it also make sense to use the
GC for smaller hips so one of the
features that we have added recently is
the support for a few megabytes it's I
think that the law was that we can go is
8 megabytes so how do you use as a GC
today so I mentioned that the GC was
added as an experimental feature in a
Java 11 so you need to unlock explicitly
the GC so there is a specific hotspot
flag unlock experimental a vm option to
basically unlock any experimental
feature of the vm so you do that and
then you use the specific flag to enable
the GC so basically to sell the vm to
switch from g1 which is the default GC
to zgc
and there we go then the thing that you
might want to do is tune the GC to tune
the GC the thing that you need to do
basically is just said the each size one
of the design goal of the GC was also to
provide a default behavior that avoid
any tunings
obviously you still have the ability to
do more tuning than just setting the hip
size but by default the GC should should
give you a good result with just setting
the website so AGC what is the history
behind the GC GC was initially
introduced in 11 as an experimental
features on linux we have hadded
additional capabilities in 12 intersted
the GC support was added for arm 64 and
finally in 14 so there is that we have
done two months ago is hiring support
for Mac OS and windows for the GC and
the plan is to make the GC as a
production feature so basically we are
removing that experimental flag from the
future in DDF 15 so this year
so this is a picture that I took only
earlier this year in Sweden and on stage
was a Monica Beckwith from Microsoft and
well that's her claim it's not my claim
so zgc shine when it comes to
responsiveness so I encourage you to
check her presentation which is now
online where she goes basically about
the benefit of zgc now let's quickly
talk about G 1 G C so G 1 G C is the
default G C obviously we have made a lot
of investment within GGC but that
doesn't mean that we were not looking at
improving G 1 so for example in 14 we
had it support for a new ma so new must
stand for non-uniform memory access so
basically that means that some some
memory might be well the distance
between the memory and the course is not
always equal so from 1 cor accessing a
given memory might be more expensive
because it's more distant than accesses
memory in a different part of the well
formed from a different course parallel
GC was new more worse in C this a long
time so in 14 we have had it support
Numa support for G 1 and that's not all
if we look at the number of an
enhancement that we have done in our on
G 1 since gk8 it's over 700
announcements that together greatly
improve G 1 so the shafts shows for
example so the shots below shows the
native memory overhead caused it by the
by your G 1 GC for a heap size of 6 16
mega byte and what we can see is that
well if we look at g DK 8 the extra
native memory was a run for megabyte in
11 it was around well it was below 3
sorry I said megabytes gigabytes so 8
need an additional 4 gigabyte 2 GC that
large heap
GDK 11 it was reduced to I think 2.7
gigabyte and in 14 its it has been
reduced to 1.7 gigabyte so basically you
see that by switching from 8 to 14 we
have greatly reduced the memory
footprint of g1 not only that we also
improve the performance so basically
when you put together all those heaven
and reading enhancements that improves
g1 a lot across all areas so throughput
footprint latency and so on and so on so
that's something that you you need to
consider if obviously GC well the GC GC
characteristic as you are important to
you you need to think about moving to a
newer version of the of the platform so
this is another chart that shows some of
the management that have been done to g1
so let's see this is using the standard
spec gbb benchmark so this one is using
a fix it fix hip so set to 4 gigabyte
all the results are normalized and I her
is better so we have maxed G ops and
quick LG ops both are looking at the
throughput the thing is that quick LG G
ops is looking in addition to throughput
is also looking at Latin Z's
so we can see that parallel GC has been
included so the performance of our LG C
has been increased between 8 and 14 but
we can also see that there is a huge
boost in terms of latency improvement
when it comes to G 1 in 14 having said
that if you look sorry at this slide at
the next slides we see in this
particular case so this is whether with
a heap of 16 GB gigabyte that there has
been a regression between 8 well we I
don't have the result of G 1 here but we
can clearly see that there is a drop so
we had a
aggression basically and I don't
remember the exact issue if you want to
know more about the given bug it's you
just need to check the blocks at the
bottom of the slides but that issue has
been solved so we can clearly see that G
1 in 15 will improve the latencies we
see that the throughput is is while
there is a slight drop in terms of
throughput only 97 percent versus
hundred percent well it's a small it's a
small basically small trade-off but when
we see the benefit that gives that it
gives in terms of latency improvement I
think that it's fair to say that it's ok
to pay that that's more price so quickly
stuffed-up time is something that we
always look to improve in all the Java
release and obviously 14 is not is not
an exception now we can see in this case
that the stuff that time for a given
it's a small application it's basically
a HelloWorld application there is a
small improvement
obviously the as faster we get the more
difficult it is to find large
improvement but still between 13 and 14
the startup time has been improved and I
can already tell you that between 14 and
15 it we still slightly improved now
this is basically the same benchmark but
with different scenarios so a hello
world application a hello world
application that uses a lambda
expression and then a hello world
application that is using a conquered
string I think I knew basically seen
that across all the release we are
improving the startup time for those
different scenarios so that's something
that again is useful over time whenever
you switch to a larger to a newer
version of Java so now let's talk so we
have discussed about the GC which which
is one of that those ambitious project
basically having a new garbage
collectors that provide low latency
another one that deal with memory
is project Valhalla and that that is a
clearly very ambitious project so the
code of general of vanilla is basically
to reboot the relationship that the gvm
are with the data in memory so if you
know Java you know that Java is very
good at optimizing code we have for
example a JIT compiler that will improve
over time your code as it runs so on
that side we're good but the next step
is we to look on how we can optimize a
data in memory now there's an issue we
have the jet d'eau Java type systems
something that obviously is very
powerful but there is a price price to
pay and sometimes we miss a bit of
flexibility and that's basically due to
the fact that each object has an
identity it's something that obviously
is needed we are not going to get rid of
object identity it enables mobility
polymorphism and so on and so on on the
other hand there are some use case where
objects might not need identity but
still today they have to pay the price
for that features even though those
object might not benefit from identity
so basically project Valhalla is looking
at how we can improve the density of
information within memory and the thing
that the team is looking at is basically
how we can declaratively say that ok for
that type of object I don't need that
object to handle an identity it's not
something that can be done automatically
so that we involve some help from the
developers so the developer will have to
specifically say or specifically say ok
for that type of object I don't need
identity and then the VM will be able to
improve out those object will be stored
into memory and the VM will be able to
increase the density to a memory density
for those type of objects another pro
is projecting so if you look today they
are well I will simplify a little bit
but there are two types of programming
approach so you have a traditional
blocking approach so it's very easy to
program to develop with the thing is
that well it's so it's very easy to
develop it's also very easy to debug the
thing is that that approach doesn't
scale as soon as your code blocks
well basically your code is waiting for
something to happen so you are using
while you are blocking resources
that's not very effective on the other
hand you can go for a model that is more
geared towards a reactive approach the
thing is that developing reactive
application well that's on one hand a
very difficult model to program with and
more importantly that the code you write
is very difficult to debug enhance to
maintain typically if you try to debug a
reactive application well you see that
something you have an issue here but in
fact the issue is not reopening on that
well in that region of the application
but it happens on for somewhere else but
it's very basically it's very difficult
to do correlation between an issue and
where it happened within the flow of the
code but still if you want to scale if
you want to have efficient resource use
of you you need to go to other approach
that approach so a project loom is
basically trying to solve that by making
concurrency simple again ow
right now the JVM is using native
threads kernel threads loom introduced
the notion of your 12 threads which are
basically two threads that are managed
by the JVM so those threads are some
kind of well visual threads software
threads that are managed and he ruled by
the JVM and obviously the JVM will have
to do mapping between those virtual
thread and some underlying kernel
carrier thread but that that isn't
dulled by the JVM and the thing is that
those virtual threads are very very
cheap so it doesn't
it's not a really an issue to write code
that is blocking because the virtual
thread that is blocking is not blocking
an actual underlying physical threads so
basically you can write application
using virtual thread your code can
blocks but you don't have to pay of
resource and the virtualization so those
that are so cheap that it well you don't
have an ax you don't haven't have to
pull those threads so you just block the
thread and you you start a new thread
it's it's it's it's not an issue because
those threads are very cheap so that's
basically what a loom is trying to
solved now those days we have multiple
early access build of loom if we look in
the platform there are already a few
gems that are been that have been added
in the platform for loom and more
specifically in GDK 14 we have we have
hope we implemented the legacy socket
API that was something in preparation
for something that's coming in JDK 15
which is or implementing the legacy data
so grew that diagram socket API which
has been done in preparation of flume so
another large project is Panama so the
goal of Panama is basically to arrange
to enrich the interaction between the
Java Virtual Machine and a foreign
native code historically we had gni for
that Java native interface but gni has
been specifically designed in the early
days to be I would say not friendly to
use we want to basically provide an
alternative to Ginny I wear it is easy
safe and efficient to use from Java
nutella's to use native code from Java
if we look at the deliverables of Panama
there are three main deliverables the
foreign memory access API which is in 14
in incubator so that's something that
you can use already today
it basically allowed to efficiently and
safely use of memory of that is not on
the Java app but you can access that
memory from Java code
then there is an extraction part it's
basically the ability to extract from
sea native header files so the extract
interface and generate binders that you
can use directly from Java code there
are two parts for the extraction parts
that there is a tool that mimic that
mechanically do the extraction but there
also no API that more advanced developer
can use to meet more advanced scenarios
and last but not least there's the
vector API which allows to easily
express vector computation that will
compile at runtime and execute on a
vector on CPU that support vector vector
eyes extension such as SSE or AVX 4md
your arms scalable vector extension and
the vector RP I is right now in
incubator candidate so we don't know
yeah
yet in which GD Carol is it will be
headed so today what we have for loom is
the foreign memory access API in
incubator that's something that you can
use and we also have a early access
build for the extraction part and then I
also put this in the Panama part even
though that specific job is not really
part of Panama but given that it's very
close to the hardware and well I put it
here so jet 3-5-2 basically had the
ability to manage non-volatile memory
via byte buffer that's something very
specific so I'm not going to discuss
about that anymore so what I'm going to
do now is a very small Panama demo so it
takes a bit of time
switch okay so let's see so I hope that
it's big enough
so whatever here I have a very simple
java application but first I'm going to
go let's see where is it no so I'm on
six this is a Linux so I sign in Linux
no I don't want to do that well I fit
the name and sorry let me check okay
this this or sorry too small you know
it's red line so this is a header file
that is part of a five six so this is a
real line library that basically give us
read line support of something very
basic so there are multiple function and
what I want to do here is you use one of
the one of the red line function from
Java so the first thing that I need to
do is use the extract tool to basically
parse the red line header files to
extract all the information and then
generate the binder interface for that
so I'm going to use this G extract tool
so and I specify here that this is the
past for example of the library the G
the riddling library this is the path of
the header file that we want to x-ray it
and what I want is that I want the
outcome to be in that a jar file
obviously I'm not on the right version
so let's see I'm on 14 and I'm I need to
switch G so I'm going to switch to a
specific GDK build that support panama
and it's 14 I think oops
ramaa yes so let's invoke jig strike G
extract again
okay bunch of warning but this is a
early access build okay now I have this
jar that has been generated so what I
want to do is basically I have this
small java application we can very
quickly go over the code of that
application so a scope is something that
is provided by the foreign memory yes
the foreign memory api of panama and
basically scope are used to enforce
lightness checks on scope resources so
it's basically some sort of memory but
that we were allocated on the other side
so on the native side we need to enforce
likeness because whenever we are locate
on the other sides of the fence so on
the native side obviously at some point
in time what has been allocated needs to
be dedicated so that's why we need scope
so I create a scope then from that scope
has I allocate a string I pass it I pass
in the screen name so we're on the on
the sea side and then I'm just invoking
that function that is coming from the
redline library using this pointer that
is defined here so basically I'm just
passing this string to the native
function and what we get in return is a
P object which is a pointer and then I'm
just deploying displaying that object so
this is a two string method invocation
on the P so on the pointer object and
then I use this static method to
basically get the content of that
pointer so let's compile that so Java C
let's see class bus I specify the jar
redline and then the source okay now I
need to run that
that guy so name so this is basically
this line here where we invoke the real
line so this is the CE OS six function
that is invoke I pass it's something
test and then the result is the
following so it's a so the type is a
bonding pointer so this is this line in
fact to string on that P object-- which
is a pointer and then so this is all the
result of the two string information all
the information that we get the idea to
string and then the last thing is this
test which is basically we asked the
foreign memory API to give us the
content that is pointed on the other
side of the fence but by that given
pointer so this is in a nutshell how
panamá works so if you if you have any
question you can use the chat or we can
discuss at the end it's up to you so
moving on another big project is a
project ember so the goal of amber is
basically to continue continuously
improve developer productivity through
the evolution of the java language so
it's not something that happened through
one single release it's something that
we have started around a Java 10 and
since Java 10 we have hadded new
features which are basically emerging
from project amber var is a big one so
variable type inference was added in 10
in 14 we're having switch expression it
becomes a standard features after to run
off preview we're doing another round of
preview for text blocks we are
introducing records weren't sure
introducing also pattern matching with
instance of in preview 2 so I'm going to
discuss most of those features so the
first one is a record so
course basically give you the ability to
so they are providing a very compact
syntax for declaring class which are
data holder so basically a couple
inimitable trouble in which you can
store data and that's something that you
can basically pass around I'm going to
show you how it work so you will see
that well it's something that is a on
one hand very simple but on your hand
very efficient something else that is
coming from amber is a text blocks
so basically text blocks are multi-line
string literals
so take the following example so you
want to store the HTML that we have on
the left side typically you would do
something in your code with text blocks
you can now do that
so you basically keep the Descent acts
as it is you don't have to escape
anything this is something which is very
convenient for dealing with XML JSON ml
SQL and so on again that's something
that we will see in a demo in a minute
so then we have a pattern matching
that's something that we will see in the
demo it will be more clear and finally
we have a new switch expression so let's
go to the demo that will be a more
concrete so let's see well intelligence
already started so I'm going to very
quickly create a new project
I need to configure my compiler because
I don't know why but by default generate
Java c5 bytecode and then I also need to
configure my project and I'm gonna
increase the font for the code don't
worry
so here given that I'm gonna use SR it's
not here it's here
given that I'm going to use some preview
feature I need to ask specifically tell
to IntelliJ that I want to use preview
features because preview features are
not enabled by default and I also need
to do it let's see here so again I'm
going to use 14 preview features okay so
a source ok so let's just run that and
see if it works ok it works
so the first thing that I'm going to
show you is recourse so let's create a
record let's say that we want to create
a record for a persona and a person as a
name and a person as a first name and
that's it
it's all we have to do now what I can do
in my code is the following for example
so I can create a record and today
speakers is the let us say David oops
oops sorry it's obviously not a record
about a person okay so now I have this
speaker object that I can use so for
example a speaker so let's run that so
this is the result so this is basically
the to do to string method that is
invoke ated on that speaker object so
let's have a look at what has been what
we are here so target class we should
have two class so we have the test class
and we have this person claps so this is
our record so if we look at the record
itself so just by this simple
declaration we see that we have a few
methods that have been generated so
generated so the class person is final
it extends java.lang records it has a
few methods so it has a constructor it
has a two string it has a it has a
default ascot methods it has an equals
and then it has two gathers last and
first name so that means that I can for
example invoke one of those and we use
one of those method and you see that
this time we have the lab assay instead
of the two string so what we can do if
we look at the record itself obviously
this is the default behavior
I haven't specified anything I can
define my own constructor so person I
can say for example that let's see we
want to upper
case all the names right so let's run
that so you see that the lab assay is
now in uppercase and you see that the
only thing I had to do is basically I
just have to specify what needs to be
done with one of the the field I didn't
have to specify anything for the first
field so it has a default behavior but
now if I'm doing something like this for
example if let's see last is blank then
this last equal Nemo's here the compiler
will complain because last might not
have been initialized so if we go
through this branch of course last easy
last is initialized but that means that
we if we have a else it won't be so if
last name is not blank it won't be
initialized so to solve that basically
we need two other in this case a health
and so else this last fall's plus in
this case we have a default for second
branch and this case it it works so if I
have a blanks let's run that and you see
that this time oops sorry
it's the the first time is an animal's
because it is blank so that's basically
our record works
the next thing text blocks so let's see
for that I'm gonna yes so this is the my
the poem that has been generated so it's
just some XML so it's the pump from my
project and well I want
a string for that so for that I'm going
to use a text block so for that I'm used
a triple quotes and that's all it takes
now I can do so from South if I run that
well you see that the text blocks has
been is correctly including the ident a
tion because here I'm basically copy the
HTML as it was so what what I've done
here is basically I kept the ident Asian
but we will see we probably don't want
to have all those space in front that's
something that takes blog handles for us
something else that we can do is for
example the following with text blocks
so they're not able to able to evaluate
the expression but well let's just do
that so how did a person has here and
now I can use formatted and let's see
and what I want here is the speaker
first for example so let's run that
yep sorry typo it's a method so if we
look at the HTML you we see that here
well it's not class but it's the first
name but you get the idea so basically
we can do some kind of cheap expression
interpolation using formatted with text
blocks so that's basically our texworks
text blocks works now let's move on to
another features of number and that's
let's pattern matching so pattern
matching so you see we have this speaker
object which in fact is a person so that
means that we can do something like
speaker first right so we would get
david but it might happen that the type
of that object is of that yes of that
speaker would be object in that case if
you see we cannot directly invoke the
first method so what would would
typically do with something like this so
if speaker instance of it's a person so
if it's a person then what we do we
create a new object so it's a person
object X equal to a speaker but we have
two specific cast it to person type and
here obviously we want with the
exception so that works so the thing is
that here you see that if we have this
type we create an object of that same
type and we cast it from the other
object using that same type there are a
lot of repetition going on what we can
do now with pattern matching instance of
energy TK 14 is the following so we
declare the new variable here and that's
it so if you run this
we'll get the exact the exact same
behavior
so hello Davi this is the first one and
hello David this is the second one and
you see that this one is more 6n so it's
more obvious to use so the last one and
I'm probably gonna skip that one because
it takes a bit of time is this
expression so it's a new type of switch
expression that works like this so this
is on the left side this is how we
traditionally works the thing attacked
for example here there's a bug in the
sense that there is no break here so if
I do a switch on let's say Friday well
number of character will be 6 and then
it would be 7 so that would be the end
result 7 in this case I'm doing a switch
over an enumeration so all the values
are no because when numeration but still
if I miss for example one of the day the
compiler will not be able to tell me
okay you are not evaluating windows day
for example so that's why we have a
default but given that we know all the
value the default is a bit well it's a
bit hot to have to use a default value
so what we can do now there is a
question we will we be able to use
recorded GBA GP entities and not
directly something that well you can use
records with GPA but the thing that you
have to keep in mind is that records are
immutable so you cannot change with any
fills as soon as it has been created so
let's go back to these to the switch
expression this is the new switch
expression it basically returns the
value directly so something we were not
able to do in the former switch
expression so that well that's why this
is on the left side the switch statement
and this is an expression because it
returns the value so we have all the
case given that again we are doing a
case on enumeration the compiler will
test tell us if if for example were
missing a day so if we are missing a day
either we had this day or we have to
deal with the default value if we are
dealing with all the days and if
we have a default value the default will
never be rich so that's something that
the compiler can can also infer that the
default branch will is basically a dead
branch those kind of things so that's in
a nutshell the switch expression so I'm
going to move a little bit because I'm a
bit ahead of time I'm sorry
shouldn't my bad I switch the slide I
should then switch moved out of the
slides so the amber demo we have seen
the amber demo so those are some of the
project that the more ambitious
long-term project that we're working on
what we see is that gradually some of
the features emerging from this project
are headed in Java so we've seen the
foreign memory coming from loom for
example we've seen Alhambra has added
multiple features or since Java 10 in
the Java platform but obviously the Java
platform is not all about huge an
ambitious project in 14 we have this new
elf full new pointer exception jab 3 5 8
so we have all seen seen that kind of
code where we basically have a new
pointers so it's not a big deal because
the we know where the new point shows
happened so line 6 6 6 so we just have
to look at that line right the thing is
that line might looks like the following
so we know that it's happened here but
we really have no idea where it happened
exactly that's what the new pointers the
helpful with pointers option gives us so
that's something that you have to
explicitly enable in a 14 and now you
will have something like this so it
cannot involve the city get district
because the return value of get city is
null so it basically gives us more
information to help us to pinpoint the
exact issue that raised that new
pointers so that's something that is
available as a standard feature in 14
it's not in available enabled by default
and I've seen some discussion where in
15 it might be enabled by default so
it's a it's a small features but it's a
very convenient features
GDK flight recorder is something that is
available I think since Java 11 and the
basic idea of JDK of flight recorder GFR
it's a black box that keeps track of
even that are emitted by different
component within the GDK itself so it
can be the JVM it can be your code so a
bunch of heavens are raised and GFR will
keep track of them and that's something
that you can use after the fact to do
some kind of analysis the thing is that
GFR is very low overhead so that's
something that you can use in production
to basically detect and pinpoint
specific issue something that we're
hiring in GDK 14 is even swimming so
until now the the way you were using GFR
was the following so you start the
recording of your application so you use
your application then you stop the
recording you dub the content of the
event to repository and then you process
those events now an application that is
running as the ability to stream out
event as they happen so you can
basically do is you can have some some
some cough some some sort of sidecar
application to do analysis of the event
as they happen so there is a specific
API to do that in GDK 14 the thing is
that obviously we're keeping we are
improving a GFR through all the release
so in 14 we are we had hundred and forty
five different event types for GFR and
in 15 I've checked in the late well it's
not the latest bill because we have done
at twenty to build yesterday but in the
middle of last week we are we had
hundred and fifty-seven GFR even type so
it it keeps GFR it in itself keeps to
have more matrix within the platform
that you can use and not only that you
can also write your own custom and even
type for your application something else
that is part of Gd k14 is this new
packaging tool Jib Jab 343 right now
it's still in an equation phase
so the idea of that tool is it's a tool
that gives you the ability to create
native installer specific for a given
platform so on Windows you will either
have an MSI or an excel file on my quest
you will have a big package file or a
dmg and so on and so on and it has a lot
of additional I would say native
features such as the ability to pass
parameters to the native executable that
will invoke that will do the
installation of your java application
and obviously work with jailings and so
on and so on
so that's something that you can use
today to basically create an activex
installer for your java code now let's
quickly look at java 15 so that's the
schedule nothing will change on that
front so this is a table that I did well
I did it yesterday and I checked this
morning it was still up to date so those
are the multiple job that will be part
of 15 I'm going to discuss specifically
to Jeb's that is a learning class and
where it's your the one I'll seal the
silk types you'll class it's not here
now I don't so yeah I miss one well
anyway it's on my slide later on oh yes
here sorry it see the other one is silk
class so so this slide shows the jet
that are either integrated so already in
the early build of GDK 15 or they are
targeted so then sorry targeted means
that we intend to add them to 15 or we
propose to target them though so that's
basically the first step before we
integrate them so we tell the community
okay we want to add that to 15 is there
any objection if not we will if we move
to target it and then one the works is
done it will move from targeted to
integrated so basically there is a very
high chance that all the jets here will
be part of
GDK 15 just keep in mind the small
disclaimer that we might find a big
issue in one of those one of the jab
here and we might decide to remove it at
the very last minute so that there's
always a risk and then there are a few
other jabs that are currently being
worked on and we don't know yet if there
will be part of 15 so one is silk class
and well there are a bunch of jet but I
just took three where clearly there are
a lot of activities going on right now
so maybe there will be part of 15 we
will see in a few weeks
and at worst by early June we will know
for sure if they are part of 15 or not
so silk class flow in memory access an
incubator so that's part of project loom
and then the vector API which is also
part of Project loom so I'm going to
very quickly discuss a hidden class and
seal class which are often confused so a
hidden class is something that is very
specifically that has been specifically
done for frameworks developers so if we
look at frameworks they have this habit
of dynamically generating classes and
use those classes through reflection the
thing is that those classes given that
they're generated can potentially be
used by Hodder slash external bytecode
something that we clearly don't want so
basically the ability of it edan class
give now frameworks developer the
ability to still generate dynamic e
classes on the fly but those class are
hidden for the rest of the world so only
the framers that generate those tasks
will be able to use those classes so it
targets frameworks developers but if we
look at Java C for example Java sees
your show using the techniques for
example for lambda expression so that's
something that is also useful for Java
itself and one of the thing that will be
done in addition to creating this new
facility is also deprecating the Sun
Myshkin safe define analysis that is
used exactly for doing that dynamically
generating generating classes so if you
look at the properties of those classes
well in terms of discovery
discoverability they shouldn't be
basically discovered by discoverable by
classes outside of the classes that has
created at that classes in terms of life
cycle it should those classes should be
able to be aggressively unloaded to give
the framers the ability to generate a
lot of classes and as soon as those
classes are not needed they will be
automatically garbage collected now they
can be garbage collected through a more
traditional approach that's something
that is but the behavior of the GC is
configurable for hidden classes but what
we know for sure is that the aggressive
unloading is something that is needed
and then access control that basically
give us the ability forecast that
creates dynamically another class to
access that class but that also prevent
other classes external to that classes
to access that newly created class so
that's basically none shall hidden
classes it's not something that you're
gonna use that most of the developers
like you and me will use it's clearly
something for frameworks developers and
then they are seed blast and some people
tend to confuse the two there are
completely different so before we talk
about seed class we need to quickly talk
about inheritance so inheritance is
something that encourage code reuse so
we basically have a class hierarchy and
all the class for example a class that X
and the class can reuse features from
the class that it extends for now the
thing is that the class hierarchy is
most of the quail is often used for code
reuse but sometimes it's used for
something completely different so the
class hierarchy is on is sometimes also
used to model different possibility of a
given gap of given domains so for
example we want to model the different
shape that are supported by a graphic
application so we would have a shape
class or interface and then we are have
subclasses that would extend that shape
classes like a square
the shapes on exactly next and shapes
and so on or we we can have a class that
representative type of vehicles that we
sell and then we would have I don't know
a CV a coupe sedan and so on that
extends that super classes so that's a
different something that is completely
different and the problem is that right
now if you have this shape superclass
that is extended by triangle circle
exact on and so on you cannot prevent
any other class to also extend it and
that's something that we would like to
well read with a sealed class so C Class
would basically allows to have a given
class hierarchy that is bounded so it
the class hierarchy can only be extended
by class within that limited closed
class hierarchy and not by any external
classes and every cycle we use would
still be possible but it would only be
possible within domain within the
boundary boundary of the closet class
hierarchy so how does that work well
let's have a look at an example that
would be more obvious so I have this
shape superclass and we have two new
keywords so we have sealed that is used
to basically say okay the class shape is
sealed and then we have the permits
keyword that tells which class or
interface can use that superclass so
sealed is sorry shape is sealed and only
in this example circle circle rectangle
and square are allowed to extend the
shapes and then there are a few
variations like the flag the fact that
if you are within the same package or SM
modules you can just use the class name
you don't have to use the full package
name if you have nested class so all the
classes within a single file source you
just seal the superclass and by default
all the classes that are present in the
same source file will be
permitted by default to extend that soup
superclass
so that's basically how it works now
it's not clear today if Silva's will be
part of did he give 15 if not that's not
really an issue just mean that we'll
have to wait another six months
and it will be for GF 16 so I think it's
time to wrap up so today we've discussed
about what new features will be added to
Java in 2020
so GDK 14 was released two months ago
and DK 15 will be raised in four months
from now i've also discussed very
quickly and outdoors large ambitious
long-term projects are basically
gradually adding capabilities into the
platform with the ultimate goal goals of
revamping completely the platform now I
I need to quickly discuss another new
project that we've just announced two
weeks ago and that is Laden so laden
basically tried to solve to tackle some
of the pain points of Java and that is
the slow startup time the slow time to
performance and the locked footprint of
the Bob java application
and everything is relative when I say
slow it's low compared to typically
native applications for example
footprints it's again compared to native
application so basically a Laden tried
to tackle those pain point by
introducing the concept of a static
image to Java something similar to Ralph
Ian achieve image Laden aims to leverage
existing component of the GDK such as
hotspot G a OTC which is an alt compiler
that we have an experimental form since
gk9
into the platform but also C D s and
gelling and clearly this is just the
early days of leiden we have just
started to gather interest around that
project but we think that over time this
is something that would be important so
basically trot bring the capability that
we have with native Miam then similar
capabilities but directly into the Java
form so this is the slides depict the
content of GDK 14 I think that we have
discussed most of the jobs that we have
here the only thing that I need to
mention and I think I've mentioned that
at the beginning is that jobs are are
also used to remove holger things from
the platform so you see that for example
3 6 2 & 3 6 3 are duplicating things
from the platform and or removing so
when we remove something from the
platform we first deprecated to tell the
world that ok that features will be
removed in the features and then later
on it will be actually removed so it's
abilities face removal approach and da14
is available so you should download it
right now and give it a try so in terms
of conclusion Java is still free we have
put in place everything to deliver
faster and we are delivering faster and
we haven't had Rich's future pipeline
for the Java platform a heifer and also
keep in mind this year marks the 25th
anniversary of Java and given the
pipeline that we have well we can't
really say that there is a bright future
for Java developers and with that I'd
like to thank you for your time and I
don't know if we still have time for
questions
have time for one question someone have
a question you can also ask question on
Twitter so there is my Twitter handle
there so if you have any question and
you don't feel like asking now you can
also ping me on Twitter
I think stream 8 has a question yeah so
regarding the project so the last thing
was actually looking into is is the the
problem of high pressures in high
pressure in gently so that is a real
that's more complicated problem in
father so what is the state of it and if
there is that is that is that mountain
climb then so you know Brian gets the
job architect so Brian is the architect
of the Java platform and basically his
answer is it will be so whenever someone
ask about when it will be deliver his
answer is is pretty easy it will be a
below it will be available when it's
ready and the fact that well it's not
yet there means that well things are
still being being worked on so I cannot
give you any more precise answer than
that but yeah you're right Vala lies
it's really a fundamental change within
the platform the nice thing is that with
the new release guidance well we don't
have the issue that we we had in the
past where we basically add a time
window to add new features in the
platform every three years so if we miss
that time window that basically means
that we have to wait another three years
to add that into the platform those days
we can gradually add features every six
months so we can expect in the future
release to come to see some features
emerging from Vdara but I can I can give
you any more precise answer than that
I'm sorry
thank you David
thank you thanks you thank you very time
okay thanks everyone for joining since
you next time thank you yeah bye