The same problem,
ninety years apart

There is no source listing for this exhibit because there is no source. The behaviour of the machine is the set of wires in the panel, and to change the report you unplug a cord and plug it somewhere else. A 407 program was a physical object you carried to the machine room in a frame.

The whole report hangs on one cord: COMPARING EXIT UNEQUAL to PROGRAM START. The 407 compares each card’s department field against the one before it, and when they differ it fires a control break — take the counter’s accumulated total, print it, clear the counter, resume.

That comparison only works because the deck arrived sorted, and the sort is not part of the program at all. It happened on a different machine, in a different room, possibly on a different day. The precondition lives in the world rather than in the code, which is the single most alien thing about this exhibit.

Everything the 407 did structurally, FORTRAN makes you say. The comparison, the print, the reset, the resume — four cords become nine statements, and the statement numbers are the only thing holding them together.

IF (KODE - LAST) 30, 35, 30 is the arithmetic IF: evaluate the expression, then branch to one of three labels depending on whether it came out negative, zero or positive. It is a three-way GOTO, and it was the primary conditional in the language.

Note that the department is an integer code rather than a name. FORTRAN II had no character type; text existed only as Hollerith constants inside FORMAT statements, which is why the literal 11HGRAND TOTAL has to carry its own length as a prefix. The data had to be numbered before it could be processed, and somebody in the building kept the codebook.

And there at the bottom: the duplicated PRINT 200 after the loop. The last department has no successor to differ from, so its total never breaks. Every control-break program written between 1957 and roughly 1985 contains this same small act of remembering, and the ones that forgot silently dropped a department.

The control break is identical to FORTRAN’s — same comparison, same reset, same forgotten-final-group trap. What COBOL adds is somewhere to put the layout.

PIC ZZZ,ZZ9.99 is an edited picture, and it is the most underrated idea in the language: it declares that this field, when something is moved into it, will suppress leading zeros, insert a comma at the thousands and fix two decimals. The formatting is a property of the destination, not an act of the code. Modern printf is a step backwards from this.

COBOL is mocked for its verbosity, but look at what the verbosity buys. A person who does payroll and not programming can read ADD PC-AMOUNT TO WS-DEPT-TOTAL and audit it. That was the explicit design goal, and by that measure it worked for sixty years.

Look for the loop. There is not one. RPG has a fixed program cycle built into the runtime: read a card, set indicators, do total-time output, run the calculation specs, do detail output, repeat until the hopper is empty. You do not write it and you cannot change it.

The two characters L1 in columns 59–60 of the input spec declare that DEPT is a control field at level one. From that single annotation the cycle derives everything — it saves the previous value, compares on every card, sets the L1 indicator when it changes, and runs total-time output before the new card’s detail processing. The control break has become a declaration again, twenty-nine years after the 407.

LR is last-record, set automatically at end of file, which means RPG cannot have FORTRAN’s dropped-final-group bug: the last break is not something a programmer is able to forget.

The price is total. Your program has one shape, and programs that do not fit the cycle get written by fighting it; generations of RPG programmers have the scars. But for this problem — and this problem was most of commercial computing in 1964 — six lines do the work of COBOL’s forty.

The entire report is one line, and it contains no loop, no accumulator, no comparison against a previous value, and no dependence whatsoever on the order of the deck.

U ∘.≡ DEPT is an outer product: take every department name against every card’s department and produce a matrix of ones and zeros. That matrix is the grouping — row two is a mask selecting the payroll cards. Watch it build in the panel below.

Then +.×, the inner product, multiplies that matrix by the amount vector: exactly matrix multiplication, which means each row contributes an amount only where its mask is one. Grouping and summing turn out to be the same operation as linear algebra, and once you have seen that you cannot unsee it.

This is a different claim from every exhibit above it. FORTRAN and COBOL and RPG all agree that a program is a sequence of things happening to one card at a time. APL says the whole deck is a single value, and the program is a function of it.

This one genuinely executes. The panel below is a small token-threaded Forth running that exact source a word at a time, so you can watch the data stack fill and drain. Amounts are integer cents, because Forth of this era had no floating point and did not miss it.

There are no parameters and no local variables anywhere. RECORD receives its arguments because CARD left them on the stack, and it juggles them with SWAP and DUP. This is either liberating or appalling depending on the hour of the day.

The real idea is the colon. Every definition adds a word to the dictionary, and from that moment it is indistinguishable from a built-in — BREAK is now part of the language. You do not write a program in Forth so much as grow a language down towards the problem, which is why the top-level word is three lines long.

The control break is back to being hand-written, as it was in FORTRAN. But notice where it lives now: it is a named thing, defined once, and the last line reads almost like the RPG spec sheet two exhibits up.

Nothing here describes a procedure. total(Dept, Total) is a claim about when two things stand in a relation, and the report is produced by asking for every pair that satisfies it. The engine does the searching.

findall(A, pay(_, Dept, A), Amounts) reads: collect every A such that somebody in this department was paid it. The underscore is an anonymous variable — the name is irrelevant to the question, so it does not get one.

Deck order is meaningless here, as it was for APL, but for a different reason. APL made order irrelevant by treating the deck as one value; Prolog makes it irrelevant by treating it as an unordered set of assertions. Both had to abandon the card feed to get there.

And the same program answers questions it was never written for. ?- total(shipping, T). asks about one department. ?- pay(N, D, A), A > 12000. asks who earns most. There is no main. There is a database of truths, and whatever you care to ask of it.

Four lines, and every one of them is a cord from the first exhibit. ORDER BY is the 082 sorter. GROUP BY is the comparing exit. SUM is counter 4A. The reset is so thoroughly implied that the language has no word for it.

This is the hinge of the whole page. Thirty-nine years after the accounting machine, and after four exhibits of programmers writing the sort and the break and the reset out by hand, somebody wrote the four ideas down as names and the problem stopped being a program.

What changed underneath is the interesting part. The 407 could only do this because a human had already sorted the deck; the query planner decides for itself whether to sort-and-break or build a hash table, and on a large enough table it picks the plugboard’s strategy for the plugboard’s reasons. Sorting in order to group never stopped being the right answer — it stopped being the programmer’s problem.

Codd’s claim in 1970 was that data has a structure independent of how any particular program wants to walk it. Nothing on this page before this exhibit believed that. Everything after it assumes it.

Two rules. The first has no condition, so it runs on every line; the second runs at end of input. There is no loop in the source because awk supplies one — read a record, split it into fields, test each pattern, run the actions that match, repeat. Exactly as RPG did it in 1964.

total[$2] += $3 creates the bucket on first touch. Associative arrays were not a common language feature in 1977, and they are what let the grouping be one character of syntax instead of a data structure you have to build.

Compare this with the RPG spec sheet three exhibits up. Both declare per-record behaviour and let the runtime own the sequence; both have an automatic end-of-input hook, called END here and LR there. Two entirely separate traditions independently rediscovered the accounting machine’s shape, one in commercial data processing and one inside a research phone company.

And unlike every card-era exhibit, the deck order is irrelevant — because the hash table remembers what the control break had to be told.

You do not compile this. You select it inside a running image, press do it, and it happens to objects that were already alive — and that stay alive afterwards. The deck is not read from a file at the start of a run, because there is no start of a run.

[:acc :card | … ] is a block: an object that holds code, which you hand to the collection so that it can call you back. Every conditional and every loop in the language is built from this and nothing else. ifTrue: is a message sent to a boolean with a block as its argument, and that is not a metaphor or a teaching simplification.

The last stanza is the Smalltalk move. groupedBy: is not a language feature — it is a method somebody added to Collection one afternoon, inside the image, while the system was running, and from then on it was as native as anything Xerox shipped. This is the same instinct as Forth’s dictionary, ten years later and a great deal larger.

The consequence nobody expects: an image can be saved with your half-finished work still on the stack, mailed to a colleague, and resumed mid-thought on their machine. The program and its execution are the same artefact.

One line does the work. It is a good line, it is the right line, and almost nobody who writes it could tell you what happens inside.

What happens inside is a hash aggregate — and if the frame is large enough, or the operation spills to disk, what happens inside is a sort followed by a control break, because that is still, in 2026, the correct algorithm when the groups do not fit in memory. The 407 was not doing a primitive version of this. It was doing this.

Look at colspecs=[(0,10),(10,18),(18,24)]. Those are the punched card’s column boundaries, and the function is called read_fwf — read fixed width formatted. Ninety years on, the deck is still a supported input format, and the columns have not moved.

This is not a lament. Layers that hide their machinery are how anything large gets built, and nobody should have to wire a panel to add up a column of numbers. But it is worth knowing that the thing being hidden is not complexity for its own sake. It is a sorter, a comparator and a counter, and somebody wired them together before the war.