Programmer Musings

GUIs vs TUIs, Conclusion

When I originally approached this topic, I wanted to explain to those GUI users why a TUI is more powerful. As I tried to write down my opinions, I realized that once again this was more a case of it depends than I had thought. I really should know better by now.

In order to level the field for this post, I covered two different views of which is better:

• Why Textual User Interfaces are Better than Graphic User Interfaces
• Why Graphical User Interfaces are Better than Textual User Interfaces

I intended each of these positions to be mostly black and white, with no compromise with any position other than the one I was presenting at the time. Neither one of them completely matches my opinions.

Although I use the GUI on every system I touch, I also have at least 2, and sometimes as many as 5 or 6 terminal windows open on a command line at all times. I've always preferred a TUI to a GUI, but I've had trouble explaining why. Many people might argue that it's as simple as I learned computers before GUIs became common.

Many of the really good programmers I've known also have a preference for working from the command line. Many people just assume that it's a power user thing.

The Power User Argument

Why does using the command line seem to be a power user thing? What do I mean by power user?

Any computer user falls on a range of different levels of expertise for different activities. Let's say that someone who has never touched or seen the activity or software is a novice. Someone who wrote the code or has worked on that system since it's very beginning is a guru.

In between those levels are varying degrees of competence, from able to solve simple tasks to perform feats of magic that dazzle those with less experience. At the low end of the scale, you tend to spend a lot of time trying to satisfy the requirements of the computer or program. At the upper end of the scale, you make the computer work for you.

A power user is someone on the high end of the scale. They may not know as much as the guru, but their skills and knowledge in the activity exceed the norm. These users are the ones that can really make a system do their bidding.

A power user will usually value their time much more than the computer's time and understand that there is a difference. They will learn how to push as much work as possible onto the computer, rather than doing it themselves. If a task takes three steps, they will try to automate them to only need one. If something needs to be done every day, they will work to make the computer schedule the work to start on its own.

To the power user, a text-based or command line interface is a good thing because it is probably scriptable. Instead of typing 3 commands, I can make a script, or macro that does those 3 commands when I make one request. Most GUIs either don't provide this ability or provide just the ability to record a series of actions a replay them.

While some people develop amazing abilities with graphical programs, they are often limited to what the designer of the program thought you might want to do.

Different Viewpoints

The key step forward for me came with the realization that there are basically two very different modes for using a computer: automating work and extending your capabilities.

Automating Work

Automating work is based on the idea of delegating uninteresting or repetitive work to the computer. Anything that can be done with minimal or no input from you is open for automation. A TUI is great for this kind of work. Its killer feature of scripting makes automating work relatively easy. Part of what makes a power user is the ability to recognie what can be automated and the skills for putting those tasks into a form that can be done by the computer.

This form of automation can make you much more effective by delegating the boring parts of your work to the computer. Automated data collection and manipulation has allowed businesses and the sciences to do amazing things. Once upon a time, those processes were limited by the people you had collecting and manipulating the data. There would inevitably be errors caused by people becoming bored and not being as precise as needed. Computers don't become bored.

Extending Capabilities

GUIs really shine in places where human input is indispensable. In this case, the computer becomes more of an instrument for extending our capabilities. Behind the scenes, there may be a lot of the other kind of automation. But, the key is putting data in front of a human to make a decision or change.

Drawing programs, music creation software, imaging software, and many similar tools all work to control complexity and put the information that the user needs to know at her fingertips. This allows the user to focus on the evaluation or creative aspects of the task.

Sometimes a huge amount of effort is applied to allow the user to visualize data that isn't inherently visible (or, at least with our built-in visual system). Once the data is in a form that we can interpret, a skilled human is much more effective at recognizing surprising aspects of the visualization.

This kind of work is not necessarily repeatable, but humans aren't really good at repeatable. If it's repeatable, let the computer do it and give us the result to work from.

Conclusion

Neither GUIs or TUIs are more powerful in all cases and activities. A person's preference for one or the other is likely due to a combination of what they learned first and what kinds of problems they solve.

That's why even us old command line users normally use GUI desktop systems, even if we cover them with terminal windows for doing real work<grin/>.

Why Graphical User Interfaces are Better than Textual User Interfaces

As I said in the last entry, you can separate computer users by their user interface preferences. In that entry, I made the argument that a text-based interface (TUI) is better than a graphical interface (GUI).

Since that isn't inflammatory enough, I'm now going to argue that GUIs are better than TUIs.

A Short History of Modern Computer Interfaces

Early computer interfaces were text-based because the computers were not powerful enough to draw much in the way of graphics while doing any other work. Also, we only had one real input device, the keyboard. Driving graphics with a keyboard is incredibly slow and awkward.

Once computers became fast enough to do the graphics calculations, Palo Alto's mouse became a viable way to interact with the computer. (Light-pen technologies were in use before the mouse, but they never got the kind of traction needed to take off.)

Attributes of Graphical Interfaces

GUIs have many advantages, including

• precise
• discoverable
• novice friendly
• small number of commands/gestures
• consistent set of commands for all objects
• well suited to touch interfaces

Some of these advantages explain why GUIs are usually regarded as user friendly. Most GUIs also have some disadvantages, including

• limited number of mouse commands/gestures
• not voice-input friendly
• hard to repeat commands
• expert hostile

Why Graphics?

The graphical interface made remembering objects, the nouns of the system, easier by representing each with a picture. New users could easily find the objects that they wanted to manipulate by just looking at the screen.

Although the mouse was originally limited to click, double-click, and dragging, system designers found ways to expand the use of the mouse without requiring the user to count clicks or do weird gestures. First, the modifier keys were added so that Shift-Click and Ctrl-Click could be different than a simple click. The development of the context menu, made it possible for different objects to have different possible commands without an explosion of mouse gestures.

Context

One spot where GUIs can cause some confusion is in the use of context. Different commands or mouse gestures can have very different effect depending on the current focus.

• Clicking on a picture may display it.
• Clicking a file may load your spreadsheet program.
• Clicking on a link may start your browser.
• Clicking on a program may execute it.

In each of these cases, you could argue that clicking on the object should do the default action for that thing, but until you learn the default actions this behaviour can be surprising. It does still cause problems when the thing you just clicked isn't what you thought it was.

The Killer Feature

The real killer feature of the GUI is the ability to boil down complex tasks and information into simple commands and displays. GUI-based tools make graphing data much easier than looking at rows of text. The web really took off when graphics and video became easier.

Drawing with a GUI interface is much more user friendly than trying to describe what you want to draw in text. As they say: A picture is worth a thousand words.

Comparison to TUIs

Unlike a TUI, you don't have to know the names of things advance to work on them. This makes the GUI initially much easier to use than a TUI. Moreover, a single (or double) mouse click normally does the right thing with the object. You don't need to learn a whole bunch of program names or commands in order to act on objects. With context menus, you can quickly find any other commands you might want to apply to an object, without a need for memorizing them.

In addition, there are many graphical tools that allow you to manipulate complex data in many forms by clicking and dragging exactly like you're used to. Some more complex actions may require new gestures, but they are normally not hard to learn.

Expanding Your Abilities

With a GUI, you can see large or complex sets of data all at once and work with them relatively easily. Selecting an area of a picture with a mouse is so much easier than trying to select it by typing commands. Scrolling with the mouse through a video or audio file is much easier than selecting a position with text, because of the instant feedback as you move.

GUIs kind of act as a magnifier on your normal abilities.

Why Textual User Interfaces are Better than Graphic User Interfaces

One of the ways that you can separate groups of computer users into groups is by their preferences in user interfaces. A few decades ago, most computer interfaces were simple text. The display hardware didn't support fancy graphics, and the processors weren't fast enough to do the calculations needed for reasonable graphics. As computers and display technology improved, a few companies pushed for graphical user interfaces (GUIs) because they were more user friendly.

Since the text user interfaces (TUIs) are older than the graphical user interfaces (GUIs), some people believe that the TUI is obviously inferior to the GUI. Nothing could be further from the truth. If graphical approaches are obviously superior to text-based approaches, why do humans use language instead of pictures and miming for most of our communication?

Obviously, in some circumstances, a text-based approach must be better than a graphical approach.

A Short History of Early Computer Interfaces

The original computer interfaces were wire. You connected up wires to the appropriate components and made the functionality you wanted. Eventually, people figured out that they could program the computer in terms of binary, 1s and 0s. This was a huge step forward. You didn't need a soldering iron to make changes to the program.

Unfortunately, remembering strings of 1s and 0s is not easy for us humans. Eventually, someone realized that the computer could convert short strings into the appropriate binary code. This gave us an assembler and our first text-based interface.

Attributes of Textual Interfaces

TUIs have many advantages, including

• precise
• flexible
• repeatable
• can be generated by code
• expert friendly
• input by speech recognition

Some of these advantages explain why TUIs are usually regarded as not user friendly. Most TUIs also have some disadvantages, including

• not easily discoverable
• requires keyboard/speech input skill
• often requires some form of grammar
• novice hostile

Why Text?

A text interface gets its power from the fact that language is one of humanity's most powerful tools. By defining a number of carefully chosen verbs, we can very precisely specify what we want done. Declaring a number of nouns or a protocol for naming nouns allows us to apply these verbs to many different objects.

We can even add attributes that modify the verbs and nouns in arbitrary ways to gain more precision. When the TUI uses a well-defined grammar for combining these verbs, nouns, and other attributes, you can make powerful commands after learning a few short rules.

Jargon

One complaint that many people have about a TUI is the weird terms that get used. While you might easily be able to understand what copy means, grep doesn't make sense until you learn the lingo. But, this is actually no different from human languages.

Human languages accumulate new terms and jargon all the time. If people don't have a precise enough word for a concept they use a lot, they create a new word. Every human activity that reaches a certain level of complexity causes us to create a special vocabulary for that activity.

Whether you are talking medicine, engineering, football, or music, any field develops its own special language. This language starts out as jargon for a particular group, but in some cases, it eventually becomes part of the mainstream language.

This leads to the biggest disadvantage of TUIs, the need to learn a new language to deal with the interface. To some people, this is a major barrier. But, it shouldn't be, we learn new words all the time.

The Killer Feature

The real killer feature of the TUI, is the ability to save and repeat a set of commands. A well-designed TUI makes repeating commands relatively easy. The ability to get commands either from the keyboard or from a file allows the user to do something remarkable. By giving a name to a set of commands that you want to run, you can now create commands that do what you want to do. You can extend the computer's abilities.

Maybe you do the same 5 things every morning when you come in to work. Wouldn't it be wonderful to type a short command and have those 5 things started for you? Even if those things required that you do something explicitly for each one, the ability to run them with a simple command means that you don't have to do the repetitive work of starting them.

Now imagine that you have a different handful of tasks for each day of the week. Wouldn't it be better to execute the Monday Tasks than to think about which tasks you did last week at this time?

This is the feature that allows expert users of a TUI to do amazing things with a computer in relatively short order.

Command shells usually do more than just allow you to repeat commands. Adding the ability to conditionally execute commands or loop to execute a command multiple times with different arguments moves a simple TUI up to the point of real power use.

Programs Driving Programs

A still more advanced ability of TUIs is the ability to drive them with the output of a program. Since the input is just text, anything that can generate text can potentially serve as input to the TUI. Early dynamic web pages worked this way: take input from a user, format the text as input to a program, return HTML to the user.

Unix systems are famous (or notorious) for their ability to pipe the output of one command to the input of another. This allows a series of simple tools to do quite complex work by chaining them together.

Comparison to GUIs

The ability to easily store and repeat commands is a main reason why a TUI is more powerful than a GUI. With relatively little training, someone can learn to customize their system by adding special purpose commands. All that's needed is an appropriately formatted file of other commands. This file contains commands very similar or identical to ones you are already using.

In general, you can't add features to a GUI by just adding a new gesture or way of clicking. At the minimum, you need access to something like the TUI or a programming language to make your commands, then you can put that somewhere that you can click. There usually isn't an easy way to duplicate the steps you go through each day to make a new command that combines them.

Making the Computer Work for You

To me, the TUI is a tool that allows me to make the computer work for me. I can easily create a command or sequence of commands that will tell the computer to go off and do work for me, without requiring me to babysit it waiting for each step.

One of my favorite examples of this is really simple. Years ago I was working on an MS Windows system and talking with a big fan of GUIs. We were having a good-natured argument about UIs before I noticed that he was doing a lot of clicking. I asked what he was doing and he said he was cleaning backup files out of a directory. He had been selecting individual files and was going to delete them in one go.

I took the keyboard and typed the following in a command window:

del *.bak *.bck

This caused the computer to find all of the files that he was trying to select by hand and deleted them. Later, I realized that I could have changed the explorer window to sort by extension and selected the files more easily. But, the one line command seemed much more obvious to me.

More importantly, there is no way to repeat his steps in another directory to delete the backup files there. You would need to open the directory in explorer and select the right files again by hand. My command could be easily repeated anywhere you want and it would do the right thing in each directory.

That is the power of a TUI.