Keyboards & Command Line Interfaces: Crash Course Computer Science #22 Video Lecture | Introduction to Computer Science: An Overview - Software Development

Hi, I’m Carrie Anne, and welcome to CrashCourse
Computer Science!
We’ve talked a lot about inputs and outputs
in this series, but they’ve mostly been
between different parts of a computer – like
outputting data from RAM or inputting instructions
to a CPU.
We haven’t discussed much about inputs coming
from humans.
We also haven’t learned how people get information
out of a computer, other than by printing
or punching it onto paper.
Of course, there’s a wide variety of input
and output devices that allow us users to
communicate with computers.
They provide an interface between human and
computer.
And today, there’s a whole field of study
called Human-Computer Interaction.
These interfaces are so fundamental to the
user experience that they’re the focus of
the next few episodes.
INTRO
As we discussed at the very beginning of the
series, the earliest mechanical and electro-mechanical
computing devices used physical controls for
inputs and outputs, like gears, knobs and
switches, and this was pretty much the extent
of the human interface.
Even the first electronic computers, like
Colossus and ENIAC, were configured using
huge panels of mechanical controls and patch
wires.
It could take weeks to enter in a single program,
let alone run it, and to get data out after
running a program, results were most often
printed to paper.
Paper printers were so useful that even Babbage
designed one for his Difference Engine, and
that was in the 1820s!
However, by the 1950s, mechanical inputs were
rendered obsolete by programs and data stored
entirely on mediums like punch cards and magnetic
tape.
Paper printouts were still used for the final
output, and huge banks of indicator lights
were developed to provide real time feedback
while the program was in progress.
It’s important to recognize that computer
input of this era was designed to be as simple
and robust as possible for computers.
Ease and understanding for users was a secondary
concern.
Punch tape is a great example – this was
explicitly designed to be easy for computers
to read.
The continuous nature of tape made it easy
to handle mechanically, and the holes could
be reliably detected with a mechanical or
optical system, which encoded instructions
and data.
But of course, humans don’t think in terms
of little punched holes on strips of paper.
So, the burden was on programmers.
They had to spend the extra time and effort
to convert their ideas and programs into a
language and a format that was easy for computers
of the era to understand – often with the
help of additional staff and auxiliary devices.
It’s also important to note that early computers,
basically pre-1950, had an extremely simple
notion of human input.
Yes, humans input programs and data into computers,
but these machines generally didn’t respond
interactively to humans.
Once a program was started, it typically ran
until it was finished.
That’s because these machines were way too
expensive to be waiting around for humans
to type a command or enter data.
Any input needed for a computation was fed
in at the same time as the program.
This started to change in the late 1950s.
On one hand, smaller-scale computers started
to become cheap enough that it was feasible
to have a human-in-the loop; that is, a back
and forth between human and computer.
And on the other hand, big fancy computers
became fast and sophisticated enough to support
many programs and users at once, what were
called multitasking and time-sharing systems.
But these computers needed a way to get input
from users.
For this, computers borrowed the ubiquitous
data entry mechanism of the era: keyboards.
At this point, typing machines had already
been in use for a few centuries, but it was
Christopher Latham Sholes, who invented the
modern typewriter in 1868.
It took until 1874 to refine the design and
manufacture it, but it went on to be a commercial
success.
Sholes’ typewriter adopted an unusual keyboard
layout that you know well – QWERTY – named
for the top-left row of letter keys.
There has been a lot of speculation as to
why this design was used.
The most prevalent theory is that it put common
letter pairings in English far apart to reduce
the likelihood of typebars jamming when entered
in sequence.
It’s a convenient explanation, but it’s
also probably false, or at least not the full
story.
In fact, QWERTY puts many common letter pairs
together, like “TH” and “ER”.
And we know that Sholes and his team went
through many iterations before arriving at
this iconic arrangement.
Regardless of the reason, the commercial success
of Sholes’ typewriter meant the competitor
companies that soon followed duplicated his
design.
Many alternative keyboard layouts have been
proposed over the last century, claiming various
benefits.
But, once people had invested the time to
learn QWERTY, they just didn't want to learn
something new.
This is what economists would call a switching
barrier or switching cost.
And it’s for this very basic human reason
that we still use QWERTY keyboards almost
a century and a half later!
I should mention that QWERTY isn’t universal.
There are many international variants, like
the French AZERTY layout, or the QWERTZ layout
common in central Europe.
Interestingly, Sholes didn’t envision that
typing would ever be faster than handwriting,
which is around 20 words per minute.
Typewriters were introduced chiefly for legibility
and standardization of documents, not speed.
However, as they became standard equipment
in offices, the desire for speedy typing grew,
and there were two big advances that unlocked
typing’s true potential.
Around 1880, Elizabeth Longley, a teacher
at the Cincinnati Shorthand and Type-Writer
Institute, started to promote ten-finger typing.
This required much less finger movement than
hunt-and-peck, so it offered enhanced typing
speeds.
Then, a few years later, Frank Edward McGurrin,
a federal court clerk in Salt Lake City, taught
himself to touch-type; as in, he didn’t
need to look at the keys while typing.
In 1888, McGurrin won a highly publicized
typing-speed contest, after which ten-finger,
touch-typing began to catch on.
Professional typists were soon able to achieve
speeds upwards of 100 words per minute, much
faster than handwriting!
And nice and neat too!
So, humans are pretty good with typewriters,
but we can’t just plunk down a typewriter
in front of a computer and have it type – they
have no fingers!
Instead, early computers adapted a special
type of typewriter that was used for telegraphs,
called a teletype machine.
These were electromechanically-augmented typewriters
that could send and receive text over telegraph
lines.
Pressing a letter on one teletype keyboard
would cause a signal to be sent, over telegraph
wires, to a teletype machine on the other
end, which would then electromechanically
type that letter.
This allowed two humans to type to one another
over long distances... basically a steampunk
version of a chat room.
Since these teletype machines already had
an electronic interface, they were easily
adapted for computer use, and teletype computer
interfaces were common in the 1960s and 70s.
Interaction was pretty straightforward.
Users would type a command, hit enter, and
then the computer would type back.
This text “conversation” between a user
and a computer went back and forth.
These were called command line interfaces,
and they remained the most prevalent form
of human-computer interaction up until around
the 1980s.
Command Line interaction on a teletype machine
looks something like this.
A user can type any number of possible commands.
Let’s check out a few, beginning with seeing
all of the files in the current directory
we’re in.
For this, we would type the command, “ls”,
which is short for list, and the computer
replies with a list of the files in our current
directory.
If we want to see what’s in our “secret
StarTrek Discovery Cast dot t-x-t file”,
we use yet another command to display the
contents.
In unix, we can call “cat” - short for
concatenate.
We need to specify which file to display,
so we include that after the command, called
an argument.
If you’re connected to a network with other
users, you can use a primitive version of
a Find My Friends app to get more info on
them with the command “finger”.
Electromechanical teletype machines were the
primary computing interface for most users
up until around the 1970s.
Although computer screens first emerged in
the 1950s, and were used for graphics they
were too expensive and low resolution for
everyday use.
However, mass production of televisions for
the consumer market, and general improvements
in processors and memory, meant that by 1970,
it was economically viable to replace electromechanical
teletype machines with screen-based equivalents.
But, rather than build a whole new standard
to interface computers with these screens,
engineers simply recycled the existing text-only,
teletype protocol.
These machines used a screen, which simulated
endless paper.
It was text in and text out, nothing more.
The protocol was identical, so computers couldn’t
even tell if it was paper or a screen.
These virtual teletype or glass teletype machines
became known as terminals.
By 1971, it was estimated, in the United States,
there was something on the order of 70,000
electro-mechanical teletype machines and 70,000
screen-based terminals in use.
Screens were so much better, faster and more
flexible, though.
Like, you could delete a mistake and it would
disappear.
So, by the end of the 1970s, screens were
standard.
You might think that command line interfaces
are way too primitive to do anything interesting.
But even when the only interaction was through
text, programmers found a way to make it fun.
Early interactive, text-based computer games
include famous titles like Zork, created in
1977.
Players of these sorts of early games were
expected to engage their limitless imaginations
as they visualized the fictional world around
them, like what terrifying monster confronted
them when it was pitch black and you were
likely to be eaten by a grue.
Let’s go back to our command line, now on
a fancy screen-based terminal, and play!
Just like before, we can see what’s in our
current directory with the “ls” command.
Then, let’s go into our games directory
by using the “cd” command, for “change
directory”.
Now, we can use our “ls” command again
to see what games are installed on our computer.
Sweet, we have Adventure!
All we have to do to run this program is type
its name.
Until this application halts, or we quit it,
it takes over the command line.
What you’re seeing here is actual interaction
from “Colossal Cave Adventure”, first
developed by Will Crowther in 1976.
In the game, players can type in one- or two-word
commands to move around, interact with objects,
pickup items and so on.
The program acts as the narrator, describing
locations, possible actions, and the results
of those actions.
Certain ones resulted in death!
The original version only had 66 locations
to explore, but it’s widely considered to
be the first example of interactive fiction.
These text adventure games later became multiplayer,
called MUDs or Multi-User Dungeons.
And they’re the great-forbearers of the
awesome graphical MMORPG’s (massive, multiplayer
online role playing games) we enjoy today.
And if you want to know more about the history
of these and other games we’ve got a whole
series on it hosted by Andre Meadows!
Command line interfaces, while simple, are
very powerful.
Computer programming is still very much a
written task, and as such, command lines are
a natural interface.
For this reason, even today, most programmers
use command line interfaces as part of their
work.
And they’re also the most common way to
access computers that are far away, like a
server in a different country.
If you’re running Windows, macOS or Linux,
your computer has a command line interface
– one you may have never used.
Check it out by typing “cmd” in your Windows
search bar, or search for Terminal on Mac.
Then install a copy of Zork and play on!
So, you can see how these early advancements
still have an impact on computing today.
Just imagine if your phone didn’t have a
good ol’ fashioned QWERTY keyboard.
It could take forever to type your Instagram
captions.
But, there’s still something missing from
our discussion.
All the sweet sweet graphics!
That’s our topic for next week.
See you soon.