Course Capstones

This is Unit Twelve of Computer Science, and it is unlike every unit before it. There is nothing new here. No definitions, no mechanisms, no procedures. Every entry in this unit is a capstone, and every capstone reaches back across the whole course rather than closing a block of its own. The first takes the most ordinary complaint anybody has about software — this is slow — and shows that the question has a real answer on every single level the course covered, from the algorithm to the memory hierarchy to the network. Two of them are about how the course thinks rather than what it said. One gathers every trade the course made and shows they share one grammar. Another argues that eleven units leaned on a single idea in eleven costumes. One is a gallery of every error the course marked, and it finds a shape they all share — each is a true thing stretched one step too far. And two of them close threads: the transit app that has run since Unit One, and the question the course opened by refusing to answer. By the end you will be able to do five things. One: diagnose a slow application by layer. Two: state a trade in the course's grammar. Three: recognise abstraction as the same move everywhere. Four: say what shape the course's errors share. Five: answer what computer science is.

One capstone, and it starts from a complaint rather than a concept. Somebody says an application is slow. That sentence has a candidate answer in the algorithm, in the data structure, in the memory hierarchy, in the database, in the network, and in how the thing was deployed — and knowing which layer to look at first is what the course was for.

The most ordinary complaint there is.

CS 0671 One Slow App, Every Layer

The question has a floor on every level of the course, and diagnosing it top to bottom is the whole curriculum working as one instrument rather than as eleven separate subjects.

One capstone, and it makes an argument about the discipline itself. Nearly every decision this course described was a trade — time against space, performance against productivity, normalising against querying speed, guarantees against processing cost. Gathered in one place, they share a single grammar.

Every trade, in one place.

CS 0675 The Tradeoff Ledger

Computer science run end to end is trade management, and the course's recurring decisions share one grammar — name both sides, price both sides, and choose on purpose rather than by default.

One capstone, and it is the deepest thing in the course. Every unit made the same move — hide the machinery, expose the contract. The operating system did it to hardware. The language did it to machine code. The type did it to bits. Eleven costumes, one idea underneath.

The move every unit made.

CS 0680 Abstraction, the Course's One Idea

Every unit leaned on the same move, and seeing abstraction as one idea wearing eleven costumes is the deepest version of the whole curriculum — the thing that makes the units a subject rather than a list.

One capstone, and it does something the individual error entries could not. Each of those corrected one belief in isolation. Walked together, the whole gallery reveals that they fail the same way — every one of them is something true, carried one step past where it stops being true.

Every error, in one gallery.

CS 0685 The Misconception Museum

The course kept a museum of canonical errors, each numbered beside its correct twin — and walking the whole gallery at once shows they share a shape: a true thing, stretched one step too far.

One capstone, and it closes the longest thread in the course. The transit app was experienced in Unit One, analysed, built in Unit Nine, deployed in Unit Ten, and defended in Unit Eleven. Its final pass runs a rider's half-second through all of it at once.

The app, one last time.

CS 0690 The App, Complete

One transit app has carried the course from its first unit to its last, and its final pass runs the rider's half-second through every layer simultaneously rather than one at a time.

One capstone, and it answers the question the course opened by setting aside. Unit One separated computer science from programming and declined to say what the subject actually is. This entry answers it — and the answer is only available now, because the evidence is the eleven units behind it.

The question, finally answered.

CS 0695 What Computer Science Is, Answered

The course opened by separating computer science from programming, and closes by answering the larger question with the whole curriculum as evidence — the study of computation across every layer where computation lives.

Five things you can now do, and Computer Science is complete. You can diagnose a slow application by layer — algorithm, structure, memory, database, network, deployment — and know which floor to check first. You can state a trade in the course's grammar: name both sides, price both sides, and choose on purpose rather than by default. You can recognise abstraction as the single move underneath every unit — hide the machinery, expose the contract — and name where each unit made it. You can say what shape the course's canonical errors share: each one is something true, carried one step past where it stops holding. And you can answer what computer science is, with eleven units as the evidence rather than with a definition offered on trust.