As an independent consultant, I am able to work on a wide variety of projects, collaborating with highly diverse teams. While I’ve worked with some incredibly talented people, I also see a pattern among UX professionals that is incredibly unfortunate, namely what I call the Reality Problem. At it’s core, the problem is this:
Most UX Practitioners Never Actually Create Anything Real
By Real, I mean actual working software that you can do something with, that is neither a simulation or a prototype, but is in fact the gosh-darn real deal. When was the last time you actually wrote real working code? If your answer is “not long ago” then I applaud you, but I also lament the fact that you probably are in the minority within the UX discipline.
So why is this a big deal? Well, it is for several reasons…
If you’re not building stuff, you’re removed from reality
What if you were writing a book about gardening but had never actually dug your fingers into the dirt, never actually planted vegetables, never watered and nursed them and kept weeds from suffocating them, never felt the joy of seeing them take root and grow and bear fruit. How could one possibly write a book about gardening without these real, tactile experiences? It would obviously be impossible, right? But designing software is in many ways no different from gardening, and to understand software, to know how to design it and get the most out of it, to have a blooming, thriving crop, as it were, well you’re going to have get your hands dirty.
So am I saying that all UX designers need to become software developers? Absolutely not. But what I am saying is that unless you regularly dig around in some code, you’re going to lose touch with the reality you’re designing for. Additionally, you’re going to lose your empathy for the people you’re designing for.
If you’re not building stuff, you’ll have less empathy for those who do
No, by people I’m not talking about end users. Yes, empathy for the end user is important, but that’s a completely different issue. I’m talking about your actual target audience, which is not the end users. (They are the target audience of the product itself.) The actual target audience of the work that you produce is the developers (and, depending on your team or project, other roles, such as visual designers.)
And believe me, if you’ve personally had to write production grade code, I can guarantee that it will impact how you approach your design solutions. You will, for example, think twice about throwing in some gratuitously cool feature. For the person with no coding experience, that little dynamic widget thing they dropped in their wireframe took them maybe all of 30 seconds to add. In other words, there is a complete disconnect between their work and the reality associated with this feature. And that reality is that 30 seconds of UX work can equal a full day’s work for a developer. Does that mean we should not innovate and continue pushing the envelope? Of course not. It simply means that one should be more pragmatic, and defer to the standard solution in most cases, and then innovate in places where you really can make a strong case for that it is worth the effort.
By simply having more of a general appreciation for what is involved in coding something, you can save yourself and your team so much of the time and headache that tends to go into back and forth of a developer having to explain to the UX Lead that, um, yeah, that thing you got in there is pretty darn complex. Instead, you might be able to empower your design skills by thinking a bit more like a developer.
If you’re not building stuff, you’ll never understand how developers think
I remember many years ago toiling away at a deck of wireframes for a content management system, only to later discover that my detailed design ideas were largely being ignored by the developers. Why? Because after reviewing my wireframes, they had then taken a broader perspective on the problem, and decided to use an off-the-shelf CMS framework. As it happened, that CMS framework came with a default user interface out of the box. In other words, my approach of focusing on the UI rather than on focusing on the design of the overall system led me to wasting a lot of time.
The developer perspective turned the whole UI design process on its head. Instead of starting by designing a UI, it here was more effective to leverage an existing UI standard and then shift from a design exercise to a customization exercise of that UI. While my mindset was fixated on creating a UI from scratch, they were all about reuse. And why did they never mention this to me, allowing me to create a whole deck of virtually useless wireframes? Well, for the simple reason that I never asked. If I had taken a developer perspective on my design, my starting point would instead have been to first work with developers to research what available frameworks are out there, and then if we agree on one to use as a starting point, my design exercise is instead transformed into a customization exercise.
Another great example of developer thinking is reflected in test-driven development. In that model, a piece of code is the user requirement. In other words, instead of writing a traditonal list of text requirements, you instead make the underlying intent of that requirement manifest in the form of code. In other words, since a well-formed requirement should be unambiguous and testable, why not represent it as an actual piece of code that inherently will be unambiguous and will simultaneously be what performs the test of the requirement that it describes? This type of thinking can be really really hard for UX folks to understand. But I think if they were to spend less time doing wireframes and more time actually building stuff, it would suddenly make a lot of sense, and the whole design effort would be better off because of it.