The History of IT: From the Abacus to the AI-Native Era
A sourced, comprehensive history of information technology: hardware, software, cloud, vendors, licensing, and trends. Why each layer exists, what became legacy, and the risk lessons every builder should learn from.
Information technology is not only software and architecture. It is also hardware, vendors, contracts, licenses, and the slow politics of what an organization can and cannot stop using. This guide tells that whole story in one place, from the abacus to AI agents, and it does something a normal timeline does not: it explains why each layer exists, when each idea genuinely appeared (with the original source), what later became legacy, and the risk lessons that keep repeating. If you only learn the new thing without its history, you are likely to repeat a mistake someone already made.
This article is the written companion to the interactive IT history timeline , where you can filter by lifecycle state, follow legacy-to-successor connections, and open the primary source behind every date. For the pure beginner hardware story, start with a short history of computing . For the architecture-specific deep dive, see the history of software architecture .
The one pattern that explains all of it
Read the timeline below and the same shape repeats in every era. A constraint appears or lifts, and the dominant design moves to match it.
- Computers were rare and expensive, so one mainframe served many terminals.
- Cheap microprocessors put a computer on every desk, so work moved off the mainframe.
- The web connected those desks to the world, so businesses moved online.
- Web-scale traffic and large teams broke the monolith into services.
- Rentable cloud made elastic, pay-per-use the default.
- Transformer models turned data into general capability, and AI moved into the stack.
Architecture rarely changes for fashion. It changes when the cost of hardware, the reach of the network, the scale of demand, or the structure of teams makes the old shape too expensive. The same is true of vendors and licenses, which is the part most histories skip.
The eras at a glance
The timeline
The driver: calculation was done by hand. Each device automated one more step of arithmetic or logic, building the ideas electronic computers would later run.
- 1804The Jacquard loom and the punched card
A loom controlled by a chain of punched cards. Changing the cards changed the woven pattern.
Why It was the first stored, interchangeable set of instructions, the seed of the program. It led directly to Babbage's engines and to the punched cards that built IBM.
- 1843Ada Lovelace's algorithm
A published method for computing Bernoulli numbers on Babbage's unbuilt Analytical Engine.
Why It showed a machine could manipulate any symbol, not only numbers. That is the idea behind every application.
- 1936The Turing machine
Alan Turing defined what is computable and described a universal machine that could run any program.
Why It is the theoretical blueprint of the general-purpose computer, the reason one device can run any software.
The driver: vacuum tubes then the transistor let machines compute with electricity instead of moving parts. Computing went from lab experiment to commercial machine.
- 1945ENIAC and the stored-program design
ENIAC, with about 17,000 vacuum tubes, ran in 1945. The same year, von Neumann described keeping program and data in one memory.
Why The von Neumann architecture is still how nearly every computer works, from your phone to a data center.
- 1947The transistor
Bell Labs demonstrated a small, solid electronic switch with no fragile glass or moving parts.
Why It is the fundamental building block of all modern electronics and every chip.
- 1957-59FORTRAN and COBOL
The first widely used high-level languages, for science (FORTRAN) and business (COBOL).
Why They made programming usable beyond machine-code specialists. COBOL still runs core banking and government systems today, a vivid example of accepted legacy.
The driver: computers were rare, huge, and expensive, so one central machine served many users. Shared architectures, the relational database, and the first networks appeared.
- 1964IBM System/360
The first family of computers to share one architecture across many machine sizes.
Why It created the idea of an instruction set that outlives any single machine. IBM Z mainframes still run that lineage, which is exactly why so much critical software cannot be moved off it.
- 1969-74Unix, the relational model, and TCP/IP
Unix (1969) shaped operating systems. Codd's relational model (1970) gave databases a rigorous foundation. Cerf and Kahn's TCP/IP (1974) let networks interconnect.
Why Three of the most durable ideas in computing. They underpin Linux, every SQL database, and the internet itself.
The driver: cheap microprocessors put a computer on every desk. Work moved off the central machine, and open standards let independent vendors build a whole ecosystem.
- 1981The IBM PC
An open, documented architecture that let third parties build compatible hardware and software.
Why Openness created the PC ecosystem and Microsoft's dominance through MS-DOS and Windows.
- 1983-89GNU and the GPL
Richard Stallman launched the GNU Project (1983) and published the GPL (1989), the copyleft license.
Why This is the legal foundation of open source. Understanding it is the start of understanding the license wars 30 years later.
- 1989-91The World Wide Web and Linux
Tim Berners-Lee proposed the web at CERN (1989); CERN put the code in the public domain in 1993. Linus Torvalds released Linux (1991).
Why A free web standard and a free operating system kernel became the backbone of everything that followed.
The driver: the web connected personal computers to the world. Browsers, open-source servers, and the first internet businesses defined the dot-com era.
- 1995Java, JavaScript, PHP, MySQL, Apache
A wave of languages and open-source servers arrived in a single year.
Why They made dynamic, database-backed websites cheap to build, and the open-source LAMP stack powered the early web.
- 1999-2001Salesforce, VMware, and REST
Salesforce delivered software as a subscription (SaaS). VMware made x86 virtualization practical. Roy Fielding defined REST.
Why SaaS, virtualization, and simple web APIs are three of the pillars the cloud was about to be built on.
The driver: renting computing by the hour replaced buying servers. Amazon, Google, and Microsoft turned infrastructure into a utility, and the smartphone put it in every pocket.
- 2006AWS launches, and "cloud" gets its name
Amazon launched S3 (March) and EC2 (August). Google's Eric Schmidt popularized the phrase "cloud computing" the same year.
Why Pay-as-you-go infrastructure removed the need to buy hardware upfront, which reshaped how every company builds software.
- 2007-08iPhone, Android, and GitHub
The smartphone launched the mobile-first era. GitHub made collaborative coding social.
Why Mobile became the dominant way people reach software, and GitHub became the center of how it gets built.
The driver: containers and orchestration made software portable and elastic. Teams adopted DevOps, microservices, and automation to ship continuously at scale.
- 2013-14Docker, Kubernetes, Terraform
Docker (2013) made containers easy. Kubernetes (2014) orchestrated them. Terraform (2014) defined infrastructure as code.
Why Containers are the newer abstraction that largely replaced full virtual machines for packaging apps, the layer above what VMware pioneered.
- 2017The Transformer
Google's paper "Attention Is All You Need" introduced the Transformer architecture.
Why It made models highly scalable and is the direct foundation of every modern large language model.
The driver: transformer models turned data into general capability, while a wave of relicensing and vendor consolidation reminded everyone that IT is contracts as much as code.
- 2022-23ChatGPT and frontier models
ChatGPT (2022) brought generative AI to the mainstream. GPT-4 and Claude launched the same day in March 2023.
Why Capable models became a competitive platform layer for building applications, the way the cloud became a platform layer before it.
- 2023HashiCorp's BSL and Broadcom's VMware
HashiCorp relicensed Terraform to the source-available BSL, prompting the OpenTofu fork. Broadcom bought VMware and ended perpetual licenses.
Why Two reminders in one year that the license and the contract, not just the technology, decide your real cost and your freedom to leave.
The timeline above is a selection. The interactive timeline holds the full set of milestones with primary sources, lifecycle states, and connections.
How technology dies (the lifecycle thread)
Nobody outside IT understands why a bank still runs software from the 1980s. The reason is that technology does not die all at once. It fades through stages, and at each stage the cost of leaving rises.
Windows XP (2001) reached the “legacy, still running” stage and stayed there for years past its 2014 end of support, because ATMs and industrial machines were too costly to migrate. Mainframes and COBOL are the same story at a larger scale. At the other end, Adobe Flash and Google Reader were discontinued outright. The full treatment, with how to plan for it, is in how technology dies: the service lifecycle .
IT is contracts, not just code (the legal thread)
The part of IT history that beginners never hear is that a technology choice is also a legal choice. The code can be excellent and the contract can still ruin you.
- SAP was founded in 1972 by five ex-IBM engineers to run finance, supply chain, and HR on one connected data model. Its R/3 suite (1992) became the system of record for much of the global economy. That is exactly why SAP is “like it is” today: sprawling, expensive, and very hard to leave, because it sits at the center of how a company actually runs.
- Broadcom and VMware. VMware’s x86 virtualization (from 1999) made the cloud economically possible. After Broadcom completed its acquisition on 22 November 2023, it ended perpetual licenses within weeks and moved to subscription-only bundles. Companies locked into VMware faced sharp price increases with no quick exit.
- HashiCorp and Terraform. On 10 August 2023, HashiCorp relicensed Terraform from open source to the Business Source License. The community responded by forking it into OpenTofu under the Linux Foundation. The same pattern hit MongoDB (2018), Elastic (2021), and Red Hat’s CentOS (2020).
The lesson is that you should treat the license and the exit cost as first-class criteria, not an afterthought. The full history and a protection checklist are in software licensing and vendor lock-in .
Why Dynatrace started exactly when AWS did
This is a good example of history explaining the present. Dynatrace was founded in 2005. AWS launched S3 and EC2 in 2006. That timing is not a coincidence.
Before the cloud, debugging meant logging into the one server your app ran on. As applications moved to cloud infrastructure and split into many services across many machines, that approach broke. You could no longer see the whole transaction from one place. Application performance monitoring, and later observability, arose precisely to trace a single request as it crossed dozens of services. The cloud created the problem that observability solves, which is why the two industries grew up together. To go deeper, see observability .
Is virtualization expensive legacy now?
The honest answer: it depends on whether you can leave. Virtualization itself is not obsolete. It still runs underneath most of the cloud. But the VMware product, after Broadcom’s licensing changes, has become an expensive commitment for organizations that cannot move off it. Containers (Docker and Kubernetes) are the newer abstraction for packaging and running applications, and some teams are moving to open hypervisors like Proxmox or KVM, or to public cloud. So for a company that is locked in and cannot migrate, yes, it has become expensive legacy. For one that can, it is just one option among several. See virtualization fundamentals for the technical picture.
Where trends come from (and how to read them)
If you want to know what is rising and what is fading, you need to know where the signals are. The most cited is Gartner, the analyst firm founded in 1979. Its Magic Quadrant plots vendors on two axes, completeness of vision and ability to execute, sorting them into Leaders, Challengers, Visionaries, and Niche Players. Its Hype Cycle, introduced by Jackie Fenn in 1995, charts how expectations for a new technology rise to a peak, crash into a trough, and then recover to a realistic plateau.
These tools are useful and also much debated, because vendors pay to engage with analysts and because hype is hard to separate from substance. Other signals worth tracking include the ThoughtWorks Technology Radar, the CNCF landscape, and the Stack Overflow Developer Survey. The full guide is how to read technology trends .
The mistakes that keep repeating
History is most useful as a list of errors you do not have to make again.
| Lesson from history | The mistake | How to avoid it |
|---|---|---|
| Lock-in is a contract risk | Building on VMware or a single cloud with no exit plan | Treat exit cost and license terms as first-class selection criteria |
| Free tiers can vanish | Depending on Google Reader or free CentOS for production | Have a paid or self-hostable fallback for anything critical |
| Open source can be relicensed | Assuming Terraform or Elasticsearch will stay open forever | Prefer foundation-governed projects; watch who controls the license |
| Legacy is a slow trap | Letting Windows XP or a mainframe app become un-migratable | Budget for migration before the cost of staying exceeds the cost of leaving |
| Hype is not adoption | Buying the peak of a hype cycle | Wait for the slope of enlightenment; pilot before you commit |
| Dependencies are your risk | Ignoring a deep library like Log4j until it breaks | Maintain a software bill of materials and patch plan |
Further reading
- The History of IT: interactive timeline : every milestone, filterable by lifecycle, with the original source behind each date.
- A short history of computing : the beginner hardware story, from the abacus to the chip.
- The history of software architecture : the architecture-specific deep dive from mainframes to AI-native.
- How technology dies: the service lifecycle : the maintained-to-legacy lifecycle and how to plan for it.
- Software licensing and vendor lock-in : the legal history every builder should know.
- How to read technology trends : Gartner, the hype cycle, and where to find real signal.
- Computer History Museum: Timeline of Computer History : the definitive public history of computing.