ReactFX VS Phoenix

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.

A standard Phoenix app contains a priv/repo/seeds.exs script file, which populates a database when it is run, so that developers can work with a conveniently prepared environment.

There was one in the Phoenix Framework (Elixir) about issuing certificates with an invalid end date: https://github.com/phoenixframework/phoenix/issues/5737

Interestingly, Azure had this bug some years ago too leading to an outage. https://azure.microsoft.com/en-us/blog/summary-of-windows-az...

Official website: https://www.phoenixframework.org/

Since you mention Rails, have you seen https://www.phoenixframework.org/

Thus, we set out to build a desktop application using a LiveView from the Phoenix Framework in Elixir. For the uninitiated, a LiveView is a process that receives events, updates its state, and renders updates to a page as diffs. The LiveView programming model is declarative: instead of saying “once event X happens, change Y on the page”, events in LiveView are regular messages which may cause changes to its state.

It seems though like Phoenix is similar like Blazor Server (using web socket), but Phoenix is: SEO friendly (first render is plain html) Light weight, scales well and concurrency is first class Easy to develop (runs a local server so you see live updates) Compiled With auth out of the box https://www.phoenixframework.org/

Sorry to hear this. Phoenix v1.7 changed how it structures files in disk and that broke quite some of the getting started material. However, the guides are always kept up to date, so you can give it a try: https://hexdocs.pm/phoenix/overview.html

You can also see the resources on this page listed by year: https://github.com/phoenixframework/phoenix/blob/main/guides... - the recent launched ones are most likely up to date.

Yes! I love Elixir :) [Phoenix LiveView](https://www.phoenixframework.org/) is really amazing. I feel so fast working in it. I got hooked after watching Chris McCord's ['Build a real-time Twitter clone in 15 minutes'](https://www.youtube.com/watch?v=MZvmYaFkNJI&embeds_referring...), and things have improved a lot since then.

I still work on a lot of Java projects. As of JDK 17 Java has most of "ML the good parts" and has the same scalable, reliable and high-performance threading Java is famous for. JAX-RS provides a Sinatra style framework that makes it easy to write JSON API back ends. JDK 21 is just about to come out as a long term supported version and it will be even better.

I do my side projects in Python with aiohttp and think it is a lot of fun even though people tell me it is suicide (I guess if you block the thread you are in trouble)

I think "Next.js" really wants a node.js backend which has the big advantage that you can share code with the front end and back end. It's basically single-threaded but I know people who are happy with it.

The system I'd most like to try is

https://www.phoenixframework.org/

which is just great if you want to do stuff with websockets that is more interactive than what most people are doing.