Hubbry Logo
User interfaceUser interfaceMain
Open search
User interface
Community hub
User interface
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
User interface
User interface
User interface
View on Wikipedia
from Wikipedia

The Xfce desktop environment offers a graphical user interface following the desktop metaphor.

In the industrial design field of human–computer interaction, a user interface (UI) is the space where interactions between humans and machines occur. The goal of this interaction is to allow effective operation and control of the machine from the human end, while the machine simultaneously feeds back information that aids the operators' decision-making process. Examples of this broad concept of user interfaces include the interactive aspects of computer operating systems, hand tools, heavy machinery operator controls and process controls. The design considerations applicable when creating user interfaces are related to, or involve such disciplines as, ergonomics and psychology.

Generally, the goal of user interface design is to produce a user interface that makes it easy, efficient, and enjoyable (user-friendly) to operate a machine in the way which produces the desired result (i.e. maximum usability). This generally means that the operator needs to provide minimal input to achieve the desired output, and also that the machine minimizes undesired outputs to the user.

User interfaces are composed of one or more layers, including a human–machine interface (HMI) that typically interfaces machines with physical input hardware (such as keyboards, mice, or game pads) and output hardware (such as computer monitors, speakers, and printers). A device that implements an HMI is called a human interface device (HID). User interfaces that dispense with the physical movement of body parts as an intermediary step between the brain and the machine use no input or output devices except electrodes alone; they are called brain–computer interfaces (BCIs) or brain–machine interfaces (BMIs).

Other terms for human–machine interfaces are man–machine interface (MMI) and, when the machine in question is a computer, human–computer interface. Additional UI layers may interact with one or more human senses, including: tactile UI (touch), visual UI (sight), auditory UI (sound), olfactory UI (smell), equilibria UI (balance), and gustatory UI (taste).

Composite user interfaces (CUIs) are UIs that interact with two or more senses. The most common CUI is a graphical user interface (GUI), which is composed of a tactile UI and a visual UI capable of displaying graphics. When sound is added to a GUI, it becomes a multimedia user interface (MUI). There are three broad categories of CUI: standard, virtual and augmented. Standard CUI use standard human interface devices like keyboards, mice, and computer monitors. When the CUI blocks out the real world to create a virtual reality, the CUI is virtual and uses a virtual reality interface. When the CUI does not block out the real world and creates augmented reality, the CUI is augmented and uses an augmented reality interface. When a UI interacts with all human senses, it is called a qualia interface, named after the theory of qualia.[citation needed] CUI may also be classified by how many senses they interact with as either an X-sense virtual reality interface or X-sense augmented reality interface, where X is the number of senses interfaced with. For example, a Smell-O-Vision is a 3-sense (3S) Standard CUI with visual display, sound and smells; when virtual reality interfaces interface with smells and touch it is said to be a 4-sense (4S) virtual reality interface; and when augmented reality interfaces interface with smells and touch it is said to be a 4-sense (4S) augmented reality interface.

Overview

[edit]
The Reactable musical instrument, an example of a tangible user interface

The user interface or human–machine interface is the part of the machine that handles the human–machine interaction. Membrane switches, rubber keypads and touchscreens are examples of the physical part of the Human Machine Interface which we can see and touch.[1]

In complex systems, the human–machine interface is typically computerized. The term human–computer interface refers to this kind of system. In the context of computing, the term typically extends as well to the software dedicated to control the physical elements used for human–computer interaction.

The engineering of human–machine interfaces is enhanced by considering ergonomics (human factors). The corresponding disciplines are human factors engineering (HFE) and usability engineering (UE) which is part of systems engineering.

Tools used for incorporating human factors in the interface design are developed based on knowledge of computer science, such as computer graphics, operating systems, programming languages. Nowadays, we use the expression graphical user interface for human–machine interface on computers, as nearly all of them are now using graphics.[citation needed]

Multimodal interfaces allow users to interact using more than one modality of user input.[2]

Terminology

[edit]
A human–machine interface usually involves peripheral hardware for the INPUT and for the OUTPUT. Often, there is an additional component implemented in software, like e.g. a graphical user interface.

There is a difference between a user interface and an operator interface or a human–machine interface (HMI).

  • The term "user interface" is often used in the context of (personal) computer systems and electronic devices.
    • Where a network of equipment or computers are interlinked through an MES (Manufacturing Execution System)-or Host to display information.
    • A human–machine interface (HMI) is typically local to one machine or piece of equipment, and is the interface method between the human and the equipment/machine. An operator interface, on the other hand, is the interface method by which multiple pieces of equipment, linked by a host control system, are accessed or controlled.
    • The system may expose several user interfaces to serve different kinds of users. For example, a computerized library database might provide two user interfaces, one for library patrons (limited set of functions, optimized for ease of use) and the other for library personnel (wide set of functions, optimized for efficiency).[3]
  • The user interface of a mechanical system, a vehicle or an industrial installation is sometimes referred to as the human–machine interface (HMI).[4] HMI is a modification of the original term MMI (man–machine interface).[5] In practice, the abbreviation MMI is still frequently used[5] although some may claim that MMI stands for something different now.[citation needed] Another abbreviation is HCI, but is more commonly used for human–computer interaction.[5] Other terms used are operator interface console (OIC) and operator interface terminal (OIT).[6] However it is abbreviated, the terms refer to the 'layer' that separates a human that is operating a machine from the machine itself.[5] Without a clean and usable interface, humans would not be able to interact with information systems.

In science fiction, HMI is sometimes used to refer to what is better described as a direct neural interface. However, this latter usage is seeing increasing application in the real-life use of (medical) prostheses—the artificial extension that replaces a missing body part (e.g., cochlear implants).[7][8]

In some circumstances, computers might observe the user and react according to their actions without specific commands. A means of tracking parts of the body is required, and sensors noting the position of the head, direction of gaze and so on have been used experimentally. This is particularly relevant to immersive interfaces.[9][10]

History

[edit]

The history of user interfaces can be divided into the following phases according to the dominant type of user interface:

1945–1968: Batch interface

[edit]
IBM 029 card punch
IBM 029

In the batch era, computing power was extremely scarce and expensive. User interfaces were rudimentary. Users had to accommodate computers rather than the other way around; user interfaces were considered overhead, and software was designed to keep the processor at maximum utilization with as little overhead as possible.

The input side of the user interfaces for batch machines was mainly punched cards or equivalent media like paper tape. The output side added line printers to these media. With the limited exception of the system operator's console, human beings did not interact with batch machines in real time at all.

Submitting a job to a batch machine involved first preparing a deck of punched cards that described a program and its dataset. The program cards were not punched on the computer itself but on keypunches, specialized, typewriter-like machines that were notoriously bulky, unforgiving, and prone to mechanical failure. The software interface was similarly unforgiving, with very strict syntaxes designed to be parsed by the smallest possible compilers and interpreters.

Holes are punched in the card according to a prearranged code transferring the facts from the census questionnaire into statistics.

Once the cards were punched, one would drop them in a job queue and wait. Eventually, operators would feed the deck to the computer, perhaps mounting magnetic tapes to supply another dataset or helper software. The job would generate a printout, containing final results or an abort notice with an attached error log. Successful runs might also write a result on magnetic tape or generate some data cards to be used in a later computation.

The turnaround time for a single job often spanned entire days. If one was very lucky, it might be hours; there was no real-time response. But there were worse fates than the card queue; some computers required an even more tedious and error-prone process of toggling in programs in binary code using console switches. The very earliest machines had to be partly rewired to incorporate program logic into themselves, using devices known as plugboards.

Early batch systems gave the currently running job the entire computer; program decks and tapes had to include what we would now think of as operating system code to talk to I/O devices and do whatever other housekeeping was needed. Midway through the batch period, after 1957, various groups began to experiment with so-called "load-and-go" systems. These used a monitor program which was always resident on the computer. Programs could call the monitor for services. Another function of the monitor was to do better error checking on submitted jobs, catching errors earlier and more intelligently and generating more useful feedback to the users. Thus, monitors represented the first step towards both operating systems and explicitly designed user interfaces.

1969–present: Command-line user interface

[edit]
Main article: Command-line interface
Teletype Model 33
Teletype Model 33 ASR

Command-line interfaces (CLIs) evolved from batch monitors connected to the system console. Their interaction model was a series of request-response transactions, with requests expressed as textual commands in a specialized vocabulary. Latency was far lower than for batch systems, dropping from days or hours to seconds. Accordingly, command-line systems allowed the user to change their mind about later stages of the transaction in response to real-time or near-real-time feedback on earlier results. Software could be exploratory and interactive in ways not possible before. But these interfaces still placed a relatively heavy mnemonic load on the user, requiring a serious investment of effort and learning time to master.[11]

The earliest command-line systems combined teleprinters with computers, adapting a mature technology that had proven effective for mediating the transfer of information over wires between human beings. Teleprinters had originally been invented as devices for automatic telegraph transmission and reception; they had a history going back to 1902 and had already become well-established in newsrooms and elsewhere by 1920. In reusing them, economy was certainly a consideration, but psychology and the rule of least surprise mattered as well; teleprinters provided a point of interface with the system that was familiar to many engineers and users.

The VT100, introduced in 197″8, was the most popular VDT of all time. Most terminal emulators still default to VT100 mode.
DEC VT100 terminal

The widespread adoption of video-display terminals (VDTs) in the mid-1970s ushered in the second phase of command-line systems. These cut latency further, because characters could be thrown on the phosphor dots of a screen more quickly than a printer head or carriage can move. They helped quell conservative resistance to interactive programming by cutting ink and paper consumables out of the cost picture, and were to the first TV generation of the late 1950s and 60s even more iconic and comfortable than teleprinters had been to the computer pioneers of the 1940s.

Just as importantly, the existence of an accessible screen—a two-dimensional display of text that could be rapidly and reversibly modified—made it economical for software designers to deploy interfaces that could be described as visual rather than textual. The pioneering applications of this kind were computer games and text editors; close descendants of some of the earliest specimens, such as rogue(6), and vi(1), are still a live part of Unix tradition.

1985: SAA user interface or text-based user interface

[edit]

In 1985, with the beginning of Microsoft Windows and other graphical user interfaces, IBM created what is called the Systems Application Architecture (SAA) standard which include the Common User Access (CUA) derivative. CUA successfully created what we know and use today in Windows, and most of the more recent MS-DOS or Windows Console Applications will use that standard as well.

This defined that a pulldown menu system should be at the top of the screen, status bar at the bottom, shortcut keys should stay the same for all common functionality (F2 to Open for example would work in all applications that followed the SAA standard). This greatly helped the speed at which users could learn an application so it caught on quick and became an industry standard.[12]

1968–present: Graphical user interface

[edit]
Main article: Graphical user interface
AMX Desk made a basic WIMP GUI.
Linotype WYSIWYG 2000, 1989
  • 1968 – Douglas Engelbart demonstrated NLS, a system which uses a mouse, pointers, hypertext, and multiple windows.[13]
  • 1970 – Researchers at Xerox Palo Alto Research Center (many from SRI) develop WIMP paradigm (Windows, Icons, Menus, Pointers)[13]
  • 1973 – Xerox Alto: commercial failure due to expense, poor user interface, and lack of programs[13]
  • 1979 – Steve Jobs and other Apple engineers visit Xerox PARC. Though Pirates of Silicon Valley dramatizes the events, Apple had already been working on developing a GUI, such as the Macintosh and Lisa projects, before the visit.[14][15]
  • 1981 – Xerox Star: focus on WYSIWYG. Commercial failure (25K sold) due to cost ($16K each), performance (minutes to save a file, couple of hours to recover from crash), and poor marketing
  • 1982 – Rob Pike and others at Bell Labs designed Blit, which was released in 1984 by AT&T and Teletype as DMD 5620 terminal.
  • 1984 – Apple Macintosh popularizes the GUI. Super Bowl commercial shown twice, was the most expensive commercial ever made at that time
  • 1984 – MIT's X Window System: hardware-independent platform and networking protocol for developing GUIs on UNIX-like systems
  • 1985 – Windows 1.0 – provided GUI interface to MS-DOS. No overlapping windows (tiled instead).
  • 1985 – Microsoft and IBM start work on OS/2 meant to eventually replace MS-DOS and Windows
  • 1986 – Apple threatens to sue Digital Research because their GUI desktop looked too much like Apple's Mac.
  • 1987 – Windows 2.0 – Overlapping and resizable windows, keyboard and mouse enhancements
  • 1987 – Macintosh II: first full-color Mac
  • 1988 – OS/2 1.10 Standard Edition (SE) has GUI written by Microsoft, looks a lot like Windows 2

Interface design

[edit]
Main article: User interface design

Primary methods used in the interface design include prototyping and simulation.

Typical human–machine interface design consists of the following stages: interaction specification, interface software specification and prototyping:

  • Common practices for interaction specification include user-centered design, persona, activity-oriented design, scenario-based design, and resiliency design.
  • Common practices for interface software specification include use cases and constrain enforcement by interaction protocols (intended to avoid use errors).
  • Common practices for prototyping are based on libraries of interface elements (controls, decoration, etc.).

Principles of quality

[edit]

In broad terms, interfaces generally regarded as user friendly, efficient, intuitive, etc. are typified by one or more particular qualities. For the purpose of example, a non-exhaustive list of such characteristics follows:

  1. Clarity: The interface avoids ambiguity by making everything clear through language, flow, hierarchy and metaphors for visual elements.
  2. Concision:[16] However ironically, the over-clarification of information—for instance, by labelling the majority, if not the entirety, of items displayed on-screen at once, and regardless of whether or not the user would in fact require a visual indicator of some kind in order to identify a given item—can, and, under most normal circumstances, most likely will lead to the obfuscation of whatever information.
  3. Familiarity:[17] Even if someone uses an interface for the first time, certain elements can still be familiar. Real-life metaphors can be used to communicate meaning.
  4. Responsiveness:[18] A good interface should not feel sluggish. This means that the interface should provide good feedback to the user about what's happening and whether the user's input is being successfully processed.
  5. Consistency:[19] Keeping your interface consistent across your application is important because it allows users to recognize usage patterns.
  6. Aesthetics: While you do not need to make an interface attractive for it to do its job, making something look good will make the time your users spend using your application more enjoyable; and happier users can only be a good thing.
  7. Efficiency: Time is money, and a great interface should make the user more productive through shortcuts and good design.
  8. Forgiveness: A good interface should not punish users for their mistakes but should instead provide the means to remedy them.

Principle of least astonishment

[edit]

The principle of least astonishment (POLA) is a general principle in the design of all kinds of interfaces. It is based on the idea that human beings can only pay full attention to one thing at one time,[20] leading to the conclusion that novelty should be minimized.

Principle of habit formation

[edit]

If an interface is used persistently, the user will unavoidably develop habits for using the interface. The designer's role can thus be characterized as ensuring the user forms good habits. If the designer is experienced with other interfaces, they will similarly develop habits, and often make unconscious assumptions regarding how the user will interact with the interface.[20][21]

A model of design criteria: User Experience Honeycomb

[edit]
User interface / user experience guide
User Experience Design Honeycomb[22] designed by Peter Morville[23]

Peter Morville of Google designed the User Experience Honeycomb framework in 2004 when leading operations in user interface design. The framework was created to guide user interface design. It would act as a guideline for many web development students for a decade.[23]

  1. Usable: Is the design of the system easy and simple to use? The application should feel familiar, and it should be easy to use.[23][22]
  2. Useful: Does the application fulfill a need? A business's product or service needs to be useful.[22]
  3. Desirable: Is the design of the application sleek and to the point? The aesthetics of the system should be attractive, and easy to translate.[22]
  4. Findable: Are users able to quickly find the information they are looking for? Information needs to be findable and simple to navigate. A user should never have to hunt for your product or information.[22]
  5. Accessible: Does the application support enlarged text without breaking the framework? An application should be accessible to those with disabilities.[22]
  6. Credible: Does the application exhibit trustworthy security and company details? An application should be transparent, secure, and honest.[22]
  7. Valuable: Does the end-user think it's valuable? If all 6 criteria are met, the end-user will find value and trust in the application.[22]

Types

[edit]
Touchscreen of the HP Series 100 HP-150
HP Series 100 HP-150 touchscreen
  1. Attentive user interfaces manage the user attention deciding when to interrupt the user, the kind of warnings, and the level of detail of the messages presented to the user.
  2. Batch interfaces are non-interactive user interfaces, where the user specifies all the details of the batch job in advance to batch processing, and receives the output when all the processing is done. The computer does not prompt for further input after the processing has started.
  3. Command line interfaces (CLIs) prompt the user to provide input by typing a command string with the computer keyboard and respond by outputting text to the computer monitor. Used by programmers and system administrators, in engineering and scientific environments, and by technically advanced personal computer users.
  4. Conversational interfaces enable users to command the computer with plain text English (e.g., via text messages, or chatbots) or voice commands, instead of graphic elements. These interfaces often emulate human-to-human conversations.[24]
  5. Conversational interface agents attempt to personify the computer interface in the form of an animated person, robot, or other character (such as Microsoft's Clippy the paperclip), and present interactions in a conversational form.
  6. Crossing-based interfaces are graphical user interfaces in which the primary task consists in crossing boundaries instead of pointing.
  7. Direct manipulation interface is a general class of user interfaces that allow users to manipulate objects presented to them, using actions that correspond to the physical world, at least loosely.
  8. Gesture interfaces are graphical user interfaces which accept input in a form of hand gestures, or mouse gestures sketched with a computer mouse or a stylus.
  9. Graphical user interfaces (GUI) accept input via devices such as a computer keyboard and mouse and provide articulated graphical output on the computer monitor.[25] There are at least two different principles widely used in GUI design: Object-oriented user interfaces (OOUIs) and application-oriented interfaces.[26]
  10. Hardware interfaces are the physical, spatial interfaces found on products in the real world from toasters, to car dashboards, to airplane cockpits. They are generally a mixture of knobs, buttons, sliders, switches, and touchscreens.
  11. Holographic user interfaces provide input to electronic or electro-mechanical devices by passing a finger through reproduced holographic images of what would otherwise be tactile controls of those devices, floating freely in the air, detected by a wave source and without tactile interaction.
  12. Intelligent user interfaces are human–machine interfaces that aim to improve the efficiency, effectiveness, and naturalness of human–machine interaction by representing, reasoning, and acting on models of the user, domain, task, discourse, and media (e.g., graphics, natural language, gesture).
  13. Motion tracking interfaces monitor the user's body motions and translate them into commands, some techniques of which were at one point patented by Apple.[27]
  14. Multi-screen interfaces, employ multiple displays to provide a more flexible interaction. This is often employed in computer game interaction in both the commercial arcades and more recently the handheld markets.
  15. Natural-language interfaces are used for search engines and on webpages. User types in a question and waits for a response.
  16. Non-command user interfaces, which observe the user to infer their needs and intentions, without requiring that they formulate explicit commands.[28]
  17. Object-oriented user interfaces (OOUI) are based on object-oriented programming metaphors, allowing users to manipulate simulated objects and their properties.
  18. Permission-driven user interfaces show or conceal menu options or functions depending on the user's level of permissions. The system is intended to improve the user experience by removing items that are unavailable to the user. A user who sees functions that are unavailable for use may become frustrated. It also provides an enhancement to security by hiding functional items from unauthorized persons.
  19. Reflexive user interfaces where the users control and redefine the entire system via the user interface alone, for instance to change its command verbs. Typically, this is only possible with very rich graphic user interfaces.
  20. Search interface is how the search box of a site is displayed, as well as the visual representation of the search results.
  21. Tangible user interfaces, which place a greater emphasis on touch and physical environment or its element.
  22. Task-focused interfaces are user interfaces which address the information overload problem of the desktop metaphor by making tasks, not files, the primary unit of interaction.
  23. Text-based user interfaces (TUIs) are user interfaces which interact via text. TUIs include command-line interfaces and text-based WIMP environments.
  24. Touchscreens are displays that accept input by touch of fingers or a stylus. Used in a growing amount of mobile devices and many types of point of sale, industrial processes and machines, self-service machines, etc.
  25. Touch user interface are graphical user interfaces using a touchpad or touchscreen display as a combined input and output device. They supplement or replace other forms of output with haptic feedback methods. Used in computerized simulators, etc.
  26. Voice user interfaces, which accept input and provide output by generating voice prompts. The user input is made by pressing keys or buttons, or responding verbally to the interface.
  27. Zero-input interfaces get inputs from a set of sensors instead of querying the user with input dialogs.[29]
  28. Zooming user interfaces are graphical user interfaces in which information objects are represented at different levels of scale and detail, and where the user can change the scale of the viewed area in order to show more detail.
[edit]

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

User interface

View on Grokipedia
from Grokipedia
A user interface (UI) is the component of an interactive system that enables communication between a user and a , such as a computer, software application, or electronic device, by facilitating the input of commands and the presentation of output through sensory channels like sight, sound, or touch. It represents the only portion of the system directly perceptible to the user, serving as the boundary where intentions are translated into actions and vice versa. User interfaces encompass a range of elements designed to support effective interaction, often modeled through frameworks like DIRA, which breaks them down into four core components: devices (hardware for input/output, such as keyboards or screens), interaction techniques (methods like clicking or swiping), representations (visual or auditory depictions of data), and assemblies (how these elements combine into cohesive structures). Effective UI design prioritizes , consistency, and reduced , guided by principles such as placing the user in control, minimizing memory demands through intuitive cues, and ensuring uniformity across interactions to prevent errors and enhance efficiency. The evolution of user interfaces parallels the , originating with rudimentary batch processing systems in the mid-20th century, where users submitted jobs via punched cards without direct feedback. By the , command-line interfaces (CLI) emerged as the dominant form, allowing text-based input and output on terminals, as seen in systems like those developed for mainframes. The 1970s marked a pivotal shift with the advent of graphical user interfaces (GUI), pioneered by researchers including Douglas Engelbart's demonstration of the mouse and windows in 1968, and further advanced at Xerox PARC through innovations like icons, menus, and direct manipulation by and his team. These developments laid the foundation for modern GUIs commercialized in the 1980s by products like the Apple Macintosh and Windows, transforming from expert-only tools to accessible platforms for broad audiences. Contemporary user interfaces extend beyond traditional GUIs to include diverse types tailored to specific contexts and technologies. Graphical user interfaces (GUI) rely on visual elements like windows and icons for mouse- or keyboard-driven navigation, while touchscreen interfaces enable direct manipulation via fingers on mobile devices. Voice user interfaces (VUI), powered by , allow hands-free interaction as in virtual assistants like , and gesture-based interfaces use body movements for control in immersive environments like . Command-line interfaces (CLI) persist in technical domains for precise, scriptable operations, and menu-driven interfaces guide users through hierarchical options in embedded systems. Recent advancements, including multimodal and adaptive UIs, integrate multiple input methods and personalize experiences based on user context, reflecting ongoing research in human-computer interaction (HCI) to improve accessibility and inclusivity.

Fundamentals

Definition and Scope

A user interface (UI) serves as the medium through which a human user interacts with a , , or device, enabling the bidirectional exchange of information to achieve intended tasks. This interaction point encompasses the mechanisms that translate user intentions into machine actions and vice versa, forming the foundational layer of human-machine communication. The scope of user interfaces is broad, spanning digital computing environments—such as software applications and hardware peripherals—and extending to non-digital contexts, including physical controls on everyday appliances like stoves and washing machines, as well as instrument panels in vehicles that provide drivers with essential operational feedback. Over time, UIs have evolved from predominantly physical affordances, such as mechanical switches and dials, to increasingly virtual and multimodal forms that support seamless integration across these domains. At its core, a UI comprises input methods that capture user commands, including traditional devices like keyboards and pointing devices, as well as modern techniques such as touch gestures and voice recognition; output methods that deliver system responses, ranging from visual displays and textual readouts to auditory cues and tactile vibrations; and iterative feedback loops that confirm user actions, highlight discrepancies, or guide corrections to maintain effective dialogue between user and system. While closely related, UI must be distinguished from (UX), which addresses the holistic emotional, cognitive, and behavioral outcomes of interaction; UI specifically denotes the concrete, perceivable elements and pathways of engagement that users directly manipulate.

Key Terminology

In user interface (UI) design, refers to the perceived and actual properties of an object or element that determine possible actions a user can take with it, such as a button appearing clickable due to its raised appearance or shadow. This concept, originally from and adapted to HCI by Donald Norman, emphasizes how design cues signal interaction possibilities without explicit instructions. A in UI design is a conceptual mapping that leverages familiar real-world analogies to make abstract digital interactions intuitive, such as the where files appear as icons that can be dragged like physical documents. This approach reduces by transferring users' existing knowledge to the interface, as outlined in foundational HCI literature. An interaction paradigm describes a fundamental style of user engagement with a system, exemplified by direct manipulation, where users perform operations by directly acting on visible representations of objects, such as resizing a by dragging its edge, providing immediate visual feedback. Coined by in 1983, this paradigm contrasts with indirect methods like command-line inputs and has become central to graphical interfaces. UI-specific jargon includes widget, an interactive control element in graphical user interfaces, such as buttons, sliders, or menus, that enables user input or displays dynamic information. Layout denotes the spatial arrangement of these elements on the screen, organizing content hierarchically to guide attention and navigation, often using grids or flow-based systems for . State represents the current configuration of the interface, encompassing , , and properties of elements that dictate rendering and behavior at any moment, such as a loading spinner indicating ongoing processing. Key distinctions in UI discourse include UI versus UX, where UI focuses on the tangible elements users interact with—the "what" of buttons, layouts, and visuals—while UX encompasses the overall emotional and practical experience—the "how it feels" in terms of ease, satisfaction, and efficiency. Similarly, front-end refers to the client-facing layer of development handling UI rendering via technologies like , CSS, and , whereas back-end manages server-side logic, data storage, and security invisible to users. The Xerox Alto computer, developed at Xerox PARC in 1973, introduced overlapping resizable windows as a core component of its pioneering graphical user interface, enabling multitasking through spatial organization of content.

Historical Evolution

Early Batch and Command-Line Interfaces (1945–1980s)

The earliest user interfaces in computing emerged during the post-World War II era with batch processing systems, which dominated from the mid-1940s to the 1960s. These systems relied on punched cards or tape as the primary input medium for programs and data, processed offline in non-real-time batches on massive mainframe computers. The ENIAC, completed in 1945 as the first general-purpose electronic digital computer, used plugboards and switches for configuration, but subsequent machines like the UNIVAC I (delivered in 1951) standardized punched cards for job submission, where operators would queue decks of cards representing entire programs for sequential execution without user intervention during runtime. This approach maximized hardware efficiency on expensive, room-sized machines but enforced a rigid, one-way interaction model, with output typically printed on paper after hours or days of processing. The transition to command-line interfaces began in the 1960s with the advent of systems, enabling multiple users to interact interactively via teletype terminals connected to a central mainframe. The (CTSS), developed at MIT in 1961 under Fernando Corbató, ran on an and allowed up to 30 users to edit and execute programs concurrently through typed commands, marking a shift from batch queues to real-time responsiveness. This model influenced subsequent systems, culminating in UNIX, initiated in 1969 at by and as a lightweight, multi-user operating system written initially in . UNIX's command-line paradigm emphasized a shell for interpreting text-based commands, fostering modular tools like for chaining operations, which streamlined programmer workflows on and later minicomputers. Key advancements in the further refined command-line access, including the , introduced in 1977 by Stephen Bourne at as part of UNIX Version 7. This shell provided structured scripting with variables, control structures, and job control, serving as the default interface for issuing commands like file manipulation (e.g., for listing directories) and process management, thereby standardizing interactive sessions across UNIX installations. DARPA's , operational since its first connection in 1969, extended remote access by linking university and research computers over packet-switched networks, allowing users to log in from distant terminals and execute commands on remote hosts via protocols like , which democratized access to shared resources beyond local facilities. Despite these innovations, early batch and command-line interfaces suffered from significant limitations, including a profound lack of visual feedback—users received no immediate graphical confirmation of actions, relying instead on text output or printouts that could take extended periods to appear, often leading to delays. Error proneness was rampant due to the unforgiving nature of punched cards, where a single misalignment or punch invalidated an entire job deck, necessitating manual re-entry and resubmission in batch systems. Command-line errors, such as mistyped in CTSS or UNIX shells, provided terse feedback like "command not found," exacerbating issues without intuitive aids, and required users to memorize opaque without on-screen hints. In social context, these interfaces were explicitly designed for expert programmers and engineers rather than general end-users, reflecting the era's view of computers as specialized tools for scientific and computation. High learning curves stemmed from the need for deep knowledge of machine architecture and low-level syntax, with interactions optimized for batch efficiency or terminal throughput over accessibility—non-experts were effectively excluded, as systems like demanded physical reconfiguration by technicians, and even time-sharing prioritized resource allocation for skilled operators. This programmer-centric focus, prevalent through the , underscored a where was secondary to raw computational power, limiting broader adoption until subsequent interface evolutions.

Emergence of Graphical and Text-Based Interfaces (1960s–1990s)

The emergence of graphical user interfaces (GUIs) in the 1960s marked a pivotal shift from purely text-based interactions, enabling direct manipulation of visual elements on screens. Ivan Sutherland's system, developed in 1963 as part of his MIT doctoral thesis, introduced foundational concepts such as interactive drawing with a , constraint-based object manipulation, and zoomable windows, laying the groundwork for modern and user-driven design tools. This innovation demonstrated how users could intuitively create and edit diagrams, influencing subsequent research in human-computer interaction. Building on this, Douglas Engelbart's oN-Line System (NLS) at the Stanford Research Institute in 1968 showcased the "Mother of All Demos," featuring a mouse-driven interface with hypertext links, shared screens, and collaborative editing capabilities that foreshadowed networked computing environments. The 1970s saw further advancements at Xerox PARC, where the Alto computer, released in 1973, integrated windows, icons, menus, and a pointer—core elements of the emerging (windows, icons, menus, pointer) paradigm—allowing users to manage multiple applications visually on a display. Developed by researchers like and , the Alto emphasized and desktop metaphors, such as file folders represented as icons, which made abstract computing tasks more accessible to non-experts. These systems, though experimental and limited to research labs, proved GUIs could enhance productivity by reducing reliance on memorized commands. Parallel to graphical innovations, text-based interfaces evolved toward greater standardization in the 1980s to improve consistency across applications. Microsoft's , introduced in 1981 for the PC, provided a command-line environment with rudimentary text menus and , enabling early personal computing but still requiring users to type precise syntax. 's Systems Application Architecture (SAA), launched in 1987, addressed fragmentation by defining common user interface standards for menus, dialogs, and keyboard shortcuts across its DOS, , and mainframe systems, promoting interoperability in enterprise software like early word processors such as . This framework influenced text UIs in productivity tools, making them more predictable without full graphical overhead. The commercialization of GUIs accelerated in the mid-1980s, with Apple's Lisa computer in 1983 introducing the first affordable GUI for office use, featuring pull-down menus, icons, and a on a display. Despite its high cost of $9,995, the Lisa's bitmapped screen and drew from innovations to support drag-and-drop file management. The Apple Macintosh, released in 1984 at a more accessible $2,495, popularized these elements through its "1984" advertisement and intuitive design, rapidly expanding GUI adoption among consumers and small businesses. The WIMP paradigm, refined at PARC and implemented in these systems, became the dominant model, emphasizing visual feedback and pointer-based navigation over text commands. Despite these breakthroughs, early GUIs faced significant challenges from hardware constraints and adoption hurdles. Low-resolution displays, such as the Alto's 72 dpi bitmap screen or the Macintosh's 72 dpi , limited visual fidelity and made complex interactions cumbersome, often requiring users to tolerate jagged graphics and slow redraws. In enterprise settings, resistance stemmed from the high cost of GUI-capable hardware—exemplified by the Lisa's failure to sell beyond 100,000 units due to pricing—and entrenched preferences for efficient text-based systems that conserved resources on mainframes. Outside the West, Japan's research contributed uniquely; for instance, NEC's PC-8001 series in the late 1970s incorporated early graphical modes for word processing with support, adapting GUI concepts to handle complex scripts amid the rise of dedicated Japanese text processors like the QX-10 in 1979. These developments helped bridge cultural and linguistic barriers, fostering GUI experimentation in during the personal boom.

Modern Developments (2000s–Present)

The 2000s marked a transformative era for user interfaces with the advent of mobile and touch-based systems, shifting interactions from physical keyboards and styluses to direct, intuitive finger inputs. Apple's , released in 2007, pioneered a display that supported like tapping, swiping, and multi-finger pinching, enabling users to manipulate on-screen elements in a fluid, natural manner without intermediary tools. This innovation drew from earlier research in capacitive touch sensing but scaled it for consumer devices, fundamentally altering by prioritizing gesture over command-line or button-based navigation. Google's Android platform, launched in 2008, complemented this by introducing an open-source ecosystem that emphasized UI customization, allowing users to modify home screens, widgets, and themes through developer tools and app integrations, which democratized interface across diverse hardware. The transition from stylus-reliant devices, such as PDAs in the , to gesture-based exemplified this evolution; the pinch-to-zoom , popularized on the iPhone, permitted effortless content scaling via two-finger spreading or pinching, reducing and enhancing for visual tasks like map navigation or photo viewing. Entering the 2010s, web user interfaces evolved toward responsiveness and dynamism, driven by standards and frameworks that supported seamless cross-device experiences. The specification, finalized as a W3C Recommendation in 2014, introduced native support for multimedia, canvas rendering, and real-time communication via APIs like WebSockets, eliminating reliance on plugins like Flash and enabling interactive elements such as drag-and-drop and video playback directly in browsers. This facilitated responsive design principles, where UIs adapt layouts fluidly to screen sizes using CSS , a cornerstone for mobile-first web applications. Concurrently, Facebook's React framework, open-sourced in 2013, revolutionized single-page applications (SPAs) by employing a for efficient updates, allowing developers to build component-based interfaces that render dynamically without full page refreshes, thus improving performance and user engagement on platforms like and sites. The 2020s have integrated and multimodal capabilities into user interfaces, fostering adaptive and context-aware interactions that anticipate user needs. Apple's , debuted in 2011 as an voice assistant, leveraged to handle queries via speech, marking an early step toward conversational UIs; by 2025, it had evolved into a multimodal system incorporating voice, text, visual cues, and device sensors for integrated responses across apps and ecosystems. In November 2025, Apple reportedly planned to integrate a custom version of Google's Gemini AI model to further enhance Siri's reasoning, context awareness, and multimodal processing while maintaining through on-device and private compute. In parallel, augmented and interfaces advanced with zero-touch paradigms, as seen in Apple's Vision Pro headset launched in 2024, which uses eye-tracking, hand gestures, and voice controls for —allowing users to manipulate 3D content through natural movements without physical controllers, blending digital overlays with real-world environments for immersive productivity and entertainment. Overarching trends in this period include machine learning-driven , where algorithms analyze user data to tailor interfaces—such as recommending layouts or content based on behavior—enhancing relevance but amplifying privacy risks through pervasive tracking. Ethical concerns have intensified around manipulative designs known as dark patterns, which exploit cognitive biases to nudge users toward unintended actions like excessive data sharing or subscriptions; these practices prompted regulatory responses, including the European Union's (GDPR) enacted in 2018, which enforces transparent consent interfaces and prohibits deceptive UIs to safeguard user autonomy in digital interactions.

Types of Interfaces

Command-Line and Text-Based Interfaces

Command-line interfaces (CLIs) and text-based user interfaces (TUIs) represent foundational paradigms for interacting with computer systems through textual input and output, primarily via keyboard commands processed in a terminal environment. In CLIs, users enter commands in a sequential, line-by-line format, which the system interprets and executes, returning results as streams to the console. This mechanic enables direct, precise control over system operations without reliance on visual metaphors or pointing devices. For instance, the Bourne Again SHell (Bash), developed by Brian Fox for the GNU Project and first released in 1989, exemplifies this approach by providing an interactive shell for systems that processes typed commands and supports command history and editing features. Similarly, Microsoft PowerShell, initially released in November 2006 as an extensible automation engine, extends CLI mechanics to Windows environments, allowing object-oriented scripting and integration with .NET for administrative tasks. These interfaces remain integral to modern computing as of 2025, powering routine operations in distributions and server management. The advantages of CLIs and TUIs lie in their efficiency for experienced users, minimal resource demands, and robust support for through scripting. Expert operators can execute complex sequences rapidly by typing concise commands, often outperforming graphical alternatives in speed and precision for repetitive or remote tasks. Unlike graphical interfaces, which require rendering overhead, text-based systems consume fewer computational resources, making them suitable for resource-constrained environments and enabling operation on headless servers. A key enabler of scripting is the mechanism in systems, invented by Douglas McIlroy and introduced in Version 3 Unix in 1973, which chains command outputs as inputs to subsequent commands (e.g., ls | [grep](/page/Grep) file), facilitating modular, composable workflows without intermediate files. This of small, specialized tools connected via pipes promotes reusable scripts, enhancing productivity in programming and system administration. Variants of text-based interfaces include terminal emulators and TUIs that add structure to the basic CLI model. Terminal emulators simulate hardware terminals within graphical desktops, providing a windowed environment for text I/O; , created in 1984 by Mark Vandevoorde for the , was an early example, emulating DEC VT102 terminals to run legacy applications. TUIs build on this by incorporating pseudo-graphical elements like menus, windows, and forms using text characters, often via libraries such as . Originating from the original curses library developed around 1980 at the , to support screen-oriented games like Rogue, (as a modern, portable implementation) enables developers to create interactive, block-oriented layouts in terminals without full graphical support. These variants maintain text-only constraints while improving usability for configuration tools and editors. In contemporary applications, CLIs and TUIs dominate practices and embedded systems due to their automation potential and reliability in non-interactive contexts. Tools like the AWS Command Line Interface (AWS CLI), generally available since September 2, 2013, allow developers to manage cloud resources programmatically, integrating with pipelines for tasks such as deploying . In workflows, AWS CLI commands enable scripted orchestration of services like EC2 and S3, reducing manual intervention and supporting scalable automation. For embedded systems, CLIs provide lightweight debugging and control interfaces over serial connections, allowing engineers to test features without graphical overhead; for example, UART-based shells in microcontrollers facilitate real-time diagnostics and configuration in resource-limited devices like IoT sensors. These uses underscore the enduring role of text-based interfaces in high-efficiency, backend-oriented computing as of 2025.

Graphical User Interfaces

Graphical user interfaces (GUIs) represent a in human-computer interaction that employs visual elements to facilitate user engagement with digital systems, primarily through desktop operating systems and web browsers. Originating from at PARC in the 1970s, GUIs shifted computing from text-based commands to direct manipulation via graphical metaphors, enabling users to interact with on-screen representations of objects and actions. This approach, formalized as the model—standing for windows, icons, menus, and pointer—became the foundational structure for modern visual interfaces, allowing intuitive navigation without requiring memorized syntax. The core structure of GUIs revolves around elements designed to support efficient multitasking and object-oriented interaction. Windows provide resizable, overlapping frames for running multiple applications simultaneously, enabling users to organize and switch between tasks seamlessly. Icons serve as visual shortcuts to files, folders, or programs, allowing quick selection and manipulation through point-and-click actions. Menus offer hierarchical lists of options, typically accessed via pull-down or context mechanisms, to present commands in a structured manner. The pointer, controlled by devices like the , acts as the primary selection tool, translating physical gestures into precise on-screen movements for dragging, dropping, and highlighting. Prominent examples of WIMP-based GUIs include Microsoft's , released in 2021, which enhances multitasking with features like Snap Layouts for arranging windows in predefined grids and virtual desktops for workspace segregation. Similarly, desktop environment, initially developed in 1997 as part of the GNU Project, embodies WIMP principles in distributions; its 2025 update in version 49 introduces refined window management, adaptive theming, and improved pointer interactions for high-resolution displays. These implementations demonstrate how WIMP elements persist as the backbone of desktop GUIs, adapting to contemporary hardware and user needs. In web environments, GUIs evolved through browser technologies that extended concepts to distributed applications. Cascading Style Sheets (CSS), standardized by the W3C in 1996, enabled the separation of visual presentation from content, allowing developers to create icon-like elements, window-resembling panels, and menu structures using layout properties. , introduced in 1995 by , added dynamic interactivity, powering pointer-driven events such as hover effects and drag-and-drop functionalities that mimic desktop behaviors. Responsive design principles further advanced web GUIs by ensuring adaptability across devices; for instance, Bootstrap, launched in 2011 by engineers, provides a mobile-first grid system and component library that facilitates consistent -style interfaces on varying screen sizes. GUIs offer distinct advantages, particularly in accessibility for novice users, by leveraging visual feedback and spatial metaphors that align with human perceptual strengths, reducing the cognitive effort needed to learn and perform tasks compared to command-line alternatives. This intuitiveness stems from direct manipulation, where users see immediate results of actions like resizing windows or selecting icons, fostering a sense of control and reducing error rates in routine operations. Hardware enablers have been crucial: the , invented by in 1964 at , provided precise pointer control essential for WIMP interactions, though it gained widespread adoption only in the with the Apple Macintosh's integration of graphical displays. High-DPI screens, popularized since Apple's Retina displays in 2010, enhance visual clarity by rendering finer icons and text, improving feedback precision on modern devices without straining user eyesight. Despite these benefits, GUIs face challenges such as , where dense arrangements of windows, icons, and can overwhelm users with excessive visual stimuli, leading to slower decision-making and higher during complex tasks. Achieving consistency across platforms remains problematic; for example, macOS employs a dock-based menu paradigm with uniform window controls, while Linux environments like allow extensive customization that can result in divergent pointer behaviors and icon placements, complicating user transitions between systems. These issues underscore the need for streamlined design to balance expressiveness with in evolving GUI ecosystems.

Emerging and Multimodal Interfaces

Emerging user interfaces extend beyond traditional visual and textual paradigms by incorporating diverse input modalities such as touch, voice, gestures, and even neural signals, enabling more natural and intuitive interactions. Touch-based interfaces gained prominence with the introduction of capacitive screens in the in 2007, which allowed direct manipulation through finger gestures on a responsive display, revolutionizing . Swipe gestures, enabling fluid navigation like scrolling or dismissing content, became standard in mobile applications following early implementations in devices from 2009 onward, with apps like popularizing left-right swipes for decision-making in 2012. To enhance feedback, provides tactile responses; Apple's Taptic Engine, debuted in 2015 with the and , uses linear resonant actuators to deliver precise vibrations simulating button presses or textures, improving user confirmation without visual cues. Voice and conversational interfaces leverage (NLP) to facilitate hands-free interactions, shifting from rigid commands to fluid dialogues. Amazon's Alexa, launched in 2014 with the device, pioneered widespread voice-activated control for tasks like music playback and smart , processing billions of interactions weekly by 2019 through cloud-based NLP. Advancements in generative AI have further evolved these systems; integrations of models like , starting in 2023, enable context-aware conversations in apps for productivity tools and , allowing users to query complex information via natural speech rather than structured inputs. Immersive interfaces immerse users in augmented or virtual environments, blending digital overlays with the physical world or creating fully synthetic spaces. (VR) headsets like the , crowdfunded in 2012, introduced head-tracked 3D interfaces for gaming and simulation, using stereoscopic displays and motion sensors to simulate presence. (AR) and mixed reality have advanced with devices like Meta's Quest series; the 2025 Horizon OS update for Quest 3 introduces an evolved spatial UI with passthrough camera enhancements, allowing seamless blending of real-world vision with virtual elements for intuitive navigation via gaze and hand tracking. Brain-computer interfaces (BCIs) represent a frontier in direct neural interaction; 's prototypes achieved the first human implant in January 2024, enabling thought-controlled cursor movement for paralyzed individuals through wireless electrode arrays decoding brain signals. As of November 2025, has implanted devices in at least 12 individuals, with users demonstrating advanced capabilities such as controlling computers for gaming and communication. Multimodal interfaces fuse multiple input types for richer experiences, such as combining voice commands with gestures in smart home systems, where users might say "dim the lights" while waving to adjust intensity, as seen in integrated platforms like with compatible hubs. This fusion enhances accessibility and efficiency but introduces challenges, particularly privacy risks in always-on systems that continuously monitor audio, video, or , potentially leading to unauthorized without robust and user mechanisms.

Design Principles

Core Principles of Interface Quality

Core principles of interface quality form the foundation for designing user interfaces that are intuitive, reliable, and effective in supporting user tasks. These principles, derived from human-computer interaction , prioritize user needs by ensuring interfaces are predictable, unobtrusive, and responsive. Key among them are consistency, , with error prevention, and immediate feedback, which collectively reduce user frustration and enhance task completion rates. Consistency ensures uniform behavior and appearance across interface elements, allowing users to apply learned interactions without relearning. For instance, standard icons, menu structures, and response patterns—such as using the same for throughout an application—minimize cognitive effort and errors. This principle, articulated in Jakob Nielsen's usability heuristics, promotes adherence to platform conventions and internal standards to foster familiarity. Immediate feedback complements consistency by providing clear, real-time responses to user actions, such as visual confirmations of presses or progress indicators during operations, which reassure users that their are recognized and processed. Without such feedback, users may repeat actions unnecessarily, leading to inefficiency. Simplicity focuses on minimizing by presenting only essential information and controls, thereby avoiding overwhelming users with extraneous details. Techniques like progressive disclosure achieve this by initially showing basic features and revealing advanced options only when needed, such as expanding a collapsed for expert users. This approach, rooted in minimalist principles, has been shown to reduce task completion time by deferring complexity and preventing , particularly in complex software environments. Efficiency and error prevention enable seamless interaction by accommodating varying user expertise while safeguarding against mistakes. For expert users, interfaces incorporate shortcuts like keyboard accelerators or customizable workflows to accelerate routine tasks, aligning with Nielsen's heuristic for flexibility and efficiency. To prevent errors, designs include forgiving mechanisms such as confirmation dialogs for destructive actions and functions, which allow recovery without penalty. A quantitative foundation for efficiency in pointing-based interactions is provided by , which models the time required to acquire a target with a . The law states that movement time TT is given by T=a+blog⁡2(DW+1),T = a + b \log_2 \left( \frac{D}{W} + 1 \right), where aa and bb are empirically determined constants, DD is the distance to the target, and WW is the target's width. This principle guides target sizing and placement in graphical interfaces, ensuring larger or closer elements are easier and faster to select, thereby optimizing usability in touch and mouse-driven environments.

User-Centered Design Models

User-centered design models emphasize frameworks that integrate psychological insights and iterative processes to align interfaces with users' cognitive processes, expectations, and needs. These models shift focus from technical specifications to , ensuring interfaces facilitate intuitive interactions and minimize . Key contributions from seminal works in the 1980s onward provide structured approaches to achieve this alignment. The Principle of Least Astonishment (POLA), also known as the Principle of Least Surprise, posits that user interfaces should behave in ways that match users' preconceived expectations to avoid confusion or unexpected outcomes. This principle advocates for designs that do not "astonish" users by adhering to familiar conventions, thereby enhancing predictability and trust in the system. For instance, in menu systems, options should respond in expected manners, such as confirming deletions only when explicitly requested, to prevent erroneous actions. Don Norman's contributions to introduce psychological models that address how users perceive and interact with interfaces. In his 1988 book , Norman describes affordances as properties of objects that suggest possible actions, such as a button's raised edge implying it can be pressed, drawing from to guide user intuition. Complementing affordances are signifiers, which provide explicit cues about how to use those affordances, like icons or labels that clarify functionality and prevent misinterpretation. These elements support habit formation by making interfaces self-evident, allowing users to develop reliable interaction patterns over time. Norman's model further incorporates the Gulf of Execution and Gulf of Evaluation to explain interaction challenges. The Gulf of Execution represents the gap between a user's intentions and the actions required by the interface, bridged by clear mappings and constraints that translate goals into executable steps. Conversely, the Gulf of Evaluation covers the difficulty in interpreting system feedback, addressed through immediate and unambiguous responses that confirm outcomes. By minimizing these gulfs, designs promote seamless cycles of action and assessment, fostering user confidence and reducing errors in habitual use. This framework, rooted in , underscores the need for interfaces to mirror users' mental models. Peter Morville's UX Honeycomb, introduced in 2004, offers a multifaceted framework for evaluating and designing user experiences beyond mere . Represented as a hexagonal , it outlines seven interconnected facets that collectively define a robust UX: useful (solving real needs), usable (easy to navigate), desirable (emotionally engaging), findable (locatable content), accessible (inclusive for diverse users), credible (trustworthy presentation), and valuable (delivering business or personal worth). Morville emphasizes that these facets are interdependent, requiring balanced attention to create holistic experiences; for example, a highly usable but non-credible interface may fail to retain users. This model serves as a diagnostic tool for designers, highlighting trade-offs and priorities in user-centered projects. The Double Diamond model, developed by the British Design Council in 2003, provides an iterative framework for thinking, visualized as two diamonds representing divergent and convergent phases. It consists of four stages: Discover (exploring user needs and insights through ), Define (synthesizing findings to frame problems), Develop (ideating and prototyping solutions), and Deliver (testing, refining, and implementing). This non-linear process encourages cycles of , allowing teams to revisit earlier stages based on user feedback, thereby ensuring designs evolve in response to real behaviors and contexts. Widely adopted in UX practice, it promotes empathy-driven innovation while accommodating complexity in modern interfaces.

Evaluation and Usability

Usability Metrics and Testing

Usability metrics provide quantitative and qualitative measures to evaluate the effectiveness of user interfaces, focusing on how well they enable users to achieve goals. Key metrics include task success rate, which assesses the percentage of users who complete intended tasks without assistance, often serving as a foundational indicator of overall . Error rates measure the frequency of user mistakes, such as incorrect inputs or navigation failures, highlighting potential interface flaws that lead to frustration or inefficiency. Task completion time quantifies the duration required to finish a task, revealing whether the interface supports efficient interaction; shorter times generally indicate better , though context like task complexity must be considered. Satisfaction metrics capture subjective user perceptions, with the (SUS) being a widely adopted tool consisting of a 10-item scored from 0 to 100, where higher scores reflect greater perceived ease of use. Developed in 1986, SUS offers a quick, reliable benchmark for comparing interfaces across studies. International standards like ISO 9241-11 (2018) formalize usability as the extent to which a product can be used to achieve specified goals with effectiveness (accuracy and completeness of task achievement), efficiency (resources expended in relation to accuracy), and satisfaction (comfort and acceptability) in a specified context. These standards guide metric selection by emphasizing balanced evaluation of objective performance and . Testing methods complement metrics by identifying issues through structured approaches. Heuristic evaluation involves experts reviewing interfaces against established principles, such as Jakob Nielsen's 10 usability heuristics from 1994, which include visibility of system status, user control and freedom, and error prevention to detect potential problems efficiently without user involvement. compares two interface variants by exposing user groups to each and measuring performance differences, often using metrics like task success or engagement to determine the superior design quantitatively. Eye-tracking, advanced with accessible tools in the post-2000s era, records gaze patterns to visualize attention distribution, fixations, and saccades, uncovering mismatches between user focus and interface elements like overlooked buttons or confusing layouts. Practical tools facilitate these evaluations, particularly for digital interfaces. Google Analytics, launched in 2005, tracks web usability through metrics like bounce rates, session duration, and conversion paths, enabling indirect assessment of navigation efficiency and user drop-off points. Remote testing platforms such as UserTesting, founded in 2007, allow unmoderated studies where participants record sessions, providing video, audio, and think-aloud feedback to analyze real-time interactions and compute metrics like error rates remotely. These tools democratize , supporting iterative improvements aligned with ISO standards and core design principles.

Accessibility and Inclusivity

Accessibility in user interfaces ensures that digital systems and applications can be perceived, operated, understood, and robustly interacted with by people with disabilities, promoting equal access to information and services. This is critical given that an estimated 1.3 billion people, or 16% of the global population, experience significant disabilities, a figure projected to rise due to aging populations and chronic health conditions. The primary international standard for web accessibility is the Web Content Accessibility Guidelines (WCAG) 2.2, developed by the World Wide Web Consortium (W3C), which outlines success criteria across four core principles known as POUR: Perceivable (content must be presented in ways users can perceive), Operable (interfaces must be navigable and usable), Understandable (information and operation must be comprehensible), and Robust (content must work with current and future technologies, including assistive tools). These guidelines apply to a wide range of disabilities, including visual, auditory, motor, cognitive, and neurological impairments, and emphasize techniques such as sufficient color contrast, keyboard navigation support, alt text for images, and captions for multimedia. Inclusivity in broadens to address diverse user needs beyond disabilities, incorporating variations in age, culture, , , , and situational contexts to create equitable experiences for all. is defined as an approach that proactively recognizes potential exclusions, learns from diverse perspectives, and solves specific challenges to benefit broader audiences—a method encapsulated in Microsoft's three foundational principles: recognize exclusion, learn from diversity, and solve for one, extend to many. This mindset overlaps with by ensuring interfaces are flexible and adaptable; for instance, features like resizable text or multilingual support not only aid those with low vision or non-native speakers but also enhance overall user satisfaction across demographics. Unlike , which often focuses on legal compliance and accommodations for disabilities, inclusivity emphasizes proactive and , such as avoiding biased algorithms in AI-driven interfaces or designing for low-bandwidth environments in global contexts. Key practices for achieving and inclusivity involve user-centered testing with diverse participants, including those with disabilities, and adhering to established frameworks. For example, WCAG conformance levels (A, AA, AAA) guide implementation, with AA being the common target for most websites to ensure broad usability without overwhelming complexity. Inclusive design principles further recommend providing comparable experiences across devices, prioritizing essential content, and offering user control over preferences like animation speeds or input methods. Real-world applications include the , which uses modular components for customizable input, benefiting gamers with motor impairments while appealing to hobbyists seeking personalization. Similarly, curb cuts in —originally for wheelchair users—illustrate how inclusive solutions extend utility to parents with strollers, delivery workers, and cyclists, a concept paralleled in UI by features like voice navigation that assist not just the visually impaired but also hands-free users in vehicles. Challenges in implementing these aspects include balancing innovation with compliance, as emerging technologies like may introduce new barriers for users with vestibular disorders, necessitating ongoing updates to standards like WCAG. Legal mandates, such as the Americans with Disabilities Act (ADA) in the and the , reinforce these practices by requiring accessible digital interfaces in public and commercial sectors. Ultimately, integrating accessibility and inclusivity from the design phase—rather than as an afterthought—yields more robust, marketable products, as evidenced by studies showing that accessible websites rank higher in search engines and reduce support costs through intuitive navigation.

References

  1. https://academic.oup.com/book/60808/chapter/529001532
  2. https://www.sciencedirect.com/science/article/pii/S1071581924001642
  3. https://www.researchpublish.com/upload/book/USER%20INTERFACE%20DESIGN-332.pdf
  4. https://www.researchgate.net/publication/221515200_User_interface_history
  5. https://pmc.ncbi.nlm.nih.gov/articles/PMC6108970/
  6. https://www.academia.edu/70223248/User_Friendly_A_Short_History_of_the_Graphical_User_Interface
  7. https://dl.acm.org/doi/10.1145/1358628.1358696
  8. https://www.techtarget.com/searchapparchitecture/definition/user-interface-UI
  9. https://www.browserstack.com/guide/what-is-user-interface
  10. https://www.simpplr.com/glossary/user-interface/
  11. https://pmc.ncbi.nlm.nih.gov/articles/PMC9568819/
  12. https://www.interaction-design.org/literature/topics/ui-design
  13. https://www.sciencedirect.com/topics/engineering/human-machine-interaction
  14. https://www.nngroup.com/articles/definition-user-experience/
  15. https://hci.stanford.edu/courses/cs147/2022/wi/lectures/13-conceptual-models.pdf
  16. https://www.sciencedirect.com/science/article/abs/pii/B9780444818621500868
  17. https://www.cs.umd.edu/~ben/papers/Shneiderman1983Direct.pdf
  18. https://dl.acm.org/doi/10.1145/800276.810991
  19. https://www.techtarget.com/whatis/definition/widget
  20. https://developer.android.com/topic/architecture/ui-layer/stateholders
  21. https://www.nngroup.com/articles/what-is-user-experience/
  22. https://aws.amazon.com/compare/the-difference-between-frontend-and-backend/
  23. https://spectrum.ieee.org/xerox-alto
  24. https://www.si.edu/spotlight/punch-cards/punch-cards-data-processing
  25. https://www.computerhistory.org/timeline/1961/
  26. https://www.nokia.com/bell-labs/about/dennis-m-ritchie/hist.pdf
  27. https://www.cl72.org/130gnuOS/bourne_shell.pdf
  28. https://apps.dtic.mil/sti/tr/pdf/ADA115440.pdf
  29. http://www.bitsavers.org/pdf/mit/ctss/CTSS_ProgrammersGuide.pdf
  30. https://www.microsoft.com/en-us/research/wp-content/uploads/2017/01/the-computer-reaches-out.pdf
  31. https://spectrum.ieee.org/graphical-user-interface
  32. https://www.researchgate.net/publication/2953879_The_Xerox_Star_A_Retrospective
  33. http://www.o3one.org/hwdocs/bios_doc/dosref22.html
  34. https://bitsavers.trailing-edge.com/pdf/datapro/Datapro_Reports_on_PC_and_LAN_Communications_1992/Vol3_723.pdf
  35. https://computerhistory.org/blog/the-lisa-apples-most-influential-failure/
  36. https://www.nngroup.com/articles/macintosh-25-years/
  37. https://arstechnica.com/features/2005/05/gui/
  38. https://museum.ipsj.or.jp/en/computer/word/history.html
  39. https://www.apple.com/newsroom/2007/01/09Apple-Reinvents-the-Phone-with-iPhone/
  40. https://www.w3.org/TR/2014/REC-html5-20141028/
  41. https://react.dev/blog/2013/07/23/community-roundup-5.html
  42. https://www.apple.com/newsroom/2025/06/apple-intelligence-gets-even-more-powerful-with-new-capabilities-across-apple-devices/
  43. https://www.bloomberg.com/news/articles/2025-11-05/apple-plans-to-use-1-2-trillion-parameter-google-gemini-model-to-power-new-siri
  44. https://www.apple.com/apple-vision-pro/
  45. https://www.apple.com/newsroom/2024/05/apple-announces-new-accessibility-features-including-eye-tracking/
  46. https://dl.acm.org/doi/fullHtml/10.1145/3411764.3445779
  47. https://dl.acm.org/doi/10.1145/3419249.3420132
  48. https://www.gnu.org/software/bash/
  49. https://learn.microsoft.com/en-us/powershell/scripting/install/powershell-support-lifecycle?view=powershell-7.5
  50. https://www.techtarget.com/searchdatacenter/tip/Top-4-advantages-of-a-command-line-interface
  51. https://www.walkme.com/blog/graphical-user-interface-vs-command-line-interface/
  52. https://unix.stackexchange.com/questions/284723/when-was-pipelining-introduced
  53. https://cscie26.dce.harvard.edu/~dce-lib113/reference/unix/unix2.html
  54. https://invisible-island.net/xterm/
  55. http://techdoc.kvindesland.no/linux/journal/Magazines/LJ17/1124.html
  56. https://github.com/aws/aws-cli
  57. https://docs.aws.amazon.com/vsts/latest/userguide/aws-cli.html
  58. https://dojofive.com/blog/embedded-command-line-interfaces-and-why-you-need-them/
  59. https://www.cs.cmu.edu/~15292/assets/slides/11-GUIsAndMicrosoft.pdf
  60. https://ohiostate.pressbooks.pub/graphicshistory/chapter/16-1-xerox-parc/
  61. https://www.dougengelbart.org/theMouse
  62. https://blogs.windows.com/windowsexperience/2021/06/24/introducing-windows-11/
  63. https://release.gnome.org/calendar/
  64. https://www.w3.org/Style/CSS20/
  65. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Introduction
  66. https://getbootstrap.com/docs/3.3/about/
  67. https://academic.oup.com/book/60808/chapter/529002273
  68. https://www.sri.com/hoi/computer-mouse-and-interactive-computing/
  69. https://open.clemson.edu/cgi/viewcontent.cgi?article=2052&context=all_theses
  70. https://uxplanet.org/in-app-gestures-and-mobile-app-usability-d2e737bd5250
  71. https://www.theguardian.com/technology/2015/mar/11/apples-force-touch-taptic-engine-explained-haptic-technology
  72. https://www.amazon.science/blog/alexa-at-five-looking-back-looking-forward
  73. https://uxdesign.cc/will-chatgpt-like-interfaces-ever-replace-graphical-user-interfaces-64991fc287f1
  74. https://www.kickstarter.com/projects/1523379957/oculus-rift-step-into-the-game
  75. https://www.uploadvr.com/quest-v83-ptc-evolved-navgiator-horizon-os-ui/
  76. https://neuralink.com/updates/a-year-of-telepathy/
  77. https://blog.uxtweak.com/multimodal-design/
  78. https://www.ramotion.com/blog/multimodal-interfaces/
  79. https://www.nngroup.com/articles/ten-usability-heuristics/
  80. https://www.nngroup.com/articles/progressive-disclosure/
  81. http://www.cs.umd.edu/users/ben/goldenrules.html
  82. https://jnd.org/books/the-design-of-everyday-things-revised-and-expanded-edition/
  83. https://www.nngroup.com/articles/two-ux-gulfs-evaluation-execution/
  84. https://semanticstudios.com/user_experience_design/
  85. https://www.designcouncil.org.uk/our-resources/the-double-diamond/
  86. https://www.nngroup.com/articles/success-rate-the-simplest-usability-metric/
  87. https://measuringu.com/essential-metrics/
  88. https://www.userlytics.com/resources/blog/5-most-important-usability-metrics-in-ux-research/
  89. https://www.researchgate.net/publication/228593520_SUS_A_quick_and_dirty_usability_scale
  90. https://www.iso.org/standard/63500.html
  91. https://www.nngroup.com/articles/ab-testing/
  92. https://www.uxmatters.com/mt/archives/2005/12/introduction-to-eyetracking-seeing-through-your-users-eyes.php
  93. https://www.webdesignmuseum.org/web-design-history/google-analytics-2005
  94. https://www.usertesting.com/company/newsroom
  95. https://www.who.int/news-room/fact-sheets/detail/disability-and-health
  96. https://www.w3.org/WAI/standards-guidelines/wcag/
  97. https://inclusive.microsoft.design/
  98. https://www.w3.org/WAI/fundamentals/accessibility-usability-inclusion/
  99. https://www.interaction-design.org/literature/topics/inclusive-design
  100. https://www.section508.gov/develop/guide-accessible-web-design-development/
  101. https://www.nngroup.com/articles/accessibility-inclusivity-study-guide/
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.