In 1943, IBM chairman Thomas Watson allegedly said, 'I think there is a world market for maybe five computers.' Whether or not he actually said this, the sentiment was common—computers were massive, expensive machines for governments and large corporations.

By 1977, that assumption lay in ruins. The Apple II, Commodore PET, and TRS-80 hit the market—affordable computers for homes and small businesses. Within a decade, 'personal computer' went from oxymoron to household term.

This revolution demanded entirely new thinking about operating systems. Time-sharing optimized for many users sharing one expensive machine. Personal computing inverted this: one user, one machine, entirely their own.

Personal computers became possible because of one invention: the microprocessor—an entire CPU on a single integrated circuit chip.

The Intel 4004 (1971):

The first commercial microprocessor was designed for calculators, not computers. But visionaries saw the potential:

Rapid Price Decline:

Moore's Law—the observation that transistor density doubles approximately every two years—meant that computing power became exponentially cheaper:

Price dropped while power increased—within 20 years, a $2000 PC exceeded the capabilities of a $500,000 mainframe.

Early microcomputers had minimal operating systems—often just a BASIC interpreter in ROM. But as systems gained floppy disk drives, a proper disk operating system became essential.

CP/M - Control Program for Microcomputers (1974):

Gary Kildall's CP/M became the first dominant microcomputer OS. It established patterns that would persist through DOS and beyond:

CP/M's Genius: Hardware Abstraction

CP/M's layered architecture solved a critical problem: the microcomputer market was fragmented. Dozens of manufacturers made incompatible hardware. CP/M isolated hardware dependencies in the BIOS, allowing the same software to run on any CP/M machine:

  Application Software
         │
         │ (uses standard BDOS calls)
         ▼
    ┌─────────┐
    │  BDOS   │  ← Same for all machines
    └────┬────┘
         │ (uses BIOS)
         ▼
    ┌─────────┐
    │  BIOS   │  ← Different for each machine
    └────┬────┘
         │
         ▼
      Hardware

Software developers could write once and sell to the entire CP/M market—a precursor to today's platform ecosystems.

MS-DOS / PC DOS (1981):

When IBM built the PC, they approached Microsoft for an operating system. Microsoft purchased QDOS (Quick and Dirty Operating System) from Seattle Computer Products, modified it, and licensed it as MS-DOS (to IBM) and PC DOS (IBM's version).

DOS was heavily influenced by CP/M—similar architecture, similar commands (DIR instead of CP/M's DIR, TYPE instead of TYPE, etc.). The key differences:

DOS Characteristics:

1. Single-Tasking: One program at a time. When you ran a program, it took over completely. To run another program, you had to exit the first.

2. Command-Line Interface: Users typed commands at the C:\> prompt. No built-in graphics—programs could draw directly to screen memory.

3. Real Mode Only: The 8088's limited memory model meant programs could access all memory—no protection.

4. Terminate and Stay Resident (TSR): A clever hack allowing programs to remain in memory after 'exiting', providing primitive multitasking (pop-up utilities, print spoolers).

5. 640KB Limit: Due to IBM's memory map design, only 640KB of RAM was available for DOS programs—the infamous 'conventional memory' limit that plagued PCs for years.

While CP/M and DOS served power users well, they required learning arcane commands. A parallel development would ultimately transform computing: the Graphical User Interface (GUI).

Xerox PARC (1973-1979):

Xerox's Palo Alto Research Center developed breakthrough technologies that defined modern computing: the Alto computer with its bit-mapped display, mouse input, windowing system, and object-oriented programming.

The Alto's interface was revolutionary:

• WYSIWYG Editing: What You See Is What You Get—text on screen looked like printed output
• Windows: Programs ran in rectangular areas that could overlap
• Mouse Navigation: Point and click replaced typing commands
• Icons: Pictures represented files and actions
• Menus: Options appeared when requested, didn't clutter the screen

Apple Lisa (1983) and Macintosh (1984):

The Lisa was Apple's first GUI computer—technically impressive but at $9,995, commercially unsuccessful. The Macintosh, launched in January 1984 at $2,495, brought the GUI to (upper) mainstream consumers.

Microsoft Windows (1985-1995):

Microsoft saw the GUI future but faced a challenge: millions of existing DOS users and software. Windows began as a graphical shell running on top of DOS:

Windows 1.0 (1985): Tiled windows only (couldn't overlap), limited capabilities, slow. Commercial failure.

Windows 2.0 (1987): Overlapping windows, better performance, VGA support. Modest success.

Windows 3.0 (1990): Major redesign. Protected mode support for more memory, improved graphics, program manager. First mass-market Windows success.

Windows 3.1 (1992): Refined, stable, TrueType fonts, OLE. Became ubiquitous in business.

Windows 95 (1995): Revolutionary release. 32-bit support, true preemptive multitasking, long file names, Plug and Play, Start menu, taskbar. Defined the PC interface for a generation.

While Windows 3.x and 95 added GUI sophistication, they remained fundamentally limited by their DOS heritage. Microsoft needed a true modern OS for professional use.

Windows NT (New Technology, 1993):

Microsoft recruited Dave Cutler, the architect of DEC's VMS operating system, to design a completely new OS from scratch. NT was everything DOS-based Windows wasn't:

NT Architecture:

┌─────────────────────────────────────────────────────────────┐
│                    User Mode Applications                    │
├─────────────────────────────────────────────────────────────┤
│  Win32    │  POSIX    │   OS/2    │    Security Subsystem   │
│  Subsystem│  Subsystem│  Subsystem│                         │
├───────────┴───────────┴───────────┴─────────────────────────┤
│                    NT Executive Services                     │
│  ┌─────────┬──────────┬──────────┬──────────┬────────────┐  │
│  │ I/O Mgr │ Obj Mgr  │ Proc Mgr │ Memory   │ Security   │  │
│  │         │          │          │ Manager  │ Ref Monitor│  │
│  └─────────┴──────────┴──────────┴──────────┴────────────┘  │
├─────────────────────────────────────────────────────────────┤
│                    Hardware Abstraction Layer (HAL)          │
├─────────────────────────────────────────────────────────────┤
│                         Hardware                             │
└─────────────────────────────────────────────────────────────┘

Key NT Design Decisions:

While Microsoft dominated the PC market, Unix—born in the time-sharing era—found its way to personal computers through multiple paths.

BSD and University Unix (1970s-1990s):

The University of California, Berkeley extended AT&T Unix with virtual memory, networking (the TCP/IP stack used everywhere today), and the vi editor. BSD (Berkeley Software Distribution) became the Unix of choice for research and engineering.

BSD variants continue today: FreeBSD (servers), OpenBSD (security), NetBSD (portability).

Linux (1991-present):

Linus Torvalds, a Finnish student, began writing a Unix-like kernel for his 386 PC in 1991. Unlike commercial Unix, Linux was freely distributed under the GNU General Public License.

macOS: Unix with a Beautiful Face (2001-present):

When Steve Jobs returned to Apple in 1997, the classic Mac OS was showing its age—no modern memory protection, no preemptive multitasking. Apple needed a new foundation.

The solution came from NeXT, Jobs's company during his exile from Apple. NeXTSTEP was built on Mach (a microkernel from CMU) and BSD Unix. Apple combined these into Darwin, the open-source Unix core of macOS:

┌─────────────────────────────────────────┐
│              macOS Applications          │
├─────────────────────────────────────────┤
│  Cocoa/Cocoa Touch    │    Carbon       │
├─────────────────────────────────────────┤
│              Core Services               │
│    (CoreFoundation, Security, etc.)     │
├─────────────────────────────────────────┤
│           Darwin (XNU Kernel)            │
│  ┌─────────────────┬─────────────────┐  │
│  │   Mach Kernel   │   BSD Layer     │  │
│  └─────────────────┴─────────────────┘  │
└─────────────────────────────────────────┘

macOS demonstrates that Unix can power an intuitive consumer OS. The same Darwin kernel underlies iOS, iPadOS, watchOS, and tvOS—Unix runs on billions of Apple devices.

The personal computer era led to remarkable operating system diversity. By the mid-200os, three major families dominated:

Windows Family:

• Desktop dominance (90%+ market share at peak)
• Windows NT kernel across consumer and server
• Strong backward compatibility emphasis
• Proprietary, commercial model

Unix/Linux Family:

• Server and supercomputer dominance
• Mobile dominance (Android uses Linux kernel)
• Open-source development model
• Fragmented into distributions (Ubuntu, Red Hat, Debian, etc.)

Apple Family:

• Premium consumer market
• Darwin kernel (Mach + BSD)
• Tight hardware-software integration
• Proprietary, vertically integrated model

The personal computer era established user interface paradigms that remain dominant today. Let's examine the key elements that emerged and their evolution:

The Desktop Metaphor's Longevity:

Despite being over 40 years old, the desktop metaphor persists:

• Files look like paper documents
• Folders organize files hierarchically
• The trash/recycle bin holds deleted items
• The desktop is a workspace for current work

Attempts to replace this metaphor (like Windows 8's full-screen Start) faced user resistance. The desktop metaphor succeeded because it mapped computing concepts to familiar physical objects, reducing cognitive load.

Touch and Beyond:

Mobile computing introduced new idioms—swiping, pinching, long-pressing—but didn't eliminate WIMP concepts. Rather, it adapted them. iOS and Android still use windows (now fullscreen), icons, and a form of pointer (the finger). The PC-era foundations remain.

The personal computer revolution transformed computing from an institutional resource to a personal tool. Operating systems evolved to match, prioritizing individual productivity over shared resource management:

What's Next:

The personal computer brought computing to the home and office. The next evolution would bring it everywhere else—into cars, appliances, factories, and pockets. The final page explores modern OS evolution: mobile computing, cloud infrastructure, containers, and the emerging patterns that will define operating systems for the next generation.