Abstract: This article, through numerous examples and the author's understanding, introduces the classic problem in human-computer interface design: the pattern phenomenon, and points out specific measures to avoid this problem in product design. It is hoped that this article will serve as a starting point, prompting domestic product designers, especially software product designers, to pay attention to interface usability, enabling products to go from ordinary to excellent. Keywords: Human-computer interface design pattern, software usability, human-computer interaction —Improvement of the Windows XP user login interface If you frequently use a computer, you may have had similar experiences. When logging into a system, there is usually a login screen requiring a username and password. In most cases, the system remembers previously entered usernames, so the username is already displayed on the screen, and the cursor is directly positioned where you enter the password. You enter the password several times, but the system always says the password is incorrect, even though you are certain the password and username are correct. You are completely baffled and so angry you want to smash the keyboard. But just as you are about to throw your fist, you suddenly notice the Caps Lock indicator light on the keyboard is lit, and you realize the reason. Is it your fault? Perhaps it should, but why can't the software provide better suggestions? Windows XP's user login interface has made improvements to password input in this type of login screen. Some observant users may have already noticed the subtle differences in operation between this interface and previous versions of Windows. If you haven't noticed yet, you can try the following experiment: First, press the Caps Lock key on your keyboard, then click the mouse in the password input box to place the cursor where you want to enter your password. You'll then see a prompt box appear prominently, displaying the message "Your keyboard is in Caps Lock mode, which may cause you to enter the wrong password..." Continue the experiment: Press the Caps Lock key again, and the prompt box disappears. Click the username input field with the mouse, and press the Caps Lock key again to switch to uppercase, but this time the system no longer displays any prompt box. After several such operations, you will discover the pattern: if the current cursor is in the password input field and the keyboard is in uppercase mode, the system will display the prompt box; however, if the cursor is in the username input field, the prompt box will not appear. Perhaps you've already guessed the reason for this design, or you've already experienced its benefits from use: it avoids the problem of password errors caused by the Caps Lock key going unnoticed by the user. II. What is the Pattern Phenomenon in Interfaces? In the login interface problem discussed above, the reason users are prone to errors is a classic problem in human-computer interface design: the pattern phenomenon. Computer scientist and cognitive psychologist Jef Raskin, the father of the Macintosh, provides a insightful discussion of the pattern phenomenon in his book, *The Humane Interface: New Directions for Designing Interactive Systems*. Simply put, if a user performs the same action but gets different results in an interface, then that interface exhibits a pattern phenomenon. In other words, such an interface has different patterns (or internal states), and in different patterns, the same action will cause different results or perform different functions. Taking the password input in the login interface above as an example, when the user presses the 'a' key on the keyboard, the actual input could be a lowercase 'a' or an uppercase 'A', depending on the current Caps Lock key. In the real world, there are many examples of interface patterns. This phenomenon exists not only in software interfaces but also widely in everyday items. Here are three examples of items we've all encountered. First, a television set. The power button on a television set exhibits a pattern. If the television is off, pressing the button turns it on; if it's on, pressing the button turns it off. Second, a manual camera. Before point-and-shoot cameras, you needed to set the correct aperture, shutter speed, and focal length before taking a picture. The same action of pressing the shutter button will produce vastly different results under these different settings. Third, a manual transmission car. The gear in a car determines its movement. Pressing the accelerator will move the car depending on whether it's in first gear, fifth gear, or reverse. Here, the same action of pressing the accelerator produces different results. Figure 1: A car's gear shift mechanism. Let's look at three examples of modal interfaces in software products. First: The Enter key on the keyboard. In DOS command line mode, the Enter key generally executes a command or launches an application; in a text editor, it generally adds a newline; and in a dialog box, it's equivalent to clicking the "OK" button, closing the dialog box. Second: Many software programs can now block pop-up windows while browsing the web, such as the Google bar and MSN bar. Installing these programs causes browser modal issues. When browsing certain websites, you might encounter strange errors. For example, some websites allow you to upload a file stored on your computer. When you click the "Select File" button on the website page, nothing happens. This is because in "Pop-up Blocking Mode," the "Select File" window is not displayed by the browser. You might not be aware that the browser is in "Pop-up Blocking Mode," so you might think your operation is incorrect or that the website is faulty. Third: The full-screen character mode editor vi under the Unix operating system. This is an early text editor popular on Unix, powerful in function but also notoriously difficult to learn. The software has two modes: edit mode and command mode. In edit mode, pressing letter keys inputs the corresponding letter, achieving text input; in command mode, pressing different letter keys performs completely different functions. For example, the letters kjlh correspond to moving the cursor up, down, left, and right. Pressing the 'a' key enters edit mode and sets the input point to the right of the cursor; pressing the 'i' key also enters edit mode, but sets the input point to the left of the cursor. Harmful and Harmless Modes Interfaces exhibiting pattern phenomena do not always cause usability problems or easily lead to errors. For example, in the case of a television, people rarely make mistakes when using the power button. However, in the case of a manual camera, people often produce poor-quality photos due to incorrect camera settings, or in the case of a manual transmission car, stalling or damage to the car due to untimely or improper gear shifting. So, under what circumstances do interfaces exhibiting pattern phenomena easily lead to user errors, or what can be called "harmful modes"? A quick rule of thumb is: are the internal states or factors of a product that affect different results from an action clearly displayed to the user on the interface? If so, this mode is a "harmless mode"; otherwise, it's a "harmful mode." In the example of turning a television on and off, the function performed by pressing the switch button depends on whether the television is currently on or off, and this state is clearly displayed to the user, so the user won't make a mistake. Attentive readers may have noticed that in the example of a hand-held camera, aren't factors affecting the final image quality, such as aperture and shutter speed, clearly displayed to the user on the camera's screen? Why then do users still frequently set them incorrectly? To explain this, we need to further modify the above rule of thumb: in an interface exhibiting pattern phenomena, the internal states of a product that affect different results from the same action must be clearly displayed to the user, and this state must be the user's current focus. Only when both of these conditions are met is it a "harmless mode." Figure 2: Aperture and shutter speed are already displayed on the screen. In the example of turning a television on and off, whether the television is currently on is the factor affecting the different results of pressing the power button. When the user presses the button, their attention is focused on changing the television's state, so they are well aware of the outcome. In the example of a handheld camera, when the user frames the shot and places their index finger on the shutter button, their attention is on the image in the viewfinder, concerned with whether the desired scenery or person is within the frame and in the correct position. Although the shutter speed and aperture values ​​are clearly displayed on the screen, the user doesn't pay attention to these factors, resulting in these factors affecting the final image quality being ignored during the shot. In interfaces with "harmful modes," if the system or product can quickly provide feedback to the user about the results of their actions, allowing them to quickly realize the error and take appropriate measures to fix or correct it, such an interface is acceptable; that is, the mode problem will not cause serious errors. Taking cameras as an example, a major difference between digital cameras and traditional film-based cameras is that users can immediately see the final image after taking a picture. At this point, users can promptly identify problems such as overly bright or dark photos caused by improper aperture or shutter speed settings, thus realizing the need to adjust various parameters appropriately to ensure proper exposure. Let's look back at a "harmful but acceptable" interface in computer interfaces: the problem of typing uppercase and lowercase letters on the keyboard. From our analysis of the mode problem above, it's clear that the current uppercase/lowercase state of the keyboard determines the result of pressing the same letter key, and this state is displayed to the user via the Caps Lock indicator light. However, because users' eyes are generally on the screen when typing (at least for most skilled keyboard users), they rarely pay attention to the indicator light. Therefore, a common phenomenon is that after typing a complete word, the user only then realizes that all the input is uppercase, and only then does they realize the keyboard is in uppercase mode. But because the system promptly displays the input letters, the user quickly realizes the error and can correct it in time. Can you imagine how terrible it would be if you couldn't see the letters you typed? Even if you typed the wrong uppercase letter, you wouldn't know. Does such an interface really exist? Yes, the password input interface mentioned at the beginning of this article is exactly like this. For security reasons, in all password input interfaces, all letters typed by the user are displayed as an asterisk (*) or any other similar symbol. But this means there is no feedback to the user, making it easy to cause the kind of error mentioned at the beginning of the article. The clever design of the Windows XP user login interface lies in its application of the principle of timely feedback. Under the constraint of ensuring security requirements, it improves an interface with a "harmful mode" to an acceptable one, avoiding errors. By displaying a conspicuous prompt box on the screen, it attracts the user's attention and clearly tells the user the current uppercase status of the keyboard, allowing the user to clearly understand whether their keystrokes will input uppercase or lowercase letters, thus avoiding errors. The Root Causes of the Four-Mode Approach and How to Address It in Product Design: From a cognitive psychology perspective, Jef Raskin points out that the reason why interface patterns make products difficult to use is that they interrupt people's normal thought processes when completing a task, forcing them to think about other issues unrelated to the main task at hand. This creates a significant memory burden and cognitive difficulties. In the example of a manual transmission car, people are concerned with and try to control direction and speed. However, controlling speed is not simply a matter of using the accelerator and brake. The driver must first set the correct gear. Here, the thought process of "setting the gear" disrupts people's focus on speed control, creating a memory burden and cognitive difficulties. Fundamentally, the "pattern" phenomenon in interfaces arises because product functions exceed control buttons or cannot all be displayed in limited display space, thus failing to establish a one-to-one correspondence between control mechanisms and functions. For example, if a device has 20 functions but only 11 buttons on the interface, it's obviously impossible for each button to correspond to a single function. In this case, by designating one button as a special mode button, its pressed or released state determines the different actions of the other ten buttons, thus providing 20 functions with 11 buttons. Figure 3: A simple old-fashioned radio. Taking a real-life example, you might remember an old-fashioned radio with a simple control panel, containing only two knobs: one for volume and one for tuning. These two knobs correspond to two functions, and that's all the radio functionality. Anyone who has seen such an interface once can use it. Now consider your MP3 player, which has dozens of functions but only a few buttons. This clearly demonstrates a mode phenomenon. Such an interface is difficult to learn and remember, often requiring the manual to complete certain functions. Figure 4: MP3 player. After understanding these mode phenomena in interfaces, we can pay attention to them in product design to avoid problems caused by mode issues, such as difficulty in use or easy errors. Specifically, this can be achieved through the following three steps: First, whenever possible, completely eliminate mode phenomena, ensuring that every action produces the same result regardless of the situation. If a product's functionality is indeed very simple, achieving this isn't difficult. However, for products with many functions, completely eliminating mode effects requires complex technology, which generally leads to increased product costs. For example, point-and-shoot cameras completely eliminate the mode effects caused by aperture and shutter speed, but to do so, many control components need to be added to the camera to automatically set the aperture and shutter speed based on the distance of the subject and the ambient light, requiring complex technology. Similarly, the automatic transmission in an automatic car is a solution to eliminating mode effects; however, it is also a very complex and expensive component in automatic cars, and generally, automatic cars are more expensive than manual cars with the same configuration. Essentially, many products with "automatic" or "intelligent" in their names attempt to eliminate mode effects in product use through technological means, thereby improving ease of use. Secondly, if, due to certain reasons or constraints, it's impossible to achieve a perfect one-to-one correspondence between functions and actions, it's crucial to strive for a "harmless mode." This means displaying the internal system states that influence the outcome of an action to the user, ensuring these displayed states are at the user's attention, so that the user is clearly aware of the result of their action. Finally, if, despite all efforts, we still cannot guarantee that the displayed states are at the user's attention—meaning the interface exhibits a "harmful mode"—we must utilize the principle of timely feedback to promptly inform the user of the result of their action, allowing them to immediately recognize the error and take corrective action. Conclusion With technological advancements, products will have increasingly richer functions. How to make these functions easy for users to learn and use, thereby truly realizing the full value of the product, is a major challenge for product design. The pattern problem in interface design explains, from one perspective, why a product is easy to use and why it's prone to user errors. By focusing on pattern issues, you can design products that are easy to learn and use, thereby improving user satisfaction.