The tale of the stable Chicken Horse

Inspired by HTMX's "No new features" feature, I decide to search for a fitting backend to build the most stable stack possible. Lower than low maintenance. Join me on my journey to boring stability! ✨

Beautiful shiny stacks

I work at a small digital agency where we build apps using a very awesome stack: Django, Inertia, Vue, Tailwind, where we abstracted away the API and automagically sync types and forms between the Python and TypeScript world. All with server-side rendering and the whole shebang! It's beautiful and works like a charm.

There's just one thing that has been bothering me. Vue 2 became Vue 3, its Options API made way for the Composition API, Nuxt had major updates with breaking changes, Inertia had a major update. Hell, even Tailwind changed the way it handles configuration!

It's not that these breaking changes are impossible to fix, but they do take a lot of time and effort to keep up with. We have a lot of web apps to maintain and every major update also needs to go through testing to make sure everything still works as expected - all without knowing what might break. We've managed to keep up with it (and I'm still a big fan of the stack) but maintenance feels a bit inefficient when you're not really using all these shiny new features that come with the updates.

One idea to rule the stack

And then, like a hero in a spaghetti Western, an unhinged Montana man rides in on a laserbeam-eyed horsey.

The first time I heard about HTMX, I was enthusiastic, but it did not really click with me initially. I still liked the idea of having the data in the frontend JavaScript environment to work with, but after revisiting it a few times and seeing what people were building with it, I was sold. From that moment, all my side projects were powered by HTMX and I was a happy camper.

So it turns out this unhinged Montana man was actually kind of a genius. Behind the meme-y laser horse facade hides a very smart academic who has been sharing his ideas on web development in the form of books and essays. A lot of these ideas are very simple in nature, but as it often goes in life, the simplest (working) ideas are the hardest to come up with.

Maybe one of his simplest and (in my opinion) best ideas was to not add any new features to HTMX and make this promise as a feature. I love it. No new features, meaning no new lines of code, meaning no new bugs, meaning only bugfixes until the code converges to a heavenly state of reliability. This sh*t scales! Write once, run forever, and have all the time in the world to focus on important things like preventing yourself from starting yet another side project that'll live and die in your GitHub graveyard.

If only there was a backend framework that promised to not add features. I would switch and never look back.

Enter the Chicken Horse

So what options are there? Frameworks like Laravel and Django are fairly stable (a new major version every couple of years), which is probably good enough. But I want more. Give me a stack that will outlive me and my children.

A realistic option would be to use Vanilla PHP, but even PHP has a major upgrade every few years. Let's go boringly stable.

Some assumptions and requirements:

HTML, CSS, JS and HTTP that works in the browsers of today, will work in the browsers of tomorrow
There will always be hardware for which a portable subset of C can be compiled
Dependencies that are actively maintained and have been stable for a long time will remain stable for a long time

In other words: we want a programming language which compiles to portable C and has stable dependencies for web development. Ever heard of CHICKEN?

Don't let the name fool you, this is a serious programming language. It's a Scheme dialect that compiles to C and has been around since 2008. It's actively maintained, has a small but dedicated community and has a lot of libraries available. It's also very stable and has a very small core. All in all a great fit for our requirements!

The programming language mainly follows a legacy Scheme specification R5RS, which means it will not be subject to a lot of change. Perfect! Even better, the four dependencies we will need for web development are - while actively maintained - pretty much "done". No need for new features.

Totally unrelated, but very cool: CHICKEN uses a very interesting garbage collector algorithm called Cheney on the MTA. I totally recommend reading up on it, if you like compilers. It's triggering me to write a compiled language for the web to accompany HTMX, but that might be an idea for another blog post.

The Potential of the Chicken Horse

What excites me about this combination is the escape from the framework treadmill. With HTMX's interactive capabilities and CHICKEN's stability, we can build web applications that require minimal maintenance while remaining performant. Forum posts from CHICKEN's community suggest excellent resource efficiency and a surprisingly productive development experience once you overcome the initial Scheme learning curve.

For those of us seeking digital permanence in our work, this stack might be the sustainable alternative we've been looking for. I'm planning to test it on my next side project, and who knows—it might just become my go-to stack for building things meant to last.