Chapter 6

Multiprogrammed Operating Systems (1960-1970)

As computer hardware increased in power and complexity in the 1960s, the need for more sophisticated system software to manage machine resources and simplify program execution became increasingly apparent. Simple batch processing systems, despite having represented a first step towards automation, showed their limits in terms of efficiency and interactivity. This period saw the emergence of multiprogrammed and time-sharing operating systems, which would revolutionize the way users interacted with computers and lay the foundation for modern operating systems.

6.1 The Limitations of Batch Processing:
Sequential and Inefficient Execution

As discussed in Chapter 3, batch processing involved the sequential execution of a set of jobs, with limited operator intervention. Although this approach improved computer usage compared to manually executing each individual instruction, it had several significant limitations:

• Low CPU utilization: During input/output (I/O) operations, the CPU often sat idle waiting for the external device to complete its task. This led to underutilization of the expensive CPU resource.

• Long wait for results: Users had to wait for the entire batch to complete to get the results of their job, even though this took only a fraction of the total execution time.
• Lack of interactivity: It was not possible to interact with the program during its execution, making it difficult to debug and run applications that required immediate feedback.
• Limited priorities: All jobs in the batch were generally executed with the same priority, with no ability to favor more urgent or important jobs.

These limitations pushed researchers and developers to explore new ways of managing computer resources that could overcome the inefficiencies of batch processing.

6.2 The Emergence of Multiprogramming:
Sharing the CPU to Maximize Utilization

multiprogramming is a technique that allows multiple programs (or processes) to reside simultaneously in main memory and share the CPU. The fundamental idea is that when a program must wait for a slow operation (such as an I/O operation) to complete, the CPU can switch to executing another program that is ready to run. In this way, we try to keep the CPU as busy as possible, improving the overall efficiency of the system.

To implement multiprogramming, several mechanisms were needed:

• Memory management: The operating system needed to be able to allocate and manage memory space to accommodate multiple programs at the same time, ensuring that one program did not interfere with the memory of another.
• CPU Scheduling: The operating system had to implement algorithms to decide which of the ready-to-run programs should get access to the CPU and for how long.
• Protection: It was critical that the operating system provide protection mechanisms to prevent one program from accessing or modifying another program's memory or resources in an unauthorized manner.

Multiprogramming allowed the productivity of computer systems to be significantly increased, as multiple jobs could be completed in the same amount of time.

6.3 The First Multiprogrammed Operating Systems:
Pioneers in Resource Management

Some of the first operating systems to implement multiprogramming include:

• Atlas Supervisor: Developed for the Atlas computer at the University of Manchester in the early 1960s, this operating system was one of the first to introduce concepts such as virtual memory and multiprogramming, demonstrating the feasibility of these techniques.
• IBM OS/360: Introduced in 1964, OS/360 was one of the first large-scale operating systems designed to support multiprogramming on a family of IBM System/360 computers with varying hardware capabilities.
• OS/360 was an extremely complex operating system for its time and represented a milestone in the development of operating systems, introducing concepts such as job control languages ​​(JCLs) for job management and sophisticated memory management mechanisms. However, its complexity also made it difficult to implement and manage.
• Other operating systems such as the Master Control Program (MCP) developed for the Burroughs computers also implemented forms of multiprogramming.

6.4 The Introduction of Time-Sharing:
The Illusion of a Personal Computer for Many Users

time-sharing is an extension of multiprogramming that allows multiple users to interact with the computer at the same time. The idea is to divide CPU time into small intervals (time slices or time quanta) and assign each interval to a different user. The CPU switches rapidly from one user to another, creating the illusion that each user has a dedicated personal computer.

Time-sharing was motivated by the desire to provide an interactive computing experience to multiple users simultaneously, overcoming the limitations of batch processing. This was especially important in contexts such as scientific research and education, where many users may need access to the computer to run small programs, edit files, or interact with the system in real time.

To implement time-sharing, techniques such as:

• Time slicing: CPU is allocated to each process for a short period of time.
• Swapping: If a process is not using the CPU for an extended period (e.g., waiting for user input), its memory space can be temporarily moved to disk (swapped out) to make room for other active processes. When the process becomes ready to run again, it is returned to memory (swapped in).
• User and terminal management: The operating system needed to be able to manage multiple user access via remote terminals.

6.5 Pioneering Time-Sharing Operating Systems:
Towards Interactivity

Some of the earliest and most influential time-sharing operating systems include:

• CTSS (Compatible Time-Sharing System): Developed at MIT (Massachusetts Institute of Technology) in the early 1960s, CTSS was one of the first successful time-sharing systems. It allowed multiple users to interactively access a mainframe computer via terminals, opening up new possibilities for research and education. CTSS profoundly influenced the development of subsequent operating systems.
• Multics (Multiplexed Information and Computing Service): An ambitious project that began in 1965 as a collaboration between MIT, General Electric and Bell Labs. The goal was to create a powerful, reliable and secure time-sharing operating system, with advanced features such as a hierarchical file system. Although the Multics project did not achieve immediate commercial success, many of its ideas and concepts profoundly influenced the development of future operating systems.
• Unix: Born as a "spurious" project within Bell Labs in the 1960s, mainly by Ken Thompson and Dennis Ritchie, Unix was initially inspired by some of Multics' ideas but with a simpler and more modular approach. One of the distinctive features of Unix was its portability, made possible by its implementation in the C language (also developed at Bell Labs by Ritchie). Early versions of Unix supported time-sharing and introduced fundamental concepts such as the hierarchical file system and the command-line interface (shell), which would have a lasting impact on the world of computing.

6.6 Fundamental Concepts of Modern Operating Systems Introduced in This Period

The decade 1960-1970 was crucial for the definition of many of the fundamental concepts that still form the basis of modern operating systems today:

​​
• Memory management: The first techniques for allocating memory (e.g., fixed and variable partitions) and for protecting memory between different processes were developed. The introduction of virtual memory in systems like Atlas and OS/360 represented a significant advance, allowing programs to use more memory than was physically available.
• CPU Scheduling: The first scheduling algorithms were introduced to decide which process should be executed by the CPU in a multiprogrammed, time-sharing environment. Algorithms such as round-robin (used in many time-sharing systems) and priority-based algorithms began to be studied and implemented.

• Device Management: Operating systems began to include mechanisms to manage and control the various input/output devices connected to the computer, providing a uniform interface to application programs.
• File systems: Operating systems such as Multics and Unix introduced the concept of a hierarchical file system, which allowed data to be organized into directories and subdirectories, simplifying file management and access.
• User Interface: While batch processing often did not involve direct user interaction during execution, time-sharing systems introduced the command line interface (CLI) as the primary means of interacting with the operating system.

6.7 Challenges and Innovations in the Development of Operating Systems

The development of multiprogrammed and time-sharing operating systems in the 1960s was an extremely complex undertaking. Operating system programmers faced challenges such as concurrent management of multiple processes, synchronization and communication between processes, protection of system resources, and error handling.

This period also saw the emergence of major innovations in software development techniques and systems design. Modularity, code structuring, and the introduction of high-level programming languages ​​such as C for operating system development (as in the case of Unix) helped manage the growing complexity of system software.

The evolution of operating systems in the 1960s, with the shift from batch processing to multiprogramming and time-sharing, represented a fundamental change in the way users interacted with computers and in the efficiency with which hardware resources were used. The introduction of key concepts such as memory management, CPU scheduling, device management, and file systems laid the foundation for the modern operating systems we use today. Pioneering systems such as OS/360, CTSS, Multics, and Unix had a lasting impact on the field of computing, profoundly influencing the development of systems software for decades to come.