Via Negativa
By: Adrian Zumbrunnen
Tags: Product Management, Design Thinking, Startup, User Experience, UX

2. Reduction adds resilience

In 2009, two pilots from Air France flight 447 were in serious trouble. After flying through some storms earlier during their journey, some sensors on the wing caught ice and stopped working. This by itself, was not a big deal. As with most aviation accidents, it was a series of small errors that ultimately lead to a catastrophic outcome.

When some of the airspeed sensors stopped working, the autopilot disabled itself to give control back to the pilots. They themselves went on and were confronted with an array of different signals that were all simultaneously competing for their attention. A focus on the wrong signals lead to wrong interpretations. This on the other hand lead to wrong decisions that eventually resulted in the plane to stall.

It wasn’t until the very end that the pilots realized what was happening. The last recorded exchange was “Damn it, we’re going to crash… This can’t be happening!.” A few seconds later, the sound of desperate insight turned into fatal silence.

That day, all of the 228 passengers on board of Air France 447 died.

We increasingly depend on automated systems. As long as everything works as expected, they bring us great comfort, increased safety, and reliability. The moment systems become “safer”, however, is the moment we become negligent of what they actually do. Once they fail, we fail spectacularly, or even worse: we crash.

A large number of safety features and signals can easily become so complex that it’s hard to make sense of the overwhelming information. All these well intentioned additions and precautions may have well added to the cause of the failure itself. The more complex something gets, the harder it is to understand what’s happening.

When I started designing websites, life was easy. All you needed was an editor, an HTML, and a CSS file. On days when I felt witty, I even added some JavaScript. Today, I feel like I need to go through a regimen of tasks before I get to write my first line of code.

It usually involves setting up NPM, Webpack, Babel, React JS and all the other technical mumbo jumbo. All these layers come together to build a pyramid of inter-dependent blocks. This approach has greatly increased the efficiency of our craft but came at the cost of fragility. Once a module or dependency breaks, the whole system falls apart. We easily forget that the underlying foundation of the web is plain old simple HTML, CSS, and JS — even if some of the most avant-garde technologists want us to believe they aren’t.

Go to awwwards.com and take a minute to browse through the latest featured websites. The pattern is obvious. Most of them have vivid imagery, fullscreen autoplay videos, parallax-backgrounds, large JavaScript files, and artfully spinning loading indicators that build great suspense for the site’s content to finally appear.

Most websites get awwwarded to do more, not less. There is nothing wrong with that, as long as nothing goes wrong.

More than ever, it feels like we’re building and designing with the assumption that everything just works. That everyone will be using the same class of device, browser, and network connection we have. And how are many of us dealing with this ever increasing challenge? By reducing complexity where it’s easiest: empathy. Instead of designing and building for others, we’re designing and building for slightly altered versions of ourselves.

Through Via Negativa, we are getting into similar territory to what Jeremy Keith calls Resilient Web Design.

Resilient Web Design is about starting with the essence, and enhance from there. Instead of building an array of features simultaneously, you start with what’s needed and augment it with all the nice-to-have’s. When someone uses the crappiest browser we shall not mention by name, the core of the experience still works:

Lots of cool features on the Boston Globe don’t work when JavaScript breaks; “reading the news” is not one of them. Mat Marquis

By forcing us to focus on what’s needed, we ensure that we get our priorities straight. We all prefer boarding a plane that is safe, over a plane that hast the best entertainment system. The same applies to the way we build products — even when it’s not about life or death.

Make no mistake, that doesn’t just apply to the web. It applies to any technology, whether it’s development for iOS, Android or any other platform out there. If you are thinking about replacing a standard OS component or navigation pattern with your own, think again. Reinventing existing components is more expensive than we think. It’s not just that custom code needs to be maintained but users need to learn it too. Overall consistency often trumps individual greatness.

In iOS, swiping to the left is a system wide gesture convention to navigate to an app’s previous screen. In Gmail however, instead of going back to my inbox, it opens my previous email. Gmail behaves like Photos, instead of most other productivity apps. Swiping through emails is a well intentioned idea, but it quickly results in confusion since it clashes with pre-existing OS patterns.

When I started turning my website into a chat, I originally started with a version that was technically much more complex than what I have now. It used Natural Language Understanding so users could speak freely instead of the constrained version I eventually went for. The problem was that it became technically so difficult to manage, that I couldn’t ensure the experience was robust and consistent. I limited the functionality for the sake of the interface’s predictability. Interestingly enough, very few people ever complained about the fact that they couldn’t type whatever they wanted.

Takeaway: A reduction of complexity doesn’t necessarily lead to a reduction of usefulness and delight. By removing what isn’t essential, we’re adding resilience to the things that are. The baseline experience is the same for everyone. From there, everyone is on their own.