React and its ecosystem is a pile of garbage perpetuated by industry inertia. UseState, useMemo, useThisAndThat where you have to guess whether that dependency will cause a re-render? Or 20 different routers, state managers, query builders? I'm not even talking about html-in-ts with `!!a && (<div>...</div>)` A stodgy, bloated, overhyped and misused monstrosity, that's what React is.

useMemo is definitely a scourge on my existence. Doesn't help that a bunch of people write articles like "don't bother with it!!" when memoisation results can cause actual real bugs when integrating with a third party lib.

Unmounting and then remounting the same component is actually a bad thing when you lose your component state in the process. And when you have enough useEffect's in your system that's exactly what happens unless you're liberally sprinkling useMemo

React is opinionated. The whole point of the library is having UI updates being driven by state mutation. When I hear complain about the hooks, I ask about what is the state, and where do mutations occur, and usually, I get blank stares in returns.

It's all about the state. `useState` is the starting point (adding new items to the state set), `useEffect` for tying the UI to external systems, `useMemo` for state transformation, `useRef` for storing stuff outside of the state you want to react to,... Then you use custom hooks to make the code modular, stuff like usePost, useProfile, useCommentUpvote,... (HN domain)

If you design your state well, the application, at least the UI layer, becomes easy to code and maintain.

Running rust in wasm works really well. I feel like I'm the world's biggest cheerleader for it, but I was just amazed at how well it works. The one annoying thing is using web APIs through rust - you can do it with web-sys and js-sys, but it's rarely as ergonomic as it is in javascript. I usually end up writing wrapper libraries that make it easy, sometimes even easier than javascript (e.g. in rust I can use weblocks with RAII)

It does work well logically but performance is pretty bad. I had a nontrivial Rust project running on Cloudflare Workers, and CPU time very often clocked 10-60ms per request. This is >50x what the equivalent JS worker probably would've clocked. And in that environment you pay for CPU time...

The rust-js layer can be slow. But the actual rust code is much faster than the equivalent JS in my experience. My project would not be technically possible with javascript levels of performance

That's fair and makes sense. In my case it was just a regular web app where the only reason for it being in Rust was that I like the language.

did you profile what made it so slow specifically? sounds waaaaay worse than I would expect

I did. I don't remember the specifics too well but a lot of it was cold starts. So just crunching the massive wasm binary was a big part of it. Otherwise it was the matchit library and js interop marshalling taking the rest of the time.

edit: and it cold started quite often. Even with sustained traffic from the same source it would cold start every few requests.

the JS layer is slow, indeed, but it shouldn't be that much slower that it meaningfully impacts frontend apps

A demonstration of that by the creator of Leptos:

https://www.youtube.com/watch?v=4KtotxNAwME

Fascinating video, thanks for sharing.

What's a better alternative for shared types? OpenAPI is really outdated and the tooling is always a mess.

There is ts-rs [1], but it's only for TS.

[1]: https://docs.rs/ts-rs/latest/ts_rs/

protobufs?

When serialized as JSON perhaps. Being able to inspect payloads in the browser is too convenient.

I'm doing this now and it's mostly great but the openapi generators are not good. At least the Typescript ones produce confusing function signatures and invalid type syntax in some cases.

Why not Angilar? React and Angular are not worth comparing directly, but why not use Angular for the web interface?