Dauros

Yes! HTMX is a better API on top of a XMLHttpRequest for this approach. A hypothetical next iteration of the HTML standard could make most of HTMX unnecessary. Maybe one day.

Usually we have a base template with a content block that a child template can extend. The extend keyword supports variables as well. So we can create a dummy base template, e.g. fragment_base.html, that contains only the content block and if a request is coming from HTMX we set the base template to the dummy one, so the rendered template will contain only the fragment.

It's already supported with the client-side-templates extension [1]. HTMX can fetch JSON from the backend then calls e.g. nunjucks.render() with the data.

[1]: https://htmx.org/extensions/client-side-templates/

Not at all, you can preload as many data as you wish and use vanilla or a companion JS framework like Alpine.js or HyperScript or any web-component to make the current page interactive without fetching the backend. It's a trade-off between the initial page size vs. additional network delay.

HTMX is basically a JavaScript framework that makes the traditional request-response approach feels like an SPA via replacing only part(s) of the current page with the response. In this case: it loads a small form, submits it to the backend, then replaces the respective part of the page with the updated markup. The state is kept only at the backend.

With some constraints you can create a page that works with or without JS. The same endpoint can be used for serving HTML fragments for HTMX and full page for JS-disabled clients since the HTMX request can be detected by the HX-Request header.

Because they are actually two distinct views: one is a details view, the other one is a form view. HTMX loads the form view and replaces the respective part of the page. But it needs to contact the backend for the form, you don't have the data model on the client like with an SPA framework, so you cannot generate the form.

On the other hand this site also teaches the internet that eventually everything becomes a reaction-diffusion system/phase separating fluids [1].

[1]: https://www.karlsims.com/rd.html

HTMX helps you create an SPA-like experience without using a full SPA framework. You can utilize the full power of your favourite backend framework (e.g form validation, template-system, authorization, etc.) without writing JS code directly. Some examples:

- Infinite scroll: HTMX detects the specified viewpoint and requests the next batch of content. The backend returns only the rendered partial HTML content that HTMX appends to the bottom of the page.

- Next page of a paginated content: if the users clicks on the 'Next page' button, the backend returns only the rendered HTML content of the next page, HTMX replaces only this part of the page.

- Form submission/validation: you can skip most of the frontend validation and use the backend for it. If the form has an error, HTMX replaces the new rendered form with the inlined error messages. Otherwise it can forward the user to the next page or shows some success message.

- Inline edit: e.g. click on the row in a table to load a small form just for that line. After the submission the backend returns the updated rendered table.

- Chained select input elements: when the user selects something in the first dropdown, it triggers an HTMX request that loads just the next select element that reflects the value of the first one.

- Background task with progress bar: just return a delayed, automatically triggered HTMX request from the backend until the task is finished. The status (e.g width) of the progress bar is also calculated on the backend.

- Search preview: with the builtin debounce filter trigger a search request that returns the search suggestions.

- Multiple small(er) updates on the page: one HTMX request can return multiple HTML partials that updates any part of the page. If you couple it with the builtin automated polling/websocket, you can build a live dashboard easily.

Of course you can do any of these with a SPA framework coupled to the backend API. But with HTMX you don't have to write a single line of JS, just put some htmx-something="..." attributes in the backend template files.

Site bug report: on the pricing page the 'Use cases' and `Features` links in the footer are throwing errors in the browser console. I guess they are trying to jump to a specific section on the home page without going to the home page first.

Yes, Go templating is quite hard. There was a feature request[1] to implement the Django/Jinja2-like Pongo2 template engine[2], but got rejected because it would have been a too big change.

[1]: https://github.com/gohugoio/hugo/issues/1359

[2]: https://github.com/flosch/pongo2

You can combine HTMX with a SSG like Hugo and generate a bunch of partial HTML files that HTMX can load later on request. No server is required.

Joplin also have a few plugins [1], e.g. Obsidian-like graph plot of the notes [2,3], math mode [4], or tabs interface [5].

[1]: https://github.com/joplin/plugins/blob/master/README.md#plug...

[2]: https://github.com/agerardin/joplin-plugin-knowledge-graph

[3]: https://github.com/treymo/joplin-link-graph

[4]: https://github.com/CalebJohn/joplin-math-mode

[5]: https://github.com/benji300/joplin-note-tabs

AFAIK the only one is Dramatiq [1] with dramatiq-pg [2]: a 3rd party message broker using Postgres LISTEN/NOTIFY.

[1]: https://dramatiq.io/

[2]: https://gitlab.com/dalibo/dramatiq-pg/

> Refactoring shouldn't exist in this hypothetical game

Without refactoring the factory planning phase would be more difficult since I don't want to fill the best places on the map with unmaintainable, non scalable factories. Refactoring should be very easy, e.g. like in Factorio with construction bots: just press ctrl + x and the bad part of the factory is gone.

If you want to build an abomination, try SeaBlock mod [1] for Factorio. You don't have to refactor anything, space and resources are infinite, so just build a new factory next to the old one after you research a new tier of technology.

[1]: https://mods.factorio.com/mod/SeaBlock

Gitg. Similar to gitk but with a nicer GTK GUI.