FrOW HTML Fragments over the Wire by Thomas Güttler ¶
What is HTML Fragments over the Wire ? ¶
To understand FrOW I would like to have a short look at the history of web development.
The old way: Full page
Current hype: SPA (“JSON over the wire” together with React or Vue)
static site generators
The old way: Full page ¶
In the “good old days” before SPA (Single Page Applications) the browser loaded whole pages from the server.
The user could send data to the serve by filling out a form, and Post/Redirect/Get was used to process the data.
The full page reload is slow and introduces navigational issues .
Imagine you scrolled to a particular place on the page, and then you fill in a form. After the submit your browser would get a redirect and then reload the fresh page again. Now the position on the page was reset.
That’s not what you want.
Current hype: SPA (JSON over the wire) ¶
Most current frameworks decouple the backend and the frontend:
The backend provides an API (REST or GraphQL) and sends data (usually in JSON data format) to the client.
The client renders this data via JS.
Popular examples: React, Angular, Vue, ….
Server ---[JSON]--> Client (React/Angular/Vue) --> HTML
This has several benefits:
Developers don’t need to know everything. Some can focus on the backend, some can focus on the frontend.
The same API could be used for several purposes: Once by the frontend in the browser, once for integrating a third party application.
With tools like react-native you can create native apps for mobile devices.
But if this is so great, why was SSR (server side rendering) invented ? I won’t answer this question, there are thousand blog posts copying the reason from each other to hype this new thing.
static site generators ¶
If you internet page is just a digital business card, you don’t need dynamic content.
Even for blogs with just few new pages per week you don’t need an solution which executes code on the server.
SSG (static site generators) are great for readonly pages. In this case it does not matter much if you use a SPA or if you create several pages.
FrOW: HTML Fragments over the Wire ¶
Different use-cases need different solutions. And I think most software projects are between both ends.
As soon as you want to receive some input from the user, the SSG approach with pure static content does not work anymore.
For big companies, which have several software development teams, the clear cut between front-end and back-end is fine.
But for mid-sized proejcts this cut can introduce an additional overhead .
I am very happy that today (autumn 2020) more developers realize that there is a way to keep things simple by sending html snippets/fragments from the server to the client.
Then updates to the page get done via html fragments . These fragments usualy don’t contain a head or body tag.
I think html-over-the-wire has these benefits:
Much smaller technology stack. It is much easier to learn (for example onboarding new employees).
Input validation needs to be done on the server side anyways. No need to re-invent this in the frontend. If you use a library like the django forms library you get both in one step: A form in HTML format and a way to validate the input the server receives.
Testing is simplified. You don’t need to test your JS code, if there is no JS code.
Call it SSR (Server side rendering) or not.
If I compare modern SSR frameworks like Nextjs/Nuxtjs with a Django/Rails application plus htmx/unpoly/hotwire, then one thing is clear for me: html-over-the-wire is boring and simple . That’s why I will choose it .
Do it yourself ¶
Maybe you don’t need React/Vue or an other fancy thing. You can create great pages with HTML+CSS+JS.
You can implement html-over-the-wire yourself with XMLHttpRequest, fetch() or a library like axios.
But have a look at the libraries below, they provide you with nice features which help you do things in a declarative way (by using html attributes), instead of writing code (imperative).
Unpoly allows you to swap parts of the page, but provides many additional features.
Some of the additional features:
Faster response times: Outsmart latency by preloading pages, following links earlier, caching responses and keeping a persistent CSS / JS environment.
Branch off interactions into modals, popups or drawers. Return to the main page when you’re done.
Validate forms against server rules while filling in fields.
Written in Coffeescript.
Hotwire builds upon turbo. The primary focus seems to be to deliver page changes over WebSocket. I don’t plan to create a WebSocket based solution.
Maybe hotwire is really great. I don’t know. I have not found an easy to understand example while browsing their pages.