Conceptual Models

From CS160 Spring 2014
Jump to: navigation, search

Readings

  • Direct Manipulation Interfaces. User Centered System Design. Chapter 5. Hutchins, Hollan & Norman. Read Sections 1 and 2 only. (You'll read the rest for Wednesday).

Featured Responses

Emily Sheng - 2/10/2014 15:35:17

A direct manipulation interface is a term that describes a system with three specific properties. One property is that there is a "continuous representation of the object of interest." In other words, the user should be able to see the visual representations of the data he is working with at all times. Another property is that the user should be able to perform "physical actions or labeled button presses instead of [using] complex syntax." All necessary actions can be learned by copying an expert or by similarity to familiar actions in everyday life, and there are no hidden syntax rules. The third property is that operations that can be incremented/reversed should be "immediately visible" for instantaneous feedback.

Although direct manipulation interfaces may allow users to feel as if they were really manipulating the things being represented, this type of interface may become tedious to interact with. For example, in class we saw the example of how a person's desktop was literally arranged as if it were a real 3D desk. The files were not displayed in a list, but rather as a stack of physical files which you could flip through. While this direct manipulation interface is intuitive to the users (in the sense that it is similar to physical files which they have presumably encountered), it also carries the problem in the physical world of being unable to quickly find a file. Here is an example where the technological interface has tried to assimilate too much to that of the physical world and has also inadvertently brought up the same problems we face in the physical world.

Another point is that although direct manipulation interfaces may be better for novices, experts or those who must perform the same manipulations many times over different sets of data may find direct manipulation slow. By resorting to direct manipulation interfaces, we are ignoring the ability of machines to perform batch tasks and the ability to do them quickly and efficiently.

Luke Song - 2/9/2014 13:38:22

A direct manipulation interface is a human-machine interface that allows the user to immediately observe the effects of the actions that the user performs through the interface. For example, instead of manipulating the text in XML files to adjust the layout of an android application under construction, the user can use a direct manipulation interface to position each component using a mouse while the XML files are changed automatically to reflect the user's modifications.

However, there are trade-offs when creating a direct interface. When users can directly manipulate objects, they feel as though the objects they see are the objects in reality. Of course, we know that they're only representations of those objects through the current program instead. This may have subtle effects such as hiding functionality of the objects from the user and limiting the versatility of the actions the user can perform. In addition, a graphical user interface may require the user to take more time for long, repetitive tasks than a more direct one. We've all seen presenters of PowerPoint presentations try to resize the window manually or click "slideshow" from the drop-down menu when we know that there exist quick shortcuts for each. Although it is possible to write macros that manipulate the mouse, it is far easier and more versatile to write macros for text-based interaction to reduce the strain of repetition.

Ryan Yu - 2/8/2014 18:53:45

A direct manipulation interface is essentially a human-computer interaction (HCI) system that has a number of unique properties. These properties include continuous representation (visually) of the object/s of interest, a lack of complicated syntax in favor of visual widgets/buttons, and widely reversible actions, that, when reversed, are immediately seen to be rolled back to the user. A good example of direct manipulation is resizing a shape on the screen, such as dragging the corners of a pentagon to distort its shape.

Although direct manipulation interfaces give users immediate feedback and make many tasks easy with its "natural translation of intentions to actions", these interfaces actually complicate many tasks for users. In this sense, not *everything* should be done directly via direct manipulation. For instance, the article mentions that "a repetitive operation is probably best done via a script." (In this particular case, it would be much preferable to write some actual code that automates the function you are trying to achieve -- writing this with code makes your functionality more precise.) In this sense, direct manipulation interfaces "have difficulty handling variables, or distinguishing the depiction of an individual element from a representation of a set or class of elements."

Furthermore, direct manipulation may be problematic for users simply because direct manipulation on-screen may be less accurate than writing what you want to achieve in code. Let's take the shape-resizing example again -- if you just want to resize a pentagon to fit within another container, then maybe direct manipulation is fine. But let's say you want to resize your pentagon to fit *exactly* within the confines of another pentagon -- then, perhaps writing some more precise code to resize your inner pentagon is the preferred way to go. Easy of use, associated with direct manipulation, may not always be a good thing as well. If users don't really need too much knowledge to manipulate objects in the system with direct manipulation, then this could prevent them from actually understanding the system, and understanding the underlying logic behind it. This could obviously cause problems down the road if the user needs to implement something related that is *not* embedded in a direct manipulation interface. In this sense, sometimes it may be better for the user (especially a developer) to dig deeper into the structure and the framework of a service to better understand how it works.


Responses

Ryan Yu - 2/8/2014 18:53:45

A direct manipulation interface is essentially a human-computer interaction (HCI) system that has a number of unique properties. These properties include continuous representation (visually) of the object/s of interest, a lack of complicated syntax in favor of visual widgets/buttons, and widely reversible actions, that, when reversed, are immediately seen to be rolled back to the user. A good example of direct manipulation is resizing a shape on the screen, such as dragging the corners of a pentagon to distort its shape.

Although direct manipulation interfaces give users immediate feedback and make many tasks easy with its "natural translation of intentions to actions", these interfaces actually complicate many tasks for users. In this sense, not *everything* should be done directly via direct manipulation. For instance, the article mentions that "a repetitive operation is probably best done via a script." (In this particular case, it would be much preferable to write some actual code that automates the function you are trying to achieve -- writing this with code makes your functionality more precise.) In this sense, direct manipulation interfaces "have difficulty handling variables, or distinguishing the depiction of an individual element from a representation of a set or class of elements."

Furthermore, direct manipulation may be problematic for users simply because direct manipulation on-screen may be less accurate than writing what you want to achieve in code. Let's take the shape-resizing example again -- if you just want to resize a pentagon to fit within another container, then maybe direct manipulation is fine. But let's say you want to resize your pentagon to fit *exactly* within the confines of another pentagon -- then, perhaps writing some more precise code to resize your inner pentagon is the preferred way to go. Easy of use, associated with direct manipulation, may not always be a good thing as well. If users don't really need too much knowledge to manipulate objects in the system with direct manipulation, then this could prevent them from actually understanding the system, and understanding the underlying logic behind it. This could obviously cause problems down the road if the user needs to implement something related that is *not* embedded in a direct manipulation interface. In this sense, sometimes it may be better for the user (especially a developer) to dig deeper into the structure and the framework of a service to better understand how it works.


Hao-Wei Lin - 2/8/2014 21:32:47

Direct Manipulation Interface is an interface on which the users interact with representations(e.g. a folder on your desktop) that are part of the interface while having the perception (whether actually accurate or not) that they are directly manipulating the underlying structure (i.e. code structure) by manipulating the representations of these structures. An example is the sketchpad designed by Sutherland. The user would use a pen device to draw lines on a screen as if drawing on a sketchbook. This interface uses direct manipulation to make the representation (drawing line with a pen) a mirrored reflection of the underlying structure (a program that draw line) so that it’s clear to the user that what he/she is manipulating is the underlying structure of the code. In cases like this, an output expression (the line on the screen) serves as a component of the input expression (drawing and connecting it on the screen), which would gives the users feeling of directly manipulating the representations on the screen. This interface is beneficial because, for the user, he/she can understand the basic functionality quicker, and for the developer, it is easier to define new functions and features because these functions can just be add-on features on the interface as well.

A possible problematic aspect of Direct Manipulation Interface I can think of is that the user might overlook the functionality of an interface where the representations fail to represent. For instance, a folder we have on our desktop is a representation of a directory. While to normal users it is clear that the function of a folder is to store files (just like how a real-life folder store documents, picture, and what not), it might be unclear to the user that you can also lock your folder (because it is not intuitive in real life that you can lock a physical folder on its own). Basically, there might be parts of the functionality that the Direct Manipulation interface cannot fully encompass in its representations.

Another issue that the users may encounter is that the representations may not be self-explanatory (either because of bad design, or the nature of the object being represented), and would require extra learning for them to know how to manipulate the representation. An example is the plug-in in a laptop, which in some cases it is represented as a Lego piece. For users who have limited computer knowledge (say, my grandparents), it is not intuitive to them what the plug-in meant ( as there is nowhere you can plug those plug-ins into) and what you can do with them without learning about the functionality of it.


Andrew Fang - 2/8/2014 23:12:59

A direct manipulation interface is a venue through which users can interact with systems in an intuitive manner with a gentle learning curve, and where objects in the system are represented as relatable objects. Often, a large amount of processing power is required to generate a direct interface, so this can be taxing on the fluidity of the program, the battery life of the device, as well as the deteriorated functionality of other programs on the device (due to reduced allocation of system resources) that the user may need. Programs that take a lot of computation, a lot of rendering, are just inherently going to run slower. So no matter how well the interface represents real world objects, no matter how easy it is to learn how to use, if the system lags and delays, the the user will be frustrated. If use of the interface takes a hit on battery life, the user will be unhappy and will likely spend less time operating through the interface, because she would rather have a functioning device than one without power. If the use of a direct manipulation interface decreases the functionality of other applications, it could be quite burdensome to the user, especially if they rely heavily on those other applications. All in all, while direct manipulation interfaces can be extremely useful, they can sometimes be problematic to the user.


Zack Mayeda - 2/9/2014 11:34:31

The goal of direct manipulation is to provide an interface that performs the same effects and has the same feel as the objects / files being represented. This is accomplished by using actions like dragging or clicking and labeled buttons in place of complicated steps, numerous quick and reversible actions used to manipulate objects, and the constant presence of the final product which immediately updates in response to user input.

These types of interfaces may be a burden for users if all interfaces they use differ somewhat in the actions that are possible and the way in which those actions are accomplished. For example, many computer applications may not have direct manipulation interfaces, but they often share common interface components such as File, Edit, and View menus. These shared interface elements make it easier for the user learn a new application. While direct manipulation interfaces can make it easier to learn a single application, it may be a burden to a user to learn a new interface for each new application they try, even if the interface has a feeling of directness.


Ziran Shang - 2/9/2014 18:33:53

A direct manipulation interface uses buttons and physical actions, along with a continuous representation of an object of interest in a way such that any actions performed by the user show an immediate impact on the object, and are reversible. An example of such an interface is a graph program with buttons representing various functions, which can be connected when used.

Direct interfaces can be problematic in a few ways. First off, they may not be good for small screens since there will be less space to work with, and a lot of buttons could take up valuable space needed for manipulating data. If there are many buttons and they are not organized in a logical way it could be difficult for new users to find the button they are looking for quickly. Also, experienced users may find key shortcuts or other methods faster to use.


Luke Song - 2/9/2014 13:38:22

A direct manipulation interface is a human-machine interface that allows the user to immediately observe the effects of the actions that the user performs through the interface. For example, instead of manipulating the text in XML files to adjust the layout of an android application under construction, the user can use a direct manipulation interface to position each component using a mouse while the XML files are changed automatically to reflect the user's modifications.

However, there are trade-offs when creating a direct interface. When users can directly manipulate objects, they feel as though the objects they see are the objects in reality. Of course, we know that they're only representations of those objects through the current program instead. This may have subtle effects such as hiding functionality of the objects from the user and limiting the versatility of the actions the user can perform. In addition, a graphical user interface may require the user to take more time for long, repetitive tasks than a more direct one. We've all seen presenters of PowerPoint presentations try to resize the window manually or click "slideshow" from the drop-down menu when we know that there exist quick shortcuts for each. Although it is possible to write macros that manipulate the mouse, it is far easier and more versatile to write macros for text-based interaction to reduce the strain of repetition.


Michelle Nguyen - 2/9/2014 15:53:55

A direct manipulation interface is an interface which allows users to interact with representations of the objects they are working with in ways as if they were physically engaging with that object. For instance, the article uses the example of how files are displayed on a PC. The icons for the files are not the actual files themselves, but representations for the files. When a user drags the file's icon to their trash, it gives them the feeling that they are physically putting that object into the trash. Another example is how a user resizes their image, such as in a paint program or in a word document. By dragging the corners of the image, the user is given the impression of control where they are directly interacting with their picture.

However, although a direct manipulation interface may be easier for users to learn, there are also some cons to this form of interface. For instance, a direct manipulation interface may be more time consuming for a user (especially one who may be more experienced with technology). Returning to the example of dragging files to delete them, it takes time for a user to drag the file's icon to the trash. Without using the direct manipulation interface, it takes much less time to simply right-click and delete, or type "rm ___" in the command line. Or, say a user is trying to resize a picture and knows exactly what dimensions they want their picture to be. Trying to achieve these exact dimensions with direct manipulation by dragging and stretching the image will take much longer than simply entering the height and widths they want. Thus, in order to provide a direct manipulation interface, the program requires the user to do more than necessary for the sake of feeling as if they are engaging physically with their object. This may be a burden when actions can actually be done in quicker, simpler ways. Another problem may be that not all users may understand the analogies that the direct manipulation interface relies on. What if a user has grown up in a culture where they have never used a trash can before (unlikely, I know)? Dragging that file icon to the trash may not make sense for them as it does for others. It is hard to determine what makes sense for everyone and whether or not that interface will be of any help to them. The direct manipulation interface will only be beneficial for those who can understand it, and an unnecessary burden to those who do not. Also, for some actions, there may not be a good way to provide a clear metaphor that can allow the user to act with that object in a natural way. Any attempt to force the action to be "directly manipulated" may be more confusing and complicated than it needs to be. Sometimes it is best for the user to just learn a new way of interacting with things in order to perform actions more simply and efficiently.


Daniel Haas - 2/9/2014 15:58:01

HH&N shy away from giving an explicit definition of a direct manipulation interface (hereafter DMI), but one could synthesize their collection of examples and properties of such interfaces into a definition such as: "direct manipulation interfaces" are those which enable user interaction via a strong semantic metaphor between the commands, resources, inputs and outputs of the system and the actual objects (data/file/etc.) being manipulated.

The authors describe several benefits of such interfaces, but I can also imagine scenarios where one wouldn't want to interact via direct manipulation. For example, if the objects one wishes to manipulate require high precision (say, you need to aim a missile at a target), it will be hard to design an effective DMI. Rotating a missile to a correct orientation when thousandths of a degree of rotation make a huge difference would be nearly impossible with a mouse or touch interaction on a rotatable object. Additionally, if there are a large number of similar tasks to be done (say, move all .jpg files to a specific folder), a DMI will be inefficient as compared to a script, since it would require the user to move each file individually (or at least select them all individually).


Munim Ali - 2/9/2014 19:57:24

A direct manipulation interface is an interface design that aims to enable 'seamless' interaction between the user and the interface. This technique tries to achieve this by representing various functions and features as objects that can be manipulated by the user. These types of interfaces usually allow the user to perform actions that more often than not correspond to those performed in the physical world.

Such direct interfaces could be problematic to users in the following ways:

1. Repetitive Processes: Performing a repetitive operation through a direct manipulation interface could be described as tedious at best. When we want to perform a task repetitively a script seems far better suited than direct manipulation.

2. Variables, Object classification: Direct manipulation interfaces make handling variables difficult. These interfaces also have difficulty in distinguishing the depiction of a single element from a set of those elements.

3. Accuracy: These interfaces rely on the accuracy of user actions (as many of these reflect real world actions). Accuracy is something that is often better handled by the system or depicted symbolically (Eclipse GUI vs XML for Android development).

4. Stifling new means of interaction or Restricting tasks: Because the core idea of direct manipulation interfaces is to mirror real world actions a lot of enhancements and features are missed because these may not have real world counterparts.


Jay Kong - 2/9/2014 20:55:51

A direct manipulation interface is one where the objects of interests are continuously represented and allow "rapid, reversible, and incremental actions and feedback". In other words, a direct manipulation interface allows you to directly and continuously interact with the object of interest -- an example would be controlling a character in an role-playing game.

Such interfaces can be problematic for users. With, say, a "conversational model" interface like the command line, the behavior of a command typed is very limited and well defined. You type in some predefined keywords and you expect some output that correlates to those predefined keywords.

On the other hand, a direct manipulation interface provides continuous representation of the object of interest and allows incremental actions. The behavior of an input should be comparatively boundless, as well as less defined. That, however, requires a lot of manpower for design and development to grasp everything a user would think to do. Most direct manipulation interfaces only offer a subset of what users would imagine to do. As a result, it is a common source of frustration when a user tries to do something and such an interface won't allow it.


Tien Chang - 2/9/2014 22:41:42

Direct manipulation interface are programs to manipulate data to the way one thinks about a problem by using physical actions or labeled button presses. The interfaces are quick to learn, and actions on the programs are malleable. Users should feel short distances and high engagement with the interfaces.

However, direct interfaces could be a burden for users, as some interfaces are too tedious for novices or experts who might need to learn need new functions and buttons. The more manipulation a user wants from a system, the more effort is required of the user, causing a user to feel a lack of directness from a poorly designed interface. If there are delays between execution and results of actions, that would be problematic for users and create a lack of direct engagement.


Myra Haqqi - 2/9/2014 23:40:35

A direct manipulation interface is a design that consists of constantly depicting the object(s) of interest to the user, physical tasks that the user can execute in order to manipulate the object(s) of interest without the need to type using complicated language, and a fast yet simple manner to reverse unwanted actions that allows users to immediately get feedback about what is transpiring relative to the object(s). Shneiderman, who coined the term “direct manipulation,” goes on to demonstrate the assets of this kind of interface. In particular, he mentions that users who are not familiar with the interface can easily learn how to perform basic operations quickly. Also, those who have more experience with the interface should be able to perform a myriad of tasks, including defining new functions and features for the system. Furthermore, users who may not have used the interface for a period of time should still be able to remember the fundamental actions when they return to the system. Also, the need for error messages should largely dissipate, as error messages are more problematic than useful for users. Also, users should be able to gain instant feedback about what their actions are doing, and whether or not their actions ultimately lead to achieving their desired outcomes. If not, then users should be able to alter their actions in order to accomplish whatever they need to. Users should also not have to circumvent any adversities because the interface should be easy to understand and because any actions the user performs should be easily reversible in the event of a mistake.

Such direct interfaces could be a burden or problematic for users because it might not always be perfectly clear to the user of how to manipulate objects of interest and how their actions will affect the objects. For example, users may not possess the intuition that manipulating an object in a certain way will lead to some action being performed. If the user has a clear goal in mind of some operation that needs to be carried out, then it might be simpler for the user to compose exactly what he needs to do rather than clicking on various icons, for example in a graphical interface. Also, in the event that the user is unsure of why his actions are not executing correctly, an error message may be more useful rather than detrimental; however, according to Shneiderman, error messages should become obsolete. For interfaces that involve graphical designs, for instance, users may not understand what a certain graphic represents, and the user may not know how to perform various actions. Direct manipulation requires the user to learn some basic information about how to interact with the interface, and may require the help of a more experienced user to explain it to them, which is yet another disadvantage because it requires help, time, and effort. Also, abstract representations may be confusing to users who do not see what the representations symbolize. Furthermore, direct manipulation interfaces may require the user to exercise more cognitive abilities in order to understand what he needs to do, and also how to accomplish his tasks.


Ian Birnam - 2/9/2014 23:51:50

A direct manipulation interface refers to a system with the following three properties: 1) Continuous representation of the object of interest. 2) Physical actions or labeled button presses instead of complex syntax. 3) Rapid incremental reversible operations whose impact on the object of interest is immediately visible

These interfaces could be a burden to users because they may lack the speed or precision that the user requires. For example, Using a touch-based GUI to code or design something may prove to not be as precise or as fast as coding the style through words, since it's difficult to get exact, pixel precision if you are directly manipulating the objects. Also, depending on the computer, there might be computational limitations, which make the program run slower using a DMI as opposed to a non-DMI system.


Jimmy Bao - 2/9/2014 23:59:48

A direct manipulation interface is an interface that allows the user to directly manipulate (hence the name) and interact with the data. A direct manipulation interface possesses such properties like continuous representation of the object of interest, physical actions or labeled button presses instead of complex syntax, and rapid incremental reversible operations. The advantages of direct manipulation include but are not limited to: easy for beginners to pick up and experts to work rapidly and efficiently, error messages are rarely needed, and users can see what they're doing as they're performing a specific task so if they're doing something wrong, they can fix the issue and continue on.

Direct interfaces could potentially be a burden in the sense that since it could be relatively simple, people could feel pressured to have to learn how to use the interface quickly and effectively. Maybe some direct manipulation interfaces don't support some of the harder functionalities that are hard to implement that users may need as well. That would surely be problematic for users since they can't use that certain interface for all their needs.

Going off of hard functionalities to implement for a particular interface, I think direct interfaces could be hard to create as well, which is problematic for the programmers. Direct manipulation interfaces allow users to easily perform a task, but there are probably a lot of things going on in the background. Take the WYSIWYG interface. It allows pretty much anyone to be able to create or edit webpages because of the simple interface. They will literally see what they'll get. They don't have to worry about any of the syntax or any of the backend stuff due to the interface's simplicity.


Andrea Campos - 2/10/2014 0:15:13

A direct manipulation interface is one that allows users to interact with a program that abstracts away many complex, computational details in favor of graphical, object-based representations of their tasks. Rather than requiring a user to be extremely skilled and proficient to use the interface, any level of users can learn to use it quickly, as the more "direct" these interfaces are, the less mental effort is required of users to interact with it.

A direct interface could be problematic for users if the user does not want the complex details abstracted away. The article mentions a mathematical direct interface that solves matrix equations through arrows for inputs/outputs, but maybe certain users would want greater detail into how these computations are performed, either to gain knowledge or to ascertain its accuracy. Also, while these direct interfaces require less "cognitive" effort, this may mean the process one is doing may take longer, and sometimes it may be better to expend more mental efforts in the interest of saving time. The article also mentioned a line sketching interface to communicate with computers, but it seems like certain actions would take longer this way then through a more mediated, complex system like a desktop.


Christopher Echanique - 2/10/2014 0:25:02

A direct manipulation interface is one that provides the user with physical actions instead of complex syntax and rapid incremental and visible operations to minimize cognitive resources to complete a user's task. In many cases, direct interfaces are beneficial to the user by simplifying complex tasks. However such interfaces could burden users who may not want certain system functions to be abstracted away. Consider a direct interface that allows a user to press a button that captures and stores an image for later retrieval. The interface provides the user with directness since they don't have to specify a directory at which to store the image. However in some cases the user might want to have access to that image outside of the scope of the application or understand where it is being managed in memory. This can be problematic since the direct interface abstracts some important complex system actions that the user might want to know more about and have more control over.


Rico Ardisyah - 2/10/2014 0:29:01

In first two chapters of Direct Manipulation Interfaces, Hutchins, Hollan and Norman discuss about the details and the aspects of direct manipulation interfaces. They describe one of the example of DMI is a system of interface that gives metaphor of the nature. In addition, DMI has to represent the object continuously, does not have complex syntax, and reversible, incremental actions. There are some assumptions about DMI, such as novice it is easy to be learned by users. Expert users can work with high performance, and also error messages are not really necessary. As the matter of fact, the users will feel in control when they are using DMI. One of the most successful DMI is video game where the players play the game and the interface gives the metaphor of the nature of the real condition.

The DMI is indeed a very useful and interesting system. However, there is no, indeed, a perfect system. Even though DMI represents the metaphor of nature, there are some users that have disability that cannot use DMI. For those users, DMI is not a good feature. Moreover, there are some metaphors that do not really represent the real nature. The expectation of user is also can be a problem, when they underestimate or overestimate the DMI. Some DMI is implemented in mobile devices that has small screen. This also can be problematic for user.


Haley Rowland - 2/10/2014 0:32:50

A direct manipulation interface is a system that lets a user directly interact with objects pertaining to the task at hand. The system shouldn’t involve complex syntax- the user should feel immersed in a world where their actions on objects directly affect the state of the system. Direct manipulation can be a burden if it pigeons a user into viewing a problem in a certain fashion. If the scope of the model-world is too small, it can hinder a user’s flexibility in approaching the task. Also, if the model-world doesn’t match the user’s cognitive representation of the task, then the user would have to re-learn and re-shape the way they approach the task, which is a burdern.


Ravi Punj - 2/10/2014 1:17:55

A Direct Manipulation Interface (DMI) is a notion of an interface wherein the objects of interest to the user can be directly interacted with, or manipulated by the user. Additionally, a DMI structures the interactions or manipulations to be semantically direct, i.e. close to the user's intention. For eg. if there is a graphic representation of files and the user wants to group the files, he/she would drag them together. Thus the physical proximity achieved by dragging the graphical representations of the files is akin to the user's notion of grouping,

Such interfaces are not suited for repetitive tasks. Taking for the above example, if the user wishes to rename a bunch of files (let's say to prepend a fixed string to each of them), the user is better off writing. Therefore, sometimes a symbolic representation is more suitable than a directly manipulatable representation. Additionally, the burden of accuracy falls on the user in DMIs. The user must manipulate the objects of interest precisely and cannot rely on the system's hardwired accuracy. Since, we know that computer system's are superior in their precision and ability to repeat a task indefinitely without faulting, the symbolic language interface is preferred.


Will Tang - 2/10/2014 1:18:42

A direct manipulation interface maintains continuous representation of an object while allowing the user to manipulate it and produce results through physical actions. Certain operations can be performed on the object that are immediately reviewable and easily reversed. Direct manipulation interfaces are designed to be easy to use for novices. Direct interfaces can, however, be problematic for users when the tasks performed aren't suited to hands-on manipulation. For example, if an action is repeated constantly, then it wouldn't be clever to have the user repeat the action multiple times. In addition, using familiar concepts of data manipulation to simplify interfaces for novices can reduce the learning curve. This simplification, however, may encourage complacency or a lack of motivation to learn new things. Direct manipulation may also provide unnecessary actions to perform tasks that could otherwise be performed quickly by an expert. Dragging and dropping may be intuitive and easy to pick up, but some users may prefer the slight speed increase of terminal commands.


Lauren Speers - 2/10/2014 1:49:00

A direct manipulation interface is an interface designed such that the user behaves and feels as if he is manipulating the subjects of the tasks themselves, rather than representations of the subjects. This sense of directness is achieved by minimizing the cognitive effort required by the user to translate his goals into the interface’s representation of his goals and by designing the interface for direct engagement, so that the user feels he is interacting directly with the appropriate environment, rather than using the interface to manipulate a representation of the environment.

However, direct manipulation interfaces’ close relation to reality can cause problems for the users. For instance, though direct manipulation interfaces may decrease the effort required to adjust to the interface for users familiar with the subject domain, direct manipulation interfaces will not help a user who is unfamiliar with the subject domain and may require even more effort to learn than another interface. Additionally, direct manipulation interfaces do not support the repetition of events like scripts do, which may make tasks more tedious and time consuming for a user who needs to perform repetitive tasks. Finally, direct manipulation interfaces are typically poor interfaces for programming tasks since variables and instances of objects are hard to represent, and scope definition is hard to represent.


Patrick Lin - 2/10/2014 5:56:30

Direct manipulation interfaces as defined in the reading has the properties of continuous representation of objects and physical operations manipulating said objects instead of syntax. They ideally minimize the amount of cognition necessary to translate a user’s goal into physical requirement, and amount of effort needed to perform the action.

While direct manipulation generally seeks to make usage intuitive and less error-prone, possible complications may arise if the interface is not suited for the display screen, or is too small to easily use. The metaphor of objects the developers create may also be subjective and slow down or confuse users, or the application might simply be more suited for a simpler, textual representation. It could also be more difficult to use if the interface is radically different from what people are used to, or go against habits users have formed through the use of other applications.


Andrew Lee - 2/10/2014 8:15:47

A direct manipulation interface is one where the user can physically interact with the task items, which in turn have a level of granularity that matches the way the user breaks down a task.

Direct interfaces break down when the task is inherently more abstract, and doesn't entirely deal with concrete or predetermined entities. As mentioned in the paper, when the task involves descriptions, like computer programs, manipulating undetermined things (maybe one can characterize it as "quantum"?) can get pretty awkward.

An example that many Berkeley EECS students are familiar with the LabVIEW software, which was used in EE20N labs. The interface followed a data flow paradigm, which mainly consists of placing down functional blocks (like addition, "if", logarithm) and wiring them together, where data values will flow through the wires. So it was direct in the sense that the user can follow the values that flow through the wires, and watch them transform through the blocks. However, for constructs like the "for" loop, which may not have a predetermined behavior (eg. if the number of times it loops depends on a variable), the user has to mentally simulate and reason how the data goes through the "for" loop since the visual representation doesn't show an "unfolded" version of the loop, which is closer to how it executes. Plus, by the time EECS students take EE20N, most have already internalized C/Java/Python-style "for" loops, which doesn't quite easily translate into the language of LabVIEW, increasing the semantic distance.


Namkyu Chang - 2/10/2014 8:18:19

Direct manipulation interface is a system which has the following properties, as defined by Shneiderman:

1. Continuous representation of the object of interest 2. Physical actions or labeled button presses instead of complex syntax 3. Rapid incremental reversible operations whose impact on the object of interest is immediately visible.

We are also given an example of analyzing a data matrix by plotting it in a graph. We can see how this example relates by seeing that: 1. the object of interest (the data matrix) is continuously represented initially in matrix form, then in graph form; 2. Labeled buttons (the basic icons on the bottom of the screen); 3. By changing any of the buttons, the impact is shown on the graph.

A case where direct interfaces could be problematic is when there’s a long distance between the user’s thoughts and the system’s requirements. Consider the case of above where the user analyzes a data matrix using direct manipulation. The example states that circling a certain subset of plotted points re-plots the line of regression. However, what if this wasn’t the case? What if circling the points deleted them? Or if it calculated the mean point out of the subset? There are many possible outcomes that may be obvious to the user, and a system cannot be programmed to expect all these different results. What ensues is what may be the obvious functionality for some may not be for others, and a programmer who cannot get inside the users’ minds will undoubtedly put a long distance between his/her system and the user.

An example of such “highly interactive, graphical programming” that I have personally used was in 61C, where we used a software to create circuits. It had all 3 properties of a direct manipulation interface as coined by Shneiderman. It constantly showed the current state of the circuit, it had multiple buttons and actions which allowed me to manipulate the current circuit, and making any changes (or cancelling those changes) shows how the circuit looks immediately. A direct manipulation interface may be useful in this case where we create a circuit, but when programming becomes more complex, the distance I mentioned in the above paragraph may become longer, making it harder for the user to use.


Gregory Quan - 2/10/2014 11:31:03

A direct manipulation interface, as the name implies, allows the user to “directly manipulate” objects by using physical actions such as clicking and dragging instead of typing commands. Also, the objects of interest are made to symbolize the things that they physically represent, for example, pictures of folders on a computer desktop to represent actual folders. A user can drag and drop a folder into another folder to change the directory structure.

Direct manipulation interfaces do have some disadvantages. One disadvantage is speed: experienced users might be forced to work much slower than necessary when working with a direct manipulation interface. For example, moving a file may be as simple as typing ~20 characters, which can be faster than moving a mouse and clicking on a screen.

Because direct manipulation interfaces require more abstraction and complexity, there is more opportunity for things to go wrong. In order to manipulate the folder on the desktop, the desktop process has to understand and translate a series of mouse clicks and drags into a move command. Also, the cost to develop and maintain direct manipulation interfaces can be significantly more than simpler interfaces. The desktop process requires more memory, more hardware (a mouse), more processing power, and more code in order to work properly.

Poorly designed direct manipulation interfaces may not be as intuitive as they are intended to be. For example, if a user was supposed to double click a folder before dragging it, they may not understand how to move the directory that it represents.


Qianyun Li - 2/10/2014 11:35:27

Direct manipulation interface refers to an interface that uses physical actions or labeled button presses instead of complex syntax, therefore making it easier for users to operate by intuition.

The advantages of direct manipulation interfaces are the feeling directness, less possibility for error occurence, easier for first-time users to learn by observing other people manipulating the interface.

Such direct interfaces could be problematic because in some situation it might be more difficult to program, the metaphors sometimes could be misleading and its spatial and visual representation is not always preferable.


Eric Hong - 2/10/2014 12:12:44

A direct manipulation interface is a what-you-see-is-what-you-get interface where the user can directly manipulate and interact with the visually apparent data and connections. It has the three following properties: continuous representation of the object of interest, physical actions instead of complex syntax, and rapid incremental reversible operations with immediately visible impact. Despite advantages in an easy learning curve, high expert productivity, and immediate feedback on actions, a direct manipulation interface also has several drawbacks. First, the user needs some fundamental knowledge of the problem in order to manipulate the data or connections. There is usually no single button the user can press to accomplish the work without prior knowledge of what the data means. Secondly, direct interfaces usually require a big enough display so the user can see enough to visually identify and manipulate the data or connections. This requires a bigger screen size that hardware devices are not always equipped with. Thirdly, the computation time and delay associated with visual alterations can affect the speed of finishing the task. An expert might be able to finish the same task faster with a different interface that functions without the need to wait for display changes.


Brian Yin - 2/10/2014 12:55:08

A direct manipulation interface is an interface which utilizes interactive objects which an user may execute actions on and then get immediate feedback. A direct manipulation interface seeks to minimize the 'distance' between the user and the interface and the provide the user with direct control by providing an effective means of communicating what can or cannot be done with objects of interest.

Because of its visual and interactive nature, direct interfaces may be useful for newer users of an interface. As users interact with the application, they can get instant feedback and learn what each feature does. Moreover, direct manipulation interfaces can take advantage of the habits and intuition users have interacting with real world objects by mimicking these real world objects.

While direct interfaces may have these characteristics, they may still be confusing to use. For example, built in Microsoft Paint is fairly easy and intuitive to use because it includes few functionality and the ones it does include, it is easy to infer what they do based on icons and response. Photoshop on the other hand, while still a direct interface, is fairly difficult to use for new users as it has many features, many of which lay users may not be familiar with.

Another possible disadvantage of direct interfaces is the speed at which tasks can be performed. It may be faster to perform a task such as renaming a bunch of files utilizing code rather than using a direct manipulation interface (i.e. finding an file object, right clicking rename, renaming the object, and then verifying if the change is correct),


Everardo Barriga - 2/10/2014 13:07:47

Direct manipulation interfaces are powerful interfaces that allow users to work rapidly, intuitively and directly. You should be able to manipulate objects that are representations of data. For example, a picture of a folder represents a folder full of files. Your actions should also be immediately visible and you should be able to reverse your actions. Direct manipulation interfaces are a way of representing data and a way of letting you interact with data to give you options that you might not have seen using a solely text-based interface.

I think one of the problems with this approach to interfaces is the “first-personnes” aspect of it. The paper describes it similarly to watching a play and being immersed into the world presented to you. I think that if you do this, you could over-stimulate the user and perhaps kill the productivity of the user. The user should also not feel overwhelmed, and being immersed in a brand new world can be overwhelming. In other words the user should be allowed to think critically while also believing the interface “world” created. there is a difference between being engaged and being immersed and I think it should be explicitly clear to have the user engaged, not letting his inhibitions go and allowing the user to remain critically alert.


Cory McDowell - 2/10/2014 13:08:33

A direct manipulation interface is one where you can operate on an object or data using visual tools and blocks which make it easy to see what is happening to the information and how it is being acted upon or analyzed.

While the graphical aspect makes data easy to manipulate, one is also limited to the functionality of the provided graphical tools. Dragging and dropping icons can also be much slower than typing. Also, when typing there is much more freedom of how something can be designed, but this does lead to many errors, which are avoided by using direct manipulation interfaces.


Sergio Macias - 2/10/2014 13:23:39

Direct Manipulation interface is a user interface which creates a real world metaphor within the interface. It allows users to perform actions on the screen which coincide with real world actions, i.e. if the app is for a flashlight, it will have part of the flashlight (like the handle) on the screen with a power button visible. It mimics the look and action possibilities of the real world, which is pushing the power button to turn on the flash light.

While direction manipulation can be nice, there are some problems that arise with this kind of interface. One problem is that people have to “learn” how the interface works. This is the case when the interface is not intuitive, meaning that the actions possible in the interface do not coincide with possible actions in the real world in an obvious way, then it will be extra difficult to learn to use the interface. Another key part is that there “should be no delays between execution and results”, and its possible that certain underlying systems won’t be able to support this and thus this key feature won’t be possible. Lastly, direct manipulation takes away the opportunity to think in new ways since the interface lends itself to ways of thinking that are already set in our mind.


Shana Hu - 2/10/2014 13:26:49

Direct manipulation interfaces are systems in which users can interact with objects which directly represent factors of interest and see the results of their actions quickly. These interfaces are largely reliant on succinct labels or actions, in order to present a direct and streamlined experience. As a result, users feel as if they are directly engaged with the system and are able to manipulate objects quickly and easily.

Although Schneiderman points out many advantages to direct systems, the direct nature of the interface may pose problems for some users. Although it is easy to learn functionality by watching a more experienced user, someone who is trying to learn the system on their own might not be able to figure out how to interact with the system if there are not clear directions. Direct systems usually forgo long and involved lines of text which provide clear directions, so users might not know how to manipulate objects due to lack of instructions.


Shana Hu - 2/10/2014 13:26:30

Direct manipulation interfaces are systems in which users can interact with objects which directly represent factors of interest and see the results of their actions quickly. These interfaces are largely reliant on succinct labels or actions, in order to present a direct and streamlined experience. As a result, users feel as if they are directly engaged with the system and are able to manipulate objects quickly and easily.

Although Schneiderman points out many advantages to direct systems, the direct nature of the interface may pose problems for some users. Although it is easy to learn functionality by watching a more experienced user, someone who is trying to learn the system on their own might not be able to figure out how to interact with the system if there are not clear directions. Direct systems usually forgo long and involved lines of text which provide clear directions, so users might not know how to manipulate objects due to lack of instructions.


Albert Luo - 2/10/2014 13:31:12

A direct manipulation interface is one where the user gets to see visually the progress he/she is making when interacting with an interface; essentially, the user an feel like he/she is in control and has some semblance of physical interaction.

This can be a problem because it poses the burden of learning different icons and symbols onto the users. While it is slightly better than a command prompt interface, the fact remains that users still have to learn what different icons mean and how to use them, so the learning curve can be quite steep. Depending on the kind of direct manipulation interface, users could also be misled or be confused by the lack of detailed information. For example, in replacing tables with graphs, details are lost and users could make incorrect conclusions based on what it looks like rather than what the data actually says.


Shaina Krevat - 2/10/2014 13:39:44

A direct manipulation interface is a user interface designed to, in some ways, mimic real life so that the user can learn the system quickly and effectively without looking to a manual. The “object of interest” will always be represented on the screen (for example, a file on a desktop), the user can interact with it without complicated syntax (double clicking to see the contents of the folder as opposed to “ls” as it would be in UNIX), and interaction will have immediate feedback (when a file is dragged into a folder, it will immediately disappear from the desktop and reappear within the folder).

A problem with direct manipulation interfaces is that they are often restrictive. Compare the common desktop display to a command line interface. The command line is straight forward, organized, and has the ability to create new commands. In a direct manipulation interface, it is often much harder for new users to create new commands, and sometimes impossible. Furthermore, what is considered “direct” for some people might not be for others. A direct interface might work for some people, while others might find it easier to have the command line, or other modes of input like speech recognition. If the interface can only be controlled through touch (as described in the example in the reading), then someone who can’t use their hands would not be able to use it, as shown in the VoiceDraw video in class.


Jeffrey DeFond - 2/10/2014 13:44:48

   A direct manipulation interface should have the following characteristics; It should have a continual representation of the object of interest, it should allow for quick reversible changes that are immediately visible on the object of interest and finally it should limit the use of complex syntax in favor of physical representations and buttons. 
  These are not universal positives. Graphically displaying the object of interest is not always as straight forward as it may seem, trying to represent a very large matrix and a long series of complex operations on it would be harder to "proof read" in a graphical representation. Hutchins, Hollan and Norman also mention the hardware requirements, specifically in terms of representing the graphics, but I would posit that you would need a much larger screen in order fit all of the buttons and objects that are in apps in a direct manner.


Dalton Stout - 2/10/2014 13:48:24

A direct manipulation interface is a service or program that uses the power of metaphor to represent tasks literally, rather than abstractly, to the user. The hope is that physically performing the task in a virtual way is appealing to novices, but can still be mastered by experts. The authors describe it in more technical terms; they aim to reduce the amount of cognitive resources required to complete each task. They discuss the concept of distance. They describe distance as the ease at which a user can transition from the real world problem to the virtual metaphor. It may be problematic to use a DMI if you are inexperienced with the task at hand. For example, maybe you don't know much about statistics and you would rather just tell your computer to find you the variance and std. dev. rather than act out the computation yourself on a graph. Power users may find it problematic to continually act out the program metaphor when the same computations could be done in a command line interface.


Opal Kale - 2/10/2014 13:49:46

A direct manipulation interface is where "all the 'programming' is done graphically, in a form that matches the way one thinks about the problem." Furthermore, the desired operations are performed by moving the appropriate icons onto the screen and connecting them together, or "directly manipulating" the objects. This is equivalent to writing a program or calling on a set of statistical subroutines, but with the advantage of being able to directly manipulate and interact with the data and the connections. "There are no hidden operations, no syntax or command names to learn. What you see is what you get."

Direct interfaces could be a burden or problematic for users if they must do a repetitive operation. Direct manipulation interfaces have problems with accuracy, because the user must control the actions with precision, and we all know humans aren't perfect. Direct manipulation also "restricts ourselves to only building an interface that allows us to do things we can already do and to think in ways we already think" and is limiting in that way. Finally, it is tricky to control the scope of variable bindings in direct manipulation environments.


Charles Park - 2/10/2014 13:58:59

Direct manipulation is a system that have three major properties: continuous representation of the object of interest, physical actions or button presses instead of complex syntax, and rapid incremental reversible operations whose impact on the object of interest is immediately visible. Some examples of the disadvantages or burdens on the users is that for certain tasks such as filing and retrieval, browsing, and table manipulation, the drag and drop methods were found to be slower than the use of radio buttons or a single data entry box for changing the order of fields in a table. As Perlis called the “Turning tarpit”, the bit shuffling of a very simple abstract machine cases the burden of spanning the gulf from user intention to bit manipulation entirely on the user. (When trying to get the 56% out of 100% it might be difficult to scroll to that location using the user’s finger and accurately finding the location of desire rather than to just type it out).


Vinit Nayak - 2/10/2014 14:02:32

Direct manipulation interface (DMI) is a style of interface in which the user can directly operate on the data and see a cause and effect relationship between what they do and the outcome it produces. They should see a direction relationship between the results of what they are doing so they can change if they do not like the desired output. A DMI is meant to be quick and responsive to the user does not have to waste time trying to figure out how to operate it due to complicated syntax or ambiguity in its actions. The user is in full control of the actions done via the interface. This however can also prove to be a problem regarding accuracy, as stated in the article. The user needs to be trusted to interact with the DMI and negligence on the users part can affect the outcome of their actions. The interface is not allowed to try to adjust or autocorrect the users mistakes, as that takes away from user control. Another negative point about DMIs has to do with the nature of DMIs themselves. Because they are meant to be very direct for a specific set of actions based on the user's task, this limits the scope of the number of users and the number of tasks that can be accomplished with any single given interface. This means there will be little abstraction and generalizations in the DMI so users with different tasks will not be able to use it, meaning multiple interfaces will need to be created, which could result in more time and monetary costs.


Anju Thomas - 2/10/2014 14:05:24

Hutchins, Hollan and Norman discuss a range of *advantages* of "direct manipulation interfaces". Give a brief definition of a direct manipulation interface.

As emphasized by Hutchins, Hollans, and Norman, direct manipulation interface enables the user to control the representations in a similar way as manipulating the object itself. It makes the user feel more in control of the objects, through representation of the object of interest and quick incrementable reversible operations whose effect on the object is soon noticeable.

An advantage of the direct manipulation interface is its ability to enable the users to directly manipulate and interact with the data and the connections. A significant property of such interfaces is that it minimizes the effort between user’s goals and the way they must be specified to the system. Another property of direct manipulation is that rather than having an abstract computational medium, the interface is represented graphically in a form that matches the way the user might thinks of the problem.

However despites its many advantages, such as learning basic functionality quickly through demonstration, retaining operational concepts, not needing error messages, and presenting more comprehensible and easily reversible operations, direct manipulation interfaces also have some inevitable tradeoffs. These trade offs pose disadvantages to different users using the program in different contexts and with different goals or interests.


Explain how such direct interfaces could be a burden or problematic for users.

Some disadvantages of direct manipulation interface is that it might require expertise in the task domain. Other possible problems could also include the misinterpretation of users while mapping the interface according to a different metaphorical meaning and the implementation difficulty for the programmers themselves.

The user action to perform each desired operation can also be tedious and time consuming. For instance, in one case the user has to tediously move the appropriate icons on to the screen, connect them together and match each column’s data with the corresponding x axis and y axis.

Another situation is, for instance, the desktop. If the desktop interface was formatted like a physical desk, as discussed in class, then the user would have to tediously shuffle through pages and search for needed items in random places as done with the object itself in physical life, instead of being neatly organized into files and folders as in current desktop interfaces. In this case, the current desktop presents greater ease in handling objects due to its repetitive framework to previous desktop and file structure.

Though advantageous in some situations, such as Ivan Sutherland’s ingenious sketchpad which allows users to easily manipulate the object on the interface and the pinball machine, that allows users to create infinite number of pinball game interfaces, at other times direct manipulation interfaces might require greater effort and resources from the designers. Financial and time constraints for the programmer can also limit its use. Thus, it can be beneficial and harmful, depending on the user’s backgrounds and assumptions on the metaphorical meaning displayed by the interface. If the user is not familiar with the mapping, then it might become confusing, while the more familiar user finds much greater ease with a direct manipulation interface.

A different problem that might possibly be caused by direct manipulation interfaces includes the restraint held by the number of actions that can be performed by the user. For instance, the user is limited to only a certain number of direct interface operations, such as moving, connecting, zooming, etc..

Though the interface might assist novices manipulate through the program, it might fail to cater to expert users who seek more advanced features and less tedious or time consuming  operations. The expert user in this case might want to use the program to find quick results  rather than for user experience, in which case the user would have to use an overly simplified model for something that might be done quickly through more complex programs. 

Another example of the effects of direct manipulation interfaces can be studied through Build Your Own Blocks (BYOB), which is a graphical programming language that helps the user interact more naturally with code. Its direct manipulation interface enables the beginners to smoothly transition into their first programming assignment rather than being intimidated by the text based coding. The graphical language allows the users to visualize the code and understand how to perform functions through visual hints or metaphors such as a for loop. Here the user can guess the inputs of the for loop, rather than memorize its syntax.

However for an expert programmer or industrial worker would not be as interested in programming using BYOB due to its tediousness and time consuming aspects. The text code might be a much easier way to program in this case, despite the more natural user experience provided by BYOB.



Peter Wysinski - 2/10/2014 14:13:04

Direct Manipulation is described as a way of getting a result through trial and error. It is a form of interactive design that does not attempt for the user’s outcome to be perfect the first time around; the user is expected to make an error. However, because it is effortless and quick to correct mistakes such an interface is considered by many to be the gold standard. Since direct manipulation lets users see the outcome as soon as a mistakes is made it prevent the mistake from carrying over to future interactions. As such it removes the need to include error messages and allows for users to discover features in the software quickly by taking ‘risks’ in their actions. A modern day example of direct manipulation is Instagram. It shows the effects of filters as soon as they are applied and lets users see how the image will look like with different filters. The speed at which the effects are applied encourages users to try filters until they find one that they like best.

For Direct Interfaces to be effective the hardware must be fast enough to make all the actions seems instant. Lag prevents the actions from feeling snappy which in turn makes it difficult for mistakes to be effortlessly corrected in a way the encourages exploration through trial and error. If a user is unsure what kind of trend line to apply to their data and it takes over a minute for each of the options to be processed, the user will be discouraged from trying all the available options until he gets one that suits his needs. Direct Interfaces can turn out to be problematic as they must represent their subject in a way that natural language would not. The interface language must be implied which if not done properly makes it difficult for direct engagement. In modern day most programs uses the floppy disk icon to represent a save action, as the action is no longer taken upon the object ‘the floppy disk,’ new users who use the icons for the first time may be unsure of its effects.


Andrew Dorsett - 2/10/2014 14:19:03

Direct manipulation interfaces (DMI) are interfaces that lead the user to believe they are directly manipulating something such as data, images, sound, etc via the interface. A successful DMI represents the data and actions in a way that is familiar and logical to the user. Burdens can arise when the implementation is incorrect. Meaning they do not function the way users think they should function. This leads to frustration and a steep learning curve. DMI's also can limit the functionality for advanced users by imposing only a certain set of actions.


Kaleong Kong - 2/10/2014 14:22:04

Advantages: From the reading, the following advantages are stated: 1. It can let novices to learn the functionality of a tool easily. 2. Experts can work extremely fast and carry out a large range of task, even if new features are added. 3. If people already have the knowledge of the tasks that the software carries out, they can learn to use the software easily. 4. Error messages are rarely needed. 5. User can immediately see the consequences of their action. If the intermediate result is not correct, they can easily go back to the earlier step or restart the whole procedure.

Definition: The promise of direct manipulation is that instead of an abstract computational medium, all the “programming” is done graphically, in a form that matches the way one thinks about the problem. The interface needs to have a good metaphor of the real world, so that the users can establish a “direct engagement” to the interface.

Problems: Some of the production of the feeling of directness is due to adaptation by the user. If the interface doesn’t have a good model of metaphor to the real world, it will give user a hard time to adapt it. Also, not every task is suitable to model it exactly the same as reality, for example, buying a book at bookstore. In this example, I think everyone prefers to have a filter/ select option to help you choose your wanted book. If people model it as a realistic book store which interface contains a lot book shelf and all books are in the shelf, I guess everyone, even for those didn’t use computer before, know how to use it. However, most people would agree that that is not convenient since you need to go over all the shelf to find the correct category and then search the right book from the shelf but not even sure if the book store has that book or not. I think a good interface would be one that would provide a good enough “direct engagement” and also give users extra feature that would solve the inconvenience that they have in real life.



Alexander Chen - 2/10/2014 14:26:52

Hutchins, Hollan, and Norman describe the direct manipulation interfaces as interfaces where users can quickly grasp the interface due to some familiarity with other similar interactions, e.g. sketchpad applications and drag and drop applications. Another important aspect of these direct manipulation interfaces (DMI) are that the user should be able to see appropriate feedback to make the experience more "lifelike", i.e. the feedback that the user would expect to see if they were to undertake the action in the actual world with the actual peripheral. Just as drawing on paper should leave a mark of wherever your drawing utensil has touched, the same should be true on electronic devices. In a paint application in your computer, you equate holding a click on the mouse to putting a paintbrush down onto the canvas; a stroke is made when you drag the cursor; and the brush is lifted when you lift your finger off the mouse clicker.

Still, when designing these interfaces, we have to minimize the gulfs of execution and evaluation. Does the software carry out the user's goals as he/she expected, and does it provide understandable and expected feedback? For example, continuing off the paint application, a user might be familiar with the click and draw command, but when they want to erase, they have to learn a new command. In the physical world, some would be accustomed to flipping their pencil around and using the eraser end of the pencil to conduct this task. However, there is no easy analogy to "flipping your cursor around" in the paint application. Perhaps the user would try to right click and draw the cursor to erase. After some moments of frustration, the user would likely look in the toolbar for an eraser, or, worse, they might delete their entire canvas under the assumption that paint strokes could not be undone.

In summary, DMI are supposed to be easy to understand for most users, if the programmers make the correct and complete metaphors for the digital objects in the computers to the real objects in the physical world. If the digital object is missing a property that a real object has, this would confuse the user. The same can be said for the feedback, the feedback should be familiar, given the context of the digital object, otherwise the simplicity of DMI is broken.


Andrew Chen - 2/10/2014 14:27:09

A direct manipulation interface must have a small distance between the task the user wants to accomplish, and what he must do to accomplish that, and it must also possess a qualitative feeling of direct engagement. What the small distance refers to is the so-called “gulf” between a person’s goals and knowledge and what kind of description is provided by the system with which this person interacts with. What the second attribute refers to is the user’s feeling that he is directly interacting with the objects instead of interacting with the program.

However, direct manipulation interfaces are not as efficient for some tasks, such as those that should be automated via a script, for example. Repetitive tasks would be extremely inefficient if done through a direct manipulation interfaces. In addition, direct manipulation interfaces require that the user be precise (to a certain degree) in how they interact with the interface. Also, if the user does not have sufficient knowledge in the domain of the objects he is trying to interact with through the interface, he may have trouble learning how to use the interface, as he has not developed an intuition in this space, intuition being a sense of familiarity.


Christina Guo - 2/10/2014 14:27:44

A direct manipulation interface is an interface in which representations of objects act like physical objects, and can therefore be manipulated or acted upon using physical actions that will generate immediately visible feedback or results. Direct interfaces could be a burden on users if the product is not accurately researched and tested. It can be hard to figure out what is considered a "natural" action for users, and there can be different expectations of outcomes of specific actions depending on culture, experience, and habit (whether it's different international cultures, or previous experience with technology, or just different life experiences). Sometimes, it may not be possible to design an interface that feels innate for every possible target user. If one is attempted, then some users may experience unexpected actions from a physical manipulation of the interface, causing even greater confusion than if a indirect manipulation interface were used.


Aayush Dawra - 2/10/2014 14:29:04

A direct manipulation interface is essentially a WYSIWYG (What You See Is What You Get) type interface that adheres to the following properties: - Continuous representation of the object of interest. - Physical actions or labeled button presses instead of complex syntax. - Rapid incremental reversible operations whose impact on the object of interest is immediately visible. The promise of a direct manipulation interface is that instead of an abstract computational medium, all the desired operations are performed simply by moving the appropriate icons onto the screen and connecting them together. Connecting the icons is the equivalent of calling on a set of subroutines, but with the advantage of being able to directly manipulate and interact with the data. There are no hidden operations and thus no complexity in a direct manipulation interface.

The most fundamental problem of a direct interface is that it is basically an amplification of our pre-existing knowledge of a domain and although it allows us to think in familiar terms of the application domain, it inhibits us from thinking in terms of the medium of computation. Hence, it restricts itself to things that we are already accustomed to and poses a challenge of how to think of and interact with a completely new domain, which is at the heart of exciting new technology. Another shortcoming, as outlined by Hutchins, Hollan and Norman in the article, is how the difficulties in the task domain get transferred to the user domain, for instance if a user lacks skills in a given task domain on which the interface is based, he/she would come to think of the system as difficult to use, which is primarily the reason that directness should not be equated with ease of use. Apart from these major problems that the user might face while using direct interfaces, other minor problems also include accuracy while performing a repetitive operation using a direct interface, which is best handled by an automated script rather than the user, difficulty in handling variables and distinguishing the depiction of a single element from a class of elements.


Sol Park - 2/10/2014 14:35:08

According to the authors, a direct manipulation interface is that the programming can be done graphically in the form that matches the way one thinks about the problem. They also mention that "the desired operations are performed simply by moving the appropriate icons onto the screen and connecting them together". A direct interface has the advantage of being able to directly manipulate and interact with data and the connections. It seems like the feature of direct manipulation interfaces are the use of graphic icons that represent actions, programs and files available in the system. No need of syntax and commands between the user and the work to be performed. The user works directly on the screen which displays information. It has such advantages but it also has disadvantages. Users must learn meaning of components which might be meaningful to designer only, not to users. Also, visual representation may be misleading. This could be a problem since there is no other way to interpret them(no syntax or commands).


Matthew Deng - 2/10/2014 14:46:38

Direct Manipulation Interfaces are interfaces that utilize cognetics by representing real objects, using little syntax, and making actions reversible as well as showing their effects, in order to provide smooth human-computer interaction. DMI's use metaphors to represent the system as real life objects, such as having a Recycle Bin for delete items, or folder icons to hold other items. This allows people to make simple connections to real world things, so that it is easier for them to learn new interfaces and understand the concepts used. However, this can cause issues, such as the interface being way too simple. Direct manipulation restricts the way people use the interface, limiting them to only be able to perform the most basic operations - ones whose effects are visible and reversible - rather than more difficult operations that might require more thinking and "distance". For example, Paint uses much more direct manipulation than Photoshop. Paint is much easier to understand, but its possibilities are far more limited. In addition, direct manipulation also causes both designers and users to think very metaphorical and structural way, which can hinder them from visualizing problems in more creative or abstract ways.


Justin MacMillin - 2/10/2014 14:53:08

A direct manipulation interface is a type of interface in which the user interacts with the objects themselves on screen instead of smaller parts of them. The reading gives an example of manipulating a matrix of numbers. In a direct manipulation interface the user can access the matrix, or parts of it, as whole objects instead of accessing each number in the matrix on its own. Direct manipulation interfaces seem like an effective interface implementation strategy, however, it assumes that the user thinks as the programmers do. In the matrix example, the reading talked about how if the user wanted to interact with a cluster of points on a graph (from the matrix), the user can circle those points and drag them to a new graph. While this way of interacting with data may make sense to the programmers, it might not make sense to every person who uses the application. In this particular case, I think a direct manipulation interface is convenient because it makes logical sense to drag the points to a new graph given how we as a society are learning to use previous interface interactions and apply them to new ones. On the other hand, if the user had to interact with the numbers individually it would be less likely they have usability issues. Of course, there would be the down side that it is less convenient to use this type of interface. Near the end of the reading Hutchins, Hollan and Norman talk about how distance and engagement are two important aspects of this notion of "directness" in an interface. While they make solid points about their reasoning for certain design aspects of the interface, not all people are going to assume the features they implement will exist. In my opinion it is difficult to design an interface that all users in all disciplines will find obvious and natural.


Anthony Sutardja - 2/10/2014 15:00:41

A direct manipulation interface is not a strictly defined set of interfaces. It's the set of interfaces that give off the impression and feeling of "directness." Although it's a quality that is not very quantifiable, it's best judged as a quality that requires the least cognitive resources.

Sometimes, however, direct interfaces can be problematic for users. This often happens because we try to use natural movements towards content that is artificial.

What do I mean by that? Take for example browsing through a catalog of *many* clothing images on a website. On an iPhone browser, the direct interface is to scroll with your thumb. You'll peruse each image with a swipe of the thumb. However, if you want to go through them very quickly, you'll find yourself rapidly performing a repeated motion that really is not very comfortable. That being said, on a computer, you can use the keyboard arrows to navigate across images. This is a lot easier for you and won't break your thumbs. I believe the issue with the swipe gestures (and other direct interfaces) arise when we apply very natural interfaces like swipe gestures to navigate a completely artificial context, like when the page never ends. You would never encounter this situation in the real world, yet we apply it as a primary way of navigation on our mobile devices. It makes sense for some applications, but not for others.


Sang Ho Lee - 2/10/2014 15:02:26

A direct manipulation interface is an interface that is based on the fact that the user's goals can be achieved by physically manipulating the programmatic representations of different objects, The direct manipulation interfaces relies on the model-world metaphor rather than the conversational metaphor-- meaning that physical actions and objects, not language becomes the primary communicative method between the user and the program. Such direct interfaces could easily be problematic for users. While abstractions and more indirect language based interfaces may seem more difficult to learn in the beginning, the idea of a direct interface may not scale up for more complex programs with many functions. Users may become inundated and overwhelmed by the number of buttons or gestures in a direct manipulation interface for such large, complex programs. While physical objects and actions are effective and dare I say, intuitive, the power of language comes in the fact that large amounts of information can be cleanly organized and effectively communicated to any one that can read. Another burden may be that a direct manipulation interface may not be what may be best cognitively for users. As Raskin points out, UI designers must take into account cognetics, as ergonomics are taken into account for designing mechanical machines. Therefore, it is foolish to apply the direct manipulation interface to all design. There are clear benefits to it, but being mindful of users' cultural and cognitive abilities may hold a higher priority.


Seth Anderson - 2/10/2014 15:04:11

A direct manipulation interface is made up of interactions between humans and machines that show constant and continuous feedback between the action the user is taken and the output on the screen. For example, when a user rotates a photo on it's axis in Photoshop with the mouse, the image of the photo on the screen is continuously rotated variable to the speed and direction of the user's mouse.

Direct interfaces such as these could end up being quite problematic to users, even though they do have many benefits. One of the most glaring issues is their speed: by mimicking relationships in the physical world, direct manipulation interfaces sacrifice the possible speed that could come with abstracting away the directness. For example: typing in that a photo should be rotated 90 degrees immediately rather than adjusting it and fidgeting around with the mouse until it reaches the same rotation. Another issue that could be problematic to users, especially disabled ones, are the physical limitations. Using the same example, if the mouse being used to rotate the photo reaches the end of the mousepad before the rotation is complete, the user will have to pick up the mouse and readjust it's position, causing the rotation to take longer and likely go in the wrong direction.


Jeffrey Butterfield - 2/10/2014 15:05:22

A direct manipulation interface is an interface that instills into the user a feeling that his or her input directly causes the result that the user wants to attain. A successful direct manipulation interface reduces the size of the cognitive transition between a user’s thought and a user’s actions to carry out that thought. A good direct manipulation interface must also provide feedback that illustrates how the user’s actions have impacted his or her progress towards the goal. The opposite of a direct manipulation interface is an interface that presents the "machine" as an intermediary between the input and desired result. Interfaces that extend the conversation metaphor for human-computer interaction do not employ direct manipulation because the user is essentially telling the computer what to do, instead of doing it for himself or herself.

Direct manipulation interfaces are not appropriate for all instances of HCI because of some inherent disadvantages involved in their use. As the paper points out when describing direct manipulation interfaces, “The system requires expertise in the task domain,” meaning that what can be manipulated and how to manipulate it must still be learned by the user, either through intuition or an external teaching source. Perhaps learning the task domain can be easier than learning, say, a textual language, but learning of some sort still must occur.

Therefore, direct interfaces can become burdensome when new tasks must be performed and the user is ignorant of how to perform them. For example, if the user wanted to expand upon the case in the paper by manipulating data in a 3-dimensional matrix (a matrix of matrices), the way to go about plotting the same columns is no longer apparent. In this case where the user is unsure, there is no advantage between direct and indirect interfaces—both require the user to “look up” the proper command or action. Arguably, looking up the solution for a direct interface might be considered less pleasant than for an indirect interface (e.g. consulting Javadocs), because while someone inputting language commands expects the need to look up function documentation, he does not expect to be required to look for an action/gesture that was originally supposed to be more “intuitive.”


Emily Reinhold - 2/10/2014 15:21:47

A direct manipulation interface is a medium through which users can communicate desired actions to the computer in a seemingly "direct" way. The term "direct" is relative, and users tend to feel that their actions are direct when they can very easily go from thinking about what they want to do and doing said action. Hutchins, Hollan, and Norman explain that the feeling of directness is attributed to the distance between one's thoughts and the requirements of the system and the engagement of the user.

Direct interfaces could pose many issues for specific tasks users may want to accomplish. For example, if a user wishes to delete every file on his/her computer, then a direct interface might require him to click and drag each individual file to the trash can. This repetitive task would undoubtedly get quite cumbersome, whereas running a single command "rm -rf ~/" could accomplish the same results in a much shorter amount of time. This example gives rise to the notion that repetitive tasks may be less suited for direct manipulation interfaces.

Further, the nature of direct manipulation interfaces allow for users to not get their hands dirty and understand what is happening behind the scenes. While this is good in some cases, it could also breed a culture of trusting the few people who actually build the interfaces. Putting all of our trust in the hands of these few people could be dangerous. It also leaves all of the creativity in coming up with new applications/technologies up to the few people who understand the underlying programs that run the direct manipulation interfaces.


Juan Pablo Hurtado - 2/10/2014 15:26:57

A direct manipulation interface is an interface that have the following properties:

1. Continuous representation of the object of interest. 2. Physical actions or labeled button presses instead of complex syntax. 3. Rapid incremental reversible operations whose impact on the object of interest is immediately visible.

It could be a burden, because it could be slower to manipulate than other interface, also if it is too graphical it also could lag a lot and because different users come from different realities, it could be that the representations of different objects where confusing or ambiguous.


Erik Bartlett - 2/10/2014 15:34:44

A direct manipulation interface is an interface that gives the user the illusion of directly manipulating the objects of the computer, through two different metaphors: model-world and conversation metaphors. One gives the user “direct access” to manipulate the world seemingly with their hands, while the other (conversation) uses a conversational vocabulary to give them control over the world - mapping phrases to actions.

These types of interfaces can be cumbersome and problematic when a task is intricate and takes a large amount of low level detail to execute. For example, when trying to break data into extremely small groups for analysis in a spreadsheet, the user would manually have to select each set and define what actions to take on it, as opposed to a command line script in python that could take in the data set and analyze it within 5 lines of code using case statements.


Emily Sheng - 2/10/2014 15:35:17

A direct manipulation interface is a term that describes a system with three specific properties. One property is that there is a "continuous representation of the object of interest." In other words, the user should be able to see the visual representations of the data he is working with at all times. Another property is that the user should be able to perform "physical actions or labeled button presses instead of [using] complex syntax." All necessary actions can be learned by copying an expert or by similarity to familiar actions in everyday life, and there are no hidden syntax rules. The third property is that operations that can be incremented/reversed should be "immediately visible" for instantaneous feedback.

Although direct manipulation interfaces may allow users to feel as if they were really manipulating the things being represented, this type of interface may become tedious to interact with. For example, in class we saw the example of how a person's desktop was literally arranged as if it were a real 3D desk. The files were not displayed in a list, but rather as a stack of physical files which you could flip through. While this direct manipulation interface is intuitive to the users (in the sense that it is similar to physical files which they have presumably encountered), it also carries the problem in the physical world of being unable to quickly find a file. Here is an example where the technological interface has tried to assimilate too much to that of the physical world and has also inadvertently brought up the same problems we face in the physical world.

Another point is that although direct manipulation interfaces may be better for novices, experts or those who must perform the same manipulations many times over different sets of data may find direct manipulation slow. By resorting to direct manipulation interfaces, we are ignoring the ability of machines to perform batch tasks and the ability to do them quickly and efficiently.


Gavin Chu - 2/10/2014 15:36:02

Direct Manipulation Interfaces are interfaces that are interactive and easy to use because it requires user involvement. Hutchins, Hollan and Norman discussed directness in terms of distance and engagement. Distance refers to how easy is it for the user to use the app. It is "inversely proportional to the amount of cognitive effort," meaning an app is direct if the user doesn't have to think too much about how to use the app. Engagement on the other hand, has to deal with how well the user connects with the app, like if the user can imagine himself or herself as a part of the app.

The creation of Mii characters on the Nintendo Wii system is a good example of a direct manipulation interface. The distance is close because the user knows himself or herself well enough that it shouldn't be hard to create a virtual version of himself or herself. It is also engaging because the user can imagine standing inside the game and adjusting his or her physical features such as hair style or eye color.

Direct interface could be a burden for apps with very simple functionality such that having a interactive interface only complicated the task. For example if you want to fill out a form, a designer could make each field on a separate view and have the user go through all of them one by one. It might be intuitive for user to proceed through each field by pressing next each time, but if each field asks for one word answers like name, phone number, and address, it's unnecessary to make addition manipulation to the design.

Direct manipulation interface can also be a burden if the app tries to accomplish too many tasks. There's is a limit to how complicated something can get before the user starts feeling discouraged to use the app. Each functionality might be cleverly designed, but if there were 50 different of these functionalities, the user would still be confused even though each task is simple by itself.


Diana Lu - 2/10/2014 15:38:03

A direct manipulation interface refers to an interface where the interaction with the interface is one that is supposed to be equivalent to something the user would understand in the real world. An example of this would be zooming in on something by pulling at its outer edges, enhancing the image inside the proverbial box, or using desktop interfaces as a metaphor for real desktops, on which you can sort files into folders, something that should be innate to most professionals.

However, while direct manipulation interfaces are intended to make interaction intuitive for a user, they can become a burden when too much emphasis is placed on the metaphor and usability and simplicity fall to a second priority. An example of this was actually brought up in class, where an interface was designed to represent a 3D desk, bringing the metaphor to a realistic interpretation. However, even though the interface was realistic, it became unnecessarily complicated and was actually problematic in use. Specifically, the folders could only be flipped through because that was the equivalent of the real world desktop, but it was actually more inconvenient for the user.


Liliana (Yuki) Chavez - 2/10/2014 15:59:57

A direct manipulation interface is when the model of the objects in question mimic the appearance and behavior of the object itself (the one that you want to manipulate) so that the representation of the object in the interface becomes a more accurate and engaging model. Having a direct manipulation interface (as opposed to interfaces that use other models like language) reduces the gulf of execution (between the goals of the user and the physical system) for the user so that their thought processes that occur before a certain action is reduced.

The authors themselves admit that the feeling of 'directness' a user interface might have is partly due to the design of the interface, and partly due to the work by the user in adapting to the user interface. Direct manipulation interfaces make many assumptions on how the user will react to the object itself and based on those estimations make certain the object behave in a certain based on the estimated actions of the user.


Nahush Bhanage - 2/10/2014 16:03:34

A direct manipulation interface is a type of user interface which involves a continuous representation of the object of interest, focusing on physical actions on the interface instead of complex syntax. With such an interface, users get immediate feedback of their operations on the object of interest.

Direct interfaces could be problematic for users in many ways, some of which are as follows:

1. Users need to have a basic understanding of the domain to be able to make use of such an interface. 2. They need to know and remember what do various icons and other visual components stand for. 3. Visual representation of an object could have multiple interpretations. It might seem meaningful to designers while users might find it misleading. 4. Since icons and other visual components require more space than text, some objects might be placed outside the screen.


Prashan Dharmasena - 2/10/2014 16:05:31

A direct manipulation interface is an interface that allows the user to instantly and easily manipulate data. On one hand, it's simplification of rather complex tasks and allows new users to use the interface without too much of a learning curve. But, on the other hand, it could also prevent experts from doing extremely complex tasks. It would be like trying to make a perfectly round sphere from Lego blocks.


Sol Han - 2/10/2014 16:08:53

A direct manipulation interface is an interface that minimizes the gap between the user's world and the object's world to produce an experience that makes the user feel like they are directly interacting within the object's domain. Direct manipulation interfaces are designed to be easy and efficient for novices and experts alike by reducing the need for cognitive effort (for example, utilizing buttons instead of complex syntax). Directness is composed of two major aspects, engagement and distance (where distance can be subcategorized as semantic or articulatory).

Direct interfaces could be problematic for users in various ways, one major way being that making these natural mappings can stifle creativity in approaching the domain by restricting how we interact with the domain. For example, one of the examples discussed by Hutchins, Hollan, and Norman is the difference between low-level and high-level programming languages. High-level languages are more direct, making it easier for the average user to accomplish their goals. Yet low-level languages are powerful in the sense that they allow for manipulation of the smaller components that comprise the overall system; this feature may be potentially utilized, say, to speed up computations.


Nicholas Dueber - 2/10/2014 16:21:43

Direct manipulation interfaces are characterized by several descriptions. The first is that the user can directly see what they are manipulating the whole time and are able to understand if what they are doing is to the benefit of their task. Another description is that a novice will be able to pick it up the interface quickly and will be able to complete their goal in a reasonable amount of time. Another description is that the user will be able to create their own personalized functions for the interface. The idea of directly manipulating an environment and calling it directness is inherently a relative term. The interactions of the user and how direct they are with their actions may or may not lend themselves to feeling like they have directly influence a result. The problem with direct interfaces is that they have to rely on depicting things that are easily understood and interpreted. They require the program to depict things as metaphors for what they actually do in the real world. An immediate example I can think of is the trash bin on your desktop of your computer. It’s functionality is to “throw things away” delete content from you computer. This is easily understood by the user based on the UI. For data manipulation, it is often more difficult to make things intuitive for the user to manipulate and know that they are getting closer to their goal. This may limit the user in their ability to do complex tasks with the data if they are limited to pre-thought out functionalities by the programmer. Often the user will try to go beyond the limits that the programmer had intended for the program. Thus the graphical interface may pose limits to the user.


Zhiyuan Xu - 2/10/2014 16:24:26

A direct manipulation interface is a type of interface where the user can interact with the system through a visual representation of the process. A direct manipulation interface has three characteristics: a graphical or visual representation of the objects of interest; rapid, reversible and incremental actions that directly impact the object of interest, and usage of visual representation of an action instead of usage of command language.

While direct interfaces have many advantages, they may be problematic for users. The mapping of the action taken may not be intuitive to users. For example, the interface may not be representative of a natural gesture that users normally use, or the visual representation may not map well to an experience that the user is familiar with. If this is the case, then the users may stumble upon using this interface.


Armando Mota - 2/10/2014 16:27:44

A direct manipulation interface is one in which the user has consistent and, what many would describe as “natural”, interactions with the interface and its features. Natural in this sense would refer to a connectedness - a user’s actions are represented immediately and consistently (objects are represented in the same way, manipulations are shown clearly and in real-time). Rather than require a special syntax or language of manipulation, button presses, clicks, and physical manipulations (or representations of physical manipulations that mirror those in the physical world) are used, allowing the user to complete actions much like they would with physical objects.

Direct manipulation interfaces do have some mitigating factors that should keep us all from hopping on the old bandwagon just yet. The advantage of an extra layer of abstraction, as in, learning a specialized language or set of commands that operate an interface, is that it is highly adaptable. While the initial command language takes some learning, you can use it to operate on many platforms, actions, problems, and interfaces, whereas a direct manipulation interface, because it is without this layer of abstraction and closer to a real-world interaction, would be narrower in its usefulness. This extra layer of abstraction can be clearer as well (provided you know the language/commands). Very explicit instructions can be written down explaining how to open a file with my terminal, however it would be a little harder to write down extremely specific directions on how to “move the mouse to the item that looks like a folder, then click on it” (this description seems very clear to us, being expert users of GUIs, however from the point of view of excruciating clarity, these directions are just not as close to those that can be given by a more abstract language). Another possibly drawback is the notion that direct manipulation is not always the fastest/most efficient way of completing a task. A task on my terminal, for example, might involve considerably less button clicks and menu navigation than attempting the task by GUI. In the event of an error or malfunction in which the problem cannot be immediately solved, direct manipulation interfaces run into another problem. Take for example once again, the GUI analogy of moving a file into a file folder. The direct manipulation approach would most likely involve clicking and dragging the file into the folder on the screen, which, when it works, is completely fine. If you encounter some error, perhaps, that the GUI doesn’t provide a clear answer to, you might have benefitted from knowing the language the OS is written in, or any lower-level language that could possibly give you more information on why the action you are attempting isn’t working. The largest possible problem for direct manipulation interfaces is the possibility that people, in dealing with the same objects, might have slightly different ways of naturally dealing with and manipulating them. If the interface analogues of real objects in the world are modeled after what designers think these objects are, act like, and behave like in the real world, it is really up to the designer to make sure that connection between user and object is fully representative. Given the variability in people, this can prove challenging. An interface which is natural to most but not to others is useless to the others, or at least less useful.


Allison Leong - 2/10/2014 16:32:27

A direct manipulation interface is an interface in which data and concepts are continuously represented as objects that can be manipulated by the user through the selection of functions that are clear, concise, and reversible. Actions in direct manipulation interfaces are meant to mimic actions in the physical world, resulting in a smooth and intuitive user experience. An example of a direct manipulation interface would be a gui where users can resize shapes by clicking on the edge of a shape and dragging the shape to its new size. Such interfaces can be problematic for users when dealing with data that is too large to fit on a screen in a usable manner. Direct interfaces can also be a burden to users when data is misrepresented in a way that is confusing to the user. Additionally, direct interfaces may be easy to use when one is an expert with the data and the interface itself, but may be problematic for users who frequently look at new interfaces. Without standardizing interfaces, it may be difficult for users to switch between interfaces as well as learn how to use new ones.


Maya Rosecrance - 2/10/2014 16:33:35

A direct manipulation interface has a visual representation of the thing the user is dealing with, buttons and actions a user can use to interact with, an undo feature and rapid feedback of a users input. Its a interface that new users should be able to learn quickly and where users can immediately see the results of their interaction.

As mentioned in the article, a direct interface could be problematic for very repetitive tasks or for tasks where the user himself might not know what to do with a set a tools. They also have problems with accuracy as if a user wants to move an image to the right hand corner exactly, a less direct interface may be more valuable as it can "snap" it to the right corner without the user moving it precisely to the right pixel.


Daphne Hsu - 2/10/2014 16:38:44

A direct manipulation interface is an interface where the way the user interacts with the interface reflects actions from the real world. The user manipulates the interface in such a way that is intuitive and represents things from the user's life that they are familiar with. Direct interfaces could be a burden for users if the designer wants to over emphasize the "real-life" relationship. The desktop example from lecture is a good example of this. The designer designed a computer desktop very similar to a real life desktop that users would be familiar with, but this ended up being way too cluttered and complicated for the user to use happily. The designer was too focused on having a direct manipulation interface, that the actual practicality and usability of the interface suffered.


Sangeetha Alagappan - 2/10/2014 16:39:15

A direct manipulation interface (DMI) is one that allows for continuous representation of the object of interest, supports physical actions such as button pressing or finger drawing, allows reversible operations and provides immediate feedback. A direct manipulation interface aims at increasing the feeling of “directness” (though a relative term) by reducing the “distance”(reducing the distance between the gulf of execution and the gulf of evaluation, reducing commitment of cognitive resources) and improving “engagement”(building an interface on the conversation metaphor or the model-world metaphor) between the user and the system, making the system more intuitive, efficient and easier to use.

However, while direct manipulation interfaces have helped popularise computers and improved productivity, they have a number of disadvantages. One is the conversation metaphor, where the user and system “converse” with each other - this can prove problematic if the user and the system don’t share the same vocabulary, making for a difficult, frustrating user experience. Since Direct Manipulation Interface is “What you see is what you get”, if the output is unhelpful or not intuitive, it makes using the system harder. Similarly, gestures which seem intuitive may in fact be different in different cultures and thus difficult to figure out when using a DMI. Even if a DMI has been sufficiently navigated by the majority of people, it is often difficult to improve the interface. As in the case of Windows Surface, a huge overhaul of the interface which increases the “directness” might be difficult for even regular Windows users due to their familiarity with only the old interface. Finally, since the DMI proves to be an efficient abstraction to the complex syntax and workings of the system, it often is problematic if something breaks as most people are unfamiliar with the real workings of the system and cannot do much to fix it.


Meghana Seshadri - 2/10/2014 16:40:00

A direct manipulation interface basically allows for users to manipulate objects, designs, and data on interfaces by using actions that somewhat correspond to similar actions that people usually do for tangible things in the real world. Examples are things such as manipulating graphical data to change how exactly its represented and as a computation technique, as well as something simple as changing the size of a rectangle by dragging the corners of it. Furthermore, it should continuously represent the object or data. Despite the numerous advantages that are presented by Hutchins, Hollan, and Norman regarding direct manipulation interfaces, there are several disadvantages or burdens on the user as well. Direct manipulation interfaces have the key downfall of keeping a user’s knowledge base within the confines of what they already know. Because the big advantage of direct manipulation interfaces is that it allows users to think within familiar terms and actions in regards to the application, it also becomes a disadvantage in that it restricts the user to think in ways that they already have before, and thus skips out on the possibility of new technology.


Kevin Johnson - 2/10/2014 16:40:48

The Scratch programming language is an attempt to allow programming using a direct manipulation interface. Instead of writing code, the user drags "code blocks" around, and each block has a unique function. Changing the arrangement of code blocks changes the program.

The obvious downside to this interaction method is that it is extremely limited. A full programming language can have an immense variety of functions, while Scratch is limited by the code blocks provided. This is a problem endemic to direct interaction interface - in the data analysis example given in the paper, the system provides "intuitive" and direct access to certain functions, such as splitting the data into separate groups. However, it provides only an extremely limited ability to manipulate the data in a more fundamental level like Excel provides.

I'm not sure that "direct" is really a style of interface in itself. Instead, interfaces are more or less "direct" relative to the specific tasks being performed. As in the example of the piano and the violin, directness depends on your perspective.


Doug Cook - 2/10/2014 16:41:29

According to the authors, a direct manipulation interface is one in which the user feels as though they are working with (manipulating) the data relevant to their task. It is as if there is a “qualitative engagement” with the interface in addition to the ease of use and speed. Such an interface can occasionally be a vice just as much as a virtue. When the data being worked with is cumbersome and requires many parallel computations, for example. Considering operations that involve matrix math, it’s obvious that showing large matrices directly to the user will place some burden on them to carry out many tiresome algebraic calculations that are better left to the machine. Direct manipulation also carries the potential to inhibit development of novel and (possibly more efficient) interfaces by conditioning users to expect the same level of engagement that they’re already familiar with. These two issues demonstrate both a short term and long term problem posed to users, so it’s critical to remember these trade offs when choosing a direct manipulation approach.


Tristan Jones - 2/10/2014 16:45:55

A quick definition of a direct manipulation interface is that it's a type of UI where the user can quickly and easily tell the computer what they want to do by manipulating "objects" on a screen. These objects represent their physical analogs and by manipulating these users can affect the output of the program. Direct manipulation interfaces are intended to be intuitive and easy to understand. They also make reorganizing work, undoing work, and trying out new features easy for users. This is very different from more traditional GUIs and command lines.

Direct interfaces do have issues. For programs with very many features, it is often difficult to list all the features it offers. Direct manipulation interfaces take up more screen space and it is hard to pack all the information you need into a small screen. Furthermore, DMIs make it difficult for professional users to automate tasks. If a user wants to perform a large sequence of actions in a row, s/he needs to be able to set up the DMI and save it as a larger block macro. Command lines are perfect for solving this problem: there are widely used shell scripts that automate user tasks. This is one of the benefits of a "menu"-based interface - it is much easier to create an API for a programmer to automate user actions.


Justin Chan - 2/10/2014 16:46:24

A direct manipulation interface is an interface where users can see and manipulate physical representations of objects of interest with great ease.  Said manipulations are small, rapid, reversible, and have immediate feedback. 

Direct interfaces can (ironically) be a burden for repetitive motions. While they provide a good, simple, and understandable interface for users, this can get tiring kind of quickly if you’re doing said action over and over again, where the simplicity of the interface gets in the way of efficiency. A good example the reading brings up is a situation where a script can do something for you efficiently, directly, and most importantly, repeatedly, something that would probably take you a lot more time if you were to do it manually yourself. Additionally, since humans are interacting with direct interfaces, there exists a big possibility for inaccuracy and lack of uniformity. For example, chances are that when I draw 2 boxes on Microsoft Word, they’ll be different sizes because my arm isn’t perfect. If I tell a computer to draw 2 boxes of 10-inch width each, it will always do it perfectly. If I’m drawing my masterpiece, this isn’t a big deal because I’m in charge of the end product. If I’m making a model of a house, I NEED things to be exactly correct. What you get in extra customizability and comfort you may lose a little in precision and inaccuracy. Philosophically this makes a lot of sense. We are humans – we are all different, unique, and we make mistakes.


Seyedshahin Ashrafzadeh - 2/10/2014 16:49:04

The concept of direct manipulation is that instead of an abstract computational medium, all the programming is done graphically in a way that matches how users think. Directness is a feeling toward an interface. The feeling of directness is inversely proportional to the amount of cognitive effort it takes to manipulate the system. A good interface is an interface that needs less cognitive effort and helps bridge the gulfs toward a more direct results of interaction. Committing extra cognitive resources to in order to use an interface leads to indirectness of the interface. According to Shneiderman, direct manipulation has the following properties. It represents the object of interest continuously. It has physical actions or labeled buttons instead of complex syntax. Also, its rapid incremental reversible operations impact on the object of interest immediately. Based on the authors, these interfaces have the following advantages. 1) Beginners can learn basic functionality quickly, usually through watching other experienced users. 2) Experts can rapidly carry out tasks that they want. 3) knowledgeable intermittent users retain operational concepts. 4) Error messages are very rare. 5) Users see immediate feedback and they can change their direction if they want to. These immediate feedbacks and natural translation of intentions to actions make some tasks very easy. According to the authors, "the matching of levels of thoughts to the interface language - semantic directness - increases the ease and power of performing some activities at a potential cost of generality and flexibility." However, direct manipulation interfaces have their disadvantages too. For instance, repetitive tasks is best to be done with scripts not these interfaces. These interfaces have difficulty handling variables or distinguishing the depiction of an individual elements from a representation of a set of elements. Also, these interfaces have problem with accuracy since this responsibility is given to the users to control their actions with precision. A more fundamental problem that these interfaces have is that they support the way we normally think about a domain. In this case we are restricted to interfaces that allow us to do things in the way we already do and to think we already think. Therefore, we will miss our chance of exciting potential of new technologies to provide new ways of thinking and interacting with a domain.


Stephanie Ku - 2/10/2014 16:54:00

A direct manipulation interface is an interface that provides representations of objects that behave as if they were the objects themselves. Literally, what you see is what you get. The interface is a world of behaving objects, rather than a language of description. Often, the system requires only expertise in the task domain, but just little/minimal knowledge of computing. There may be several problems that a direct interface could bring to the user. Firstly, direct manipulation interfaces relies on objects, and the tasks associated with these objects. This assumes a predefined knowledge of these tasks by the user. While it may be faster and more intuitive to learn, depending on how well this interface was created, and the objects modeled, it may be difficult for the user to get accustomed to it. Furthermore, the relationships (or tasks and behaviors) that are associated with these objects must be predetermined. This places a limit on the things the user can manipulate and achieve. While this is great for users who may only need to do so much, users with more computational knowledge may want to achieve and do more, then find out they can not. Moreover, some users may prefer to do all their commands at once, and then see their final result, which minimizes latency between tasks. However, in direct manipulation interfaces, the idea is that users can see immediately whether or not their actions are furthering their goals. Ultimately, the biggest burden may lie on whether or not the direct manipulation interface is appropriate for the program or task at hand. While it may make sense for file systems, it may not for others.


Max Dougherty - 2/10/2014 16:54:41

Direct manipulation is a type of user interface which provides "representations of objects that behave as if they are the objects themselves". Unlike the long standing terminal "conversation" style interface, which requires typing abstract commands to "manipulate" tell the computer how to manipulate objects, direct manipulation takes out the middleman. By removing the proxy, a user is provided with a more "intuitive" experience. These interfaces will often include a visual component and mimic how a user might imagine a solution to the problem. Direct interfaces provide greater affordances by displaying the functionality directly and reducing the "distance" between the user and the underlying program. This allows new users to consider the range of functionality at an early stage, and can benefit an experienced user by letting them carry out many complex tasks quickly. A visual representation also allows a user to recognize errors more immediately though feedback, and reduces the need to parse error messages to find bugs.

Although this interface has many strong benefits, when the range of a system's functionality expands beyond what can be displayed onscreen, the UI can become cluttered or it must be organized in an increasingly "distant" manner. This distance obfuscates functionality from the user. Furthermore, if the object in question cannot be represented in three dimensions, for example a higher dimensional matrix, producing a visual interface may be impossible.


Emon Motamedi - 2/10/2014 16:57:19

A direct manipulation interface is an example of an interface in which the user communicates all actions he wishes to be completed graphically through visual, physical additions to the objects shown on the screen rather than through syntax. The results of these actions are immediately displayed on the screen graphically so the user knows the effect of the actions he performed and the user has the ability to easily reverse his action if the result is not what he expected.

However, these interfaces present certain disadvantages for users. For instance, if a repetitive action were needed by a user, it would become cumbersome to constantly repeat the action graphically/physically and this action would probably be more efficiently carried out within syntax. A second area of burden comes from tasks that require great precision. By interacting with a graphical screen, the user gives up some levels of precision in the actions he takes, a loss which could prove very problematic to cope with for certain tasks. Direct machine interfaces also require a user to have knowledge of the different actions that he can perform, knowledge that usually is acquired from observing an expert interact with the interface. If the user were forced to learn potential actions on his own, he may limit himself to the actions that come naturally in interacting with the interface and not expand to the greater range of complex features the interface is capable of due to his lack of knowledge. Finally, direct manipulation interfaces work best when they mirror natural human actions and tendencies, yet this schema for creation prevents the employment of an even better interface that does not limit itself to mirroring human normalcy.


Dylan McCapes - 2/10/2014 17:06:13

Direct manipulation is the quality of an application to remove a need for an understanding of underlying methods and data structures and reduce the amount of possible errors. Put simply, direct manipulation helps users know and see what's going on in their application. One example is the difference between MS-DOS and Windows. MS_DOS requires a knowledge of commands and data structures to manipulate files while in Windows a user simply selects the folder with a mouse where they can drag it to a destination or select a destination from a graphical display of the file system. The way that Windows users manipulate the files is more direct because they can see the files and where they want to put them, and they don't need a knowledge of commands to do so. This is definitely an easier way of doing things, but there are also downsides to direct manipulation.

The burdens and difficulties of direct manipulation range from system requirements to usability. Early examples of direct manipulation applications were often hindered by system requirements such as power usage and computational power. Although modern platforms provide the tools necessary to support most applications, there remain problems with usability in both the time it takes to complete an operation and the actual manipulation of objects. While it may be nice to see a file system graphically, it may be more of a burden to click and drag the file across the screen. Let's also think about the graphical depiction of the file. While it may directly engage the user to see the object as a representation, the user is also limited in the number of operations they can perform on the object through the window of abstraction. Through a command line interface the user may be able to perform more functions from the home directory.


Bryan Sieber - 2/10/2014 17:10:57

In the reading of direct manipulation interfaces, Hutchins, Hollan and Norman explicitly discuss a range of advantages that these interfaces possess that truly make them powerful. Direct manipulation interfaces must be easily learned, be useful for a wide range of tasks, present users with the fruit of their actions immediately, and rarely show users error messages. Direct manipulation systems/interfaces must be able to produce a feeling of directness and feel natural. The definition that Hutchins, Hollan and Norman provide the readers about directness is as follows: “an impression or a feeling about an interface” (317). Directness is measured in two aspects: distance (how simple the translation is), and direct engagement (use of the model-world metaphor). The less cognitive effort required to use the interface the more direct the system will feel. This directness can be achieved by using symbols common to the intended users of the interface. Such as the folder example mentioned in the reading. Users who have had experience with manila folders would know that the folder is a location of other files, but if the users have never had experience with manila folders, they might not get the reference. The choice of symbols used by the designer can either be helpful or harmful to the user-interface interaction. If chosen wrongly the interface could become tedious, burdensome, and abstract to the user.


Cheng Sima - 2/10/2014 17:11:54

Direct manipulation is an interface that provides the users with an engagement experience by supporting the way users think about certain objects to allow them to perform operations on objects with minimal cognitive effort.

Such direct interfaces may seem very efficient and easy to use; however, at times they can be a burden or problematic for users. For example, if a user needs to perform the same task 100 times, "direct manipulation" to perform the task would be extremely frustrating for the user. Secondly, if the task itself is abstracted and has no direct corresponding real life mirror, then direct manipulation could be problematic for users. Lastly, if the task requires precision that only the computer can handle, letting the users directly manipulate the object for the task may lead to undesirable outcomes.


Steven Wu - 2/10/2014 17:12:48

Direct manipulation interface is something a designer wishes to achieve but cannot take the entire credit for since the feeling of directness a user experiences is due to the adaptation to the user. What I am mean from this is that with the use of a direct manipulation interface, a user isn't required to have a vast set of cognitive resources to interact with a device or process. The design of a product manages to come off as intuitive. This idea of not overbearing the user comes from the sense of directness for the product. There are two points to note when examining directness. The first "involves the notion to distance between one's thoughts and the physical requirement of the system under use". The second comes from "the qualitative feeling of engagement, the feeling that one is directly manipulating the objects of interest". The distance allows the interaction to come off in a high-level manner as in something that minimizes the cognitive effort on an individual. The engagement comes off in an abstract sensation. Here symbolism plays a key role in human-computer interaction. In the reading, there is a file represented as an image on the screen. The metaphors we engage within our “real lives” and the words in our oral speech represent everyday objects and interactions that could be symbolized as images on a screen. This becomes the bridging of this gap in thee directness and symbolism in human-computer interaction. Although, this might appear as a fluid representation for the behaviors for an object on screen, it is on the user's end that further solidifies the metaphor that a virtual folder appearing in front of him is where a file represents on the screen. A person must be able to referred to these types of things on the fly in a sort of unconscious way, similar to how you know the last letter of your first name without really knowing what it is immediately. These triggers that are overlaid in computer programs permit the user to act as if the representation in the computer is the object in real life. However can a designer always overcome this metaphorical obstacle? No not necessarily. Say for example in the file system representation that an individual is accessing directories within his computer but he has never come into contact with a real life folder interaction, let alone one single manila folder. To accommodate this shortcoming, a designer would approach it like the way it was mentioned with the ergonomics in the "Cognetics and the Locus of Attention" reading, and disregard the few and obscure edge cases that wouldn't be able to use your interface. Seemingly enough, a large chunk of these properties will have to be disregarded to achieve a direct manipulation interface from the majority of its users.




Insuk Lee - 2/10/2014 17:15:51

Direct manipulation interface refers to those systems that lets the user feel like he/she is manipulating the object of interest directly to achieve his/her goals in using the system as the tool. It facilitates the process of using the interface, so that there are no wide gaps between the understanding of what the user wants to accomplish and how the system will actually let the user achieve this. I guess an example of a direct manipulation interface is Logism or Multism, used in CS61C and EE40, and these are solid software platforms that lets the users do complex things, but a problem is that it is hard to explore or find out about all the various options and settings available to the users without extensive training. They are direct manipulation interfaces by definition but do not present a good user experience/interface.


Brenton Dano - 2/10/2014 17:18:20

A direct manipulation interface is an interface that is designed to try to immerse the user intimately with the experience by giving them a view of the objects of the system and ways of directly operating on these objects in an intuitive way. It accomplishes this by continuously representing the important objects in the interface, by using physical actions such as drags, drops, and clicks on labeled buttons, and by immediately showing the impact of changes in the main view. This is seen as a sharp contrast to normal compiled code. In compiled code for example, your changes or errors won't be seen until compile time. With a DMI, if you connect your wiring incorrectly in the Logism DMI that we used in 61C, the wires will turn red instead of green, immediately telling the user that they did something wrong.

All though at first it seems like a DMI is the way to go, it has some drawbacks. For example, consider the example shown in the reading of the matrix math DMI. What if the user wants to do a large amount of calculations? With code, perhaps the user could iterate through a loop to do a shortcut for some calculations. With a DMI on the other hand, they would have to tediously draw many lines connecting rows with columns. Not only could this lead to carpal tunnel and frustration, but it is also very error prone. Another drawback is that it is hard to check how the user got to the state the interface is in. How many drags, drops, button presses got him to the current state? What if he wants to resume this state at a later time, but in the future, forgets where he was in his thought process. With code, you can use recent commits to refresh your thinking, but with a DMI a whole version control system would have to be implemented and its not necessarily clear the best way to do this.


Aman Sufi - 2/10/2014 17:25:06

Direct manipulation interfaces, as described in the reading, are interfaces that attempt to allow the user to interact with them in a way that requires less cognitive thought to understand how to use, which is defined as the ‘distance’ between the gulfs of execution and evaluation, and implements direct engagement, which the reading explains as the abstraction and method of manipulating data that should ideally lead the user to feel as if they are in direct control of the objects which they are interacting with rather than consciously perceiving the machine or having to learn and employ a new model in order to understand how to operate it. In particular, it is stressed that inter-referential I/O needs to be utilized, where the input and output devices are represented by the same model, in order to achieve a strong direct engagement between the user and the machine.

Direct manipulation interfaces are not always as concise or quick to use as the traditional interfaces they may come to supplant or supplement, even though they often make it easier to visualize and understand what is going on with less cognitive effort. Similar to the example in the reading, we can see the example of visual programming languages such as Labview and Matlab, where it is often easy to understand what is happening to data as you are able to place functions and tools on the screen such as the plot tool, but which are time-consuming to use as you have to pull up each individual object from a menu and decide where to plot it to keep the schematic organized. This is in comparison to traditional conversational programming languages where the complex diagram could be replaced by a few lines of code. Conversational programming languages foster automaticity naturally due to their repetitive tasks and so it is much easier to churn out lines of code quickly without thinking too much as compared to having to pull up and place each function or variable (which is another thing which is hard to represent in current direct manipulation interfaces) individually. Of course, knowing exactly what to type requires memorization in programming languages and is not as intuitive, but using such a system once you have learned its finer points is often much faster and more efficient than direct manipulation interface based languages.

Tying in to the other reading by Raskin, direct manipulation interfaces make it easier for us to keep the current item that we are working on in our locus of attention because objects are attempted to be displayed in an easy-to-understand and manipulate manner. It is harder to lose the train of thought while working with direct manipulation interfaces in general, and risk having our current thoughts depart back to our cognitive unconscious.


Chirag Mahapatra - 2/10/2014 17:25:26

The intention of direct manipulation is to allow a user to manipulate objects presented to them, using actions that correspond loosely to the physical world. An example of a direct manipulation is resizing a rectangle using a mouse.

Direct interfaces can be a burden because they generally take up more computing resources than a simple text interface. Consequently, they are harder to build and modify. For example, most simulation packages like Simulink, Sigma while being very graphical and intuitive, are limited when the user wants to build custom blocks. Compared to this in a text interface, the user has to write a piece of script to create new functionality.

Another big challenge of the direct manipulation interface is that we interact with the interface with things which we already know and think. It does not encourage us to think of new ways to interact with the application. Also it does not provide the user an easy way to learn a new system. It is best used when the user is a domain expert. Finally, it is really hard to program with a direct manipulation interface. Hence, most programming environments are based on scripts. Hence, we will still have conventional programming languages. The above are a few examples of where direct manipulation interfaces are problematic for users.


Robin Sylvan - 2/10/2014 17:29:59

A direct manipulation interface enables a user to interact with data in a cognitively accessible way. The example they used was with breaking up data in a matrix - this is very difficult to think about doing by hand, but using an interface where they circled a group, users could separate data in a way that seemed natural. Some things could be a burden to users if the manipulation is very repetitive. These could be done by some sort of script. Also, sometimes its not clear to the user what the interface is, and this can also give them problems.


Derrick Mar - 2/10/2014 17:30:26

If I were to example to someone as simply as possible what a direct manipulation interface is, I would say it is basically a GUI. Now with this explanation, you are probably still unclear about what exactly a direct manipulation interface exactly is and as the authors assert there is no precise definition of “directness” although there are some variables that provide boundaries such as distance and engagement. An example I like to give is the experience of using a mouse to stretch or shrink a window on a computer screen. In short, there is constant feedback to the user for a particular action. It is an effort to model the way we think in the real-world (when we pull something in we visualize it getting smaller).

Like anything in life, there are trade-offs. In terms of direct interfaces. As the authors state, it is much easier to use a command-line interface to automate repetition then a direct interface. Another good point that the authors bring up is that a direct interface can be limiting in terms of coming up with more innovative interfaces because it relies on what users already know and assume. A good example the shows the disadvantages of a direct interface is the website-creation application called WIX. It is a great tool to quickly create websites by dragging and dropping images, divs, and text. However, the ability to add dynamic parts to your website is limiting because of the interface's ability to handle multiple variables at once (something that is much easier to do in code).


Conan Cai - 2/10/2014 17:31:52

Direct manipulation is using physical interactions to continuously provide input. These interfaces are suited towards graphical tasks but they can also be burdensome. Physical interactions means that repetitive motion can cause strain on muscles and users may develop fatigue while using the interface. Physical controls can also be non intuitive and only learned when a user is shown how to physical manipulate something. Physical interactions can also be less precise than using some other kind of input. For example, using a mouse leads to greater precision while trying to "click" than does trying to use a finger and tap.


Romi Phadte - 2/10/2014 17:40:36

Direct Manipulation interfaces are interfaces that let you directly manipulate data or the interface. For example, labview would be a direct manipulation interface. If you want to use two functions, you drag lines from one to the other. 'The promise of direct manipulation is that instead of an abstract computational medium, all the "programming is done graphically" .'

There are issues of scale. For example for very repetitive tasks, a script is more often than not better than a repetitive action via direct manipulation. Additionally, direct manipulation doesn't necessarily mean "ease of use". It makes it easier to understand. However, problems involved with the domain of work may be transfered to the user interacting with the interface if the interface is indeed "invisible". Direct manipulation flies in the 2000 years of development moving towards abstract models. In certain situations like dealing with large data sets, sometimes abstract models are more convenient and less clunky.


Christopher Schechter - 2/10/2014 21:53:06

Direct manipulation interfaces are designed to take simple, intuitive input from the user to manipulate data in a way that reflects how one would think or otherwise interact with the data in the real world. In this way, data would be presented in a method that reflects the non-virtual world, so that the user would find manipulation to be a natural thing.

Problems can arise from this method of making interface easy for the users. Hutchins, Hollan, and Norman sum up most of these difficulties with their ideas of the "Gulf of Execution" and the "Gulf of Evaluation." The Gulf of Execution is, to put it simply, the idea that implementing such a high-level interface can make tasks more complex, with many input actions needed for certain tasks, and leaves plenty of room for user error. The Gulf of Evaluation is the idea that having high-level output can make it difficult for the user to know if the output matches what they want. Essentially, the drawbacks of a direct manipulation interface can be very similar to the drawbacks a person would face doing the same actions in real life, except that using a computer app might not always be as flexible as in real life.