There is no widely accepted definition of what an OS is. Rather, there are a bunch of ideas that describe what an OS should do which are useful to understand.

One way of explaining this is describe the operating systems in terms of the roles it should play:

Referee

It needs to manage the protection, isolation and sharing of resources, ensuring that different applications all behave in the best way possible to allow tasks to be done effectively.

Tasks as a referee include:

• Resource allocation
• Communication

Illusionist

Provide clean easy to use abstractions of physical resources so that software does not need to meddle with the complexities of the hardware layer.

Tasks as an illusionist include providing the illusion of:

• Infinite memory
• Higher level objects
• Masked limitations

Some of the abstractions (of hardware) that the operating system provides are:

Processor → Thread

Memory → Address Space

Disks → Files

Networks → Sockets

Machines → Processes

This is the best way to think about these components of the operating system: as a bridge between the software and the hardware.

Glue

Provide common services that all applications can use to provide a cohesive front to applications.

Some services it provides include:

• Storage
• Networking
• Window System and Design
• Sharing, Authorisation

Evolution of Operating Systems

Operating systems have evolved from manual hardware control in the 1940s to today’s cloud-native, AI-integrated platforms. Their journey reflects the growing complexity of computing, shifting from batch processing to multitasking, graphical interfaces, mobile ecosystems, and now containerized, distributed environments.

Early Stuff

• Pre-OS Era (1940s–1950s): Machines like ENIAC required manual rewiring or punched cards. Programs directly controlled CPU, memory, and I/O, with no multitasking or abstraction layers.
• Batch Processing (1956): GM-NAA I/O introduced automated job handling. Programs were queued and executed sequentially, reducing operator workload.
• Multiprogramming & Timesharing (1960s): Systems like CTSS (1961) and Multics (1969) allowed multiple users to share resources. This introduced process scheduling, memory partitioning, and I/O buffering, laying the groundwork for modern multitasking.
• Unix (1971): Portable, modular, and multitasking. Its design principles—hierarchical file systems, process isolation, and device abstraction—became the blueprint for modern OSs.
• Standardization: IBM’s OS/360 unified mainframe software, introducing consistent APIs and resource management.

Closer to today

• Personal Computing: CP/M (1974) and MS-DOS (1981) simplified OS design for microcomputers, focusing on command-line interfaces and basic file management.
• Graphical User Interfaces: Apple Macintosh (1984) and Windows (1985) popularized GUIs, shifting focus from command-line to user-friendly interaction.
• Networking Integration: TCP/IP became standard in Unix systems, enabling distributed computing and the rise of the Internet.
• Linux (1991): Open-source, community-driven development introduced modular kernels, extensibility, and widespread adoption in servers.

Mobile and Cloud

• Mobile OSs: iOS (2007) and Android (2008) redefined interaction with touch interfaces, app ecosystems, and energy-efficient scheduling.
• Virtualization & Containers: VMware, Docker, and Kubernetes enabled resource isolation, scalability, and microservices architectures, transforming OSs into orchestrators of distributed systems.
• Cloud-Native OSs: Modern platforms emphasize elastic resource allocation, security hardening, and integration with AI/ML workloads.
• AI Integration: Voice assistants (Siri, Alexa, Google Assistant) embedded into OSs, leveraging predictive algorithms and natural language processing.

Future Directions

• Quantum OSs: Managing qubits and hybrid classical-quantum workloads.
• Sustainable Computing: Energy-aware scheduling and green data centers.
• Self-Healing Systems: AI-driven fault detection and autonomous recovery.