Ada Lovelace, Programming, and the Imagination of Computation: From Analytical Engine to AI Caution

Last Updated June 23, 2026

Ada Lovelace, Programming, and the Imagination of Computation examines how a nineteenth-century mathematical writer helped imagine computation before electronic computers existed. Lovelace did not build a machine. She did not program in a modern programming language. She worked with Charles Babbage’s proposed Analytical Engine, translated Luigi Menabrea’s account of the machine, and added extensive notes that pushed the meaning of computation beyond arithmetic calculation.

Her importance lies in the imagination of computation as much as in any single technical table. Lovelace saw that Babbage’s Analytical Engine was not merely a faster calculator. It was a general symbol-processing machine in conception: a device that could follow operations, manipulate relations, and potentially work on things other than ordinary numbers if those things could be represented according to rule. Her famous discussion of Bernoulli numbers matters because it shows a procedure written for a machine that was never fully built. Her reflections on music, symbols, operations, and limits matter because they show a mind trying to understand what computation could become.

This article treats Lovelace carefully. It does not reduce her to a romantic myth of solitary invention, nor does it dismiss her because she worked collaboratively with Babbage. Instead, it places her at a historical junction between mathematics, machinery, notation, programming, imagination, gendered scientific culture, and computational philosophy. Her legacy is not just “first programmer.” It is the recognition that computation can be an abstract medium for structured operations.

This article introduces Ada Lovelace, Charles Babbage, the Analytical Engine, Luigi Menabrea, Lovelace’s Notes, Note G, Bernoulli numbers, punched cards, programming, loops, symbolic operations, mechanical calculation, computation beyond arithmetic, poetical science, imagination, music, machine limits, software history, gender and scientific authorship, collaboration, origin stories, artificial intelligence, and responsible algorithmic reasoning. It argues that Lovelace matters because she saw computation as a general procedural medium before computation had modern machines, languages, or institutions.

Why Lovelace Matters

Ada Lovelace matters because she saw the Analytical Engine as more than a calculator. Babbage designed machines for calculation, but Lovelace helped articulate the wider idea that a machine operating on symbols could become a general medium of procedure. Her notes interpreted the Engine as a system for operations. That shift is crucial in the history of algorithms because it links calculation with programmable symbolic manipulation.

Lovelace’s reputation often centers on whether she wrote the first computer program. That question is important, but it is too narrow by itself. Her broader significance lies in how she imagined a machine’s possible scope: not just arithmetic tables, but patterned operations on symbolic relations.

Lovelace matters because she helped imagine computation before computation had its modern institutional form.

Back to top ↑

The Analytical Engine as a New Kind of Machine

Babbage’s Analytical Engine was different from a simple calculator because it was conceived as a general-purpose machine. It would use a store for numbers, a mill for operations, and punched cards to direct the sequence of action. Although it was never completed in Babbage’s lifetime, its design anticipated important ideas in programmable computing.

For Lovelace, the Analytical Engine represented a new relation between rule and machine. The machine could be instructed. It could execute a sequence. It could combine operations. It could reuse intermediate values. It could, in principle, act on symbolic relations if those relations were expressed in a form the machine could handle.

The Analytical Engine made it possible to imagine a machine that could follow a structured procedure rather than merely perform a fixed calculation.

Back to top ↑

Translation, Notes, and Intellectual Authorship

Lovelace’s major published work on computation began as a translation of Luigi Menabrea’s article on Babbage’s Analytical Engine. But her notes greatly expanded the text. They were not merely explanatory footnotes. They developed arguments about operations, symbolism, machine structure, possible applications, and limits.

This matters for intellectual authorship. Translation is not passive when the translator interprets, extends, clarifies, reframes, and theorizes. Lovelace’s notes show that algorithmic history often emerges through commentary, not only invention. Her authorship is inseparable from translation, collaboration, mathematical exposition, and conceptual imagination.

Lovelace’s contribution is best understood as interpretive, technical, collaborative, and imaginative at once.

Back to top ↑

Note G and the Bernoulli Number Procedure

Note G is the most famous technical part of Lovelace’s notes. It presents a table for the computation of Bernoulli numbers by the Analytical Engine. The procedure is historically important because it is a machine-oriented sequence of operations written for a general-purpose calculating engine.

Whether one calls it the first computer program depends partly on definitions. The machine was never completed, and Lovelace worked in conversation with Babbage. Still, Note G is a landmark because it translates mathematical recurrence into an ordered procedure for a programmable mechanical design.

Note G is important not because it resembles modern code exactly, but because it imagines mathematical procedure as machine instruction.

Back to top ↑

Programming Before Programming Languages

Lovelace’s work belongs to programming before programming languages. There was no Python, C, Fortran, Java, or assembly language. There was no stored-program electronic computer. There was a proposed mechanical engine controlled by cards and a mathematical imagination capable of translating operations into a structured machine process.

This makes Lovelace historically valuable. She helps us separate programming as a conceptual act from programming as modern syntax. Programming begins not with a particular language but with the formulation of ordered operations for an executing system.

Lovelace helps show that programming is first a disciplined imagination of executable procedure.

Back to top ↑

Operations, Symbols, and Computation Beyond Arithmetic

One of Lovelace’s most important insights is that computation could be understood as operation on symbols, not merely arithmetic on numbers. Numbers could stand for quantities, but they could also represent other relations if a domain could be encoded. This is why her reflections are often seen as anticipating broader symbolic computation.

The Analytical Engine was designed around number, but Lovelace imagined a general logic of operations. If relations could be expressed symbolically, the machine’s processes might apply to them. That idea points toward later computing, where text, images, sounds, instructions, graphs, and models are all represented in computable forms.

Lovelace’s imagination of computation begins where number becomes a medium for operations on structure.

Back to top ↑

Poetical Science and Computational Imagination

Lovelace described her intellectual orientation in terms often associated with “poetical science.” This does not mean replacing rigor with fantasy. It means joining disciplined mathematical analysis with imaginative perception of possibility. Lovelace’s strength was not only calculating what the Engine could do, but imagining what kind of thing the Engine was.

Computational imagination matters because new technologies are often misunderstood when interpreted only through older categories. If the Analytical Engine is seen only as a calculator, its generality disappears. If it is seen as a symbolic engine, a new future becomes visible. Lovelace’s imagination allowed her to interpret machinery philosophically.

Lovelace’s “poetical science” is one reason her notes still matter: they interpret computation before computation becomes ordinary.

Back to top ↑

Music, Pattern, and Symbolic Generality

Lovelace famously imagined that the Engine might compose elaborate scientific music if the fundamental relations of pitched sounds could be expressed and adapted to the machine’s operations. This is one of her most striking insights because it treats computation as a general symbolic medium.

Music is not arithmetic in the narrow sense, but music has structure: pitch, interval, rhythm, pattern, transformation, repetition, variation, and rule. Lovelace’s point is not that the Engine was ready to become a composer. It is that computation could operate on represented relations beyond ordinary numerical tables.

Her music example is a powerful early statement of computational generality.

Back to top ↑

Machine Limits and the Lovelace Objection

Lovelace also articulated a famous limit: the Analytical Engine had no power to originate anything on its own; it could do what humans knew how to order it to perform. This claim later became known in discussions of machine intelligence as the Lovelace objection.

Whether the objection defeats modern AI is a separate question. But historically, it matters because Lovelace did not treat machinery as magic. She understood both the power and the boundary of programmed operation. Machines could execute procedures with extraordinary capacity, but their operations depended on representation, instruction, and human-specified relations.

Lovelace’s limit is not anti-computation. It is a disciplined account of what computation depends on.

Back to top ↑

Collaboration with Babbage

Lovelace’s work cannot be separated from Charles Babbage. Babbage designed the Engine, supplied technical context, and corresponded with Lovelace. Lovelace translated, interpreted, organized, and extended the published explanation. Their collaboration is sometimes used either to inflate or diminish Lovelace’s contribution. Both moves are too simple.

Collaborative authorship is common in the history of computation. Machines, programs, notations, and concepts emerge through networks. Babbage’s engineering and Lovelace’s interpretation are different contributions. The question is not whether one cancels the other. The question is how their roles combined to make a new concept of computation visible.

Lovelace’s contribution is collaborative, but collaboration is not the same as absence of authorship.

Back to top ↑

Gender, Credit, and the Politics of Recognition

The history of Lovelace is also a history of recognition. Women’s contributions to mathematics, astronomy, computation, and engineering have often been minimized, reframed as assistance, or remembered only symbolically. Lovelace’s case is complicated because her fame has sometimes been exaggerated into myth and sometimes challenged in ways that risk diminishing genuine intellectual work.

A responsible account does not need either extreme. It can acknowledge debate about the technical authorship of Note G while still recognizing the originality of her interpretive vision. It can place Babbage’s role clearly while also recognizing that Lovelace’s notes gave the Engine a broader conceptual life.

Lovelace deserves neither mythology nor dismissal. She deserves historically careful attention.

Back to top ↑

From Mechanical Procedure to Software Imagination

Lovelace’s writing belongs to the transition from mechanical procedure to software imagination. The Analytical Engine was a machine of gears and cards, but Lovelace’s notes treated its operations as abstract procedures. This is one reason she remains central to software history.

Software is not merely machine hardware. It is the ordering of operations. It is a way of representing procedure so that a machine can act. Lovelace did not write software in the modern sense, but she helped imagine the separation between machine capability and the instructions that give it purpose.

Lovelace’s imagination helped separate the machine from the program before modern software existed.

Back to top ↑

Lovelace and Modern AI Caution

Lovelace’s reflections remain relevant because modern AI systems often prompt confusion about agency, creativity, originality, and understanding. The Lovelace objection reminds us that machine output depends on systems of representation, instruction, data, design, and human interpretation. Modern machine learning complicates this claim, but it does not make it irrelevant.

AI systems may produce unexpected outputs, but they are still built through architectures, training objectives, datasets, optimization routines, evaluation protocols, deployment contexts, and user prompts. Lovelace’s caution encourages us to ask not only what a machine produces, but what ordering, representation, and prior knowledge make that output possible.

Lovelace’s insight fits the Sustainable Catalyst principle: AI belongs in the toolkit, not in control.

Back to top ↑

Origin Stories and Careful Memory

Lovelace is often remembered as the first programmer. This phrase can be useful, but only with care. It captures the importance of Note G and her machine-oriented procedure. It also risks simplifying a collaborative, conceptual, and historically complex achievement into a slogan.

Careful memory separates several claims. Lovelace translated and expanded Menabrea’s article. She wrote notes that interpreted the Analytical Engine broadly. She included a table for Bernoulli numbers. She imagined computation beyond arithmetic. She articulated machine limits. These are distinct contributions, and each deserves its own place.

Lovelace’s legacy is strongest when remembered as layered rather than sloganized.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Lovelace’s historical contribution can be modeled as:

The Analytical Engine can be modeled as:

Programming before modern programming languages can be modeled as:

The Lovelace objection can be modeled as:

These formulas are interpretive models. They clarify conceptual structure without claiming Lovelace used modern notation or computer-science terminology.

Back to top ↑

Python Workflow: Lovelace Computation Imagination Map

The Python workflow below creates a dependency-light interpretive map of Lovelace’s contribution to programming and computational imagination. It scores themes by programming structure, symbolic generality, machine orientation, mathematical grounding, imaginative reach, limit awareness, collaboration, authorship, modern resonance, and AI caution, then writes reproducible CSV and JSON outputs.

# ada_lovelace_computation_imagination_map.py
# Dependency-light workflow for mapping Lovelace's role in programming and computational imagination.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
from statistics import mean
import csv
import json
from datetime import datetime, timezone

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"
JSON_DIR = ARTICLE_ROOT / "outputs" / "json"


@dataclass(frozen=True)
class LovelaceConfig:
    article: str = "ada_lovelace_programming_and_the_imagination_of_computation"
    core_threshold: float = 0.80
    high_programming_threshold: float = 0.86


def timestamp_utc() -> str:
    return datetime.now(timezone.utc).isoformat()


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        path.write_text("", encoding="utf-8")
        return
    fieldnames = sorted({key for row in rows for key in row.keys()})
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")


def lovelace_themes() -> list[dict[str, object]]:
    return [
        {"theme_id": "note_g_bernoulli_procedure", "programming_structure": 0.98, "symbolic_generality": 0.86, "machine_orientation": 0.98, "mathematical_grounding": 0.94, "imaginative_reach": 0.86, "limit_awareness": 0.76, "collaboration": 0.92, "authorship": 0.90, "modern_resonance": 0.98, "ai_caution": 0.82},
        {"theme_id": "analytical_engine_general_machine", "programming_structure": 0.92, "symbolic_generality": 0.96, "machine_orientation": 0.98, "mathematical_grounding": 0.90, "imaginative_reach": 0.94, "limit_awareness": 0.84, "collaboration": 0.92, "authorship": 0.86, "modern_resonance": 0.98, "ai_caution": 0.86},
        {"theme_id": "computation_beyond_arithmetic", "programming_structure": 0.86, "symbolic_generality": 0.98, "machine_orientation": 0.92, "mathematical_grounding": 0.88, "imaginative_reach": 0.98, "limit_awareness": 0.86, "collaboration": 0.86, "authorship": 0.94, "modern_resonance": 0.98, "ai_caution": 0.90},
        {"theme_id": "music_pattern_symbolic_generality", "programming_structure": 0.78, "symbolic_generality": 0.98, "machine_orientation": 0.88, "mathematical_grounding": 0.82, "imaginative_reach": 0.98, "limit_awareness": 0.82, "collaboration": 0.78, "authorship": 0.94, "modern_resonance": 0.96, "ai_caution": 0.86},
        {"theme_id": "lovelace_objection_machine_limits", "programming_structure": 0.78, "symbolic_generality": 0.88, "machine_orientation": 0.92, "mathematical_grounding": 0.82, "imaginative_reach": 0.90, "limit_awareness": 0.98, "collaboration": 0.80, "authorship": 0.94, "modern_resonance": 0.98, "ai_caution": 0.98},
        {"theme_id": "translation_notes_authorship", "programming_structure": 0.84, "symbolic_generality": 0.90, "machine_orientation": 0.88, "mathematical_grounding": 0.86, "imaginative_reach": 0.94, "limit_awareness": 0.86, "collaboration": 0.98, "authorship": 0.98, "modern_resonance": 0.94, "ai_caution": 0.84},
        {"theme_id": "gender_credit_recognition", "programming_structure": 0.76, "symbolic_generality": 0.82, "machine_orientation": 0.78, "mathematical_grounding": 0.78, "imaginative_reach": 0.90, "limit_awareness": 0.88, "collaboration": 0.96, "authorship": 0.98, "modern_resonance": 0.96, "ai_caution": 0.86},
    ]


def score_theme(row: dict[str, object], config: LovelaceConfig) -> dict[str, object]:
    imagination_score = mean([
        float(row["programming_structure"]),
        float(row["symbolic_generality"]),
        float(row["machine_orientation"]),
        float(row["mathematical_grounding"]),
        float(row["imaginative_reach"]),
        float(row["limit_awareness"]),
        float(row["collaboration"]),
        float(row["authorship"]),
        float(row["modern_resonance"]),
        float(row["ai_caution"]),
    ])

    if imagination_score >= config.core_threshold and float(row["programming_structure"]) >= config.high_programming_threshold:
        interpretive_status = "core_lovelace_computation_thread"
    elif imagination_score >= config.core_threshold:
        interpretive_status = "major_lovelace_computation_thread"
    else:
        interpretive_status = "supporting_lovelace_computation_thread"

    return {
        "theme_id": row["theme_id"],
        "programming_structure": round(float(row["programming_structure"]), 6),
        "symbolic_generality": round(float(row["symbolic_generality"]), 6),
        "machine_orientation": round(float(row["machine_orientation"]), 6),
        "mathematical_grounding": round(float(row["mathematical_grounding"]), 6),
        "imaginative_reach": round(float(row["imaginative_reach"]), 6),
        "limit_awareness": round(float(row["limit_awareness"]), 6),
        "collaboration": round(float(row["collaboration"]), 6),
        "authorship": round(float(row["authorship"]), 6),
        "modern_resonance": round(float(row["modern_resonance"]), 6),
        "ai_caution": round(float(row["ai_caution"]), 6),
        "imagination_score": round(imagination_score, 6),
        "interpretive_status": interpretive_status,
    }


def interpretation_cautions() -> list[dict[str, str]]:
    return [
        {"caution": "do_not_reduce_lovelace_to_a_slogan", "meaning": "The phrase first programmer is useful only when Note G, collaboration, and definition are explained."},
        {"caution": "do_not_dismiss_translation_as_passive", "meaning": "Translation, annotation, interpretation, and expansion are intellectual work."},
        {"caution": "do_not_project_modern_software_backward", "meaning": "Lovelace wrote machine-oriented procedure, not modern source code."},
        {"caution": "do_not_ignore_babbage", "meaning": "Babbage's machine design and collaboration are central to the story."},
        {"caution": "do_not_overstate_machine_agency", "meaning": "Lovelace's machine-limit reflections remain important for AI-era claims."},
    ]


def main() -> None:
    config = LovelaceConfig()
    themes = lovelace_themes()
    scored = [score_theme(row, config) for row in themes]
    cautions = interpretation_cautions()

    summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "themes_reviewed": len(scored),
        "core_threads": sum(1 for row in scored if row["interpretive_status"] == "core_lovelace_computation_thread"),
        "major_threads": sum(1 for row in scored if row["interpretive_status"] == "major_lovelace_computation_thread"),
        "supporting_threads": sum(1 for row in scored if row["interpretive_status"] == "supporting_lovelace_computation_thread"),
        "mean_imagination_score": round(mean(float(row["imagination_score"]) for row in scored), 6),
        "cautions": len(cautions),
        "interpretation": "Lovelace should be studied as a bridge between mechanical procedure and software imagination: programming structure, symbolic generality, machine orientation, and machine limits.",
    }

    write_csv(TABLES / "lovelace_themes.csv", themes)
    write_csv(TABLES / "lovelace_computation_imagination_map.csv", scored)
    write_csv(TABLES / "interpretation_cautions.csv", cautions)
    write_csv(TABLES / "lovelace_imagination_summary.csv", [summary])

    write_json(JSON_DIR / "lovelace_config.json", asdict(config))
    write_json(JSON_DIR / "lovelace_computation_imagination_map.json", scored)
    write_json(JSON_DIR / "interpretation_cautions.json", cautions)
    write_json(JSON_DIR / "lovelace_imagination_summary.json", summary)

    print("Lovelace computation imagination map complete.")
    print(TABLES / "lovelace_imagination_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns Lovelace’s legacy into a reproducible interpretive artifact: programming structure, symbolic generality, machine orientation, imagination, limit awareness, collaboration, authorship, modern resonance, and AI caution are documented together.

Back to top ↑

R Workflow: Lovelace Programming Diagnostics

The R workflow reads the generated CSV outputs, summarizes Lovelace themes, visualizes dimensions, and writes an additional diagnostic table.

# ada_lovelace_computation_imagination_summary.R
args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

map_path <- file.path(tables_dir, "lovelace_computation_imagination_map.csv")
summary_path <- file.path(tables_dir, "lovelace_imagination_summary.csv")

if (!file.exists(map_path)) {
  stop(paste("Missing", map_path, "Run the Python workflow first."))
}

lovelace_map <- read.csv(map_path, stringsAsFactors = FALSE)
summary <- read.csv(summary_path, stringsAsFactors = FALSE)

png(file.path(figures_dir, "lovelace_computation_dimensions.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(lovelace_map[, c("programming_structure", "symbolic_generality", "machine_orientation", "mathematical_grounding", "imaginative_reach", "limit_awareness", "collaboration", "authorship", "modern_resonance", "ai_caution")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = lovelace_map$theme_id,
        las = 2,
        ylim = c(0, 1),
        ylab = "Interpretive Score",
        main = "Ada Lovelace, Programming, and the Imagination of Computation")
legend("bottomright",
       legend = rownames(score_matrix),
       cex = 0.68,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "lovelace_imagination_score_by_theme.png"), width = 1000, height = 750)
barplot(lovelace_map$imagination_score,
        names.arg = lovelace_map$theme_id,
        las = 2,
        ylab = "Imagination Score",
        main = "Lovelace Computation Imagination Score by Theme")
grid()
dev.off()

r_summary <- data.frame(
  themes_reviewed = summary$themes_reviewed[1],
  core_threads = summary$core_threads[1],
  major_threads = summary$major_threads[1],
  supporting_threads = summary$supporting_threads[1],
  mean_imagination_score = summary$mean_imagination_score[1],
  cautions = summary$cautions[1],
  diagnostic_note = "Lovelace should be studied as a bridge between mechanical procedure and software imagination: programming structure, symbolic generality, machine orientation, and machine limits."
)

write.csv(r_summary, file.path(tables_dir, "r_lovelace_imagination_diagnostic_summary.csv"), row.names = FALSE)
print(r_summary)

The R layer makes the interpretive structure visible: programming structure, symbolic generality, machine orientation, mathematical grounding, imaginative reach, limit awareness, collaboration, authorship, modern resonance, and AI caution can be compared across themes.

Back to top ↑

GitHub Repository

The companion repository contains reproducible workflows, synthetic interpretive data, outputs, calculators, documentation, and multilingual examples for this article.

Back to top ↑

A Practical Method for Studying Lovelace

A careful study of Lovelace asks how translation, programming, imagination, collaboration, and machine limits fit together.

This method lets Lovelace’s contribution remain important without becoming simplified mythology.

Back to top ↑

Common Pitfalls

The first pitfall is reducing Lovelace to a slogan. The second is dismissing her as merely a translator. The third is projecting modern software backward. The fourth is ignoring Babbage. The fifth is using her machine-limit claims too simplistically in modern AI debates.

A careful account of Lovelace is more interesting than either hero worship or dismissal.

Back to top ↑

Why Lovelace Still Matters

Ada Lovelace still matters because she recognized that computation could become more than arithmetic. She saw that a machine could be understood through operations, representation, symbolic relations, and ordered procedure. She also recognized limits: machines do not become meaningful outside instruction, structure, knowledge, and interpretation.

Her legacy is not simply that she wrote a famous table. It is that she helped imagine a future in which machines could manipulate symbolic relations according to rule. She stands between mechanical calculation and software imagination, between mathematics and poetry, between engineering and philosophy, between human instruction and machine execution.

That position remains urgent today. Modern AI systems invite both exaggeration and dismissal. Lovelace teaches another path: disciplined imagination joined to technical caution. Computation is powerful because it can extend human procedure. It is dangerous when its limits are forgotten. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• Al-Khwārizmī and the Historical Roots of Algorithmic Method
• Alan Turing and the Formalization of Computation
• The History of Algorithms: From Procedure to Computation
• Large Language Models and Procedural Reasoning
• When Algorithms Should Not Be Used

Back to top ↑

Further Reading

• Lovelace, A.A. (1843) ‘Notes by the Translator’, in Menabrea, L.F., ‘Sketch of the Analytical Engine Invented by Charles Babbage’.
• Menabrea, L.F. and Lovelace, A.A. (1843) ‘Sketch of the Analytical Engine Invented by Charles Babbage’.
• MAA Convergence (n.d.) ‘Mathematical Treasure: Ada Lovelace’s Notes on the Analytic Engine’.
• Fuegi, J. and Francis, J. (2003) ‘Lovelace & Babbage and the Creation of the 1843 “Notes”’. IEEE Annals of the History of Computing, 25(4), pp. 16–26.
• Toole, B.A. (1992) Ada, the Enchantress of Numbers: Prophet of the Computer Age. Mill Valley, CA: Strawberry Press.
• Essinger, J. (2014) Ada’s Algorithm: How Lord Byron’s Daughter Ada Lovelace Launched the Digital Age. Brooklyn: Melville House.
• Woolley, B. (1999) The Bride of Science: Romance, Reason, and Byron’s Daughter. New York: McGraw-Hill.
• Copeland, B.J. (1997) ‘The Church-Turing Thesis’. Stanford Encyclopedia of Philosophy.

Back to top ↑

References

• Copeland, B.J. (1997) ‘The Church-Turing Thesis’. Stanford Encyclopedia of Philosophy. Available at: https://plato.stanford.edu/entries/church-turing/.
• Essinger, J. (2014) Ada’s Algorithm: How Lord Byron’s Daughter Ada Lovelace Launched the Digital Age. Brooklyn: Melville House.
• Fuegi, J. and Francis, J. (2003) ‘Lovelace & Babbage and the Creation of the 1843 “Notes”’. IEEE Annals of the History of Computing, 25(4), pp. 16–26.
• Lovelace, A.A. (1843) ‘Notes by the Translator’, in Menabrea, L.F., ‘Sketch of the Analytical Engine Invented by Charles Babbage’. Available at: https://www.cs.yale.edu/homes/tap/Files/ada-lovelace-notes.html.
• MAA Convergence (n.d.) ‘Mathematical Treasure: Ada Lovelace’s Notes on the Analytic Engine’. Available at: https://old.maa.org/press/periodicals/convergence/mathematical-treasure-ada-lovelaces-notes-on-the-analytic-engine.
• Menabrea, L.F. and Lovelace, A.A. (1843) ‘Sketch of the Analytical Engine Invented by Charles Babbage’. Available at: https://www.fourmilab.ch/babbage/sketch.html.
• Toole, B.A. (1992) Ada, the Enchantress of Numbers: Prophet of the Computer Age. Mill Valley, CA: Strawberry Press.
• Woolley, B. (1999) The Bride of Science: Romance, Reason, and Byron’s Daughter. New York: McGraw-Hill.

Back to top ↑