In Class Group Brainstorming
From CS160 User Interfaces Sp09
Class on Feb 4, 2009
No Slides
Readings
- Direct Manipulation Interfaces. User Centered System Design. Chap 5. Hutchins, Hollan & Norman.
Discussion
- While this is a dense reading, it is a seminal paper in HCI. Figure 6 is especially important. It is worth thinking about semantic and articulatory distances and how they differ for the gulf of execution versus the gulf of evaluation.
Denise Ngai - Feb 03, 2009 05:43:37 pm
An important aspect to consider in this reading is the analysis of the gulf of execution and the gulf of evaluation. The primary part of the gulf of execution is the intention of the user. I like how the readings explains the importance of achieving articulatory similarity between the intention and the action for that intention on the input side. For execution purposes, it is common for the action taken to mimick the user's intention. The example given in the reading describes how moving a cursor on the screen is achieved by moving a mouse similarly as you would movethe cursor. This made me consider all the other features of a program's interface. Clicking a button on the screen is achieved similarly by clicking a button on the mouse (which is physically in hand). Highlighting a line in a word document is also done similarly with the click of the mouse button and a highlighting motion over the text. From these points, it is clear that actions that mimick the intention are important, especially because we are comfortable with associating such movements to those intentions. Post-execution, the gulf of evaluation ensures that the output of the execution is the user's goal -- what the user had intended to do.
Sean Hansen - Feb 03, 2009 05:48:41 pm
First off, I just gotta say that it's always neat to find something new being analyzed scientifically. I just love trying to find ways to talk about a new subject and finding out that someone has already put in the good work to make talking about it objectively possible.
Being someone who was trouble with his enunciation, the problem of articulatory distance interests me. Would decreasing the gulf of execution in natural language increase my ability to articulate myself? I mean, if the sounds I used to express myself were less complex, would I get an increase not only in clarity, but also in meaning? The contents of the article suggest as much. When faced with an interface that feels less distant, users are better able to implement the solution they have in their head. Based on the section about how repeated use makes an interface feel less distant and how I've been speaking English all my life, you'd think that I wouldn't have anything to gain from a simpler language, but I still wonder.
Saung Li - Feb 03, 2009 06:14:48 pm
In regards to semantic distance, the user should be able to easily say what he wants in the interface language. An example of a large gulf of execution would be a user having to program everything bit by bit, an incredibly complex task that is put on the user. Likewise, the gulf of evaluation would be large if the user would have to read output completely generated in binary. Articulatory distance, on the other hand, focuses on the physical form of expressions. A great way to reduce of the gulf of execution is to turn our monitors into touchscreen so we could directly work with the content on the screen. Tools like graphical displays can help reduce the gulf of evaluation by visualizing the data and making the user feel like he is working directly with the data. Instant feedback is a must so that the user can continue his chain of thought and immediately change things as necessary. I believe that giving examples like these can help readers to understand these concepts more. Can anyone think of some more? It seems that there are many trade-offs to increasing directness, such as the lack of generality and possibilities for new ideas. However, there should be many current programs that could probably be changed dramatically to increase directness without having many negative consequences. What are some of them?
It is very interesting how the reading related to natural languages, and how their vocabulary can influence a culture into thinking that some things are more important that others. This helps me to understand how programming languages work and why we need so many of them. Some tasks are more easily done or more efficient than others amongst the different languages.
Rohan Dhaimade - Feb 03, 2009 06:47:03 pm
The gulf of execution is the gulf that exists between the user and the programs actions. The gulf of evaluation is the amount of processing required for the user to achieve his/her goal. A semantic goal of briding the gulf of execution can be easily achieved by providing some type of interface that allows them to help achieve their goal by simulating the process they would naturally do it in. The articulatory way to bridge the gap though requires them to do physical actions that are simulated on the screen. This is not necessarily always the best thing to do because there are some items that are bad to physically simulate (like repetitive tasks). One point that is interesting though is that the gulf of evaluation is dependent on the gulf of execution. If you cannot complete basic tasks and interface properly, how would you be able to achieve your goal well? The author also pointed out that the physical limitations of hardware are the currently main hindering to the direction manipulation paradigm of UI, but that has significantly changed with the introduction of multitouch cellphones and computers. Windows 7, the next generation of the Windows OS, has many multitouch features. The multitouch paradigm is going to use this new direct interaction paradigms much more than a mouse/keyboard have ever done.
Chunwei Lai - Feb 03, 2009 07:17:41 pm
The gulf of execution focuses on the intention of the user. If the user performs certain actions, there are certain expectations that the users will expect the system to respond with. The gulf of evaluation has to do with how much "processing" the user has to perform in order to determine if the goal has been achieved. The mentioned "water tank" example provides an excellent example on whether the user has to observe the current value over time to determine the rate. Raw output is typically too tedious to use by users though in certain situations they can be useful for the users. If the raw output is formatted/grouped/summarized/etc then they can be quickly used without much processing or transformation by the user. Execution and evaluation are ways the users interact with the goal through inputs and outputs of the system.
Shoeb Omar - Feb 02, 2009 10:46:02 pm
This article was pretty tough to grasp for me because of all the different terms used; however it was not a gross invention of terms to over-complicate matters but a necessary use of new ideas to communicate interesting observations about the way we interact with computers. I think there was many interesting points raised. For example I thought it was interesting how they talked about a conversation vs an object world. We work in an object world whereby we drag windows around and almost physically manipulate what's on our screen to do what we need. Yet we still have important 'conversation' mechanisms in place--think Google. Beyond this, I found it extremely interesting when they talked of the difference between the output interface language and the input interface language. They described them as two dialects and I think both the gulf of execution and the gulf of evaluation are artifacts of this fact. Whereas the gulf of execution is generally not all that difficult to minimize, I believe the gulf of evaluation is the entire reason we have classes like this one. The articulatory distance can be the same on both the evaluation and execution state for a user, but can feel vastly greater in evaluation. I'll try and elucidate this idea with an example. If someone is confused about how to make the computer do something, they can physically hit buttons, type in commands, and try different approaches out until *something* works. They can, in essence, employ trial and error to minimize the gulf of execution. Once this gulf has been overcome, they can practice continually and automate how to do a certain task (think the vi user who types dw to delete a word). This luxury of being able to have trial and error isn't possible by the computer itself. How it portrays feedback to the user isn't adaptable to different situations or users. It simply shows feedback how it was told to show feedback. Thus, whereas the gulf of evaluation can be minimized by the intellect of the user, the gulf of evaluation cannot. This is a huge reason why UI is SO important.
Alan Young - Feb 03, 2009 09:09:27 pm
Even though the paper was dense, I felt that a lot of the points were well made and had especially helpful analogies and examples. The comparison and contrast between the piano and violin was well described in explaining semantic distances. Having finished the CS61 series, I can now also appreciate another aspect of the differences between Scheme and C and MIPS assembly languages. I feel that even though the gulf of execution and the gulf of evaluation are both comprised of the semantic and articulatory distances, I personally tend to want to have an easier time in getting something done (executed), rather than evaluated. Also, I feel that the semantic distances are more of a challenge for users to overcome than articulatory distances. This is particularly true in most cases of my life, such as when I learned new languages or programming languages. Articulatory distances was like the concepts such as data structures while semantic distances was about writing the specific code in a language and for me, that entailed the somewhat cumbersome process of learning a language's syntax and looking up what library functions exist and so forth. This also applies to learning different musical instruments because even though someone may be well versed in music theory, he/she still has to learn the specifics for a specific instrument in order to output the notes desired.
Nalditya Kusuma - Feb 03, 2009 10:41:40 pm
I could not believe that there are actually lots of works have been done in user interface; the reading shows a bunch of elements associated with it and how the author uses them in order to produce a user-friendly interfaces. There are lots of terms that are similar and confusing at the same time for me such as Semantic & Articulatory Distance, Gulf of Execution and Evaluation, etc. Anyhow, the reading points out several difficulties in making a direct manipulation interface; covering issues about Distance and Engagement, and how they effects the successfulness of the interface. One point that is similar to previous readings is: The more features are available in the interface, the more difficult it is to build a direct-manipulation interfaces because it raises the distance between user intentions' and the goals to achieve. The reading also raises a point that a good interface should engage users throughout its execution and provides easy output for users to know what's going on (feedback) without making them doing additional mental thinking (water level control figure 5).
Yin-Zen "Johnny" Hwang - Feb 03, 2009 10:49:20 pm
Just wanna say: No! I hate direct manipulation for in-depth programming! It's the fugliest way to program ever. E.G.: Having modules and wires that connect them: Try designing something that has thousands of elements. You either have to encapsulate items in a way that is inefficient and takes 100 clicks to see how it's really done, or the wires are all cluttered and lying everywhere. Plus, understanding order of operation is a total mess as it could either depend on the order of instantiation, which can be lost after dragging stuff around, it can depend on where the stuff is organized, which can easily lead to clutter with many elements, etc. One final word about direct manipulation: Logisim. 'Nuff said.
E.G.: Website builders. Some of those are so hard to use and produce really ugly results. I prefer to go dig around in code to produce much better interfaces.
Direct manipulation only seem to work really well for designing things that are very, very, very modular. For example, when building custom levels, terrain design is best done using direct manipulation. But that's about it. GUI triggers just phail so badly it's not even funny, mainly because triggers need to be customized at a lower abstraction level because they are not as modular as terrain.
Something else I dislike about DM is the overuse of a mouse. Of course, that's partly due to the fact that I lack a USB mouse, every system has a different set of keyboard shortcuts, and even memorizing most of them doesn't decrease the use of a mouse by too much.
With that said, DM is probably the way people consume software. It's really annoying to interact with a console, and DM makes that interaction much more natural. But I guess that's the difference. DM is an interface for the people, while it is not a good interface for the programmers.
Cuong Ngo - Feb 03, 2009 11:30:55 pm
Reading the article reminds me of the fact that many of today's systems utilize direct manipulation interfaces. A good example is the iPhone. Apple didn't invent touch-based interface but they were the first willing to innovate it. The iPhone interface has all the virtues Shneiderman suggested. The gesture is so simple that "novices can learn basic functionality quickly." For instance, pinching is all it takes to zoom in pictures. Professional users "can work extremely rapidly to carry out a wide range of tasks, even defining new functions and features." They can easily customize the home screen according to their preferences. Last but not least, iPhone users "can see immediately if their actions are furthering their goals, and if not, they can simply change the direction of their activity." The back button on every screen does just that. Likewise, the dot navigation bar on the home screen shows the user where he or she is. In general, users can directly manipulate the interface to reach their goals.
Chang Su - Feb 03, 2009 08:36:54 pm
Very simply put, the "Gulf of Execution" is the level of difficulty with which the user could translate his/her intention to the correct command or series of commands, while the "Gulf of Evaluation" is the level of difficulty with which the user is able to comprehend the output or feedback from the interface regarding the result of his/her input. These can each be further divided into "Semantic Distance" -- how hard it is to formulate and evaluate the meaning of an expression, and "Articulatory Distance" -- how hard it is to translate the form of an expression to its meaning and vice versa.
In my opinion, to cross either "gulfs" is really to have the user and the system come to a union on some middleground. The user has to do most of the work in terms of the semantic distance, where there is little that the interface could provide, whereas a well-designed interface shortens the articulatory distance and makes the meaning of a relevant expression both easier to execute and more accessible to the user.
An excellent example of direct manipulation that comes to mind is Adobe Photoshop. The entire interface almost completely mimics a physical canvas with various artistic tools reflecting their real-life counterparts. As a result, there is almost no articulatory distance. The wild possibility of everything a user could perform in photoshop lies entirely within his/her ability to traverse the semantic distance, i.e. translate his/her intention into expression.
Carol Chen - Feb 03, 2009 11:43:41 pm
This reading could have used more concrete examples, given the unnecessary denseness, especially when the authors introduced the the concepts of distance and directness, or the gulfs of execution and evaluation. It would've been useful to see an example of when it's necessary to choose an arbitrary relationship of form to meaning. Also, I could swear the authors make directly contradicting statements at the beginning (p 6) and end (p 27) of the paper, regarding programming languages. On page 6 they say programming by composing text instructions may become obsolete. On page 27 they state that conventional languages are here to stay.
Barring that, I did get some interesting insights out of the paper. The correlation made in the beginning between a feeling of directness using an interface and this feeling being due to the requirement to commit fewer cognitive resources was useful, as was the understanding that articulatory directness is very dependent on the available I/O technology. The point was made several times that often there is a tradeoff between whether to have the user or the system do the (translation, intermediary) work. And finally it was interesting to think about how direct manipulation is not the magic solution, because 1) such interfaces require fine user precision, and 2) they support how we tend to think about a domain and are thus limiting if we use that mindset. The authors also brings the reader back to reality by reminding him or her that some interfaces appear to be immediately engaging but in actuality work clumsily, interfere too much, or demand too much of the user.
Kevin Huey - Feb 04, 2009 12:04:32 am
From what I understand, there is an important decision as to how much work is done in each level. There are two choices: force the system to churn everything out (low-level), or let the user do it (high-level). If we let the system do everything, then the user won't have much control to the outcome, and may dislike it. Let the user do everything, and he/she may get frustrated from going through X amount of steps before accomplishing even a trivial thing. So eventually there must be a happy medium so that the system doesn't do everything, but the user doesn't have to do so much that the user starts getting confused. So the question really is: how much is too much? What do we expect the user to be able to do, and how much would he/she remember? Would it be convenient, or even too convenient? Which method will help reach the user's goals in the simplest fashion?
Stephanie Shih - Feb 04, 2009 12:12:05 am
The reading put too much stock into going into the distance between interface and the actual world but not enough into giving concrete examples. It made the reading difficult to follow at times, especially with its verbosity.
That aside though, because semantic distance is about mental translation, for the gulf of evaluation it means trying to relate the actions of a program in a format the user is familiar with, while for the gulf of execution it goes in the other direction - from the user trying to get the program to understand what sie wants to do. Is it possible to translate? However, in the case of articulatory distance, it becomes a matter of physical translation - the mental translation may be possible but can it be physically functional, from the user to the program (in the case of the gulf of execution) or vice versa (gulf of evaluation)?
Mark Dhillon - Feb 04, 2009 12:21:16 am
I found the point about Direct Engagement very interesting. First off, I agree that when the user has a sense of manipulating real world objects rather than through some intermediary then interactions can approach a seamless nature. I was surprised by the author's statement about how we believe this to be of critical importance, but that we don't really know how to achieve it. Then I saw the date on the paper haha. I was reminded of the lecture on Monday morning where we saw how adding another layer to a plain rectangle can give a "button look" to something that would normally seem plain. I think that HCI designers have come a long way to making this Direct Engagement much more of a reality.
Ian Hildreth - Feb 04, 2009 12:36:02 am
Reading this article reminded me of all the games that I've interacted with that have involved direct manipulation in some form or way. Things like etch a sketch early on required some awkward, yet engaging direct manipulation, but gave the sense of actually manipulating the object with your hands. Even modern games try to incorporate direct manipulation, such as the wii, which is revolutionizing games with the use of a remote and pad. I also liked the concepts of the gulf of evaluation and the gulf of execution, because it is a good reminder that interface has multiple levels, all of which are important to consider. One level the gulf of execution is what the user perceives as to be the actual design structure for the game, and at the same time the gulf of evaluation is how the user interprets his actions on the system. On the whole though this article was very dense and tough to read.
Sean Kim - Feb 04, 2009 12:39:00 am
For communicating between a machine and users, we need to use a kind of language; interface language. By Hutchins, Hollan, and Norman, for explaining the interface language, meaning and form of expression is stressed to connect user's goal to a machine. Input/output expression, which machine can display to users, can have different type of forms with just our language. So it has a form to be interpreted and was made for an intention with a meaning. A semantic distance is used to measure how the goal, user’s intention, is different from the meaning of the interface. An articulatory distance tells us how the meaning of the interface is far from the form of it. By the terms of this paper, execution is a process from user to machine and evaluation is from machine to user. Therefore, during these processes, semantic and articulatory distance are mainly dependant on how user’s intention is specified to a action(execution) and how the form is interpretated(evaluation).
Derek Liu - Feb 04, 2009 01:02:19 am
The article points out the key factors that make an interface accessible to a wide range of people. Since the article did not provide too many examples of direct manipulation, it made me think about various video game interfaces that fall under the category of having a direct manipulation interface. From the dawn of console video games or even arcade games, the interfaces have been with some sort of game pad or joy stick with buttons all falling under the categories listed on page 315 to some degree. Beyond video games other examples would include operating systems using a pointer to indicate the mouse location, or windows to show various forms of data within the system.
The distinction made between low level and high level things made in an earlier post becomes more distinct with this definition of direct manipulation interfaces. With the key attributes of direct manipulation interfaces listed in the article, we can see that many of the programming languages that we all work with do not fall under this category.
In short, direct manipulation interfaces cater more to normal every day people as found in Mac OSX or Windows, or even Wii and XBox.
Jeffrey Patzer - Feb 04, 2009 01:23:12 am
After reading this piece I realize that most programs now try to use Direct Manipulation Interfaces. Most programs accomplish this task fairly well. However, after reading about what these direct interfaces offer I got to thinking that there is also a lot they don't offer. For a quick and easy mapping of tools, icons work great. However, once one gets past the basic uses of a tool, one begins to want the customization that goes beyond what a single icon offers. This customization that one seeks usually also provides more speed for the action as well. As a user of photoshop I will cite an example from there. When one is beginning to use this extremely complex program, one tends to use the palate that hovers on the side of the screen. Each of these tools offer many different functions however and switching between those functions can be slow and cumbersome with a mouse. For instance, when using the zoom option, one can switch between zoom in/out by holding control. This saves a good deal of time between switching back and forth between the two by selecting that option at the top of the screen. So while the icon is great initially, after a while advanced users tend to use keyboard shortcuts more than anything. So direct management for the beginning/medium user is great, but until the programs are higher level the use of the keyboard will still be the fastest manipulator of information and tools.
Colin Downs-Razouk - Feb 04, 2009 01:52:07 am
I thought the discussion of direct manipulation was interesting from the viewpoint of a computer scientist, who often uses interfaces that are purely symbolic. Being able to directly manipulate things as you would physically is in some ways less appealing than code. The best example of this that I have is your regular Unix terminal. Sometimes you want to rename a bunch of things, or do some other repetitive task, in which case doing it physically is not the best idea. But the article does address this, but it was difficult to get to (it was at the end, and the article was "dense".) I think the best interfaces have options to directly manipulate and symbolically manipulate things, and the user can choose his own way of doing things.
Timofey Titov - Feb 04, 2009 01:54:56 am
It is surprising and ironic to see how certain breakthrough things were invented a long time ago, but have not gained traction until a long time afterwards. This applies to OOP and Direct Manipulation Interfaces. The article talks about "higher-level languages" with respect to interfaces in general, and OOP would be a subset of such a general notion. Sketchpad was one of the early examples of DMI and it is noteworthy to mention that it was arguably the very first system written in object-oriented manner. (Alan Kay credits Ivan Sutherland for the invention of OOP.) Another aspect of the article that I found surprising is that a user has to cross articulatory distance first. However, it seems that humans are always just in "semantic land", where they think in higher-order abstractions.
David Burban - Feb 04, 2009 01:51:23 am
This article suffers from a lack of concrete examples that we can relate to since it was written before many of us were born. Written in 1985, the first graphical user interfaces were at their infancy, with the Apple release of the first Macintosh.
Direct Manipulation of data is a key concept from this article. Most of our day-to-day interactions with computers involves some sort of Direct Manipulation, whether we are editing a file using VIM, or reading a web page. Game also use direct manipulation, where for instance if you click on an opponent in Unreal Tournament, the gun you are holding fires at that spot. Without direct manipulation, it would be difficult to edit files, and just imagine typing in the coordinates of the opponent to shoot at!
Matthew Can - Feb 04, 2009 01:38:30 am
This reading was quite conceptual, and I enjoyed it. It's easy to see why it is so important in HCI, and I can only imagine the impact it made when it was written. Central to the paper was the notion of distance between the user's intentions and the language of the interface. So much of what designers do is bringing the interface closer to the human by building upon it with layers of abstraction. In fact, I think this sums what computer science is. It's nice to see that we have made significant progress in both semantic distance and articulatory distance since the paper was written. In the case of semantic distance, take the example of Ruby on Rails where you do not need to know much about how databases work to use one in your web application. The Wii and the iPhone illustrate how advances in the technology of input devices have shortened the articulatory distance. The effect of all of this is to produce higher levels of engagement and direct manipulation interfaces. Just think of the process of moving around and zooming into a photo on the iPhone; the user forgets the phone's touchscreen is even there. As designers, our job should be to think of ways that we can apply these new (or at least commercially viable) technologies to old interfaces. We'll bring machines one step closer to people, reduce the distance, and hopefully improve the quality life in the process.
Sean Ahrens - Feb 04, 2009 02:17:54 am
While admittedly dense, this paper was interesting for what I got out of it. First, let me point out my recognition that this paper is about 20 years old -- it was very helpful to put it in the context of the computing interfaces available at the time it was written. It seems like almost all the work that the average computer-user does nowadays is what the article would call "direct manipulation". I suppose using the file/edit/view/etc. menus is one exception -- as is using the command prompt (but your average user doesn't venture there).
A few pages in to the paper, I thought I could pretty solidly translate the author's term "Direct" to mean "Intuitive" -- but after reading further, I realized that an interface can be "intuitive" and not "direct" if the users are deeply familiar with the provided "indirect" style of doing something. An example will clarify. "File | Save" is not "direct" (as described in the paper), but I imagine due to familiarity with this interface style, most modern users would call it "intuitive" (the method to fulfill the desired action of saving is where they expect it).
Dwijgarg - Feb 04, 2009 02:23:09 am
I really thought that the discussion of the gulf of execution and the gulf of evaluation was very interesting. The article states that the gulf of execution is related to the user and the program itself. It is the schism that exists between the two and should effectively be eliminated for a seamless user interface. A great current example that has almost closed this gap is touch screens. For instance, on the iPhone, users do not have to fiddle with the mediocrity of buttons. Instead, all they do is touch whatever they want to use. On the other hand, the gulf of evaluation is the distance between the user and what is physically presented to him/her. Again, today's technology is increasingly bridging this gap by introducing better, efficient, and more user friendly interfaces that are easy to use and learn. From an overall stand point, I think that by eventually eliminating these gaps, the industry can definitely create a better user experience and interface for all products.
Shendy Kurnia - Feb 04, 2009 02:51:50 am
Answering the discussion question, I think the description of Figure 6 says it quite well. Intention spans semantic distance in the gulf of execution. The intention specifies the meaning of the input expression that satisfies the user's goal. Action specification spans articulatory distance in the gulf of execution. Interpretation spans articulatory distance in the gulf of evaluation, and evaluation spans semantic distance in the gulf of evaluation. Hence, the distance between the gulf of execution and the gulf of evaluation is the articulatory distance and semantic distance on both gulfs.
Chao Michael Zhang - Feb 04, 2009 02:52:54 am
It was interesting to think about the numerous properties needed for users of a specific interface to achieve a feeling of direct engagement. The fact that the speed of feedback is so crucial to the direct engagement feeling is very true even in something as commonplace as reading this reading in adobe reader. My computer isn't fast enough (or doesn't have enough memory) to scroll the page smoothly immediately as I scroll it with my mouse wheel, so the response doesn't correspond very well to my intended scrolling. This really breaks the sense of direct engagement, and causes reading the pdf to be much more difficult than it should be.
Kevin Nakahara - Feb 04, 2009 03:14:15 am
I found the notion of describing direct manipulation interfaces as a very high level programming language to be pretty interesting. It appears that article is pretty dated considering how much direct manipulation stuff is out there now. Things such as video game map creators and music composing software seem to fit the same bill as the pinball machine designer outlined on page 316. I also found the distinction between the gulf of execution and gulf of evaluation to be pretty interesting. It goes to show how comprehensive and thoughtful designers must be in evaluating both how the user interacts with the system, and the system interacts with the user. All in all, in the readings thus far, I've noticed how a lot of them seem to complicate and explain seemingly simple things.
Eric Hernandez - Feb 04, 2009 12:59:49 am
The gulf of execution and evaluation is a thought that not nearly enough programmers consider. It's hard to name even one system to date that couldn't have a more intuitive interface, even though the success of a product depends so much on its interface. Indeed, this is probably the main selling point for Macs, which, through my experience, seem to have few outstanding features without their slick and easy to use interfaces. The paper's discussion on outputs sharing the same domain language as inputs was also of interest, and will probably become more and more common as touch screen devices become more popular. Touch screens also have the potential for shortening articulatory distance, since the physical forms of objects more often represent their meanings in this case. Semantic distance as defined in this paper was especially interesting; H&N are quick to use this definition to describe the trade-offs between high level specialized languages versus general, Turing complete low level languages. The discussion on how bloated Unix has become was severely understated as most of my semester has been dedicated to overcoming this shortcoming. The unfortunate question that arises however, is how does one go about making a directly manipulated Unix or Microsoft Word? As the number of features increase, it seems invariably true that the complexity of the interface must increase with it.
William Cho - Feb 04, 2009 02:44:02 am
Dense reading indeed. I also did not realize that this reading was written a while ago until halfway through it. And yet the amount of thought and consideration the author put into the idea of designing devices and interfaces with the concept of direct manipulation is remarkable, especially given the time when he wrote it. I liked the idea that the interface should not be noticed, but should be part of the world in which the users can immerse themselves and act, creating a sense of direct engagement with the device. I also liked how the author discussed various ways to bridge the two kinds of gulfs that lie between the user and the interface language. The relationship between reducing semantic distance and not generalizing as well for other tasks was also true; we see that today in many situations, such as the myriad of programming languages and their various uses.
Salman Rahman - Feb 04, 2009 03:51:15 am
Wow. This a very academic paper with complex and abstract ideas of which some are very hard to grasp! It took me forever to read this and I had a lot of difficulty. I suppose I'll begin my discussion with direct manipulation. The paper argues that direct manipulation interfaces are easy to learn, easy to scale, and makes operations easily reversible. I would agree with these conclusions because direct manipulation interfaces use physical actions / button presses that make it easy and intuitive to perform actions. Take the iPhone for example. That's a good ex. of an intuitive direct manipulation interface.
Further along in the paper the authors discuss the gulf of evaluation and the gulf of execution. I'm not exactly sure I understand this. To those of you who do, could you describe it for me in more simple language than appears in the paper? I know these concepts are central to understanding Fig. 6 which the professor said to pay attention to...
Meiying Li - Feb 04, 2009 04:04:08 am
Gulf of execution is the process of input translated from human mind into physical truth. Gulf of evaluation is the process of output translated from physical truth to human perception. The "distance" between human mind (or human perception) and the intermediate (in the scope of the paper, the interface) is called "semantic distance"; The "distance" between the intermediate and physical truth is called "articulatory distance". I had a question when the paper talks about shortening the semantic distance and the articulatory distance is our goal of HCI, that for some specific tasks we definitely don't want to actually know the complicated physical truth beneath. But the paper later talks about for physical tasks that are too abstract. It is an exception in this case. We don't want the articulatory distance to be too short.
Timothy Yung - Feb 04, 2009 04:00:38 am
I found the discussion on direct engagement to be the most interesting part of this article. Having designed complex interfaces intended for use by all kinds of users, I was only able to know when a certain effect "felt right" and "belonged". When I first read about the instant feedback necessary for direct engagement, I was reminded of the "40ms" rule: anything the user does [on a web application] must provide the proper feedback within 40ms to feel natural. As explained by the article, this 40ms is roughly the maximum amount of time allowed before the user perceives the computer as an intermediary.
Alexei Baboulevitch - Feb 04, 2009 04:01:01 am
The continued use of command line programs like Emacs demonstrates one of the article's points. From what I can tell, the reason people still use these programs is that they're quite powerful if the user is familiar with them, and that their continued use results in a greater feeling of engagement - even if the gulfs of execution and evaluation are quite large. With that said, as someone who's never used such programs before a few years ago, I simply can't stand them and will use GUI alternatives whenever possible. Especially in the case of Emacs, it makes a lot more sense for me to interact with the text using my mouse rather than entering some obscure combination, even if the latter is more efficient. (I still use many keyboard shortcuts like copy, cut, paste, close, etc., but they're standardized across most Windows programs, so using them feels more natural.)
There's also an interesting parallel between direct manipulation and creative thinking. I remember reading that some of the greatest geniuses were able to think about problems in non-intellectual, almost synesthetic, ways - for instance, by "feeling" them using their sense of touch. Could these ways of thinking simply be a form of direct manipulation with the human mind, bypassing language in order to work with the problem directly? And could well-implemented direct manipulation interfaces on computers allow us to think like geniuses?
Ling Chen - Feb 04, 2009 04:17:50 am
I have never heard of the gulf of execution and evaluation before. Then again, there were many new terms I have never heard of before. The author mentioned in the paper that there are two basic ways of reducing the semantic distance: one from the system side, which requires effort on the part of the system designer; the other from the user side, which requires effort on the part of the user. I think as a good designer, one would want to make things as easy for the user as possible. Which would mean that we would want to make the output show semantic concepts as directly as possible. I like the example of the rate of filling a water tank. It example made it more clear what the author was trying to say. "What you see is what you get." Of course, the author also pointed out that direct manipulation interfaces are not without faults. After all, directness does not equal to the ease of use. Direct manipulation interfaces do not assist in overcoming problems that result from poor understanding of the task domain.
Adit Dalvi - Feb 04, 2009 03:20:22 am
The discussion on the gulf of execution and gulf of evaluation intrigued me a lot. From what I gathered, the Gulf of Execution refers to the difficulty faced by users in converting their intentions into actual commands that can be executed. The Gulf of Evaluation refers to the difficulty faced by users to determine if the goals that they expected from their inputs have been achieved or not. They each contain a Semantic Distance i.e. the difficulty that users find in describing the meaning of an expression and an Articulatory Distance i.e. how hard users find it to transform an expression into its meaning and vice versa. I feel that the main idea is to balance what the user must do and what the program must do. This is another reference to the idea of data abstraction that is so widely followed in all of computer science. Many levels of API’s exist to bridge the gap between the user and the program in order to bridge both gulfs.
Moonway Lin - Feb 04, 2009 04:49:21 am
The gulf of execution is detrimental to simplicity in UI design. For example, if a driver wanted to back a car, he'd have to
- 1) turn the key/ignite
- 2) step on brake
- 3) shift control to Return
- 4) use mirrors and back slowly until the car's out of the driveway
If the design were as simple as possible, the driver would just need to push a button and the car would automate everything for him. There would then be no gulf of execution in this UI.
A good UI design, such as a digital camera, narrows the gulf of execution. If a user wishes to take a photo, all he would need to do is press the button. If a user wishes to view a photo, he simply needs to press back/forward.
Of course, the more complicated the task, the wider the gulf of execution, because the technology needed to automate a complex process is expensive.
Prahalika Reddy - Feb 04, 2009 02:21:43 am
I really like the concept of direct manipulation. It seems like it would make the entire human computer interaction go much smoother and a lot easier for the user. After reading this, it seems like direct manipulation is what UIs should ultimately strive for.
Regarding semantic directness for the gulf of execution, it seems to me that in order to achieve direct manipulation, most of the bridging of the gulf between user intentions and machine instructions should be done by the machine, not the user. It just means to make more sense when the user doesn't have to worry.
The semantic directness for the gulf of evaluation doesn't seem as important as it does for the gulf of execution. It's still important, getting results quickly and in a manner the user understands is good, but I felt that it was a waste of resources while the actual interaction could be improved.
Alexander Cho - Feb 04, 2009 05:05:00 am
I thought it was interesting how it was said that a good user interface is one that goes unnoticed, where the user feels in direct manipulations of the objects they they become unaware that they are dealing with the machine, computer, program, and the UI. I completely agree with the sentiment that one must not make the mistake of trying to implement everything and so many features that doing the most simple of tasks becomes impossible. The discussion on UNIX seemed very relevant to this. It is an interesting trade off between levels of abstractions and control for certain tasks. More thought and translation is required of the user for more control (like programmers vs. everyday users). I thought the breakdown into the gulfs of execution and evaluation was a good way of analyzing user interfaces, and I will consider these when I design my own.
Raymond Young - Feb 04, 2009 05:14:51 am
Prior to reading this article, I had never considered a metaphor of conversation to HCI. I had always naturally understood it using the world-based model. It is intriguing to now consider how much I feel the conversation metaphor fits HCI, and yet our minds, at least my mind, moves into the world-based model as I interact with the computer. I guess it depends on the level of abstraction I perceive HCI to be. But HCI is very much like a conversation in that there's nothing physically happening as far as go the ideas that we are manipulating and perceiving. The article states that in a conversation, one cannot act upon something that has been said, for it is not an object. HCI gives the illusion of objectivity because humans have figured out how to build something very complex that we call a computer, which will preserve a state that would otherwise fall completely apart had we not cleverly designed the machine to do what we tell it to. When we are using our computers, we become immersed in them. All of a sudden, we are inside of something that feels like the world. If we don't touch a rock, it doesn't move unless something else moves it. It doesn't have a perceptible change if we don't do something to it. It may change, in that it has its own processes, but it is still an object in that it behaves differently when we're sending it input, and when we're not sending it input. But as soon as our computer dies in any number of ways, we can no longer access what we had previously perceived to be objects. We can no longer act upon them. So as soon as our clever trick fails, we return from the world inside the computer, to this world, and realize that how clever a trick it was, and many curse the computer for not behaving in the very complex way it was just a moment before. They curse it for being what it naturally was; something so transient as a conversation.
I found this reading also very informative on points of UI design. The inverse proportion of distance to the amount of cognitive effort. This is perhaps a very good reason that computer games like WoW are such an amazing experience for many people. They can do so much in that world because they don't have to do very much in this world to navigate through that world, or to perceive it, to understand it, to execute actions. The interpretation process between the worlds is almost transparent.
I really enjoyed the parts of the article on semantic and articulatory distances. One place in which semantic distance always comes up is in emotions. When someone is angry, they can say why they are angry, what happened to make them angry, and they can yell about it really loudly to let everyone know that they are angry and why they are angry. But since words are symbolic representations of objects, and there is no object which that angry represents which isn't a conditioned association, it becomes even more infuriating when one can't express "Angry" itself in words. It requires a huge amount of effort in words and in cognitive processes to express anger since there's no way to express it directly through the medium of words. The gap of execution in expressing anger is very high when using words. Also, since anger has no physical form, the amount of effort to express the meaning of anger is also very high, giving it a large articulatory distance as well. These distances to cover across the gaps of execution and evaluation must be why being angry is so draining.
The concept of arbitrary sounds also comes into play with semantically and articulatorily difficult expressions, such as emotions. Since words are just arbitrary sounds that people have agreed upon for the sake of communication, one way to express emotion would be to make sounds which don't have any semantic meaning, and this can be quite humorous to consider. The comedian Dane Cook performs the mapping of emotions to arbitrary sound quite well.
Gregory leshner - Feb 04, 2009 05:19:09 am
Bridging the gulfs of execution and evaluation and creating a usable and effective interface is really an exercise in compromise. As the paper points out, we trade off ease of use versus the ability to perform complex tasks. The move to graphical user interfaces (windows) and away from command line interfaces (DOS or Unix) was a direct attempt to bridge these gulfs and strike a middle ground. Perhaps the standard Windows and especially the Apple OSX interface has gone too far towards making things easy for users and sacrificed our ability to do new and complicated things with our machines easily. OSX tries to solve this problem by giving users access to unix interface and windows has always maintained a DOS command line interface that advanced users can get to.
The paper was very valuable if for no other reason than to remind us that the journey of directness in interfaces, of mimicking the concrete world in our virtual world, was long. The epiphany we get today of how much better the iPhone interface is from previous attempts, for example the flicking forward of a screen to move down the page or how it rubber bands when hitting the end of the file, is no different than when users first saw a iconic representations of files or WYSIWYG word processors.
Phiroath Chan - Feb 04, 2009 05:50:43 am
The reading suggest that directness is the feeling that results from interaction with an interface. Directness was further broken down into two aspects: Distance and Engagement. The meaning of these words are not very intuitive i think. Distance refers to the "distance between one's thoughts and the physical requirements of the system under use." Engagement refers to the "feeling that one is directly manipulating the objects of interest.
The reading also went over two major metaphors for the nature of human-computer interaction. My question is which metaphors is better to use and if it depends on the certain circumstances then I would like to know the circumstances that the two metaphors depend on. In conversation metaphor, the interface is a "language medium in which the user and system have a conversation about an assumed, but not explicitly represented world." This metaphor represents the interface and user as two separate things and both help each other understand things about the assumed world. In model-world metaphor, the interface is " itself a world where the user can act, and which changes. This metaphor deals with the "World" being a separate structure in itself. The user is no longer conversations with the interface, but the interface waits to be altered by the user.
Anatol Tsang - Feb 04, 2009 08:52:03 am
I feel that many of the concepts in here are outdated and have been treated almost as common sense for user interface implementation today (spreadsheets today are pretty directly manipulable, right?) However, this paper may still be important because it reminds us of how computers used to be, and how we can improve on them.
Since this article is very general, I find it hard to discuss about something (I'm a person who needs an example or concrete ideas). The differences between the gulf of evaluation and the gulf of interpretation looks like it should be the same- mentally, the same data structures stored on the computer should have the same or similar methods of interpreting input and translating output. Also, it depends on the situation. The article mentions correctly that direct manipulation may not be the best thing to do in certain situations (e.g. repetitive actions). In general, I think the gulf of evaluation is more important to optimize- the gulf of execution can be offset by training or familiarity.
Aaron Hong - Feb 04, 2009 08:54:27 am
I found this quote when I was reading to be very interesting: "In the lead article of Scientific American's special issue on computer software, Kay (1984) claims that the development of dynamic spreadsheet systems gives strong hints that programming styles are in the offing that will make programming as it has been done for the past 40 years-that is, by composing text that represents instructions - obsolete." (316)
I'm guessing this is Alan Kay, and that he means programming like how we program with C and Java and the development of "dynamic spreadsheet systems" to be systems similar to Lab View, since they were talking about this visual programming all before this quote. It it curious to see how we often make projections into the future, especially ones about how some things will become obsolete, but then to see how enduring they actually are (hard drives being another ancient relic). If Kay meant that less people will have to program in order to use their computer, then he is right here, but programing "by composing text that represents instructions" is less than obsolete.
Anjana Dasu - Feb 04, 2009 09:37:27 am
I think reducing the gulfs of execution and evaluation boils down to increasing the usability of an interface. With respect to the gulf of execution, I think closing the gap involves creating a learnable system. To create a learnable system, I think (as someone above also suggested) borrowing from other UIs is a good method. For example, a new application that uses apple-c (mac) or control-c (pc) for copy because that has become "standard" for commonly used programs (ex. the office suite). When you don't follow an existing convention, it can be frustrating for the user. In Adobe Photoshop, the most frustrating thing is that the apple-h cannot be used to hide because it has been appropriated for Extras-- which is especially irritating because it has no visible effect. As for the gap of evaluation, I think this is probably being met better now than when the article was written. WYSIWYG tools are a good example of interfaces that clearly close the gap of evaluation. For reference, I would like to know about interfaces that fail to bridge the gap of evaluation though. Perhaps the Extras in PS is an example? The user is not aware of the output because all it does visibly is check the Extras item in the View toolbar when presumably it should make some other menu bar/menu module appear. I would like to see more examples of this though.
Sum Sum Wong - Feb 04, 2009 09:36:39 am
The reading started with introducing direct manipulation, which is a form of UI design that I've never heard of. Direct manipulation have the virtues like, easy to learn, able to perform wide range of tasks, can give immediate feedback, etc. There are 2 aspects dicussed in the reading, distance and engagement, while most of content concentrated on the distance part.
A major idea provided by the reading is the gulf of execution and evaluation. Simply speaking, the gulf of execution is how well the system can understand the user and the gulf of evaluation is how well the user can understand the system. An efficient UI design should be able to minimize(I don't know if that is the right word to use) the "gulfs", which is a tough task to do especially for complex operations.
In my opinion, the reading is very conceptual and hard to understand. But thank god for Fig.6, it makes everything a lot clearer. Anyways, I think the idea of direct manipulation is very worth-considering when designing an UI.
Bernardo de Seabra - Feb 04, 2009 10:23:32 am
We were warned and you were right: a dense reading indeed. Nonetheless, it seems to be one of the foundations of HCI and important to what we will be doing in the class. The topic of the paper is "Direct Manipulation Interfaces" and the most interesting concept it covers is "Directness" (distance and engagement) as well as its drawbacks. In terms of distance, this idea is measured in terms of the gulf of execution and the gulf of evaluation. The gulf of execution is bridged by developing system commands that are as close as possible to the thoughts and goals of the user. The gulf of evaluation is bridged by generating output that is readily perceived, interpreted and evaluated by the user. These gulfs measure two types of distances: semantic and articulatory. The semantic distance represents how close is the representation of an element in the interface with what the user wants to say. The author then explores ways of reducing the distance between the gulfs in this concept and misconceptions about some ideas. The articulatory distance describes the relation between the meaning of expressions and their physical form. In other words, how close are the forms of the elements in the interface to the actual and realistic meaning of what they represent. A few approaches to accomplishing this are offered by the others. Overall, this paper made me think about concepts that are to a certain extent intuitive but in a much more profound way and the challenges that are faced in HCI.
Szu-Chun Mao - Feb 04, 2009 08:09:42 am
It’s certainly an interesting article about HCI, particularly the part about direct manipulation where I learn the tradeoffs between generality and specificity. Comparing Windows and Unix sets a good example that illustrates the importance of easy to use versus learnability. Adobe Dreamweaver, a web development tool, uses WYSIWYG (what you see is what you get) making the output shows the semantic concepts directly to users in order to bridge the gulfs. The common goal of all these examples is to move the interface language toward the users in order to improve HCI and to make users feel more natural using them without giving much explanation. However, as mentioned, all direct manipulation interfaces have tradeoffs so we need build a framework which allows us to analyze the substitutions in order to find a well-suited solution for users.
Victor Lum - Feb 04, 2009 10:17:35 am
I think this article makes some good points about how the output should be presented to the user. I especially liked what they said about the better the interface is, the less you have to think about it. Often I would use a new program and not be able to interpret what's going on. It's only after studying it for a while, that I finally figure it out. This is where things like video games really excel. You can just look at it, and you'll know mostly what's happening, without ever needing to read the manual (although actually playing it is a different story). Either that, or I have learned to think they're natural because I play too many games.
Siddharth Shah - Feb 04, 2009 02:27:50 am
The gulf of execution goes from the goals to the system state. The gulf of evaluation gores from the system state to the goals. The semantic distance for execution is how much help is provided by the system, and how work the user must come up with by himself/herself. The semantic distance for evaluation is the amount of processing structure the user needs to determine whether the goal was accomplished or not.
This reading was definitely dense. I liked the discussion about how to bridge the gulfs, and actually I really like the whole idea of the different gulfs. A lot of people would just lump them together and not worry about it, but if you really break it down like this you have a much better shot at reducing each gulf and therefore coming up with a more solid design.
Chris Thompson - Feb 04, 2009 10:40:57 am
One of the key goals discussed in the paper was the idea of direct engagement -- the idea that a user feels like they are working with data, not that they are working with a program that allows them to interface with the data. If one can give the user the feeling that they control the abstract, idealized, conceptual objects of interest then they shall be more productive at the cost of less energy and have a greater feeling of satisfaction.
We must be careful how we achieve this directness, though, and strongly consider the tasks that are to be performed by our system. In many cases one interface can clearly be more direct than another, but then when the intended task changes, it might be the case that the second interface is now clearer. I think their example with the piano and violin illustrated this idea clearly; you can find notes easier on a piano, but you can't control their vibrato. This implies that we must think very hard about the intended tasks of a system we're developing, in order to ensure that there is a maximized feeling of directness for all of those tasks.
David Jiang - Feb 04, 2009 10:24:29 am
According to the reading, directness is the measurement of how one interacts with the user interface. It has two parts, the gulf of execution and the gulf of evaluation. Each is further broken up into a semantic distance and the articulatory distance. After initially reading the article I was a bit confused about the distances, but figure 6 made it so much more clear. Forming an action corresponds to the gulf of execution's articulatory distance while determination of the output expression from the form of the output expression is the gulf of evaluation's. As for their respective semantic distances, for execution, it is what is needed to satisfies the user's goals in going into the system as an input expression, while for evaluation, is it how the user makes sense out of the interface coming back from the system. The reading talks about the overall balance between the system and the user. It speak of creating a balance that doesn't make the system do just the right amount of work so that the user does not have to; but yet at the same time, allows the user to input the right amount of information, as well as get the desired amount back.
Joseph Tsay - Feb 03, 2009 09:16:22 pm
This article, although a little tough to understand at times, analyzed direct manipulation software, in which the user is able to complete tasks using an intuitive graphics based interface. It describes both the gulf of execution, the process that the user must go through before the task is complete, and the gulf of evaluation, the process the user must go through to determine if the task has been completed. It describes how certain aspects, when streamlined or processed more, can decrease the size of these gulfs and make the usage of the interface even easier and better.
Adam Kauk - Feb 05, 2009 11:24:36 pm
This article is really interesting. At one point the authors said that people can have a sense of directness just by having practiced something many times and being able to do something well. This reminds me of all of the lynux-snobs out there who say lynux is the best. It probably is, once you put in all of the practice to properly use it, but the reason most people don't use it is that it isn't very accessible.
I also liked the quote near the end that says for the last two thousand years we have been trying to go toward abstraction instead of directness. To some extant that is correct. What other areas could be improved by cutting some of the formalism and going direct?
I would also like to see people combine the model world interface with the conversation interface. That might lead to the best interface yet.
