What Computer Science Is

This is Unit One of Computer Science. The unit's job is to establish what the field actually covers, and the capstone states the reason it holds together: the parts answer one another. Algorithms need machines, machines need programs, and programs run among people. Two error entries in the first four, and both correct a shrinking. Equating the field with programming reduces it to one tool. And assuming algorithms require computers gets the history backwards — the idea is thousands of years older than the electronics, and people were programming machines a century before there was anything electronic to program. The unit also introduces something the course returns to repeatedly. Some problems resist computing entirely, and naming a limit is treated here as a finding rather than a failure — which is the opposite of how limits usually get reported. By the end you will be able to do five things. One: say what the field studies, and where programming sits inside it. Two: say why an algorithm needs no computer. Three: say what separates an old general-purpose machine from a new one. Four: say why a spreadsheet is a programming environment, and where it stops. Five: say why calling a system neutral is a design claim.

Two entries, and the second is an error entry placed second on purpose. The equation it corrects would shrink everything the course goes on to cover, so it gets dealt with before anything is built on it.

The field.

CS 0001 Computer Science

The study of computing — the algorithms, the machines that run them, and the people who design them and live with them. Wider than any single device or application.

And the equation.

CS 0002 "Computer Science Is Programming"

Treating the field as programming mistakes one tool for the discipline, which also studies machines, theory, and consequences. The equation shrinks every later chapter before it opens.

Five entries on the field's central object. What it is, what it does not require, how far back it goes — and one worked procedure with a condition that has to hold before it works at all.

The object.

CS 0003 The Algorithm

A sequence of precise instructions taking an input, running a finite number of steps, and producing an output. A vague step disqualifies the whole thing — precision is the entry fee.

What it does not need.

CS 0004 "Algorithms Need Computers"

No computer is required — any precise, finite, repeatable procedure qualifies, whatever performs it. Machines made algorithms fast; the idea never depended on one.

How far back.

CS 0005 Computing Before Electronics

Computing devices predate electricity by millennia — tallying on an abacus in antiquity, and mechanical engines automating calculation long before current flowed.

One algorithm, worked.

CS 0006 Halving the Haystack: Binary Search

Locating a value by halving the interval and discarding the half that cannot contain it. The list has to be sorted first — halving an unsorted pile throws away halves that might have held the answer.

The first programmer.

CS 0007 The First Programmer

Ada Lovelace wrote punched-card sequencing instructions for Babbage's engine — programming a machine roughly a century before anything electronic existed to program.

Six entries on the hardware side, and the one worth pausing on is a storage decision. Keeping programs in memory alongside the data they work on is what makes a computer reprogrammable — without it, machines would do one thing each.

The four parts.

CS 0008 The Four Parts of Hardware

The physical material divides into four components. One sentence each here — every one of them gets a unit of its own later in the course.

The network.

CS 0009 The Internet

Interconnected nodes — hosts at the edges, routers in the middle, numeric addresses naming them. It is one network of networks, and the Web is a layer arriving on top of it later.

The other side.

CS 0010 Software and the Program

Software is the algorithmic side, and a program is an algorithm written so a machine can run it. Hardware with no software computes nothing at all.

The storage decision.

CS 0011 Programs Are Stored Like Data

Programs live in memory alongside the data they operate on, so improving a program means changing stored instructions. That choice is what makes computers reprogrammable.

What follows from it.

CS 0012 The General-Purpose Computer

A general-purpose machine runs whatever program is specified rather than one fixed task — which is the property separating computers from single-purpose devices.

And the error.

CS 0013 "Old Computers Couldn't Compute It"

Speed separates old general-purpose machines from new ones and computability does not — a problem computable today was computable on the earlier ones, given time. Faster never became able to compute new kinds of thing.

Two entries on the theoretical side, and the striking one is about limits. Some problems resist computing and human judgment alike — and the course treats naming such a limit as a result rather than an admission.

Three questions.

CS 0015 Theoretical Computer Science

Of any problem: can a computer compute it at all, by what algorithm, and how efficiently. The first question sometimes answers no, which is itself informative.

What resists.

CS 0017 What Resists Computing

Some problems sit beyond both computing and human judgment — accurately predicting chaotic systems over long horizons among them. Naming a limit is a finding rather than a failure.

Five entries on where computing meets everyone else. Access, a field built on data — and then the programming environment millions of people use daily without ever calling it programming.

Access.

CS 0019 The Digital Divide

Uneven access to computing and connectivity across geography, income and other lines. And the divide runs through pricing as well as through infrastructure.

A field built on data.

CS 0021 Data Science

Applying computing to managing data and drawing information from it, joining analysis with knowledge of a subject. The domain knowledge is half the field rather than decoration.

The environment nobody names.

CS 0022 The Spreadsheet Is a Program

A spreadsheet is a data-centred programming environment, and millions program in one daily without calling it that. Cells accept anything, so a wrong entry passes silently — nothing is enforced.

Where it ends.

CS 0023 When Spreadsheets End

Data can outgrow the tool, in size or in detail, and purpose-built systems take over. Losing rows at a tool's limit is a real and documented failure.

And one definition, carried.

CS 0024 Machine Learning, Pointed Home

Algorithms improving from data rather than from written rules. One definition is all this course carries — the subject is taught in full elsewhere in the catalog.

Two entries the course returns to. A design shortcut that surfaced decades later at civilisational scale, and a claim about technology that the entry insists needs evidence.

The shortcut.

CS 0031 The Y2K Lesson

Storing years as two digits was sensible under the storage constraints of its time and surfaced as a society-scale problem decades afterwards. Consequences outlive the constraints that excused them.

And the claim.

CS 0033 Technology Encodes Values

A system's design can promote or discourage inequities — technology never acts alone, but always inside a social context. Calling something neutral is itself a design claim, and it needs support like any other.

One capstone closing the unit, and its argument is about the shape of the field — why these parts belong in one discipline rather than several adjacent ones.

The capstone. One field.

CS 0035 One Chapter, Whole Field

The field holds together because its parts answer each other — algorithms need machines, machines need programs, programs run among people. Every later unit deepens one piece and none replaces the picture.

Five things you can now do. You can say what the field studies — algorithms, machines, and the people around them — and why treating it as programming shrinks it to one tool. You can say why an algorithm needs no computer, and what does disqualify one: a vague step, since precision is the entry fee. You can say what separates old general-purpose machines from new ones — speed — and what does not, which is what they can compute at all. You can say why a spreadsheet is a programming environment where nothing is enforced, and that losing rows at its limit is a documented failure. And you can say why calling a system neutral is a design claim that needs support, because technology always operates inside a social context.