Analytical engine facts for kids
The analytical engine was a special machine designed by an English mathematician named Charles Babbage. He is known as a computer pioneer. This machine was meant to be a general-purpose computer. Babbage first described it in 1837. It was planned to be better than his earlier design, the difference engine, which was a simpler calculator.
The analytical engine was designed with parts similar to modern computers. It had a section for math problems (an arithmetic logic unit). It could also follow instructions in a specific order, like doing things over and over (loops) or making choices (conditional branching). It even had memory to store information. This made it the first design for a computer that could do almost any calculation, much like today's computers. This ability is called being Turing-complete. In short, the way the analytical engine was set up is very similar to how computers are designed today. It was one of Charles Babbage's greatest ideas.
Sadly, Babbage was never able to build any of his machines completely. This was because of problems with his main engineer and not enough money. It wasn't until 1941 that Konrad Zuse built the first actual general-purpose computer, called Z3. This was more than 100 years after Babbage first thought of the analytical engine in 1837.
Contents
How the Analytical Engine Was Designed

Babbage's first idea for a mechanical computer was the Difference Engine. This machine was made for a special job: to create tables of logarithms and trigonometric functions. It did this by using a math method called finite differences. Babbage never finished building this machine. He had disagreements with his engineer, Joseph Clement, and the British government stopped giving money for the project.
While working on the Difference Engine, Babbage realized he could design a much more powerful machine. This new idea became the analytical engine. He started working on its design around 1833.
The analytical engine would get its instructions and information using punched cards. This was a common method at the time for controlling machines like the Jacquard loom, which made patterns in fabric. For showing results, the machine would have a printer, a graph plotter, and a bell. It could also punch numbers onto new cards so they could be used again later. The machine would work with regular numbers using a base-10 system.
The engine was planned to have a "store," which is like computer memory. It could hold 1,000 numbers, each with 50 digits. That's a lot of information for its time! A part called the "mill" was the arithmetic unit. It could do all four basic arithmetic operations (add, subtract, multiply, divide). It could also compare numbers and even calculate square roots. Early designs showed it in a circular shape. Later drawings showed it in a grid. Like the central processing unit (CPU) in modern computers, the mill would have its own special instructions. These were stored on "barrels" with pegs, similar to read-only memory.
The way users would program the engine was similar to today's assembly languages. It could do loops (repeating steps) and conditional branching (making choices). This meant the language could be Turing-complete, as defined later by Alan Turing. Three types of punch cards were used: one for math operations, one for numbers, and one for moving numbers to and from the mill. Babbage created many programs for the analytical engine between 1837 and 1840. These programs could solve complex math problems.
In 1842, an Italian mathematician named Luigi Federico Menabrea wrote about the engine in French. This was based on talks Babbage gave in Italy. In 1843, Ada Lovelace translated this description into English. She also added many of her own notes. Lovelace had been interested in the engine for years. Her notes included a way to calculate Bernoulli numbers using the machine. This is often seen as the first complete computer program. Because of her important work, she is called the first computer programmer.
Trying to Build the Engine
Later in his life, Babbage tried to find ways to build a simpler version of the machine. He put together a small part of it before he passed away in 1871.
In 1878, a group of scientists in Britain called the British Association for the Advancement of Science looked at the analytical engine. They called it "a marvel of mechanical ingenuity." However, they suggested not building it. They knew the machine was useful and valuable. But they couldn't guess how much it would cost to build. They also weren't sure if it would work correctly once it was finished.

From 1880 to 1910, Babbage's son, Henry Prevost Babbage, worked on building a part of the mill and the printing section. In 1910, this part was able to calculate a list of multiples of pi, though it had some errors. This was only a small piece of the entire engine. It couldn't be programmed and had no memory. Henry Babbage's "analytical engine mill" is now on display at the Science Museum in London. Henry also suggested building a smaller demonstration version of the full engine. He thought it could still do amazing things with numbers.
In 1991, the London Science Museum successfully built a complete and working version of Babbage's Difference Engine No. 2. This design included improvements Babbage found while working on the analytical engine. The museum built it using materials and tools that Babbage would have had. This showed that Babbage's designs could have been built with the technology of his time.
In 2010, a project called "Plan 28" started. It aimed to study Babbage's original plans in detail. The goal was to create a working virtual design, and then maybe build a real analytical engine. As of 2016, building a physical machine hadn't started. This was because Babbage's original drawings were very complex and hard to understand completely. By 2017, the project had created a searchable database of Babbage's materials.
Many of Babbage's original drawings have been put online for everyone to see.
How It Would Be Programmed
Babbage didn't write a simple instruction manual for his engine like we have for computers today. Instead, he showed how his programs would work step-by-step. He focused on what action would happen at each stage.
Experts believe the machine's card reader could move the cards forward and backward. This would allow for loops and conditional branching (making choices). This ability would make the engine "Turing-complete," meaning it could theoretically solve any problem a modern computer can.
One expert, Allan G. Bromley, wrote that the cards could be ordered to move forward and backward, which would allow for loops. He also noted that Babbage added ways for users to control loops in their programs.
An emulator (a computer program that acts like another machine) of the engine shows how it might work. It says the engine's card reader could skip cards forward or go backward. This would allow it to re-read cards and repeat steps.
This emulator also provides a written list of instructions. For example, a program to calculate a factorial (like 5! = 5x4x3x2x1) might look like this:
N0 6 N1 1 N2 1 × L1 L0 S1 – L0 L2 S0 L2 L0 CB?11
Here, "CB" means "conditional branch." This instruction tells the machine to jump back 11 cards if a certain condition is met.
Its Impact on Computing
What Babbage Thought Would Happen
Babbage understood that having an automatic computer would make people think about how to make programs run faster. He wrote that once an analytical engine existed, it would change how science worked. People would always ask: "How can we get these results from the machine in the shortest time?"
Computer Science Today
After his father's death, Henry Babbage continued working on the engine.
In 1909, Percy Ludgate designed his own analytical engine. It was drawn in detail but never built, and the drawings are now lost. Ludgate's engine would have been much smaller than Babbage's. It was thought to be able to multiply two 20-digit numbers in about six seconds.
Leonardo Torres Quevedo was inspired by Babbage. In 1913, he designed a theoretical electromechanical calculating machine. This machine would be controlled by a program. His paper also included the idea of floating-point arithmetic, which helps computers handle very large or very small numbers. In 1920, Torres showed his "Electromechanical Arithmometer." This machine had a math unit connected to a typewriter. You could type commands, and it would print the results automatically.
Vannevar Bush mentioned Babbage's work in his 1936 paper, "Instrumental Analysis." In the same year, he started a project to build an electronic digital computer.
Even with this early work, Babbage's ideas were largely forgotten for a while. Builders of early electronic computers in the 1930s and 1940s didn't know about the analytical engine's details. This meant they had to invent many of the same ideas Babbage had already proposed. For example, Howard Aiken, who built the Harvard Mark I (an early electromechanical calculator), praised Babbage's work later. But he didn't know about the analytical engine's design while building the Mark I. He even called his visit to the built part of the analytical engine "the greatest disappointment of my life." The Mark I didn't have the analytical engine's important feature of conditional branching. Similarly, J. Presper Eckert and John W. Mauchly didn't know the details of Babbage's work before they designed the first electronic general-purpose computer, the ENIAC.
How It Compares to Other Early Computers
If the analytical engine had been built, it would have been a digital machine. It would have been programmable and Turing-complete. However, it would have been very slow. Luigi Federico Menabrea wrote that Babbage believed his engine could multiply two 20-digit numbers in three minutes.
To compare, the Harvard Mark I could do the same task in just six seconds. A modern computer's CPU can do it in less than a billionth of a second!
Name | When it first worked | Number system | How it worked | How it was programmed | Could it do any calculation (Turing complete)? | Memory |
---|---|---|---|---|---|---|
Difference engine | Not built until the 1990s (designed in 1820s) | Decimal (base 10) | Mechanical | Not programmable; numbers set by hand | No | Physical position of wheels |
Analytical Engine | Not built (designed in 1830s) | Decimal (base 10) | Mechanical | Programmed by punched cards | Yes | Physical position of wheels |
Ludgate's Analytical Engine | Not built (designed in 1909) | Decimal (base 10) | Mechanical | Programmed by punched cards | Yes | Physical position of rods |
Torres' Analytical Machine | 1920 | Decimal (base 10) | Electro-mechanical | Not programmable; settings by patch cables | No | Mechanical relays |
Zuse Z1 (Germany) | 1939 | Binary floating point | Mechanical | Not programmable; settings by patch cables | No | Physical position of rods |
Bombe (Poland, UK, US) | 1939 (Polish), March 1940 (British), May 1943 (US) | Character calculations | Electro-mechanical | Not programmable; settings by patch cables | No | Physical position of rotors |
Zuse Z2 (Germany) | 1940 | Binary floating point | Electro-mechanical (mechanical memory) | Programmed by punched film | No | Physical position of rods |
Zuse Z3 (Germany) | May 1941 | Binary floating point | Electro-mechanical | Programmed by punched film | Yes, in theory | Mechanical relays |
Atanasoff–Berry Computer (US) | 1942 | Binary | Electronic | Not programmable; numbers input by punched cards | No | Capacitor memory |
Colossus Mark 1 (UK) | December 1943 | Binary | Electronic | Programmed by patch cables and switches | No | Vacuum tubes and thyratrons |
Harvard Mark I – IBM ASCC (US) | May 1944 | Decimal (base 10) | Electro-mechanical | Programmed by punched paper tape (no conditional branch) | No | Mechanical relays |
Zuse Z4 (Germany) | March 1945 (or 1948) | Binary floating point | Electro-mechanical | Programmed by punched film | Yes, by 1950 | Mechanical relays |
ENIAC (US) | July 1946 | Decimal (base 10) | Electronic | Programmed by patch cables and switches | Yes | Vacuum tube flip-flops |
Manchester Baby (UK) | 1948 | Binary | Electronic | Binary program entered into memory by keyboard (first electronic stored-program computer) | Yes | Williams cathode ray tube |
EDSAC (UK) | 1949 | Binary | Electronic | Five-bit code and variable-length numbers (first stored-program computer for many users) | Yes | Mercury delay lines |
See also
In Spanish: Máquina analítica para niños