UNIX: Making Computers Easier To Use -- AT&T Archives film from 1982, Bell Laboratories

Summary

This video script discusses the development of the UNIX operating system, which began in 1969 at Bell Labs by Ken Thompson and Dennis Ritchie. It highlights UNIX's simplicity, productivity, and ability to solve complex computing problems by breaking them into smaller tasks. The script explains the core components of UNIX: the kernel, shell, and utility programs. Examples include using UNIX for document preparation, spell-checking, and creating pipelines to streamline processes. The video emphasizes UNIX's impact on programming, file management, and its ability to foster a collaborative computing environment.

Takeaways

• 💻 UNIX was developed in 1969 by Ken Thompson and Dennis Ritchie at Bell Labs to simplify complex operating systems.
• 🛠 UNIX helps make computing tasks easier by decomposing complex tasks into simpler subtasks, improving productivity.
• 🔧 The UNIX operating system consists of three main parts: the kernel, the shell (command interpreter), and utility programs.
• 🔍 UNIX allows users to create programs by combining existing ones, like building blocks, without starting from scratch.
• 📂 UNIX's file system is versatile, allowing users to store and retrieve files in a formatless manner, making it easier for programmers.
• 🚀 Pipelining in UNIX enables the seamless connection of multiple programs, allowing data to flow efficiently between them.
• 👥 UNIX was designed not only as a powerful tool but also as a communal system where users could collaborate and share solutions.
• 📝 UNIX utilities like spelling checkers and writing aids have expanded beyond Bell Labs, contributing to various applications like document preparation.
• 📈 The modularity of UNIX allows rapid development of new applications by leveraging pre-existing, debugged components.
• 🔗 UNIX’s strength lies in its flexibility and efficiency, making it a highly productive system for a wide range of computing tasks.

Q & A

Who were the primary developers of the UNIX operating system?

Ken Thompson and Dennis Ritchie were the primary developers of the UNIX operating system, which they began developing at Bell Labs in 1969.

What was the initial motivation behind the development of UNIX?

Thompson and Ritchie developed UNIX because they found existing operating systems to be too complex, and they wanted to create a simpler, more efficient system that provided a better programming environment.

How does the UNIX operating system improve programming productivity?

UNIX enhances productivity by providing a simple operating system with reusable tools, allowing users to build complex programs by combining smaller programs, rather than writing everything from scratch.

What are the three main components of the UNIX operating system?

The three main components are: the kernel, which manages the computer's hardware; the shell, which interprets user commands; and the utility programs, which perform specific tasks like editing or sorting.

How does the UNIX file system structure compare to a file cabinet?

The UNIX file system is similar to a file cabinet, where directories are like folders and files are like sheets of paper. This hierarchical structure allows for efficient file organization and retrieval.

What is 'pipelining' in UNIX, and why is it important?

Pipelining in UNIX allows multiple programs to be connected so that the output of one program becomes the input of the next, simplifying data processing. It enables efficient stream processing without the need for temporary files.

How does UNIX handle file data differently from other operating systems?

UNIX treats files as 'formless,' meaning they are just streams of bytes. This allows any program to process any file, making data handling more flexible compared to other systems where file formats are rigidly defined during creation.

What is the benefit of using existing utility programs in UNIX?

Using existing utility programs in UNIX allows users to build new functionality quickly by combining smaller, pre-existing tools, saving time and avoiding the need to develop everything from scratch.

What kind of software did the UNIX team at Bell Labs initially create, and how did it evolve?

The team initially created programs for their own needs, but these tools became widely used throughout Bell Labs and eventually beyond. UNIX's modularity and its growing family of utilities allowed it to evolve into a powerful, general-purpose system.

How has the UNIX system contributed to writing and documentation at Bell Labs?

UNIX helped develop tools like the 'Writer's Workbench,' which assisted in improving technical documentation. These tools provided spelling checks, style analysis, and readability scores, helping non-professional writers create clearer documents.

Outlines

00:00

🔧 The Origins of UNIX: A Revolutionary Operating System

Paragraph 1 introduces the development of UNIX by Ken Thompson and Dennis Ritchie at Bell Labs in 1969. Initially created to address their own needs, UNIX quickly evolved into a widely used operating system both within Bell Labs and globally. The paragraph discusses the need for better programming tools to improve productivity in the tech industry, comparing it to historical telephone switching by human operators. It highlights how UNIX tackled the growing challenge of managing large amounts of software across various systems and applications, providing a solution for efficient computing.

05:01

🔠 Breaking Down Complex Programs into Simple Components

Paragraph 2 delves into the powerful modularity of UNIX, focusing on how users can build complex programs by connecting smaller, simpler ones. An example is provided where a UNIX user finds spelling errors in a document by running multiple small programs sequentially. The process involves converting a sentence into individual words, standardizing case, sorting, and removing duplicates before comparing against a dictionary. This approach showcases the flexibility and efficiency of UNIX in handling tasks by reusing existing tools rather than creating new programs from scratch.

10:01

📂 UNIX File System and Streamlining Data Processing

Paragraph 3 explains the structure and advantages of the UNIX file system, likening it to a filing cabinet with nested folders and files. The UNIX system treats files as strings of characters or bytes, making it easier for programmers to handle data without rigid formatting restrictions. Additionally, the concept of 'pipelining' is introduced, where multiple programs are connected in a stream to process data efficiently. The paragraph concludes by demonstrating how UNIX’s pipelining eliminates the need for temporary files, simplifying complex operations.

15:04

📊 The Power of Pipelines and Efficient Task Automation

Paragraph 4 builds upon the concept of pipelining, showing how UNIX allows users to automate repetitive tasks and improve productivity. The example of a talking calculator demonstrates how different programs can be combined to create seamless workflows. By putting a series of commands into a file, users can automate the process, reducing the need to type the same commands repeatedly. This highlights UNIX’s ability to simplify complex tasks and empower users to automate their work with minimal effort.

20:04

✍️ Writing Aids and Enhanced Documentation with UNIX

Paragraph 5 shifts focus to applications of UNIX beyond programming, specifically in document preparation. The UNIX-based 'Writer’s Workbench' helps authors improve the quality of technical documentation by checking spelling, grammar, and writing style. This tool is particularly useful for non-professional writers, such as engineers and developers, who produce critical documentation. The paragraph emphasizes how UNIX’s modularity enabled the rapid development of such tools, demonstrating the system’s wide-reaching impact beyond computing tasks.

Keywords

💡UNIX

UNIX is a family of multitasking, multiuser computer operating systems that is widely used in computing industry. In the video, UNIX is highlighted as a system developed by Ken Thompson and Dennis Ritchie at Bell Labs, which has evolved to be widely used not only within Bell System but also globally. The video discusses UNIX's role in solving complex computing tasks and its impact on productivity in high technology industries.

💡Operating System

An operating system is a system software that manages computer hardware, software resources, and provides services for computer programs. In the context of the video, the operating system, particularly UNIX, is described as a collection of programs that simplify the computer's hardware for application programmers, allowing them to create software more easily.

💡Productivity

Productivity in the video refers to the efficiency and effectiveness of work, especially in the context of software development. The video emphasizes the need for better techniques and tools, like UNIX, to enhance productivity in programming and software maintenance, drawing an analogy with the historical need for telephone operators and the shift to automated systems.

💡Application Software

Application software are programs that perform specific tasks, such as word processing or database management, for the user. The video distinguishes between application software and system software, with the latter including the operating system that manages computer resources. UNIX is shown as a platform that supports the development of various application software.

💡Time-sharing

Time-sharing is a method of sharing computing resources among many users by allocating a small amount of time for each user. In the video, the concept is mentioned as an essential feature of communal computing, where UNIX systems encourage close communication and efficient use of computing resources through time-sharing.

💡Shell

The shell in UNIX is the command-line interpreter that provides a way for users to interact with the operating system. The video describes the shell as part of the UNIX operating system that manages the communication between the user and the system, interpreting commands and executing programs.

💡Pipeline

A pipeline in UNIX is a mechanism of invoking multiple programs and linking their input and output streams in a chain. The video uses the example of a spelling mistake program to illustrate how pipelines allow data to flow from one program to another without the need for intermediate files, streamlining the process and enhancing productivity.

💡Formless File

A formless file, as mentioned in the video, is a file that contains a stream of bytes without any predefined structure. UNIX's file system treats files as formless, which simplifies programming as any program can process any file. This concept is central to UNIX's flexibility and the ability to use data in various ways.

💡Proofreading

Proofreading in the video refers to the process of checking written text for errors and inconsistencies. The UNIX system is used to develop tools like 'proofer', which help in identifying spelling mistakes and punctuation errors, and also analyze the style of written text, making documentation and other written materials more professional and readable.

💡Darwinism in Computing

The term 'Darwinism in Computing' used in the video refers to the natural selection process where useful programs and commands developed by individuals for their needs are adopted by others, leading to their widespread use. This concept illustrates how UNIX and its utilities have evolved and become integral parts of the computing ecosystem due to their utility and adaptability.

Highlights

Ken Thompson and Dennis Ritchie developed UNIX at Bell Labs in 1969.

UNIX is widely used in various industries for solving complex problems.

High technology industry faces challenges in software productivity and maintenance.

UNIX helps manage large amounts of software across many computers.

UNIX decomposes complex computing tasks into simple subtasks.

UNIX is composed of a kernel, a shell, and utility programs.

UNIX allows creating complex programs by combining simpler ones.

UNIX's file system is likened to a file cabinet, simplifying data retrieval.

UNIX's formless files allow any program to process any file.

Pipelining is a fundamental contribution of UNIX, allowing data to flow between programs.

UNIX streamlines tasks by eliminating the need for temporary files.

UNIX utilities have been used to build valuable applications beyond the Bell System.

UNIX's development has been influenced by Darwinian principles, spreading useful programs.

UNIX has aided in the quick development of programs like the writer's workbench.

UNIX's proofreading program 'proofer' checks spelling and punctuation errors.

UNIX's style analysis program helps improve the readability of written text.

UNIX's impact on computing is seen as a step towards easier technology use.

Transcripts

back in 1969

a couple of computer scientists here at

Bell Labs started to develop some

programs they needed for their own use

what Ken Thompson and Dennis Ritchie

started developing then has evolved into

the UNIX operating system which by now

is widely used not only in the Bell

System but in other places around the

world in the next few minutes we're

going to tell you about a few of the

problems that UNIX is useful for and

we're going to talk some about both

operating systems in general and the

UNIX operating system in particular to

show you how UNIX helped people solve

problems

if you look particularly at Bell

Laboratories but at high technology

industry in general there is a

tremendous need for better techniques

and tools to make our work more

productive we just simply cannot like

all the software that needs to be

written in fact a good analogy is that a

number of years ago when telephone calls

were switched not by computers but by

human beings operators people predicted

that sooner or later the entire

population of the United States would

have to be telephone operators to switch

all of the calls that needed to be

switched we have the same problem in

programming productivity today now

keeping large amounts of software

working and keeping it working in the

face of change simply takes a lot of

people the bell system we have many

millions of lines of software we have

thousands of many computers we have

hundreds of very large computers and

there is a lot of software that needs to

be kept working there's all different

sorts of software there are is the

switching software that switches your

telephone calls there is administrative

software that administers the entire

process and there is for instance the

billing software how many systems do you

know give you a bill for something that

costs as little as 10 or 20 cents

there's a lot of software so we need

lots of techniques and tools to make

this more productive the programs which

tell a computer how to switch a

telephone call or computer payroll or

play an electronic game are called

application software there's another

type of software the programs which

control the resources of the computer

itself the memory of the computer the

processing elements and the terminals

connected to the computer

this latter type of software is called

an operating system another way of

saying what an operating system is is

that it's a collection of programs which

make the intricate hardware of the

computer see more simple and

comprehensible from the point of view of

an applications programmer so that the

applications programmers can create

software more easy

we are trying to make computing as

simple as possible in the late 1960s

Dennis Ritchie and I realized that the

then-current

operating systems were much too complex

we attempted to reverse this trend by

building a small simple operating system

on a mini computer what we wanted to

preserve was not just a good programming

environment in which to do programming

but a system around which a community

could form fellowship we knew from

experience that the essence of communal

computing as supplied by remote access

time sharing systems is not just a type

programs into a terminal instead of a

keypunch but to encourage close

communication UNIX started out as a

two-man effort and by now it's used all

over Bell Labs we have close to 20,000

computer terminals in this company

roughly one per employee and most of

them are used for communicating with

UNIX systems one of the main reasons

that UNIX is popular around here is

because it provides graceful facilities

for decomposing complex computing tasks

into simple subtasks the UNIX operating

system is basically made up of three

parts the kernel or operating system

proper is the part that manages the

control of the Machine and supervises

scheduling of the various user programs

the shell or which is the name we give

to the command interpreter looks after

the communication between the user and

the system itself the third part which

is actually the largest is the various

utility programs which perform specific

tasks like editing a file or sorting a

bunch of numbers or making a plot in

other words all the other programs that

are not provided directly as part of the

operating system kernel one of the

things about UNIX is the ability that we

have to create complicated programs by

building them out of simpler programs

rather than writing programs from

scratch we can often construct them just

by gluing together existing programs

almost like building blocks

let me show you an example of how that

would work by writing a program without

actually writing a program to find

spelling mistakes one of the things that

UNIX has been used for it for a long

time is document preparation helping

create letters and papers and books and

so on so let me write this spelling

mistake program I'm not going to do it

for a whole document because we don't

have one but let me print a single

sentence the sentence comes from a paper

that John Massey and I wrote and if you

look at it carefully you can see that

they're actually a couple of spelling

mistakes in it so suppose that we wanted

to use a computer to find those spelling

mistakes instead of doing it by hand

basically what we want to do is to take

each of the words in that sentence and

compare them against dictionary to

compare it against the dictionary which

is sort of one word for line it's

certainly going to be easiest to convert

this into one word per line so let me

run a program called make words program

that already exists we'll take its input

from sentence and we'll dump the output

into some thing that I will simply call

words words is a file just like sentence

let's look at that and there it is all

of the words one word per line now if I

want to compare those against a

dictionary I've made some progress but

it's clearly not done yet because for

example my dictionary doesn't have the

word Bell or the word Laboratories with

a capital letter at the beginning it

only has them in lowercase and so if I

do a blind search I won't get the right

answer so the next thing I want to do is

to convert words and the lowercase and

so let me just run a program called

lowercase on words and dump the output

in this case into something that'll call

LC words

inventing file names as I go here and

let's look at that one and see how we

did

and sure enough bail and laboratories

are in lower case so we're getting

warmer we're almost at the point where

we could compare these words one at a

time against the dictionary the

dictionary is in alphabetical order and

it will be a lot more efficient if we

only go one pass through my list of

words and one pass through the

dictionary rather than sort of poking

randomly at the dictionary so let me

sort my list of words so I'll say sort

kalsi words

and I'll put that one into sordid words

and let's see how that worked and sure

enough they're sorted into alphabetical

order we're sorting it shows us

something else

notice that the word systems appears

twice there and that seems kind of silly

and now in a single sentence it doesn't

really matter but in the big document

it'd be very nice to get rid of all of

the duplicates so let me run another

program which exists on UNIX called

unique and I will say unique from the

sorted words and to a unique words and

let's see what we got here

sure enough the word systems the

duplicated word has gone away and now

we're almost at the point what we want

to do finally is compare the list of

words that I have here with the

dictionary and print the words that are

in my list that are not in the

dictionary and we'll do that with a

program called mismatch where I simply

say mismatch and then we'll go from the

unique words and the dictionary those

are my two sources of input and mismatch

will simply print all of the words which

are in unique words that are not in the

dictionary and this one takes a little

longer because the dictionary is

actually fair size but sure enough we

got laboratories and we got provide

which are the two spelling mistakes and

that tells you that this is actually

quite a reasonable way to look for

spelling mistakes unfortunately we've

got a couple of other things we got the

word time-sharing and we got the word

unix and this tells you why it isn't a

perfect way to look for spelling

mistakes time sharing is a fine example

of jargon it's a word that means

something to everybody in computing and

probably means nothing at all the people

who aren't in the computer business and

UNIX is an example of a proper name and

is not likely to be in the dictionary

ever so what do we do when we get this

list of words what we do is that we fix

the spelling mistakes in the sentence

and that's done and we take the words

that weren't spelling mistakes but that

we're useful jargon like time sharing or

useful proper names like UNIX and we use

them to improve our dictionary so not

only are we finding the spelling

mistakes

but we're also able to do the job better

by taking that output and enhancing the

dictionary that we use to find further

spelling mistakes and so the next time

we do it we'll never see those words

again and so I think that what we've

seen here is the the way that programs

get developed on UNIX very often is not

by somebody sitting down and saying I'm

going to do this complicated job like

printing like creating a program to find

spelling mistakes what I'm going to do

instead is to try to break that big job

up into little pieces to see if I can do

a part here a part there and a part

somewhere else and then stick them

together to get the job done and then

the other thing that sort of comes with

UNIX is that they're already very large

collection of useful programs little

tools kind of building blocks that mean

that you don't have to build your own

building blocks you can use the ones

that are already there and I think this

is one of the reasons why UNIX is a very

productive system for most of us because

the set of building blocks is already

there and you can glue things together

very very quickly in the way that I've

shown you here and that way get your job

done in a hurry and that in a sense is

what productivity is one of the

strengths of the UNIX system is its file

system let me give you an oversimplified

example UNIX file system is like a file

cabinet in a file cabinet there are

folders within folders there are letters

sheets of paper and on these letters and

sheets of paper are words and characters

similarly in the UNIX file system there

are directories that have tags on them

and within directories you can find

other directories or files and this

allows you to be able to retrieve a file

very simply through this kind of

indexing system files in the UNIX system

are form atlas that means that they are

simply a string of characters or bytes

any format imposed on that data is done

by the programmer rather than by the

operating system

this makes programming very easy for for

programmers for let me contrast other

operating systems where at file creation

time a programmer must specify what

information will be in the file how big

the file will be etcetera and once that

is done the programmer is locked into it

having locked into that kind of file

then later it becomes impossible to put

another kind of data in that file the

analogy is to trying to put a legal

sized document into a letter size file

it simply won't fit the UNIX system you

don't have this problem because data in

files is form atlas and data can be

easily moved back and forth between

files form atlas files in which the data

consists solely of a stream of bytes

it's uninterpreted by the operating

system simplify life because it means

that any program can process any file

when you combine this with the concept

of pipelining your stream processing it

makes UNIX and extremely powerful

programming tool I think the notion of

pipelining is the fundamental

contribution of Unix the notion that you

can take a bunch of programs two or more

programs and stick them together end to

end so that the data simply flows from

the one on the left to the one on the

right and the system itself looks after

all the connections all of the

synchronization making sure that the

data goes from the one into the other

the programs themselves don't know

anything about the connection as far as

they're concerned they're just talking

to the terminal what Brian showed you

earlier was that rather than write a

special program to find spelling

mistakes it's possible with Unix to

cobble together already existing

programs and end up with a program that

basically finds spelling errors now he

did that by writing all by using one

program on his sentence

and then putting that output into a

temporary filing and running various

programs on the temporary files it's

possible using UNIX stream processing or

pipelining to eliminate the use of

temporary files and let the system put

the data from one program into the next

those are called pipelines let me show

you how that works with Brian's same

example I'll use the same programs in

the same text file so I first run on

make words on my text file and I run

that through lower case I run that

through sort and I run that through

unique and I run that through mismatched

and out of the end of the pipeline comes

the spelling errors now it's also

possible to sensing you get tired of

typing the all the commands on one line

to put the sequence of commands in a

file and run only that file the system

will then interpret what's inside that

file is what you want to run so I have

this same sequence and if I called check

and I can run check on my text and again

I'll get it get out my spelling errors

now let me show you another example I

have a desk calculator program I'm going

to run the output of the desk calculator

through program called number which

turns the numbers into English and then

I'm going to run that through a program

called speak which turns the written

English into spoken English and we now

have a talking calculator so if I say on

8-3 for example it tells me five

now I can put this in a file put this

pipeline in a file name talk calc and

get the same thing now we'll raise 2 to

the 100th power 100 million 267

octillion 650 septillion 660 Liang 228

quintillion 229 quadrillion 401 trillion

496 billion 700 3 million two hundred

five thousand 376 now person using this

program doesn't need to know that it's

that it's more than one program running

and all of these things make our life

much easier you don't have to keep

typing the same thing over and over

again and that's important for several

reasons the first one is that I as a

single programmer can can up a set of

commands that it would have had to have

typed but now I can get it by just

typing something fairly short I issue

one command and what's really done is

quite a few commands the second thing is

because it looks the same as the

existing commands on the system it's

very easy for other people to use

we've seen a great deal of Darwinism in

the development and spread of eunuchs

initially people in the computing

Science Research Center broke programs

and commands that we'll use were useful

for their own needs but a number of

other people discovered that they were

useful for their needs as well and as a

consequence these programs and spread

rapidly throughout the laboratories what

this all means is that there is more

leverage for everybody that this is sort

of a continuation of progress in the

computing field in which we have gone to

higher and higher level languages and

what has happened with UNIX is that over

the years we've developed an increasing

family this family of useful programs

has gotten bigger and bigger and bigger

and of course people who have used it

for a long time have a whole bunch of

members of this family at their

fingertips so that they can really get

things done very quickly and I think

it's that that really makes UNIX as

productive as it is people have used the

UNIX utilities to build all sorts of

valuable applications and all of these

are now part of the UNIX family of

programs some of these applications turn

out to have usefulness that goes way

beyond the bail system for example the

programs which we call the writers

workbench were originally designed for

the use of our own people here but by

now are used by people in a lot of other

places as well in the bail system we

produce enormous amounts of information

for craftspeople that tell them how to

install maintain and repair equipment

this documentation is much more

important these days than it used to be

25 years ago most of our equipment was

mechanical a person who was trying to

install a repair piece of equipment

could frequently figure out how to use

it just by looking at it these days

however our equipment is much more

complex it's made up of computers and

computer programs called software to

debug or fix this kind of equipment you

almost always need the documentation

this documentation is usually written by

the developers after all they know the

most about the equipment but they

weren't necessarily trained in how to

write well so to help people like this

and

improve the bail system documentation

we've developed some writing aids called

the writer's workbench to begin I'll

show you the output of a proofreading

program called proofer as you can see

here the file has only four lines in it

or three sentences probably by just

looking at it quickly you can tell that

it has several errors in it if it were a

longer paper however you might have

trouble figuring out what those errors

are so let me show you what our

proofreading program would do with this

text the first information that comes up

is a spelling check this program is

basically a spelling checker that's

similar to the one that Brian Carnahan

demonstrated earlier in this film one of

the advantages of UNIX is that we were

able to take this program and/or one

fairly similar to it and build it into a

proofreading package so you see that it

found the two misspelled words here it

then goes on and looks for simple kinds

of punctuation errors we've gone however

beyond simple proofreading to try and

analyze the style of people's written

text as well

remember they frequently don't have a

professional editor to look at their

writing and there's lots of things about

writing that are important especially in

training documentation but people

frequently don't know for instance you

want to have the smallest number of

passive verbs that you can and still

have the text read fluidly because the

passive verbs make text difficult to

read so we have a program that

analyzes many of the different features

of the syntactic style of a paper I've

run it here on a memo of mine here it

tells you what the readability score is

it tells you that it's 11th grade it

tells you that that's a reference to 11

years of schooling that you have to have

to read this text and tells you that

that's a good score it then goes on and

describes the variations and says that

you've had a good distribution of simple

compound complex and compound-complex

sentences following the short version it

tells you that 57 words is pretty long

for a sentence and that really you

probably ought to change it and it goes

beyond that and tells you how you could

find what that sentence is and all the

sentences in your text that are over

some lengths are UNIX operating system

helped us a lot to develop these

programs quickly for instance there were

many modules like the spelling checker

and the diction program that were

already existed and we're already

debugged so we didn't have to start from

scratch computing is going to be more

and more it or woven with people's lives

as the years go by so computer

technology is going to have to evolve to

be easier for people to use UNIX is

certainly not the end of the road in

this regard but I think it's a good step

along the way

you

you

you