Conceptual Models II
From CS160 User Interfaces Fa06
Lecture on Sep 20, 2006
Readings
- Direct Manipulation Interfaces. User Centered System Design. Chap 5. Hutchins, Hollan & Norman.
Keenahn Jung - Sep 18, 2006 01:21:23 pm
I found most interesting the comparison between the conversation and model-world metaphors for designing/describing UI's. Often when using a UI, say the windows file explorer, I "feel" the connection to the metaphorical objects I manipulate. When deleting a file, or emptying the recycle bin, I feel that my hard drive has been cleansed. When I run the disk defragmenter, I feel satisfied when the boxes, representing clusters on disk, line up neatly next to each other. Thus, I can see how UI's built on the model-world metaphor would engage the users more and give them a greater sense of control and influence.
Later on in the paper, the authors mention that it is possible to design the language so that the symbols/meaning pairs are not arbitrary. In spoken language, onamonapoetic words have some relation to their meaning, but they differ greatly across languages! Thus, what seems like a "natural" pairing of symbol to meaning to one person would seem wholly unnatural to others.
PS: First post!!
Bowen Li - Sep 18, 2006 03:58:58 pm
The graph example: It seems very GUI based. Although it is intuitive enough, it seems incredibly slow. Using text and equations can be much faster and more specific. What if you had 20 equations in there? That's a lot of dragging to fit onto 1 screen.
They are being somewhat contradictory in their terms: It's called 'direct manipulation' but in fact you aren't directly manipulating the data at all you are only specifying to the computer how you would manipulate it. They say: 'the user is in direct contact with linguistic structures, structues that can be interpreted as referring to the objects of interest, but that are not those objects themselves' however, if you examine what a graph is, it is exactly a metaphor to the data, not the data itself. The data itself is nothing more than numbers, or maybe pairs of numbers. Thus their "direct manipulation" actually distances itself from the data by using the graph or the icons as intermediaries.
They talk about trying to bridge the gulf between goals and tasks to be specified to the system. The gui method works in simple cases but not in complex ones. This is reflected in web designers' choice to use text editors to make web pages instead of wysiwyg editors. The graphicals don't work well, they aren't well implemented. It's hard to specify all but the most trivial tasks.
Since the article is dated at 1985, I think there is some cultural element to this. At the time computers were not as GUI weighted as they are today, so it is natural that the article would focux on moving in that direction. Learning to do things in text in the 80's might have meant learning a whole programming language, or something similar. But today, things like MS Office suite make it much easier to do data manipulation tasks. Most people who make data charts know how to use Excel, even though it requires some learning.
The article spends a lot of time talking about different "distances" the interface has with the way people think about problems. But as computers have become ubiquitous, they have really shaped the way we think about problems. It now seems natural to me to break a task down into simple instructions for a computer, if I were to use something "high level" or have "direct manipulation" made available, I would have to reconform to that new way of interaction.
Robert Taylor - Sep 18, 2006 09:17:26 pm
I agree with Bowen that the manipulation is not entirely direct. It is, however, more "direct" than writing (+ x y) or something more text based. As far as the "benefits" of direct manipulation, I don't think the reading got it all right. Let's take moving files into different directories as an example for their points. Here direct mainuplation involves opening windows, dragging folders across different windows, perhaps clicking on the properties of a file and changing something, or clicking the name of the file, waiting a few seconds, and then giving it a new name. Indirect manipulation would be doing all of this by a terminal.
1. "Direct manipulation is easier to use for novices, and does not have as steep a learning curve." Certainly this is true; to use a terminal one has to know the commands, while the intuitive motion of dragging a file into different folders is much easier to learn.
2. "Experts can work extremely rapidly, defining a new ange of functions and tasks." No. The whole point of direct manipulation is its simplicity and intuitiveness; this prevents it from becoming a medium that can be advanced for experts to work rapidly with. One can only point and click so fast; text based manipulation can become more efficient as users learn commands, tab completion, and small scripts. For example, typing chmod -R 444 ~/Photos/*.jpeg is much faster to type than the process of point and click navigating to a directory, arranging icons by type in the window, scrolling down and highlighting all the ones you want to select, right clicking them, going to properties, and setting permissions. Obviously understand chmod is more a thing for "experts" and is not direct manipulation, but it is much, much faster.
3. "Knowledgeable intermittent users can retain opeeraitonal concepts". True, and it does apply more to direct than indirect maniuplation. Again it comes down to direct manipulation being easier and slower.4
4. "Less error messages." No. Either they're implying that users make less mistakes with direct manipulation, or that direct manipulation simply doesn't give error messages, which isn't useful feedback. I think it's debateable as to whether users make less mistakes with direct manipulation; while it certainly is more intuitive, users still have to do the same tasks, even if they are dine in different ways, and thus probably will still make about the same mistakes.
5. "Immediate feedback" Yes, although not in every situation. Visual cues can give us a better idea of the big picture than text, but the second part, that they can immediately change their direction of activity, isn't thayt big a deal. When you realize you're going in te wrong direction, you typically change direction. Because of the slowness of graphical, direct maniuplation, I think if anything it would take longer to go back/undo and/or change direction than in a text based, indirect manipulation environment.
The authors actually spend some time talking about file maniplation, and how files cannot really be rperesented as text as well as in a more visual way (windows with icons), which I agree with; my issue is that they don't spend time adreesing the trade offs in efficiency that come with direct manipulation. There is a mention of higher level languages, such as zetalisp, and systems, such as unix, that started out on a simpler, lower, level, and burgeoned out of control. While it doesn't really address my point, it does bring up an interesting paradox of how direct manipulation and efforts to make things easier to use actually can make them harder. In some sneses, the most "direct" manipulation comes from lower level interaction such as the terminal or MIPS, instead of KDE or Java.
Ramy Ghabrial - Sep 18, 2006 10:10:55 pm
It seems that what the authors refer to as the "gulf of evaluation"/"output interface language" is what we would now simply call "feedback". In the case of a conversation model, this would be the system messages, output, confirmation and errors the system responds to the user's commands with. In the case of a model-world, this would be how well the system shows all relevant data and corresponds to the user's mental image of how it works. This gulf must be bridged both semantically and articulatorily, by outputting relevant features as directly, concisely and intuitively as possible.
Antonis Mannaris - Sep 19, 2006 12:36:31 am
This article was written in 1985 yet it successfully tackles an issue that is very relevant today. Ever since GUI's became the norm for most commercial designs, and the internet, achieving a successful Direct Manipulation is a key to a successful system. The article talks about the distance between the thoughts of a user, and the actions he needs to take in order to express those thoughts through an interface. A very basic example is to follow a link by clicking on it. However designers need to be careful not to assume that all people think alike. At some point, we need to sacrifice this form of directness to avoid the danger of being TOO accurate. A second form of distance is the distance between the output and the conceptual understanding of that output. I believe designers often, in their attempt to make this distance shorter, make their own system less versatile and powerful (e.g. automated behavior). Another very interesting section is when the article talks about bringing the user's conception closer to the system. This statement goes hand in hand with the idea that designers should take advantage of systems that users are already familiar with. For example, assuming that the mouse is a good input device is pretty reasonable. Closing, it is obvious that direct manipulation is good when the users are not computer experts. If the goal of a system is to provide a user the power to manipulate the system itself (or the computer), then command lines and the conversation model seem more appropriate and efficient.
David Hoffman - Sep 19, 2006 10:34:00 am
The Hutchkins et. al. article is an interesting discussion of some of the reasons to choose a direct interface versus a low level interface. I think the best point that he makes is that eventually people learn the low level interface fairly well and interpret it as being direct. I can relate to this myself to some extent as some of the operations that I have learned to do in programming now seem second nature and direct where initially they seemed to be very circuitous. One clear example of this type of direct interface vs low level interface is with Labview. Hutchkins would argue that labview is a direct interface because you visually connect the things that you want to together and use icons to tell the computer what to do with the different signals. On the plus side, it is easier to interpret visually what is going on. On the down side, it runs slower than if it were hard coded and the software can be buggy. I think that Hutchkins was very good in his assessment that the problem with really direct interfaces is that they shun potential advantages of new technology. There are many applications where it is much better to tell the computer what you want in its terms so that it gives you what you really want instead of trying to describe it in the highly variably interpretable vocabulary that people would use.
Huangnankun - Sep 19, 2006 03:20:09 pm
The writer starts off with an example of a direct manipulations system where a graphing program can use connectors and operators to make the user interface easier to use. The author’s notion of “direct manipulation” seems to come from the non-computer world of everyday tasks. In our everyday situation, when we push and object, we expect it to move, when we pull a flexible object, we expect it to stretch. The level of feedback and intuition provided in our real world is unmatched by any computer based interface.
In the computer world, the author introduces the concept of “distance” which defines the “directness” of the interface. It is referred to as distance because an interface always introduces a level of abstraction on top of the real task that is to be performed. The less the abstraction, the less the distance. However I feel in many cases that abstraction is a necessary evil. Take the author’s own example application, while it works for simple plotting, the system will quickly breakdown as more data streams clutter up the interface. Something like what matlab use (code based plotting), although has more “distance”, can manage large amounts of data much better.
The author goes on to talk about how distance can be reduced by making data and inputs outputs user-manipulated, just like the real world. He also talks about the importance of expression, which can be summed up by “say what it actually means”. Next up was the topic of programming language and the author talks about higher level languages which are more intuitive to use. Based on my own experience, higher level languages works well for some scenarios ( such as SQL ), but for certain performance oriented applications, lower level languages such as assembly can’t be beat.
One of the points the author brings up is that in order to make abstractions easier to handle, interface designers can make users learn the interface and adopt to it rather than trying too hard to design an “direct interface”. I agree with this since most of the interface element we use on the computer today have no real world counterparts, thus there’s no real “directness”. But interface elements such as the checkbox and the scrollbar are so well designed that most users have already long gotten used to it. Thus in a way, the “directness” can be changed by user’s training.
Jason Shangkuan - Sep 19, 2006 04:58:39 pm
The Hutchins article addresses a constant concern that users have with every interface, especially software, which is the ability to convey the meaning and intentions with the least amount of effort. The breakdown of distance into semantics and articulation breaks down the upfront challenges of designing an interface. A good example to start with is the iDrive discussed in class. Semantically it tries to abstract all the interfaces into a single control and in terms of articulation, it implements everything through symbols.
Engagement is really a metric on how effective the semantics and articulation were implemented (essentially, is the distance short?) For the iDrive, depending on the feature, it is a long distance to use certain features so the engagement is poor and not realistic. When designing, it is important to take into consideration the end result of engagement; the articulation may be well thought out and implemented well, but the engagement can still be poor. The example of the iDrive described is the best example of this seemingly disconnected relationship.
Hiroki Terashima - Sep 19, 2006 07:01:24 pm
The metaphorical examples in this article are just a small subset of a more general metaphor that maps computers to humans and vise versa. A computer "is sleeping", "is running", "crashed", "isn't responding", etc. We do tend to think of computers this way, and I think it promotes some intimacy with the computers because we explain the computer's behaviors using language that we'd use to explain our own. What stands in the way, according to the paper, is the "gulf of execution" and the "gulf of evaluation" that are introduced by interfaces. A good interface can bridge the gulfs, so the user doesn't have to make lots of effort to use the system, thereby resulting in a more direct feeling of interaction.
This paper mainly touched on the "direct-engagement"/"direct-manipulation" idea, and it made me think of the recent Web 2.0 efforts and use of technology like AJAX in particular...Before, the web was more static, created/manipulated by an almighty webmaster, but now, it seems like almost everybody can change the contents of the web, and it's becoming more and more user-friendly and easy-to-manipulate (ex: wikipedia, google-calendar/spreadsheet). The improvement in technology helped make this possible.
Scott Friedheim - Sep 19, 2006 08:38:38 pm
I think the reason I found this article so painfully boring is that the ideas presented, although abstract, were not new. Given that this article was published in 1985 demonstrates how impressive the ideas are and reflects the brilliance of the writer in understanding how HCI is supposed to work yet without REALLY experiencing it yet. Even to day (especially having to do with web applications) we are trying to achieve a level of fluidity in our applications to make them feel more natural and intuitive. This reminds me of the videos that were shown in the last discussion section. It wasn't the first time I have seen those videos however, every time I do see them it just amazes me at how advanced the ideas were and where scientists were at that time. The only thing holding them back was the technology to implement their ideas. This really makes me excited for the future and what ideas are just waiting to be born pending technological advances.
Cheng-Lun Yang - Sep 19, 2006 10:34:02 pm
A successful user interface design is the one that makes the users feel they are directly manipulating what they want to manipulate. The windows operating system i used all these years meet the above criteria. When I click on one file, the hour glass picture enables me to visualize that the computer is processing my request. On the other hand, the unix operating systems used in lab makes it harder for users to visualize. When i type "rm xxx.c", the prompt line does not show anything indicating the job is successful. I would have to check the current file list to figure out whether i successfully removed the file or not. The windows system has low gulf of evaluation as you are able to see the file disappearing when you delete it. But windows system has higher gulf of execution since you have to either right click on the file and select "delete" or drag the file to the trash can. Above actions are not intuitive to first time computer users. For the unix systems, it's the opposite of windows system. It has high gulf of evaluation because it is hard for the users to know whether the commmand executed properly.
Patrick Rodriguez - Sep 19, 2006 10:56:22 pm
I have to concur with some of the other posters that a lot of these ideas are suited more for inexperienced computer users. While it is nice for the interface to graphically mirror what is going on, sometimes this is a big hinderance when you just want to get things done. Command line vs GUI system operations, for example, as one poster pointed out. I certainly find myself dropping down to the CLI at times, even on Windows. Another example would be the graphical programming languages that are touted as easier to use than traditional languages. True, but the ease of use comes at a cost. Many times, a simple script can do what would otherwise take a convoluted graphical program. To experienced programmers, it's just easier to think in terms of code rather than graphical components. So we really need the best of both worlds, ease of use and power. If those two factors can't exist within a direct manipulation interface, then at least provide both a graphical and script interface (or a "basic" and "advanced" mode, so to speak).
Tak Wong - Sep 19, 2006 10:42:34 pm
I found this article a bit too long for what it is trying to convey. It tried to give a lot of examples for concepts that are relatively easy to understand (like the virtuosity and semantic distance). I believe we should design with letting the user see what exactly they are manipulating, but at what cost? If the user wants to, say, make thousands of possible changes to a simple image and we are missing one feature, is this considered bad design? It also depends on how much resource we have. Having a text based interface will definitely save a lot of programming time, and it may be worth it if the interface is not used very often. This sort of raises the contradiction of if the interface is not used very often, then we should have the the user adapt to the interface. But, the user will likely to have less experience with the interface, so it will be harder to use. On the other hand, if the interface is used frequently, then it may make sense to design a very friendly graphical interface. But, the user has a lot of experience in the interface, so he or she can basically adapt to any reasonable type of interface if it is used repeatedly. So either way, it doesn't seem very cost effective.
Alex Wallisch - Sep 19, 2006 09:30:05 pm
One issue with this article is that it tries to make the interface as conceptually simple as possible given no prior knowledge or conception of how the system does (or should) work. For example, somebody who had never touched a computer in his life might find the direct manipulation interface discussed at the beginning of the reading to be intuitive, and when this article was written in 1985ish, that might have actually been the case. However, these days a lot of people in this field have some experience with Microsoft Excel or OpenOffice Calc or similar spreadsheet programs that are capable of generating charts, and they have some idea of how charts like this work in those contexts. To people with these experiences (such as myself) the type of direct manipulation interface discussed wouldn't make sense; it may be more in line with what is "intuitive" in everyday life, but it's not how we expect computers to behave.
Patti Bao - Sep 19, 2006 11:28:46 pm
Direct manipulation is an interesting concept, although a little fuzzy at times. For some reason, my initial response was to think about that scene in Minority Report, where people just wave their hands across a screen to drag and drop objects on it. What appealed about that scene was probably the same thing that appeals about direct manipulation - it seems like such a simple and intuitive way of interacting with things. Yet the point is also made that these direct manipulation interfaces are just illusions, and the designer is supposed to sustain that illusion. It's not like you can actually pick up that button you just made for an online form and really feel the feedback when you push it. At times, I feel like the whole web phenomenon is misguiding too, because at the end of the day, no matter how cool something looks or "feels", all we are doing is just writing new files or modifying existing ones.
In spite of that, I think direct manipulation really does make a lot of sense. My only concern is that the authors make some things sound so intuitive when they're not necessarily intuitive for all users. The graph example at the beginning still relies on a graph icon. But in an ICT4D (ICT for Development) class I took last year, someone was developing an interface for use in Tamil Nadu and she had to rethink the concept of using weather icons and push buttons because those users weren't familiar with them. It's hard to say how well direct manipulation interfaces can work in all situations, but if well-designed, they can be pretty convincing.
Yimin Yao - Sep 19, 2006 11:16:01 pm
The article, given the year of its publication, is reasonably accurrate in describing the relationships and distances between the user's intention, input interface language and output interface language. However for a topic that's somewhat common sense if you take a moment to think about it, I find the article a bit overdue with its fancy and abstract terminalogy.
I think web design softwares are good examples of applications designed to bridge the gulf between user's intention and the input language of the system. If you want to insert an image in a table on a webpage, or simply change the background, it's much more "direct" to just click a button and browse for the image, then stretch the image with mouse to adjust to desired size. The traditional, less direct process of typing html or other code into a text file, and only see the effect of your manipulation after saving and previewing in the browser is rather tedious even with practice.
I think an important point is that even though directness can be developed bwteen users and many interfaces through automation/frequent practice, it should also be the goal of interface designers to generate directness for the user to minimize the need for practice.
Maksim Lirov - Sep 19, 2006 11:42:14 pm
This article explains what characteristics make systems direct. One point that I think it misses on is that many times there is a tradeoff between making a system as direct as possible and making a system as useful as possible. Oftentimes, the simplification of a user interface causes the whole system to lose some of its functionality.
In most modern operating systems with graphical interfaces, 30 clicks and drags of a mouse can accomplish the same thing as one line on the command line. Oftentimes, the clicking and dragging provides a more direct method of accomplishing things to the beginning user, but arguably is less direct for a more experienced user. The vi editor (which the authors provide as an example) may look impossible to use for the beginning user, but it provides a "hand-in-glove" feel to experienced vi users. To vi experts, vi's commands are "the way things are supposed to work."
On a similar note, efficiency must be considered when arguing for/against direct manipulation systems. To beginners, direct manipulation increases their efficiency. However, to experienced system users, direct manipulation many times decreases their efficiency.
Jonathan Yen - Sep 19, 2006 11:34:05 pm
Direct manipulation is definitely useful in a number of circumstances, especially when one wants to deal with data in a way that is more intuitive and less cumbersome. For example, when a user might want to draw a shape on a computer, they would want to draw it directly, rather than go through the details and figure out where each point should go. In such instances, direct manipulation would make things much more simple. However, when trying to correct individual components on such a drawing, direct manipulation may be less desirable to use. To shift a drawing by several pixels to the left, it would be much more preferable to have a way to deal with this in the "conversational interface" rather than agonizingly trying over and over to get it in the desired position.
Robert Held - Sep 19, 2006 11:49:56 pm
I felt that the authors did a good job of framing the ideal direct-use interface. However, I was most interested by their parting words, where they emphasize that a direct interface is not always what one wants. Based on the items they covered earlier in the article, it seems like having a direct, graphically-based programming language would be a bad idea. Specifically, introducing icons and graphical elements to coding could make it difficult to manage low-level processes. However, I think that LabView is a good example of a language that can do both. Used chiefly by engineers and scientists to create quick data acquisition programs, LabView provides boxes and wires in a graphical interface that are used to connect variables and execute pre-made functions. Thus, no lines of code need to be written to create a LabView "Virtual Instrument." However, if the need arises, one can also create C++ or MATLAB modules for LabView. Thus, one can easily provide lower level commands. The authors mention that such an ability would be necessary for a graphical coding environment, but they also dismiss it as undesirable, listing Lisp and UNIX as languages with similar capabilities that, in their eyes, became too bloated. Perhaps the development of more powerful computers since the publication of the article has made graphical environments more acceptable.
Melissa Jiang - Sep 20, 2006 12:04:11 am
Like many others have pointed out already, I too believe that there is a tradeoff between direct graphical manipulation and text programming. It seems unimaginably hard to give a graphical represetation to every single programming feature. The sheer amount could possibly clutter the workspace and boggle the user's mind. Not to mention, if the user wants to modify anything more lower leveled, the direct manipulation may hinder their process. There are many miniature options that an experience user will want to modify but will hold no use for less exerpeicen users. Will those still be represented within the direct graphical manipulation system? If so, they will clutter; if not, what happens if a user does want to use it?
However, a pure text programming system will not be as intuitive for less experienced users. Until they come up with a design that truly allows good graphical control on the high level end as well as the low level end, then a mixture of both seems appears to be the best option (much like the current Windows and Mac OS).
Vahe Oughourlian - Sep 19, 2006 11:49:27 pm
Papers such as these are inheriently frustrating in that they propose to define a problem but give little effort towards a solution. However, at least this case tends not to overblow the merits of its method, and it acts as a medium by which "you hear what you need to hear." In this case, the author is trying to move design away from the cryptic, command-line interfaces prevelent in 1985 towards the graphical interface present only a few systems (namely the Apple II, at this point). He does bring up great points, in regards to making information available to the user that has meaning in both how it is represented to the user and where it is represented to the user. But he does shoot himself in the foot in his own metaphor. The comparison between direct manipulation vs indirect manipluation and the piano and the violin? He fails to mention the inherit problems of size in regards to direct manipulation. A piano (at least, an acoustically good piano with a full set of keys) is large. Very large. And heavy. Very heavy. In comparison to the much smaller violin (in addition to the technical details of tuning the two instruments), the piano is a joke. No one would ever use such a clunky, large, and immobile instrument when they could just as easily reproduce the same notes, with a slightly higher learning curve (discounting the acoustics of the sounds, of course), with the violin in a more portable and expressive package. That's part of the problem of dealing with anything by direct manipulation. If we do nothing by proxy (for instance, using the keyboard and the mouse), we crowd ourselves into a corner where items must be of relative size and shape of their real-world counterparts. Thus, we lose the inherit abilities in computers to do what they do best (computation) and instead waste time and effort on interpretation. Short of the lower learning curve I don't see too much merit in this idea, except for the observation that names and representations of items in computers should, perhaps, be more natually named. However, any sort of useful conversational model, like the one the author mentions, is, at least to current computing technologies, highly improbable due to the large variance in the delivery of a single command and the ambiguity of natural languages.
Suneet Shah - Sep 19, 2006 11:50:40 pm
I thought the reading was interesting becuase it used some great examples. When we use direct interfaces that work well, we often take them for granted. A simple example is the file system on our computers. Files are represented as icons, and we use these icons to manipulate them and perform actions on these files. Its a great representation that works well, and in terms of direct representation, brings us close to our goals of being able to perform manipulations, have nice organization, and easily most other tasks. Its great for the first time user and average user. But often times people prefer command line interfaces, because for the advanced user, one can perform batch tasks that otherwise would take much longer using the icon representation. The article touches upon this trade off, that with direct representations you always have this tradeoff between the representation and the ease of use. I also agreed with the article about how important and revolutionary the first direct image editor was. This is a simple tool that we now take for granted, but is really revolutionary. I also thought the point that was made in the article that displays need to be thought of as pieces of paper as something that hit really close to home. I mean, that seems to be the theme of this class. Paper and pen make up the universal interface that we have been trained to use ever since, and is a behavior that is deeply engrained in all of us and our society. Despite technological advances, we are still not able to move away it in our society. All critical documents are still stored as paper forms. When drug companies submit drugs for approval they still deliver TRUCKLOADS of paper to the FDA for approval.
Jason Lee - Sep 20, 2006 12:27:34 am
The article is an interesting read because it tried to break down the exact definition of the term "direct manipulation". However, the term "direct manipulation" seems to be a relative term, as the definition of a discrete object and the different ways to manipulate them varies from person to person. The most interesting part to me was the section "Automated Behavior Does Not Reduce Semantic Distance", which states in so many words that a person may get accustomed to the way a poor or difficult interface works and behave under the feeling that he/she is directly manipulating objects within the interface, citing vi as an example. However, isn't this basically the same thing as direct manipulation if the user feels as if he or she is in complete control over the objects that he or she creates? This idea is further explored in the section "The User Can Adapt to the System Representation", where the author describes that the user will start thinking about how to go about a task based around the interface the user will be using. Another thing to think about is that every interface, no matter how direct, will require some degree of training and adaptation to use. While it is true that creating an interface that is similar to the way that we would manipulate objects in real life will probably require less training/adapting than one that does not, nearly any interface can emulate the feel of what the author describes as direct manipulation given the right amount of training and getting accustomed to it. Simply taking a look at some of the interfaces we deal with (both on computers and in the real, physical world) is a testament to this. Therefore, it seems that while direct manipulation is an important aspect of interfaces to consider, it is probably ultimately more important to consider that the interface allow for the complete manipulation of all of its objects.
Edward Karuna - Sep 20, 2006 12:38:47 am
The direct manipulation model that the article deals with seems to be based upon the basic ideal of immediate feedback, and lots of it. Every action appears to be required to generate some sort of feedback to the user, thus no action remains mysterious to the user, in terms of result, anyhow. This goal also has the side-effect of both making as much information as possible to the user, but also possibly overwhelming the user with 'too much information' syndrome. Unfortunately, once we have crossed into overwhelming the user, though, we have completely defeated the purpose of the direct manipulation model.
Utsav Shah - Sep 20, 2006 12:45:42 am
Direct Manipulation concept makes sense and seems useful but not today. It talks about how the interface should create a world where all user can see is the object and manipulate it. That's a great idea if you're teaching something to a little kid. Nowadays, in the web 2.0 era, users have some technical knowledge and in my opinion these things are not needed. That also doesn't mean we can have complex interfaces, they still have to be simple and easy to use.
Andrew Tran - Sep 20, 2006 01:44:21 am
Ideally i would like most interfaces to be close to fully semantically direct. I just find it much easier to have mostly everything i want to do with the program to be one click away right in front of me so i can use the program more easily. The authors give the example of the piano, when when you want to hear middle C all you have to do is push down on that key. However, there is a tradeoff to having interfaces be more semantically direct. One example i found would be Adobe Photoshop CS. This program is wonders if you really know how to use it, but its many buttons and screens and toolbars right in front of you is a bit overwhelming. Maybe they should have the option of allowing the users to customize the toolbar to have the tools they would only use.
Direct Manipulation does have its issues. I agree on how interfaces should not be fully direct in some cases, such as when doing something repetitively it is better for the computer to do it rather than having the user waste a lot of time doing it themselves. In my opinion there can never be a perfect interface, there will always be something that people would not like about it.
Kang Chen - Sep 20, 2006 02:13:36 am
Direct manipulation tends to be easier to learn for most beginners. The user gets immediate feedback which helps them learn the consequences on their previous actions and adjust/modify their future behaviors. However, most modern user interfaces for production softwares tend to abuse this. Programs such as Photoshop or Dreamweaver do provide WYSIWYG capabilities which is very helpful when you are trying to use it for learning purposes. For instance, I personally learned HTML by dragging around elements and randomly clicking on icons in Dreamweaver and see how the undlying code changes. Then there comes a point when I've learned enough to not have to rely on this slow and tedious technique. It's at this point that I find the UI to be counter-productive. Whenever I try to do things in the WYSIWYG mode, the final output is always slightly off comparing to my original design or that the code is very poorly generated. Then I am forced to go back to the code editor and make the appropriate adjustments. Wouldn't it be much faster if I had just began my work with the code editor? So then what's the point of having dozens of buttons all over the screen? Not only does it take me extra time to find the right icon corrosponding to the action I am trying to perform but it might not perform what I had in mind.
Of all the softwares I've used so far, I think Mac OS X has the best combination of direct graphical manipulation and text programming. The GUI has very few icons which helps me find the most frequently used action very quickly. It's also armed with several powerful UNIX shells that allows me to create customized actions/scripts to perform more complicated tasks easily.
Rayhan Lal - Sep 20, 2006 03:07:40 am
This is an elegant paper “for a more civilized age.” Back in 1985 computers were mainly used for computation (i.e. performing some sort of mathematical operation on large datasets). Of course there was word processing but editing (and viewing) documents would have been seen as a secondary use of cycles. Direct-manipulation interfaces start to make a little more sense from this perspective. The issue is that there are MANY operations one can use on any given dataset and making them all visible, is difficult if not impossible. One could just use primitive operations but laying down one-hundred of those would get tiring and make whatever diagram you were looking at extraordinarily complicated.
I wanted to address a couple of points others brought up. First of all this article absolutely does not say “direct manipulation interfaces” are an all-purpose answer (see “6. Problems with direct manipulation”). They do, however, eliminate errors because those errors made by the user are errors due to a “lack of knowledge of the task domain.” If addition and subtraction functions are visible and recognizable and what you used is addition when what you needed was subtraction, then you can’t blame the interface. I think watching a process generate output is very useful. Imagine using an algorithm that stops after some function yields a small enough epsilon, watching it reach convergence would give you a good idea that it is doing something and doing it properly.
You simply cannot imagine all the metaphors our generation has acquired from using computers (this is often the reason you can understand things about the computer your grandparents do not). (It would be interesting to see if these schemas are created during some receptive period when one is younger.)
Michael Moeng - Sep 20, 2006 02:18:46 am
I think the major issue with direct manipulation is that while many users would find a more direct interface easier to use and interact with--some may find it cumbersome. Interactions with objects differ between people. Small differences, like being left-handed, or being used to driving on the left side of the road, may cause a "different" user to feel ill at ease when using a very direct interface like the ones described.
Abstract interfaces do not suffer as much from this issue, as an example: left-handed people can type just as well as right-handed people, but might find a regular mouse (which provides pretty direct manipulation) difficult to use.
Tony Yu Tung Lai - Sep 20, 2006 03:52:52 am
After reading about the definition given by the authors in the earlier sections of the paper, I was surprise to find out that automated behaviorin an interface doesn't (always) help close the distance of directness. Although automated behaviors can reduce the user's cognitive effort when performing an individual task, it doesn't help the user in terms of overall performance. It is much more effective to close the directness distance by making the interface easier to learn than having the interface performing steps for the user.
Qingyun Tang - Sep 20, 2006 04:43:04 am
I totally agree with the article with its claim of separating directness into two aspects: distance and engagement. In direct manipulation, one can directly work on the physical material instead of working through an interface to achieve one’s thoughts. On the other hand, there is a qualitative feeling of engagement. With direct manipulation, one could feel that he is totally touching the material he works on, thus becomes more enthusiastic towards the work. So is it worth it to have direct manipulation? The answer is maybe for me, because there is apparently a lot of work in order to achieve the direct manipulation. Those work and effort can be used towards the actual manipulation instead. In this class, the Anoto Pen is like this direct manipulation device. We can digitally input things into computer through physically writing on the paper. However, the uneasiness of processing the writing is a huge problem. Like all other examples such as sketchpads mentioned in the article, Anoto Pen lacks OCR function. OCR is extremely important to many people in order to let them start to use the system. Nevertheless, people do prefer getting instant digital results after writing on a paper than having to draw something with a mouse.
Tabassum Khan - Sep 20, 2006 06:55:55 am
Despite the advancement in technological know how in developed countries like United States, the importance of realtime feedback and intuitive interfaces cannot be ignored. I agree that direct manipulation interfaces might be cumbersome for technology savvy people who live in the web 2.0 era, and I guess in a way the article agrees with it too, but what fraction of the world's population are we talking about. In my opinion, this concept might prove very important in spreading technological knowledge in less developed areas of the world. People for whom computing is still a distant and elusive concept, introduction to the world of computers without a direct manipulation concept might not be well recieved. In India, PC and cell-phone giants are spending a huge amount of money to make their product appealing and usable to the rural population and one of the ways that they are accomplishing this is by making the interfaces as intuitive as possible.
This article shares its concept with the artcle by Norman.
David Eitan Poll - Sep 20, 2006 08:47:08 am
I found the ideas in this paper to be quite fascinating, as they put into words concepts that are easily taken for granted in modern HCI design. I kept thinking to myself how much this describes many of the programs I use on a daily basis. My OS, for example, is primarily a direct manipulation interface composed of files, folders, commands, and the like. But even further than that, it is clear that direct manipulation has made its way into nearly every piece of software that people find useful. It's a common interface element now. For example, what program doesn't take advantage of multiple-item selection and manipulation? There are a few, but I know from experience that they can be terribly frustrating to work with. People have come to expect a minimal level of direct manipulation with their software, even if the software is not at its core a directly manipulated program. I think this has been such a successful concept because it plays well to the way that people process constructed information. When we think of, for example, a document (Word seems like a great example of a Direct Manipulation Interface to me), we're used to thinking of words, images, and formatting. Direct manipulation gives us very direct control over all of these things, providing immediate feedback (seeing how your change affects the document), and working well with the user's sense of what ought to happen when a particular change is made.
Joe Hart - Sep 20, 2006 08:58:56 am
I like the idea that a user can try different operations on a set of data without needing to worry about any permanent changes. This allows the user to "play" around with the data to a) not be afraid of the computer (this was written in 1985), b) better understand the data, and c) arrive at correct solutions to their problems. This article seems to me like the root of object oriented programming techniques. The idea that everything created in a computer can be thought of as an object to be manipulated just as real world objects. Through this metaphorical mapping the human operator can suspend belief just enough to more naturally interact with the computer.
Interestingly the author even went as far to put down some problems to the direct manipulation interface. Some things the user doesn't want to directly manipulate such as repetive tasks. It also points out that through a metaphorical mapping from the real world domain to the computer domain we might get trapped thinking too narrowly when interacting with a computer and miss out on new ways of thinking. I agree with these possible pitfalls and also think that UI's should allow for easy understanding while at the same time push the envelope of the metaphor.
Yen Pai - Sep 20, 2006 09:44:46 am
The author was indeed prophetic, especially about the limitations of WYSIWG programming interfaces. I liked the articulation of the theory of direct interfaces, a concept that is familiar today but is more taken for granted than understood as an academic topic. Reading the article, I was reminded of the early days of the Web, when there would be shopping (failed) Web sites that tried to model themselves after a real shopping mall or plaza, allowing the user to "walk" down a row of stores: clear examples of taking the conceptual model too literally, or is that all too easy to say today? The use of language and conversation as a metaphor for user/computer interaction was a good one and allowed the authors' to articulate the core interface problems (also problems in regular human communication): the ability to correctly state intention and to comprehend the other's reaction (feedback). But the most interesting part of the paper dealt with warnings about the potential disadvantages of direct interfaces, specifically the one about not taking advantage of new technologies in order to replicate existing conceptual models and/or behaviors.
Ming Huang - Sep 20, 2006 10:19:13 am
Relating to today's state of computer graphical user interfaces, I could not help but to applaud the insight shown by HCI researchers shown in this article, back in a time computers were relatively limited in processing power and a graphical UI is not necessarily doable on any machine.
Today much of our GUIs adhere to the paradigms of direct interaction. Criticism aside, the new version of Windows Vista has its windows the appearance of pieces of rough glass, which fades, but does not totally obscure, objects behind it. This is done in order to adhere to the metaphor of the windows brand name. Much of the icons, animations, and placements of dialogs are designed to convey their purpose besides the text labels, so that a user who may not be very proficient in the labels' language can make better guess work as to what the objects do. Interestingly enough, today's GUI's seem to use a hybrid of the model-world metaphor and conversation metaphor in their design: while objects like icons and windows are placed in a world space where they can me manipulated directly with the mouse and keyboard, informational messages pop up from time to time in dialog boxes to get users attention and tell them in their language, what has happened.
On that note, what we are doing as designers in general is to conserve cognitive resources and spend them on better things, like trying to accomplish the user's intended task. In fact, all tools are supposed to minimize the mental effort the user put into learning how to use it, In some cases this is hard to do, however, such as in a 3D modeling or CAD drawing toolkit. They categorize the myriad of functions into reachable places that are not immediately obvious to the user. So this UI design process can be seen as a trade-off between the urge of the designer to put more convenient features in and the will of the user to demand more direct, intuitive designs.
Johnathan Hawley - Sep 20, 2006 10:57:38 am
Direct Manipulation Interfaces - I thought this concept was interesting which states "The frequent use of even a poorly designed interface can sometimes result in a feeling of directness like that produced by a semantically direct interface." I think this is a key concept that separates Engineers and Computer Science people from the general public. Using vim on Unix is an example. I saw one cs student once fly through that interface like it was the easiest thing in the world. I still find it terribly difficult to navigate. Even things like word processors fall into this category. I've typed papers on the word processor my whole life and I think it is rather straight forward. But I've noticed older generation who try to use them have a very difficult time. I suppose practice just goes with the territory with all technology.
Kimberly Lau - Sep 20, 2006 11:32:16 am
I think using the concept of direct manipulation in any design is very powerful. With any program that I have used, those which mimic the actions I am actually performing are always the easiest to learn, to use, and to teach. For instance, the two 3D computer-aided modeling programs I have used most often here in school: ProE and Solidworks. Both are useful, but one noticeable difference is that Solidworks provides icons that depict its functionalities more clearly -- extrude, cut, draw, etc, whereas ProE sometimes requires certain (seemingly unnecessary) paths to execute those same functions. As such, students often prefer to use Solidworks over ProE. Likewise for coding, I can have a fair amount of trouble writing code, especially when the written code does not reflect that action I want to perform. There is no way for me to intuit what I want unless I already know the code itself.
The Sketchpad mentioned as one of the first examples of direct manipulation strikes me as interesting. Today, new products are being produced that still use those same ideas. Pixar recently developed a new tool that allows animators to draw right onto the screen of a playing movie during editing.
Jae Chang - Sep 20, 2006 11:41:50 am
Direct Manipulation Interfaces – Direct manipulation is a very interesting concept and widely used in nowadays. By dividing dimensions of distance from user goals and degree of engagement form a space of interfaces, author located exactly where direct manipulation is and stressed the importance of such interface. For an interface as conversation, low-level language has large distance from user goals when high-level language has small distance. Similarly, for interface as model world, the direct manipulation is much closed to user goals when low-level world has great distance from user goals. The tradeoff of the direct manipulation is that such interfaces have difficulty handing variables and less accuracy.
Because direct manipulation provides friendly graphical interface, less experienced users may have easy way to learn and use such applications. However, when users often used such application, users may want to extend its functionality but direct manipulation has limitation of extensibility; UNIX consoles have many powerful and extensible features by using pipe than explorer. Even if the direct manipulation interface has many advantages, deciding which application is needed to use such interface should be the most crucial task for software designers.
Charles Lee - Sep 20, 2006 11:33:03 am
Direct manipulation is indeed an ideal interface for the user, but in some circumstances, it may be complicated to implement. Potential complications for the 3 properties for direct manipulation are:
- Continuous representation of the object of interest - It can be complicated to switch the object of interest in some way that allows for a graceful return after the user is finished with the current object of interest. At that point, what is the user presented with? Giving the last-used object is not always the right answer, one example being when the user is browsing the leaves of a mental hierarchy, and wants to go up one level to a table of contents of sorts.
- Physical actions or labeled button presses instead of complex syntax - If many functions or options are available, then the space each of these buttons requires can add up to a cluttered mess.
- Rapid incremental reversible operations whose impact on the object of interest is immediately visible - An "undo" button for reversibility can be complicated for some applications, such as networked collaborative programs (situation similar to CVS).
Michael Mai - Sep 20, 2006 02:57:54 am
Direct Manipulation Interfaces
The article's conception and separation of distance and engagement was well thought out and very agreeable. Currently, I believe that distance will become and always will be the bigger issue to handle for designers. In terms of direct engagement, the major area of concern was feedback time. With the increased power in computer processing as well as other areas, the feedback issues are becoming less and less of a concern and the ability to maintain the illusion will be easier.
Sung Yi - Sep 20, 2006 11:49:06 am
I think the concept of making the UIs so to remind the users of the task it is designed for is still required nowadays. From my personal experience on the open and close button on the elevator, the users would feel much comfortable from such intuitive signs as open and close arrows, rather than "open" and "close" signs as words, because it would take more time for the users to read the words and recognize what it means than just to recognize symbols. Also, sometimes the users will feel certain UIs are intuitive from the frequent use of them. An example of this would be the difference between using emacs and microsoft visual studio. Some UC Berkeley students might feel emacs is easy to use after memorizing all the shortcut keys, which they have to take some time to learn. However, beginners feel more comfortable using microsoft visual studio than using emacs.
Chen Chang - Sep 20, 2006 11:40:46 am
I like the concept of direct manipulation interfaces and think its very practical in reality. Like the author stated, some advantages are that all programming is done graphically so there is no syntax nor hidden functions to learn about and no abstract computational medium necessary. This is excellent for beginners trying to take a crack at something new but aren't exactly savvy with knowledge, as they can pick up on the basics immediately. At the same time, experts and ones with more knowledge can carry on with their usual tasks in an efficient fashion whether it be adding new functionality or features. Also, the reading mentioned lisp and unix as two highly customizable platforms so at times it may be a burden of maintaining such a large system as the user base constantly adds support to it. I completely agree with this statement as its not hard to do a google search to find the number of open source projects available for *nix so it could be stressful to figure out your personal needs and customize accordingly.
Vijay Rudraraju - Sep 20, 2006 12:09:26 pm
I am a physics major and as such I took Physics 111, which is one of the major laboratory classes for physics majors about basic semiconductor circuits. Our primary software tool in the class is LabView, which implements a direct manipulation user interface almost identical to the one proposed by the article in figure 1. Complex signal analysis programs are created by manipulating modules, which represent almost any tranformation or display that a physicist would want when dealing with signals, and metaphorically wiring the modules up in various ways. This creates a very high-level direct manipulation programming language that is obviously very limiting for general applications. However, because the program is developed for a very specific application and user group I think it is a well-done implementation of the ideas presented in the article. I recommend that students try the application out if they come across a system with the program installed.
Heung Tai - Sep 20, 2006 12:15:23 pm
I think the distance metaphor is the subset of engage. Why do we think different step is short distance? Because our instinct tell us that they are somehow related very closely. If we have this instinct, that means we are engaged. Engage is very important, because it's about how human being percept the manipulation of data; hence, it's about user friendliness.
Randy Hilarbo - Sep 20, 2006 12:13:27 pm
I think that direct manipulation is a very important concept, in which a lot of good UI right now can be rooted from. The idea of how much you want to bridge the "gulf of execution" and the "gulf of evaluation" can really affect the effectiveness of the interface that you are designing. Having a really close distance between the users' intentions and the physical system is really important especially if you only worry about having your users think about what they want to do rather than how they can manipulate the system to do it. Likewise, having a sense of engagement between the user and the objects s/he is manipulating constitutes a good interface. However, I also agree with the other posts that while direct manipulation puts an ease to the end user, it may also limit what they could do with the system.
Suthee Chaidaroon - Sep 20, 2006 12:29:25 pm
The important point in this article is to make sure the interface is very intuitive, user-friendly, and visualization as it suggested in a term of direct manipulation. Today software applications really follow in this direction as we can see they are turning into heavy-weight user interface application. The concept of directness is powerful: it describes the traslation from user's thought or desire into system's tasks; it concerns with the feeling the one is directly manipulating the objects of interests. As I can see from their example of graph plotting software, the program tried to minimize the number of operations user need to input, while it provides a small feedback. It is also interesting to see how they tried to developed the conceptual idea of user-computer interaction in the old date. The language processsing today is much more sophisciated than in the past, so that programmers can spend less time on coding. I think this is a sign that we are heading forward to this article's idea.
Julius Cheng - Sep 20, 2006 12:25:06 pm
Ease of use through direct manipulation interfaces is, like the concluding paragraph of the reading states, not a cure-all solution for user interfaces. Expert users, users who have crossed the semantic gulf, strive for efficiency over intuitivity of use, and thus don't demand direct manipulation as much. I found the reading to be sort of boring because it was information I already came about from using designed interfaces all my life, but it's nice to have catchphrases like the "gulf of execution." I wish that the reading would have expounded on the tradeoffs between direct manipulation and non-intuitive, indirect, but fast manipulation, because that seems like one of the most interesting questions in UI study. How much do you tailor your design to make learning easy for novice users, and how much functionality to you provide for experts, or if you try to do both, how can you ease the transition from being a novice user to an expert user?
Direct manipulation seems to be the standard now, but what about the guys who still use UNIX or play text-based games online (MUDs, they're called?).
Roland Carlos - Sep 20, 2006 12:29:23 pm
The article made it seem like most of the success tied to a Direct Manipulation interface is based on how "natural" it seems (or rather, how much the result of a user's action lines up with their expectation...if we move the mouse to the left, we want the pointer to go to the left for example). But this makes a lot of sense. In one our previous readings, we saw first hand what happens when something doesn't work as expected. One person found that their glass door was working as expected and found themselves trapped.
I've even recently had an experience with a Direct Manipulation interface going against my own expectations. I was recently given a Mac to play around with, but being a lifelong PC user, I had little experience with the Mac. Therefore, I was constantly griping about the lack of a "right-click", no start menu, and not knowing where to go to find my documents. While that interface is great for most people, for me, it went against my expectations in a PC environment and found getting around the Mac difficult. In my head, I had created an expectation that all computers like Windows, but obviously, this not the case.
The article also has an interesting idea of "Automated Behavior Not Reducing Semantic Distance". This basically means that a bad interface is still a bad interface, even if users seem to be working fine with it. Imagine somehow that some users have gotten ahold of some bad interface, but still decide to use it. Eventually, over time, with repetition, they will be able to work efficiently in that interface, but this process is only due to a person's natural ability to adapt to things given time and practice. Any new users that are introduced to this interface will still be subject to same the problems with the interface. Therefore, this limits future marketability and use for the interface.
In the end, it all comes down to what people are used to. Like for me, I'm used to PCs and will probably decry the "lack of functionality" for Macs, but the opposite opinion is just as strong.
Of course, Emacs will always be a terrible editor, no matter what any Berkeley student will say.
Sean Carr - Sep 20, 2006 11:42:16 am
These principles/virtues for design are very good. That causes me to wonder why, over 20 years after being proposed, do we still see a multitude of badly designed interfaces? It is because designing for all of these virtues is difficult, takes a long time, and therefore is costly. Designing an inerface which is simple enough for novice users and yet incorporates advanced features and the ability to define new functions and features is doable, but requires a lot of developement beyond what many software budgets and time schedules allow. Yes I know there are companies like Microsoft and Google who have vast resources and are able to develop such interfaces if they choose, but they don't always do this. Part of the reason for this is probably because they don't have to since they are still able to succeed and get market share without doing so because other competitors don't have these interfaces either. I think using direct manipulation virtues is catching on more now on the web since there are so many products out there that do the same thing that UI details and usability become the differentiator.
Siyan Wang - Sep 20, 2006 12:43:37 pm
The ideas outlined in this article seem pretty close to what we have discussed about the metaphors users develop when interfacing with some design. The detail it goes into about bridging the semantic and articulatory gaps seems a bit more intuitive than what we've already discussed. However, this paper is 20 years old and it seems that many more interfaces would be designed this way. Things are much better than they were then with mostly console-driven interfaces, but some there are some interfaces that seem very backwards.
Michael Udaltsov - Sep 20, 2006 12:49:03 pm
I find it interesting that even though the current computer GUIs allow for much easier direct manipulation (for example file management, drawing, typing, and even video games), there are still many problems with the interfaces. One of the issues is handling complicated series of tasks, or repetitive operations, which as the article mentions, is "probably best done via a script, through a symbolic description of the tasks..." instead of direct manipulation. For example, it's still difficult to automatically rename a series of files using most GUI-based approaches. Using the command-line it's faster, but only for someone with prior experience. Also, a lot of the time even simple tasks that are allowed by an application are difficult to do simply because the interface is badly designed - for example accessing hidden options or elements that don't correspond to the functions they perform. As explained in the article, repeated use of such an interface may give an illusion of directness, simply because of remembered actions. But this doesn't address the issue of semantic distance - the task is still not doable directly. This is an issue in many operating systems and applications. With thousands of actions available, and limited screen area (as well as design and simplicity considerations), many of those actions end up hidden in menus, additional windows, panels, etc. One such example is Microsoft Office - there is a lot of functionality, and while there have been attempts at only showing most common or relevant options at one time, there is always some option missing that takes a lot of time to find. One solution to this problem could be to simplify the various complicated programs that we use, but I think the real solution would be to develop a better interface since the current model doesn't fit the requirements very well.
Jonathan Chang - Sep 20, 2006 12:48:38 pm
This concept seems to be in line with, or even a superset of, the idea Anoto has of using pens rather than the more "traditional" user interface devices. The idea is to adapt technology to fit intuition, not adapt human behavior to fit arbitrary technology. For all the same reasons listed in the article (e.g. easier learning curve, usability, etc.) this makes the human-friendly device a much more attractive option in new applications. Additionally, this will result in a more unified approach to the devices we see around us, rather than the current hodgepodge where anyone that wants to be proficient in many things must learn many methods of interaction.
Siu Pang Chu - Sep 20, 2006 12:43:32 pm
Direct Manipulation Interfaces is a human-computer interaction style that was defined by Ben Shneiderman and which involves continuous representation of objects of interest, and rapid, reversible, incremental actions and feedback. The goal of this idea is to give more freedom to the user, so that the user can directly manipulate the objects as they wanted. The user can do those actions as similar as the physical world. Having a real world like operation can make it easier for a user to learn and use an interface. Since the interface like a real object, the user can giving rapid feedback and completing the task more quickly. There area still problems with Direct Manipulation Interfaces, it have both virtues and vices. And it have difficult handling variables, and accuracy.
Aleksandr (Sasha) Ashpis - Sep 20, 2006 01:00:00 pm
It is definitely a good point that direct manipulation are powerful and easier to use then lets say command line, but they do still have the draw back of that a novice wont inherently know how to use if, unless taught some minimal basics. Semantics of language, whether it be a computer language or a human language, like English, are crucial, and the better designers bridge the gap between human and machine, aka make it easier for the average Joe to interact with the computer the easier and more cost effective it would on everybody. For example, if something goes wrong, most people call tech support, which costs them time and the company money due staffing and infrastructure of the tech support, if user were given tools to resolve problems themselves, they could probably do it faster, and next will not call, because I’m a firm believer in if you do it yourself you will most likely remember. This would result in less calls to tech support and thus saving time and money for all. All this can be achieved with better support interfaces on PC’s.
Dexter Lau - Sep 20, 2006 12:04:01 pm
I tend to relate the message of this article to the mouse click wheel. The only reason there is the *click* is for the feel how far you moved; it creates a metric for virtual, on-screen navigation. Doing this direct manipulation provides the real-time feedback that every user needs. It's like trying to type on a computer without a monitor.
Eric Vacca - Sep 20, 2006 12:41:17 pm
Hunchins gives a very well thought out and orginized presentation of the affordances of both direct and symantic input to a computer. They are both invariably related in that one cannot exist without the other. I think which concept to use to manipulate a computer in the current state of computers only has to do with the user wants and needs. Because new interfaces and technologies are coming out and a increased pace, the use of direct interfaces will become increasingly important, not only for the novice, but for the expert.
I see it as a way to seperate the user from the designer. Many CS majors go back and forth, which complicates the issue. My father recently changed jobs, and is happily taking on new languages knowing that staying current with advances is key to staying employed. He has autmoated the process of learning all the low level symantec languages, and thus can relearn everything he knows much faster. Where as when he is showing me something on a windows computer, i can't help thinking to myself, how is this guy a software engineer (due to his slow interactions). Because i was brought up on visual direct interfaces, i adapt to these visual direct interfaces much as he adapts to syntactical interfaces using the conversational model. Its a difficult situation, because my mind works visually, not because that is an inherent property of my brain, but because that is what i'm used to. The feeling I get is that it is a generational gap for computer users. When MORE direct interfaces come out that utilize motion, i'm sure our children will find them intuitive, but in our old age, we will find using GUI's is much more intuitive.
Tom McClure - Sep 20, 2006 01:15:13 pm
I really like the choice of the term "gulf" to describe the gaps in execution and evaluation that need to be bridged/crossed. The choice of an applicable frame, or metaphor is itself so key to the success or failure of every HCI. It was interesting to see that despite the ubiquity of GUI today v. at the time the article was written, the ideas behind better HCI outlined are still very much applicable today (where, even in the world of GUIs, there is still a significant gulf of execution/evaluation).
Leo Chen - Sep 20, 2006 01:18:42 pm
A GUI is a level of abstraction that makes things easier for a user. Even though it's a level of abstraction it may allow users to understand the system even better, so in a sense bringing the user closer and shortening the "Gulf of evaluation".
It's easy for the user when the conceptual model is closely related to what the actual action is. For example, dragging and dropping a file into the recycle bin is intuitive.
Andrew Hao - Sep 20, 2006 01:50:10 pm
Hutchins, Hollins and Norman make the point that the higher-level and more specialized the GUI is, the more complex it becomes as more layers accumulate (a la Lisp and its derivations). Where does the balance lay between functionality and simplicity? For example, UNIX/Linux is controllable via the BASH shell and also via the GNOME window manager. Certainly, the GNOME interface is much simpler and affords many more complicated operations but good Lord, it runs like a sloth. This is where lightweight window managers step in (a personal favorite is XFCE), striking a balance between functionality and simplicity.
Simon Tan - Sep 25, 2006 12:57:41 pm
Comment 1: Robert makes a good point that many actions by command line are much easier for experts to do, but completely confounding for novices. Yes, the direct manipulation interface of files, folders, and icons are useful and easy to grasp, but they only get in the way when it comes to mass file management or more complex tasks like setting permissions. Which is better? It really depends on the user, and I believe this is a case of knowing who your target user is and tailoring a solution specific for them. Operating systems usually have both CLIs and a friendly GUI to accomodate both the advanced and novice crowd.
Comment 2: With lines like "Direct manipulation interfaces are not a panacea" and "It is important not to equate directness with ease of use", I am realizing that there is no such thing as the perfect interface. The direct manipulation interface (as exemplified by the graph example) seemed like nothing could be more intuitive; however, it stands to reason that someone who never experienced anything like the graph example would be dumbfounded as to how to work it when presented with it. In that sense, no matter what the interface, training in the task domain is needed.
Eric Yoon - Sep 25, 2006 06:15:13 pm
It's an interesting article, in that it clarifies the goals of interface design in intriguing ways. I liked how the article based an assessment of the effectiveness of the design on how much cognitive effort is employed in figuring the interface out. The concepts, "gulf of evaluation" and "gulf of execution," are interesting ways to break that approach down further.
Although at first glance it would seem that many tasks are not amenable to a direct manipulation approach, more opportunities may exist than one would expect. The organization of computer files into folders and the concept of "drag and drop" is a clever one that utilizes the analog of paper folders and trash cans. Techies who love UNIX-esque interfaces may have never imagined such an approach; but people need analogies to every day life to grapple with and understand new concepts and tools.
CharlesLeung - Sep 27, 2006 11:08:38 am
1) Using higher-level languages to bridge the gap between the intentions of the user and the specifications required by the computer is a very important concept. Users will feel much more comfortable and be more likely to use a product if they can communicate in the same language that the task-domain usually uses. If a user has to learn how to communicate in a new, low-level way in order to communicate his intentions and desires, then it will be just another barrier for the product to be adopted.
2) Another way to bridge the gap is that the user can adapt to the system representation. Although this sounds very reasonable, I think that the designer of a product should not depend on the user having to adapt for a new system representation too much. Unless the new system representation is vastly better than the previous one, or that the product is something that must be used, I don't think that the designers should count on potential users to change their habits. Of course, the authors are right in saying that this is obviously a balancing act between the new (hopefully better) system representation and the cost of making the users change their habits. I think that it can be very easy for designers to falsely assume that users would be open-minded about learning new things.
Bryce Lee - Sep 27, 2006 12:41:00 pm
I do not wholly agree with Hollan and Norman's presented advantages of a direct manipulation system. The rift between presentation and meaning does not necessarily exist from the computer presentation level. They give the example of plotting on a graph; however, the acquisition of data itself was an indirect acquistion, as the captured information is in itself another representation. Additionally, they state that direct manipulation would provide an easier learning curve for individuals familiar with the domain. This assumes there are running trends behind the methodology. The communication between individuals in a domain comes through uniformity in presentation of data, not in the methods to create it.
The gulf of execution and evaluation is a common issue with many user interfaces currently implemented. The adoption of real-life metaphors have given users a certain assumption about the result of certain actions, despite difference in the underlying operation. For example, moving around icons with certain keys held produces result different from the perceived movement. However, this issue has a diminishing impairment on the user. Here, habit builds a sense of understanding which helps reduce this distance over time.
Anton Mikhailov - Sep 27, 2006 01:41:08 pm
I was particulary interested by the quote "Users have reduced anxiety because the system is comprehensible and because actions are so easily reversible." This struck me very interesting because of its simplicity. Many times I've knocked an interface because you get stuck in a state because of a mistake. During the learning process, I find that I learn best by poking around and seeing what stuff does, rather than reading manuals and applying structured examples. Understandably, this is not always possible (in a case of operating a plane for example), but surely on something as virtual as a computer you should not have much fewer of these cases. Because of this, we can easily facilitate the user with a "pokable" interface where they can comfortably learn by playing around with your program.
This is also related to the concept of distance discussed in 2.1. An interface that is not reversible has a sort of virtual distance increase, because the user may feel close in progressing forward but infinitely far away from the reverse controls. Because of this, the whole feel breaks down. It is also worth noting that even one of these events is enough to mess up the whole feel.
Robin Franco - Dec 15, 2006 11:46:08 am
Comment 1: The idea of reducing the “gulf of execution” is a good one but at times we can only reduce this distance by so much. From reading the wikipedia article on it, one good example is recording a show on the VCR. One would like to simply be able to press the record button. But the system needs more information, such as the channel and time. We could improve this by guessing the program one will want to record (based on preferences) but this will never be 100% correct, which leads to frustration. So no matter how hard we try, we will still need a few extra steps in the process.
Comment 2: We also has to take into account how efficient a very “directly manipulated” system can be. It might be nice to be able to immediately see my changes on the screen, but at what cost? If it vastly slows down the entire system, I would much rather see incremental changes. And at what point do “immediate changes” start to appear as “incremental changes”? All this would have to be taken into account when deciding the level of interactivity afforded by a new interface.
