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.
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.
> And you never have to touch it again, since most likely you configured it in a way you like.
That was the issue for me, there actually is quite a bit of churn in the Neovim plugins ecosystem compared to VSCode (Packer vs Lazy for plugin management is just the latest iteration). I used to have Neovim plugins all built out but the churn was too much for me.
I've used vim-plug for over a decade and it's been working fine. Yes there has been a lot of churn within some plugins, but overall it hasn't been that bad in my opinion.
And with lazy tracking plugin versions in a lock file, it's easy enough to pin plugins to a known good version whenever something breaks.
(I finally rewrote my entire config, and lazy is vastly better than vim-plug. I should've done so sooner.)
> (I finally rewrote my entire config, and lazy is vastly better than vim-plug. I should've done so sooner.)
What's better about it? I ask because I've been using `Plug` since I switched from pathogen (what feels like) an eternity ago and I don't really know any reason to switch because it just sort of works...? Every few years or whatever I'll overhaul the config (not a choice but it just sort of happens) and I'm curious whether switching plugin management plugin has a point.
- You can specify plugins dependencies, instead of having everything in a big list.
- You can separate each plugin setup/configuration into separate files.
- It tracks plugin versions in a lock file that you can commit into git. Makes it easy to identify plugins that breaks and lets you pin it to a known good version.
- Nicer UI to install and update plugins, including a git log for each plugin.
- Lazy loading of plugins. Not critical, but it does make a difference if you have a few slow plugins that you need occasionally or just a lot of plugins.
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.
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!
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.
> Much of your business logic can live in the backend, and it keeps your frontend really tiny.
Ah, so "with htmx you can use any language" is true because its users are no longer using a programming language per se for the front-end, but instead are defining logic with htmx's DSL?
Yes but vue is far more involved than htmx though. Vue has its own way of architecturing your project. htmx is closer to a progressive enhancement of html
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.
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.
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.
seems good for low-interactivity sites, especially if everyone is generally looking at the same content. i'd consider it for my company's front-of-site, sales sites, blogs, that sort of thing. i certainly wouldn't write discord, vscode, or even a simple no-code tool with it.
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.
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.
I had the same issues with AstroVim when it was first coming together. Looks like the creator was rapidly iterating to try and make it easier to configure.
It’s now in a stable enough state that I haven’t had any issues.
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.
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.