How information became computable

1. Central Thesis

This study examines the transition from machines that embody one procedure to systems that can receive, represent and execute many procedures.

Modern computing emerges when procedure, data and machine state become separately representable, mechanically or electronically transformable, and increasingly rewritable.

The six topics perform different operations:

• Mechanical calculators embeds restricted arithmetic procedures in mechanisms.
• Punched-card control and data entry stores instructions or records in machine-readable physical positions.
• Electromechanical tabulation turns collections of unit records into sortable and countable administrative datasets.
• Binary digital representation provides a robust two-state representational substrate for many information types.
• Electronic digital computers executes changeable sequences at electronic speed, especially once instructions enter addressable memory.
• Programming languages and compilers lets humans describe procedures in formal source languages that translators map into executable forms.

Collapsing these into one “computer revolution” would erase the architecture that made general computation possible.

2. From Written Algorithm to Mechanical Procedure

Written arithmetic preserves methods, but a person must still perform each carry, lookup and repetition. Mechanical calculators move part of that procedure into gears, drums, accumulators and carry mechanisms. The machine does not understand numbers. It constrains physical state changes so that correct operation produces a numerical result.

This is an early form of executable information. The procedure is real, repeatable and externally embodied, but usually difficult to change. Reprogramming a fixed calculator often means selecting another control, rearranging a mechanism or using the device differently. The distinction between stored method and changeable program is therefore crucial.

Babbage's designs expose the frontier. The Difference Engine mechanises a specialised tabulation method. The Analytical Engine concept separates a store, a mill and punched-card control. It belongs partly to the history of mechanical calculation and partly to the conceptual history of programmable computers.

3. Punched Media: Procedure and Data Become Portable

Punched cards and related media turn absence and presence at defined positions into machine-readable distinctions. In the Jacquard loom, cards control a sequence of textile operations. In Hollerith-style systems, cards encode attributes of people or transactions. Later computer installations use cards for program statements, data and job-control instructions.

The same physical form can therefore carry different logical roles. A card is not inherently a program or a database row. Its function depends on its code, reader, deck order and institutional procedure.

Punched media create a new portability. The machine can be reconfigured without rebuilding its mechanisms, and records can travel between entry, sorting, tabulation and storage stations. They also create fragility. A misplaced card, damaged punch, misunderstood field or obsolete code can corrupt the sequence or make the deck unreadable.

4. Tabulation: Administration Becomes Machine-Readable

Electromechanical tabulation turns the punched card into a unit-record system. Each card represents a person, account, event or object. Machines sense fields, sort records, count categories, accumulate totals and print reports.

The transformation is not merely faster arithmetic. It changes administrative visibility. Governments and businesses can classify populations, inventories and transactions at scales that would overwhelm manual ledgers. New questions become practical because machines can repeatedly regroup the same records.

That power depends on prior classification. Before the machine counts, an institution decides which categories exist, which answers fit which fields and how ambiguous lives become codes. Data processing therefore begins before the card enters the reader. The machine amplifies the schema that human administrators designed.

5. Binary: A Common Alphabet Without Automatic Meaning

Binary representation is often described as the language of computers. The phrase is convenient and misleading. Hardware distinguishes physical states. Designers interpret those states as bits. Larger conventions interpret bit patterns as numbers, characters, instructions, colours, sound samples or addresses.

Binary is valuable because two separated state regions are comparatively robust. Noise can alter a voltage without changing the interpreted bit, and regenerative circuits can restore a degraded signal to a standard state. Exact copying becomes practical across storage, processing and transmission.

Yet binary does not abolish semantics. The same bit pattern can represent several things under different schemas. A bit-perfect file may be useless when its format, character repertoire, dimensions, timing or version is unknown. Binary unifies the substrate while multiplying the need for metadata and standards.

The map therefore distinguishes:

• binary from decimal or other radices;
• digital from analogue representation;
• abstract bits from their physical realisation;
• raw bitstreams from structured information objects.

6. Electronic Computers: Speed Meets Reprogrammability

Electronic switching reduces operation time dramatically, but speed alone does not define a computer. Historical systems combine features in different ways. A useful comparison asks whether a machine is automatic, digital, binary, electronic, programmable, general-purpose and stored-program.

The Z3 demonstrates program-controlled electromechanical digital computation. Colossus demonstrates high-speed electronic processing for specialised cryptanalytic tasks. ENIAC demonstrates broad electronic numerical computation but initially relies on wiring and switches for configuration. The Manchester Baby demonstrates electronic execution of a program from memory. EDSAC and later machines turn stored-program architecture into a practical user service.

These distinctions make “the first computer” a poor standalone claim. Each candidate may be first under a different feature bundle.

Stored-program operation changes the economics of procedure. Instructions become information that can be loaded, copied, edited and selected. The same processor can become a calculator, simulator, payroll system or text processor through different programs. Hardware generality is activated by software and memory.

7. Programming Languages and Compilers: Procedure Becomes Formal Text

Machine code expresses operations in architecture-specific forms. Assembly gives symbolic names to those operations and addresses. Higher-level languages provide abstractions for formulas, records, loops, procedures and data structures.

A programming language is not its compiler. The language defines valid source forms and intended meaning. A compiler analyses the source and produces a target program, often through several intermediate representations. Different compilers can implement one language, and one compiler infrastructure can support several source or target languages.

This layer moves complexity rather than erasing it. Programmers no longer manage every register and address directly, but they depend on translators, libraries, runtimes, operating systems and standards. A source file without its toolchain can become as archaeologically mute as an undeciphered inscription.

The early compiler story is also plural. Grace Hopper's A-series systems helped establish automatic programming and reusable routines. FORTRAN demonstrated that a high-level scientific language and optimising compiler could produce code competitive with hand programming. COBOL and other languages expanded machine use into administrative domains.

8. The Six Locations of Procedure

This study reveals a useful sequence in where procedure resides:

| Location | Example | Main property | |---|---|---| | Human memory or written algorithm | Manual arithmetic | Flexible but labour-intensive execution | | Fixed mechanism | Mechanical calculator | Repeatable operation with low reconfigurability | | External control medium | Loom or computer card deck | Portable sequence control | | Wiring or plugboard | Tabulator control panel, early ENIAC | Reconfigurable but setup-heavy | | Addressable memory | Stored-program computer | Rapid loading, modification and branching | | High-level source plus translator | FORTRAN and compiler | Human-oriented abstraction and cross-machine portability |

This sequence is not pure replacement. Modern systems still contain fixed hardware logic, firmware, external configuration, stored programs and translated source layers simultaneously.

9. Speed Versus Service

The batch reinforces a distinction already visible in telecommunications: component speed is not total service latency.

An electronic computer can perform operations rapidly while users wait hours for a batch slot. A punched-card deck may take minutes to read but days to prepare and debug. A compiler may translate quickly while organisational approval, test data and output review dominate the workflow.

Historical claims should therefore record:

• operation or switching rate;
• input preparation time;
• configuration time;
• queue delay;
• execution time;
• output turnaround;
• debugging and correction cycles.

The fastest machine in the room may still inhabit a slow institution.

10. Human Labour Does Not Disappear

Each topic shifts labour:

• calculators reduce manual arithmetic but require entry, checking and maintenance;
• punched cards reduce repeated control setup but create punching, verification and deck-handling work;
• tabulators reduce counting but expand classification, coding and machine-room operations;
• electronic computers reduce execution time but require programmers, operators and engineers;
• compilers reduce machine-code labour but expand language design, optimisation, testing and toolchain maintenance.

Automation should therefore be described as labour reallocation and reskilling rather than simple removal.

11. Administrative Power

Computing foundations develop inside organisations with substantial resources: states, militaries, census offices, universities and large firms. Their problems shape which information becomes machine-readable.

Tabulation makes populations legible through categories. Electronic computation makes simulation, optimisation and surveillance faster. Programming languages make large software systems possible, but standards and vendor ecosystems can lock organisations into particular architectures.

The political question is not only who owns the machine. It is who defines the schema, selects the program, verifies the output and can challenge the result.

12. Preservation Consequences

Each layer has distinct preservation requirements:

• a calculator needs mechanism knowledge and operational technique;
• a card deck needs physical order, code definitions and reader compatibility;
• a tabulation workflow needs wiring diagrams, card schemas and report procedures;
• a binary object needs format and interpretation metadata;
• a computer program needs architecture and execution environment;
• high-level source may need compiler, version, options, libraries and runtime.

Preservation therefore moves from saving objects to preserving executable relationships.

13. Master-Specification Consequences

This study requires the map to add or refine:

1. Operation repertoire.
2. Instruction location.
3. Graded programmability.
4. Representation layer and state alphabet.
5. Binary, digital and electronic as separate properties.
6. Schema visibility and data-entry burden.
7. Machine speed versus service latency.
8. Feature matrices for disputed computer firsts.
9. Program-data relation.
10. Abstraction level.
11. Translator and runtime dependency.
12. Source-target and toolchain lineage.
13. Verification burden.
14. Administrative legibility and classification power.
15. Labour reallocation.

14. Evolutionary Sequence

The sequence can be represented as:

written procedure → embodied mechanism → portable machine-readable control → machine-readable administrative records → common discrete representation → electronic stored-program processing → formal source language and automated translation

The sequence is layered rather than linear. Modern computers retain mechanical constraints, external media, binary encodings, administrative schemas and human verification.

15. Content Packaging Opportunities

Possible documentary spine:

• The Machine That Remembered the Carry
• When Holes Became Instructions
• The Census Became a Dataset
• Zero and One Needed a Dictionary
• Why There Is No Single First Computer
• The Translator Inside Every Program

The visual motif is procedure migrating through physical locations: a clerk's hand, a gear train, a card deck, a control panel, a memory address and a compiler pipeline.

16. Final perspective

This study marks the transition from information technologies that preserve or transmit messages to machines that systematically transform representations.

The decisive change is not one component. It is the increasing separability of procedure, data, representation and machinery. Mechanical calculators embody procedure. Punched media make procedure or data portable. Tabulators process structured record collections. Binary provides a robust common alphabet. Electronic computers execute changeable sequences rapidly. Programming languages and compilers make those sequences writable at higher levels of abstraction.

Every gain creates a new dependency. Mechanised accuracy depends on entry and maintenance. Machine-readable records depend on schemas. Binary objects depend on formats. Stored programs depend on architectures. High-level source depends on translators and runtimes.

Computing did not remove interpretation from information work. It built a taller stack of representations through which interpretation could be delegated, accelerated and concealed.