Thanks to a sharp co-worker of mine, I was recently introduced to "Magic Ink: Information Software and the Graphical Interface," by Bret Victor. It was quite an interesting read; Victor makes a lot of good points. For instance, he suggests that we should view information software as graphic design, i.e., taking the concerns of traditional graphic design as paramount and then taking it to the next level by availing ourselves of context-sensitivity, which he defines as inferring the context from the environment, history, and, as a last resort, interaction.
The thrust of the argument is around reducing interaction and making software smarter, i.e., more context aware and, eventually, able to learn through abstractions over learning algorithms. I think we can all agree with this emphasis, but I do think he unnecessarily latches onto the term "interaction" as a bad thing, or rather, I think he presents "interaction design" in an overly-negative light.
True, the smarter we can make computers (and consequently require less interaction from users) the better, but that doesn't negate the usefulness of interaction design, human factors, information architecture, and usability. There are many, valuable things to be learned and used in all of these interaction-oriented fields, and we shouldn't deride or dismiss them because they focus on interaction. I felt that Victor's negative emphasis on this and his speculating that why software sucks in relation to this took away from the value of his overall message.
The Problem of Privacy
There is one problem that I don't think he addressed in terms of increasing environmental context awareness, and that is security, specifically, privacy. It is tempting to think about how wonderful it would be for a computer to know more about our environment than us and thus be able to anticipate our needs and desires, but in order to do this, we, as humans, will have to sacrifice some level of privacy. Do we really want a totally connected computer to know precisely where we are all the time? Do we really want it to be "reporting" this all the time by querying location aware services? Do we really want a computer to remember everything that we've done--where we've been, who we've interacted with, when we did things?
I think the trickier issues with context awareness have to do with questions like these. How do we enable applications to interact with each other on our behalf, requiring minimal interaction from us, while maintaining our privacy? How does an application know when it is okay to share X data about us with another application? Do we risk actually increasing the level of interaction (or at least just changing what we're interacting about) in order to enable this context sensitivity?
If we're not careful, we could end up with a Minority Report world. People complain about cookies and wire taps, the world of computer context-sensitivity will increase privacy concerns by orders of magnitudes. This is not to negate the importance of striving towards greater context sensitivity. It is a good goal; we just need to be careful how we get there.
Towards Graphic Design
One of the most effective points he made was in illustrating the difference between search results as an index and search results as a tool for evaluation itself, i.e., thinking about lists of information in terms of providing sufficient information for a comparative level of decision making. It is a shift in how developers can (and should) think about search results (and lists in general).
Similarly, his example of the subway schedule and comparing it to other scheduling applications is a critical point. It illustrates the value of thinking in terms of what the user wants and needs instead of in terms of what the application needs, and it ties in the value of creating contextually meaningful visualizations. He references and recommends Edward Tufte, and you can see a lot of Tufte in his message (both in the importance of good visualizations and the bemoaning of the current state of software). I agree that too often we developers are so focused on "reuse" that we fail miserably in truly understanding the problems we are trying to solve, particularly in the UI.
That's one interesting observation I've had the chance to make in working a lot with graphic/visual designers. They want to design each screen in an application as if it were a static canvas so that they can make everything look and feel just right. It makes sense from a design and visual perspective, but developers are basically the opposite--they want to find the one solution that fits all of their UI problems. If you give a developer a nicely styled screen, he'll reuse that same style in the entire application. In doing so, developers accidentally stumble on an important design and usability concept (that of consistency), but developers do it because they are reusing the design for maximum efficiency, not because they're consciously concerned about UI consistency! It is a kind of impedance mismatch between the way a designer views an application UI and the way a developer does.
The Timeless Way
I'm currently reading Christopher Alexander's The Timeless Way of Building, which I hope to comment on in more depth when done. But this discussion brings me back to it. In fact, it brings me back to Notes on the Synthesis of Form as well, which is an earlier work by him. One of the underlying currents in both is designing a form (solution, if you will) that best fits the problem and environment (context). The timeless way (and patterns and pattern language, especially) is all about building things that are alive, that flow and thrive and fit their context, and the way you do that is not by slapping together one-size-fits-all solutions (i.e., reusing implementations) but in discovering the patterns in the problem space and applying patterns from the solution space that fit the problem space just so. The reuse is in the patterns, at the conceptual level, but the implementation of the pattern must always be customized to fit snugly the problem.
This applies in the UI as well as other areas of design, and that's the underlying current behind both Tufte's and Victor's arguments for the intelligent use of graphic design and visualization to convey information. You must start by considering each problem in its context, learn as much as you can about the problem and context, then find patterns that fit and implement them for the problem in the way that makes the most sense for the problem. But more on the timeless way later.
A Good Read
Overall, the paper is a good, thought-provoking read. I'd recommend it to pretty much any software artisan as a starting point for thinking about these issues. It's more valuable knowledge that you can put in your hat and use when designing your next software project.
The opinions expressed herein are solely my own personal opinions, founded or unfounded, rational or not, and you can quote me on that.
Thanks to the good folks at dasBlog!
Copyright © 2015 J. Ambrose Little