wrapperup

Agree on the first point, I think using JS makes more sense when you need to update some client state, like a dropdown or even that edit example. But htmx makes a lot more sense when you need to render some data from a server. In a SPA, you receive JSON, only to transform it back into HTML to render, so why not skip that middle step?

You might find https://data-star.dev/ interesting, it takes some of the modern approaches (signals, etc) and mixes it with the efficiency of sending straight-up HTML, htmx style. It's very similar to using Alpine + htmx together.

Oh yeah for sure. I haven't had that happen to me, but when I dropped AstroNvim, I had a chance to start from fresh (on lazy).

Small customized config also means smaller and more precise changes. I haven't touched mine in quite a long time, only usually to add that cool trick or plugin that pops up every so often.

I've used all except Kakoune. For me, Neovim is the one that stuck. Helix is cool, but having no plugins is a deal breaker (for now!) The onboarding experience is much nicer for sure, and Helix's LSP is way easier to set up than Neovim's.

That being said, Neovim, once you get it set up, is great. The biggest hurdle for me was the config, but if you just start from scratch and make a light config (mines about 200-300 lines, with LSP, hints, etc) you can get through it. And you never have to touch it again, since most likely you configured it in a way you like. Well unless you wanna add the occasional plugin. There are also distros of Neovim that contain a fully baked IDE-lite experience, but honestly those have extremely complicated config, and often IME don't feel nice and light.

It's definitely not for everyone. There is that time investment to get started, but it's definitely been worth it for me.

My config: https://github.com/wrapperup/nvim-config

I recently did this in a relatively small crate, and it halved the dependencies. Highly recommended if you don't need async.

Hetzner is fantastic. We switched from Linode to Hetzner over a year ago for our website and backend, and have been running with zero downtime. The pricing is also pretty darn cheap. Hoing they expand their US locations!

Yep, indeed. But htmx can reduce that a lot (to 0 even, in some instances), which is why it's really nice.

There's also WASM, which is slowly gaining steam, but it still isn't a first class citizen like JS is.

Much of your business logic can live in the backend, and it keeps your frontend really tiny. The idea is to generate HTML on the backend, instead of using a front-end framework to generate HTML on the client from an API call.

You can also do the same in Node if you want to, I currently have a TS website that is mostly templated HTML in production (without htmx). Htmx would be perfect for that site.

I think something like Twitter and Discord could be written in it, but something like Google Maps or VSCode, definitely not. For anything where you need server data rendered, it's perfect.

I'm currently writing a website that contains user generated content for a game, kinda like Steam Workshop.

Mostly great, there is a lack of native Rust frontend tooling outside of Leptos/Dioxus for templated websites, such as static file handling and bundling. Previously, I used vite for this on a templated nodejs website.

But I am working on a simple web bundler crate similar to vite to alleviate that (check out the htmx discord!). It's missing the HMR part for assets that can be hot reloaded (it just refreshes your browser), but this will improve things quite a bit for anyone making templated SSR Rust sites.

Otherwise, the backend ecosystem is really fantastic in Rust, not much to complain about. Axum is great, and I'm using cornucopia for SQL. Having the type safety is a killer feature.

Yeah with these frameworks, you usually need to pair it with a backend that talks to your database. Most of the code you write in these frameworks run on the client (but they employ some server rendering techniques for performance reasons, but generally you treat it like client code)

Astro is another one that is server-first, similar to PHP, so maybe you'll like that. It also has integrations with the popular frontend frameworks.

And if you don't like any of that, htmx is great!

If you want a job, it's probably going to be React. But for personal projects, I hear Svelte would be up your alley. SolidJS is another nice option if you want to get into JSX templating, and more into something like React hooks that actually makes sense and performs close to vanilla JS.

But recently (and maybe you're already familiar), a library called htmx started gaining popularity, which you might like. It doesn't require a build step, npm or node to use it. I'm using it with a Rust-based monolithic website to great success, but you can use it with any backend in any language you like.

I use 10x editor, Rider/Clion

Agreed. Back then, I tried to get into neovim with packer and a ton of plugins, then tried AstroVim and stuff broke all the time. Went back to vscode.

I tried it again about half a year ago with a much leaner, custom lazy (plugin manager, not LazyVim) setup, and now it's my main IDE for everything except C++ (clangd sucks, sorry)

It took me less than a day to get a decent config, and now I rarely touch it (occasionally there may be a nice plugin to throw in). Config is about 2-300 lines, with LSP (rust, typescript), harpoon, oil.nvim telescope, etc. Works great.

Yup. It's pretty common to see Alpine + HTMX used together since they are both HTML first. I've heard web components work well with HTMX too.

It's fantastic, and also my favorite. And for those who might not know, he was the one who really mainstreamed Data-oriented design and ECS architecture in my eyes.

He previously was also leading the charge on Unity DOTS, though unfortunately it seems Unity is having a tailspin at the moment. The work on DOTS is solid, if incomplete.

JetBrains' IDEs are very heavyweight, it's apples to oranges. And while there is some native code in them, they're still driven by the JVM mostly. There is fleet, but it's not an improvement to vscode at all IMO.

How about vscode vs sublime, neovim, or any other native text editor with LSP support? vscode is slow comparatively.

Yes. It's increasingly common in big C++ code bases (Unreal for example) to prefer interfaces, templates and composition over inheritance, though it's mostly found in newer code. Unreal is still fairly OOP since it is decades old.

Of course, there is some object-orientedness to it, the author even calls part of his new code "objects". I guess some people would call that OOP, but it's certainly not traditional OOP.

Rust does a really nice job of making that the first obvious thing to reach for (simple structs, traits and generics), and making the slower stuff like dyn traits (v-table indirection) more annoying and less desired. Reducing indirection and abstractions makes it easier to reason about code.

The tooling is great, don't get me wrong. But as soon as you need to do anything that slightly deviates the norm in Unreal engine, you're constantly butted up against broken features, or terrible performance. I can't count the number of times we had to fix a feature or some silly performance problem that was broken in the engine itself.

The latest of which was Iris (to be fair, it is in an early state, but it is a major improvement to ue4's replication), there are some baffling design choices that deliberately made it way harder to make custom serializers for networking.

It's not all sunshine and rainbows. It mostly depends on if you walk the well trodden path or not.