ReactFX VS reagent

You could also write that in many other languages like Clojure (with cljfx for FP fans), Python, Ruby, JavaScript, and of course Java. It would be less verbose if I used a library that better used Kotlin's features, but the goal here is that you can look up the JavaFX APIs from the link above (there are a couple of implied static imports).

So not much different, but it demonstrates how the text property of the label is bound to a dynamically computed string which is in turn bound to an observable number. When the timer fires, the count increases and the label is recomputed. Everything is done that way so layout computations, for example, won't run unless the size of the label changes. And that's it - no need for VDOMs or prop drilling or state memoization or any of these other performance hacks.

At some point you'll observe that this seems a like like "reactive programming" as used on the server side, and then might want to explore a library like ReactFX which connects these two worlds together.

https://github.com/TomasMikula/ReactFX

There are some other nice features in this type of toolkit that the web community seems to be heading towards. I'd be willing to bet a lot that at some point they'll even reinvent inheritance under a new name, because being able to write code that's generic over component trees is really pretty useful. The hooks/functions model totally wrecks that and has led to this explosion of "design systems" (otherwise known as themes), none of which interoperate properly or can be coded against in an abstracted manner.

None of this is to say that FX is perfect or that React/SolidJS etc are the wrong tools to use. You can run FX apps in a browser using a form of server side rendering - check out https://www.jpro.one to see a fully crawlable website that's actually implemented using JavaFX on the server with no frontend/backend split existing at all. But it only works well if you don't have a fast and reliable server connection, plus a server with plenty of RAM and CPU. Alas browsers pull all sorts of mean tricks to keep people locked inside the HTML5 sandbox so JS frameworks aren't going anywhere, but it would be nice if that community spread its wings a bit and looked at prior art from outside their language. GUIs are old and the challenges involved in them aren't new, and from the outside it looks suspiciously like there is no real progress being made here, only wheel spinning.

ReactFX - For cleaner, easier-to-reason event handler composition. Nice!

I've noticed when you look into a lot of classes in some libraries like guava, apache commons, or ReactFX, you'll notice a sort of abstraction pattern. There'll be a class that houses a bunch of common methods. Inside of those methods, instead of putting the relevant logic inside of the method, they'll call an operation-specific class that executes the logic. An example would be PredicateUtils or EventStream. Is there name for this pattern? It doesn't quite seem like it fits the command or service layer patterns.

Generating `HTML` from lisps has poisoned any other approach for me, see for example https://www.neilvandyke.org/racket/html-writing/, https://reagent-project.github.io/, and https://edicl.github.io/cl-who/

Hiccup syntax for Clojure uses hash maps (curly braces) for attrs, e.g. `{:style {:background "red" :margin "1em"}`

See Reagent which uses Hiccup synta: https://reagent-project.github.io/

    (defn simple-component []

* Single-Page App: shadow-cljs for the build concerns (https://github.com/thheller/shadow-cljs), Reagent with Re-frame for complex/large app (https://reagent-project.github.io and https://github.com/day8/re-frame). Even if we now prefer using HTMX (https://htmx.org) and server-side rendering (Hiccup way of manipulating HTML is just amazing, https://github.com/weavejester/hiccup).

The API documentation lists the most commonly and rarely used parts before going into detail and there are many usage examples.

Reagent has a nice intro tutorial (classic todo-app): http://reagent-project.github.io and many other helpful tutorials and resources for beginners: https://cljdoc.org/d/reagent/reagent/1.2.0/doc/documentation...

However, since Reagent is still stuck with class-components for more complex behavior and relies on Hiccup, which is nice but has a performance cost compared to pure React, I am unsure about its future. Like some others in the Clojure community, I have moved to thin React wrappers like Helix and use Refx to integrate those with re-frame. It may be a bit confusing right now for beginners since there is no “golden path”.

Also, unfortunately, many smaller libraries are poorly documented and it seems like it is expected from the developer to dig into the source code to find out what’s going on.

What I found the most difficult as a beginner was how to setup a project in ClojureScript in the first place, like all the configuration in shadow-cljs, how it interacts with deps.edn, how it integrates with npm, the REPL, etc. But dev/build config has always been a weak spot for me, so it might be just that.

Overall, I still very much enjoy working with Clojure(Script), more than in any other language. Anyone who likes Lisps and functional programming should give it a try (and be sure to watch Rich Hickeys amazing talks!).

have you tried cljs and reagent? it’s a different vibe.

my bootstrap: https://github.com/nathants/aws-gocljs

the project: https://reagent-project.github.io/

Clojure people have been doing this for a decade or so. It’s really so much better to work with. All started with Hiccup and when React came along you got Reagent and many more developments building on the idea.

> But Reagent supports functional components as well, with hooks and all.

I addressed this already: while reagent is able to emit function components, there is a performance penalty to this.[1]

> I also very much like Hiccup, and so do many of us, because code is data and data is code, and Helix has decided not to support that.

Hiccup is convenient to write, but it is a constant run-time cost and a significant storage cost given that you have to store long series of constructors to cljs.core.PersistentVector in your bundle, have the JS runtime actually construct the vector, then pass it through a Hiccup interpreter to finally produce DOM nodes and throw away the persistent vector, only to repeat this entire process again on re-render.[2]

> Helix has decided not to support that.

That is simply not true. From the Helix documentation[2],

> If you want to use libraries like sablono, hicada or even hx hiccup parser, you can easily add that by creating a custom macro.

These are all Hiccup interpreters you can readily use.

IME there is very little difference between using the $ macro in Helix and writing Hiccup. I do not really miss Hiccup when I use Helix, and you still have data as code ;)

While this is from an unrelated project, there are benchmarks[3] done against Reagent that demonstrate the sheer overhead it has. In practice it is not a big problem if you rarely trigger a re-render, but otherwise it is a non-trivial cost, and if you want to use modern React features (like Suspense), there is a lot of r/as-element mingling going on, converting cases, etc. that simply make Reagent feel more tedious to use than Helix.

Also, the newer UIx2, which largely borrows from Helix, is "3.2x faster than Reagent" according to one of the contributors.[4]

I think it'd be worthwhile to benchmark all of these libraries against each other and record the data in one place. Maybe I'll get around to doing it this weekend :)

---

[1] https://github.com/reagent-project/reagent/blob/master/doc/R...

[2] https://github.com/lilactown/helix/blob/master/docs/faq.md#w...

[3] https://github.com/roman01la/uix#benchmarks

[4] https://github.com/pitch-io/uix/pull/12

Reagent is peak React. All the good stuff without any of the hook and readability problems the article describes.

No affiliation, happy user for years.

https://github.com/reagent-project/reagent