Headless Apps

We’ve been promoting an idea lately that has been around for a while but doesn’t seem to get much press. We’re calling it “headless apps” but it likely has other names out in the wild. We think it’s a major change in emphasis for how applications ought to be built. For almost the last 20 years, the two prevailing modes for building applications have been to use either use cases, or, for agile developers, stories. We’re not suggesting abandoning either one, but recognize that both tend to subtly emphasize user interface lead design. Most use cases devote a lot of their spec to the way the user will interact with the application, which is primarily UI design. And the agile approach tends to focus on what the sponsors will see and how their experience will change. Consider this, though: most of the code and most of the effort in application development goes into the UI. As a result the UI becomes harder to change, and you need to get consensus among the users if you’re going to mess with it. Further, the business logic tends to get marbled in with the UI, making it also intractable. Finally, most developers aren’t all that good at UI design. The headless app approach says: design the business logic (validation and side effects) needed to support a business interaction (an event or a request). But only provide an API (these days, a RESTful or WSDL API). For testing and exercising you can build a “humble interface” (similar to Michael Feathers’ Humble Dialog), but it’s really only a scaffolding interface. Then turn the UI / Web Developers loose on it. They can build mashups, they can make several different stylistic approaches to the same functionality, and allow users to choose what would suit them best for the task at hand. The same user may use different UIs for the same task in different contexts. The UI developers are free to experiment uncoupled from the business layer, as they can’t really break anything. In many ways we think this was what was intended but rarely achieved with the classic three-tier architectures.