the orders of
Complexity of websites
and what they imply for the design of web platform features
I don’t remember who first described it this way1, but I like to think about the complexity of websites as roughly fitting a logistic ("S"-shaped) curve2:
- The first (simplest) order of complexity consists of a long tail of more-or-less static websites built primarily with HTML and CSS, e.g. the site you’re reading right now.
- The second order, comprising the vast majority of sites out there, consists of LAMP-ish, CMS-y things.3 They’ve got databases containing content and server side logic/templates which render that content into stuff sent down the pipe to the browser. Simpler sites in this tier are most blogs, and complex sites in this tier are big, popular sites like the New York Times.
- The third (most complicated) order consists of complex web applications like Google Docs or Photoshop on the web, whose backends and frontends barely resemble the architecture of sites in the second order.
The inflection points between these orders are where developers need to pick up whole new sets of skills in order to proceed:
- Transitioning from the first order to the second requires learning things like SQL or its moral equivalent, some amount of JavaScript, one or more server side programming languages & templating systems, how to configure your web server beyond the basics, etc.
- Transitioning from the second to the third order often requires a wholesale un-learning and re-learning of how to build websites, since the stack is so dissimilar to what you’ve seen before.
Sure, fine, whatever, but what does any of this have to do with
Designing web platform features
Browser engineers usually work for big technology companies. Big technology companies disproportionally operate complex web applications of the third order, and/or have important business partners that do. Managers and the other folk who call the shots in terms of what features to implement or prioritize (understandably) tend to prioritize things their VIPs are vocal about.
If most of the feedback or feature requests you prioritize come from the developers of extremely complex web applications, it’s really easy to fall into the trap of designing web platform features so complex and over-engineered that they can only realistically be adopted by the developers of extremely complex web applications. The Rule of Least Power goes right out the window.
This is especially bad because
The Web is generative
How to people learn to make websites? Generally like so:
- See a neat thing on a website,
- view source,
- copy and paste onto your own site,
- type-y type-y hacky hacky,
- ⌘R or F5 (reload)
That is, when you see a neat thing on a website, you can use your browser’s developer tools to figure out how that site does it, and then try to replicate it yourself. This is what makes the web generative. [Generativity is] the ability of a technology platform or technology ecosystem to create, generate or produce new output, structure or behavior without input from the originator of the system.
4 (Wikipedia)
When we hold fast to the Rule of Least Power, when we strive to come up with the simplest thing that could possibly work, we tend to come up with features that can be readily adopted by the people who make websites of the first and second orders of complexity—that is, the developers of the vast majority of the sites out there. It’s usually a mistake to design features with only the GMails and Google Docs of the world in mind. Design for Bob.
See also
- Gall’s Law:
A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over with a working simple system.
- Extensibility, HTML, and the Web ecosystem, slides from a talk I gave back in 2009 that had a bunch of this in there.
- The Website vs. Web App Dichotomy Doesn't Exist by Jake Lazaroff.
Notes
- It was probably Tantek. It usually is. ⏎
This is what a logistic curve looks like. Note the characteristic "S" shape, where the y value rises slowly at first, then quickly, then slowly again. (SVG sourced from the Wikipedia article.) ⏎ - Yes, I know referring to the LAMP stack makes me sound like an old fuddy-duddy. First off, yes, I am an old fuddy-duddy, but secondly, all of the advances in backend and frontend architecture and tooling that have happened in the last couple of decade don’t fundamentally alter this analysis. ⏎
- Look, I hate to be the person to break it to you if you didn’t already know, but Tim doesn’t personally make every website. ⏎