This post by LukeW illustrates perfectly something that I have seen as well. Death by a thousand progress indicators. As he notes, the well-intentioned desire to show progress can actually emphasize that things take time. Watch out for that–you may want to try other approaches instead.
Seems like every day I see a new article talking about the challenges of Responsive Web Design. And tellingly, the discussion of the challenges appears to be more in the context of just basic Web sites, that is, more information oriented sites with relatively straightforward page-to-page navigation interactions. From an interaction design perspective, such solutions are comparatively simple, contrasted against your average application, which typically involves significantly more challenging interaction design problems–just for one device class.
I have speculated before that Responsive Web Design is a lie. While that is a bit of hyperbole, the reality is that the fundamental idea behind the RWD technique is flawed from a Design perspective. It is purely a pragmatic concession, and as you can see by the many pragmatic challenges to even rather basic solutions (information Web sites), not to mention the typical huge bloat it causes, one just has to wonder how long the industry will keep trying to pound that square peg into that round hole.
We can make ourselves bigger, stronger hammers. We can use bores to make the “hole” bigger, but at the end of the day, it’s just a flawed technique. You can’t get to a great experience with a one-size-fits all solution, and you can’t reasonably manage many customized experiences with a single code base. Oh, and that’s on top of the Web platform, a platform that is, at its best, still immature from an application platform perspective.
Call me a party pooper, but that’s the reality we are saddled with. I think we’d be better off focusing our energies on just making it easier to design and build awesome solutions for individual device classes at a time, and looking at more manageable ways to share sharable assets between device class solutions. There are tools today that help, but we are far from an ideal solution. But at least that approach isn’t fundamentally flawed, i.e., it is possible we will get to a good solution. Not so with RWD.
A colleague recently shared this article saying that Steve Jobs never listened to his customers. That, IMO, is a bit off. I am fairly sure it is not accurate to say that of Steve Jobs, but more importantly, I don’t think it is something that should inform how we do design ourselves.
When you rely on consumer input, it is inevitable that they will tell you to do what other popular companies are doing.
Exactly. Biz stakeholders do this, too. But nobody wants you to replicate exactly what someone else has done–what would be the point of that? The takeaway is just inspiration–there is something about these examples they are giving you that is inspiring to them. Maybe you can drill in on what they like about the existing solutions, or maybe you just take them as indicative and try to find the good in them yourself (or both!).
…your insights are backed up with an enormously expensive creative process populated by world-class designers
A key point–valuable innovation does not come cheaply. It’s not a first-idea-out-of-your-head-is-right kind of thing. It’s not a process that prioritizes efficiency and cost management above discovering the best solution. This doesn’t mean good design is unattainable without a big budget and “world-class designers,” but it needs to be recognized that it doesn’t come free. It can’t really be tacked on as an afterthought, and the team and stakeholders at least needs to be invested in the goal of great design balanced with other concerns (usually cost and time).
It’s really hard to design products by focus groups.
Of course. This is a truism in UX design; maybe it wasn’t a truism when Steve said it–I don’t know.
Should you listen to customers is not a simple yes/no question. The question is when should you listen to customers, how should you listen to/ask them, and how should you incorporate what they tell you into your design process.
Asking customers what they want can be valuable, especially when it comes to refinement. Once you release something, potentially something innovative, customers will (hopefully) begin to use it and tell you (if you are listening) things they like, don’t like, pain points, and aspirations. All of that is extremely valuable, and you are stupid and arrogant if you ignore it.
But you don’t just make what people ask for. What they ask for is just an indicator of what they need, and sometimes it is a misleading indicator. For example, on Indigo Studio, we sometimes get asked “are you gonna do X?” where X is something they are used to doing with another tool. Sometimes X doesn’t fit at all with the design principles and goals of Indigo; in those cases, we’d have to have most of our customers demanding it before we’d do it, and even then, we would adapt it as best we can to the Indigo design language. More often, you can actually do X, but not quite in the way they are used to doing it, that is, you can meet the need but in a different way than they are used to.
The important thing is that you don’t take what customers say at face value. You try to understand what the real need is and design for that in the context of what makes the best design given all of your constraints and goals.
Focus groups are one of the least valuable ways to get feedback due to the group bias factor. Surveys can help, but they have to be crafted and analyzed well. One-on-one interviews are better, but you have to be careful not to lead people too much (and they are one of the more expensive methods). In-context observation usually yields design insights you wouldn’t get from a dialogue, and that’s also where a lot of potential innovation can come from. All of these are different ways you can listen to customers, and they can be applied effectively when they are appropriate.
At the end of the day, though, you have these inputs, but they are just that–inputs, and you have to lean on designers to come up with creative solutions. You have to foster that creativity and provide room for it in your process and environments.
Having customers involved early usually won’t–on its own–lead you to groundbreaking, innovative solutions, but their input into the design process provides good signposts to help add healthy constraints to your solutions, point you roughly in the right directions, and to refine existing solutions in use. So while we might agree with Steve that you shouldn’t “design by focus group,” that hardly means “never listen to your customers.”
I’ve previously written about the importance of keeping a focus on users when thinking about responsive Web design. I’ve also written about ways to think about responsive Web design in the context of doing interaction prototyping. I’ve personally had some experience designing responsive interfaces. I’ve spent time with my colleagues thinking about how to support responsive Web design in Indigo Studio, and I’ve talked to other designers about their experiences with RWD, including their experience with other tools.
Here’s the thing, so far, it seems to me that responsive Web design is a lie. It is snake oil. To be clear, I’m not saying that the actual technique of using CSS media queries to set breakpoints is a lie. That is a fact. You can do that. What I am saying is that what most people seem to take away from RWD after learning about it is this:
Hey lookie, I can design/code one thing instead of three (or more) and have it just work on all those things equally well.
That. That is a lie. It’s a pipe dream. You’re smoking something. It’s just not that simple. It’s not that simple from a design perspective, nor is it that simple from a code/dev perspective, except in the rarest, simplest cases. Even if you can simply use media queries, it can get pretty convoluted pretty easily. Even something as conceptually simple as an image is troublesome in RWD.
The reality is that most folks, even big RWD advocates, usually advocate for more than media queries–like RESS–sometimes this is strictly to help with performance (especially on mobile), but it can also be to deal with complexities and/or to simply make the desired designs feasible.
And RWD is sneaky. You start out thinking, hey, I’ll just add this breakpoint, then I just move this here, this there, and so on. Then you realize, hey, that’s actually not that great for <the phone | the tablet | the desktop | the TV> and you change this little bit here, that little bit there, and before you know it, you’ve got this huge jumbled mess that actually makes it harder to improve and maintain than if, for instance, you had just created different, cleanly separated apps in the first place.
OR (even worse from a UX/Design perspective), you start making design concessions in order to keep the thing manageable from a technical perspective. Oh, it’s not that bad, really. Or you might think, if I do that better design, it’ll be hard to implement and hard to maintain, so we’ll stick with this half-ass solution–just for the sake of the principle of RWD. This is bad for prototyping and bad for design.
So let’s zoom out a bit. What are we actually trying to achieve? I’ve heard basically three goals:
- One URL. When you give people a URL (e.g., in an ad) or they find one (e.g., in something shared on social media), you don’t want to land them on a solution that was designed for the wrong device class. You don’t want to offer (normally) a “view this in our standard/full site” or vice versa. It should just work and just be optimized for their device class (see my article describing device classes).
- One set of code/design. Across device classes, there is a lot of stuff that can be shared. The benefits are less implementation time and when you update it in one, it is updated in others. The underlying benefit is simply that it is theoretically more feasible to target multiple device classes if you leverage this one-solution-for-all sharing.
- “Fluid” resizing. When orientation changes on a device or a browser window is resized, it fluidly rearranges.
RWD is promoted as the current/best solution to these. But the devil is in the details. Sure, it solves #1 hands down. But #2 is where things get hairy, as noted above. I would suggest that #3, in most cases, is really just not that important. If there were interactions in your solution that made resizing/changing orientation an integral activity, and you wanted that fluidity to enhance those interactions, maybe it is valuable. But in most cases, how fluidly it resizes is far less important than the fact that it does. Most people don’t sit there and resize just to observe the beauty of the fluidity of the layout system.
Where do we go from here, then?
One way forward is to keep holding onto the RWD dream and try to beat it into submission. Make it work, no matter how hairy things get. This is an ideological solution–you value the RWD pattern more than actually crafting solutions that are best for your users/business. The other reason to move ahead with RWD is that you are naive and believe that RWD will deliver everything it promises. In both cases, it’s not a great premise.
So should we be asking ourselves, are there better solutions to achieve these goals?
- There are no silver bullets. If you want a great experience for people on each device class, you have to design for each device class. This is work. It may or may not imply that you can leverage RWD as an implementation technique, but there is no free design here. If you want things to fluidly and intelligently reflow and rearrange, you have to define the rules for your context. And beyond very basic layouts/nav, you are going to need to reimagine how some things work depending on the device class–what works well from an interaction perspective on a phone is different from a tablet is different from a desktop is different from a TV is different from a kiosk is different from wearable devices… No tool, whether you hand-code RWD or use a WYSIWYG tool like Indigo can protect you from having to think about and design for these different device classes and their related contexts of use.
- The more complex your solution is (on one platform) the more complex it will be to make it work across platforms, and that complexity increase is non-linear, especially when you try to make one set of code work for all of them.
- What we have here is essentially another incarnation of separation of concerns. The same reasons you should keep your behavior separate from your structure separate from your styling are fundamentally the same reasons you don’t want to bunch up trying to serve multiple device classes in one solution.
So I think if we consider the problem from a view to separation of concerns, the solution is clearer.
One App, One Platform
One solution is of course the independent, per-platform app solution. Most people will agree, as a rule, that this is the best approach to maximally optimize the experience for each platform (much less device class). What will feel best on Windows Phone is an app that was designed for Windows Phone, and the same applies for the other major platforms.
This implies the least amount of reuse across platforms and the highest cost of implementation and maintenance. The problem is that this is not feasible for a very large segment of people who need to make software run on many devices.
One App, All Platforms
This is essentially the RWD solution. In theory, it sounds great. In reality, it’s a lot more complicated than it sounds and often can result in suboptimal experiences on each device class. Further, there are hidden design, implementation, and maintenance costs.
There’s also a lot of talk about “future proofing,” but that too is only a half truth. At a minimum, it presumes similar input/interaction modalities for new devices, which are almost certainly not going to be there in many cases. And if the new interaction modalities can be mapped to existing ones (think, for example, touch gestures to mouse/keyboard), it again could easily result in suboptimal experiences for these new device classes. So it may or may not work on new devices/interfaces–that’s the best we could claim. Hardly a compelling reason to adopt an approach.
One App, One Device Class
This is the path that seems most viable to me. The basic premise is both your designs and your implementations are cleanly separated across device classes (i.e., you have a phone solution, a tablet solution, a desktop solution, etc.). You can even map device classes together if they are close enough–you could have a tablet/desktop solution and a phone solution, or a desktop/TV solution. If the similarities are close enough/good enough, you can still make those trade-offs and combine classes, without (as with RWD) assume all in one.
- It is honest about the complexities involved, both from a design and (potentially) implementation perspective. It treats the experience with a particular device class as something that should be considered on its own.
- It makes it easiest to optimize for each class. Through separation of concerns, the design effort is cleaner and, even more so, the code is cleaner. You don’t have elements and their styles stomping on each other.
- It strikes a good balance between optimization and reusability. You don’t have to make an app per platform, nor do you have to contort your mind and code and (often) the experience to suit all possible interaction modalities and layouts in one solution.
- It is honestly future proofed. Probably the underlying technology will still be Web. And as new devices emerge, you can see if the device can be assigned to an existing class or not (based on more than simple width of viewport). If so, it’s simple enough to “turn it on” for that device and have it share an existing device class solution. If not, then at least you’re being honest about it and not serving up some half-baked solution for it. You can choose if the new device class is worth investing in a specialized solution. If it is, probably there will be multiple vendors with that class of device, so you still can target cross platform that way within the class.
- You can be more strategic about what is shared or not shared. Often your data services can be shared across most classes. Your content can be shared. Your styling, to an extent, can be shared. Even individual pieces of the UI can be shared. Plus, you can encapsulate what is shared more cleanly. Instead of starting from a base that makes everything shared by default (RWD), you select the things that make sense and share them. This makes the sharing and the per-device-class code cleaner.
- You can avoid improvement paralysis. If every change you make has to be simultaneously made to every device class, it makes you that much more hesitant to make changes–you have to be ready to deal with them all at once. This equally applies to changes that make sense for all device classes as well as optimizations that make sense for one device class. It doesn’t matter. When everything is mixed in together, you always have to worry about unintended consequences to everything that is sharing it. With a per-device-class approach, you can feel much more confident that your design changes are safe. You can tackle each class at a time, which is ironically more manageable than all at once, and you can make sure the change is optimized for that class.
- You can still achieve fluid resizing per device class (whether that is resizing windows or changing orientation), if you feel that’s important enough to invest in. If it is Web, you can still leverage its built-in reflowing capabilities and even use some RWD techniques.
- You can still manage URLs and loading the appropriate experience for a device class, in most cases. Again, if it is Web, there are plenty of techniques you could use based on user agent information and serving up the appropriate device class solution based on that, with a good default.
None of this means that RWD is never a solution (it could even still be part of the solution). The problem is that it has become the proverbial hammer that makes all apps look like a nail. People are assuming it is the way to approach both prototyping and implementation. The hype around it causes expectations to be very disproportionate to the reality–which ends up sending people down the wrong road and causing all sorts of unexpected pain for them. It ties them to that approach, which is like a spiral of doom that it is hard to break out of if you need to.
If all you have is a basic informational Web site with basic navigation, you can probably get away with just RWD without it being too painful. There may be enough things in its favor to warrant that approach. Even so, you risk writing checks that will bounce if, for instance, you think this means that all this responsiveness is “for free” or that it means you are future proofed. On the other hand, it seems to me that assuming a baseline of per-device-class designs and solutions, strategically sharing across them, is a much more realistic, honest, and optimal approach in most cases. What do you think?
If you’re looking to hire a competent UX professional, do not ask for “Experience with Adobe Tools” in your job description. Especially don’t ask for PhotoShop. Even visual designers are waking up to the fact that PhotoShop is not a good software UI design tool.
UX design is a distinct skill set from visual/graphic design. They are complementary, and some UX designers are competent visual designers while some visual designers are competent UX designers, but they are still distinct skills, much like development is distinct from design.
A UX designer should basically never use Photoshop. Illustrator is a decent hackable tool, but if you’re going to go that route, you might as well just use OmniGraffle. Still, all of these are basically just for static wireframing/UI comps, with varying levels of hackability to communicate interaction design intent. Adobe had an interesting UX design tool for a while–called “Flash Catalyst,” but they killed it, because they killed Flash (I deduce).
If you’re going to pick a software tool for interaction design, it should be one that is suited to exploring interactions, which implies interactivity, i.e., as a designer, I can say, “when a user does <insert name of user action here>, the app should do this…” At a super bare minimum, clicking should be supported, but seriously, what viable apps these days only support static, full-page/screen refresh navigation?? So then you get into needing to explore and express transitions and animations. I’m not talking about fancy dingbat silly animations. No, I’m talking about animations that help users understand and interact effectively with a given UI design.
At this point, the software tools that your average competent UX designer can grapple with get reduced. You can of course code prototypes, but that’s generally not the best idea. So you want a tool that allows a UX designer to explore and express user interactions and app responses to those interactions but doesn’t get them bogged down in code.
Now I am biased having worked extensively on it, but the only tool that really qualifies there is Indigo Studio. Sure, Axure is another alternative, but it is significantly more complex to use and tied to the details of the Web platform.
So if you’re going to ask for a software tool competency for a UX designer, pick one of these. But really, as long as a UX designer can effectively explore and communicate design ideas, it doesn’t matter what tool they use. If you are constraining them to specific tools, something is wrong with your process. What you need to look for is evidence of good designs–both designs and implementations, as well as evidence of design research and evidence of design evaluation. Ask about their process and techniques they use to discover the best designs. Just don’t ask for Adobe tool competency.
I originally was going to put a picture of my own navel here, but I just couldn’t bring myself to do that to ya. This pic is, according to wikipedia, the official representation of the human navel. So there you go. Okay, now look back over here.
Why a navel? Because I just stumbled upon yet another anti-skeuomorphic article by a designer. (Argh!) And if there was ever a fit of navel gazing in the design community, it is this one. The
funny sad thing is that even when we try to not gaze (as this fella is), we do it.
This article is so paradoxical. It says it is not anti-skeu, but the bulk of the article is critiquing just that. And in its critique of skeuomorphism, it makes the same mistakes it is critiquing. It dances around and even says some good things, but then falls into the same trap that those who use skeuomorphism as a way to show off do.
Great experiences are the sum of multiple factors. Any one thing being off can ruin the overall effect. Content and context, focus and environment: they’re inseparable and necessary parts of the whole experience.
Software experiences aren’t just software; they’re also about the device. Alan Kay was right: “People who are really serious about software should make their own hardware.” We can’t literally do that, but we can accept that the hardware is part of the user’s context when using our software. The two exist in symbiosis, to create the user’s context.
The first paragraph is spot on. The second one rapidly falls off the cliff. Hardware and software by no means “create the user’s context.” The user’s context is a function of many other things, such as physical environment, mental state, personal history/experiences, current desires, other people they are engaged with, time of day, and so on. But that’s not the real issue.
The real issue is there seems to be an underlying mentality here that is problematic, one that does lip service to the human experience with designed things while fetishizing the designed things themselves–in this case software (and/or hardware together). When the designer’s focus is still the object–the thing we are designing, whether that is software or something physical–then we still have a case of tail wagging.
When it comes to a question of tail wagging, it is no different to expend your designer expertise and effort to create a thing that is “true” to its medium than it is to expend that expertise and energy to create a thing that mimics something in a different medium. Both are subject to the same navel-gazing dangers because both are fundamentally focused on designing a thing according to some designer-appreciated principle. If in the past designers looked down on each other because a design wasn’t skeuomorphic, today they look down on each other if a design isn’t minimalist. You can just as easily show off how properly minimalist your design is as you can how skeu it is. In both cases, the focus is on things and designers’ pride in having designed those things.
Who bloody cares if a designed thing is “true” to its medium if the people it is designed for don’t like it or have a hard time engaging with it. It’s one thing to say that you want people to be immersed and not think about the thing, but then if you turn around and just talk about making the thing “true,” you’re still missing the point. People don’t want a chromeless photo browser–they want the experience of remembering what the photos call to mind. People don’t want a flat, clean calendar–they want to situate themselves in time and keep track of things in relation to it. People don’t really even want photos or calendars–the things–they are simply a means to an end.
“Content over chrome” is missing the mark. “Being true to your medium” is missing the mark. It’s all designer fetishes and fads. The only reason there is good in them is inasmuch as they, incidentally, cause the designer to better evoke the experiences that people want. You might say that’s the whole point of minimalism, but I say that 1) you can evoke those experiences with or without minimalism, 2) sometimes you can even do it better, and 3) why obscure the real goal with a goal focused on the things? It’s just as simple to ask yourself “does this chrome distract from the experience I intend to evoke for the people I am designing for in such and such a context?” as it is to ask “is this design ‘true’?” And the first question is actually more to the point and doesn’t put the focus on adhering to principles that may or may not incidentally answer the first question, which again, is really the question you should be asking.
If a design that looks like a paper book and imitates turning paper pages evokes an experience that people want–it is a good design. If it surprises and delights people, even better! Who effing cares if it is skeuomorphic or minimalist or whatever other fad, trend, or school of design it is? If that’s what you’re worried about, you’re doing it wrong.
As someone who is something of a freak in the Design community, maybe I find it easier to see it from an outsider’s perspective. One thing that I was surprised by was the tendency to embrace fads and trends. “That’s so 2004” is a valid criticism for many designers. One year big rounded jelly bean buttons are in. The next year straight edges with reflections are all the rage. Now “flat” is in and with that is “anti-skeu.” I get it; the need for novel stimulation is a built into the human psyche, as is group belonging and the desire to feel superior to others (i.e., to feel valuable).
Being fashionable is certainly a valid consideration to have–all other things being equal in terms of designing for people and their contexts, you might as well be fashionable to boot. But if you’re going to adopt minimalism, at least do it for the right reasons (i.e., not because it is fashionable to be anti-skeu), and don’t get so caught up in it that you lose sight of what really makes a design best–that it fits what the people you are designing for want and/or need.