Historical Notes

The authoritative reference for every historical claim in this module. Unit materials cite this page rather than restating history in their own words, so that a correction here propagates instead of leaving stale copies behind.

Each claim carries a verification status: established, contested, or unsourced. The labels are defined in course/references.md. Reference labels in square brackets — [P2], [S1] — resolve there.

A warning that is also the lesson: this is the part of the module where confident, fluent, wrong text is easiest to produce and hardest to notice. That applies to AI-generated drafts of this page, and it applied to the nineteenth-century printers too.

1. The people and the machine

Established. Charles Babbage designed the Analytical Engine, a general-purpose mechanical computing machine, from the 1830s onwards. It was never completed in his lifetime. Its architecture separated a "store" (memory) from a "mill" (processing), and it was to be programmed with punched cards adapted from the Jacquard loom. [S1], [S4]

Established. In 1840 Babbage lectured on the Engine in Turin. Luigi Federico Menabrea wrote up an account in French, published in 1842. [P1]

Established. Augusta Ada King, Countess of Lovelace, translated Menabrea's article into English and appended seven Notes, A to G, of her own. The translation with Notes appeared in 1843 in Taylor's Scientific Memoirs, volume 3. Her Notes run to roughly three times the length of the article she was translating (a commonly repeated characterisation of the 1843 text, not a figure the text itself states). [P2]

Established. Note G contains a table setting out, operation by operation, how the Engine would compute a Bernoulli number. [P2]

2. "The first program"

Contested — and the contest is the teaching point.

The claim "Note G contains the first computer program" is useful shorthand and a poor historical statement. What is actually disputed, and by whom:

• What Note G contains is not in dispute: an explicit, ordered, operation-by- operation specification of a computation, including working variables and a repeated group of operations, intended for a general-purpose machine. [P2]
• Whether that constitutes "the first program" depends on a definition nobody agreed in advance. Babbage had written sequences of operations for the Engine earlier, in unpublished notebooks. [S1], [S4]
• How much of the Notes was Lovelace's own work is genuinely disputed. Stein [S2] argues for a substantially smaller contribution than the popular account; Toole [S3] argues for a larger one; Hollings, Martin and Rice [S5] work through the surviving correspondence in detail. Babbage's own account [P3] is a primary source written by an interested party decades later.

How the module handles this. Unit 1 states only the checkable core: Note G was published in 1843 and contains an ordered operation table intended for the Analytical Engine. It reports “first program” as a common, contested retrospective description rather than claiming priority. It does not adjudicate the authorship question or pretend the question is settled in either direction.

A claim being contested does not make it unknowable or make all positions equal. It means the honest statement is "sources disagree, here is the disagreement", which is a different skill from repeating whichever version you met first.

3. The indexing convention in Note G

Established, and verified computationally.

Lovelace numbers only the Bernoulli numbers that are not zero. The odd-index Bernoulli numbers above the first are all zero, and in her scheme they simply do not receive labels. Her label numbers are therefore one smaller than the modern indices — her B_k is the modern B_k+1:

Note G's worked example computes her B₇, which is the modern B₈ = -1/30.

This mapping is implemented and tested in course/lab/reference_bernoulli.py (ada_to_modern_index, ADA_NOTE_G_INDEX_MAP) and covered by tests/test_reference_bernoulli.py.

Why the module makes so much of this. It is a specification hazard of exactly the kind that still causes defects: two systems, the same symbol, different meanings, and no error message when they meet. A learner who asks an AI to "reproduce Ada's Bernoulli calculation" and compares the result against a modern table will see a mismatch that is nobody's arithmetic error. The checker reports it as ada-indexing.

4. The error in the published table

Established: the table printed in Note G contains an error, and it is in operation 4.

Established (facsimile [P2a], accessed 2026-07-23): operation 4 acts on the variables ²V₅ and ²V₄, in that order, and its stated result is (2n−1)/(2n+1). Since V₄ holds 2n−1 and V₅ holds 2n+1, producing that result requires dividing V₄ by V₅. The table prints the operands the other way round. See the facsimile recorded at [P2a]; the diagram is headed "Diagram for the computation by the Engine of the Numbers of Bernoulli. See Note G (page 722 et seq.)", which is also the source for the page number now given in [P2].

Established (facsimile plus correction of record): the correct ordering is V₄ ÷ V₅; the published V₅ ÷ V₄ inverts the division. The location and the inversion are established by the facsimile [P2a] and the archival correction of record [S8], and corroborated by [S7], a detailed independent reconstruction, self-published. The corrected table computes −1/30 — Ada's B₇, the modern B₈.

Established (recomputed in this module): what the as-printed table actually computes is 139/630, not the −25621/630 that encyclopaedia and blog accounts [S6] repeat. The module reconstructed Note G's 25 operations and ran them with exact arithmetic (course/lab/noteg.py): the corrected run reproduces the documented −1/30, which is what earns trust in the reconstruction, and the as-printed run then yields 139/630. The misprint corrupts only the A₀ term (operation 9 overwrites the affected variable before the multiplicative loop), so it cannot produce a value as large as −25621/630 ≈ −40.7. The much-repeated −25621/630 appears in no scholarly source and does not survive recomputation — which is exactly the lesson of this unit, now demonstrated on the unit's own example.

Still contested: how it got there. The common description is a typesetting error rather than a mistake in the procedure Lovelace devised — Babbage's 1864 memoir records that she caught an error for him, and this one is often read as introduced in printing. But that attribution is an inference, not something the table itself can settle, and whether Babbage prepared or checked the table bears on the unsettled authorship question in section 2. Do not state the printer, or any individual, as the cause.

A caveat that is itself the lesson. The facsimile consulted is a single compressed web image [P2a]. From it, the operand order (V₅ before V₄) and the location (operation 4) are legible and match the secondary account; the division operator is small enough at that resolution to be easy to misread — on a first pass it can look like a plus sign. The value chain has now been recomputed from the operation sequence (course/lab/noteg.py), so the 139/630 result rests on the module's own tested code rather than on repetition; a higher-resolution facsimile or the physical page in Scientific Memoirs vol. 3 would still settle the fine typography beyond doubt. What is settled now is the location, the operand inversion, and — by computation — the value the faulty table produces.

Why this restraint is the lesson, not a limitation. Unit 7's teaching point is not "here is an amusing bug in a famous document". It is that a published, respected, widely-cited table carried an error for a long time because readers trusted it instead of checking it, and that the specific story now attached to that error has itself propagated by repetition. A fluent AI system will produce a confident, detailed account of the Note G error on request. So will many websites. Being able to say "that is the common claim, here is what is actually established, here is what would settle it" is the transferable skill — and a module that modelled the opposite behaviour while teaching it would be worthless.

5. The "originate anything" passage

Established that the passage appears in Note G [P2]. Lovelace writes that the Analytical Engine "has no pretensions whatever to originate anything", and that it can do "whatever we know how to order it to perform".

Contested what it implies for modern systems. Unit 8 asks learners to compare the claim with what a language model does, and is written to leave the question open rather than resolve it. Both of the easy readings are available and neither is obviously right:

• A language model produces text no human wrote, so in some sense it originates.
• A language model produces statistically likely continuations of its training data given a prompt, and "we ordered it to perform" exactly that.

The honest position is that Lovelace was writing about a specific machine she understood in detail, that the passage is being applied well outside its original context, and that the argument turns on what "originate" means — which is a philosophical question the module does not settle. Present it as a live question. Quote briefly; the source is public domain, so the limit is pedagogical rather than legal.

6. Claim register

The quick-reference summary. Anything a unit asserts about history should appear here.