Long before electronic computers, societies needed reliable arithmetic for trade, astronomy, and taxation. The abacus, used across Mesopotamia, China, and Rome, encoded place value in beads slid on rods — a tangible algorithm for addition and subtraction that trained users in systematic calculation rather than memorization alone.

In the seventeenth century, Blaise Pascal and Gottfried Leibniz designed mechanical calculators that performed repeated addition through geared wheels. These devices were fragile and expensive, yet they demonstrated that arithmetic could be mechanized. Charles Babbage's Analytical Engine (1830s concept) proposed program-controlled operation via punched cards borrowed from Jacquard looms — an architectural idea that would reappear a century later as stored-program computers.

Human computers — often women mathematicians — performed manual computations for navigation tables and ballistics through the early twentieth century. Their labor underscores that "computing" was originally a human profession; machines later augmented and eventually replaced much of that repetitive work, shifting human roles toward programming, verification, and interpretation of results.

World War II accelerated demand for rapid cryptanalysis and fire-control calculations. Colossus (1943–1945, Bletchley Park) used vacuum tubes to break Lorenz cipher traffic; ENIAC (1945, U.S.) was a general-purpose electronic calculator weighing tons and consuming enormous power. Both proved that vacuum-tube switching could outperform mechanical speed limits, though reliability and programming remained painful.

Alan Turing's 1936 paper on computable numbers defined a theoretical machine capable of executing any algorithm given sufficient tape and time — the Turing machine model still underpins computer science curricula. John von Neumann's 1945 report described stored-program architecture: instructions and data reside in the same addressable memory, enabling programs to modify themselves and loaders to bootstrap operating systems.

Postwar institutions — universities, national laboratories, and corporations — funded research that miniaturized components and standardized programming. The shift from custom wiring panels to stored programs made software a durable asset separate from hardware, laying the economic basis for the software industry.

The transistor (Bell Labs, 1947) replaced fragile vacuum tubes with solid-state switches, shrinking size and power while improving reliability. Mainframe computers such as IBM's System/360 (1964) offered families of compatible machines and operating systems — a business strategy that reduced customer migration risk and established IBM's dominance in enterprise computing for decades.

Early operating environments were batch-oriented: operators queued jobs on punched cards or tape, and the machine executed them sequentially with minimal interactive feedback. Time-sharing experiments in the 1960s multiplexed one processor among many terminals, giving multiple users the illusion of dedicated machines and foreshadowing modern multi-user servers.

High-level languages (FORTRAN, COBOL, later C) abstracted hardware details so programmers could express algorithms in portable syntax. Compilers translated source code into machine instructions, accelerating development and creating a software supply chain distinct from hardware manufacturing.

Intel's 4004 (1971) demonstrated that entire CPUs could fit on a single chip. The Altair 8800 (1975) sparked hobbyist kits; Apple II (1977), Commodore PET, and Tandy TRS-80 brought color graphics and expansion slots to homes and schools. IBM's PC (1981) used an open architecture with licensed DOS from Microsoft, unintentionally enabling a clone market that commoditized hardware.

Graphical user interfaces, pioneered at Xerox PARC and commercialized by Apple Macintosh (1984) and Microsoft Windows (1990s), replaced command-line memorization with pointers, windows, and icons for mainstream users. Desktop publishing and spreadsheet software (VisiCalc, Lotus 1-2-3, Excel) turned PCs into business appliances, not only hobby machines.

Moore's Law — the observation that transistor density roughly doubles every two years — guided industry roadmaps for decades. While physics and economics now complicate scaling, the cultural expectation of ever-cheaper compute capacity shaped consumer software design, from bloated applications to cloud offload of heavy processing.

ARPANET (1969) linked research sites with packet switching — breaking messages into packets that could reroute around failures. TCP/IP (1980s standardization) became the lingua franca of internetworking; the Domain Name System (1983) mapped human-readable names to numeric addresses, scaling the internet beyond memorized IP lists.

Tim Berners-Lee's World Wide Web (1989–1991) added hypertext documents and URLs atop the internet, not replacing TCP/IP but making information publishing accessible. Browsers (Mosaic, Netscape, Internet Explorer, later Chrome and Firefox) turned the web into a platform for commerce, media, and applications delivered without local installation.

Smartphones fused cellular radios, sensors, and app ecosystems. Apple's iPhone (2007) and Google's Android (2008) shifted internet access from desktop-first to mobile-first, influencing API design, responsive web layout, and security models centered on app sandboxes and biometric unlock. Cloud data centers now back most mobile experiences with synchronized accounts and push notifications.