Evolution of Operating Systems: Second Generation Operating Systems (1955-1965) A new hardware technology was introduced. This technology is the trans

Evolution of Operating Systems:
Second Generation Operating Systems (1955-1965)

A new hardware technology was introduced. This technology is the transistor. With the new technology came a new look for operating systems. Specifically, the batch operating system was introduced.

Since programming in machine language is obviously very difficult and are prone to errors, most computer systems were slowly provided with additional software and hardware. Examples of software introduced were:

1.    Aassemblers, loaders and linkers
2.    Libraries for common functions.

Almost at the same time card readers, line printers and magnetic tapes became available. Thus consoles were replaced by these new input devices. Consequently, device drivers were written for these I/O devices and were made available to the users.

Then, in the pursuit of making program development more convenient to users, language translators were introduced. Although this made it more convenient for users to write programs, the operations of the computer became more complex. For example, with a high-level language translator like COBOL, to run a program in COBOL, the following steps have to be followed by the user:

1.    Load the COBOL compiler from the magnetic tape into the computer’s memory. Then, initiate the execution of the compiler. Once running, the compiler will read the COBOL program of the user from the card reader. Finally, the compiler will write the assembler equivalent of the COBOL program into a magnetic tape.

2.    Load the assembler from the magnetic tape into the computer’s memory and initiate its execution. This will produce the binary object of the program from the assembler version.
 
3.    Load the binary object of the program and initiate its execution.

With high-level languages, a considerable amount of time is clearly spent setting up the job.

Attempts were made to reduce the job set-up time. Some of these attempts were done by:

1.    Hiring professional operators
2.    Batching together similar jobs.

In the first solution, since a considerable amount of time is spent on loading assemblers and loaders, less time is spent if the one doing this has experience rather than leaving the said activities to programmers themselves. On the other hand, by batching similar jobs, the loading of a particular compiler can be minimized. For example, given a job request like

COBOL, FORTRAN, COBOL, FORTRAN, COBOL

will require the loading of the COBOL compiler three times and the FORTRAN compiler twice. Rearranging the sequence to:

COBOL, COBOL, COBOL, FORTRAN, FORTRAN

will only need the loading of COBOL and FORTRAN compilers once each.

Later, automatic job sequencing and program loading were introduced. These were achieved by creating a small program, called a supervisor, whose function is to automatically load and transfer control from one program to another. The supervisor program understood a certain language called the job control language. This language contains instructions like where to read the compilers, linkers, and loaders which are needed by a particular user program. With this supervisor program, together with the idea of waiting for a number of jobs (batch), form the core of the early batch operating systems.

A variation of the early batch systems is a system where input and output operations are done off-line. In this system, an inexpensive processor is used to do input by transferring data and programs from card readers to magnetic tapes. These input tapes are then transferred to the main computer where processing occurs. Outputs of the processing are similarly placed in an output tape, which as in the input operation are printed on the line printer using another inexpensive processor. Throughput is obviously improved since doing the input directly from a card reader and the output to a line printer are much slower than doing it using magnetic tapes.