The Irony of Abstraction

As both a developer and a user experience designer, I often marvel at the lack of understanding both sides have for each other. While making UX recommendations to a developer on a particular interface I have had a conversation something along these lines more than once:
Developer: "The user needs to understand how it really works."

Me: "No they don't."
The developer's statement is a shocking one to me, but understandable. Developers know that software is hard. Their egos are generally tied to being able to do something that is very difficult. Something that, quite literally, requires perfection to function.

Because the developer has poured so much effort into understanding software development, and building a particular piece of software, they want the user to appreciate that complexity. So they push back on UX-based adjustments that simplify the user's interaction with the software.

Yet it also reveals a hubris that isn't based in reality. The reality of software (and the computer sciences in general) is that we create abstractions. A software interface is an abstraction. Its goal is to abstract the user from the difficulties of software development, and focus on the task at hand.

We all sit on top of layers of abstraction

I find many developers fail to stop and ponder that they sit upon layers and layers of abstractions themselves. How many people really know how a computer works? How many could solder together logical gates and build a processor? People who talk about computers being '0s' and '1s' think they are down to the nuts and bolts, but '0' and '1' is just a mental abstraction over the flow of electrons, or dimples in gold foil, or other on/off physical constructs.

There is many a web developer (sadly) who knows little of HTTP, browser rendering engines, and how the internet really works. There is many a coder who knows nothing of how a compiler works, or the IDE they write code in. So it is the height of irony to say "the user should understand".

Now the reverse irony is that it is highly beneficial for developers to dig deeper and understand the layers of abstraction below them. Why? Because our abstractions are leaky. We will inevitably run across problems that to fix require a deeper understanding. Abstraction layers in coding fail.

But users aren't developers. They should be sitting at a comfortable, non-leaky level above the plumbing of software. If we feel they need to understand how the software works, it's either our own ego or frustration speaking, or the abstractions we built have holes that need to be plugged. So look at the UX and plug them!

We live in layers of abstractions. As developers and UX designers we create layers of abstraction. Our job to protect the user from the lower levels, not force learning them.

Don't be angry at your users for not understanding how hard you've worked. If it all seems simple and quick to them, then you've done your job well. 

Enjoy building good abstractions. Your users will thank you.

blog comments powered by Disqus