Slashdot Mirror
Source Code for CTSS released
Mainframes ROCK! writes "The source code for the Compatible Time-Sharing System, CTSS, has been released, and the here is the source code. CTSS was one of the first time-sharing operating systems and a direct ancestor of Linux. Developed at MIT in the 1960's on a specially modified IBM 7094 system.; it was developed at Project MAC at MIT. CTSS was first published, as well as operated in a time-sharing environment, in 1961; in addition, it was the system with the first computerized text formatting utility, and one of the very first to have inter-user electronic mail."
...is on RubyForge right here.
It's 400K lines of assembly code... what could be sweeter?
The Army reading list
According to RMS in Revolution OS, this was also the machine that he worked with at MIT. I believe it was the fact the he had access to all the code on the system that lead him down his path, believing that you need source code availability to fix/tweak/hack to your needs.
put the what in the where?
REMINISCENCES ON THE HISTORY OF TIME SHARING
John McCarthy, Stanford University
1983 Winter or Spring
I remember thinking about time-sharing about the time of my first contact with computers and being surprised that this wasn't the goal of IBM and all the other manufacturers and users of computers. This might have been around 1955.
By time-sharing, I meant an operating system that permits each user of a computer to behave as though he were in sole control of a computer, not necessarily identical with the machine on which the operating system is running. Christopher Strachey may well have been correct in saying in his letter to Donald Knuth that the term was already in use for time-sharing among programs written to run together. This idea had already been used in the SAGE system. I don't know how this kind of time-sharing was implemented in SAGE. Did each program have to be sure to return to an input polling program or were there interrupts? Who invented interrupts anyway? I thought of them, but I don't believe I mentioned the idea to anyone before I heard of them from other sources.
My first attempts to do something about time-sharing was in the Fall of 1957 when I came to the M.I.T. Computation Center on a Sloan Foundation fellowship from Dartmouth College. It was immediately clear to me that the time-sharing the IBM 704 would require some kind of interrupt system. I was very shy of proposing hardware modifications, especially as I didn't understand electronics well enough to read the logic diagrams. Therefore, I proposed the minimal hardware modification I could think of. This involved installing a relay so that the 704 could be put into trapping mode by an external signal. It was also proposed to connect the sense switches on the ccnsole in parallel with relays that could be operated by a Flexowriter (a kind of teletype based on an IBM typewriter).
When the machine went into trapping mode, an interrupt to a fixed location would occur the next time the machine attempted to execute a jump instruction (then called a transfer). The interrupt would occur when the Flexowriter had set up a character in a relay buffer. The interrupt program would then read the character from the sense switches into a buffer, test whether the buffer was full, and if not return to the interrupted program. If the buffer was full, the program would store the current program on the drum and read in a program to deal with the buffer.
It was agreed (I think I talked to Dean Arden only.) to install the equipment, and I believe that permission was obtained from IBM to modify the computer. The connector to be installed in the computer was obtained.
However, at this time we heard about the "real time package" for the IBM 704. This RPQ (request for price quotation was IBM jargon for a modification to the computer whose price wasn't guaranteed), which rented for $2,500 per month had been developed at the request of Boeing for the purpose of allowing the 704 to accept information from a wind tunnel. Some element of ordinary time-sharing would have been involved, but we did not seek contact with Boeing. Anyway it was agreed that the real time package, which involved the possibility of interrupting after any instruction, would be much better than merely putting the machine in trapping mode. Therefore we undertook to beg IBM for the real time package. IBM's initial reaction was favorable, but nevertheless it took a long time to get the real time package - perhaps a year, perhaps two.
It was then agreed that someone, perhaps Arnold Siegel, would design the hardware to connect one Flexowriter to the computer, and later an installation with three would be designed. Siegel designed and build the equipment, the operating system was suitably modified (I don't remember by whom), and demonstration of on-line LISP was held for a meeting of the M.I.T. Industrial Affiliates. This demonstration, which I planned and carried out, had the audience in a fourth floor lecture room and me in the computer room an
ken thompson and dennis ritchie both used ctss, and cite it as an inspiration for unix. and we all know unix is linux's father's former roommate. what does that make linux? ...absolutely nothing.
Nostalgia or machinropology, whatever, http://www.lcs.mit.edu/publications/pubs/pdf/MIT-L CS-TR-016.pdf
CTSS (Compatible Time Sharing System) lent its name to MIT's ITS (Incompatible Time Sharing System) for the PDP-10.
I'm pretty sure it was ITS that RMS developed Emacs (Editor Macros, or Eight Megs and Constantly Swapping) on but he'd know for sure.
Also, from SAIL (Stanford Artificial Intelligence Laboratory) we got WAITS which was the West-coast Alternative to ITS.
MULTICS also grew out of these roots, and Unix of course is a play on "Multics".
It was the Incompatible Time Sharing System.
More information here: http://www.its.os.org/
The first version of what came to be called CTSS ran in 1961 on an IBM 709. See here for more info:
http://www.multicians.org/thvv/7094.html
Indeed, calling CTSS a DIRECT ancestor is a bit of a stretch. Dennis Ritchie is about as authoritative as you are going to get on the history of Unix and Unix is the direct ancestor of Linux. Read his article on the history of Unix. There you will find his quote in section 1.3 on just where CTSS comes into the genisis of Unix....it is a distant ancestor. The Wikipedia article on history of OS'es is strangely lame on this topic.
SLASHDOT: news for people who can't concentrate on work or have no life at all and got tired of yelling back at the TV.
On the newsgroup, it's stated " You'll have to know
a little FAP and MAD to understand it. There are even a few programs in AED-0, an Algol variant."
Thank god, I thought I was going to have to learn something new...er, old to be able to use it!!!
The first mainframe versions of Unix(R) were run on top of a modified version of CTSS. Also CTSS is considered the father of Multics which in turn begat Unix.
"To those who are overly cautious, everything is impossible. "
There is a thread on this very topic over on alt.folklore.computers right now, and the concensus is: While the 7094 CPU is emulated, there is a lot of IO that is required for CTSS to run that is not ready for prime time - some of which is probably pretty easy to knock out, but some of which (the channel controller) is Big Black Voodoo, in terms of asynchronous operation with the main CPU.
How does the Slashdot Effect happen given that no slashdotters ever RTFA?
Languages like Java and C# are chosen for speed of development, which is especially important in the fast-changing market of mobile devices. You don't want to be dinking around with registers while your competitors are releasing completed products.
In the mid-1960s, the 7094 was one of the biggest, fastest computers available, able to add floating numbers at a speed of about 0.35 MIPS. A standard 7094 had 32K 36-bit words of memory. Its data channels could access memory and run simple channel programs to do I/O once started by the CPU, and the channels could cause a CPU interrupt when the I/O finished. They cost about $3.5 million. Paul Pierce's collection includes a real 709 and 7094.
MIT got an IBM 7090, replacing the 709, in the spring of 1962, when I was a freshman, and had upgraded the 7090 to a 7094 by 1963. The 7090 and 7094 were operated in batch mode, controlled by the Fortran Monitor System (FMS). Batch jobs on cards were transferred to tape on an auxiliary 1401, and the monitor took one job at a time off the input tape, ran it, and captured the output on another tape for printing and punching by the 1401. Each user job was loaded into core by the BSS loader along with a small monitor routine that terminated jobs that ran over their time estimates. Library routines for arithmetic and I/O were also loaded and linked with the user's program. Thus, each user's job had complete control of the whole 7094, all 32K words of memory, all the data channels, everything.
IBM had been very generous to MIT in the fifties and sixties, donating its biggest scientific computers. When a new top of the line 36-bit scientific machine came out, MIT expected to get one. In the early sixties, the deal was that MIT got one 8-hour shift, all the other New England colleges and universities got a shift, and the third shift was available to IBM for its own use. One use IBM made of it was yacht handicapping: the president of IBM raced big yachts on Long Island Sound, and these boats were assigned handicap points by a complicated formula. There was a special job deck kept at the MIT Computation Center, and if a request came in to run it, operators were to stop whatever was running on the machine and do the yacht handicapping job immediately.
Early Time-Sharing
MIT professors, such as Herb Teager and Marvin Minsky, wanted more access to the machine, like they had had on Whirlwind in the fifties, and quicker return of their results from their FMS jobs. John McCarthy wrote an influential memo titled "A Time Sharing Operator Program for Our Projected IBM 709" dated January 1, 1959, that proposed interactive time-shared debugging. These desires led to time-sharing experiments, such as Teager's "time-stealing system" and "sequence break mode," which allowed an important professor's job to interrupt a running job, roll its core image out to tape, make a quick run, and restore the interrupted job. McCarthy's Reminiscences on the History of Time Sharing describes his and Teager's role in the beginnings of time-sharing. Teager and McCarthy presented a paper titled "Time-Shared Program Testing" at the ACM meeting in August 1959.
FMS and Batch Processing
MIT and the University of Michigan were both 7094 owners, and the computation center people were colleagues who traded code back and forth. When I was a freshman in 1961, we used FORTRAN in the elementary course (FORTRAN II was brand new then), but by the time I was a sophomore, MIT had installed Michigan's MAD language, written by Graham, Arden, and Galler, and was using that in most places that a compiler language was needed, especially computer courses. MAD was descended from ALGOL 58: it had block structure and a fast compiler, and if your compilation failed, the compiler used to print out a line printer portrait of Alfred E. Neumann. (MIT took that out to save paper.) Mike Alexander says, "MAD was first developed about 1959 or 1960 on a 704, a machine which makes the 7094 look very powerful indeed." MAD ran under UMES, the University of Michigan Executive System, derived from a 1959 GM Research Center executive for the IBM 701 that was one of the first operating systems.
Part of the Michigan/MAD code was a replacement for the standard FORTRAN output formatter routine, (IOH). (Programs written
AdsJunction.com Ad Network