Evolution of User Interfaces
A command-line interface is defined by typed commands and typed computer responses.
Who Could Touch the Computer?
Most people who use computers today type into them, tap them, or speak to them without thinking about how that conversation came to exist. To understand the command-line interface, it helps to start with a more basic question: in early computing, how close could an ordinary person get to the machine? The answer changes how we should think about user interfaces, because the interface is first of all a question of access.
What do you think happens?
In early computing, could an ordinary person, or even most programmers, type commands directly into the computer and read its typed replies?
Reveal answer
No, programs and data were handed to attendants who entered them and returned the response later.
Ordinary people, including most programmers, could not approach the computer directly. Their material went to attendants, and the response came back later. Direct typed communication came from later developments that made a person's terminal a live channel to the machine.
From Submitting Work to Holding a Conversation
A command-line interface is easiest to understand as a change in access. In the earlier arrangement, a person prepared material, gave it to an attendant, and waited for a result to be delivered back. Nothing about that process is a conversation: there is one submission and one later delivery. Later developments made it possible for a person to communicate with the computer directly, by typing commands and receiving typed responses. The defining feature is the back-and-forth, not the keyboard itself.
The word interactive in this context means that the user does not merely submit material and wait. The user communicates with the computer through the terminal, and each reply can shape the next command.
Tracing One Command-and-Response Exchange
The interaction can be followed as a short loop with three stages. First, the user types a command. Second, the computer produces a response. Third, that response is typed back to the user, who can then type the next command. Follow the diagram below from top to bottom: each arrow is one message, and the numbers show the order in which they happen. The first message begins at the user, not at the computer.
Following a short typed exchange
A user wants to ask the computer a question and act on the answer. Trace the loop for one full round, then say what the user does next.
- 1Step 1: the user types
The user types a command at the terminal. This is the user's input, the first half of the defining pattern.
- 2Step 2: the computer responds
The computer produces a response to that command. The response is typed, not handed back later through an attendant.
- 3Step 3: the response appears
The response is typed back to the user through the terminal, so the user reads it at once.
- 4Step 4: the loop repeats
Because the reply is visible, the user can decide the next command based on it. This repeated exchange is what makes the interface interactive.
One round is complete when the response is on the screen. The user's next command starts a new round of the same loop.
How Timesharing Gave Many People One Computer
Timesharing allowed multiple people to interact directly with one computer by switching the computer's attention rapidly between them. Each person sends input through a terminal, and the single shared computer serves each in turn. Because the switching is fast, each person can experience the computer as responsive to them, even though the machine is actually attending to someone else at other moments.
Read the diagram as a rotation rather than a queue of finished jobs. The computer gives one user a turn, moves its attention to the next user, and eventually returns. The important idea is the sharing of a single machine among several people, each interacting with it directly through their own terminal.
Timesharing Versus the Command-Line Style
Timesharing and the command-line interface are often mentioned together, but they answer different questions. Timesharing describes shared access: how many people can use one computer at once. The command-line interface describes the communication style: what the exchange looks like once a person is connected. Keeping these apart prevents a common confusion, which the next table lays out.
| Question | Timesharing | Command-line interface |
|---|---|---|
| What is it? | A system that shares one computer among users | A style of typed input and typed output |
| What does it describe? | Shared access to the computer | The communication style of the exchange |
| How many people? | Multiple people at once through separate terminals | Can describe the exchange with one person only |
| Historical note | Switches the computer's attention rapidly between users | Early personal computers used it with one person at a time |
Timesharing and the command-line interface are different concepts that can appear together.
Mistakes Learners Make About Interfaces
Common mistake Treating timesharing and the command-line interface as the same thing
What it looks likeSaying a timesharing system is a command-line interface because people typed into it.
Why it failsTimesharing describes shared access among several users. The command-line interface describes the typed communication style. One can exist without the other.
Do this insteadAsk two separate questions: how many people share the machine, and how the exchange is communicated.
Common mistake Believing the command-line interface requires many users
What it looks likeAssuming a typed exchange with a personal computer is not a command-line interface because only one person uses it.
Why it failsEarly personal computers used command-line interaction with one person at a time.
Do this insteadA command-line interface can describe a typed exchange even when multiple users are not sharing the computer.
Common mistake Thinking the earlier attendant model was interactive
What it looks likeDescribing submitting a program to an attendant and receiving output later as a live conversation.
Why it failsThe user did not communicate with the computer directly. The interaction was a submission followed by a delayed delivery.
Do this insteadInteractive means the user types a command, the computer responds, and the user can act on that reply.
Common mistake Describing timesharing as the computer serving one user completely before moving to the next, when the source describes rapid switching of attention
Checking Your Understanding of the Loop
A user at one terminal types a command, and the computer returns a typed response. Then a second user at another terminal types a command. Explain, in your own words, which stage of the command-and-response loop each user is in, and why this is different from the attendant model. Then say whether this scenario describes timesharing, the command-line style, or both, and justify your answer.
Hints
- Count the stages: user types, computer responds, response is typed back.
- Ask separately how many people share the computer and how the exchange is communicated.
- The source says timesharing switches the computer's attention rapidly between users.
Explain to a classmate why an early personal computer with a single typed user still counts as using command-line interaction, even though no timesharing occurred.
Hints
- Focus on the communication style, not on how many people shared the machine.
Key Takeaways
- A command-line interface is defined by typed commands from the user and typed responses from the computer, forming an interactive loop.
- Early computing separated ordinary people, including most programmers, from the computer: they submitted work to attendants and received results later.
- Timesharing let multiple people interact directly with one computer by rapidly switching the computer's attention between them.
- Timesharing describes shared access, while the command-line interface describes the communication style; early personal computers used the typed style with one person at a time.
- Tracing an exchange means following the user's command, the computer's response, and the typed reply back to the user, which then shapes the next command.