The First AI Programs — When Machines Began to Learn
In the summer of 1956, a group of scientists gathered at Dartmouth College for a workshop that would change the future of technology. This “Dartmouth Conference,” as we discussed in the previous post, wasn’t just a meeting — it marked the official birth of a new field: Artificial Intelligence.
When those researchers left Hanover, New Hampshire, they didn’t just take home new ideas. They returned to their labs fired up with determination to turn theory into reality. The late 1950s became a period of bold experiments, groundbreaking programs, and the first real steps toward making machines “think.”
Let’s take a deep dive into that fascinating era.
Logic Theorist (1955–1956): When Reasoning Went Digital
In 1955, three researchers—Allen Newell, Herbert A. Simon, and Cliff Shaw—had an ambitious idea: what if a computer could think through problems the way humans do, not just crunch numbers?
Their answer was Logic Theorist, a program built to prove mathematical theorems. It ran on RAND Corporation’s JOHNNIAC computer, powered by a new kind of language called Information Processing Language (IPL). This wasn’t just about numbers anymore—IPL allowed the machine to manipulate symbols and relationships between ideas.
In 1956, they unleashed Logic Theorist on the notoriously dense Principia Mathematica by Alfred North Whitehead and Bertrand Russell—a book famous for its complexity. The program proved dozens of theorems, and in a twist worthy of headlines, it even found a shorter, more elegant proof for Theorem 2.85 than the one written by its original authors.
The Logic Theorist discovered a shorter proof for exactly this theorem—fewer steps than the original proof by Whitehead and Russell.
That moment was a turning point. It meant a machine could follow a chain of reasoning and even improve on human logic in some cases.
How did it pull this off?
Think of it like solving a maze. Instead of wandering randomly, Logic Theorist used heuristics—rules of thumb—to guide its search through possible proof steps, avoiding dead ends and zeroing in on promising paths. This “guided search” strategy became a cornerstone of AI research for decades to come.
Of course, the program wasn’t perfect. It could only handle narrow, well-defined problems and needed its inputs carefully prepared by humans. But the achievement was undeniable: it proved computers could work with abstract concepts, not just numbers—and that they could reason, at least in a limited way.
General Problem Solver (1957–1959): When Problem-Solving Went Universal
By 1957, Allen Newell and Herbert A. Simon weren’t satisfied with proving just math theorems. Logic Theorist had shown that a computer could think through one kind of structured problem — but what if a single program could tackle any problem, so long as you could describe it clearly enough?
That ambition gave birth to the General Problem Solver (GPS) — not a navigation system (this was decades before satellite GPS), but a pioneering AI designed to solve a broad range of tasks. If Logic Theorist was like a chess prodigy for proofs, GPS was meant to be a universal problem-solver.
The core idea was deceptively simple:
- Define where you are (the starting state).
- Define where you want to be (the goal state).
- Use reasoning to bridge the gap.
GPS introduced an approach called means–ends analysis — essentially, it compared the current state to the goal, spotted the differences, and then looked for actions that would reduce those differences. Step by step, it nudged the system toward the finish line. If it hit a wall, it could backtrack and try a different path, like a persistent puzzle-solver.
This was a big conceptual leap. Instead of hard-coding solutions for each task, GPS provided a framework that could, in theory, work on everything from mathematical proofs to puzzle games to scheduling problems — so long as the problem could be expressed in the right symbolic language.
Of course, reality was less glamorous. Early GPS struggled when problems got too big or too messy. Its symbolic reasoning system couldn’t easily handle the chaos of real-world data, and the program could get bogged down in combinatorial dead ends. Still, its influence on AI was profound: it showed that search + heuristics + representation could be a reusable recipe for machine problem-solving.
Newell and Simon’s vision — that the same reasoning engine could work across domains — became a guiding light for decades of AI research, from planning systems to today’s reinforcement learning agents.
Arthur Samuel’s Checkers (1952–1959): A Machine That Learns
In 1952, IBM researcher Arthur Samuel set out to answer a simple but ambitious question:
Could a computer improve its own performance just by playing more games?
He started by programming a checkers-playing system for the IBM 701, and later the IBM 704. The first version wasn’t anything special—it followed a fixed set of rules Samuel had written by hand. Predictable. Limited. Easy to beat.
The turning point came when Samuel decided to let the program learn.
He introduced two major ideas:
- Evaluation Function – The program could “score” a board position using key factors such as piece advantage and mobility.
- Adaptive Learning – Instead of keeping those scoring weights fixed, the program adjusted them over time. It remembered board positions that led to victories (rote learning) and used countless games of self-play to refine its strategy.
To plan ahead, it used a search technique called minimax, combined with pruning to avoid wasting time on hopeless branches.
By 1959, Samuel’s program had reached the level of a strong amateur player—good enough to give human opponents a real challenge. That same year, in an IBM Journal paper, he popularized the term “machine learning.” The phrase had been floating around in academic circles before, but Samuel’s work gave it real visibility.
Why was this a breakthrough?
Before Samuel, most computer programs were like cookbooks—every possible step had to be written down by a human. Samuel’s checkers player proved that performance could improve with data and experience. Instead of programming exactly how to win, he built a system that learned how to win.
LISP (1958–1960): The language that let AI speak
CONS, CAR, CDR.
In 1958, John McCarthy began designing LISP for AI research, publishing the foundational paper in 1960. LISP treated programs and data in the same uniform way—as symbolic lists. That simple idea unlocked elegant manipulation of knowledge, expressions, and rules.
LISP offered recursion as a first-class tool, automatic garbage collection, and a tiny set of primitives that could express surprisingly rich ideas. For AI, this was perfect. Researchers could represent facts, rules, and trees directly, then write concise procedures to reason over them. LISP quickly became the language of AI labs at MIT and beyond, shaping decades of symbolic AI work.
Its influence is still with us. Many features that feel natural in modern languages—higher-order functions, REPL-driven workflows, homoiconicity in some DSLs—trace back to LISP’s design
Why these first programs still matter
Between 1955 and 1959, AI gained proof that three pillars could stand up on real machines. Symbolic reasoning worked on formal problems. General problem solving could plan toward goals given the right structure. Learning from data could lift performance without rewriting the program by hand. And underneath it all, LISP gave researchers a language that fit the work.
These systems had limits. They needed clean problem definitions and careful setups. But they showed that intelligence could be broken down into parts a computer can handle: representation, search, learning, and control. Everything that came later—computer vision, expert systems, deep learning—grew from these roots.
Next in the Series
The optimism of 1956–1959 would soon give way to a sobering slowdown. In the next chapter, we will examine the arrival of the AI Winter, when overpromises, limited computing power, and funding cuts almost froze the field entirely.
See you there.
