RSTS/E (an acronym for Resource Sharing Time Sharing Extended) was a multi-user time-shared operating system developed by Digital Equipment Corporation ("DEC") (now part of Hewlett Packard) for the PDP-11 series of 16-bit minicomputers, and used primarily during the 1970s and 1980s, although some installations were still being upgraded well into the 1990s.
RSTS/E started as RSTS-11, for the PDP-11/20. Unlike RSTS/E, it ran on PDP-11s without memory mapping hardware. RSTS-11 only supported the BASIC-PLUS programming language. RSTS/E (V5A) was introduced in 1973, to take advantage of the memory mapping hardware and larger memory support introduced with the PDP-11/45. Starting with V5B, RSTS/E supported multiple programming languages, although that support was not made official until some time later.
The cost of micro computers dropped so drastically, and their performance rose so radically, that minicomputers such as the PDP-11 were no longer cost effective. In the late 1990s DEC sold its PDP-11 software business to a company named Mentec , and DEC then essentially discontinued releases of RSTS in order to concentrate on their VAX series of mainframe computers.
Mentec would later publicly grant a no-cost license to anyone for non-commercial hobby purpose use of the operating system software developed for the PDP-11, and as the result of the release (for non-commercial use) of a PDP-11 emulator for the IBM-PC, as well as image copies of disk drives of RSTS which exist on the Internet, it is possible for a hobbyist to run RSTS/E on a personal computer in software emulation as fast or faster than it originally ran on the real hardware.
The RSTS/E Operating System is usually referred to just as "RSTS" and this article will generally use the shorter form. The acronym was usually pronounced as "RIST-ess" or "RIST-uhs". RSTS was primarily programmed using an extended version of the BASIC programming language which DEC called "BASIC-PLUS." Essentially all of the system software for the operating system, including the programs for resource accounting, login, logout and managing the system, were written using BASIC-PLUS.
RSTS operates strictly in text mode as it used non-graphical computer terminals (and modems) connected to it by the equivalent of serial ports, and uses a command line interpreter (or CLI) whose primary command language is BASIC-PLUS, although special "CCL" (Concise Command Language) commands which can be installed by the System Manager may be used. A CCL is analogous to a shortcut to a program on a Windows system or a symbolic link on Unix-based systems, although a CCL is installed as a memory-resident command each time the system is restarted, it is not permanent like a disk file. Later versions of RSTS include DCL as a choice for the CLI, giving users access to the same command language used in RSX-11 and, later, OpenVMS.
As many as 63 terminals could be connected to a RSTS system, depending on the processor being used, the amount of memory and disk space, and the system load. Most RSTS systems had nowhere near that many terminals. Users could also submit jobs to be run in batch mode. There was also a batch system called "ATPK" that allowed users to run a series of commands on another terminal in semi-interactive mode similar to batch commands in MS-DOS.
Users connected to the system by typing the LOGIN command (or HELLO) at a logged-out terminal and pressing return. Actually, typing any command at a logged-out terminal simply started the LOGIN program which then interpreted the command. If it was one of the commands which were allowed to be used by a user that is not yet logged in ("Logged Out"), then the associated program for that command was CHAINed to, otherwise the message "Please say HELLO" was printed on the terminal. One could determine the status of a terminal by the prompt printed by the command interpreter, usually the BASIC-PLUS run-time system. A logged-in user was given the prompt "Ready" and a user who is logged out is given the prompt "Bye".
A user would log in by supplying their user number and password. User numbers consisted of a project number (this would be the equivalent of a group number in Unix), a comma, and a programmer number. Both numbers were in the range of 0 to 254, with special exceptions. When specifying an account, the project and programmer number were enclosed in brackets. A typical user number could be [10,5] (project 10, programmer 5), [2,146], [254,31], or [200,220], etc. When a user was running a system program while logged out (because the system manager had enabled it) their user number would appear as [0,0]. Thus that is not a valid account number.
In every project, the programmer number 0 was usually reserved as a group account, as it could be referenced by the special symbol #. If one's user number were [20,103], a reference to a file name beginning with "#" would refer to a file stored in the account of the user number [20,0]. This feature would be useful in educational environments, as programmer number 0 could be issued to the instructor of a class, and the individuals students given accounts with the same project number, and the instructor could store in his account files marked as shared only for that project number (which would be students in that class only, and no other).
Two special classes of project numbers existed. Project numbers of 0 were generally reserved for system software. Project numbers of 1 are privileged accounts, equivalent to the single account "root" on Unix systems, except that the account numbers [1,0] through [1,254] are all privileged accounts.
There are also certain special accounts on the system. The account [0,1] is used to store the operating system file itself, all run-time library systems, and certain system files relating to booting the system (author's comments appear on the right in bold):
Ready DIR [0,1] Name .Ext Size Prot Date SY:[0,1] BADB .SYS 0P < 63> 06-Jun-98 '''List of bad blocks''' SATT .SYS 3CP < 63> 06-Jun-98 '''Bitmap of allocated disk storage''' INIT .SYS 419P < 40> 06-Jun-98 '''Operating system loader program''' ERR .ERR 16CP < 40> 06-Jun-98 '''System error messages''' RSTS .SIL 307CP < 60> 06-Jun-98 '''Operating system itself''' BASIC .RTS 73CP < 60> 06-Jun-98 '''BASIC-PLUS run time system''' RT11 .RTS 20C < 60> 06-Jun-98 '''[[RT-11]] run time system''' SWAP .SYS 1024CP < 63> 06-Jun-98 '''System swap file''' CRASH .SYS 35CP < 63> 06-Jun-98 '''System crash dump''' RSX .RTS 16C < 60> 23-Sep-79 '''[[RSX-11]] run-time system''' TECO .RTS 39C < 60> 24-Sep-79 '''[[Text Editor and Corrector|TECO]] text editor''' Total of 1952 blocks in 11 files in SY:[0,1] Ready
Ready in this case is the system command prompt, similar to the C> prompt in MS-DOS or the % prompt in many Unix-based shells. The DIR command is an installed CCL equivalent to a RUN command for the DIRECT program. [0,1] is the account number (and directory name) of the main system storage account. It would be referred to as "project number 0, programmer number 1".
The numbers shown after each file represent its size in disk blocks, a block being 512 bytes or 1/2 kilobyte (K). "C" indicates the file is contiguous (is stored as one file without being separated into pieces, similar to files on a Microsoft Windows system after a drive has been defragmented), while "P" indicates it is specially protected (cannot be deleted, even by a privileged user unless the P bit is cleared by changing the protection code). The numbers in brackets (like "< 40>") represent the protections for the file, which is always displayed in decimal. Protections indicate if the file may be seen by any other user, by other users with the same programmer number, if the file is read only or if it may be altered by another user, and whether the file may be executed by an ordimary user giving them additional privileges. These protection codes are very similar to the r, w and x protections in Unix and similar operating systems such as BSD and Linux. Code 60 is equivalent to a private file, code 63 is a private non-deletable file, and 40 is a public file.
Certain other system files are kept in account [1,1]. The account [1,2] is the system-wide public library, and any public file in that account could be referenced by prefixing its name with a dollar sign ($). "!" is used for account [1,3], "%" for [1,4] and "&" for [1,5]. The account [1,1] also had the special privilege of being the only account where a user logged in under that account is permitted to execute the POKE system call to put values into any memory in the system. Thus the account number [1,1] is the closest equivalent to "root" on Unix-based systems.
When logged in, a user may either type language statements in the BASIC-PLUS programming language, issue the RUN command to run a program, or issue a special command called a CCL to execute a program with command options.
One of the features of RSTS is the means for the execution of programs and the environment used to run them. The various environments allowed for programming in BASIC-PLUS, the enhanced BASIC Plus 2, and in more traditional programming languages such as COBOL and FORTRAN. These environments were separate from each other such that one could start a program from one environment and switch to a different environment to run a different program. These environments were referred to as "run-time systems".
One of the most powerful text editors ever developed, the TECO editor, was itself implemented as a run-time system due to the amount of memory it used, (i.e. if it had run within another run-time system there probably would have been no memory available to edit user documents.)
Programs written in BASIC-PLUS ran under the BASIC run-time system, which allowed them 32K bytes of memory. If one wrote programs in a language that permitted true binary executables such as FORTRAN or the Macro Assembler or others that ran under the RT-11 run-time system, the amount of memory available would be 56K.
Programs written for the RSX run time system such as COBOL, the Macro Assembler, or the later releases of BASIC Plus 2, the amount of memory available to such a binary program would still be 56K due to the requirements of the RSX Run-Time System being allowed the top 8K to use for itself. RSTS version 7 and later allowed the RSX Run-Time system to be included in the kernel of RSTS, making it completely "disappear" from the user address space, thus allowing 62K of memory for user programs. The remaining 2K still could not be used, either because of software limitations in RSTS memory management, or deliberately, to catch accidental wraparound of addresses in user programs.
Programs got around the limitations of the amount of available memory by using libraries (when permissible), by complicated overlay strategies, or by calling other programs ("Chaining") and passing them commands in a shared memory area called "Core Common," among other practices.
RSTS Release Dates and historical notes
|V05-21||1973 July||First version called "RSTS/E".|
|V04B-17||1975 July||Final patch release of V04; last version for non-MMU machines.|
|V06A-02||1975 July||Last version to be installed using DOS-11.|
|7.2||1982 May||First release of RSTS/E supporting DECnet.|
|9.0||1985 May||DCL supercedes MCR as of this release.|
|8.0G||1985 September||Final patch release of 8.0|
|10.1A||1998||First and only Mentec release, Year 2000 fixes only.|
RSTS/E is available under a non-commercial free licence for hobbyist use on the Supnik emulator.
RSTS/E is still available under a commercial license from Mentec.