It's funny how helping your XYZ-neighbour because he's XYZ like yourself is totally okay, unless XYZ=white. Because when XYZ=white you are a nazi/fascist/white-supremacist/extreme-rightwing/hatespeecher/etc; all based off that single comment.

Look into https://en.wikipedia.org/wiki/Worker_cooperative

And in Russian I believe such a company is called a "Soviet". They idea that the main part of the economy is run by this kind of organizations is one of the best parts of the USSR's attempt at communism.

https://en.wikipedia.org/wiki/Worker_cooperative

There have been some govts that mandated this type of organization for part of their economy; we usually refer to that as communism.

(no value judgement here, there are day's when I'm quite a commie myself)

I learned Duck-typing from Ruby: if it talks like a duck, walks like a duck and swims like a duck -- it's a duck.

Applying this to Sam: he's white.

I just want to keep it simple.

Async "infects" you code: for it to bring benefits your whole codebase needs to be doing it (ingesting requests, db calls, web API calls).

Due to this we see "split" stacks in programming languages: one lib stack for synchronous, and one for async.

I did not think the benefits of better performance under load is worth the mental overhead of doing async everywhere. So i went with blocking calls and virtual threads. No regrets.

https://apps.kde.org/nl/kturtle/ (in pretty much every linux distro) also brings that benefit (though the language is not exactly a LOGO clone).

https://en.wikipedia.org/wiki/Suchir_Balaji

(sorry for the thinfoil hat remark)

P.s.: I find Kotlin "an acceptable typed-Ruby" with an industrial strength VM (the JVM) and two compiles to native stories (KMP and GraalVM-native).

So thanks Shopify for taking them under your wings.

X-mas wish: that the Servo project gets a proper patron (looking at you, Huawei and Samsung).

I used Qt, Gtk, React, Elm, JS-spagetti-with-some-jQuery-on-top...

And now I understand why people like Elm.

It's still open source! Just like in the pre-AI era they are welcome to submit a PR and improve it in the way they like it. The main dev seems very open to accepting help.

Htmx is the opposite of what I like. I will not use it ever for something serious.

it's a lot of fun working at a codebase that does essentially does not allow for runtime programming errors (validation errors are still there, or API/3rd-party errors still need to pass through your code; your Elm code is essentially incapable of creating any runtime programming errors of it's own).

There are bridges to Rust:

https://pub.dev/packages/flutter_rust_bridge

https://github.com/qt/qtbridge-rust

And this project, Relm4, is one of m.

I had to click a little to confirm that Relm4 (like the original Relm) is --as the name shows-- borrows from https://elm-lang.org

Elm comes with some really cool concepts known as The Elm Architecture (TEA) and many projects have since borrowed from it. Usually people in the FP-enthousiasts group are more inclined to like TEA. I'm not sure to what extend the brides mentioned above allow for a TEA-like architecture.

Nonetheless I hope all who do use Htmx, enjoy using it.

Since you are reading, here a story of mine. Both me and a friend build a SaaS product using ClaudeCode. We both have 15+ year experience in software (he more in dotNET me more in FLOSS).

He just accepted everything it came up with (pretty much vibe). I was suuuuuuper careful about what I accepted and spend the first weeks programming a lot myself.

His stack for JS was HUUUGE. Several different technologies were used. Mine JS stack was: only use Alpine.js (and avoid JS as much as possible).

His backend stack was equally huge: lots of native/binary OS dependencies bundled in Docker. Mine was 13MB of libs on top of the JVM.

Being one year in I run 3500 tests in 20secs. App boots under 3secs.

He considers rewriting it.

The art(isanal) is still important. Sure it's different now. But MY GOD what a difference a bit of oversight/leadership/tech-vision can make.