Corey Prophitt

Suckless Web Development


Web development sucks.

In an era of increasing web application complexity I take solace in a simple web development methodology.

I have been calling it the suckless methodology. It's an obvious reference to the classic suckless tools and their philosophy, but it doesn't borrow any specifics from it.

My suckless web development methodology is about building web applications that will stand the test of time while being efficient, unobtrusive, accessible, and simple to maintain. In essence, it is about making web development suck less.

The suckless methodology boils down to three core ideas. These ideas are not entirely new and I have written about some of them before. This post serves as a sort of natural evolution of these ideas into a more unified philosophy or methodology.

Stick with the fundamentals.

This is not the first time I have written about using the fundamentals while developing. A few years ago I wrote about choosing dependencies.

In short, you don't need to use Haml, Jade, JSX or whatever is gaining stars on GitHub this week. You should strive to write your HTML in HTML, your CSS in CSS and your JavaScript in JavaScript the browser can already understand.

Don't stop with your choice of languages. You should avoid bringing in non-fundamental tools such as complex tool chains and transcompilers. Complex tool chains only grow more complex and introduce more complexity into your product. Meanwhile, simple shell scripts and makefiles from the 1990s still work and are accessible by default on most operating systems.

There are plenty of great libraries and frameworks out there that function without the need for a complicated build step (mithril.js, etc). Reach for those libraries and frameworks first. Save the complexity for later (or never).

Avoid (or own) your dependencies.

I once had a team lead that had the mantra, "Don't make what you can take."

I abhor that way of thinking. Third party code and tools are not free. They are not there for the taking. Every dependency you introduce is a potential source of failure; a source of security and maintenance nightmares.

In general, avoid dependencies whenever possible. Not only in code, but with regards to your tooling and even the companies you come to rely on.

Never forget, Github may disappear. The library owner may change hands or go rogue. The library may be renamed or disappear completely.

If you do require a dependency, adopt it. Vendor it. It is yours to take care of now. You own it. If you cannot accept that you should not be using it.

Use JavaScript, but don't depend on it.

JavaScript has brought a lot of good to the web and opened up numerous possibilities within the web browser but it has come at a great cost.

The barrier to entry for new web developers is insurmountable. The complexity, bloat, and maintainability of modern frontend clients is a complete disaster. To make matters worse the web feels less usable than ever before.

JavaScript isn't inherently bad. It can be used to great effect. Make use of it if you can, but don't rely on it. There was a time when unobtrusive JavaScript and progressive enhancement were all the rage. Those movements have been overshadowed with modern frontend frameworks.

Cull the bloat and wasted resources. Server side rendering enables you to include what is needed when (or if) it is needed. Don't require JavaScript arbitrarily on every page of your website. If your payments page or a complicated component requires it, fine. But don't require JavaScript everywhere because of it.

Avoid modern frameworks and instead adopt the timeless idea of using JavaScript to enhance your website or application. Strive to make the web usable even with JavaScript disabled. The web becomes a better place for everyone when you do.

© 2012-2023 · Corey Prophitt