Many of us have a little time off at this time of year. Here are two books that are worthwhile and not too hard to read. Take some time to read about embodied interaction, and COM+.
Where the Action Is -- The Foundations of Embodied Interaction by Paul Dourish (MIT, Cambridge MA, 2001, 245pp, mitpress.mit.edu, ISBN 0-262-04196-0, $35.00)
There is a broad consensus that computer-based tools are hard to use. Many people believe that the problem lies in the way we design and build these tools. Recently I have reviewed quite a number of books that address that issue.
In The Humane Interface (Micro Review, May/June 2000), Jef Raskin takes a user-centered approach, loosely based on ideas that cognitive psychologist Bernard J. Baars discusses in his book A Cognitive Theory of Consciousness (Cambridge, 1988).
In The Inmates are Running the Asylum (Micro Review, Sept/Oct 2000), Alan Cooper makes the business case for taking interface design out of the hands of programmers. Cooper wants us to base our designs on intimate knowledge of the target users and their jobs.
In the Social Life of Information (Micro Review, Jan/Feb 2001), John Seely Brown and Paul Duguid ask us to stop looking at every human activity as a form of information processing. They show how ignorance of the social context of human activities often leads to failed attempts to automate those activities. In the same issue of Micro Review I look at Contextual Design by Hugh Beyer and Karen Holtzblatt. That book describes elaborate procedures for understanding and using the social context that Brown and Duguid talk about.
Paul Dourish approaches the same issues as these other authors, but from a somewhat different point of view. He uses the term embodied interaction to tie together several threads: tangible computing, social computing, and the philosophical tradition of phenomenology.
Tangible computing makes computer mediated interactions more natural by imbuing common objects with digital capabilities. For example, a telephone answering machine uses a row of marbles to represent your waiting messages. You place a marble into a receptacle to hear the message, then put it either into the save bin or the recycle bin. The power of tangible computing is that it takes icons to a higher level by giving symbolic meaning to actual physical entities.
Social computing tries to understand the social context of the tasks you plan to automate. The trick here is to see the orderly social conduct emerge from the seemingly chaotic details, yet not overlook the hidden lubrication that makes the machine run. Using techniques like those that Beyer and Holtzblatt discuss, you identify the lubrication and thus avoid the disasters that Brown and Duguid talk about. One idea that arises out of social computing is coupling. Coupling is establishing and maintaining the relationship between action and meaning. For example, when you move the mouse, you might be positioning the cursor to insert text into a document, but you might also be bringing it back to the center of the mouse pad, or you might even be clearing space to set papers next to your keyboard.
Phenomenology isn't new, but it's a lot newer than the Cartesian philosophy that underlies many current approaches to interface design. Unlike Descartes, the phenomenologists do not separate mind and body. Meaning, for the phenomenologists, arises from our interactions with the world. The idea of an affordance, prominent in Donald Norman's writings on usability, comes from the phenomenologist J. J. Gibson. An affordance (a doorway, for example) makes its use obvious through its form.
These three threads underlie embodied interaction. We exist in the physical world. We exist in a social context. We derive and create meaning by our interactions with these environments.
This all seems pretty theoretical, and you may be inclined to contrast it unfavorably with the precision and clarity of modern software design and construction. Dourish anticipates this reaction and turns it on its head. He sees current software design methods as abstract and theoretical, because they model users and interactions without first observing them. These methods, in his view, rely on disembodied cognition. The methods he advocates require you to become directly involved with the specifics of the actual practices for which you intend to provide computer based support.
Because his methods depend so much on the different details of different situations, he feels he cannot reduce them to rules or guidelines. Instead, he lays out the following design principles:
- Computation is a medium.
- Meaning arises on multiple levels.
- Users, not designers, create and communicate meaning.
- Users, not designers, manage coupling.
- Embodied technologies participate in the worlds they represent.
- Embodied interaction turns action into meaning.
Because these design principles require a design context to make examples comprehensible, Dourish applies them to an issue that most readers are likely to be familiar with: the debate between convergence and information appliances.
Convergence is the idea that a single computer will handle spreadsheets, word processing, email, phone, fax, TV, movies, news, and any other communication or content delivery applications you might think of. An information appliance is a specialized computer-based device (a microwave oven, for example) that is simple to use because it doesn't have to do everything. Are these both the future of computing, or do they conflict?
When Dourish views this debate from the viewpoint of embodied interaction, he sees each of these alternatives as a technological solution, a way that designers try to manage or overcome the barriers and boundaries between applications. Users, on the other hand might be more interested in separating their personal from their work information, but not in separating writing a document from sending it. Dourish's design principles call for making users, not designers, the arbiters of where to place the boundaries.
This book is important reading for anyone engaged in designing computer-based systems to support human activities. It is full of interesting ideas and insights. I recommend it.
COM and .Net Component Services by Juval Löwy (O'Reilly, Sebastopol CA, 2001, 362pp, www.oreilly.com, ISBN 0-596-00103-7, $39.95)
COM is the acronym for Microsoft's component object model. This book, despite its title, is not about COM or Microsoft's new platform, .NET. It's about COM+. This requires a little explanation, and who better to provide that explanation than Roger Sessions.
More than three years ago, I reviewed Roger Sessions' interesting book COM and DCOM -- Microsoft's Vision for Distributed Objects (Micro Review, Mar/Apr 1998). As Sessions explains there, Microsoft has a coherent strategy for distributed applications. This strategy leads to architectures somewhere between Windows-specific clients on a Windows-specific network and generic browsers on a generic intranet.
When Sessions was first studying COM, he was intrigued to discover an early version of Microsoft transaction server (MTS). MTS, as Sessions points out, has little to do with transactions. Instead, it definitively solves the problem of how to share resources among clients in a client/server environment in a way that scales easily to large numbers of low-volume clients. According to Sessions, every current solution to this problem follows the principles of MTS. The Sun Enterprise JavaBeans framework, for example, is almost identical to MTS.
This brings us to COM+, and the point of this lengthy explanation. COM+ is MTS. That is, when Microsoft brought out its new version of MTS, they renamed it COM+. It provides the component services for COM and for Microsoft's new platform, .NET. This, finally, explains the book's title. The rest of the book is easy to explain.
Löwy follows two threads more or less in parallel through the book. The first thread is a thorough discussion of each component service -- what problem it solves, how it solves it, and what to be aware of when you use it. The second thread is a step-by-step explanation of how to use each service, with realistic code examples. Both threads are useful, but I especially like the thorough discussions, because Löwy understands the material and explains it clearly.
The chapter on queued components is a good example of this pattern. Many designers know the benefits in system robustness and improved performance of calling some object methods asynchronously, that is, of having the method return control to the caller before completing the requested operation. Löwy reviews the benefits, discusses the ad hoc pre-COM+ solutions and the problems they cause, then describes the COM+ solution, which uses MSMQ (the Microsoft message queue) and queued components. He sketches the implementation architecture, so you have a good idea of how the system handles the asynchronous calls and what the performance consequences of using them are. From there he goes on to explain how to design, code, and manage queued components. He even includes a substantial section on pitfalls.
Löwy's appendixes provide additional useful material. One appendix provides motivation and documentation for a component you can download from the book's website. The component logs calls, providing a useful debugging tool.
Another appendix describes COM+ 1.5, a version that appeared as Löwy was finishing the book. Keeping this material separate is a good solution to this potentially troublesome problem. Probably the material will migrate into the body of the next edition of the book.
The book also treats the way that COM+ provides component services for .NET. The book does not cover .NET (or COM, for that matter). An appendix provides a primer on .NET for the uninitiated, though it's hard to see why the uninitiated would be reading about component services for .NET.
This is a good book about an important technology that promises to be central to systems development in Microsoft environments for a long time to come. If you don't already know this material, this is a good way to find out about it.