The History of Computers: From Calculators to AI Systems

Turn this article into takeaways for your work.
Each assistant summarizes the article only for you and suggests best practices for your work.
One evening in 1812 or 1813, a young man dozed over a table of logarithms. Those are printed lists of numbers that make multiplication easier. At Cambridge, a fellow club member woke him and asked what he was dreaming about. Charles Babbage replied that the tables might be calculated by machinery.
The history of computers is the story of one idea repeating. Every generation made computing cheaper, then moved it closer to the person doing the work. Calculation went from clerks to a few giant institutional machines. Then it reached desks, then pockets, and now models you instruct in plain language. If you run a team, the pattern matters more than any single invention. It predicts who gets value from the next wave and who gets left waiting for a specialist.
Quick timeline of computer milestones
| Year/Era | Milestone | Why it mattered |
|---|---|---|
| 1830s-1840s | Babbage designs the Analytical Engine; Lovelace publishes her notes (1843) | The idea of a programmable machine existed a century before one could be built. |
| 1890 | Hollerith punched cards used for the US census | Data processing became an industrial job, not a clerical one. |
| 1944-1946 | Colossus runs at Bletchley Park; ENIAC is unveiled | Electronic speed replaced mechanical speed. |
| 1947-1948 | The transistor is invented; the Manchester "Baby" runs the first stored program | Hardware got reliable and software became changeable. |
| 1951 | UNIVAC I is delivered to the US Census Bureau | Computers began to look like products for organizations. |
| 1958-1959 | Kilby demonstrates the first integrated circuit; Noyce patents a version that can be mass-produced | Many components could live on one chip. |
| 1964 | IBM announces System/360 | One compatible family let customers grow without rewriting software. |
| 1971 | Intel's 4004 puts a central processing unit (CPU) on a chip | Computing could be embedded in almost anything. |
| 1975-1977 | Altair 8800 and Apple II | Individuals and small businesses could own a computer. |
| 1979 | VisiCalc ships for the Apple II | The first reason for a business to buy a PC. |
| 1981-1984 | IBM PC and Apple Macintosh | A standard platform, then a graphical interface. |
| 2006 | Amazon launches S3, the first Amazon Web Services (AWS) offering | Infrastructure became something you rent by the month. |
| 2007 | Apple announces the iPhone | A computer in every pocket, with the App Store following in 2008. |
| 2012 | AlexNet wins on graphics processing units (GPUs) | Graphics chips became the engine of modern AI. |
| 2022-2024 | ChatGPT arrives; Microsoft launches Copilot+ PCs | AI became an interface, and PCs started shipping with AI silicon. |
Counting machines and punched cards (1830s-1930s)
The first chapter of computer history is about removing calculation labor. People had counted with tools for millennia. The Computer History Museum calls a marble table abacus from the Greek island of Salamis, dated to about the 4th century BCE, the oldest surviving calculating device. Babbage's machines were different because they were meant to follow instructions. He designed automatic computing engines in the 1800s and, as the Computer History Museum puts it, "invented computers but failed to build them." Difference Engine No. 2, the first complete Babbage engine, was finished in London in 2002, 153 years after the design.
In 1834, with his first project stalled, Babbage conceived the Analytical Engine, a general-purpose programmable machine. Ada Lovelace's 1843 notes on it described how such a machine could follow instructions rather than only add numbers. She also speculated that it could work on things other than numbers, such as music.

The first place this became commercial was data. The US census had a processing crisis, and the government held a contest to solve it. Herman Hollerith won by recording data on punched cards that a tabulating machine could read, and the Computer History Museum notes that the Census Bureau was still using the same basic system about seventy years later. In 1896 Hollerith founded the Tabulating Machine Company, which merged into the firm that became IBM in 1911.
The new problem was volume. Once you can process a card, you want a million cards, and the work moves from thinking to feeding the machine. Anyone who has spent a Friday keying records into a system knows the descendant of that job, and it's the same work that AI data entry automation now handles. Feeding cards by hand could only go so fast, though, and the push for more speed came from war.
What this means for teams today:
- Representing work as structured data and repeatable instructions is the oldest idea in computing. It's still the first step in any automation project.
- If a process depends on people re-keying information between systems, you're running a punched-card workflow with newer furniture.
War, electronics and the first stored programs (1940s)
War money paid for electronic speed. The first Colossus became operational at Bletchley Park in 1944 to break German Lorenz ciphers, according to the Computer History Museum timeline. The Electronic Numerical Integrator and Computer (ENIAC) followed. Physicist John Mauchly proposed it in 1942, and it was built between 1943 and 1945 with US Army funding to calculate ballistics tables. On February 15, 1946, its existence became front-page news in The New York Times. The Computer History Museum records that it used almost 18,000 vacuum tubes, that one failed about every day or two, and that maintenance crews eventually learned to fix a fault in about 15 minutes.
Two changes in the late 1940s mattered as much as speed. In December 1947, John Bardeen and Walter Brattain made the first working transistor at Bell Labs, which the Computer History Museum notes grew out of research into replacements for unreliable vacuum tubes. And on June 21, 1948, the Manchester "Baby" became the first computer to run a program stored electronically in its own memory. Cambridge's EDSAC followed in 1949. The National Museum of Computing says it is generally accepted as the first practical stored-program electronic computer, and it provided a regular computing service for over nine years.
Stored programs are the quiet breakthrough. Once instructions live in memory like data, you can change what a machine does without rewiring it. That's why software exists as a business at all.
The problem these machines created was fragility. ENIAC was a room-sized system tended by specialists, and every new job meant rearranging how the machine was set up. Reliability and reusability became the next race, and this time businesses did the buying.
What this means for teams today:
- Flexibility beats raw speed. A system you can reconfigure without an engineer gets used more, which is the argument behind every no-code tool.
- Budget for the people who keep the machine running, not just the machine.
Mainframes: computing as an institutional utility (1951-1970s)
In March 1951 the US Census Bureau received its first UNIVAC I, which the Computer History Museum calls the first commercial computer to attract widespread public attention. It did about 1,905 operations per second and stored data on magnetic tape. Over the next two decades the mainframe became the default tool of large organizations. The Museum's mainframe exhibit shows the range. NASA used an IBM 7094 to control Mercury and Gemini space flights, and a transistorized computer ran Japan's first online, real-time railway reservation system in 1960. SAGE, an air-defense network that connected 23 computer sites, and SABRE, the American Airlines and IBM reservation system operational by 1964, showed computers could run live operations rather than overnight reports.
The defining product was IBM's System/360, launched on April 7, 1964. IBM describes it as one strictly compatible family under a single architecture, so software written for one machine could run on any other in the line. Customers could add capacity without rewriting programs, and the company bet $5 billion on the idea. That compatibility promise is still how enterprise software sells itself.
Mainframes also set the organizational pattern. Scarce, expensive computing power got centralized. Teams submitted jobs, waited for output, and designed their processes around the queue. The new problem was distance: the people with the questions were far from the people with the machine, and a specialist priesthood sat between them. Shrinking the machine was the obvious fix.
What this means for teams today:
- Centralization is a response to scarcity, and it returns whenever coordination or security matters. A shared data strategy is the modern version of the mainframe's single source of truth.
- Enterprise suites still carry this DNA. If you're weighing a big shared platform, what ERP is and how it works is the clearest description of the trade-off between standardization and flexibility.
- Batch thinking survives in approval chains and weekly reports. Workflow automation is how teams finally retire it.
Chips, minicomputers and Moore's Law (1959-1970s)
Mainframes got big because components were large and expensive. The integrated circuit changed that. Jack Kilby of Texas Instruments demonstrated a working circuit on September 12, 1958. In 1959 Robert Noyce of Fairchild Semiconductor patented a version that could be manufactured in volume. The Computer History Museum says their work, done separately, let computing power "increase dramatically." Digital Equipment Corporation's PDP-8, which the Museum's timeline calls the first commercially successful minicomputer, gave labs and factories a computer of their own. It cost one-fifth the price of a small System/360.

The microprocessor finished the job. Ted Hoff and Stanley Mazor conceived Intel's 4004. In 1971 Federico Faggin, assisted by Masatoshi Shima, squeezed its 2,300 transistors into a 16-pin package, per the Computer History Museum. The chip began as a calculator order: in April 1969 the Japanese firm Busicom and Intel signed a provisional agreement for custom calculator chips. A computer had become a component.
Gordon Moore's observation gave the industry a planning rhythm. In 1965 he projected that components per chip would double every 12 months for about a decade. At the 1975 IEEE International Electron Devices Meeting he slowed that to a doubling every two years, per the Computer History Museum. Whether or not you call it a law, executives planned around it: wait a cycle and the same budget buys more.
The problem this created was sprawl. Once a CPU is cheap enough to embed, computing leaves the data center and lands in products, tools and machines nobody in the IT department is tracking. The smallest of those machines soon landed on desks.
What this means for teams today:
- When a capability becomes cheap enough to embed, it spreads into places you didn't plan for. That's true of microprocessors in 1971 and of AI features in 2026.
- Manufacturers felt this first, and you can see it in robotics and automation and digital twin technology.
Personal computers and the spreadsheet (1975-1990)
Personal computing began as a hobby. In January 1975 Popular Electronics put the Altair 8800 on its cover, a $397 computer kit from MITS. Orders flooded in. Apple's Apple II followed in 1977 as a ready-to-use machine for consumers and sold in the millions for nearly two decades.

What turned a hobby into a business purchase was software. VisiCalc, released in 1979, is described by the Computer History Museum as "the 'killer app' that spurred Apple II sales." Dan Bricklin built the first prototype in spring 1978, and it was followed by spreadsheets from Lotus, Microsoft, Borland and others. A finance manager could finally model a budget without waiting for a mainframe slot or a programmer.
Then came the standard. IBM unveiled its Personal Computer on August 12, 1981 at a price of $1,565, and the IBM history page notes that IBM published technical references so other companies could build software and peripherals. The machine used an Intel 8088 chip and an operating system from Microsoft that later became known as MS-DOS. That openness made the PC a de facto industry standard, and other firms reverse-engineered its boot code to make "IBM compatible" machines. In 1984 Apple launched the Macintosh, which the Museum calls the first successful mouse-driven computer with a graphical user interface.
The new problem was fragmentation. Every department built its own spreadsheet, kept its own files and trusted its own numbers. Many teams still live there, and the reasons they leave are laid out in escaping spreadsheets and CRM vs spreadsheet. Connecting those isolated desks was the next job.
What this means for teams today:
- Tools win when the person closest to the work can use them without a specialist. That's the real reason the PC beat the mainframe terminal.
- Standards beat features. The IBM PC's open design created an ecosystem that no single vendor could match.
- Rolling out new software is a people problem first. Employee technology adoption covers what actually moves behavior.
Networked PCs and enterprise software (1990s)
By the 1990s the question was no longer "can everyone have a computer?" but "can their computers talk to each other?" Offices wired their PCs together. Email, shared drives and databases turned individual machines into a company system, and the Internet connected companies to each other. In 1990, at the CERN physics laboratory in Switzerland, Tim Berners-Lee built the first Web browser-editor. The history of the Internet tells that half of the story.
Business software changed shape to match. Instead of one program on one desk, companies adopted systems that held a single record for customers, orders and inventory. That is the idea behind enterprise resource planning (ERP) and customer relationship management (CRM) software. The old tension returned in new form. Centralized data was powerful, but only if everyone put the same information in the same place. It's why modern teams still have to define CRM as a single source of truth and keep it clean with CRM data hygiene.
The new problem was integration. Every system worked in isolation, and moving data between them became a full-time job, which set up the demand for cloud software and application programming interfaces (APIs) in the next era.
What this means for teams today:
- A networked tool is only as good as the shared record behind it. Decide who owns each field before you roll out the platform.
- Treat data quality as an operating routine, not a cleanup project.
Cloud and mobile: computing becomes a service (2006-2015)
On March 14, 2006, AWS launched publicly with the S3 storage service as its only offering, according to Amazon. That date matters because infrastructure stopped being something you bought and became something you rented by usage. A startup could run on the same class of machines as a bank without ordering a single server.

Mobile arrived next. On January 9, 2007 Apple announced the iPhone, which it described as three products in one handheld: a mobile phone, a widescreen iPod with touch controls and an internet communications device. The platform came a year later. In June 2008 Apple said the iPhone 3G ran hundreds of third-party applications already built with its new software development kit. A month later it reported more than 10 million App Store downloads in the first weekend. That turned the phone into a platform. Field sales, delivery, inspection and support work, all the jobs that never sat at a desk, finally had software.
The combination changed buying habits. Teams stopped waiting for the IT department to provision hardware. They started subscribing to software-as-a-service (SaaS) tools with a credit card. That brought speed and a new headache: dozens of apps, overlapping licenses and scattered data. The economics are covered in the SaaS sprawl problem and TCO modeling for SaaS, and the architectural pattern is in the SaaS tech stack. The next workload would strain that rented model harder than any app had.
What this means for teams today:
- Renting capacity moves cost from capital spending to monthly operating spend. Your finance and procurement process has to move with it.
- Mobile is the interface for anyone who doesn't sit at a desk, so design workflows for the phone first for field teams.
GPUs and AI-era systems (2012-today)
The latest chapter is about a different workload. In 2012, Alex Krizhevsky and Ilya Sutskever, graduate students at the University of Toronto working with Geoffrey Hinton, trained AlexNet, an image-recognition neural network, on Nvidia graphics processing units (GPUs) using CUDA, Nvidia's programming system for them, per IEEE Spectrum. The training ran on a computer with two Nvidia cards, using ImageNet, a dataset completed in 2009 by Fei-Fei Li's team. Their entry in the 2012 ImageNet contest won with a top-5 error rate of 15.3%, against 26.2% for the runner-up. It showed neural networks were practical once you had enough data and parallel hardware. The Computer History Museum and Google later released the original source code as open source.
Since then the workload has shaped the hardware. On November 30, 2022, OpenAI released ChatGPT to the public, putting a conversational interface on top of large models. On May 20, 2024, Microsoft introduced Copilot+ PCs, which it describes in its announcement as "a new category of Windows PCs designed for AI," pairing a neural processing unit with the CPU and GPU and claiming 40+ TOPS (trillion operations per second). Intelligence is starting to move back from the data center toward the device, in the same way processing once moved from the mainframe to the desk.
That history connects directly to the history of artificial intelligence. AI didn't replace computing history. It sits on top of faster chips, cheaper memory, bigger storage and global networks, which is the argument in the history of AI. For readers who want the building blocks, start with what an AI chip is, what an AI data center is and on-device AI.
The new problem is cost and control. Running models consumes computing power, energy and budget, and the question of where intelligence should live is a real architecture decision. It could sit in a central platform, inside business applications, on employee devices or inside automated workflows. How AI agents work is a good starting point for the workflow end of that choice.
What this means for teams today:
- Ask where each AI task should run: in the cloud for scale, on the device for privacy and speed, or inside an application for context.
- The skills gap repeats the PC era. The people closest to the work will get the most from AI if they're trained to use it, which is the subject of digital literacy and AI-human collaboration.
Key Facts
Key Facts: The History of Computers
- The 1890 US census used about 60 million punched cards, and an operator could process about 7,000 a day, at least ten times faster than manual methods, per the Computer History Museum.
- ENIAC had almost 18,000 vacuum tubes and lost one roughly every day or two, according to the Computer History Museum.
- The Manchester "Baby" started its first program at 11am on 21 June 1948, and the run took 52 minutes.
- IBM launched System/360 on April 7, 1964, replacing five product lines at a cost of $5 billion over four years.
- Intel's 4004 fit 2,300 transistors into a 16-pin package in 1971.
- The first IBM PC cost $1,565 on August 12, 1981, with 16 kilobytes of memory and no disk drive.
- AWS launched publicly on March 14, 2006 with one service, S3 storage.
- AlexNet won the 2012 ImageNet contest with a 15.3% top-5 error rate against 26.2% for the runner-up.
The Proximity Pattern: four moves that repeat in every era
Looking across 190 years, the same four moves show up every time a new kind of computing arrives. We call this the Proximity Pattern. It's our own synthesis of the history above, not a published study.

- Centralize. When a capability is scarce and expensive, organizations pool it. The mainframe, and today the shared AI platform, are examples.
- Shrink. Hardware gets cheaper and smaller, from the transistor to the chip to the phone, so the capability can move closer to the work.
- Standardize. A shared standard creates an ecosystem: System/360 compatibility, the IBM PC's open design, cloud APIs. The standard decides who builds on top of whom.
- Abstract. A simpler interface hides the machine: the spreadsheet, the graphical interface, the touchscreen, the prompt. Adoption jumps when this happens.
Then the cycle starts again, because the new level of access brings its own sprawl and a new round of centralizing. If you're planning technology for a team, ask which move you're in. A tool still in the Centralize phase needs specialists. One that has reached Abstract can be handed to everyone, with guardrails.
Computer history offers a simple rule for the next decision your team makes about technology: the winners are rarely the fastest machines. They're the ones that put capability within reach of the people doing the work, on a standard others can build on. Start there when you evaluate the next tool, and you'll usually pick well.
Where to go next
Go deeper into the history
- Computer timeline: from the abacus to AI PCs: every major milestone, dated, from counting boards to on-device AI.
- The five generations of computers: vacuum tubes, transistors, chips, microprocessors and the fifth-generation question.
- The history of the abacus and mechanical calculators: from counting boards and Napier's bones to the Pascaline, the Arithmometer and the pocket calculator.
- Charles Babbage and the Analytical Engine: the table problem, the mill and the store, and why his engines waited more than a century to be built or attempted.
- Ada Lovelace and the first computer program: the 1843 Notes, the Bernoulli table in Note G, and the debate over who wrote the first program.
- Hollerith, punched cards and the 1890 census: from Jacquard's loom cards to the census tabulator, the Tabulating Machine Company and IBM's 80-column card.
- Colossus and wartime code-breaking computers: the Polish bomba, the Bombe, Tunny, Tommy Flowers' Colossus and decades of secrecy.
- The history of ENIAC: artillery firing tables, Project PX, the six programmers, the 1946 unveiling and the patent ruling.
- The stored-program computer and von Neumann architecture: from Turing's 1936 paper and the EDVAC report to the Manchester Baby and EDSAC.
- UNIVAC and the first commercial computers: UNIVAC I, Ferranti Mark 1 and LEO I, the 1952 election night and IBM's comeback.
- The history of the mainframe: from census tabulating rooms and defense orders to the 1990s obituary and the z era.
- IBM System/360: the 1961 SPREAD report, the 1964 compatible family, the OS/360 delays and a lineage that still runs.
- The history of the transistor: from crystal rectifiers and 1926 patents to Bell Labs in 1947, silicon, the MOSFET and FinFET.
- The history of the integrated circuit: the wiring crisis, Kilby's 1958 demo, Noyce's planar chip, the patent fight and the foundry age.
- The history of the microprocessor: from many-chip CPUs to Intel's 4004, the IBM PC, RISC and ARM, and multicore.
- Moore's Law: origin and evolution: Gordon Moore's 1965 cost forecast, the industry roadmap, the heat wall and the chiplet debate.
- Who invented the computer?: Babbage, Turing, Zuse, Atanasoff, Flowers, Eckert and Mauchly, and why the answer depends on the definition.
- The history of operating systems: from batch monitors and time-sharing to Unix, DOS, Linux and phone platforms.
- The history of programming languages: from loom cards and Lovelace's notes to FORTRAN, C, Python and prompting.
- The history of cloud computing: the computer-utility idea, time-sharing, rented servers and the AI cloud.
- The history of the personal computer: desk-size precursors, kit machines, the 1977 trio, the IBM standard and the computer everywhere.
- The history of the spreadsheet: clay-tablet ledgers, LANPAR, VisiCalc, Lotus 1-2-3, Excel and the shared cloud sheet.
- The history of the mouse and the GUI: from the memex idea and Engelbart's 1968 demo to Xerox PARC, the Macintosh, Windows and touch.
- The history of the GPU: from Sketchpad and the Geometry Engine to GeForce 256, CUDA, AlexNet and AI accelerators.
- The history of the smartphone: car phones, pen handhelds, the IBM Simon, BlackBerry, the iPhone and the app platform.
Related histories
- The History of the Internet: the networking story that turned PCs into a global system.
- The History of AI: how today's models grew from decades of research.
- The History of Productivity: how each wave of tools changed how we measure output.
- The History of Management: how organizations adapted to the machines.
- The History of Project Management: planning methods that grew alongside computing.
Business systems and data
- What is ERP?: the enterprise descendant of the mainframe.
- Digital transformation strategy: how to plan a technology shift.
- Business intelligence: what organizations do with all that data.
- Robotic process automation: software robots for repetitive work.
AI and the next wave
- Artificial intelligence: a plain-language definition.
- What is business AI?: the foundation of the ACE framework.
- What is an AI agent?: software that acts, not just answers.
- Evolution of business AI: how companies moved from analytics to agents.

Co-Founder, Rework.com
On this page
- Quick timeline of computer milestones
- Counting machines and punched cards (1830s-1930s)
- War, electronics and the first stored programs (1940s)
- Mainframes: computing as an institutional utility (1951-1970s)
- Chips, minicomputers and Moore's Law (1959-1970s)
- Personal computers and the spreadsheet (1975-1990)
- Networked PCs and enterprise software (1990s)
- Cloud and mobile: computing becomes a service (2006-2015)
- GPUs and AI-era systems (2012-today)
- Key Facts
- The Proximity Pattern: four moves that repeat in every era
- Where to go next