Understand the historical developments in the evolution of the operating system
Discuss the evolution of operating systems, and explain each major achievement
Operating System Services
A computer is a set of resources for the movement, storage, and processing of data. The OS is responsible for managing these resources and for providing convenient access to them. The OS is a program that controls and manages the execution of application programs, and it serves as an interface to the system hardware. Some functions supported by the OS include:
Access to I/O devices
Controlled access to files
Error detection and response
Historical OS Developments
Pre-Operating System Computers
The earliest computers had no operating system at all. Programmers had to code directly to the hardware, and there were no programming languages or library functions that could be called -- all machine code was generated by hand. Some of these early computers were called "serial processing systems," because they ran only one program at a time. Many functioned like complex calculators, with programs to develop tables to accurately fire artillery and other long-range guns.
The Mark I computer (image: Harvard University).
User programs had access to the computer one at a time, in series. A great deal of setup and programming time was required. Pioneers like Grace Hopper wrote programs for early systems such as the Mark I, Mark II, and Mark III, as well as ENIAC and UNIVAC (see her describe Mark I/II around the 30-minute mark here). She advocated for development of programming languages that would use English-language statements, rather than only mathematical symbols, and the development of compilers to translate them into machine code. Hopper also was influential in the development of COBOL, the first widely-used compiled programming language.
With the earliest computers, the programmer had to access the machine directly, often wasting precious time setting up a program to run. The first step in the evolution of the OS was the creation of batch systems. A batch is a job or program that can run to completion unattended.
Batch systems featured a special supervisor program called the monitor. The monitor was a very simple program that sequenced the user jobs. The monitor remained in memory at all times. User jobs would only be in memory while they were running.
Batch systems had several important differences from their predecessors:
User no longer has direct access to the processor
Monitor is always in memory
Operator batches jobs together and places them on an input device
Each program branches back to the monitor when finished
Monitor runs in kernel mode, user jobs run in user mode
An example of this kind of system is the IBM 701 (~1953):
The problem with simple batch systems was one of efficiency. When the currently running program was waiting for some event, the CPU sat idle. The batch monitor could sequence from one job to the next only when a job terminated. Even worse, should a job fail to terminate, it would hold up all the jobs behind it. An operator would need to manually terminate the job and re-queue the ones behind it.
In multiprogramming systems, memory is expanded to hold multiple programs at once. Execution of the jobs is interleaved, but not very rapidly (the 'time quantum' is relatively long, perhaps on the order of seconds). Multiprogramming systems were not interactive (i.e., no user command shell/terminal). An example is the UNIVAC 1107:
Batch multiprogramming systems had the following characteristics:
Programs, or "jobs," are not interactive with the terminal/user
A controller switches between the jobs without waiting for program completion
The folowing image illustrates the multiprogrammed execution of three different programs on a multiprogramming system:
Note that multiprogramming is not the same as multiprocessing. In batch multiprogramming systems, there is still just a single processor, but there is more than one job in memory, ready to run, at any given time. This means the processor does not have to sit idle if one program, for example, is waiting on input.
Multiprogramming: having more than one program in memory at a time, ready to run (Note: not the same as multiprocessing).
As computers became more powerful, users and programmers wanted a way to interact with their programs. However, doing so could hold up all the running jobs in a multiprogramming system, while it waits for user input. To address this limitation, time-sharing systems were created. They can be used to handle multiple interactive jobs at the same time. Execution is interleaved over a short time quantum, so that each user has the illusion of full access to the system's resources. Users accessed the system via a terminal, and one system could support multiple terminals at the same time. At a time when time on a computer was very expensive, time-sharing systems also facilitated the idea of charging user accounts based on the amount of total time they used on the machine.
Processor time is shared among multiple users
Multiple users simultaneously access system terminals
OS interleaves the execution of each user program in a short burst, or quantum, of computation
An example time-sharing system is the CTSS / IBM7094 (mid-late 1960s):
Time sharing systems of the 1960s brought the OS to the precipice of the modern era of computing, which evolved beginning in the 1970s and 1980s. In the next section, we list a few of the important features that remain ubiquitous in almost all modern operating systems.
Modern OS Developments
In recent decades, there have been several important developments that are now common to all major operating systems.
The concept of a process is fundamental to the modern OS. All modern operating systems include some notion of a process.
Definition. A process can be defined in a number of ways:
A program in execution
An instance of a running program
The entity that can be assigned to, and executed on, a processor
A unit of activity characterized by at least one sequential thread of execution, a current state, and an associated set of system resources
Components. A process contains three main components:
An executable program
The associated data needed by the program
The execution context of the program
Execution Context. The execution context is internal data the OS uses to supervise and control a process, such as:
Status: run, suspend, blocked, etc.
The OS will itself be composed of processes, many running in kernel (privileged) mode of the CPU. These, in turn, will manage all the user processes, running in the unprivileged mode of the CPU.
Multiprocessing is where more than one execution unit exists in the hardware -- either multiple 'cores' on one CPU, multiple CPUs in one system, or both. Through appropriate scheduling of processes, the OS can take advantage of a multiprocessing architecture.
Multithreading is the subdivision of a process into smaller units of execution, called threads, which may run concurrently. Whereas a process contains one or more threads and associated system resources, a thread is a single dispatchable unit of work, which includes the process' context. Each thread must belong to a process.
The fundamental difference between processes and threads is that a process is generally considered a unit of resource allocation and protection, whereas a thread is just a unit of execution. On most systems, threads don't own resources by default; they generally share the resources of their parent process.
When multiple processes or threads can run in parallel, a number of concurrency challenges arise. Synchronization and communication among processes and threads executing in parallel are two of the major design challenges of the modern OS.
Object Oriented Design
Modern programming languages like Java, C++, C#, and Swift permit object-oriented design, which can make development simpler and improve OS extensibility. The use of object-oriented programming (OOP) varies widely by OS. As the modern operating system code base grows into hundreds of millions of lines of code, the employment of OOP could make a significant difference in OS maintainability.
An operating systems kernel space can be characterized as employing a monolithic or a microkernel design, according to the following definitions:
Monolithic Kernel: a large kernel containing virtually the complete operating system, including scheduling, file system, device drivers, and memory management. All the functional components of the kernel have access to all of its internal data structures and routines. Typically implemented as a single process, with all elements sharing the same address space. Historically, the monolithic kernel characterization was the most common, and is the appropriate label for popular operating systems such Microsoft Windows, Linux, and Android.
Microkernel: a design in which the OS kernel is as small and simple as possible, performing a minimum of essential tasks. Other functions, like device drivers, I/O protocols, and file system implementations, are run as separate modules, usually in User mode. Examples include the Mach kernel (used in Mac OS), MINIX (precursor to Linux), and QNX (used in embedded systems)
Pros and Cons. In recent decades, some researches have asserted the benefits of the more modular, microkernel design. A monolithic kernel may be easier to develop, at least initially, and may very well have some performance benefits, due to fewer transitions between kernel and user mode. Compared to a microkernel design, though, a monolithic kernel's complexity may make it difficult to manage. Also, a crash in one element of a monolithic kernel may be able take down the whole system. On the other hand, a well-design microkernel-based system should be more modular, simple, scalable, and even more secure. For an interesting debate between Tanenbaum and Torvalds on monolithic kernel vs. microkernel design, check out this link.
Virtualization and Containerization
Virtualization allows a single computer or server to simultaneously run multiple different host operating systems at the same time. There are two basic types:
Type I - VMM/Hypervisor runs on hardware. Examples: VMware ESX, Xen
Type II - VMM/Hypervisor is 'hosted' as an application in another OS. Examples: VMware Workstation, Parallels, VirtualBox
Containerization is a technique for bundling up an application with all the resources it needs to execute. This is much more lightweight than using a full virtual machine (VM), because a container contains only the components an application needs, and nothing more. Containerization is efficient and popular for 'cloud' server deployments. Two popular container technologues are Docker and Kubernetes.
Docker describes its technology this way: "A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another. A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings."
Notable Operating Systems
There have been a number of noteworthy commercial and open-source operating systems developed over the years. Here are a few:
MULTICS. MULTICS (Multipexed Information and Computing Service) was developed as a time-sharing OS for computers built by GE and Honeywell. It was the first OS to introduce dynamic linking, in which needed library code could be mapped into memory as needed, instead of being statically compiled in to a binary executable. It also pioneered the use of multiple levels of hardware execution privilege, or 'rings', and a hierarchical (tree-structured) file system. MULTICS was developed using PL/1, a numerically-focused procedural programming language. Two MULTICS programmers, Ken Thompson and Dennis Ritchie, went on to design Unix, bringing with them the ideas from MULTICS that they liked.
Unix. Unix begain as UNICS, a play on words from its predecessor (Uniplexed Information and Computing Service), because its initial focus was for smaller, simpler system. The original version was developed at Bell Labs for AT&T. It was developed almost entirely in the (then new) C programming language, which was initally standardized by Kernighan and Ritchie. Unix features a modular design, and over time developed support for multitasking and multiple users. many variants followed, and almost all modern operating systems inherit some technology from it. Unix also recently celebrated its 50th anniversary!
CP/M. CP/M was developed primarily by Gary Kildall as an OS for personal computers based on early 8-bit Intel processors. It featured a an I/O system (Basic Input/Output System, or BIOS), disk controller (Basic Disk Operating System, or BDOS), and command interpreter (Console Command Processor, or CCP).
MS-DOS. In 1980, IBM was looking for an OS for its upcoming family of personal computers. Talks with CP/M, which was viewed as a leading candidate, were unsuccessful, but Bill Gates and Microsoft were able to strike a deal for their MS-DOS system, which borrowed (some say cloned) many of CP/M's features. MS-DOS pioneered the FAT (file allocation table) file system, which was simple and portable. MS-DOS ran on systems based on the Intel 8086 processors.
Microsoft Windows. Windows evolved from MS-DOS with a fully graphical, mouse-driven user interface. It wasn't the first personal computer system to do so, largely copying earlier systems from Apple, which had in turn famously copied mouse-driven systems developed by Xerox researachers at the Palo Alto Research Center (PARC). But Windows was the most commercially successful personal computer based on graphical user interface (GUI) design.
OS/2. This operating system was IBM's bet they could design a microkernel-based OS that would supplant MS-DOS. Although it failed spectacularly, OS/2 had strong adherents and famously made its way into the New York City subway system.
Linux. Linux was developed in 1991 by Linus Torvalds, in what was not originally intended to be such a widely-used product. Torvalds modeled Linux after Minix, an educational OS by Tanenbaum, based on the POSIX standard. Torvalds continues to lead development of the Linux kernel; because it is open source, anyone is free to incoroporate the Linux kernel into an OS distribution, and many different 'flavors' of Linux exist. Linux emphasizes speed and performance, but evolved away from the microkernel design of Minix. Linux is considered more of a monolithic kernel design. It adheres mostly to the POSIX standard, with some exceptions. Although not very different from Unix in terms of features, initally, Linux is important as the first fully-featured, completely open-source OS.
MacOS. MacOS is the current name for operating systems developed for personal computers by Apple. It formed the basis for operating systems the company developed for use in its iPhone, Apple Watch, and AppleTV products. The technology that evolved into MacOS over the years derived from a number of sources. Apple purchase NeXT and incorporated its object-oriented technology. The core of MacOS is built on the XNU kernel, which is POSIX-compliant. MacOS development is done using a mixture of the C, C++, Objective C, and Swift programming languages.
iOS. The iOS operating system was developed for the iPhone, the first true smartphone, capable of running generic applications like a desktop computer. It was designed around a touch-screen interface and pioneered the concept of a curated application exchange, or 'app store'.
Android. After the release of the iPhone, Google created its Android OS as an open-source alternative. Based on the Linux kernel but with a Java-based application interface, today Android is the most widely used OS in the world, found on over 3 billion smartphones worldwide. Both Android and iOS are currently based on processorrs using the ARM architecture.
An operating system is a resource manager, supporting applications and facilitating access to hardware and other resources.
Early computers had no operating system at all.
Early developments in the evolution of the OS included simple batch systems, batch multiprogramming, and time-sharing systems.
Modern OS developments include processes, multiprocessing, multithreading, object-oriented design, and virtualization and containerization.