The Compatible Time-Sharing System (CTSS) was the first general purpose time-sharingoperating system.[2][3] Compatible Time Sharing referred to time sharing which was compatible with batch processing; it could offer both time sharing and batch processing concurrently.
CTSS was developed at the MIT Computation Center ("Comp Center"). CTSS was first demonstrated on MIT's modified IBM 709 in November 1961. The hardware was replaced with a modified IBM 7090 in 1962 and later a modified IBM 7094 called the "blue machine" to distinguish it from the Project MAC CTSS IBM 7094. Routine service to MIT Comp Center users began in the summer of 1963 and was operated there until 1968.
A second deployment of CTSS on a separate IBM 7094 that was received in October 1963 (the "red machine") was used early on in Project MAC until 1969 when the red machine was moved to the Information Processing Center[4] and operated until July 20, 1973. CTSS ran on only those two machines; however, there were remote CTSS users outside of MIT including ones in California, South America, the University of Edinburgh and the University of Oxford.[1][5]
History
John Backus said in the 1954 summer session at MIT that "By time sharing, a big computer could be used as several small ones; there would need to be a reading station for each user".[6] Computers at that time, like IBM 704, were not powerful enough to implement such system, but at the end of 1958, MIT's Computation Center nevertheless added a typewriter input to its 704 with the intent that a programmer or operator could "obtain additional answers from the machine on a time-sharing basis with other programs using the machine simultaneously".[7]
In June 1959, Christopher Strachey published a paper "Time Sharing in Large Fast Computers" at the UNESCO Information Processing Conference in Paris, where he envisaged a programmer debugging a program at a console (like a teletype) connected to the computer, while another program was running in the computer at the same time.[8][9] Debugging programs was an important problem at that time, because with batch processing, it then often took a day from submitting a changed code, to getting the results. John McCarthy wrote a memo about that at MIT, after which a preliminary study committee and a working committee were established at MIT, to develop time sharing. The committees envisaged many users using the computer at the same time, decided the details of implementing such system at MIT, and started the development of the system.
Experimental Time Sharing System
By July, 1961[10] a few time sharing commands had become operational on the Computation Center's IBM 709, and in November 1961, Fernando J. Corbató demonstrated at MIT what was called the Experimental Time-Sharing System. On May 3, 1962, F. J. Corbató, M. M. Daggett and R. C. Daley published a paper about that system at the Spring Joint Computer Conference.[11] Robert C. Daley, Peter R. Bos and at least 6 other programmers implemented the operating system, partly based on the Fortran Monitor System.
The system used an IBM 7090, modified by Herbert M. Teager, with added 3 Flexowriters for user consoles, and maybe a timer. Each of the 3 users had two tape units, one for the user's file directory, and one for dumping the core (program in memory). There was also one tape unit for the system commands, there were no disk drives. The memory was 27 k words (36-bit words) for users, and 5 k words for the supervisor (operating system). The input from the consoles was written to the buffers in the supervisor, by interrupts, and when a return character was received, the control was given to the supervisor, which dumped the running code to the tape and decided what to run next. The console commands implemented at the time were login, logout, input, edit, fap, mad, madtrn, load, use, start, skippm, listf, printf, xdump and xundump.[citation needed]
This became the initial version of the Compatible Time-Sharing System. This was apparently the first ever public demonstration of time-sharing; there are other claims, but they refer to special-purpose systems, or with no known papers published. The "compatibility" of CTSS was with background jobs run on the same computer, which generally used more of the compute resources than the time-sharing functions.
Applications
DOTSYS and BRAILLEMBOSS
The first version of the DOTSYS braille translation software ran on CTSS and could output to a BRAILLEMBOSS braille page printer.[12][13] DOTSYS on CTSS was first demonstrated on August 18, 1966, as part of a feasibility study where teletypesetter tape, in the form of news, was converted to Grade 2 Braille. The following month the feasibility of converting textbook information on teletypesetter tape to error-free Grade 2 Braille was successfully demonstrated.[14] As MIT CTSS was an academic system, a research vehicle and not a system for commercial computing, two years later a version of DOTSYS stripped of CTSS dependencies for software portability was used on an IBM 709 at the American Printing House for the Blind to print the first braille edition of a book produced from teletypesetter input, only a few weeks after the ink-print version.[15] The following year, on CTSS, a demonstration of printing mathematical tables in braille was shown. A short FORTRAN II program was written to produce a conversion table from inches to millimeters in braille via the BRAILLEMBOSS braille page printer.[16]
Intrex
Diagram of the Intrex running on CTSS
The Intrex Retrieval System ran on CTSS. Intrex was an experimental, pilot-model machine-oriented bibliographic storage and retrieval system with a database that stored a catalog of roughly 15,000 journal articles. It was used to develop and test concepts for library automation.[17][18][19] A deployment of three BRISC CRT consoles for testing at the MIT Engineering Library showed that it was preferred over two other systems, ARDS and DATEL.[20]
MIT Computation Center staff member Louis Pouzin created for CTSS a command called RUNCOM, which executed a list of commands contained in a file.[1] RUNCOM also provided for parameter substitution.[5] He later created a design for the Multicsshell that was implemented by Glenda Schroeder which in turn inspired Unix shell scripts.[25][26]
CTSS had an implementation of the text editor QED, the predecessor of ed, vi, and vim, with regular expressions added by Ken Thompson.
Implementation
Kernel
CTSS used a modified IBM 7090 mainframe computer[27] that had two 32,768 (32K) 36-bit-word banks of core memory instead of the default configuration which provides only one.[28][29] One bank was reserved for the time-sharing supervisory program, the other for user programs. CTSS had a protected-mode kernel; the supervisor's functions in the A-core (memory bank A) could be called only by software interrupts, as in modern operating systems. Causing memory-protection interrupts were used for software interrupts.[8]Processor allocation scheduling with a quantum time unit 200 ms, was controlled by a multilevel feedback queue.[28] It also had some special memory-management hardware,[30] a clock interrupt,[31] and the ability to trap certain instructions.[30]
Supervisor subroutines
RDFLXA – Read an input line from console
WRFLX – Write an output line to console
DEAD – Put the user into dead status, with no program in memory
DORMNT – Put the user into dormant status, with program in memory
GETMEM – Get the size of the memory allocation
SETMEM – Set the size of the memory allocation
TSSFIL – Get access to the CTSS system files on the disk
USRFIL – Change back to user's own directory
GETBRK – Get the instruction location counter at quit
Programming languages
CTSS at first had only an assembler, FAP, and a compiler, MAD. Also, Fortran II code could be translated into MAD code by using MADTRN. Later half of the system was written in MAD. Later there were other programming languages including COMIT II, LISP 1.5 and a version of ALGOL.
File system
Each user had their own directory, and there were also shared directories for groups of people with the same "problem number". Each file had two names, the second indicating its type as did the extension in later system. At first, each file could have one of four modes: temporary, permanent, read-only class 1, and read-only class 2. Read-only class 1 allowed the user to change the mode of the file. Files could also be symbolically linked between directories. A directory listing by listf:
10 FILES 20 TRACKS USED
DATE NAME MODE NO. TRACKS
5/20/63 MAIN MAD P 15
5/17/63 DPFA SYMTB P 1
5/17/63 DPFA BSS P 1
5/17/63 DPFA FAP P 2
Peripherals
Input-output hardware was mostly standard IBM peripherals. These included six data channels connecting to:
IBM 729 tape drives, an IBM 1301 disk storage, later upgraded to an IBM 1302, with 38 million word capacity
An IBM 7320 drum memory with 186K words that could load a 32K-word memory bank in one second (later upgraded to 0.25 seconds)
Two custom high-speed vector graphics displays[32]
An IBM 7750 transmission control unit capable of supporting up to 112 teleprinter terminals, including IBM 1050Selectrics and Model 35s. Some of the terminals were located remotely, and the system could be accessed using the public Telex and TWX networks.
Influences
CTSS was described in a paper presented at the 1962 Spring Joint Computer Conference, and greatly influenced the design of other early time-sharing systems.
Dennis Ritchie wrote in 1977 that UNIX could be seen as a "modern implementation" of CTSS.[35] Multics, which was also developed by Project MAC, was started in the 1960s as a successor to CTSS – and in turn inspired the development of Unix in 1969. One of the technical terms inherited by these systems from CTSS is daemon.
Incompatible Timesharing System (ITS), another early, revolutionary, and influential MIT time-sharing system, was produced by people who disagreed with the direction taken by CTSS, and later, Multics; the name was a parody of "CTSS", as later the name "Unix" was a parody of "Multics".[36] CTSS and ITS file systems have a number of design elements in common. Both have an M.F.D. (master file directory) and one or more U.F.D. (user file directories). Neither of them have nested directories (sub-directories). Both have file names consisting of two names which are a maximum of six-characters long. Both support linked files.[5]
^Singh, Jai P.; Morgan, Robert P. (October 1971). Educational Computer Utilization and Computer Communications(PDF) (Report). St. Louis, MO: Washington University. p. 13. National Aeronautics and Space Administration Grant No. Y/NGL-26-008-054. Archived(PDF) from the original on March 19, 2023. Retrieved March 8, 2022. Much of the early development in the time-sharing field took place on university campuses.8 Notable examples are the CTSS (Compatible Time-Sharing System) at MIT, which was the first general purpose time-sharing system...
^Corbató, Fernando J.; Merwin Daggett, Marjorie; Daley, Robert C. (May 3, 1962). "An Experimental Time-Sharing System". Archived from the original on September 6, 2009. Retrieved February 25, 2022.
^Evaluation and Development of Sensory Aids and Devices. Final Report(PDF) (Report). The Sensory Aids Evaluation and Development Center Massachusetts Institute of Technology. April 3, 1967. Archived(PDF) from the original on June 25, 2024. Retrieved March 13, 2022. Demonstration on CTSS of teletypesetter-to-Grade 2 Braille
^Final Report to Social Rehabilitation Administration Department of Health, Education and Welfare Washington, D.C.(PDF) (Report). The Sensory Aids Evaluation and Development Center Massachusetts Institute of Technology. April 30, 1969. Retrieved March 13, 2022. These programs, originally written to operate on the CTSS system at M.I.T., were modified for the 709 at the American Printing House for the Blind. This involved rewriting those parts of the programs which were CTSS-dependent.
^Hurlburt, Charles E. (September 15, 1971). The Intrex Retrieval System Software(PDF). ERIC (Report). MIT. Archived(PDF) from the original on June 25, 2024. Retrieved March 8, 2022.
^Overhage, Carl F. J. (March 15, 1972). Project Intrex. Semiannual Activity Report, 15 September 1971 - 15 March 1972(PDF). ERIC (Report). MIT. Intrex PR-13. Archived(PDF) from the original on June 25, 2024. Retrieved March 17, 2022. Since September 27, 1971, the BRISC has been available at the Engineering Library station on a two-hours a day basis.
^ abSilberschatz, Abraham; Peterson, James L. (June 1988). "13: Historical Perspective". Operating System Concepts. Addison-Wesley. p. 514. ISBN0-201-18760-4.
^Thornhill, D. E.; Stoz, R. H.; Ross, T. T.; Ward, J. E. (1968). "An Integrated Hardware-Software System for Computer Graphics in Time Sharing"(PDF). MIT Project MAC. ESL-R-356 and MAC-TR-56. Retrieved February 20, 2022. Console facilities include hardware projection of three-dimensional line drawings, automatic light pen tracking, and a flexible set of knob, switch, and push-button inputs. The console is attached to the Project MAC IBM 7094 Compatible Time-Sharing System either directly or through a PDP-7 Computer.
^Fraser, Sandy (2004). "An Historical Connection between Time-Sharing and Virtual Circuits". Computer Systems. Springer. pp. 85–88. CiteSeerX10.1.1.14.9546. ISBN978-0-387-21821-2. Maurice Wilkes discovered CTSS on a visit to MIT in about 1965, and returned to Cambridge to convince the rest of us that time-sharing was the way forward
^Levy, Steven (2010). "Winners and Losers". Hackers: Heroes of the Computer Revolution - 25th Anniversary Edition (1st ed.). Sebastopol, California: O'Reilly Media. pp. 85–102. ISBN978-1-4493-8839-3.
