Functional Reactive with Core JDK @ Silesia JUG (Poland)

yeah we have swan sven rupert
with us we have guardian
together with us and uh we are gonna
talk about uh fuji which is a new online
the online community around open jdk
the guardian will speak more about this
java bin is the norwegian jug we have
eight regions around the country and we
do
these monthly online meetups
we have a very we have a
crew that’s helping us to keep this
alive i’m very happy
for everyone who is helping us
keeping our meetups alive if anyone has
any questions about javan please contact
us
that was basically my introduction i
will now
hand over the word to
our speakers and i just want to say
thank you so much
gertian and sven for being with us to
share
to share your insights and information
with our community
so guardian i will hand
the word over to you
thank you very much let me start by
sharing my screen
so you should see right now uh fiji
hello my name is uh heretion i’m in
amsterdam in the netherlands
and i work at azul
i work on open source projects there and
before
azul i worked in oracle on open source
projects
and before that i worked for some
microsystems on open source projects
so um really my entire
experience in the java ecosystem has
been to work on open source projects
um i worked on especially on netbeans
and i still do it’s now apache netbeans
i worked on oracle jet which is a free
toolkit for front-end development by
oracle
and open source as well and what i’m
currently working on
since the year is fuji and fuji is what
you see right now
on the screen fuji dot io
fujay stands for friends of openjdk
and if you are a java developer
you’re using the open jdk in some way to
create applications
or if you’re learning java you are by
definition a friend of open jdk
and what kinds of things do friends of
open jdk
need you know what do you need as a java
developer what kind of information do
you need
uh what has happened over the past years
of course is that
there isn’t only one java vendor anymore
when i was in sun market systems
sun was the java vendor and every few
years there would be a new java release
what’s happened in the meantime of
course is that there are multiple
different
java vendors so i’m providing different
distributions of the open jdk if you
want to use java today there isn’t
automatically a place that you would go
to
to find the java java is provided by
amazon it’s provided by red hat it’s
provided by azure it’s provided by
oracle it’s
provided by bellsoft so here you have
on fuji and almanac listing the
different open jdk distributions
now something else that has happened
over the past years in addition to there
being multiple different vendors for
java
is that there have been multiple
different
releases now when i was in sun there
would be a new release every couple of
years
um now there are um quarterly updates
two major releases and there are um
there’s a new major release
on a much more frequent basis than
before on a very regular cadence
and also four times a year there are
updates to those
major releases so let’s say that
um that we’re using java 8.
here are all the issues that have been
fixed
for java 8 in the release in the recent
quarterly update
so we’re now in april and every april
there is a new update
to java 8 and to java 11 and to the
other
releases of of java and so here you can
see
what’s actually been fixed so you you
may be aware that there is a quarterly
update and you assume
that there are fixes and you assume that
it’s more performant but
do you know what is actually in there so
on fj you have a complete list so even
and even from here you can jump into
those issues but even this is not
all that useful because it’s still a
very long list so you can look at the
component view
which shows you those issues broken down
into their different areas so maybe
you’re interested in hotspot so this is
what’s been fixed
for april 2021 in java 8.
so now you can start browsing through
these and you might find a couple of
topics that you find interesting like g1
for example and and you know there are
various topics here
um that could be relevant to you and if
you find them relevant then you will
click
on here on the stars now
you don’t have to log in to do this this
is just to say hey this is interesting i
like this this is a good fix
you know you can read each of these
items and decide well this is relevant
for me
and all the ones that are voted on will
automatically appear
on the highlights page so the highlights
page presents
a view so let’s go to april 2020
so you can see here that for april 2020
we can see the most voted on fixes
and you can also see a commentary so for
example here there is
a fix that is quite popular for april
2024 java 8
the fix is entitled integrate marlin
renderer per jab 265.
now that’s really unclear what does it
mean so we at fuji
have added an annotation because this
is a fix that the community likes so
we have an annotation or we have
analyzed this
and we have added here a commentary jdk9
switched to using the higher performing
myelin renderer
this is a back port of that feature to
jdk8
well that’s useful information so what
you want to do
with with fuji as you can see in these
two examples is
bring together all the different
fragmented
reference materials that there are in
the java ecosystem into one place
another example of this is jvm command
line switches
where do you go to find what all the jvm
command line switches are
there isn’t one single point of
reference so there is actually
because a very nice java champion called
chris
newland has a site called chris who
codes
and you have to know that it’s there in
order to to be here of course
and here he has all the jvm options
listed
now what we have done is we have
integrated that content
into fj so on fujay you get his content
just like
the almanac is a is an
integration of content by mark huffman
so there are
various java champions and other people
in the java community
who have information on their own
separate platforms
and with fuji we have the opportunity to
integrate that information into one
place
so these are these are the three key
pieces that fuji provides at this point
but also there is a area called fuji
today now this is
for blogs so every day we publish a new
article
and here are the authors who publish on
fuji
and there are many well-known people
that you will have heard about
in the java community like um for
example
garrett grudenwald who is a java fx
expert you might have heard of
of eva grimstad from the eclipse
foundation jacquard to ee
a jaden autlip from pajaro um
many people ray sang is on here
matt rabel you know many people who you
might know from the java community but
also people that you might never have
heard of
so we want to also enable people who are
new to the java community
to present their insights and their work
and their tutorials and their content
so it’s really a wordpress site so if
you have a blog yourself
you can republish our existing content
on fuji or you can write new content on
fj there’s a lot of new content and also
republished content or future now one
interesting area is game development
now you might not know but there is a
wonderful game engine called
fxgl which is on top of java fx and the
creator of that
is a very nice guy called omas he was a
lecturer at the university of brighton
in england and he uses fiji
to educate people about the game engine
so he has
fantastic tutorials that he’s building
and publishing on fuji
every week in the next few weeks you’ll
find a new tutorial about game
development
creating simple games by means of his
java fx based
engine another example is release notes
so every java technology has release
notes but imagine if we were to collect
all the release notes
of all the java technologies into one
place into fujay
so that you would you would read about
pajaro’s new release but also about
weblogic’s new release
and also about sneak’s new release and
you know all the new releases that we
would have all that information
collected into one place so these are
the opportunities that we have
in bringing together content um into fj
so
what fuji also provides is um
a front page where you we find all the
content like an events calendar
are you organizing a conference are you
organizing jug events
why not publish your events on fuji
so here is the event calendar it’s going
to be much better i mean everything is
in progress but here is the starting
point of it
so here you see the upcoming events and
you can also add them to your calendar
etc you can go from here to the event
page
you can do a search across the events um
for common terms
um we can go much further i would like
the idea of
having hotel recommendations for example
on on fuji so that if you’ve been to
geekcon before for example
that you would or to javaday istanbul
and you’ve been to a nice hotel
that we would list that on this page
that would get people to recommend
particular hotels or to say well if you
are in copenhagen
these are the nice places to go to that
java developers
share their insights about the place
where the conference is so there’s
a lot of interesting things we can do
together um there’s something called
the um the fujipedia
so this is like wikipedia these are
definitions of different terms
like tck do you know what the tck is and
why it is important so all these terms
are defined here in a lot of detail and
you can add new content
into this too and there’s a tweet area
so if you write a nice tweet
about fj then we add you to the greatest
tweets so really it’s a community
collaboration site for anything related
specifically to java
to wrap up a little bit um who is behind
fuji so
um it is a group of different
organizations who are very well known in
the java community and everyone knows
about sneak and pajara and jfrog and
hazelcast and
dog datastax the zoo these are the
organizations behind this project
um and uh people that you’ve heard about
like stephen chin for example
simon maple from sneak i like this quote
from him
it’s incredibly important for every
ecosystem to have a core location for
information to help grow the community
and be an educational resource for all
developers to use java has lacked this
course space for many years
so this is you know we want to fill that
space
we have a slack channel of course and on
the slack channel every monday morning
we do our scheduling so we want to
publish one article per day per week
every week and every monday morning we
look in the wordpress
and we see what is in draft and we
schedule together and it’s just it’s all
done
very simply and collaboratively the
final point is that we have of course
a twitter stream twitter handle
um fuji io uh please follow fuji within
a year we have 2 000 followers which
isn’t a bad thing at all
and we want to grow this we want to grow
the community and we want to be of
service and of use
to the java community so please follow
along
on on twitter join the slack channel
i’ll put those
links into the into the chat and um
that’s fuji so what we’re doing now is
we are actually
on a tour um to promote vj because it’s
all quite new
it’s it’s existed for about a year now
and this is the final stop of the tour
and we spent the last month and or two
going to as many jags as possible went
to about 10 jugs in march in april
this is the final stop of the tour and
sven rapper is one of the people
involved in fuji and especially j
frog is on the fuji board and so
as one of the community members of fuji
sven is speaking now
i’ve known sven a really long time you
can see his background as a forest
if you look on on youtube you find lots
of youtube clips about him walking in
the forest and talking about java tips
and insights um he’s worked at vardhan
he’s
now working in in jfrog he has a long
history in the java community
he’s a great speaker with deep knowledge
and so with that
introduction let’s switch over to
sven
hello hello so so we heard
about fuji and the place everything is
about
java and then we want to follow up with
java again so
here we are talking about functional
reactive with code java
say um well now
the trickiest part for me i will start
sharing my
my screen let’s see if i’m edited with
this
one and here we are
so you should see my screens now
my screen so um
let’s start so my name is when i’m
working for j for
j fork he is the company behind
artifactory x-ray and pipeline some
other stuff but the most people will
know
um at factory and if you need some
binary manager then have a look there
and we have freight here
so check it out so by the way if you
want to reach me
twitter linkedin youtube everything but
please
know me because mail is just i don’t
know
try try something else please
um by the way if you
are attending today i’m not sure if you
see it late on youtube
maybe it’s too late but if you’re right
now online
you can use this url i’m probably just
straightforward
in java and you will find uh slides and
a video link and
if you’re fast enough you can win one of
the shirts of pink
10 shirts we have and um they will be
selected during the next
what sending you three three days so
feel free if you want to have one of the
shirts wrap one
as soon as possible so back to the topic
we are talking today we are talking
about
functional reactive with code java and
the target here is to to have
functional approaches without adding
other big
libraries or different typing systems
and
whatever the other thing is that
i was mostly working in
projects with a lot of legacy code and
it was a huge code base
and it was not so easy just to change
the whole typing system or to
add a bunch of libraries because i just
want to do it so
i was mostly yeah focusing on the core
jdk and then
there was this idea of hey functional
function is cool but
we have an object-oriented language with
java so can you combine it how you can
combine it
and what are the basic principles so
what i’m not doing here is
giving a pure theoretical
exercise that you will get from
university i will just
focus here on um practical approaches
and the first thing i want to have as an
as a starter is what is the difference
between
ooo and functional programming this is
mostly the first question i’m
here hearing so what what where’s the
border if you if you’re occurring
function with java
where’s the border can i see it and if
you’re looking at the screen i
just took the optional and you have
different ways to to deal with this
you have this option isn’t holder this
is great if you want to
avoid null so this is one of the things
you don’t want to do in the functional
um with functional approaches you don’t
want to say
uh here’s another you always want to
give something back
some result and then option is one of
the solutions so it’s a holder inside
there’s a value maybe maybe not you can
ask something
and if you’re not looking at this api is
is
what what of this is functional now is a
usage of optional functional
is it functional because you’re using
lambda expressions is this function
because you’re using message references
is this functional because you can add
transformations
and then working again on some options
successfully i think there is no clear
border
and the aspects or the the stuff i want
to explain about the functional
aspects or the functional behavior what
you can do with java is not pure
functional but you can adopt a lot of
these things
and then it will be up to you if you’re
reaching out at what level you are
reaching your
functional approach or your level of
functional programming at this
or with this language just as a short
recap i want to
let’s say the functional interfaces
functional interfaces the name says
functional it says functional
by definition well not not in the term
we want to have it but function
interfaces are quite interesting
because we need layers and places for
the api to
put stuff like who is responsible for
creating an instance of a function what
is the right place to
write down the code for a generic
function
so what what what is a good place and
interface are quite quite a good
place for this because functions by
definition are stateless
so a function means one input value one
output value and there’s no state and
my interface are not bad the other thing
is
you can go with interface over
composition instead of inheritance
if you are mixing different functions or
different behaviors you want to
compose and this is the next thing with
this fractal world
um if if you’re going to the functional
world you’re you’re
leaving the track of the pure
inheritance or pure object-oriented way
so we need some places where we can put
our sales code where we can guarantee
where it’s convenient and interfaces are
not bad there are a few things with
interfaces for example
a function interfaces just as a recap
just if you have one method signature
that has no default implementation then
if you have this marker function
interface yes or no
we don’t need it and we got these
default implementations with jdk8 it’s a
long long time ago
and what we see here is that it’s always
it’s it’s still a function interface
because we have just one method
that we have to implement one method
signature so
that’s it the next thing is i want to
play a little bit around with
inheritance and
function interfaces because with this
default implementations
what we got is uh some some yeah what
is the winning implementation and this
is just as a short exercise because
if you start designing apis and you’re
using then this functioning interface or
this
interface in general then it’s much good
to
think about what you will see from
outside how to deal with
inheritance or implementation details if
you have different methods
and so on so what what i want to do here
is
i’ve tested interface a and this has two
methods
one is the static one was a default or
was in implementation there is no
default implementation it’s an
implementation and then a method do
something with a default implementation
by the way this is no function interface
anymore because there is no message
signature
without any implementation
so we have this default implementation
here and we have the static one
we have interface b and snow uh
extending interface a and we have the
same
method signature to something and again
with the default implementation
the question who’s winning if you’re um
using this one inside inheritance
and then there’s this tiny means i have
an interface c
exactly the same message um signature
and with the default implementation
why i’m saying this one is you have with
this
if you’re going to the function world
functional or being functional is
pushing abstraction to the limit pushing
abstraction to the limits means at the
same time
that you are using more and more generic
atomic operations of functions
more more generic operations and
functions means that you’re using more
generic
words and i thought quite often that
different parts of the company or even
inside the team
they use the same wording and it was
leading to the same method signature
and this could collide somehow if you
start dealing with
method references with um
yeah that this functional approach if
you have composition over inheritance
but here so what what i’ve done is just
i
created these three interfaces and if
i’m implementing a and b
what’s a winning one and what is winning
if i’m implementing a
and c so here uh the compiler will
immediately say there is no strategy to
solve it
so you have to do it the compiled will
break and the
method to something you have to
implement the other one
if you’re using this one then you will
see
that b is a winning one for class a
but a few people um are
thinking about how to deal with static
methods so we are using static methods
later
for for providing stuff to have access
somehow or
static um imports make this
technical noise but if if you are
implementing
interfaces and you want to call the
static methods
you can’t do it all the implementing
class so you can’t
call class a dot do more you really have
to say
interface a dot bit more why i’m
mentioning this one if you’re creating
an api and if you have all this sorted
out what you want to implement and
what’s the right place
make sure that not too many details are
bleeding to the outside
so that people need to know so much
about your hierarchy
inside your framework or library so just
have this in mind
that will be necessary if you have it
okay so if you’re calling this and you
have this
diagram what we will get is interface b
is to something an interface a
it’s just the latest concrete
implementation world winning
uh the winning one so jdk9 gave us
private methods
uh here we can just clean up a little
bit so the code from default
implementations
it’s still it’s a long long time
available this
private methods but i see so much code
with
huge default implementations they’re not
taking advantage of it so
just maybe maybe it’s a good time to to
think about this
private once again so back to the
functional thing
um the first approach or what what you
read
in in if you’re reading about functional
approaches in code java is that you
should use optional
optional it’s okay it’s nice so you have
this holder you can ask it if it’s empty
empty you can create an optional you can
create module with a null
inside with uh so that you have nothing
that’s all fine
um you have methods like if
is present but you don’t have a method
like is absent
so you you can get the value you can
build a stream since jk9
so this is okay but you have a few few
things i i
don’t like so for example here was this
optional what we have is this is
present or else and then you can decide
if you want to go left or right
that’s okay you can do it with if
present but you can’t do it with if
absent so this is not existing
um then you can use for example this or
else or else throw it it really depends
on the jdk it’s the evolving of the time
but for example through this is
functional i would say no because one of
the functional approaches is
catch all functions but don’t throw them
um
given result don’t throw exceptions
this means that this or else there is
for
my point of view so being a functional
thing would be
not right in this api but on the other
side we have to use it object oriented
we have to use it function in the same
way
so this is maybe so this is the thing
that’s there for the object oriented but
throwing exceptions is something i
wouldn’t do
we are talking about how to map stuff
what we can use we can use london
expressions we can
use method references as a preference
have some
tricky things in in terms of type safety
but uh what what we can do is we can now
start
transforming so we have this value we
start
working on that value without grabbing
it out and this is one of the good
things so you have the values then you
can say okay transform transform
transform
and this is always the first approach of
thinking about
adding transformations and working with
some stuff
okay what what we have to to think is
how to get rid of this wrapping battery
wrapping so we have this flat methods
and here i’m just highlighting this or
else and throw
um well i gave my
comment on this one so but what what we
have
is this optional for me is not symmetric
enough so as i mentioned before we have
if present but we don’t have
absent we have just locking chords if we
want to move later to
functional reactive to the reactive
world because functional reactive
matching
perfectly then we have just blocking
calls
um this okay for me it’s not functional
enough so we
i’m missing a few things for example the
information about
what was going wrong if there is another
value and it’s declared final so we
can’t extend it so
we have to deal with this if you want to
have something like this then do
something else
um what what we can do is
um as an approach is we we are taking
just optional and all method signatures
creating a clause
result of t and then one
one thing is what we need is it must be
easy to transfer between option and
results
to optional from optional because
otherwise your colleagues
maybe don’t like this or it’s just ugly
um
wrapping code it should
work like a drop in replacement so take
all methods
from the optional and then extend what
you need and then you can research and
replace just
make a drop in replacement and this is
easier than
just changing huge amount of code with
different semantics and all this stuff
should be connecting to the reactive
world
i will show how what i have in mind and
that must be symmetric and this is one
thing that i really want to see in the
options someday
if that for every negative method you
have a positive one and reverse
so that you don’t have this uh
yeah in inverting stuff so if not then
do something so
it’s not nice but have in mind if you’re
creating some functional stuff
um make it usable for the old-style
world because you have to deal with
colleagues and maybe it’s a bigger
project you can’t just
switch the whole style so this
is one thing what i had in mind during
the whole um
stuff i created here so that if it is
or it must be usable uh in the o o world
um
and good otherwise the acceptance is not
so good
so to transfer it’s just too optional
from optional it’s just a wrapping
method
and now we have the first thing and look
at this message signature so
result success is something okay i have
a value and i can type it here
i i have a string and then i have a
result of type string
if i have maybe a none uh and
result with no value in but i want to
have some informations and this
is the first extension to absorption for
example the error message or some
whatever informations
i don’t want to lose the type so
even if i have a result of failure with
a text input
it is still a result of the original
types is for example here
integer so make sure that this typing is
very very clear
so that you’re not mixing up this one
but this is the first thing so
just hold additional information if
something is going wrong with the
result that is responsible for the
failures
so the next thing is if absence is
present it’s exactly what i spoke before
it’s just to to make sure that you have
for everything
positive in the negative way now with if
present oils we got with
jk910 something like this so this is
already there
but i want to have this failure message
for example as input for the negative
way
so this is something that i would
provide so that you can consume or use
this
information but this is only available
if you’re storing it before so
that’s one thing okay if you have this
one and we want later to connect to the
reactive world
make sure that you have for every method
signature something like
if present or else hasn’t chronology so
that you have
a clear wording clear api so that you
can switch to
the reactive world and make sure that
the naming is very straightforward here
at this point
um by the way all this source code is
available
uh on github i can share this link here
in the
chat or in the comments on youtube later
so you don’t have to type anything
it’s um it’s available so you can play
around and
actually classes so you can use it
easily so
the only uh one thing that is
interesting if you’re thinking about
functional world is
that you’re thinking about
transformations so you must be able to
combine things and to provide
transformation so
this is a little bit like the um
completely future api so then combined
then combined asymptotes
but why this is only in the complete
future world you can do it with an
optional or with a result in this term
here as well so just provide an
additional value
and then the transformation because
otherwise you have this code that you’re
grabbing stuff out
feeding it to the next one and then
wrapping it back to an option and also
this is not enough so we have this maps
this q transformation ability there it
will be transferred
or you have something like a combination
so that you can merge
paths with transformations
okay there is one thing then the same
stuff asynchronously
if you want so it’s just um
we will come do this later with this um
reactive style um because what what i’m
doing here is pretty
straightforward i’m just consuming
computer futures and the return type is
then
something that’s able to deal with
asynchronous calls and there is a
completely future
and so he has the full typing and the
possibility to deal
with um complete with futures
so um okay combining for instance
one thing is that i want to highlight is
that most people are just
thinking about values values invented
function but the instance of a function
could be a value as well
so it is in a way that that you um
can see a value of a little bit broader
not just
an indent string a value could be a
function as well
we will come to this okay one thing in
the
um function word is don’t don’t don’t
throw exceptions
but we have exceptions in java so
basically i find this code so let’s try
cache so
everybody knows it and it’s even worse
if you have the stream so we have a
bunch of values and then in this map
phase
oh no i have then an exception so what
what i see
mostly is that inside this map phase
they have something like try catch
and we have two two challenges here the
try itself is very repetitive
it it’s not nice i want to extract it
the next one is a return
type here for building a sum it’s okay
but if you have something else
you you don’t have it uh anymore values
that you can
use as a default answer if something is
going wrong
so um a solution could be that you start
wrapping it in optional so it’s the
first thing okay don’t
push null so wrap it in optional and
then
you start with filter if present or just
do it by a stream or whatever
but this is not nice so this is a huge
amount of bullet blade code that’s
just not nice so what can we do
uh yeah this flat map is just a new
syntax with jk known that you
don’t have this if present and filters
them
so what you can do is you can just
extract the spry catch
this try catch is a pattern and this
pattern is just
try to invoke something if it is going
wrong then catch this message
and wrap it in a holder so what we have
is the checked function
we have on one side which are this
apply with exception thing so this is a
method i want to implement so our
function interface is the message
method method signature that i could
implement so i can throw exceptions by a
challenge anymore
and then i need this try catching
wrapping in some
holder in a way that i can extract it
and this is
quite easily done because i just have
this checked function i have these two
types and the return type is a
wrapped type so this is something i have
to do
otherwise i not getting rid of this null
but if i have this one i can just use
this
check functions with limited expressions
and
what what i have with this already so if
i have an
oh here’s the implementation of the
check function it’s really just apply
implemented and then this apply with
exceptions easy add-on
and then you can use it exactly in a way
you you know
so if i have a checked function i have
already a check consumer because the
consumer
is nothing else as a function from t to
void
and i haven’t checked executed with this
one as well because
this is a function from void to result
of void because
i need the result if something is going
wrong but i’ve pulled in for it out so i
have a checked
executor with this i have a check supply
because the supplier
is just something that can give me a
fret type
and with null inside so even here i have
exactly the same so
with this approach i have a lot of stuff
already
in a way that i don’t have to write this
boilerplate code and this
is going into the functional world
because we are catching all
exceptions and throwing no exceptions
anymore
the next thing is what the function
function is a transformation input
output and we are talking mostly about
one input value one output value so
um the question is what what can we do
so i see
quite often constructions like this you
have a
function plus two a function plus ten
percent plus five
and if you want to get into the
functional world what what you could do
is or what you should do you don’t don’t
write down
what what you need describe what you
need so
the function approach is describe how to
get it instead of
writing down what you need and here what
i need
is definitely something that will give
me a function that
is possible to add a constant so how to
create it how to do it
mostly people are thinking okay a
function is just value in value hot but
the value could be
a function itself so if
if you’re doing this one then you have
to think about
oh here here i want to start combining
so you have to think about
how to create a function that is able
to create my final function
i will come to this in a few minutes
again so
with jdk8 if you want to combine
functions here it’s
for example a compose with composing and
then
if i’m going over compose i have some
challenges
because i need to add a lot of
syntactical stuff
because the type interferencer needs
information
there’s something happening before my
invocation and i will get something
out of it and then i have my input type
and i’m creating some output type
so this is composed something that’s not
nice so it’s a traditional way so adding
functions
in this order leads to a lot of
syntactical stuff because you can’t
write this gray style so with x plus
five x plus
ten you always have to add this type
information
if you want to get rid of this one you
can use
a lot of stuff for example you can write
in higher compose
i’m not i i definitely say don’t use
this in production it’s just
play around with the type of difference
and this will lead you to this
construction is just a nightmare and
what you will get is
exactly the same you have a description
what you need you have a function
that is able to build from an input
function a function
that is able to create from an input
function output function
okay this is by far too complex to use
it
the only target here is for this high
compose would it be possible to extract
this
type information in a way that you don’t
need to declare it
or a different way to declare to make it
shorter and the result is not good
because
what you have is you have all this
typing information for
every single step during the invocation
of the method
so the type interferencer really needs
this information
a given and you can’t extract it on the
flight so there is no generic way of
doing this one so and you have a very
long swim pack so this approach was
composed is not good
what you need if you want to do it
is you need the other way around and the
other way around
is that you need and then because then
you have for stopping into
a type inference an easier way so you’re
providing a type then you’re connecting
something so
you have the output type already you
know what you can consume
and so on and so on the only thing is
you need to make a
semantic equal function because you are
just reverting the order
but this is from the syntactical point a
very
easy or smooth way to combine functions
because
a function can be constructed out of
other
generic functions means that you
don’t want to to create a complex
function you want to reduce
all functions in atomic easy generic
clean steps and then based on this
tiny steps you’re building more complex
functions
this is one of the approaches to solve
every tiny step
and then combine these functions for
this you need something like
composer and then and in java go all the
way
and then
okay so how to get a function
instance so if if i have now this
function plus 2 plus 10
plus 5 what’s the right place to to
declare and how to get this one
so what you can do is you can
write in interfaces as static methods
and the return type is an instance of a
function
then you can declare this one in a
way that it’s not um
given with a state this is why i like
these
interfaces to to play there the creation
of functions of the way to create this
one
and then what you can do is just you can
use function a
and then and then the call of creating
this instance of
function so this is the first thing to
extract these
generic functions to places that you can
use it everywhere and with static
imports is a very
short way to consume this without
declaring it everywhere where you need
it so this is
one thing why i um yeah i like this
approach going over
front of this interfaces to use this one
as a place for the
factories of function interfaces wow
what a long sentence
so um back to this topic
make it more generic so functioning is
pushing abstraction to the limits
so if i see that i have these different
functions plus 2 plus 10 plus 5
what i need is something i can’t extract
this constants but this is the only
difference between all these
declarations
so the next step would be okay how can i
describe
this more generic so now i’m not writing
down i need a function plus 2
i need a function plus 10. now i
describe what i need i need
something that is able to create a
function based on a
constant input value and now what we
have a function
and the output is a function so value in
and a function out and then
i can start building all my special
functions i need all the variations so
don’t write them down
create them in a generic way then you’re
on a good way to the functional world
so if if you have this one we have now
this header
instead of at five f2 or whatever
and then i can use it everywhere with i
have this error now i’m applying with a
constant
this is a quite compact code already and
it’s a very
clean currency i don’t have to maintain
all the variations because
i’m declaring it once then i’m using it
explicitly
and the context i want to have and it’s
stateless
so that’s a good thing okay next one
if you’re coming from the
object-oriented world mostly you are
dealing with
some kind of how to extract things if
you want to go to the functional world
extracting is different for example i’m
taking this
piece of code and the next piece of code
and what
the only difference is is this input and
the other input so now i want to get rid
of this one how to extract
if you’re going over the object oriented
world
mostly you start with extract method
extract whatever
and this is leading to sub-optimal
solutions because the functional way is
not going this way
so the first thing is you can extract
this print line
okay now you have a consumer you can use
it a few times
that’s okay this is working but the next
thing
if you want to extract this constant
because you want to have this predicate
then you have the challenge that this
predicate
needs some final input so this is not
working so the extraction with
extract method extract method is just
not working here
so what can you do if you think in a
function world is
describe what you need what i need
i need a predicate created on a
constant input variable so again what i
need
is a function i need a function that is
able to create this predicate
and then if you have this one you are
extracting
way more code so you have a function
that from string is creating a predicate
and from this one you have now just this
one extraction this stream filter
whatever
and you can apply now this stream
with different invocations of your
function to create a predicate so now
you’re able to extract it in a way
the only thing that’s now created or
use or change from duplication to
implication is this constant
so this is a way to extract to a
functional world
so um this extract method is one
approach but mostly you
should start thinking about how to
describe what i need
that is if you have done it you have a
lot of stuff we have by functions
and now i’m coming to the point that
pure function world talks about you have
one input value transformed to one
output value
but we have five functions we have an
object oriented world with methods with
a bunch of input values how to connect
both of them and for this you need query
the good thing with currying is that you
can query in both directions you can
query and you can uncorrect so a by
function is
two input values then it will be
calculated and then it will be an output
value
and what you need you have to invert it
step by step so the first transformation
is
you have a function that will give you
based on the first input value a
function
that will consume the second input value
and
holds the whole transformation the
initial transformation
we will see for what this is necessary
or for what we can use this one but this
transformation is more or less
we’re taking all this because if i have
a buy function i can think about the try
function quad function whatever
i can start merging legacy code with a
bunch of input values
and transform them from a quad function
to a
pure function because i’m curing it in a
multi-dimensional way
and this can be done in a reverse order
so you can
use a method signature with multiple
input values you can query them you can
do all your function work
and if you want to go back to the option
oriented rules you just
unquery everything and you have again
this
what you want to have so means you can
do it in a try function and
so on i’m talking about try function so
we have functions we have y functions
but we have to see if i want to map
object oriented code
with massive signatures with a bunch of
attributes
i need something that i can map in a way
that i have some kind of function and
this is a
try function quad function whatever
function so that you can
map easily or you have a smooth way of
mapping
so that with grabbing the parents you
can start working functional
and reverse and with method reference
you can have very easy mapping by the
way
i will show it in a few minutes so what
how to do this
just take your by function and extend it
with one dimension i’ve done it in my
open source project since 21
for i think six levels or so if you need
more
just do it or do it by yourself but do
it in exactly the same way the
function and the buy function is done so
that you have an easy replacement
and then you can carry an anchor because
this is just one more dimension to do
this
so next thing is the function world is
talking about if you’re invoking
a method or a function two times with
the same input value
you will get exactly the same output
value if you want to have this behavior
if you’re dealing with ins this is easy
so your invoking method you will get two
times an
end both times a five that’s okay but if
you’re creating a car
or whatever then you will get exactly
the same
the instance like the other one but it’s
not the same identity so
how to do this one if you want to
implement the functionality of
memorizing what you need is just a
concurrent hashmap
and then with every invocation of the
function
you will check if you calculated this
value once
and if this is available you’re just
grabbing it and deliver this one
again instead of calculating it again so
this is just
using the compute of absence how to
combine it now with functions
if i have now a by function and
i want to use this one for example to
give
this by function the functionality of
memorizing the
the possibility to remember what you
calculated once
then the first thing is you have to
carry it because the memorizing is
working for
one input value and one output value
this challenge resolved we solved
already
with currying the possibility to
have a multi-dimensional function and
reducing it to a one-dimensional
function so with one input to one output
if i have this one i can start using
copying because on every level
during the time occurring i have the
possibility
to transform this one to a memoirs
function so what i have is the
possibility to have a multi-dimensional
caching but i can do it just for the
dimensions i want to have even this is
possible
there’s a quite interesting approach for
some
uh for some approaches if you want to
deal with legacy code and so
but the main thing is if you’re dealing
with a functional world
solve it for one dimensional challenge
make it generic
and then build a multi-dimensional
solution out of it
and this is a quite powerful approach
so here’s just this memoizing so we’re
putting in a buy function
and what you’re doing is just you are
creating or you’re currying this one
on every level of occurring you’re just
memoizing on this level
and then you’re moving back to the bio
function and providing
back a bifurcation so this is how to
combine korean
and memorizing person this can be done
in
a lot of dimensions whatever you want
because for try function it’s exactly
the same for
quad function and so on and so on and
you can do it with
functions and you can do it with y
functions and so on so
there is no limitation and um yeah
that’s it
so um i have this one with the try
function
trial function okay there’s a lot of
code i will present this slide so you
can have this one to to read it step by
step
but you can see here in the middle of
this memoirs function that you have x y
z
and you’re doing exactly is just for one
more dimension
and this is a really nice thing with the
function approaches
if you have solved it for one dimension
you can build multi-dimensional
solutions out of it
that’s one cool thing what you can do
with um method preferences it’s a good
and bad and the same way but
let’s assume you have a legacy class and
this legacy class will
have this method both this method do
work a
two input values and one output value
and you want to do some new stuff you
have a fancy
functional library or whatever but this
is consuming by functions or functions
or whatever
and how to map that and quite easy way
is
if you have this instance of your legacy
class
this object-oriented clause then you can
extract from this
instance for example it’s a message
reference that is bound to this
instance method and what you see here
you don’t need a cast or whatever
you have two input values one output
value and you can
immediately use here at this point buy
function because
two input values and one input output
value
this is why you should use trial
function quad functions and all this
stuff
because then you can go over this way
from the leg security immediately into
the functional world from the function
world can do all your stuff and then
you’re going back
and for this you don’t have to change
code and you don’t have to change
white code or whatever from the legacy
code you’re not even touching
so this is one way what is quite cool if
you want to combine
different things here so there is a
short version
legacy class extracting method reference
then adding for example memoizing
partially caching for this instance of a
method
okay uh next thing in the functional
world is how to deal with
um with um branches so we have in java
the switch we have everything else we
have this other construction which is
asking sign
so we have different things and the mess
the thing here is that
this is a complex thing uh you all saw
this if then
else and whatever and if you’re thinking
a little bit about this
how to extract it whatever complex tree
you have
you can reduce this complex tree
to a linear list of decisions with a
corresponding
solution or calculation and this is
what i’m doing here with the case the
case
needs is is it is based on two
two values it’s a pair with two values
it’s a supplier of boolean
so yes or no i’m responsible
yes or no and then a supplier for the
result so
what is what must be done at this part
so and uh if you have this one you can
define
this match cases so you have a case it’s
a condition and a value
and you have one default case that’s
just always true
if no other decision before was taken
how it looks like in in code is
um or how to implement it you’re
providing all this pace
and then you’re just iterating or
streaming over the pace
filtering out the first one that says oh
i’m responsible
and then you’re executing this one if
nothing happening here
then you’re just doing it with the
default solution what looks like in code
is
instead of a complex if-then-else tree
we have now a linear list of these
matched cases and the first parameter is
how to decide if you are now this one
that
must calculate or do something and the
second part is just
calculate the result and provide it
that’s it
and now you have a very easy linear list
and the transformation from whatever if
then else to this linear list is mostly
something that is
way better maintainable and if you’re
using static
imports um yeah here
it’s a result so it’s again a map one
and then you can start
dealing with cases or with mapping
transformation all this stuff
if you’re using static imports it’s a
quite compact syntax
and this is something that is better
matching just
with core java and you can use it with
code jdk8
okay so the next one will be streams the
same with stream is pretty active after
creation
and you want to just define streams but
you don’t want to start them
and you can use a functional approach
with this because you want to
interactively create a stream and if you
have all parts together
then you want to invoke it what you have
is you have a function that is
building based on input values the
definition of a stream
and if you are applying this function
the stream will be created
and allocating resources and
with this one you can really if you have
a graphical user interface for example
you can collect different informations
you can partially build with and then
and then and then the final stream
based on functions and then you can
invoke it and work later on
so this is just decoupling the time of
definition and execution
and uh yeah talking about decoupling
stuff
is uh now the part that’s leading to the
reactive world
the easiest thing is just an observer
has ramped up so
it’s just concurrent hashmap you have a
key you have a consumer for the value
and then you can say register unregister
and
send is just hydrate of all items
and invoke with this value
the only thing is have in mind java is
not immutable so it means
uh make sure that the consumers are not
um playing around with the value itself
so this is not safe at this part
but in october just to decouple um these
consumers from each other’s also the
producer and the consumer is just a few
lines of code
but there’s one thing that is um
not nice is you need to remember your
key
to unregister because you have to
provide a key and so
so sometimes you you don’t want to have
this one so the first improvement
is that you are playing around with the
registry so you’re using this observer
but it will be wrapped in a way that
during the
register time you will create something
that you can give
back to make it easy to
unregister so this the first thing with
this key is we want to get rid of keys
and call this key
to get rid of one you’re defining an
interface called registration
the only method is remove
and then during the execution or during
the registration
what we are doing is just we’re creating
exactly this
registration and this registration is
then
removing itself from the map
so i think i have somewhere the code for
this one
yeah so it’s just you’re registering now
and yeah to get rid of this key
is just that we are using now instead of
just adding the value that register
method will
implement the registration and the
implementation of this removes this
registration is just
remove yourself that’s it so it’s a
little bit easier
it’s more handsome and you can’t mess up
with
lost keys and then you have the first
thing
but i’m talking about um complex trees
of implications
um if if i’m talking about the
completely future
the most thought already i assume is
it’s not a process not threaded
fiber is very lightweight and we have
this completion stages
that i have to deal with so what what
can we do
and how we can combine it wasn’t
syntactic way to reduce it
and then what what we are reaching out
so with uh just as a recap was
completely future take the advantages
that you can define the pools where it’s
running so if you’re dealing with
completely futures
if you have a cpu intensive pool it’s a
different one then to have
network intensive pool so dimension them
wisely
then you can just create your complete
futures with complete future
that supply other privacy what we have
now is
immediately this complete future is
active it’s running it’s consuming
resources but on the other side you see
here the supplier
is more or less a function so the
functional world if you’re expecting all
this
stateless behavior and uh
want to go to the reactive world then
you have to halfway done
and this is a good thing so if you want
to have functional reactive
go first to the function world do this
one right
and then start resurrective but it’s way
easier to
instead of doing both at the same time
okay you can start combining and
accepting and doing all this stuff
um don’t forget to shut down this pool
otherwise um sometimes the jvm is just
much ex ending
so what what i want to have i’m looking
at this syntactical stuff
and i want to make sure how to make it
very
compact because i want to have a very
compact way of dealing with this
and this functions itself okay
we saw we can extract it in this
function interface to create these
factory methods for instance and
functions
um for every step i can provide
different executables that’s nice
um but now how how to remove how to
build some complex stuff
for example i have a value i have a
value a b and c so value a and b
are coming at different times i’m
waiting i have something that should be
calculated
this one is done i have the value c and
this
is coming at some time maybe at the
first maybe it’s the last
you never know but only if a and b is
calculated then you have the input for
the next operation
and this is the final result so looking
at this one it’s a quite complex tree
it’s really a quite complex tree how to
do this one with threads and all this
stuff is
huge amount of work if you want to get
rid of this
and and you’re using complete futures
what we want to extract the operations
if they
are functions or status then the half
work is done so
how to combine now all this timing stuff
here
if you’re doing it with the classic
completely future approach
you are creating the first one the
second one the third one then you start
combining them
and with every combination you can
provide the next transformation
so the instance of a function but
looking at this code it’s
quite it’s a lot of syntax
it’s a lot of stuff and if you start
with
supply asynchronously a b and c you’re
allocating immediately resources
and you don’t know how long it will take
until you have this
value for example so we we want to make
it a little bit more space
but first working on the syntax
so we can write it a little bit more
compact
because um i can just make sure that
i’m supplying the first one and then i’m
applying the next one next one i’m
prepping this a little bit together and
making sticky imports and all this stuff
but even this is a lot of code
for doing always the same
so i i want to highlight one more thing
sorry i want to highlight one more thing
and this is that for every combination
you can switch pools
so for every stack you can provide the
different pool it’s not necessary but
you can do it
and with this sorry
and with this you can balance the
utilization of your hardware which you
have at this point
but um if you are just using one cool
for the first example it’s fine
so playing around i want to
have this concatenation function for
example i’m just extracting
i have now there’s different suppliers
that i’m defining somewhere
it’s functions somewhere defined so it’s
somewhere this binaries or these values
are coming from
could be a network could be a read from
file whatever something
i don’t know different timing in uh
timing behavior
then i wanted to connect everything so
and
if i’m extracting this function i see
that at this part
this then combine other chronology and
so this is a lot of good
how to get rid so the next thing is
this operation is just this definition
so just have in mind that this complex
decisions and timing stuff is just this
little bit
amount of code but
if you are talking about um
design pattern and what we learned and
how to combine all this stuff
and i spoke a lot about this functional
stuff
if you are going functional you are just
deleting your knowledge about object
oriented if you’re in your functional
world you’re not
consuming your knowledge about your
object oriented world
no is there something that you shouldn’t
do
no i think you should combine both of
them so if you are going functional
inside the jvm
it’s good to mix it in a level that fits
to you
based on your skills in object oriented
and functional programming there’s one
example i want to show
for example here the complete future is
active after creation is something i
don’t want to do
if i want to start create defining
completely future
so that i’m decoupling the way of
defining what i want to do
and explicitly start running then i need
something
that is able to hold the definition
without starting and then you can do
exactly the same with the streams you
can create a function
based on an input value creating a
functional
completed future but
going back to this example what i spoke
about
is if you have different functions
whatever functions
where they are coming from and i want to
combine them in this tree of execution
i have to write a lot of stuff what can
i do to extract
this boilerplate code what can i do at
this point
because i have this compose other the
supply answering and all this stuff i
want to get rid of this stuff
i want to have something that’s compact
for example this one
and i want to decouple the point of
defining what i need and allocating
resources and executing
so for the first one this all for the
second one so defining it and executing
i know i need a function
because then i can declare everything
and then i can invoke
that’s one approach on the other side i
want to get rid of this
completely future synthetic stuff
because i just want to have these
functions and then i want to define and
combine combine combine for example
if you’re from an object-oriented world
you know the
pattern builder the builder pattern
and why not using it so if you are now
start combining both of them
you can get rid of this syntactical
stuff even with
object oriented design pattern but it
doesn’t mean that you’re giving up your
functional approach and here this could
it’s a lot of good but
it’s more or less just a build-up
pattern
you’re defining stuff you’re adding
attributes you’re doing some stuff and
if you have everything together you’re
giving something back
here you’re giving back a function that
will create it
just in the moment you need it but on
the other side
you have a builder pattern so my my
advice here at this point is
start with a functional approach do it
with code java
then start with a reactive approach but
don’t forget the object oriented stuff
you learned
you combine it to the tools you need and
you want to have and then you have
a very powerful tool set with even the
core jdk
and without adding any library
because this is just if you see the
implementation on github it’s just a few
lines of code
really not so much and you have a
complete new paradigm
so this is i think
the window is closed i’m back here so
this is what what i wanted to to explain
with the functional reactive with its
functional approach
and um yeah if if you want to know more
about uh
connect via twitter ping me via linkedin
whatever
have a look at my youtube channel since
code i’m not traveling so i’m going to
the forest and doing
there my talks for recordings otherwise
i hope
you enjoyed it and yeah give me comments
um try it out and happy coding
and so thank you
sven that was a great
um great walkthrough
and um i have to i have to say
i’m uh i was noting a lot of stuff
that i am that i am definitely going to
follow up
uh a lot of interesting stuff on the
functional programming
part and i i just
made some notes that i just wanted to
ask you uh what do you think
about the the the future in
the future of java in terms of uh you
know the evolve
the evolution of the language and
towards functional programming
and because
the type signatures of java can
sometimes make it
you know a little bit difficult to get
the overview of the whole
or the readability and so on do you have
any thoughts about
this stuff so first of all
uh what what i really like with java is
that you’re not pushed to one direction
so
you can code it object oriented you can
code it procedurally if you want you can
encode it functional
so this this one thing i really like um
there’s one thing that
is um maybe not powerful enough for a
lot of function stuff is this typing
system with generics and all this stuff
on the other side i don’t want to have
it like scala so that my compiler is
just going mad all the time
and taking hundreds of years until the
copal is done
so um i think the the balance between
the type is a how strong or how flexible
the typing is and the different
approaches and syntactic
stuff is what i like and i i really like
it
maybe it would be nice if you have some
kind of immutability
if i want but not per default and push
through so that i can decide if i want
to have something mutable or
un uh immune so this is something but i
think in
general i think the the community will
lead the development
of the roadmap of java and um
we will see what the most of us will
need and use for
the job and then it’s just fine so it
will go
the way of the community that’s good
are you mute yeah
thanks uh garten i just wanted to ask
you
a question about fuji for of the viewers
and
people who join us uh later on in the
stream
uh what was the motivation behind
creating fuji and how can people
use that to how they how can they get
get the most out of it well the
motivation behind it
is that we don’t have a
community site so far as java developers
i mean in in some microsystems times
um there was one company that was doing
java and now there are multiple
companies doing java
um you know amazon red hat uh azul
um liberica belsoft you know there are
so many companies doing
java that there isn’t one site that
connects all those different stories
together i mean where would you go
if you are a new java developer so
ultimately
what we want is for fuji to be the place
that
if somebody says hey where should i how
should i get started with java
that the answer is fuji and if somebody
says um you know
what are some tips what’s the best place
for tips and tricks
around java not the answer is fuji
because it’s a place for friends of open
jdk
so that kind of site um other
technologies have
python ruby you know languages because
um the organization backing it is it’s
much clearer who is behind a particular
technology
it’s it’s much more coherent so that’s
why we’ve created this because there’s
clearly a vacuum
for such a a meta level
java site and now it’s here so to get
involved in it is um you you follow on
twitter
and you join the slack channel and you
say hey i have content to share or i
have tips or
i would why don’t we do this so why
don’t we do that on fuji or this could
be better
we can we can make it happen together
it’s it’s all very uh
community driven that’s the whole point
yeah
very nice to hear may i just as i have
been curious about wanting the name
fuji yes is there any story behind this
name
yes so so when you see the um the
subtitle a place for friends of open jdk
so fuji has in it um the the f
for friends and and the o from
of of and the o for open because
the the problem with with a java site
is you can’t use the word java because
the word java belongs to oracle
right so if you if you come across any
site that has java in the url
or in the name there’s going to be
legal issues with oracle at some point
because oracle owns that name
so we have to hide java somehow
in in our name so fuji means friends of
open jdk
i have been clicking and looking in the
around
fuji and i have to say that i immediate
immediately
when i looked through the the bug fixes
and the changes in the language just
clicking into
for example jdk 16
and going onwards i i immediately felt
much more informed about all those tiny
tiny
tiny tiny you know changes and
and it definitely made it made
well i felt more connected because now i
can actually have a
quicker way of accessing those lists so
i have to just congratulate you on the
on
with fuji and i really look forward to
spread the word and so it can be useful
for many
developers i have of course
since the new release cycle of java
uh you know i have i i saw different
matrices
from different people making uh you know
trying to visualize
the old distros and changes and so on
so having them on one place has been
very
very cool and
[Music]
i have to say thank you again it was
very very cool
to have you with us and to share the
this meetup is recorded and will be
available on our uh
youtube channel uh and uh
sven yet another great talk
i remember you joined us in the last
year as well
and your your talk
from last year is also available in our
youtube channel
and yeah i hope everyone
had a good evening with us uh
so and i want to say thanks to my fellow
jawabin
heroes that helps us with our with
the organizat organizing our meetups
and uh gatian thank you sven thank you
so much
and with that i would
i will say thank you for watching
everyone and have a good evening
thank you very much