The problem: an expensive machine sitting idle
The earliest electronic computers had no operating system in the modern sense. A programmer often reserved time on the machine, loaded a program, watched it run, and then left so that the next person could do the same. Setting up each job took time, during which the costly computer did no useful work.
As machines grew more expensive and more people wanted to use them, the waste became obvious. The solution was software that could take over routine duties: loading jobs, handling input and output, and keeping track of resources. That kind of software is what we now call an operating system.
Early monitors and batch processing
In the 1950s, some organizations wrote small supervisory programs, often called monitors, to automate the steps between jobs. A widely cited early example is a system developed by General Motors and North American Aviation users of the IBM 704, usually described as one of the early operating-system-like programs. Credit for the “first” operating system is hard to assign, because many sites built similar tools around the same time.
The key idea of this period was batch processing. Programs and their data were gathered, often on punched cards, and submitted to the machine as a group. The system ran them one after another with little pause, and the results were returned later as printouts. Users had less direct contact with the computer, and a mistake might not be discovered until hours after submitting the job. Even so, batch processing kept expensive hardware busy, which was the point.
Libraries, languages and standard tasks
Operating systems also grew out of the practical need to share common code. Early programmers wrote their own routines for reading cards or printing results. It made more sense to provide these routines once, and for the system to handle devices on the program’s behalf. As higher-level programming languages such as FORTRAN spread in the late 1950s, systems also had to manage compilers and the steps for running translated programs.
This is a good example of what an operating system is for: hiding hardware details and offering a consistent set of services, so each program does not have to reinvent them.
Multiprogramming and the big mainframe systems
In the early 1960s, designers found ways to keep more than one program in memory at a time. While one waited for a slow device, such as a tape or printer, the machine could switch to another. This is called multiprogramming, and it made better use of the processor.
IBM’s System/360 family, announced in the mid-1960s, was meant to offer a range of compatible machines, and it needed a common operating system. The effort to build OS/360 became famous for being large, late and difficult, and it inspired Frederick Brooks’s well-known book about managing software projects. The experience taught the industry lessons about the real cost and complexity of system software.
Time-sharing
Batch processing was efficient for the machine but frustrating for people. Time-sharing took a different approach: many users, each at a terminal, could use one computer at once, because the system switched between them so quickly that each seemed to have the machine to themselves.
Researchers at MIT demonstrated the Compatible Time-Sharing System in the early 1960s, and other universities and companies pursued similar work. The Multics project, started in the mid-1960s by MIT, Bell Labs and General Electric, aimed to build a large, secure, shared system. It was ambitious and influential, though it did not achieve wide commercial success.
Time-sharing matters because it changed how people thought of computers: not as a distant service that returned printouts, but as something interactive. It also required features that are now standard, including protection between users, scheduling, and a way to manage files.
Unix and portability
After stepping back from Multics, some Bell Labs researchers, including Ken Thompson and Dennis Ritchie, built a smaller system that became Unix around 1969 and the early 1970s. It was designed to be simple and flexible. When it was rewritten largely in the C language, a milestone for systems programming, it became much easier to move to different types of hardware. Universities adopted it widely, and many later systems borrowed from its ideas, either directly or by imitation.
Operating systems for microcomputers
When microprocessors made small personal machines possible in the mid-1970s, those computers needed software too. CP/M, created by Gary Kildall, became a common operating system for early microcomputers. In 1981 the IBM PC launched with an operating system from Microsoft, known as MS-DOS or PC-DOS depending on the version, and it became very widespread.
Meanwhile, the graphical interface changed expectations. Apple’s Macintosh in 1984 brought a graphical system to a mass market, and Microsoft Windows followed in the mid-1980s, gaining popularity over the following decade. These systems put the operating system in front of ordinary users, who now interacted with it every day rather than leaving it hidden.
Mobile and beyond
Smartphones in the 2000s ran operating systems designed for touchscreens, battery limits and constant network access. Much of the underlying design still reflects older ideas, including multitasking and protection between programs. Many servers and embedded devices today run Unix-like systems, which shows how long some of these ideas have lasted.
The constant purpose
Operating systems have changed in appearance and scale, but their central job has stayed much the same: to share the machine’s resources fairly and safely, and to give programs and people a simpler way to use hardware. The history is a story of repeatedly asking how to waste less of a scarce resource, whether that was machine time in the 1950s or user attention today.