Long before computers existed, businesses used electromechanical accounting machines for data processing.
These one-ton accounting machines were "programmed" through wiring on a plugboard control panel, allowing them to generate complex business reports from records stored on punched cards.
Even though they lacked electronics and used spinning mechanical wheels to add up data, these machines could process more than two cards a second.

In honor of April 151,
I examine a plugboard that was used for tax preparation in the 1950s9 and explain the forgotten art of plugboard programming, showing how a tangle of wiring implemented a data processing algorithm.
By mounting the plugboard on an accounting machine, a particular data processing task could be performed. Although the plugboard looks like spaghetti code made physical,
tracing out the connections shows its function:
it computed deductions by summing records across multiple fields, printed a report with subtotals and totals, and punched a smaller card deck with the subtotals.

Overview of punched card data processing

Punched cards were a key part of data processing from 1890 until the 1970s, used for accounting, inventory, payroll and many other tasks. Typically, each 80-column punched card held one record, with data stored in fixed fields on the card.
The example below shows an example card with columns divided into fields such as date, vendor number, order number and amount. An accounting machine would process these cards: totaling the amounts, and generating a report with subtotals by account and department, as shown below.

Example of a punched card holding a 'unit record', and a report generated from these cards. The accounting machine can group records based on a field to produce subtotals, intermediate totals, and totals. From Manual of Operation.

Punched-card data processing was invented by Herman Hollerith for the 1890 US census, which used a simple tabulating machine that counted records indicated by holes in the cards.2
These machines steadily accumulated features, becoming complex "accounting machines" that could generate business reports.6
These machines became popular with businesses and by 1944, IBM had 10,000 tabulating and accounting machines in the field.3
In July 1948, IBM introduced the 402 Accounting Machine, which used the plugboard I'm examining.
The 402 (and the similar 4035) were feature-rich machines that had 16 counters, multiple levels of subtotals, vertical spacing control to support forms, comparisons and conditional operations,
and leading zero elimination.

IBM 403 accounting machine, with Type 82 card sorter at right.4 These machines are on display at the Computer History Museum.

The surprising thing about this history is that businesses were performing data processing with punched cards decades before the first computers,
using machinery that was entirely electro-mechanical, not even using vacuum tubes. This equipment was built from components such as wire brushes to read holes in punch cards, relays to control the circuits, and mechanical counter wheels to add values. Even though these systems were technologically primitive, they revolutionized business data processing and paved the way for electronic business computers such as the popular IBM 1401.

Plugboard programming

The accounting machines were programmed by wiring up a plugboard for a specific task.
Since each application used cards with fields in different positions, accounting machines needed a way to define each field. Different reports would be formatted with values in different locations on the page.
Applications would need to total and subtotal different values.
Before stored-program computing existed, a technique was needed to easily customize the system for a particular application. The result was wiring on control panel plugboards.

Closeup of the plugboard for an IBM 403. The accounting machine is "programmed" by plugging in wires to form connections.

The photo above shows a closeup of the plugboard. The plugboard has a grid of holes (which are called hubs), with their functions labeled.
By inserting a wire into the board, two hubs are connected, causing the accounting machine to perform a particular operation. The collection of wires specifies the operations that are performed on each card.

The back of the plugboard for an IBM 403 accounting machine.

When a wire is inserted into the plugboard, the jack on the end of the wire sticks out the back of the plugboard, as shown above.
When the plugboard is mounted in the accounting machine (below), these jacks make contact with a grid of connectors on the accounting machine, completing the desired circuits.
(Note the "setup change" switches above the plugboard; these switches will be relevant later.)

A plugboard inserted into the side of an IBM 403 at the Computer History Museum. Note the control switches above the plugboard. These can be used to change what the plugboard does.

Since the plugboard is removable, companies could easily switch plugboards to perform different tasks.
(Rewiring a plugboard for each function would be much too time-consuming.)
As a consequence, companies might have shelves full of plugboards for all the operations they performed; with plugboards, the "software" takes up considerable physical space.
The photo below shows one company's collection of plugboards to perform different tasks.

Shelves full of plugboards for the IBM 402, courtesy of IBM 1401 restoration team.

The tax program

I closely examined the wiring of the tax plugboard to determine what it does.
The first step was to trace out each wire to draw a schematic wiring diagram (below)
that shows all the connections on the plugboard.
If you compare the diagram with the plugboard photo at the start of the article, you can see that
it shows the same wiring, but in a much easier to follow format.

A wiring diagram for an IBM 403 plugboard to compute tax deductions. (Click for full size.)

I found that the program wired into the board reads cards and computes subtotals and totals from the cards.
In more detail, each card has seven fields that are read. The first field is an identifier, and all cards with the same identifier are totaled together to give totals for each of five fields.
My hypothesis is that this field is an employee id, and each card corresponds to one pay period.7
Summing the records for each employee id gives the employee's total deductions (or year-to-date deductions).
The totaled five fields could be payroll deductions such as federal income tax, state tax, social security tax, Medicare tax and retirement contributions.
After reading the cards for an employee, the accounting machine punches a new summary card with the employee's total deductions prints a line on the report.
The per-employee totals are then summed together to give overall totals at the end.

Here's how the plugboard works, step by step.
When an 80-column card is read, each digit is available in one of the reading hubs, labeled 1 through 80. By putting a wire in a hub, the digit is transmitted to another part of the machine.
For instance, suppose there is a 6-digit number punched into columns 28 to 33 of the card and we want to total these numbers. This is done by connecting a wire from reading column 28 to the upper digit of the counter, a wire from column 29 to the second digit of the counter, and so forth, for 6 wires in total.

The wires transferring the field to counter 6C are the six red wires in the photo below. The 80 card columns are available in the two rows of hubs below the label "Third reading". The inputs to the counters are the four rows of hubs below the "Counter entry" labels. Other fields are wired to counters similarly.

The six red wires connect six columns read from the card (right) to the entry of counter 6C (left).

Trying to figure out the wiring from the photo is difficult, so plugboard wiring is typically indicated in a diagram. The diagram below shows the wiring between the columns read (right) and the counter 6C (left). The six wires are compressed into one line on the diagram, using IBM's style of representing plugboards. The horizontal bars connected by a line indicate six parallel wires.

A diagram representing the connection between the card read (right) and the counter (left).

To print a total, a counter "exit" is wired to the desired printer columns.
On the plugboard, the printer columns are labeled print entries: 43 "alphamerical print entry" positions that can print alphabetical or numerical characters, followed by 45 "numerical print entry" positions that only print numbers.
The diagram below shows four wires from counter 4C to print columns 1 through 4 (yellow), and six wires from counter 6C (red) to print columns 35 through 40.

Wiring a counter to a "print exit" causes the counter value to be printed.

The accounting machine contains 16 decimal counters in all. Four of them are 8-digit counters, named 8A, 8B, 8C and 8D. Four are 6-digit counters (6A to 6D), four are 4-digit counters (4A to 4D), and four are 2-digit counters (2A to 2D). In addition, two counters can be joined together to form a larger counter.
There are also connections between counters for subtotals. For instance, counter 8A accumulates a per-employee subtotal. These subtotals are added to counter 8B to form the final total.

Another important operation is to compare two cards to see if they have the same id (and should be counted together) or if they have different ids (so a subtotal should be printed and the counters reset).
A comparison is done by wiring two fields to the two "comparing entry" rows. If the fields are different, the "comparing exit" will trigger a signal. Since we want to compare each card with the next card, we get one field from the "second reading" and one from the "third reading"; the card we are processing will be at the third reading stage while the card behind it will be at the second reading stage.
Finally, the comparison output is wired to the "program start (minor)" hub. This causes the accounting machine to start an additional cycle to print the subtotals (i.e. minor totals) and reset the counters. (There are also "intermediate" and "major" program start hubs, which provide two additional levels of totals.)

Columns 1-4 of the cards are compared to determine if subtotals should be printed.

On the diagram above, columns 1-4 from the second reading and from the third reading are wired to the comparing entry hubs. The four corresponding comparing exit hubs are wired together (gray) and connected to the minor (MI) program start hub (yellow wire to PRG START in upper right).
The closeup of the plugboard below shows the wiring on the plugboard.

Columns 1-4 of the cards are compared to determine if subtotals should be printed.

Another interesting feature of the plugboard is conditional behavior, using "selectors".
Connections can be switched based on a different signal, allowing behavior to change based on a comparison, or a panel switch.
This plugboard changes behavior based on the "setup change 1" panel switch, one of the switches on the accounting machine above the panel.
(You can think of this as the plugboard version of command-line options.)
According to the label on the plugboard (below), this switch selects "year to date". On the board, this switch enables processing of one field, as well as switching between the constant 2 and 5 for addition to counter 2B. (The reason for this constant is a mystery to me.)

The label on the plugboard shows it computes tax deductions.9 "S/P" is presumably "summary punch". The setup 1 switch selects "year to date".

The wiring on the right side of the plugboard controls the counter behavior, such as accumulating subtotals versus final totals. It also wires some of the counters together to form larger counters. For instance, counters 2C and 4D are combined to form a single 6-digit counter. 8
I won't explain the counter control wiring here; the manuals15 explain how it works.

"Summary punching" is another interesting feature of the accounting machine.
This lets you take a large file of cards and punch a smaller summary file.
For the tax plugboard, one summary card is punched for each employee, with the totals for that employee. Thus, a card file with one record for each employee's pay period is reduced to a much smaller file with one card for the employee's yearly totals. This smaller card file can then be used for further processing.

Summary punching is accomplished by connecting a summary punch machine (above right) to the accounting machine (left) through a thick cable. A hub on the plugboard is wired to enable summary punching, and another hub is wired to control when to punch a card. For the tax plugboard, a summary card is punched for each minor total with the wiring below.
A separate plugboard on the summary punch machine controlled which columns were punched on the summary card.

Summary punch wiring on the IBM 403 plugboard. The summary punch control pickup (SP Control PU on the left) is wired to punch a summary card on a minor total. The summary punch switch (SP.SW) hubs are connected by the gray wire (lower left).

Inside the 403 Accounting Machine

Its amazing how much functionality these accounting machines could provide without the benefit of electronics, purely through clever electromechanical systems.
Inside the accounting machine is a maze of motors, rotating shafts, cams and clutches, making it seem more like a car than a computer—it even contained an oil pump!
With all these mechanical parts a 403 accounting machine weighed over a ton (2515 pounds / 1143 kg).

On the plugboard, a wire is used to route a column of the card. How does a character on the card get sent across this wire? How does a counter perform addition? And how does the result get printed? The accounting machines use clever mechanisms, closely tied to the structure of a punched card, to perform these operations.

In modern terms, a character is encoded serially over a wire, by a single pulse whose timing depends on the position of the hole. These pulses start and stop the counters used to add values. These pulses also control the timing of the typebars that print the result. How these pulses are generated and how they electromechanically control the system will be described more below.

The 403's timing is based off the rotating shafts that drive the machine, rather than clock time.
Each revolution of the shaft corresponds to a "card cycle", the reading and processing of one card.
The fundamental timing unit is a rotation of 18°: this is the time between reading successive card holes, moving a typebar by one character, and rotation of a counter by one count. At 150 cards per minute, these values work out to approximately 400 milliseconds per card and 20 milliseconds per 18° step, remarkably fast for mechanical operations.

Reading cards

To understand the accounting machine, one must first understand how punched cards hold data.
Punched cards hold 80 characters of data; each character is represented by the hole pattern in a column.
The card below shows how numbers and the alphabet are punched; each character is printed at the top of the card with the corresponding punches in the column below.
A digit is simply represented by a hole in the corresponding row, 0 through 9.
(Note that numbers are stored in decimal, not binary.)
To support alphanumeric data, two "zone" rows were added above the digit rows.10
A letter is represented by putting two holes in a column: a zone punch and a digit punch.11

An 80-column IBM punched card. Each column encodes a character (printed at top) by punching holes in the column. For a digit, a hole is punched in the row with the same number. A letter is encoded by adding a "zone punch" in one of the top three rows.

You might expect the accounting machine to read cards a column at a time, so one character gets processed at a time.
But instead, cards are read "sideways", starting at the bottom.
All 80 columns are read in parallel, one row at a time, starting with row 9 and ending with row 0 and then the zone rows.
The accounting machine uses sets of 80 wire brushes to read a card, one for each column. If there is a hole, the brush makes contact with the energized metal roller underneath the card, completing a circuit and generating a pulse.
Thus, each column will have a pulse corresponding to its hole, with the 9 pulse first, followed by 8 and so forth, ending with 0. Thus, each character is encoded serially, and each plugboard wire carries one of these serial signals, but all columns are processed in parallel.

Printing

Typebars in an IBM 402 accounting machine. Courtesy Columbia University Computing History.

The accounting machine's printing mechanism consists of 88 typebars;12 each vertical bar holds all the characters that can be printed. The typebars move vertically to line up the proper characters and then hammers13 hit the typebars into an inked ribbon to print the selected characters. Thus, the characters in a line of text are printed simultaneously.

The wires in the plugboard control what gets printed by stopping each rising typebar at the right time to select the desired character.
The motion of the typebars is carefully timed to match the reading of a card, so the "3" row (for instance) of a card is read at the same time that the "3" on the typebar moves into position.
If the brush's hub is wired to a column's print hub, this signal energizes a print magnet, releasing a "stop pawl" which meshes with a tooth on the typebar, stopping it with the "3" character in position to print.
If a "2" is read instead, the brush reads the hole one time unit later; the typebar will have risen one more position, causing a "2" to be printed.

The printing mechanism consists of a complex arrangement of mechanical parts: cams, pawls, slides, springs and clutches, in combination with electromagnets to activate these parts at the right time.
The mechanism can print 100 lines per minute, so the parts are flying around rapidly and require exact timing.
The typebars move one position for every 18° rotation of the driveshaft, keeping them synchronized with card reading.

Counters

The heart of the accounting machine is the electromechanical counters that sum the values. Each digit in a counter is represented by a wheel that rotates to perform addition. The position of the wheel indicates the digit.
For instance, to add 27 to a counter, the tens digit wheel is rotated two positions and the unit wheel is rotated seven positions. Thus, to add the value in a card field, the wheels must rotate an amount corresponding to the number punched in the card.
The wheel starts rotating when a hole is read, rotates one position as each additional row is read, and stops reading at row 0. Since row 9 is read first and row 0 is last, the result is the counter rotates
the number of positions indicated by the hole.

An electromechanical counter from the IBM 403 accounting machine performs addition on two digits by rotating the counter wheels.

The photo above shows a two-digit counter unit. The counter wheels are at the left.
The start and stop coils cause the counter to start and stop rotating at the correct times by activating lever arms that control a clutch under the wheel.
Carry is implemented by cams underneath the wheel that close electrical contacts.
On the back of the board are the electrical contacts that read out the value stored in the counter; these are wired to the connector on the right.

Diagram of the electromechanical counter, indicating the key components. From the IBM 403 Field Manual.

The plugboard specifies which card columns are added to which counter digits.
To add a field's value to a counter, a column's read brush is wired to the counter through the plugboard, so the card controls how much the counter rotates.
This signal activates the counter's start coil, engaging the counter's clutch and starting the counter's rotation.
At the 0 position, the stop coil disengages the clutch, stopping the counter.
For instance, if the brush read a 7 from the card, the counter will rotate through seven positions before stopping, adding 7 to its value.
If the brush read a 1, the counter will rotate by just one position.
The reason this works is the synchronization between card movement and counter rotation; an 18° rotation corresponds to the card moving by one row as well as one count on the counter wheel.
(A counter wheel has 20 positions spaced 18° apart. Counting by 10 rotates the wheel halfway.) Subtraction is performed by adding the complement.14

A carry from one position to the next is handled by a complex mechanism. You might expect that when one wheel rolls over from 9 to 0, it increments the higher wheel like an odometer, but that would be slow for multi-digit counters.
(Keep in mind that the counters can add 150 numbers per minute, so they are spinning rapidly.)
Instead, the counters use a mechanism similar to carry lookahead. If a wheel is at 9, an electrical contact closes, allowing a lower-order carry to be passed through to the higher wheel. If a wheel passes from 9 to 0, it closes a different electrical contact, generating a carry. After the "regular" addition, any necessary carries are generated in parallel and added in a single time step. Thus, something like 99999999+1 isn't delayed by a ripple carry; instead all digits get a carry in parallel.

Relays

The accounting machine is controlled by hundreds of relays, electromechanical switches that provide all the "control logic" for the system. The photo below shows the back of the accounting machine, filled with relays; more relays are on the end panel.
To generate timing signals signals for the relays, switches were opened and closed by cams attached to the rotating shaft. Thus, everything in the system is timed from the rotating shaft.

The IBM 403 accounting machine is controlled by hundreds of relays, many of which are mounted in the back of the machine. Photo from the Field Engineering Manual, fig 81.

Conclusions

Punched card data processing is almost forgotten now, but it ruled data processing for almost a century.
Even before computers existed, businesses used punched cards and tabulators for accounting.
IBM's accounting machines were able to perform surprisingly complex tasks even though they were built from electromechanical components that seem primitive today.
Accounting machines and plugboard programming remained popular into the 1960s,
when businesses gradually switched to stored-program business computers such as the IBM 1401.
Even so, IBM continued marketing accounting machines until 1976.
Incredibly, one company in Texas still uses an IBM 402 accounting machine for their accounting today (details), illustrating the amazing longevity of punched card technology.

I announce my latest blog posts on Twitter, so follow me at kenshirriff. I also have an RSS feed.

Notes and references

April 15 is traditionally tax day in the US, but if you don't have your taxes done yet, don't panic. In 2017, US tax day is April 18 due to the weekend and holiday. ↩

To support addition, tabulators used a module called an "accumulator" with rotating dials to hold decimal numbers. This accumulator gave its name to the accumulator register still used in microprocessors today.
For example, Intel's x86 processors have a register called EAX, the EXtended Accumulator. ↩

Another part of the unit record system is the card sorter, which rapidly sorts cards on a field, putting them in the proper order to be processed by an accounting machine. I discuss IBM card sorters in detail here. ↩

The 402 and 403 accounting machines were essentially the same except the 403 could print three-line addresses. In order to print three lines from one card, the 403 has three card reading stations instead of two. (That is, it read each card three times using three sets of 80 brushes). This feature is called MLP (multi-line printing) and is useful for printing addresses on invoices, for instance. An MLP card is indicated with a special punch: 8, 9 and (1, 2, 3 or 4) punched in a single column; the last digit controls the number of lines printed. ↩

I wouldn't be surprised if these accounting machines were technically Turing-complete due to their support for conditional operations, although it's unclear how to represent the tape. Perhaps storage could be implemented by punching a new deck of cards on each cycle through the machine. Of course this would be impractical for any real use. ↩

I suspect each card represents one employee pay stub and each field indicates a payroll deduction.
However, there are alternative explanations for the plugboard.
For instance, the id field could indicate a company division, and each card represents a subdivision. In this case, the accounting machine could be totaling the tax deductions for each division such as business expenses and depreciation.
Or each card could represent one month. Since there are no variable names, it is speculation. ↩

The table below summarizes the program implemented by the plugboard, showing the mapping between input fields on the card and output fields on the printer.

Card columns

Output columns

Subtotal counter

Total counter

1-4

1-4

4C

34-38

5-10

8D

4A/2D

44-45

11-18

8A

8B

61-66

19-26

6A

2C/4D

67-71

27-32

6B

2A/4B

28-33

35-40

6C

8C

14-17

4D

from switch

2B

Columns 14-17 are summed but not printed. Presumably they are punched on the summary punch card.
Columns 34-38 are only processed if the "setup change 1" switch is active.
Counter 2B is controlled by the panel switch, adding either 2 or 5 each step. I can't figure out a reason for this; I assume the plugboard on the summary punch (which I don't have) does something useful with this value. ↩

The tax plugboard I'm examining was labeled with embossing tape which dates the labeling of the board to post 1958.
The board could originally be older, or it could have been used into the 1960s. ↩

The row above "0" is called 11 or X, while the row above that is 12. For alphabetical characters, the "0" row is used as a zone instead of a digit.
(This causes some complications in the accounting machine, such as a special mechanism to print a "numeric zero" versus a "zone zero".) ↩

This punch card code evolved into EBCDIC (Extended Binary Coded Decimal Interchange Code), the encoding used by IBM computers in place of ASCII. Many of the strange characteristic of EBCDIC, such as the alphabet not being entirely sequential, are due to its roots in punched cards. ↩

The accounting machine has typebars on the left that print alphanumerics and typebars on the right that just print digits. For alphanumeric printing, the digit signal moves the typebar in steps of four, while the zone signal moves the typebar 0 through 3 steps. Thus, an alphanumeric character can be printed. Typebars with special characters could also be installed, to print $, @, - or %. ↩

You might expect that to print each line, all the hammers hit the typebars, but it's more complex than that.
First, each hammer has a mechanical "hammerlock" control, which can enable the hammer, disable the hammer, or put the hammerlocked hammers under program control. Thus, part of the line may be printed or suppressed based on the data.
In addition, the hammers also have mechanical "hammersplit" levers which when raised cause leading zeros in a field to be suppressed. This allows the value "000123" to be printed as " 123" for instance. ↩

Subtraction uses 9's complement addition. That is, subtracting a digit n is done by adding 9-n. This is accomplished mechanically by starting the counter's rotation at position 9 and stopping when a hole is read. For example, if the hole is at position 7, the counter will increment by two positions.
There are a few complications with 9's-complement subtraction. The answer is off by one, but an "end-around carry" adds 1 to yield the correct result.
Negative numbers require special handling to be printed properly using the "net balance method" or the "balance selection" method; see the 403 manual if you care about the details.
The numeric typebars include a "CR" symbol, which indicates negative numbers as a "credit".
On a punch card, negative numbers are typically indicated with an X-punch (i.e. a zone punch in row 11) over the value. ↩

11 comments:

I have a story about the 402. I applied for a job at IBM in San Francisco in the middle 1960s. I had no particular skills for this, other than having spent a couple of boring years at Pac Bell working on switching equipment. Somehow I was routed to the branch office CE manager for an interview, and after chatting for a while, he handed me a 402 counter plate like the one you show above, with the two identical counter wheels and all the latches and pawls and coils. He said, "The one on this side works correctly, the one on the other side has something wrong with it, can you tell me what?"

I had never seen one of these before of course but I sat there across the desk from him and fiddled with them for probably 4-5 minutes and spotted that one small part was missing -- in memory it was a roller, it might have been that cam-follower roller at the 2 o'clock position off the bigger wheel. He says, "that's right, here's the part and a circlip, can you fix it?" and that was easy, so I did.

So I was hired and sent off to Poughkeepsie to learn unit record equipment maintenance.

My wife has an even more relevant yarn from that era. She was an IBM systems engineer supporting unit record customers in the 60s and she got called out one New Year's Eve because the customer had belatedly realized that in the next year the FICA had to be calculated to three decimal places not two. So she says she spent hours deep in the wiring of the payroll board for a 403 trying to figure out how to get one more decimal digit to print. About 3am the janitor comes through emptying wastebaskets and was surprised to find a woman alone in the building messing with the business equipment. But she told him what she was doing and he said, "Oh, well, I guess they had woman riveters in the war, so it's OK" and wandered off.

To read this blog is to go back 50+ years to my days as a CE. As I starting reading I thought of the 'insides' of that machine and how as a CE in my dark suite and white shirt & tie we would dive into the internals. The inside could be very dirty and oily ( note the mention of the 'oil pump' in the machine. There was a whole system of small copper tubing that were the oil lines for the moving parts. It took a very heavy duty motor to drive that 2 speed clutch and all the different moving parts. Looking at the machine now makes me wonder 'how did we ever learn to understand and fix the thing'. But learn & fix we did as well as having to understand how to wire and 'read' customer wired boards, You needed to understand the board wiring so you could understand what the customer thought he had wired the machine to do & then if correctly wired why the machine did not perform the job as wired. Young people might look at this type of system as crude but it was not. It took a lot of knowledge, planning and detail to successfully program these machines. It required logical thinking and understand of what the machine was capable of doing. Customers were smart and developed some boards that were so thick with wires that it took a 2x deep cover to fit over the board. I truly believe that it took a higher level of programming thought to wire those machines than it does to program today's computer with it's high level languages and sub-routines. An appreciation of Unit Record unit goes a long way to understand how we got to where we are today.

That sure brings back the memories. Granted, by the time I was getting into computing these machines were being phased out. There were still a few of them flopping around in every shop, many still in use. There was a computer language called RPG, report generator, that was nearly inscrutable to any modern programmer, but made perfect sense to anyone used to programming this kind of machine. In some ways, ladder logic is a survival of this type of physically oriented programming.

In "Turing's Cathedral", the author points out that these machines were heavily used in designing the atomic bomb. In fact, the appropriate plug board logic even allowed a form of general programming. A field on each card would indicate an operation between accumulators and counters. This generality, the ability to mix program and data was a guiding force for von Neumann at the Institute for Advanced Studies were he built the first general purpose computer.

P.S. If you ever get around to it, consider the glories of card sorting machines. They were the public image of computing until tape drives came in. They were pretty amazing too. Most of SQL and relational database technology flowed from punch card technology, so in a way punch cards are still with us.

David... I joined IBM in 1971 in India. Interestingly during my interview I was also handed 402 counter plate with one of the counters defective; the roller on the cam follower was missing! Appears it was one of the standard tests during that time to test the mechanical dexterity.

Small correction: the picture directly under the heading "Inside the 403 Accounting Machine" is actually a picture of a 402, because it has alphanumeric typebars on only the left half of the line. The 403 had alpha all the way across.

I learned the basics of 402 programming in High School, as I wanted a chance to work with these dinosaurs. They had a 402, a summary/reproducing punch, a collator,an 082 sorter and an 026 keypunch. Used to run the attendance for all the town schools (about 15 of them) and also to teach with. I worked part time running the attendance.

A couple of stories:The machines were rented. IBM owned them and charged us depending on how much we used them. We had a 402, because it was cheaper to rent than the faster, full alpha 403. But the guy who ran the unit record room showed me a trick: if you opened the back of the machine, there was a wall of relays. Pull out the right one, and the machine ran twice as fast. IBM lost money when you did this, because you got the speed of a 403, while paying for a 402. They didn't do it too often, but "turbo mode" was nice to have when there was any kind of time crunch.

The next year, the machines were gone and we got an 1130 computer to replace them (along with an 083 sorter and an 029 keypunch. All nice and shiny. The 1132 printer was based on the printing mechanism of a 407 accounting machine. Cheap...and slow.