Early Programming: Crash Course Computer Science #10

Summary

This Crash Course Computer Science episode explores the history of programming, from the Jacquard loom's punched cards to electronic memory. It discusses the evolution of data input methods, including the challenges of using punch cards and the development of stored-program computers. The video also touches on the von Neumann architecture and the need for simpler programming languages, setting the stage for future episodes on the topic.

Takeaways

• 💾 The script discusses the history and evolution of how programs are loaded into a computer's memory, emphasizing that it's a scientific process, not magic.
• 🧵 The Jacquard loom, demonstrated in 1801, is highlighted as an early form of programmable machine, using punched cards to define patterns in textiles.
• 📊 Punch cards were a significant innovation for data storage, being cheap, reliable, and somewhat human-readable, which was later utilized in the 1890 census.
• 🔌 Early tabulating machines, while not programmable, laid the groundwork for more complex business machines that could perform arithmetic and make simple decisions.
• 🔩 The use of plug boards, where programmers physically wired machines to perform different tasks, was a precursor to modern programming but was cumbersome and time-consuming.
• 💡 The advent of stored-program computers in the late 1940s and 1950s allowed programs to be stored electronically within a computer's memory, making them more flexible and efficient.
• 🏛️ The von Neumann architecture, which unified programming and data into a single shared memory, became the standard for computer design and is still used today.
• 🎓 The University of Manchester's 'Baby', built in 1948, was the first computer to implement the stored-program concept, marking a significant milestone in computing history.
• 📚 Punch card readers were a common method for loading programs into computers until the 1980s, illustrating the transition from physical to digital data input.
• 🛠️ Early programming required a deep understanding of hardware and was limited to experts or enthusiasts, setting the stage for the development of higher-level programming languages.

Q & A

What is the main topic discussed in this Crash Course Computer Science episode?

The main topic discussed is how programs get loaded into a computer's memory and the historical methods used for programming machines before the advent of modern computers.

How did Joseph Marie Jacquard's programmable textile loom work?

Jacquard's loom used punched cards where the pattern for each row of the cloth was defined by the presence or absence of a hole in the card, determining if a thread was held high or low to create patterns like stripes or plaid.

What was the significance of punch cards in early data processing?

Punch cards were a cheap, reliable, and fairly human-readable way to store data. They were used in the 1890 census to tabulate data and in early computers to store and execute programs.

What were the limitations of early tabulating machines?

Early tabulating machines could only perform one function, which was to tabulate data. They were not programmable and could not perform a variety of operations like modern computers.

Why were plug boards used in early computing?

Plug boards were used to control the functions of early business machines by allowing programmers to plug cables into sockets on a control panel, enabling different calculations and operations to be performed.

What was the problem with using plug boards for programming?

Using plug boards was complicated and time-consuming as it required physically rewiring the machine each time a different program needed to be run, which was inefficient and led to the search for faster and more flexible programming methods.

What is a stored-program computer and how does it differ from earlier computers?

A stored-program computer is one where the program is stored entirely in the computer's memory, allowing for easy changes and quick access by the CPU. This differs from earlier computers that used physical setups like plug boards to store programs.

Who is credited with the von Neumann architecture and what is its significance?

John von Neumann is credited with the von Neumann architecture, which is significant because it unified programming and data into a single shared memory, allowing for more efficient and flexible computing.

What was the role of punch cards in loading programs into computers?

Punch cards were used to load programming data into computers by reading the contents of the cards into the computer's memory. This method was used well into the 1980s for program input.

What was the largest program ever punched into punch cards and how many cards did it require?

The largest program ever punched into punch cards was the US Air Force's SAGE air defense system, which required 62,500 punch cards, equivalent to roughly 5 megabytes of data.

How did early home computers like the Altair 8800 allow users to program?

Early home computers like the Altair 8800 allowed users to program by toggling switches on the front panel to enter binary opcodes for instructions, then writing those values into memory and executing the program.

Outlines

00:00

💾 The Evolution of Programming and Early Data Storage

Carrie Anne introduces the topic of how programs are loaded into a computer's memory, contrasting the magical explanation from previous episodes with the reality of computer science. The discussion delves into the history of programming, starting with Joseph Marie Jacquard's programmable textile loom in 1801, which used punched cards to define patterns. The concept of punched cards as an early form of programming is explored, including their use in the 1890 census for data tabulation. The limitations of early tabulating machines are highlighted, as they were not programmable and could only perform one function. The evolution of business machines over the next sixty years is outlined, with the introduction of plug boards for programming, which were later made swappable for convenience. The complexity and time-consuming nature of programming with plug boards is emphasized, leading to the need for a more efficient method. The advent of stored-program computers in the late 1940s and 1950s is discussed, with electronic memory allowing programs to be stored directly in a computer's memory, leading to the von Neumann architecture, which unified programming and data storage. The first such computer, nicknamed 'Baby,' was constructed at the University of Manchester in 1948.

05:04

📋 The Transition from Physical to Digital Programming

The second paragraph discusses the transition from physical programming methods like plug boards and punch cards to digital programming. Punch cards were widely used to load programming data into computers, with readers that could sequentially吸入 cards and write their contents into memory. The process was prone to errors, such as dropping a stack of cards and the subsequent time-consuming reordering. The use of punched paper tape as a continuous data storage medium is mentioned, as well as the anticipation of covering more advanced storage methods like hard drives and USB drives in future episodes. The paragraph also covers panel programming, which involved using switches and buttons on large control panels to input data and control computer functions. The Altair 8800, an early home computer, is highlighted as an example of a system that required users to manually enter binary codes using switches. The paragraph concludes by emphasizing the need for simpler programming languages to make computing more accessible, setting the stage for the next episode's focus on programming languages.

Keywords

💡Computer Program

A computer program is a sequence of instructions that a computer follows to perform a specific task or solve a problem. In the context of the video, it's mentioned that programs need to be loaded into a computer's memory to be executed, contrasting the earlier simplification of the process. The video emphasizes the evolution from manual setup to stored-program computers, highlighting the importance of programs in the functionality of computers.

💡Memory

Memory in computing refers to the digital storage where data and instructions are held for immediate use by the computer. The video discusses how programs, which were once manually input, are now stored in memory, making them accessible to the CPU. This shift to electronic memory was a significant advancement, as it allowed for more efficient and flexible use of computer programs.

💡Punched Cards

Punched cards were a method of data storage used in early computing, where holes punched in specific patterns on the card represented data. The video explains how these cards were used to program the Jacquard loom and later in tabulating machines and computers. They were a precursor to modern data input methods and were key in the development of programming and data storage.

💡Tabulating Machine

A tabulating machine is an early computing device designed to process data stored on punched cards. The video describes how these machines were used to automate the counting and sorting of data from census records. While not programmable in the modern sense, they laid the groundwork for later developments in data processing and computer programming.

💡Plug Boards

Plug boards, also known as control panels, were used in early computers to physically wire different functions and operations. The video mentions that programming with plug boards was laborious and time-consuming, requiring the programmer to manually connect cables to activate specific machine functions. This method was later replaced by more flexible and efficient programming techniques.

💡Stored-Program Computers

Stored-program computers are a type of computer design where both the program and the data it operates on are stored in the computer's memory. The video explains that this design, known as the von Neumann architecture, allowed for more flexible and efficient use of computer programs. It contrasts with earlier methods where programs were physically wired into the machine.

💡von Neumann Architecture

The von Neumann architecture is a computer design model where the program and data share the same read/write memory. The video highlights this architecture as a significant milestone in computer science, enabling the development of more advanced and flexible computers. It was named after John von Neumann, who contributed to the development of early electronic computers.

💡Punched Paper Tape

Punched paper tape is a data storage medium that predates modern digital storage. The video briefly mentions it as a continuous strip of paper with holes punched to represent data, similar to punched cards but more compact. It was used for data input and output in early computing systems.

💡Panel Programming

Panel programming refers to the method of programming early computers using physical switches and buttons on a control panel. The video describes how this method was used on early home computers like the Altair 8800, where users would manually set switches to input binary codes for programming. This approach was labor-intensive and required a deep understanding of the computer's hardware.

💡CPU

The CPU, or Central Processing Unit, is the primary component of a computer that performs most of the processing inside the computer. The video mentions the CPU in the context of executing programs stored in memory, emphasizing its role as the brain of the computer that carries out the instructions of a program.

💡Programming Languages

Programming languages are formal languages used to instruct computers to perform specific tasks. The video concludes by hinting at the evolution towards higher-level programming languages, which abstracted away the complexities of hardware-specific coding. This development made programming more accessible to a broader range of users, not just experts.

Highlights

Programs must be loaded into a computer's memory, which is not a magical process but a part of computer science.

The need for programming machines predates computers, with early examples in textile manufacturing.

Joseph Marie Jacquard's programmable textile loom, demonstrated in 1801, is considered one of the earliest forms of programming.

Punched cards were a cheap, reliable, and human-readable way to store data, used in Jacquard's loom and later in census tabulation.

Early tabulating machines were not programmable and could only perform one function, such as tabulating data.

Business machines evolved to include more capabilities like subtraction, multiplication, and decision-making.

Plug boards, with their tangle of wires, were used to program early computers but were complicated and time-consuming.

The Eniac, the world's first general-purpose electronic computer, used plug boards for programming.

Stored-program computers emerged in the late 1940s, allowing programs to be stored entirely in a computer's memory.

The von Neumann architecture unified programming and data into a single shared memory, influencing modern computer design.

The first von Neumann architecture stored-program computer, nicknamed 'Baby', was constructed in 1948 at the University of Manchester.

Punch cards were used to load programming data into computers, with readers that could sequentially input cards into memory.

The largest program ever punched into punch cards was the US Air Force's SAGE air defense system, stored on 62,500 cards.

Punched paper tape was a continuous version of punch cards, used for data input and output.

Panel programming, using switches and buttons, was another method to program early computers, especially in home computing.

Programming early computers required intimate knowledge of hardware, making it a complex and tedious task for experts.

The need for simpler programming languages arose to make computing more accessible to a broader range of users.

Transcripts

Hi, I'm Carrie Anne and welcome to Crash Course Computer Science.

Over the last few episodes,

We've talked a lot about the mechanics of how computers work.

How they use complex circuits to save and retrieve values from memory,

and perform operations on those values,

like adding two numbers together.

We've even briefly talked about sequences of operations,

which is a computer program.

What we haven't talked about

is how a program gets into a computer.

You might remember in episode 7 and 8 ,

when we stepped through some simple example programs for the CPU that we had created.

For simplicity, we just waved our hands

and said that the program was already magically in memory.

But in reality, programs have to be loaded into a computer's memory.

It's not magic. It's computer science.

[Theme Music]

The need to programme machines existed way before the development of computers.

The most famous example of this was in textile manufacturing.

if you just wanted to weave a big red tablecloth,

you could simply feed red thread into a loom and let it run.

But what about if you wanted the cloth to have a pattern like stripes or plaid?

Workers would have to periodically reconfigure the loom as dictated by the pattern,

but this was labor intensive which made patterned fabrics expensive.

In response, Joseph Marie Jacquard developed a programmable textile loom,

which he first demonstrated in 1801.

The pattern for each row of the cloth was defined by a punched card.

The presence or absence of a hole in the card determined

if a specific threat was held high or low in the loom.

Such that the cross thread called the weft passed above or below the thread.

To vary the pattern across rows these punch cards were arranged in long chains,

forming a sequence of commands for the loom.

Sound familiar?

Many consider Jacquard's loom to be one of the earliest forms of programming.

Punched cards, turned out to be a cheap , reliable,

fairly human readable way to store data.

Nearly a century later,

punch cards were use to help tabulate the 1890 newest census

which we talked about in episode 1.

Each card held an individual person's data.

Things like race,

marital status,

number of children,

country of birth, and so on.

For each demographic question,

a census worker would punch out a hole of the appropriate position.

When a card was fed into the tabulating machine,

a hole would cause the running total for that specific answer to be increased by one.

In this way you could feed the

entire county's worth of people

and at the end you'd have running totals for all of the questions that you asked.

It is important to note here that early tabulating machines

were not truly computers as they can only do one thing-tabulate.

Their operation was fixed and not programmable.

Punished cards stored data, but not a program.

Over the next 60 years, these business machines grew in capability,

adding features to subtract, multiply, divide,

and even make simple decisions about when to perform certain operations.

To trigger these functions appropriately,

so that different calculations could be performed,

a programmer accessed a control panel.

This panel was full of little sockets, into which a programmer would plug cables

to pass values and signals between different parts of the machine.

For this reason they were also called plug boards.

Unfortunately, this meant having to rewire the machine each time a different program needed to be run.

And so by the 1920s, these plug boards were made swappable.

This not only made programming a lot more comfortable,

but also allowed for different programs to be plugged into a machine.

For example, one board might be wired to calculate sales tax, while another helps with payroll.

But plug boards were fiendishly complicated to program.

This tangle of wires is a program for calculating a profit loss summary,

using an IBM 402 accounting machine, which were popular in the 1940s.

And this style of plug board programming wasn't unique to electromechanical computers.

The world's first General-Purpose electronic computer,

the Eniac, completed in 1946, used a ton of them.

Even after a program had been completely figured out on paper,

physically wiring up the Eniac and getting the program to run could take upwards of three weeks.

Given the enormous cost of these early computers, weeks of downtime simply to switch programs

was unacceptable and the new, faster, more flexible way to programme machines was badly needed.

Fortunately by the late 1940s and into the 50s, electronic memory was becoming feasible.

As costs fell, memory size grew.

Instead of storing a program as a physical plug board of wires, it became possible to store a program entirely in a computer's memory.

Where it could be easily changed by programmers and quickly accessed by the CPU.

These computers were called stored-program computers.

With enough computer memory, you could store not only the program you wanted to run,

but also any data your program would need.

Including new values it created along the way,

Unifying the progrmming data into a single shared memory is called the von Neumann architecture.

Named after John von Neumann, a prominent mathematician and physicist,

who worked on the Manhattan project and several early electronic computers.

And once said, "I'm thinking about something much more important than bombs, I'm thinking about computers".

The hallmarks of a von Neumann computer are a processing unit containing an arithmetic logic unit,

data registers, an instruction register, and an instruction address register.

And finally, a memory to store both data and instructions.

Hopefully, this sounds familiar, because we actually built a von Neumann computer in episode 7.

The very first von Neumann architecture stored program computer

was constructed in 1948 by the University of Manchester, nicknamed "Baby".

And even the computer you are watching this video right now uses the same architecture.

Now electronic computer memory is great and all,

but you still have to load the programming data in to the computer before it can run.

And for this reason, punch cards were used.

Let's get to the Thought Bubble.

Well into the 1980s, almost all computers had a punch card reader.

Which could suck in a single punch card at a time and write the contents of the card into the computer's memory.

If you loaded in a stack of punch cards, the reader would load them all into memory sequentially, as a big block.

Once the programming data were in memory, the computer would be told to execute it.

Of course, even simple computer programs might have hundreds of

instructions, which meant that programs were stored as stacks of punch cards.

So if you ever have the misfortune of accidentally dropping your program on the floor,

it could take you hours, days, or even weeks to put the code back in the right order.

A common trick was to draw a diagonal line on the side of the card stack called striping,

so you'd have at least some clue how to get it back into the right order.

The largest program ever punched into punch cards was the US Air Force's sage air defense system, completed in

1955. At its peak, the product is said to have employed

20% of the world's programmers. Its main control program was stored on a whopping

62,500 punch cards, which is equivalent to roughly 5 megabytes of data.

Pretty underwhelming by today's standards.

And punch cards weren't only useful for getting data into computers, but also getting data out of them.

At the end of a program, results could be written out of computer memory and onto punch cards by, well, punching cards.

Then this data could be analyzed by humans or loaded into a second program for additional computation.

Thanks, Thought Bubble.

A close cousin to punch cards was punched paper tape,

which is basically the same idea, but continuously instead of being on individual cards.

And of course, we haven't talked about hard drives, CD-Roms, DVDs, USB thumb drives, and other similar goodies.

We'll get to those more advanced types of data storage in a future episode.

Finally, in addition to plug boards and punch paper,

there was another common way to program and control computers pre-1980: panel programming.

Rather than having to physically plug in cables to activate certain functions, this could also be done with huge panels full of switches

and buttons. And there were indicator lights to display the status of various functions and values in memory.

Computers of the 50s and 60s often featured huge control consoles that look like this.

Although it was rare to input a whole program using just switches, it was possible.

And early home computers made for the hobbyist market used switches extensively, because most home users couldn't afford expensive

peripherals like punch card readers. The first commercially successful home computer was the Altair 8800, which sold in two versions:

preassembled and as a kit. The kit, which was popular with amateur computing enthusiasts, sold for the then unprecedented low price of around

$400 in 1975 or about $2,000 in 2017.

To program 8800 you'd literally toggle the switches on the front panel to enter the binary Op codes for the instruction you wanted.

Then you press the deposit button to write that value into memory.

Then in the next location in memory, you toggle the switches again for your next instruction, deposit it and so on.

When you had finally entered your whole program into memory, you would toggle the switches, move back

to memory address zero, press the run button, and watch the little lights blink. That was home computing in 1975, wow.

Whether it was plug board switches or punched paper

Programming these early computers was the realm of experts. Either professionals who did this for a living, or technology enthusiasts.

You needed intimate knowledge of the underlying hardware,

So things like processor Op codes and register wits to write programs.

This meant programming was hard and tedious. And even professional engineers and scientists struggle to take full advantage of what computing could offer.

What was needed was a simpler way to tell computers what to do; a simpler way to write programs.

And that brings us to programming languages which we'll talk about next episode. See you next week.

Crash Course Computer Science is produced in association with PBS Digital Studios.

At their channel you can check out a playlist of shows like Braincraft,

Coma Niddy and PBS Infinite Series. This episode was filmed at the Chad and Stacey Emigholz studio in Indianapolis, Indiana

And it was made with the help of all these nice people and our wonderful graphics team is Thought Cafe.

Thanks for the Random Access Memories, I''ll see you next time.