Computers before operating systems

  1. I was wondering how people ran computers before operating system.
    Since there is no OS to load our program, run it and then show the result, was it all done manually?

    What was the procedure to load your program into the memory? I have heard something called dumb terminals. Was that used?
    When the result came, how did we see it?
     
  2. jcsd
  3. turbo

    turbo 7,366
    Gold Member

    When I was in college over 40 years ago, computers were big, dumb, monoliths - overseen by a priesthood of geeks. Users were not allowed to make any changes in OS. We were allowed only to make minor programming changes on IBM punch-cards, then present those stacks of cards and hope that they yielded some legible output on the oh-so-many pages of green and white printout paper. It was not a good time.

    Learning CUPL and Fortran was not real fun IMO because you never got to get down into the bowels of the beast. I'm sure some older members could elucidate. This is only my limited experience at a state university.
     
  4. rcgldr

    rcgldr 7,608
    Homework Helper

    The Eniac was manually programmed by manipulating switches and cables. Later versions of vacuum tube computers used something similar in concept to ROM's. Wiki article:

    http://en.wikipedia.org/wiki/ENIAC

    Some types of computers used plug board programming. When these computers started to phase out, languages like RPG which is similar in concept to plug board programing was developed for the later computers. Wiki article:

    http://en.wikipedia.org/wiki/Plugboard

    Some early transistor based computers had front panels that allowed a person to manually enter machine code. Usually a simpler loader was programmed, and then that loader could read punched cards, paper tape, or from some other device in order to load in a program. One alternative to a fixed circuit or rom for a boot loader was a small music box like drum with tabs used to toggle switches as it turned to enter the loader program (MonRobot).

    Eventually simple operating systems that mostly consisted of drivers for the computer peripherals were created. Most of these were disk based as with current systems, a few were tape based. These were similar to the "DOS" on mini-computers or MS-DOS for the PC. The file systems used on disk drives improved over time.

    During the 1960's and 1970's mainfame operating systems became fairly robust, and included the ability to run multiple batch jobs at the same time, similar to multi-tasking, except that the batch jobs normally didn't communicate with each other. True multi-tasking systems were also created during this time period.
     
    Last edited: Aug 15, 2013
  5. Okay, you enter machine or perhaps assembly code directly to a computer. But how?
    When you enter the code how do you tell the computer to run it?
     
  6. jtbell

    Staff: Mentor

    When I was an undergraduate about forty years ago, I played with a Digital Equipment PDP-5 computer which could be programmed from the front panel. It went something like this:

    • You have a list of binary machine-language instructions on a sheet of paper.
    • Set the memory address (in binary) that the first instruction is to go in, using a row of 12 front-panel switches.
    • Press a button labeled ADDRESS. A row of 12 lights, also labeled ADDRESS, lights up accordingly.
    • Set the first instruction on the switches.
    • Press a button labeled DEPOSIT. A second row of 12 lights labeled DATA lights up accordingly.
    • Press a button labeled NEXT. The ADDRESS lights advance to the next binary number in sequence.
    • Set the second instruction on the switches.
    • Press the DEPOSIT button.
    • Press the NEXT button.
    • Set the next instruction on the switches.
    • Repeat the preceding three steps until you've entered all the instructions.

    When you've entered the entire program,

    • Set the switches to the address of the first instruction.
    • Press the ADDRESS button.
    • Press the RUN button.

    I can't find a clear enough picture of a PDP-5's front panel to refresh my 40-year-old memories, so some details may have been different.
     
    Last edited: Aug 15, 2013
  7. nsaspook

    nsaspook 1,220
    Science Advisor

    Some early machines had a front panel that would control the processor, and allow you to manually control the memory data, address data ,run/halt and read/write logic lines with a set of toggle switches.
    http://www.classiccmp.org/hp/UYK-20/uyk panel.jpg
    Core memory board.
    http://www.classiccmp.org/hp/UYK-20/core.jpg

    Manual operation:
    You would unset the run switch, set address mode, toggle a address in binary, hit the set switch, set data mode, toggle in the data bits at that address, hit the set button again then repeat for the length of the program. When you were done you would again set the address to the start address of the program, press the set switch and then flip the run switch to start the computer executing instructions at that address.

    The easy way:
    Set the mode switch to use the ROM based bootloader to load the program from a 8 level tape reader.
    http://www.kh6bb.org/new1.jpg
     
  8. jtbell

    Staff: Mentor

    "My" PDP-5 didn't have a ROM bootloader, so I had to enter a short paper-tape-loader program on the front panel switches. Properly-designed programs didn't overwrite the memory area where the paper tape loader resided, so if I was lucky, I needed to enter it only once, right after I turned the machine on. We kept the list of instructions taped on the front panel for handy reference.
     
    Last edited: Aug 15, 2013
  9. OmCheeto

    OmCheeto 2,200
    Gold Member
    2014 Award

    That sounds a bit like the Altair 8800.

    [​IMG]


    I never got one, but your description sounds about right.

    Ha! The first line of the article is a hoot:

     
  10. SteamKing

    SteamKing 9,947
    Staff Emeritus
    Science Advisor
    Homework Helper

    Here is a brochure explaining some of the features of the PDP-5:

    http://archive.computerhistory.org/resources/text/DEC/pdp-5/DEC.PDP-5.1964.102646094.pdf

    If you go to p.8 of the document, there is a picture and explanation of the console keys.
     
  11. jtbell

    Staff: Mentor

    Looks like I wasn't too far off. Instead of buttons, there were two-way spring switches (console keys) that each acted like two buttons. Instead of a single DEPOSIT, there were separate LOAD ADDRESS and DEPOSIT [data]. Instead of RUN, there was START. To see the data at a particular address (already entered), you had to use EXAMINE. And there was no NEXT; both DEPOSIT and EXAMINE automatically incremented the memory location. So the procedure for entering and running a program would have been:

    • Set the switches to the address of the first instruction.
    • Key LOAD ADDRESS.
    • Set the switches to the first instruction.
    • Key DEPOSIT.
    • Set the switches to the next instruction.
    • Repeat the preceding two steps until the entire program has been loaded.
    • Set the switches to the address of the first instruction.
    • Key START.
     
  12. D H

    Staff: Mentor

    You missed a final step: Watch das blinkenlights.
     
  13. jtbell

    Staff: Mentor

    Yep, and another step, not mandatory, but good practice: use LOAD ADDRESS (once) and EXAMINE (multiple times) to check that you entered the program correctly!
     
  14. That's tiresome but very exciting. You get to interact with the hardware directly unlike nowadays.
    Thank you for the information

    Also, what are dumb terminals?
     
  15. D H

    Staff: Mentor

    Essentially a teletype in which the output went to a monochrome screen instead of paper.
     
  16. What's the difference between the current computer terminal and the dumb terminal?
    Did the dumb terminal just take input and store into the memory without processing it? So in a way, it was just another way to load a program into the computer. Was it used before operating systems came?
     
  17. harborsparrow

    harborsparrow 422
    Gold Member

    This is an excerpt from Wikipedia that is fairly accurate:

    In the context of traditional computer terminals that communicate over a serial RS-232 connection, dumb terminals are those that can interpret a limited number of control codes (CR, LF, etc.) but do not have the ability to process special escape sequences that perform functions such as clearing a line, clearing the screen, or controlling cursor position...Smart or intelligent terminals are those that also have the ability to process escape sequences, in particular the VT52, VT100 or ANSI escape sequences.

    In the broader context...the term dumb terminal is sometimes used to refer to any type of traditional computer terminal that communicates serially over a RS-232 connection.
     
    Last edited: Aug 15, 2013
  18. harborsparrow

    harborsparrow 422
    Gold Member

    I first used an IBM 360 system that used punched cards. In that case, each card was one line of code (in text), and the program would be read in line by line (card by card) and compiled, then run.

    The operating system was very primitive. People at various terminals could read in a program from cards, and those would all go into a holding area (queue) and then execute one at a time. There was an operator (an actual person) who looked at the queue and could kill a job (if, say, it ran too long) or move a job to the front of the queue. Each program had one or two cards at the front that consisted of instructions to the computer on how to load and run the program (which compiler to use, for example, since compilers were pre-loaded and waiting in memory somewhere, ready to run the program being read in, or else the operator had to load the compiler)--those instructions were in JCL (Job Control Language), and each program was a "job". JCL is still used some places. This was before any timesharing systems, but JCL and the queue and operator WERE the operating system. Before that, as with Eniac, there was nothing; the program had to be hardwired into the computer.

    Sorry this is a little muddled. You probably don't want to know about punched card computing anyway :-) This is a batch operating system, as mentioned earlier in the thread.
     
    Last edited: Aug 15, 2013
  19. harborsparrow

    harborsparrow 422
    Gold Member

    And, before punched cards, there was paper tape. The Univ. of Tenn. still had, in 1971 or 72, a paper tape reader than worked, although no one actively used it anymore.

    When timesharing came along, we all thought we had gone to heaven.
     
  20. As harborsparrow mentioned, a smart terminal is one that interprets certain character combinations as commands to move the cursor, clear a line, clear the screen, format the text, etc. -- those

    One can create ASCII-art GUI's using these escape sequences, like for text editors and games.

    Smart terminals are still common, though in virtual form. I mainly have experience with SunOS and OSX, but their terminal apps create smart virtual terminals.


    As to present-day OS-less computers, I'd imagine that some small embedded ones are OS-less, but that's about it.
     
  21. harborsparrow

    harborsparrow 422
    Gold Member

    To get down to brass tacks, "smart terminals" were really computers themselves. They contained a microprocessor--a big deal in the 1980's--that would allow, via the entry of control codes from a keyboard, a certain amount of local editing of commands before sending entered commands (usually serially) off to a remote processor for execution on "a mainframe" or "a real computer".

    I'm talking about, say, the 1980's here.

    ANSI VT100 is a standard dictating one way in which a smart terminal could operate so as to be compatible with other smart terminals. With such standards, your smart terminal could break and you could replace it with another made by a different vendor as long as both correctly implemented the VT100 standard--the the remote computer being interfaced to should not need to know the difference.

    If you run a Command Window today on a Microsoft Windows Operating system, you get a virtual environment that is quite similar to what a smart terminal was. If you type incorrectly, you could hit the backspace key (and the previously typed character would disappear from the screen, because the keyboard had created a Backspace control code whenever you pressed, say, the Delete key). The backspace action all took place within the "terminal" by means of a local microprocessor. Only when a command had been entered correctly, and you then hit Enter, would the command be "interpreted" by the operating system (which in those days meant, sent serially to a central processing unit on a mainframe computer, rather than being handled by the local microprocessor in the terminal itself).
     
Know someone interested in this topic? Share this thead via email, Google+, Twitter, or Facebook

Have something to add?

0
Draft saved Draft deleted