Functional Reactive with Core JDK @ Silesia JUG (Poland)

March 9, 2022

2 min read

74th meeting of Silesia JUG!

There are a lot of reactive frameworks in the field, some with functional languages for the JVM. However, Java gives you both. But how you could combine this and use this without adding the next big framework to your project? We will have a Core Java journey to explore a lot of excellent possibilities based on the JDK.

Sven is working as a Developer Advocate for Jfrog and coding Java since 1996 in industrial projects. He was working over 15 years as a consultant worldwide in industries like Automotive, Space, Insurance, Banking, UN, and WorldBank. He is regularly speaking at Conferences and Meetups worldwide and contributes to IT periodicals, as well as tech portals. Additional to his main topic DevSecOps he is working on Mutation Testing of Web apps and Distributed UnitTesting besides his evergreen topics Core Java and Kotlin.

Also delivered a similar talk to JavaBin Norway on the 2021 tour: is the new Java community platform with everything you need to do your daily Java development work — with reference materials on the latest OpenJDK versions, vendors, and distributions, together with insights into the latest quarterly updates, articles, blogs, tips and tricks, and much more. And all for free, accompanied by a Slack channel for discussion on all things Java and OpenJDK.

To celebrate and introduce, members of the Foojay community are doing a JUG tour and one of the stops is right here at javaBin. Come join in, learn about Foojay, and hear Sven Ruppert speak on “Functional Reactive with Core JDK”.

View Slides Here


Sven Ruppert

    Sven Ruppert

    Developer Advocate

    Sven is working as Developer Advocate for Jfrog and coding Java since 1996 in industrial projects. He was working over 15 years as a consultant worldwide in industries like Automotive, Space, Insurance, Banking, UN and WorldBank. He is regularly speaking at Conferences and Meetups worldwide and contributes to IT periodicals, as well as tech portals. Additional to his main topic DevSecOps he is working on Mutation Testing of Web apps and Distributed UnitTesting besides his evergreen topics Core Java and Kotlin.

    Video Transcript

    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
    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
    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
    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
    azul i worked in oracle on open source
    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
    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
    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 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
    is that there have been multiple
    releases now when i was in sun there
    would be a new release every couple of
    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
    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
    releases of of java and so here you can
    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
    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
    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
    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
    newland has a site called chris who
    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
    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
    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
    and here are the authors who publish on
    and there are many well-known people
    that you will have heard about
    in the java community like um for
    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
    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
    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
    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
    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
    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
    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
    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
    hello hello so so we heard
    about fuji and the place everything is
    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
    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
    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
    know me because mail is just i don’t
    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
    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
    functional reactive with code java and
    the target here is to to have
    functional approaches without adding
    other big
    libraries or different typing systems
    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
    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
    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
    and then working again on some options
    successfully i think there is no clear
    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
    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
    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
    interface in general then it’s much good
    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
    i’ve tested interface a and this has two
    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
    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
    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
    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
    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
    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
    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
    for for providing stuff to have access
    somehow or
    static um imports make this
    technical noise but if if you are
    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
    it’s still it’s a long long time
    available this
    private methods but i see so much code
    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
    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
    given result don’t throw exceptions
    this means that this or else there is
    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
    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
    transforming so we have this value we
    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
    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
    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
    perfectly then we have just blocking
    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
    to optional from optional because
    otherwise your colleagues
    maybe don’t like this or it’s just ugly
    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
    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
    and good otherwise the acceptance is not
    so good
    so to transfer it’s just too optional
    from optional it’s just a wrapping
    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
    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
    so this is something that i would
    provide so that you can consume or use
    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
    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
    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
    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
    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
    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
    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
    check functions with limited expressions
    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
    is nothing else as a function from t to
    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
    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
    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
    if i’m going over compose i have some
    because i need to add a lot of
    syntactical stuff
    because the type interferencer needs
    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
    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
    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
    the only target here is for this high
    compose would it be possible to extract
    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
    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
    easy or smooth way to combine functions
    a function can be constructed out of
    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
    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
    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
    then you can declare this one in a
    way that it’s not um
    given with a state this is why i like
    interfaces to to play there the creation
    of functions of the way to create this
    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
    so the next step would be okay how can i
    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
    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
    and the context i want to have and it’s
    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
    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
    if you want to extract this constant
    because you want to have this predicate
    then you have the challenge that this
    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
    is a function i need a function that is
    able to create this predicate
    and then if you have this one you are
    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
    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
    and what you need you have to invert it
    step by step so the first transformation
    you have a function that will give you
    based on the first input value a
    that will consume the second input value
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    there’s a quite interesting approach for
    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
    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
    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
    but you can see here in the middle of
    this memoirs function that you have x y
    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
    if you have this instance of your legacy
    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
    this is why you should use trial
    function quad functions and all this
    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
    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
    solution or calculation and this is
    what i’m doing here with the case the
    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
    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
    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
    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
    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
    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
    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
    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
    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
    lost keys and then you have the first
    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
    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
    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
    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
    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
    this one is done i have the value c and
    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
    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
    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
    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
    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
    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
    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
    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
    completed future but
    going back to this example what i spoke
    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
    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
    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
    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
    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
    a question about fuji for of the viewers
    people who join us uh later on in the
    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
    what we want is for fuji to be the place
    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
    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
    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
    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
    very nice to hear may i just as i have
    been curious about wanting the name
    fuji yes is there any story behind this
    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
    fuji and i have to say that i immediate
    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 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
    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
    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 cool and
    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
    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