Temporal coupling in Fibers and Fibers vs State Machines.
rahulnewai at gmail.com
Sun Feb 23 07:32:10 UTC 2020
Thanks for the explanation.
I have a little experience with Kotlin Coroutines and you are right in
saying that composition have to be taken care in the source code itself. It
could be argued that reactive APIs are much more easier to use in that
It is also true that when using reactive APIs, Developers don’t have to
deal with low level constructs like atomics, locks, etc. This doesn't look
same in case of virtual threads, Virtual threads looks pretty much same as
normal threads when dealing with shared resources. correct me if I got it
About the sales pitch of loom, I can see the same thing. When I started
following loom few years back, it was proposed as a solution where you can
write imperative code and get the performance on par with reactive code. It
actually felt like JVM will do the heavy lifting and API users won't have
to deal with it. It is really hard to get concurrency right in Java and
even after loom it looks like that users will have to rely on DIY solutions
or third party libraries to get things right.
On Thu, Feb 20, 2020 at 1:12 AM Dávid Karnok <akarnokd at gmail.com> wrote:
> Rafael's concerns are mostly related how the functional and declarative
> nature of the reactive libraries are difficult to learn for some people.
> Yet, these people happily code in SQL and use Java Streams. Maybe it's time
> to go back to reading database files with InputStream and use for loops as
> Martin's concerns are, if by composition he means what I think he means,
> if you could set up pieces of computation and functionality and combine
> them into larger components. If so, these components can have state and
> those state could change in response to stimuli from other components.
> Reactive is one of such approach that has individual pieces - operators
> chained up on a dataflow have internal state tracking when and how their
> peers can send data and commands to each other. Loom's, and Kotlin's
> Coroutines instead say you compose via the source code itself, by writing
> larger and larger methods encompassing a lot of imperative operations. If
> you have such a method, but for some uses need some retry code, you may be
> out of luck and have to code yet another set of methods to include that
> Vaughn's concerns are that there aren't many helping hands with Fibers and
> concurrency. In fact, you have to consider the Java Memory Model again the
> moment two routines in separate fibers have to communicate: blocking
> structures, atomics, locks and their effects on visibility. In reactive,
> from an user's perspective, you don't have to worry about most of these as
> the libraries can hide many of the intricacies of the JMM and provide you
> with an API and callback surface. Want to create an item and hand it over
> to another thread for processing? There are operators for that and you have
> only to specify how to create the item, what thread it should end up and
> what processing there should be for it. Want to generate many items?
> Replace the front of the flow and the rest will still be the same.
> Also note that Loom's sales pitch has shifted over the years. It started
> as the solution that will outperform reactive and having users code in easy
> to understand imperative fashion as the JVM will do the heavy lifting
> behind the scenes. However, we have pointed out that a) suspension is more
> costly and may dominate the overheads, b) composition (see above) is
> limited so people, individually and over and over, may end up with DIY
> solutions and c) you have to make sure locks/blocking happen in a virtual
> thread for which you may have to inject virtual thread-based executors all
> over the place.
> Ron Pressler <ron.pressler at oracle.com> ezt írta (időpont: 2020. febr.
> 19., Sze, 19:48):
>> I don’t think I really understand what the concerns are, and believe they
>> be tied to a misunderstanding of Loom’s goals and design.
>> Anyone who has concerns is welcome to explain them here, without
>> character-count limits.
>> On 19 February 2020 at 18:37:53, Rahul Khandelwal (rahulnewai at gmail.com
>> (mailto:rahulnewai at gmail.com)) wrote:
>> > Hi All,
>> > I have been following Project Loom for quite some time now and I find it
>> > really exciting.
>> > This is my first post in the mailing list.
>> > I went through the following twitter discussion -
>> > https://twitter.com/rafaelcodes/status/1176229314112741377
>> > However I could not understand the final gist/conclusion of the
>> > 1. Here In the discussion Martin Thompson had the view that Fibers don't
>> > compose and cannot escape temporal coupling.
>> > He also advocated about the use of explicit state machines instead of
>> > Fibers.
>> > https://twitter.com/mjpt777/status/1176231250308325376
>> > 2. Vaughn Vernon had opinions around the Java memory model and the
>> > complexity of the effects of predictive execution.
>> > https://twitter.com/VaughnVernon/status/1176299015849136128
>> > Could someone explain what were the concerns and suggestions they
>> > and how Fibers handle said concerns.
>> > It would be great if someone could suggest some resources to better
>> > understand above twitter discussion.
>> > Thanks,
>> > Rahul
> Best regards,
> David Karnok
More information about the loom-dev