50

The Operating systems have been tightly related to the computer architecture.An OS takes care for all input and output in a computer system. It manages users, processes, memory management, printing, telecommunication, networking etc.It sends data to a disk, the printer, the screen and other peripherals connected to the computer.

Prior to the introduction of Operating System,

What was used in computer systems to make them work?

Which concept was used to operating system in our evolution of computer?

closed as too broad by Peter Mortensen, Breakthrough, allquixotic, random Sep 11 '14 at 22:19

Please edit the question to limit it to a specific problem with enough detail to identify an adequate answer. Avoid asking multiple distinct questions at once. See the How to Ask page for help clarifying this question. If this question can be reworded to fit the rules in the help center, please edit the question.

  • 5
    "Before this, what was used in computer systems..." -- It was the same as if you didn't run an OS today. You run batch jobs by handing over the entire computer system to a single user, one at a time. – sawdust Sep 10 '14 at 20:36
  • 4
    Think of code running on a microcontroller. It doesn't run in an operating system, but it's C-code that compiles down to machine code, and is run on a real, physical device (after this machine code is "flashed" to the firmware). Operating systems just facilitate having multiple programs interact at the same time with all the parts of the computer by using the concepts of resource sharing and process scheduling. Likewise, you can also use an operating system on that little microcontroller - if you need it. – Breakthrough Sep 10 '14 at 21:16
  • A lot of the answers are focusing on I/O, how programs get loaded and peripheral devices. But that just obscures the purpose of the OS: resource management and sharing, and possibly multi-user capability. The purpose of the OS doesn't change if you load code from wire board or punched tape or drum or use a modern SDcard. – sawdust Sep 11 '14 at 1:53
  • Card deck. Punched paper tape. Operator to feed same through computer. – Daniel R Hicks Sep 11 '14 at 12:22
42

Early computers ran one program at a time.

Programs were directly loaded from (for example) paper tape with holes punched in it.

You'd program the earliest computers by setting a large set of on-off switches.

Colossus:

Atlas:

Manchester:


I am using the word "Computer" to mean the sort of device that exists nowadays in the billions. Of this vast number of computers, all but an insignificantly tiny number are digital electronic programmable computers with stored programs. I'm sure the original question is not about how people with the job title "Computer" spent their working day. In between those two types of computer, there is a progression of interesting devices not covered in this answer.

  • 1
    I have hardware I work with that uses those switches in the second picture. It also runs programs exactly the same way. Upvote for using such a great picture – Ramhound Sep 10 '14 at 13:52
  • wouldn't the earliest ones, say ENIAC, hard wired? Not switched nor having stored programs? Or is this no longer a computer because of that... curious – Rich Homolka Sep 10 '14 at 18:54
  • 1
    @RichHomolka: As you imply, it really depends what you regard as a computer. Most people nowadays probably mean a digital electronic programmable computer. Of course there were, for example, mechanical analog computers and the earliest computers were people (it was a job title). If I get time I might expand the answer to address this. I believe ENIAC was programmed by manipulating switches and cables. – RedGrittyBrick Sep 10 '14 at 20:16
  • Operating systems came in fairly early on (1956 - see en.wikipedia.org/wiki/GM-NAA_I/O). The first mass produced computer was about 1954 – Bruce Martin Sep 11 '14 at 8:24
  • “I'm sure the original question is not about how people with the job title "Computer" spent their working day” — my grandmother was a computer. – Paul D. Waite Sep 11 '14 at 12:51
13

Source: History of Operating Systems

Operating systems have evolved through a number of distinct phases or generations which correspond roughly to the decades.

The 1940's - First Generations

The earliest electronic digital computers had no operating systems. Machines of the time were so primitive that programs were often entered one bit at time on rows of mechanical switches (plug boards). Programming languages were unknown (not even assembly languages). Operating systems were unheard of.

The 1950's - Second Generation

By the early 1950's, the routine had improved somewhat with the introduction of punch cards. The General Motors Research Laboratories implemented the first operating systems in early 1950's for their IBM 701. The system of the 50's generally ran one job at a time. These were called single-stream batch processing systems because programs and data were submitted in groups or batches.

Source: http://en.wikipedia.org/wiki/History_of_operating_systems

The earliest computers were mainframes that lacked any form of operating system.

Each user had sole use of the machine for a scheduled period of time and would arrive at the computer with program and data, often on punched paper cards and magnetic or paper tape. The program would be loaded into the machine, and the machine would be set to work until the program completed or crashed.

Programs could generally be debugged via a control panel using toggle switches and panel lights. It is said that Alan Turing was a master of this on the early Manchester Mark 1 machine, and he was already deriving the primitive conception of an operating system from the principles of the Universal Turing machine.

10

Going right back to the start of computer systems you didn't have single computer systems, instead you had mainframes.

enter image description here

These mainframes would run on punched cards which would contain your program (and often your data). People would get allocated time on these systems, bring their cards along and plug them into the machines for them to process. The machine would run the program until it finished then the next user would come along with their tape and cards.

Basically that is how it worked.

  • 4
    So the "operating system" here is...whoever's doing the scheduling for the users? – Kyle Strand Sep 10 '14 at 15:34
  • 2
    My point is that your answer doesn't actually explain what you mean by "Strictly speaking Operating Systems have been around for a very long time in one form or another." You provide a basic description of mainframes, but it's not clear at all that these mainframes had anything remotely similar to what we call "operating systems." – Kyle Strand Sep 10 '14 at 17:46
  • 3
    I know what you're trying to say but I'm not terribly comfortable with this description, being old enough to have worked on mainframes that meet your precise description of a mainframe above, but which did indeed contain an operation system. The mainframe in your picture would probably be a 1970s IBM mainframe (a s/360 or s/370?) running OS/360 or an early version of MVS. – Rob Moir Sep 10 '14 at 20:02
  • 2
    There's no such thing as "punched magnetic cards". Your photo of a "mainframe" is in keeping of Hollywood's and laypersons' vision of a computer: rows of mag tape transports. – sawdust Sep 11 '14 at 2:02
  • 1
    Quite a few mis-statements here. As @sawdust said, punched cards were not magnetic. Also, punched cards often contained your program and your data; or your program might be on paper (punched) tape. Mag tape spools were much later. Prior to that programs were loaded via panel switches as shown in RedGrittyBrick's answer, or by rewiring the computer via a plugboard. I found Father, Son & Co. interesting and informative history. – Stephen P Sep 11 '14 at 7:18
6

1890-1950 - Operation inherent to the system The very earliest computers had the equivalent of what an OS does now built into them. You (the operator) were also part of the operating system as well. You flipped the register switches (or used a punch card) and physically swapped bus wires (think of the old fashion telephone operator station) and memory was linked (via physical wires) directly with light bulb (the monitor of the day) and printers (the long term storage) in such a way that the program output would light up and print directly to the device as it was being placed into the output memory buffer. There was no driver needed for these things because (due to the way those physical wires were ran) they 'just worked' (there was also no such thing as a monitor in these days. In fact it was still going to be a few decades into this era until a digital numeric display would be invented so that you could actually see the numbers you'd already entered into the register and the output as decimal numbers; printers ruled this entire era until monitors . They were wired exactly as they needed to be to work correctly. None of this part really changed much with the switch from mechanical (1890s) to electric analogue (1910s) to digital (1930s). This 'Plug N play' architecture was replaced with the interrupt system during this time and would not resurface again until the late nineties; of course by then there'd be a lot less plugging. With interrupts, devices were allowed to take CPU time which allowed architectures which weren't directly tied to hardware but it took several generations for this to really be the streamlined process we see in x86 arch (and newer); early systems often ran into horrible race conditions, hardware compatibility\delay problems, and other odd behaviours where interrupts are concerned. Because each machine used radically different (an experimental) architectures in this period; nearly all devices were custom made for the machine they worked on.

1950-1973 - Operation within a system This era saw the advent of most of the features we think of when we talk about a true operating system. Debugging, programming languages, multi users, multi tasking, terminals, disk type drives, networking, standardization of components, etc were all introduced in this era. This time saw a giant leap towards standardization of much of this which meant that we had more standardized devices but still each OS was hand crafted for each machine which meant that OS functionality was severely limited by whatever the engineers who designed that particular system decided they needed. During this time, there was a substantial grey area in what an operating system was because the different architectures handle thing much differently and a more general purpose machine will need a lot more OS than a machine which includes hardware to handle the same jobs. The fact is that hardware is always going to be faster than software and practically anything done in software can theoretically be done in hardware (it is cost\flexibility\size\time\etc which limits us from making almost pure hardware versions of everything to this day). An OS was made for a particular computer or type of computer; it would not work elsewhere. Each new computer design needed all low level OS software to be rewritten from scratch to work with a particular machine model. Near the end of this time a new OS emerged which would soon change this paradigm, UNIX written at Bell Labs by Ken Thompson and Dennis Ritchie.

1973 - Operation between systems A single program changed all of this but it wasn't UNIX. It was the C compiler (which was famously made in a garage by Ken Thompson and Dennis Ritchie after Bell Labs cut it). Until this point, any time you wrote code it was either machine code (code that the machine directly understands but is not portable) or it was written in a language which compiled your code to byte code (code which is interpreted by another program as it runs). The huge difference for OSes that C brought with it was the ability to do what is known as cross compiling into machine code. This meant that code could be written once and compiled to run across many different machine types natively as long as a compiler had been written for that machine. Operating systems must be written in machine code because machine code is literally the only code that the machine knows.

I would say that it wasn't until Ken and Dennis first compiled the UNIX kernel using a C compiler that a true OS in the modern sense was born. Before that, an OS was either a physical object or simply a pre initialized chunk of memory space designed specifically for a particular machine. Adding new devices to the system literally required that 'kernel' code to be rewritten. Now, the UNIX OS that they had designed for a particular machine could be recompiled and ran on other machines without rewriting EVERYTHING (as long as that machine was able to compile a C compiler from a bootstrap environment the rest of the OS could be written in the relatively high level C code).

  • 1
    Someone mentioned that OS\360 came before UNIX. This is also true but like all other OSes of that day, it was hand coded for each individual machine model it ran on. – krowe Sep 10 '14 at 16:52
  • 1
    Someone mentioned that FORTRAN can also cross compile. which is true, so did ALGOL (the predecessor to C), but C was the first to be bootstrapped in order to build a machine independent OS. – krowe Sep 10 '14 at 16:56
  • 1
    "until Ken and Dennis first compiled the UNIX kernel ... that a true OS in the modern sense was born.." OMG. Less true words have rarely been written on this site. There is no sense in which this statement is remotely accurate. – RBarryYoung Sep 11 '14 at 18:16
  • 1
    also ignores MULTICS (and BCPL) – Francis Davey Sep 11 '14 at 21:57
  • Most of the things listed above about UNIX and C's precedence are incorrect, most especially, why UNIX and C were so important in the history of OSs. This was due, almost entirely, to the 1974 Consent Decree against AT&T, which meant that it (and a lot of other AT&T technology) was free, including the source code. Because of this, it's real "first's" were as the first free fully functioning modern OS and low level compiler, including all of the source code. A solitary position it would occupy for 10-20 years before it's competitors would honestly admit the advantage that gave it. – RBarryYoung Sep 12 '14 at 14:17
3

In the beginning, the programs were hardwired into the computer, which would start running the program immediately from a particular location on bootup.

Then various forms of offline storage were invented: punched cards, tape, drums, even disks. Much more flexible. But not directly accessible from the CPU. The program needs to be loaded into memory before it can be run. So you write a program to load your program. This is known as a loader, or bootstrap (from the expression "to pull yourself up by your boot straps").

As the system gets more complicated, you may have a simple loader load a more complex loader. This started with microcomputers: the normal tape loader was slow, so load a decompressor and fastload the rest of the tape. Or disk speedloaders which doubled as copy protection systems by doing nonstandard things with the disk.

Or the pre-UEFI PC boot process: processor starts executing in the BIOS. This loads the first sector off the disk and jumps to it. That looks for an active partition and loads a bootloader from there, which loads the operating system. Originally that would have been COMMAND.COM for MSDOS; now it's usually NTLDR.EXE for Windows.

3

It should be noted that in early hardware (before 1960), I/O was much simplier. You could read a card, or punch a card or print a line on the printer, each with a single instruction: the buffer size was fixed, and often the buffer address was fixed too.

Even in the early 60s, with more sophisticated processors (eg. the 7090), you could still read or punch cards with a small routine (about 20 instructions), that was easily copied into each program.

Since the computer was entirely dedicated to a single job, it didn't matter if the processor was idle while waiting for the card reader to be ready to read the next card, or for the line printer to feed up the next line.

Well, it did matter, because computing time was expensive actually. This is why people invented multi-processing, time-sharing, added asynchronous I/O, and interrupts and device drivers and operating systems. The hardware device interfaces became more complex, for the programmer, giving access to lower level I/O registers, which required more complexity from the device drivers. This complexity cost (memory, programming time) was amortized over the several programs using the devices "simultaneously", multiplexed by the operating system.

Still in the 80's I was using a micro-processor based computer, emulating one of those older systems. The machine instructions had a uniform format over 80 bits (10 octets), and the instruction to read the first sector of the first hard disk and store it into the memory at address 0 was very conveniently: 0000000000. So the boot procedure consisted every morning to type this instruction on the terminal, which stored it at address 0 and executed it, which then loaded the boot sector and continued execution at the next instruction (at address 10). The file system consisted in a static table mapping file "names" to ranges of sectors, which were manually allocated! I/O was done in assembler to those files by directly reading or writing the sectors, offset by the position of the file on the hard disk which was recovered by the "open" routine.

2

Fist generation of computers designed for wider personal use had so called "Monitor" in ROM (read only memory).

Immediately after booting, the monitor provided very limited command line interface mostly to load program from the data storage like tape recorder and to start the execution (a few other commands were available for manual code entry, while seldom needed). Only one program could run at time.

Differently from the operating system, Monitor had no file system support of any kind. The human operator was responsible for finding the right tape, putting it on the recorder and positioning at the start of the needed program to load.

Monitor combined functions of both BIOS and the operating system and was already very clearly a software.

After turning on, the short "reset" signal was simply zeroing the program counter same as any other counter, at the same time switching the memory mapper (if any was present) to map the address 0000 to the Monitor ROM. It was common to have some hardware circuit for remapping Monitor into the high address space later. Apart from code startup, the "Reset" button was also used to terminate the running program so that another could be loaded.

The rudimentary "reset" button can be found on some desktop PCs even in these days.

  • That is true of the first (or second) generation of "personal computers" for home use. Before they existed, pupils at secondary schools had remote access to time-sharing computers that worked differently but would still have been "designed for wider use". I'm not sure the first generation of home computer, the Altairs and Heathkits, all had command-line monitors. – RedGrittyBrick Sep 10 '14 at 20:32
0

The most direct predecessor to the operating system would a combination of standard libraries for interfacing with devices, and the bootstrap loader system for getting a program brought into memory and started running.

Not the answer you're looking for? Browse other questions tagged or ask your own question.