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)
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.
A typical system sold for $3M
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.
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
Post-PC Era 2005 – present
mobile, virtualization, cloud computing
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
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.
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.
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.
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
Job Control Language (JCL) used to set up batch jobs.
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.
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)
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."
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
Windows 7 takes up about 20GB
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
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.
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
IBM goes back to Gates for help. Gates
buys Seattle Computer Products, the developer
of DOS, revises it and sells it to IBM.
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.
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.
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)
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.
UNIX V1 (1970 – Bell Labs)
UNIX V4 (1973 – Bell Labs)
UNIX V5(1974 – Bell Labs)
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)
Sun OS (1982 Sun)
NextStep 0.8 (1988 Next)
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.