a brief history of operating systems n.
Skip this Video
Loading SlideShow in 5 Seconds..
A Brief History of Operating Systems PowerPoint Presentation
Download Presentation
A Brief History of Operating Systems

Loading in 2 Seconds...

play fullscreen
1 / 39

A Brief History of Operating Systems - PowerPoint PPT Presentation

  • Uploaded on

A Brief History of Operating Systems. IBM 7094. A typical system sold for $3M. Discrete transistor logic boards. Core memory. The UNIVAC 1108. Raspberry Pi Univac1108. Cost $35.00 $1.6M (~ $10M (in today’s dollars) Speed 700 MHz 2MHz Storage 4GB 512KB (128 x 32 bit words)

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

A Brief History of Operating Systems

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

IBM 7094

A typical system sold for $3M

Discrete transistor

logic boards

Core memory


Raspberry Pi Univac1108

Cost $35.00 $1.6M (~ $10M (in today’s dollars)

Speed 700 MHz 2MHz

Storage 4GB 512KB (128 x 32 bit words)

Size 0.1 liters 10,000 liters (ignoring room cooling)

Power 0.5 mW ~ 10 kW

In 1968, the Chevrolet Malibu Sport Coupe with a 307-cid V-8 engine

cost $2,663.00 -- 696 times less than a megabyte of UNIVAC core memory.

history of operating systems

History of Operating Systems

First generation 1945 - 1955

vacuum tubes, plug boards

Second generation 1955 - 1965

transistors, batch systems

Third generation 1965 – 1980

ICs and multiprogramming

Fourth generation 1980 – 2005

personal computers

Post-PC Era 2005 – present

mobile, virtualization, cloud computing

early history the 1940 s and 50 s

Early History: The 1940’s and 50’s


8ft high x 50 ft long

Harvard Mark I (1944)

The earliest computers had no operating systems.



The ENIAC machine was developed for the

Army Ballistic Research Labs by the

University of Pennsylvania. It occupied

a room thirty by fifty feet. It was an

electronic version of the Mark I and

contained 19,000 vacuum tubes and 1500

relays. It consumes 200KW of power. It

could do 5000 operations per second.

It was programmed with plug boards

and switches.



Originally, each user wrote all of the code necessary to implement a particular application, including the highly detailed machine level input/output instructions.

As an example of how tedious low level programming was in the early days consider the IBM 650 (About 1953). The 650 stored its programs on a magnetic drum. Because of the rotational delay in the drum, programmers discovered that they could realize significant optimizations in program performance by proper placement of instructions on the drum. In these early days programmers spent a lot of time calculating the best place on the drum to store each instruction, so as to get the best possible performance!


One of the earliest developments to presage today’s operating systems was the consolidation of the basic input/output operations into an input/output control system, relieving programmers from having to handle the low level details of managing input and output devices.

This is the BIOS on modern personal computers.

batch systems

In early computing systems, the computer often stood idle for relatively long periods between jobs due to the set-up and tear-down time required for a job. Tapes had to be mounted, forms mounted on printers, card decks punched, and so on.

These early computers were very expensive. The IBM 701 leased for $11,900 a month, or more, depending on its configuration.

Batch Systems


IBM 701 (1953)

Electrostatic storage capacity: 20,480 digits.

Magnetic drum capacity: 81,920 digits.

Addition and subtraction: More than 16,000 operations per sec.

Multiplication and division: More than 2,000 operations per sec.

Tape reading and writing speed: 12,500 digits per second.

Drum reading and writing speed: 8,000 digits per second.

Printed output: 180 letters or numbers per second.

Punched card input: 600 digits per second.

Punched card output: 400 digits per second. 


To maximize the time that the CPU was active, General Motors Research labs developed a system to automate job-to-job transition on their IBM 701. This early batch system, developed in 1956 was considered by some as the first real operating system. This work led to the batch processing systems of the era.

batch systems1

Batch Systems

Early batch system

bring cards to 1401

read cards to tape

put tape on 7094 which does computing

put tape on 1401 which prints output

single user

single application

job control language

Job Control Language

Job Control Language (JCL) used to set up batch jobs.

ibm 7000 series


IBM 7000 Series


A typical system cost $3,134,500. IBM stopped selling them in 1969.

Memory technology: magnetic core

First introduced: 1963

Memory size: 32K 36-bit words

CPU technology: transistor

Cycle time: 2 microseconds (0.5 MHz)

the 1960 s timesharing

MIT’s Department of Electrical Engineering was one of the pioneers in timesharing systems, under the guidance of John McCarthy.

MIT had been running an IBM 704 in batch processing mode. The long turnaround time, hours and sometimes days, motivated researchers to develop a system that would reduce turnaround time. This led to the first timesharing system in November 0f 1961 called CTSS – Compatible Time Sharing System.

The 1960’s: Timesharing


As a successor to CTSS, MIT developed the MULTICS operating system. Multics was developed on a GE 645 computer, largely because the IBM/360 computers just released did not provide the necessary hardware features to support multiprogramming.

Multics was part of MIT’s project MAC. Project MAC was funded by the Advanced Research Projects Agency (ARPA) of the Department of Defense. The major players were MIT, Bell Labs, and GE/Honeywell.


Multics was never commercially successful, but it’s design included many of the important concepts we will study.

* virtual memory

* segmentation (program and data segments)


“Over time, hope was replaced by frustration as

the group effort initially failed to produce an

economically useful system. Bell Labs withdrew

from the effort in 1969 but a small band of

users at Bell Labs Computing Science Research

Center in Murray Hill – Ken Thompson, Dennis Ritchie,

Doug McIlroy, and J. F. Ossanna -- continued to

seek the Holy Grail."

dec pdp 10



The Digital Equipment Corporation PDP-10 is one of the most influential

computers in history in more ways than can be listed here.

It was the first widely used timesharing system.

os 360

Probably one of the most successful commercial operating systems, OS/360 had a rocky start.

Development started in 1964 in Poughkeepsie, N.Y.

By the end of 1965, fundamental design flaws emerged for which there seemed to be no solution.

In April of 1966 IBM announced that the OS/360 would not be delivered until the second quarter of 1967.

IBM’s response to these problems was to add more programmers to the task.



At it’s peak, more than 1,000 people were working on OS/360. These included programmers, technical writers, analysts and support staff.

This situation led Fred Brooks to note

“The bearing of a child takes nine months, no matter how many women are assigned to the task”

Mythical Man Month


OS/360 was initially delivered in three stages:

  • PCP (Primary Control Program) was a batch system.
  • It ran in 32 KB.
  • MFT – initially capable of running 4 jobs in fixed size
  • memory partitions. Later upgraded to 16 partitions.
  • MFT ran in 64KB.
  • MVT – allowed any number of tasks to be run at
  • once. MVT ran in 128KB.

Windows 7 takes up about 20GB

mits altair


The Altair 8800 made its debut in an article that appeared on the cover of the

December 1975 issue of Popular Electronics. Within two months the little

company MITS, was struggling with thousands of orders. The computer came

in kit form and required quite a bit of work and skill to assemble. Users would

enter their programs in binary by flipping switches on the front panel of the

machine. The output could be read in binary on the LEDs. No software was

available for the little machine and users would have to write their own

MITS Altair

enter bill gates

The Altair 8800 computer needed software - a computer

language - to make it really useful. Only hackers would tolerate

programming in zeros and ones. An easier language was needed.

One day Ed Roberts (The developer of the Altair) got a letter

from a company which said they had already created a version of

Basic. He immediately called the company but reached a private home in Seattle - where nobody knew anything about the letter. Paul Allen and Bill Gates had written and sent the letter using letterhead they had created for their high school computer company. They soon called Ed Roberts in Albuquerque to see if he'd be interested in their Basic, (which didn't actually exist yet), and he said that he would be as soon as he could get some memory cards for the Altair so it would have enough memory to run Basic.

Enter Bill Gates

ms dos


Gary Kildall, working for Intel

writes the first disk based operating

system for a PC, CP/M



Kildall gets the rights to CPM and creates

his own company, Digital Research. CPM

runs on 8080 and Z-80, dominates the PC


Early 1980s, IBM builds the IBM-PC. IBM looks

for an operating system and Bill Gates

suggests that IBM contact Kildall. Kildall kills

the deal.

IBM goes back to Gates for help. Gates

buys Seattle Computer Products, the developer

of DOS, revises it and sells it to IBM.

1970 s unix

Probably the most significant development of the 1970’s was Unix. Ken Thompson, Dennis Ritchie, and others were Bell Lab employees who worked on the Multics project. When it became apparent that Mutlics would not be successful, Bell labs withdrew from the project.

Thompson was never funded to do the kind of operating system work that he wanted to do. As a result he scrounged around and found a discarded, obsolete PDP-7.

1970’s - Unix


The design of Unix evolved over a period of just a few months in 1969. But, the biggest boost to the development came in 1973 when Ken Ritchie joined the group and designed a new language called “C” especially for writing the operating system. Up to this point all development had been in assembly language.

One of the first major applications written on Unix was to do Text Processing. This was done to support Bell Labs patent department. This work was so successful that Bell Labs finally funded Ritchie and Thompson to purchase a PDP-11.


AT&T, The parent company of Bell Labs, was prevented from competing in the computer industry by government regulation. So, AT&T made Unix systems available to Universities for a nominal fee. Most importantly, Bell Labs distributed the source code.

The clean design of Unix and the easy access to source code made Unix extremely popular in the academic world. One of the most powerful versions of Unix was developed by The University of California at Berkeley.

1980 s mach

One of the most significant pieces of work of the 80’s was the development of the Mach operating system at Carnegie Mellon University (1985 – 1994)

  • At the heart of the Mach operating system is the Mach micro-kernel. Key aspects of the micro-kernel include
  • support for threads
  • multi-processor support, in a single machine or over a
  • network
  • interprocess communications, sending messages directly
  • between applications
  • memory protection and safety

1980’s - Mach


Mach is not an operating system in it’s own right, and was basically unusable without a set of servers on top of the micro-kernel. So, the Mach developers did a quick and dirty port of BSD-Unix on top of the Microkernel to provide a usable system.

Performance was abysmal. Every call from a user

application, say to get the time, required the message

to be sent to the kernel using a context switch, which

would then send the request to the Unix library with

another context switch - and then repeat it all again

for the response! Thus Mach, through no real fault

of its own, was generally considered to be very

powerful, but incredibly slow.


Work over the next decade managed to improve the performance of these context switches many times, to the point where the performance of late Mach-like operating systems was in fact often better than the BSDs they were based on. However by this point in

time the academic world had largely lost interest in OS research, and Mach's promise remains unfulfilled.









IBM 701

IBM 7090

















The Unix Family Tree

UNIX V1 (1970 – Bell Labs)

UNIX V4 (1973 – Bell Labs)

UNIX V5(1974 – Bell Labs)

PWB/Unix (1974)

UNIX V6(1976 – Bell Labs)

Unix System III (1981 ATT)

UNIX V6(1976 – Bell Labs)

BSD (1978 UCB)


UNIX V7(1979 – Bell Labs)

BSD sys4 1978 UCB)


Xenix (1980)

Mach (1985)

Free BSD

Sun OS (1982 Sun)

SCO Unix

Linux (1991)

NextStep 0.8 (1988 Next)


unix standards

Unix Standards

  • Key POSIX standards include the following:
  • 1003.1 (released 1990)
    • Library procedures. Described the C system call API,
  • 1003.2 (released 1992)
    • Standard shell and utilities.
  • 1003.4 (released 1993)
    • Real-time Unix. Binary semaphores, process memory locking,
    • memory-mapped files, shared memory, priority scheduling,
    • real-time signals, clocks and timers, IPC message passing,
    • synchronized I/O, asynchronous I/O, real-time files.


The next player on the scene was X/Open

(later renamed the Open Group), a consortium of

Unix vendors formed in 1984.

In 1993 seventy-five systems and software vendors

including every major Unix company put a final end to

the Unix wars when they declared backing for X/Open

to develop a common definition of Unix.