Want to read Slashdot from your mobile device? Point it at m.slashdot.org and keep reading!


Forgot your password?
Check out the new SourceForge HTML5 internet speed test! No Flash necessary and runs on all devices. ×

What Was The First Computer Operating System? 247

somethinsfishy asks: "A shell and a kernel is a fine description of a 'primitive' OS, but back in the days of vacuum tubes and mercury delay lines, a programmer had to be intimately familiar with the hardware. No source I've seen in print or on-line definitely says 'x' is the first OS. I've looked. This seems like it could be a grey area. Any thoughts?"
This discussion has been archived. No new comments can be posted.

What was the First Computer Operating System?

Comments Filter:
  • Version 2 (which included support for subroutines, amongst other incredible inventions) was introduced on August 1949. It loaded the program, translated it from what could be described as a simple assembler. As 'Initial Orders 2' added the subroutine stuff; a library function that was used by the program while running, maybe it counts as the first OS. A few details about EDSAC are available here [cam.ac.uk]
  • FORTRAN, however, does predate emacs by quite a few years...
  • Well, it would have supported at least FORTRAN, and I think Lisp was developed on a 7040 or a 7090.

    Rev. Dr. Xenophon Fenderson, the Carbon(d)ated, KSC, DEATH, SubGenius, mhm21x16
  • fyi;

    I've been informed of some brain farts in my post (thanks Clem!).

    First, I don't know why I said MVT stood for "Mutliple Virtual Tasks" instead of "Multiple *Variable* Tasks". I guess my mind was running faster than my fingers and I was already thinking about SVS. MVT didn't have virtual memory.

    Also, Clem reminded me that the second "S"s in SVS and MVS stood for "storage" not "system". My mind is going, I guess, I should have remembered that.

    Finally, Clem mentioned that there was an OS called PCP (Primary Control Program) that came between DOS and MFT.

  • No, VSE/ESA, which is a direct descendent of DOS/VSA, is still sold and supported by IBM.

    Also, the OS/390 does *not* have a Unix Kernel, but it can support a POSIX compliant program program (TCP/IP, Hierarchical directories, etc.) under OS/390. Yes, you can do Unix development on a mainframe, under a mainframe operating system, and recompile that application under Unix.
  • Yup, mainfames still use JCL. They also,

    - use REXX and CLIST as batch scripting languages, giving the mainframe user access to any feature hosted on the box (batch processes, LU6.2 and TCP/IP communications, etc.)

    - support transnational networks with a single point of control.

    - support 200 to 300 simultaneous users with 10 to 15 large scale batch processes all running concurrently.

    - support tetra-byte size databases with response times measured in single seconds.

    - etc., etc., etc.,

    PC's never took over. PC's added to the mix and skill set that professionals learn and understand.
  • hehe, that's straight out of the Bill Gates marketing book! At least Bill knew that his was the first internet ready OS, the UNIX systems that were on the internet before then just weren't ready for it were they? IE2 was also ahead of its times with support for things like the marquee tag which made Netscape innovations such as frames and tables.

    Ahh well you can tell from your post you were taking the piss. Mark the AC as funny :)
  • was built by Konrad Zuse who probably was the
    first hacker too since the living room of his
    parents appartment was pretty completely filled
    out by his computer in 1941.

    Zuse [t-online.de]

  • Did not come into existance until 1974. If you are going to spout off at least know your stuff. The "Internet" and related techologies did not come until the 1980's and that technology was created by a working group at Berkley with funding from DARPA.
  • Well, they do have to post up to ten stories a day. Sometimes even three or four per person. That's a story every, what, 2 hours? Whew, what a workload. Glad I'm not doing it.
  • Actually, I think one of the Remington-Rand systems (like the 1101, for Project 13) had an early effort at an operating system.

    There was also the IBM 1401, IBM 7090 in the same era.

    Most of the "Operating Systems" of that era were not that much more functional than CP/M-80, delivering an ability to to handle I/O as a reasonably abstract call w/o needing to know what the I/O addresses were and writing the necessary channel program.
    Beyond the "Monitor" routines (for these I/O services) were additional layers to load in programs from the specified media (early JCL).

    You'll need someone a bit older than me (46yo) who dates back to the days when programmers were still called "logicians".

    My wife's one great aunt is 95+ and, during the 1920s, held a job AS a COMPUTER. Sheesh, times change. (In those days, apparently I/O was handled by the boys carrying the ledgers to/from the shelves.)

    "When I was your age, we didn't have none of these fancy graphics you kids have, no, if we wanted to see pictures, we ran jobs out to the card punch and held the deck up to the light!"

  • There are some jobs that Mainframes are better at.
    There are times when record-oriented I/O (rather than character oriented) makes more sense. (Just not very often)

    All kidding aside, there are some things that mainframes excel at:

    • Single Thread Performance - Some tasks CANNOT be easily subdivided. While a sort may be subdivided, merging all of the little sorted files is still a singly-threaded task; Balancing B-Trees in a DataBase key space is closely related (which is one of the reasons that adding a new row to a database is just about the most expensive single operation you can perform).
    • I/O Bandwidth - In order to keep the above fed, the I/O model takes no prisoners (and cuts few, if any, corners financially) to move data in and out of main memory.
    • I/O Connectivity - All of the above bandwidth doesn't do you much good if you only remove the chokepoint for a limited set of devices, so a mainframe makes sure that there are few (if any) limitations on I/O connectivity with the excellent bandwidth.

    IBM's channel architecture (originally seen on the S/360) was mimicked by Xerox (Sigma Series) as well as Sperry-UNIVAC (in the 1100/40 and later systems). This architecture, while best for record-oriented I/O, did it's utmost to move the data where it was needed in order to keep the processor fed.

    When CPUs exceeded I/O speeds by a huge margin (happening with the 7090s, for instance) the advantage of having multiple programs running simultaneously started to make sense.

    BTW- an early OS on the 709/7090 was CTSS - the Compatible Time Sharing System. Much that was implemented there ended up in VM/CMS.

  • Even better, the paper tape speed was limited due to the problem of disintigration at even higher speeds! 8)
  • If we define an OS as a means for scheduling hardware usage, then the first OS must have been the clipboard outside the lab!
  • I don't think this is a really easy question to answer. Originally, jobs were scheduled by a person, where the whole machine was available to one program at a time, and you had a person manually entering jobs on cards. This person was replaced with a program which scheduled the programs called "The Resident Monitor". AFAIK, this was the first job control program, but this is the stuff that led to developing OSs, certainly not a full fledged OS in and of itself.
  • Actually, if you are interested, MVT can be downloaded and run via the s/360 emulator, Hercules.

  • IBM probably started it with the 360, but maybe GE was first. I was with Honeywell from 1964, and when the H200 was introduced they didn't call any of the software OS200. That came later probably 66/67. Before that everything was done by people. Most everyting was batch, and on larger systems punched cards controlled things, and the OS were called Operators. They mounted tapes, and often controlled or changed the jobs through the console card reader.

    I didn't see much Interactive stuff 'till we joined with GE in 1968. Gecos was there then, and I can recall logging in to Dartmouth College on a GE hardcopy terminal to have my first exposure to Basic.

    BTW if you look in the Password file layout in your Linux (or any othe Unix like) system, you'll see that the GECOS field is still there.
  • Well I guess I was wrong in my earlier comment. The Mercury system used by Metropolitan Life Insurance from 1960 on their Honeywell 800 machines did this. I always considered it a program loader but it did allocate memory to different programs as they were loaded. The rest of the job was looked after by the H-800 hardware.

    The standard configuration used 8 Mag tapes, and was able to run 2 or 3 jobs simultaneously on the multitasking hardware. The hardware itself was capable of running up to 8 programs at once, but I/O considerations kept the practical number low.

    Job scheduling was done using JCL, fed through a card reader. The machines were not particularly reliable by today's standard, but you could usually run a small diagnostic in an unused program group to help isolate a problem while the machine was still running.

    The whole thing, though, was never considered an "Operating System". By '65 though IBM claimed TOS for the 7040/7090, and DOS as well for the machines that had disks. At that time these things were not much more than program loaders, and those machines did not multitask.
  • Oh, and TWM is much prettier? Don't forget how old this is...
  • I belive that the operating systems on IBM 7090 as well as IBM 1800 series machines predated the OS/360 which cam as late as mid 1960's
  • Nothing wrong with it. twm is still great when low CPU load is needed. And it is very easy to configure.

    X-Window + twm is, IMHO, more powerful than MS Windows. But who do still remind twm ? everybody knows MS Windows, even if they don't own a computer or own a MAC/Unix station.

    That's how the history is written, by what the people know well... The less known facts are shadowed by the most known. Even if that lead to inaccurate information...

    Most of the people forget that steam engine was discovered by the greeks, BC. (steam machine from Heron). The ancient greek did use science for amusement only. It was funny, not useful. Even if in mathematics we use very often the fact that only one line may contain 2 given points, who still think of this as one of the Euclide's postulates ? It's something that everybody know as "common sense" and don't try to put a name on it.
  • Remember also that this was with "magnetic drums" -- to write any data to disk you had to know the hardware and the controller very well to optimize writing and reading (transfer rate were, of course abysmal).

    Seek time was nice however, with one head per track. A 1960 drum beats a 1990 harddisk. :-)

  • This is Bugs, very low quality UK TV. Accuracy would not have been a concern. They probably did claim a PC had 10Gig of RAM, and was intelligent.
  • by ibis ( 16191 )
    I think the first OS with a kernel was the OS for the RC 4000, circa 1963. This predates OS/360 by a couple of years. I grabbed the following blurb from a dead web site via the Google cache.

    Developed by Brinch Hansen the RC 4000 system had a very interesting and innovative feature. Hansen implemented a layered OS in the RC system which featured something called the kernel at the center. The kernel was responsible for the primary OS functionality. The kernel featured a round robin CPU scheduler, it allowed processes to share memory, and it also produced messages. The idea behind the kernel was to separate the functionality of the OS, with the kernel handling the most important and basic hardware interactions. Today the kernel is an important part of most modern operating systems.
  • Quite a bit of that happend.
    While your Dad was just playing around and had no plans for his code quite often the theft was of code the original author had quite a few plans for.
    Hence GPL...

    GPL is basicly "I have given this to the world... Don't you dare take it away"
    Thats pritty much the whole idea behind open source liccenses.

    To address liccens war...
    No I would agree BSD is more free than GPL but whats even the point of the BSD liccens? It dosn't even try to address the problem of code theft and instead says "Yeah it's ok to turn it into a product". Thats cool for BSD etc where the whole objective is to create a product in the end anyway.
    To me thow for the avrage open source develuper who isn't trying to make money but trying to give something to the community. The GPL is saying "This is for everyone.. and so are it's changes...". Otherwise it's just public domain...
  • Since the first computer was the Jacquard Loom [vt.edu], wouldn't the first OS be the programmer creating the instruction cards?
  • by Anonymous Coward
    According to http://www.cs.bris.ac.uk/~ch6574/course/os_hist.ht ml the first Operating System was the IBM 709/7090 in 1960. It had Standard file usage routines (SYSIN, SYSOUT, SYSUT1, SYSUT2, SYSUT3) and supported programming languages (quite which languages it doesn't say). Hmmm... wonder if there's an emulator? Alex DeLarge http://www.bristol2600.org.uk
  • by Anonymous Coward
    Hmm if Linux development started a bit earlier or had gained momentum quicker it's growth would have been amazing.

    What you fail to realise is that Microsoft had developed a microcomputer version of UNIX (Microsoft Xenix) in 1980, before it bought MS-DOS. Microsoft actually tried to convince IBM to use a 68000 and Xenix in the IBM PC, but IBM refused.

    IBM had several reasons for insisting on a primitive CPU and CP/M-like OS, but the key one was cost. In those days, a microcomputer capable of running a minicomputer system like UNIX was simply too expensive to be feasible. Even in 1985, this was still true (although the 68000 would haven't added much to the cost, and would have avoided the horrors of the 16-bit Intel legacy). It wasn't until 386, 68030 and RISC systems became widely used that microcomputers capable of running systems like UNIX became affordable. Not coincidentally, that's when Microsoft began developing NT (on RISC).

    Early versions of Windows may have been primitive, but the limiting factor was the PC architecture itself. As bad as it was, IBM's original position proved to be the right one. The pricey systems required to run Microsoft OS/2 were rejected by consumers, who stuck with MS-DOS, and later Windows 3.x, because they had much lower hardware demands than OS/2 (or UNIX, or NT). The Mac was also too pricey (and the core OS was even more primitive than Windows 3.x, despite superior hardware).

  • It sucked more than I even remembered ;) BTW http://www.dataservcorp.com/windows.htm [dataservcorp.com] has a history of MS-DOS/Windows and has screenshots for V2 V3 and V3.11 too.
  • Anyone gotta link to some screenshots of Windows 1.0 - I've seen it before and it was a joke, I wonder if the people who haven't seen it have realised how bad it was. Windows 3.1 was a big improvement on it's previous versions. It sucked (badly) but it sucked a lot less! I didn't start using Linux until aroung the time Win95 came out. Hmm if Linux development started a bit earlier or had gained momentum quicker it's growth would have been amazing.
  • You have to especially appreciate the dialog box with the message: "File too large: FaultLog.txt" Guess some things never change...
  • You forget, Windows is written for little-endian processors. That means that the least-significant digit is written first, and the most significant digits are written after it. Notice, there are very few meaningful differences (other than gratuitous file-format changes) between MS-Word 5.0, MS-Word 6.0, MS-Word 7.0 (aka Word95), and MS-Word 8.0 (aka Word97). In contrast, there's a world of difference between MS-DOS 3.2 and MS-DOS 3.3, as well as between MS-Windows 3.0 and 3.1. (Don't even get me started about MS-Windows 3.11.)

    Tongue firmly implanted in cheek....

  • The Mojo system, currently being discussed as an alternative for the new K5, is one.

    The trust metric, as practiced at Advogato, is another.

    The bottom line is that there are Better Ways.
  • It appears that daring to complain that a /. editor can't be bothered to read all the way through a 4-line story is "flamebait". Or perhaps "redundant". No, it's a legitimate complaint. Is it really too much to ask that the editors actually edit?

    Because it's becoming quite clear to me that Slashdot has abandoned any notion of quality journalism in favour of posting stupid questions that could be answered in 5 minutes on Google...

    http://www.computer.org/annals/an1997/a1055abs.h tm

    Ah well. The advertisers get their clicks and that's what matters these days.
  • The guy who asked about dealing with W2K and AD in his UNIX network, now that's worthy.

    Daft little questions that can be answered in a few seconds with Google, that's not.

    A rule of thumb might be "if, with a search engine, you can turn up something that looks like a halfway reasonable answer within 5 minutes, then it's prolly not worth asking".

    And moderation's turned to shite, too; complaining about the editorial state of a post (the spelling's fixed now, I notice) is neither flamebait (do we expect a reasonable standard of spelling and grammar from /. editors or not?), nor offtopic (I'm talking about the sodding post, for gawds sake), nor redundant (I'm not mentioning anything twice...). But moderators don't moderate properly any more, if they ever did. Ho hum.

    Personally, I reckon /. should dump the moderation system and ban anonymous posting, and leave it at that.
  • If you really think about it, the first OS has been the Universe, and the Universe seems a lot like Windows. Ever since 'booting' (ie big bang) since the 'epoch' (0 seconds afterward), it has slowly grown bigger and bigger, and no one really knows when it will stop.

    And we are but the "I Love You" virus running within it? Or just random bits, waiting to be switched off?
  • I used a 110 baud ASCII Teletype connected to a RCA Spectra 70 mainframe via a Bell 103A modem. It was a big improvement over submitting batch jobs on punch cards.

    OS/360 and JCL builds character :-).

  • Intel didn't do anything that was revolutionary with the 8086. The IBM 360 series supported a common instruction set and programmer's model across a wide variety of hardware implementations. DEC did a similar thing with the PDP-8 and PDP-11.

    The 8086 was an much improved version of the 8080 and MS-DOS was a clone of CP/M-80, nothing revolutionary there. The 8087 was a true innovation, the predecessor of what became IEEE floating point.

  • UNIX was the first operating system that I had seen that made the user command processor an ordinary program that could be modified or replaced by the user.

    Are there any earlier examples of this?

    Other operating systems that I had used, such as RT-11 and RSX-11, put the user command processor in the kernel or made it a special privileged task that directly mucked around in the kernel.

  • Yes, in those days, they actually had an IBM engineer working full-time on the client site.

    That still goes on, most of the larger shops have a full time IBM CE on site.

    The scenerio you described is right on the mark. That happened constantly, and usually the code contributers were happy about. Remember in those days, everything was "open source". It wasn't until IBM dropped MVT for MVS and HASP for JESx that things got closed up.

    My shop (PSU) was responsible for a good portion of the development in JES2, the job entry subsystem used by most s/390 shops.

  • then i should imagine that something such as OS/390 & JCL would be one of the first (Though there may be earlier still).

    OS/390 is a pretty new name for MVS (multiple variable storage) and JCL is simply a Job Control Language, that's right, it's a language.

    The earliest s/360 operating system I'm aware of is MVT (open source, IIRC), the job entry system was called HASP.

  • MFT, yeah I DID know that was before MVT, I just forgot. Oh well, hey, It was all before I was born, I'm still trying to learn the history :)

    I didn't know DOS was first though, interesting.

  • The answer to that question may change a lot to what was the 1st OS.

    - may it be the hardware and hardcoded software used to boot from a punch card/band ? I admit this is more the definition of the BIOS.. But, as far as the entry/launchin of programs was done with these cards, it was also the part that allowed to run programs

    - May a simple hex monitor be called OS ? It allows to enter programs and to run them...

    - Must there be the complex structure of task handling (even if only 1 task is supported, like in DOS), memory management,... ?

    - what about computers like the ZX80 ? There was only the BASIC interpreter. May we speak of OS when speaking of these machines ?

    Anyway, CP/M was before QDOS which was before MS DOS... for the rest, I can't tell.
  • What's interesting is, by this standard, microsoft has yet to make an operating system.

    *snort* I'd say, by any standard, Microsoft has yet to make an operating system. ;-)
  • Hey! I just saw something I've been looking for (well, kinda) for some time now.

    This screenshot [fsnet.co.uk] includes an image (opened in a bitmap editor) of a chess board being tilted and a few chess pieces flying off of it.

    I used to have this graphic as my background in PC/GEOS (AKA GeoWorks). In fact, I still have a copy of it, but it is in some propriatary image format that only PC/GEOS knows about.

    Does anyone know where this image came from? Did it come with Windows, originally? And where can I get a copy of it in GIF or JPEG format?
  • What are you talking about? Windows *is* a command-line DOS shell with heavy makeup ;-)
  • Now go look at early Mac screenshots and compare.

    The point being, Windows 1.0 looked awful because pretty much all GUIs looked awful at the time, to our modern eyes. You've got 15 years worth of GUI development colouring your judgement there.

    I mean, even those early PARC systems (dammit, the name escapes me) on which the Apple Lisa was based look pretty damn ugly now. However, in 1984 (or whenever) when all you were used to was a green-screen or CLI, any one of these things was a real glimpse into the future(*).

    (*) = Except Windows 1.0 which looked like a command-line DOS shell with heavy makeup.

  • Well, UNIX is older than that (1969) and we should all know that it was based on the MULTICS project from before that. My money's on an earlier IBM OS. By your admission though, RSX-11M proceeds VMS (which was later renamed OpenVMS). You know, the chief architects of the WinNT kernel were big VMS designers, so you could argue using that logic that WinNT is the first OS too. <g>

    I wish I had my OS class's textbook handy.
  • Is anyone else reminded of the Apple IIGS's GUI system? Man, at least that one has seperate windows. I can't see Apple making its case about UI theft until at least Windows 2.0. I had no idea that it was so pathetic.
  • The first OS would be some program whose prorammer said to another programmer: "Here, load this in front of your code, I've alredy coded function X, all you have to do is call it". In other words, it's the 'wheel program' (as in reinventing the wheel)
    Anybody know who invented the wheel? Me neither. My guess is that every manufacturer of hardware came up with the concept more or less at the same time, out of need, and independently. We'll never really be able to pin it down.

    OTOH, who commercialized the first OS is a different question, and my money would be on IBM.

  • There's nothing even remotely constituting an operating system on the abacus. Every operation that can be performed with an abacus has to be manually done by actually interfacing with the hardware.


    "You can't shake the Devil's hand and say you're only kidding."

  • Actually Colossus was not created to break Engima, Enigma was broken using the Bombes, which were machines based on a Polish design.

    Colossus tacked the much more difficult Lorenz Cipher (aka the Fish cipher) used starting in 1941 for the most important communications between Hitler and his generals.

    Really the most amazing thing about Colossus was not that it was a programmable computer (sure that's cool) but that it could read paper teleprinter tape at 30 miles per hour (5k characters per second!). It could operate on 5 tapes in parallel, processing 25k of data per second - about the speed of a broadband connection today!
  • Dos couldn't handle anything more then 640k, actualy.
    Well, there was the Lotus-Intel-Microsoft paging scheme, "expanded memory", where you could page parts of that 640k on to and off off an expansion card. Don't recall if DOS itself had anything to do with supporting it, though.
  • I am reminded of Mel, a Real Programmer [afn.org]
  • I remember accomplishing installing Windows 3.0 on a 10 meg hard drive on my old 286. Needless to say, I cut a LOT of corners.

    I also remember seeing a Windows 3.0 knockoff in Extended Basic on the TI-994/A. Instead of a mouse, you used the joystick to load up different programs. Scary.
  • I was speaking of Win3.0, not 3.1.

    Oh. I don't really know the differences between the two, but considering it's only a difference of 0.1, I wouldn't think it would be that huge...

    Oh well.


  • Wasn't it... 320x480x16 was what it displayed, but you had to edit/create one at 640x480

    Yeah, that sounds like it. And doesn't 95/98 do the same thing in reverse? (Bootup logo is 320x480 or something, and the width is doubled when it's displayed)


  • C:\windows\system\winlogo.rle
    A run-length encoded bitmap file, 640x480x16

    Actually, IIRC, it was something like 320x480x16. Either that or it was 640x480 but got shrunk. They did something weird to it.

    And it wasn't that simple to mess with, either. You needed to create a new win.com file, by using the COPY command to concatenate a bunch of binary files...

    The last time I messed with that was, believe it or not, just two and a half years ago. I was actually using Win3.1 on my (t)rusty 486 back then. Yikes! =)


  • Here's a relevant quote from Dietel's OS book:

    "The General Motors Research Laboratories are credited with implementing the first operating system in the early 1950s for their IBM 701. In 1955, GM and North American Aviation cooperated on an operating system for the IBM 704. The IBM user organization, SHARE, fostered discussion on operating systems, and by 1957 many home-grown operating systems for the 704 had been developed."

    "Home-grown" OSes were popular at the beginning and now are popular again (would you call Linux "home-grown"?) -- I guess history does repeat itself!

  • I agree. As far as I can tell, CTSS was probably the first "real" OS, in the sense of a software system allowing multiple programmers to use the machine without loading up the hardware from scratch for each new program run.

    I would have voted for JOSS, Rand Corporation's Johnniac Open Shop System, except that a posting from Willis Ware some time back pretty firmly gave his opinion that JOSS was not a true OS. Could have fooled me, but Willis is one of the very few people I'll defer to in such matters.
  • I'll do better. Somewhere, I have a .zip archive of the install floppies. I'll have to track down what Cd that's on, but I can put 'em on a page somewhere or something...
  • OK, here is some stuff I know about the DOS you mentioned. The DOS (disk operating system) came after TOS (tape operating system). It was out there before OS/360 etc. and instead of dying, continued on. DOS/VSE became VSE/ESA (eventually), and, believe it or not, VSE/ESA 2.4 was released last year!

    AFAIK, IBM wanted VSE to die, so as to allow the OS/390 juggernaut to take up these users - but people a) seem to like the primitive VSE (yeah, the cylinder/track thing is f%$^&ing annoying), and b) if someone is going to switch from VSE - they might not go to another mainframe OS.

    The VSE development is now done in Germany(?) if I recall correctly - some IBM politics is involved here as well..
  • <rant type="pointless">

    Apparently people don't know the true value of Ask Slashdot.

    It is *not* so the guy who asks the question gets the answer. It is so that guys like me, who idly wonder about things like "who made the first OS" or "so who do I buy music from now that I'm boycotting the RIAA" or "what did CmdrTaco eat for breakfast this morning? Cold Pizza?" can get the answer.

    To repeat, the average /. reader, who might wonder about who made the first OS, but doesn't care enough to ask, is the one that benefits, not the guy who asked the question. I learned something, but apparently you're too busy bitching to have learned much at all.

    To quote somebody's sig, this is a lot like science, which is a lot like sex: something useful might come out of it (in this case, the comments from Ask Slashdot), but that's not why we do it.

  • The "processor" was just 5 characters of 5 bits held in a shit register.

    I know the UK was suffering greatly from wartime shortages just then, but couldn't they have found a more sanitary material to make the registers out of?

  • . . "It's really not an operating system until it's multi platform and is separated from the hardware enough (not written close to the machine) to allow porting to other machines."
    I think this is an applicable parameter when judging weather an operating system is really matured enough to become an OS.

    What's interesting is, by this standard, microsoft has yet to make an operating system.

  • We are all carrying around the first operating system in our skulls

    We just haven't reverse-engineered it enough to understand it.

    {nitpik} Ok, we're probably on version 1.18E29 of our operating system. There seems to be quite a bit of legacy code still there though.


  • Didn't you hear? Al Gore announced yesterday that he invented the first OS, Gorux. Like its precursor, ClintONIAC, it ran with periods of brilliance but got bogged down when the software was tinkered with.
  • FORTRAN interpreters

    Can't recall ever meeting an interpreter for Fortran. Were there such beasties ?

    Just to do some flag-waving for the Brits, I'd say that LEO was the first machine with a recognisable OS.

  • But Windows 1.0 looks like it was made in Stondeage. =) I liked the sentence which I've read in some PC Mag. Windows 1.1 German is out. Now European users can do nothing usefull with it as well!
  • LOL
    Notice the "Free Memory" on the screenshots..
    Windows 1.1 - 618k free
    Windows 2.3 - 405k free
    Windows 3.0a - 396k free

    Back then, they knew allready how to hog memory! =)
  • Well, interesting what you can find on Google. From http://www.cs.wvu.edu/~jdm/ classes/cs258/OScat/batch.html [wvu.edu]

    Generic name for operating systems for the IBM S/360, and later S/370. First version released 1966 [Mealy et al 1966]. See also OS/PCP, OS/MFT, OS/MVT, OS/VS1, OS/SVS, and OS/MVS.

    So, thats 1966 for version 1 of OS/360.

    Multiprogramming with a Fixed number of Tasks. Simple version of OS/MVT suitable for processors with limited memory. First release 1967, substantial revision 1968. [Mealy et al 1966, Auslander et al 1981].

    Thats 1967 for OS/MFT. Which means OS/360 is the earliest IBM version (That i can find). There are also some others such as SUE and POS, but they only give dates of "late 1960's", so i can't tell if these are earlier than 1966 or not. But hey, i think we're getting close ;)
  • Screenshots, nothing. You can actually download a copy of it here [abandonkeep.com] in the Apps section.

    On a related note, though, I used to have an old AT with something called GEM installed on it. Anyone remember that?

  • EDVAC's was probably the first. None of the earlier machines had anything like an operating system; programs were loaded individually using manual controls, or worse, plugboards, as with the ENIAC.

    The UNIVAC I (Universal Automatic Computer) may have had an operating system, and its first deliveries were in 1951. (EDVAC didn't come up until 1952.) The UNIVAC I was the first computer that was a real product - a number were made and sold commercially. Everything earlier was either a one-off or a special-purpose machine. The UNIVAC I looked like a computer - lots of tape drives, a big console with a typewriter and controls, and a CPU so big it had a door in the side so maintenance people could go in. The tube CPU was completely duplicated for self-checking, so the results were reliable. UNIVAC I machines processed the 1950 census, were used by Met Life, and did heavy data processing for big institutions of the 1950s.

    Eventually there was an OS of sorts for the UNIVAC 1, but I don't know when the OS shipped. It may not have been available with first shipments.

  • yes, DC (direct current) was the first o/s.

    flip a switch (aka, the input portion of the first UI) and a light (output part of the first UI) came on.

    still miles ahead of messy-dos and its ilk.

    and upgrade fees are less than a dollar.


  • The www would probably not exist in the form most people acknowledge it (I'm not talking about computer gurus, I mean the average joe who would be scared to tears at the thought of spending countless hours using something like lynx or Gopher to browse)

    And the world would be a happier place.

  • Something I found... A Brief History of Computer Operating Systems The Bare Machine Stacked Job Batch Systems (mid 1950s - mid 1960s) A batch system is one in which jobs are bundled together with the instructions necessary to allow them to be processed without intervention. Often jobs of a similar nature can be bundled together to further increase economy The basic physical layout of the memory of a batch job computer is shown below: -------------------------------------- | | | Monitor (permanently resident) | | | -------------------------------------- | | | User Space | | (compilers, programs, data, etc.) | | | -------------------------------------- The monitor is system software that is responsible for interpreting and carrying out the instructions in the batch jobs. When the monitor started a job, it handed over control of the entire computer to the job, which then controlled the computer until it finished. A sample of several batch jobs might look like: $JOB user_spec ; identify the user for accounting purposes $FORTRAN ; load the FORTRAN compiler source program cards $LOAD ; load the compiled program $RUN ; run the program data cards $EOJ ; end of job $JOB user_spec ; identify a new user $LOAD application $RUN data $EOJ Often magnetic tapes and drums were used to store intermediate data and compiled programs. Advantages of batch systems move much of the work of the operator to the computer increased performance since it was possible for job to start as soon as the previous job finished Disadvantages turn-around time can be large from user standpoint more difficult to debug program due to lack of protection scheme, one batch job can affect pending jobs (read too many cards, etc) a job could corrupt the monitor, thus affecting pending jobs a job could enter an infinite loop As mentioned above, one of the major shortcomings of early batch systems was that there was no protection scheme to prevent one job from adversely affecting other jobs. The solution to this was a simple protection scheme, where certain memory (e.g. where the monitor resides) were made off-limits to user programs. This prevented user programs from corrupting the monitor. To keep user programs from reading too many (or not enough) cards, the hardware was changed to allow the computer to operate in one of two modes: one for the monitor and one for the user programs. IO could only be performed in monitor mode, so that IO requests from the user programs were passed to the monitor. In this way, the monitor could keep a job from reading past it's on $EOJ card. To prevent an infinite loop, a timer was added to the system and the $JOB card was modified so that a maximum execution time for the job was passed to the monitor. The computer would interrupt the job and return control to the monitor when this time was exceeded. Spooling Batch Systems (mid 1960s - late 1970s) One difficulty with simple batch systems is that the computer still needs to read the the deck of cards before it can begin to execute the job. This means that the CPU is idle (or nearly so) during these relatively slow operations. Since it is faster to read from a magnetic tape than from a deck of cards, it became common for computer centers to have one or more less powerful computers in addition to there main computer. The smaller computers were used to read a decks of cards onto a tape, so that the tape would contain many batch jobs. This tape was then loaded on the main computer and the jobs on the tape were executed. The output from the jobs would be written to another tape which would then be removed and loaded on a less powerful computer to produce any hardcopy or other desired output. It was a logical extension of the timer idea described above to have a timer that would only let jobs execute for a short time before interrupting them so that the monitor could start an IO operation. Since the IO operation could proceed while the CPU was crunching on a user program, little degradation in performance was noticed. Since the computer can now perform IO in parallel with computation, it became possible to have the computer read a deck of cards to a tape, drum or disk and to write out to a tape printer while it was computing. This process is called SPOOLing: Simultaneous Peripheral Operation OnLine. Spooling batch systems were the first and are the simplest of the multiprogramming systems. One advantage of spooling batch systems was that the output from jobs was available as soon as the job completed, rather than only after all jobs in the current cycle were finished. Multiprogramming Systems (1960s - present) As machines with more and more memory became available, it was possible to extend the idea of multiprogramming (or multiprocessing) as used in spooling batch systems to create systems that would load several jobs into memory at once and cycle through them in some order, working on each one for a specified period of time. -------------------------------------- | Monitor | | (more like a operating system) | -------------------------------------- | User program 1 | -------------------------------------- | User program 2 | -------------------------------------- | User program 3 | -------------------------------------- | User program 4 | -------------------------------------- At this point the monitor is growing to the point where it begins to resemble a modern operating system. It is responsible for: starting user jobs spooling operations IO for user jobs switching between user jobs ensuring proper protection while doing the above As a simple, yet common example, consider a machine that can run two jobs at once. Further, suppose that one job is IO intensive and that the other is CPU intensive. One way for the monitor to allocate CPU time between these jobs would be to divide time equally between them. However, the CPU would be idle much of the time the IO bound process was executing. A good solution in this case is to allow the CPU bound process (the background job) to execute until the IO bound process (the foreground job) needs some CPU time, at which point the monitor permits it to run. Presumably it will soon need to do some IO and the monitor can return the CPU to the background job. Timesharing Systems (1970s - present) Back in the days of the "bare" computers without any operating system to speak of, the programmer had complete access to the machine. As hardware and software was developed to create monitors, simple and spooling batch systems and finally multiprogrammed systems, the separation between the user and the computer became more and more pronounced. Users, and programmers in particular, longed to be able to "get to the machine" without having to go through the batch process. In the 1970s and especially in the 1980s this became possible two different ways. The first involved timesharing or timeslicing. The idea of multiprogramming was extended to allow for multiple terminals to be connected to the computer, with each in-use terminal being associated with one or more jobs on the computer. The operating system is responsible for switching between the jobs, now often called processes, in such a way that favored user interaction. If the context-switches occurred quickly enough, the user had the impression that he or she had direct access to the computer. Interactive processes are given a higher priority so that when IO is requested (e.g. a key is pressed), the associated process is quickly given control of the CPU so that it can process it. This is usually done through the use of an interrupt that causes the computer to realize that an IO event has occurred. It should be mentioned that there are several different types of time sharing systems. One type is represented by computers like our VAX/VMS computers and UNIX workstations. In these computers entire processes are in memory (albeit virtual memory) and the computer switches between executing code in each of them. In other types of systems, such as airline reservation systems, a single application may actually do much of the timesharing between terminals. This way there does not need to be a different running program associated with each terminal. Personal Computers The second way that programmers and users got back at the machine was the advent of personal computers around 1980. Finally computers became small enough and inexpensive enough that an individual could own one, and hence have complete access to it. Real-Time, Multiprocessor, and Distributed/Networked Systems A real-time computer is one that execute programs that are guaranteed to have an upper bound on tasks that they carry out. Usually it is desired that the upper bound be very small. Examples included guided missile systems and medical monitoring equipment. The operating system on real-time computers is severely constrained by the timing requirements. Dedicated computers are special purpose computers that are used to perform only one or more tasks. Often these are real-time computers and include applications such as the guided missile mentioned above and the computer in modern cars that controls the fuel injection system. A multiprocessor computer is one with more than one CPU. The category of multiprocessor computers can be divided into the following sub-categories: shared memory multiprocessors have multiple CPUs, all with access to the same memory. Communication between the the processors is easy to implement, but care must be taken so that memory accesses are synchronized. distributed memory multiprocessors also have multiple CPUs, but each CPU has it's own associated memory. Here, memory access synchronization is not a problem, but communication between the processors is often slow and complicated. Related to multiprocessors are the following: networked systems consist of multiple computers that are networked together, usually with a common operating system and shared resources. Users, however, are aware of the different computers that make up the system. distributed systems also consist of multiple computers but differ from networked systems in that the multiple computers are transparent to the user. Often there are redundant resources and a sharing of the workload among the different computers, but this is all transparent to the user.
  • Actually, if by "drums," you mean 20+ foot long concrete pipes coated in metal, there are interesting facts about them (of course):

    Apparently on ships in the US navy, they would cause the ship to turn to one side due to gyroscopic forces when they had several aboard. I think they got nicknamed "rotation storage batteries" or something like that. That was until they had equal numbers turning the opposite direction.

    Also, there was a window all the way up the side so you could see a head crash (many heads, you're not going to take it apart and check each one!)
    You'd just look for the band of sparks around the pipe at one point as the head drags on the (not perfectly smooth,) pipe.
  • Technology has, somehow, changed the way we "define" things. According to the latest cultural trend, an operating system is: "the program that, after being initially loaded into the computer by a boot program, manages all the other programs in a computer. (editor's comment: wtf is that redundancy about?!) The other programs are called applications. The applications make use of the operating system by making requests for services through a defined application program interface (application program interface). In addition, users can interact directly with the operating system through an interface such as a command language. (according to whatis.com).

    Now, an operating system, traditionally speaking, is a piece of "code" (to put it somehow), that allows a user to perform operations (thus, the OPERATING system). The evolution of semiotics in the last 15 or 20 years has made it possible that we only associate "operating system" with "software". (Sign and significant associations mostly related to social influences).

    I will indulge myself with a digression: what if we divert our attention from the actual social influence of Operating system and take it one step further? What would be the first Operating system then? I mean, as in a "code that allows a user to perform operations through hardware".

    Maybe I am wrong, but I found Blas Pascal's calculator from 1,642 as the first machine that fits that definition.

  • IBM DOS/VS on the Series 3 mainframe. It provided a software Kernel and a shell, albiet using core memory and punch cards for I/O. Support for tape was added in release 2.4 and finally removable disks in the next release. This OS was replaced by DOS/VSE on the 370 and 43XX series mainframes. Finally DOS/VSE was superceded by VM and MVS. The current incarnation is OS/390 which has a Unix Kernel.:)
  • by hawk ( 1151 ) <hawk@eyry.org> on Friday August 25, 2000 @06:29AM (#828980) Journal
    ENIAC ripped off many of its innovations from the ABC, the Atanasff Berry Computer at Iowa State. The page for the machine is currently down, but a pair of replicas were recently built. You can find an article at http://www.alumni.iastate.edu/events/abcreplica.ht m. If you search for "Atanasoff Berry Computer" at the http://www.iastate.edu homepage, you'll find plenty of information.

    In a nutsheell, Atanasoff and hs graduate student Berry built the machine in the thirties to solve 17 simultaneous equations in 17 variables. ISU claims it as the first electronic digital computer. It used vacuum tube logic (small interchangable sub-chassis with a handfull of tubes), was apparently the first to use base 2 rather than 10, the first to have regenerative memory (rotating drums of capacitors), and something else important that I forget :)

    Atanasoff was called off to the Manhattan project, and the machine was taken apart for parts.

    The machine came to light during litigation over ENIAC's patents. Not only was the ABC prior art, but it's builders went to ISU and were shown the details of the ABC--which they then used and patented.

    WHen the replica project started, they found no schematics for large portions, and had to use photographs. Finding parts wasn't as bad as might be suspected, though--when they dug out ancient purchase orders to find out what parts were used, it turned out that some of the same warehouses still stocked the same parts--including the weird paper that they used for output by electrically charring it, iirc .

    Two replicas were built, one to reside permanently at the Smithsonian, and the other to tour. One (I'm not sure which) was actually fired up to solve a problem--once.

  • by hawk ( 1151 ) <hawk@eyry.org> on Friday August 25, 2000 @06:50AM (#828981) Journal
    Look at the history at http://home.san.rr.com/deans/lisagui.html

    It includes screen mockups from *before* the PARC vist. PARC certainly influencd the Lisa, but it wasn't the origin.

  • by ptomblin ( 1378 ) <ptomblin@xcski.com> on Friday August 25, 2000 @02:19AM (#828982) Homepage Journal
    I'm pretty sure the IBM/360 was the first system to use a layer of abstraction to separate the programmers from the hardware, so that they could write programs that would run on a wide variety of computers. One result of that was that you had a few operating systems that ran on these machines.
  • by wayne ( 1579 ) <wayne@schlitt.net> on Friday August 25, 2000 @04:44AM (#828983) Homepage Journal
    If I recall correctly, the order that the operating systems that were created for the IBM 360/370/390 were as follows:

    DOS -- This was a quick and dirty operating system that was created only because the "real" operating system was way behind schedule and they need something for their new hardware. It was expected to disappear soon after OS/MFT was released, but survived at least into the 80's, 20 years longer than expected. Even in the 80's, you had to figure out where to place your files by hand, by specifying the cylinder/track/block address and length in your job specification. The IBM "DOS" was much more primative than the MS "DOS" available at the same time.

    MFT - Multiple Fixed Tasks. This was a multi-tasking operating system, although each program was assigned a block of memory that was a fixed size. No virtual memory, but it had most everything else that people think of an OS having.

    MVT - Multiple Virtual Tasks. This allowed each program to use up variable amounts of memory, although they got a default region of a certain sized based on the "class" of the job that was submitted. If a program need more memory, but there was already a program running at the end of the current programs region, the first program would have to wait until the other program finished before it would continue.

    SVS -- Single Virtual System. Virtual Memory was introduced in this release. All virtual memory was created in a single large address space (16MB virtual on a 1-4MB of physical), and then an MVT type operating system was run in that virtual memory. The advantage was that the initial default memory regions could be "huge", so the chances of a program running out of space was greatly reduced.

    MVS -- Multiple Virtual System. Each program was allocated its own address space.

    Many of the systems writen for these early (pre-1980) mainframes were incredibly efficient. At the University of Nebraska, we had one of the earliest timeshare systems created called the "Nebraska University Remote Operating System" or NUROS. In 256KB of program storage, it supported around 240 users, each was able to edit files, submit jobs, view the output of the jobs, create/delete files, etc. Yes, that's right, about 1KB of memory per person. Well, sort of, as the 2260 and 3270 terminals contained another 2KB of memory that people edit most of their actual editing on. (24 lines by 80 characters = 1960 bytes)

    Oh, it was a state of the art system ca 1970 when it was created, but there is a reason why Unix survived and it didn't. :->

  • by linuxci ( 3530 ) on Friday August 25, 2000 @02:24AM (#828984)
    In a few year time the average member of the public will be convinced that Windows was the first OS, DOS didn't exist and Microsoft invented the Internet in association with Al Gore.

    I've seen a serious answer to the question somewhere but can't remember what it was. I'll have a dig about and if I find something I'll let you know :)
  • by Detritus ( 11846 ) on Friday August 25, 2000 @04:02AM (#828985) Homepage
    Can't recall ever meeting an interpreter for Fortran. Were there such beasties ?

    I'm not sure if you could call it a true interpreter, but WATFOR (Waterloo FORTRAN) was a "load-and-go" FORTRAN compiler that compiled directly into core from the user's source code. A history of Waterloo FORTRAN can be read here [uwaterloo.ca]. From the user's point of view, it behaved like a FORTRAN interpreter.

    In later years, I used DEC FORTRAN on RT-11. This compiled into threaded code with a large run-time package. I'm not sure how to classify it.

  • by hey! ( 33014 ) on Friday August 25, 2000 @03:54AM (#828986) Homepage Journal
    The Compatible Time Sharing System (CTSS) would qualify as the earliest thing I can think of that we'd recognize as a modern OS.

    There probably is not a sharp dividing line between simple batch job management systems and a real operating system, but CTSS managed multiple processes by giving them timeslices so each process (user)would think it had its own computer -- in other words it abstracted the underlying computer and the fact that multiple processes were accessing the hardware.

    There's an interesting parallel to programming languages. Algol was clean and elegant and lead to the recherche PL/1. C, in part, was designed by negating the basic premise of PL/1 -- that a language should be rich in features. Instead of cosseting the programmer with a huge array of facilities, C seeks to get out of the programmer's way by providing just the essentials.

    Likewise CTSS was a great technical success and directly lead to the brilliant but overblown Multics. And of course, Multics begat Unix, or at least strongly influenced its designers to avoid what we would now call "bloat".

    I think there's a kind of object lesson here which applies to some of the news we've discussing recently. Back in the day, computers were godawful expensive. This means there were unthinkable quantities of resources thrown into Multics, which while it pioneered many important concepts we now take for granted, was almost undoubtedly too big and complex. It certainly can't be considered a totally unqualified success -- for one thing its complexity required special hardware support which ruled out porting to other hardware. Unix again was developed originally on a shoestring which dictated a minimalist approach which fostered greater flexibility.

    So -- resources are nice to have, if you have the acuity to use them wisely. But in the end simplicity and adaptability count for more.
  • by edp ( 171151 ) on Friday August 25, 2000 @03:45AM (#828987) Homepage

    It was Maurice Wilkes, 1949:

    • As soon as we started programming, we found to our surprise that it wasn't as easy to get programs right as we had thought. Debugging had to be discovered. I can remember the exact instant when I realized that a large part of my life from then on was going to be spent in finding mistakes in my own programs.

  • by m9 ( 226271 ) on Friday August 25, 2000 @04:45AM (#828988)
  • by knarf ( 34928 ) on Friday August 25, 2000 @02:46AM (#828989) Homepage
    Well, it might not be the very first OS, but is is (one of) the first which provides hardware abstraction, compatibility and scalabiity: IBM OS/360. And now you can try it for yourself:
    • The Hercules System/370 and ESA/390 Emulator [conmicro.cx]
      Hercules is a System/370 and ESA/390 emulator which can IPL and execute S/370 and ESA/390 instructions. It can also emulate CKD and FBA DASD, printer, card reader, tape, channel-to-channel adapter, and local non-SNA 3270 devices

    So, for some REAL nostalgia, install this on your box, get OS/360 (freeware!), and before you know it you'll be running TSO with 5 users, each pecking away at their 3270 block-mode terminals. Oh, and it can also run Linux/390, so if you've got way too much time on your hand you can run Linux->Hercules->Linux/390->Hercules->OS/360 or something horrible like that.

  • by malahoo ( 128370 ) on Friday August 25, 2000 @02:58AM (#828990) Homepage
    The 4th floor of Soda Hall, UCB's CS building, has mounted on the wall what I think constitutes my Alma Mater's answer to this question: a giant abacus with a sign that reads, "In case of System failure, shake to reboot."
  • by mirko ( 198274 ) on Friday August 25, 2000 @02:42AM (#828991) Journal
    I am not surprise to read about this subject shortly after we spoke about this one [slashdot.org], anyway, we have to look towards the first computers to check what guided their data streams and when it could decently be called an operating system.
    In operating system, there is the world system and, IMHO, a system is supposed to be extendable.
    Now here is my first attempt to answer your question :
    From this site [ex.ac.uk]: Babbage's greatest achievement was his detailed plans for Calculating Engines, both the table-making Difference Engines and the far more ambitious Analytical Engines, which were flexible and powerful, punched-card controlled general purpose calculaters, embodying many features which later reappeared in the modern stored program computer. These features included: punched card control; separate store and mill; a set of internal registers (the table axes); fast multiplier/divider; a range of peripherals; even array processing.
    Sounds like we got it.
    Now, we could reformulate your question one of the following ways:
    • By assuming you expected one that would be stored distinct from the main processing unit:
      "What was the First Computer software Operating System ?"
    • By assuming you expected one that would be publicly available:
      "What was the First Computer commercial Operating System ?"
    • By assuming you expected one that would fit both previous conditions:
      "What was the First Computer software commercial Operating System ?"
    Finally, I can't wait to imagine now somebody that might ask in some years about the first microprocessor ever, because as our vision of a microprocessor will have evolved (compare Transmeta's thing -or its equivalent, in ten years from now- to the i4004) thus making this question even more difficult to answer. :-)
  • never had anything that resembled a monitor, let alone an OS.

    I'm tired of all of you guys whining about what is or is not an OS. To settle this issue once and for all, I hereby present to you the final definition of an Operating System from a company that knows this shit. [microsoft.com]


    Mr. Farber ignores the realities of the marketplace when he tries to define an operating system as "software that controls the execution of programs on computers and may provide low-level ser-vices such as resource allocation, scheduling and input-output control in a form which is suffi-ciently simple and general so that these services are broadly useful to software developers."

    In fact, at his deposition, Mr. Farber was unable to name a single commercially available operating sys-tem that fits his extremely narrow definition. Perhaps his definition made sense 25 years ago, but his testimony essentially ignores everything that has occurred in the field of operating system design over the past two decades. The Apple MacOS and Microsoft Windows and Sun Solaris all fall outside Mr. Farber's definition of an operating system, so it's hard to see what relevance his definition has in this case.

    What Mr. Farber refuses to recognize is that the ongoing evolution of operating systems has delivered to consumers more powerful and full-featured products that are much easier to use. Such enhancements are often made possible by integrating new features and functionality into an operating system, making it a more capable platform for software developers and a giving it a better user interface for users. All types of Microsoft customers-including hardware manufac-turers, software devel-opers, content developers and users-have come to rely on the fact that Windows is a stable and consistent platform that will run large numbers of applications.

    The popularity of Windows is strong evi-dence that nobody wants the sort of rudimentary operating systems Mr. Farber apparently prefers. Microsoft is very good listening to its customers and providing them with technology solutions that meet their needs. Mr. Farber might have preferred that Microsoft create a hobbled version of Windows that had only a small fraction of the useful features contained in Windows 98, but his opinion is not supported by Microsoft's millions of customers worldwide.

    Well, that has cleared everything. Now that everyone knows what an operating system is, go back and continue your discussion. :P


  • No source I've seen in print or on-line definitavely says "x" is the first OS.

    Of course not - "x" is just a windowing system!

    Sausage King of Chicago

  • by rayw ( 26249 ) on Friday August 25, 2000 @06:14AM (#828994)
    Certainly Unix WASN'T the FIRST OS. It came along later than IBMs 709/7090 and OS/360 systems but who could afford the 709/7090. Even Honeywell had an operating system before Unix came along.

    So the question could well be, who had the first affordable operating system? Then Unix would qualify because AT&T was giving it away to the academic community. Sorta like a popular OS is today. I WONDER where these youngsters got the idea from?

    When I started working in Toronto in 1967 for Honeywell Information Systems (HIS), the main storage medium was punched card, paper tape or magnetic tape. Honeywell's innovation in the field was a pnuematically operated tape drive that handled tape with kid gloves compared to the pinch rollers used in all other tape drives of the day.

    Honeywell salesmen at computer shows would take their prospects over to the IBM display, ask the IBM rep to run the tape to the end of the reel, ask them to hit "rewind", then in the middle ask the IBM rep to hit the power OFF switch, simulating a power failure situation. A rookie rep would do it, but JUST once. It initiated a procedure that came to be known as "pull and stretch tape". The two sets of pinch rollers would BOTH clamp down on the tape, pulling in opposite directions and you effectively had to discard the tape and go get the backup and hope you didn't have a power failure until you'd recreated the one you just destroyed.

    Then they'd go back to the Honeywell display, repeat the process and all that would happen is the compressors used to create the vacuum and pressure to move the tape would power DOWN and the tape was left fluttering in the tape loop chambers.

    All companies used much the same technology to move the tape reels themselves. It was how the tape was moved past the magnetic read/write heads that was Honeywells ace in the hole. Once the Honeywell patents expired in the 1970-80s, the enire industry moved to the pnuematic system.

    Certainly the Honeywell units were noisier because the compressors they used were large, loud units. The tape safety factor made it a no brainer, though.

    One company, Gulf Canada, had a magnetic drum but I don't recall that they used any kind of operating system. Many of the other hundred or so users were even largely card based. Try doing an OS with punched cards? Or paper tape?

    You booted up the system with a control panel (keyboard input came along a couple of years later; keyboard input was done at an IBM keypunch machine) and ran a compiler program to create a user written program, then you ran the user written programs.

    No resident BASIC compiler like the VIC-20 had later, which sort of looked like an operating system.

    Us techies would punch code into the control panel just as easily as I now do here at the keyboard. Even could program code to punch on cards and BOOT from the card reader!!!

    Once you'd written a bunch of programs, the operators would "batch" them together and usually reading in punch cards, run them until the programmers needed to compile another program.

    A couple of years later, 1969/70, Honeywell introduced the OS/200 operating system for the Series 200 computers they'd been selling since before 1967 to replace IBM 1401s and that was followed a couple of years later by OS/2000.

    Then Honeywell bought the GE computing division and inherited a REAL operating system: Multics, developed jointly by MIT, GE and until they pulled out, Bell Labs. Of course, that team went on to create Unix, based on some of the ideas that were developed for Multics.

    Of course the widely used OS for the GE machines was GECOS, or GE comprehensive operating system, which Honeywell changed to GCOS, I believe leaving the meaning of the "G" as general.

    That's by brief account of the HIS progression towards an operating system.


    Toronto, Ontario
  • by Noryungi ( 70322 ) on Friday August 25, 2000 @02:59AM (#828995) Homepage Journal

    My dad used to tell me how he (and a few of his friends) actually created a simple Disk Management system on an IBM mainframe. I can't remember which Big Blue machine they used, but programming was done with punch cards.

    That was the time when, if you wanted your program to actually write something to the disk, you had to create your own routines to do this! Remember also that this was with "magnetic drums" -- to write any data to disk you had to know the hardware and the controller very well to optimize writing and reading (transfer rate were, of course abysmal).

    So they just went ahead and created a clever little program to write and read data to these huge magnetic drums. From then on, all their progrmas would just call the disk management software instead of having to re-invent the wheel. Then they optimized it some more (32KB of RAM was huge in those times!) and simply used it all the time.

    Soon after this, they received the visit of their in-house IBM engineer. Yes, in those days, they actually had an IBM engineer working full-time on the client site. Proudly, they showed him this clever little software. The guy asked for the source code, which they supplied, open source-like. The blue-suited engineer thanked them and walked away with the source. My dad and his colleagues just went back to work.

    Next thing you know, IBM released, with its next-generation mainframe, a complete set of system utilities including a disk manager that looked suspiciously like the one they had created.

    Why am I remembering this? Because my dad said many times that IBM (and, certainly, other computer makers) had used their ideas, as well as the ideas of many others, to create these "system utilities". He was not bitter or anything, he just mentioned that many other users probably had their own utilities for printing, batch execution, disk management, and others, and that IBM simply had used the best ones they could find... No one "invented" an "operating system": they just used more and more utilities and integrated them with one another.

    Ah well. Just my US$ 0.02...
  • by Vanders ( 110092 ) on Friday August 25, 2000 @02:28AM (#828996) Homepage
    This is difinatly a difficult question to pin down. What are you going to define as "an OS"? If you mean Kernel & Shell, with a set of standard device drivers, then i should imagine that something such as OS/390 & JCL would be one of the first (Though there may be earlier still).

    How about the first FORTRAN interpreters for mainframes? These were originally bootstraped in front of the FORTRTAN data, and in effect, created an abstraction layer between the program and the hardware. I doubt you could say FORTRAN is an OS under the "modern" difinition though.

    There has to be an earlier example of a "modern" OS than OS/390 though. I can't imagine the idea was thought up by IBM before it was done in the lab.
  • by uhlmann ( 139234 ) on Friday August 25, 2000 @02:40AM (#828997) Homepage
    whoring for karma... ;-)
    here are some screenshots of win 1.0 [fsnet.co.uk]
  • by DrWiggy ( 143807 ) on Friday August 25, 2000 @03:33AM (#828998)
    Well, seeing as everybody is having problems defining the first OS, perhaps we should look at the first stored-program computer and see what that was running. The first "programmable logic calculator" and there were 10 of them in operation at Bletchley Park during WWII working on breaking the German Enigma cipher.

    The "OS" on Colussus as I understand it, was simply the function of a group of valves. There was hardware checking other hardware, but to my knowledge there was no software running on Colussus other than the algorithm used to break Enigma. Input was by way of punched paper tape containing cipher read a few thousand characters a second (I've seen the rebuild running, and yes it is scary watching paper tape at that speed), output was buffered onto relays which meant a typewrite was printing out onto paper roll. The "processor" was just 5 characters of 5 bits held in a shit register. I suspect the "OS" was hardware and people making sure that none of the 2,500 valves blew up. All programming was by way of hard wiring, so it's hard to determine what the OS was here. There is some really cool information about Colussus here [cranfield.ac.uk] if you're interested.

    Next there was ENIAC, which due to the fact the British Government kept Colussus an Official Secret, was considered for a long time to be the first ever computer. ENIAC seemed suprisingly similar (when I read the specs anyway) in terms of internal function to Colussus - no OS there at all. So, we still haven't found anything...

    Then there was the Baby built by Manchester University in the UK. The rebuild of the Baby now sits in the Manhester Science and Industry museum. It's a curious piece of kit to say the least. It's memory consisted of a radar screen showing an array of bits, and whether each bit was on or not was picked up by a piece of gauze in front od the screen. Because phosphor on the screen takes a while to fade, you could just fire it, and not worry for a few hundred milliseconds about refreshing it.

    The baby didn't require anything to hard wired at all. There was a group of toggle switches on the front to program the machine, and there was a sense of "state" when no program was loaded or running. Therefore, I think whatever it was running on the Baby probably has claim to being the first ever OS. There is some nice stuff on the Baby (or officially the Manchester Mark 1) over here [computer50.org] for you to peruse at your pleasure.

    So, my vote is that whatever was running on the Baby was the first OS. But then, I don't know as much about ENIAC as I do about Colussus and the Mark 1. Please feel free to correct me if the ENIAC had code running before a program was loaded.
  • by gwernol ( 167574 ) on Friday August 25, 2000 @02:40AM (#828999)
    According this this [computer.org] abstract of a paper in the IEEE Annals of the History of Computing, EDVAC had a recognizable operating system in 1952/53. I suspect this would qualify as the first OS...
  • by w00ly_mammoth ( 205173 ) on Friday August 25, 2000 @03:24AM (#829000)
    Ultimately, this is a controversial topic. Perhaps the strongest contender would be Konrad Zuse [vt.edu], who developed a programmable computer in the 1940s. Interesting first person notes from an inventor in Nazi germany.

    In the ACM archives [acm.org], there is a paper on "Monitors, an operating system structuring concept" by C.A.R Hoare. Since this is from 1974, I guess it's not too old, but still an interesting paper.

    Many have been posting about OS/360 (or 390) but while MVS was a major step in OS history, it wasn't the first. It was released in 1964, too late for the first OS.

    Also interesting is a time article on the first computer [time.com]

    All the old stuff is fun to read.


We cannot command nature except by obeying her. -- Sir Francis Bacon