Misplaced Pages

#196803

61-502: The firm began life in 1966 as Computer Software Systems , a consulting firm headed by Bob Bernard. In 1967, joined by Dick Orenstein (one of the authors of CTSS ), the company began exploring the idea of offering time-sharing services based on CP/CMS . After IBM released CP/CMS under the IBM Type-III Library in 1968, and thus became available to CSS, this dream became possible. The small firm persuaded IBM to take an order for

122-532: A S/360-67 , and key technical people were recruited. The machine was delivered in November 1968. Harold Feinleib, an early recruit from MIT, describes the situation: I couldn’t imagine what the IBM people must have been thinking. This machine cost close to $ 100K a month to rent so I am sure they were quite concerned to accept the order from a couple of young guys. Even most big companies didn’t have machines this powerful. This

183-467: A multilevel feedback queue . It also had some special memory-management hardware, a clock interrupt, and the ability to trap certain instructions. 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

244-414: A named pipe or a process substitution can be used for parallel execution. GNU bash also has a lastpipe option to disable forking for the last pipe component. Pipelines can be created under program control. The Unix pipe() system call asks the operating system to construct a new anonymous pipe object. This results in two new, opened file descriptors in the process: the read-only end of

305-446: 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. By July, 1961 a few time sharing commands had become operational on

366-496: 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. 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

427-421: A dissatisfied customer could always "hang up the phone". This put great pressure on time-sharing vendors to provide attractive levels of performance and support. Hardware vendors of the day saw different priorities; they did not focus on consistent day-to-day support. Likewise, the in-house systems groups responsible for mainstream data processing were often seen as unresponsive by their end users. Feinleib relates

488-423: A maximum of six-characters long. Both support linked files. UNIX pipe In Unix-like computer operating systems , a pipeline is a mechanism for inter-process communication using message passing. A pipeline is a set of processes chained together by their standard streams , so that the output text of each process ( stdout ) is passed directly as input ( stdin ) to the next one. The second process

549-569: 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

610-613: 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. Debugging programs was an important problem at that time, because with batch processing, it then often took a day from submitting

671-401: A pipe are run in parallel, a shell typically forks a subprocess (a subshell) to handle its contents, making it impossible to propagate variable changes to the outside shell environment. To remedy this issue, the "pipemill" can instead be fed from a here document containing a command substitution , which waits for the pipeline to finish running before milling through the contents. Alternatively,

SECTION 10

#1733092346197

732-441: A process might create new threads and use the pipe to communicate between them. Named pipes may also be created using mkfifo() or mknod () and then presented as the input or output file to programs as they are invoked. They allow multi-path pipes to be created, and are especially effective when combined with standard error redirection, or with tee . The robot in the icon for Apple 's Automator , which also uses

793-448: A reading station for each user". 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". In June 1959, Christopher Strachey published

854-488: A run and a whole day. On our system, which used the same IBM COBOL compiler, they could get dozens of turnarounds a day. They would use an IBM Selectric Typewriter terminal to edit and enter their program, and then they could run and debug it. We enabled them to put in test data and even added a symbolic debugger so they could debug their programs interactively. This program development service sold like hot-cakes Later, as time-sharing became available in more development shops,

915-401: A single machine and between machines. (An interprocess communication interface, for example, was implemented providing transparent read/write access between remote applications – using normal file system I/O, analogous to a UNIX pipe . This let applications on different mainframes exchange data without the need for any software modification.) The nature of computer time-sharing was that

976-570: A story about NCSS customer support, and how a problem at Bell Labs was resolved: One day something happened to the disk they had their files on. It was a hardware failure. Now that wasn’t a problem because we did routine backups of all our customer files. Except, for some reason we didn’t backup Bell Labs files.... [I told the salesman to] tell them exactly what happened – that we screwed up and didn’t back up their files. Explain how it happened and then say that we will do anything to help them get their data back. He sucked in his gut and did it. After

1037-502: A transformation of business structures of the 80s and 90s, forcing technical resources to respond more directly to corporate and customer needs, and encouraging the creation of new user-centered methodologies (such as rapid prototyping and joint application design ). End user access to interactive computer systems was a key step in this change. The same users who used timesharing to outfox their MIS departments eventually became early adopters of PC technology. This shift ultimately marked

1098-409: A version of ALGOL . 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

1159-408: Is an example of a pipeline that implements a kind of spell checker for the web resource indicated by a URL . An explanation of what it does follows. By default, the standard error streams (" stderr ") of the processes in a pipeline are not passed on through the pipe; instead, they are merged and directed to the console . However, many shells have additional syntax for changing this behavior. In

1220-441: Is read by the next process, and this uni-directional channel disappears when the processes are completed; this differs from named pipes , where messages are passed to or from a pipe that is named by making it a file, and remains after the processes are completed. The standard shell syntax for anonymous pipes is to list multiple commands, separated by vertical bars ("pipes" in common Unix verbiage): For example, to list files in

1281-430: Is started as the first process is still executing, and they are executed concurrently . The concept of pipelines was championed by Douglas McIlroy at Unix 's ancestral home of Bell Labs , during the development of Unix, shaping its toolbox philosophy . It is named by analogy to a physical pipeline . A key feature of these pipelines is their "hiding of internals". This in turn allows for more clarity and simplicity in

SECTION 20

#1733092346197

1342-438: Is stopped (blocked) until at least some data is removed from the buffer by the receiver. In Linux, the size of the buffer is 65,536 bytes (64KiB). An open source third-party filter called bfr is available to provide larger buffers if required. Tools like netcat and socat can connect pipes to TCP/IP sockets . All widely used Unix shells have a special syntax construct for the creation of pipelines. In all usage one writes

1403-410: Is the concept of buffering : for example a sending program may produce 5000 bytes per second , and a receiving program may only be able to accept 100 bytes per second, but no data is lost. Instead, the output of the sending program is held in the buffer. When the receiving program is ready to read data, the next program in the pipeline reads from the buffer. If the buffer is filled, the sending program

1464-455: Is the most important thing. In this climate, NCSS built a strong support and consulting organization, able to help end-users bypass their in-house technical resources. This organization allowed the NCSS sales force to ignore traditional data processing procurement routes; they could instead sell directly to line managers with discretionary budgets and revenue responsibility. Doing so flew in the face of

1525-408: Is their "hiding of internals". This in turn allows for more clarity and simplicity in the system. In most Unix-like systems, all processes of a pipeline are started at the same time, with their streams appropriately connected, and managed by the scheduler together with all other processes running on the machine. An important aspect of this, setting Unix pipes apart from other pipe implementations,

1586-446: Is used for inter-process communication using message passing. A pipeline is a set of processes chained together by their standard streams , so that the output text of each process ( stdout ) is passed directly as input ( stdin ) to the next one. The second process is started as the first process is still executing, and they are executed concurrently . It is named by analogy to a physical pipeline . A key feature of these pipelines

1647-533: The pipe() system call and pipes to the shell and several utilities in Version 3 Unix. "The next day", McIlroy continued, "saw an unforgettable orgy of one-liners as everybody joined in the excitement of plumbing." McIlroy also credits Thompson with the | notation, which greatly simplified the description of pipe syntax in Version 4 . Although developed independently, Unix pipes are related to, and were preceded by,

1708-507: 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

1769-519: The NOMAD database system. When NCSS began selling remote access to its computers, it was selling to an industry where in-house programmers did their development via batch processing on punched cards. Feinleib describes their early appeal: In those days, COBOL programmers could get one or possibly two turnarounds a day because their in-house machines were used for production work most of the time. They worked with punched cards, so any slight error would waste

1830-496: The csh shell, for instance, using |& instead of | signifies that the standard error stream should also be merged with the standard output and fed to the next process. The Bash shell can also merge standard error with |& since version 4.0 or using 2>&1 , as well as redirect it to a different file. In the most commonly used simple pipelines the shell connects a series of sub-processes via pipes, and executes external commands within each sub-process. Thus

1891-601: The 'communication files' developed by Ken Lochner in the 1960s for the Dartmouth Time-Sharing System . This feature of Unix was borrowed by other operating systems, such as MS-DOS and the CMS Pipelines package on VM/CMS and MVS , and eventually came to be designated the pipes and filters design pattern of software engineering . In Tony Hoare's communicating sequential processes (CSP), McIlroy's pipes are further developed. A pipeline mechanism

National CSS - Misplaced Pages Continue

1952-616: 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 . Robert C. Daley, Peter R. Bos and at least 6 other programmers implemented the operating system, partly based on

2013-457: The DOTSYS braille translation software ran on CTSS and could output to a BRAILLEMBOSS braille page printer. 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

2074-491: The NCSS customer base gradually shifted to a larger proportion of end-users who were trying to solve information problems without using their in-house MIS departments. By the late 1970s, the main source of NCSS business growth was its NOMAD product, well-suited for such users. At the time of the D&;B acquisition, a follow-on technology was under development that would merge advanced operating system and database concepts. The project

2135-719: The NCSS system using dial-up terminals and modems : 110 or 300 baud was typical for the early years; 1200 baud became more common after the mid 70s. Some customers installed conditioned telephone circuits for constant higher-speed access. An innovative, nationwide packet-switched network , running primarily on DEC PDP-11s , provided access between modem banks and up to a dozen large IBM and Amdahl mainframes. This network also provided interconnections between mainframes. Various distributed applications at NCSS pioneered early implementations of teleconferencing , inter-user messaging, client/server database processing (before commercial SQL systems existed), and file sharing , both on

2196-472: The commands in sequence, separated by the ASCII vertical bar character | (which, for this reason, is often called "pipe character"). The shell starts the processes and arranges for the necessary connections between their standard streams (including some amount of buffer storage). The pipeline uses anonymous pipes . For anonymous pipes, data written by one process is buffered by the operating system until it

2257-452: The current directory ( ls ), retain only the lines of ls output containing the string "key" ( grep ), and view the result in a scrolling page ( less ), a user types the following into the command line of a terminal: The command ls -l is executed as a process, the output (stdout) of which is piped to the input (stdin) of the process for grep key ; and likewise for the process for less . Each process takes input from

2318-562: The design of the Titan Supervisor was inspired by that. Dennis Ritchie wrote in 1977 that UNIX could be seen as a "modern implementation" of CTSS. 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,

2379-537: The end of the timesharing industry – which was unable to exploit or even embrace the paradigm shift that it helped create. NCSS attracted an unusual cadre of innovative people. Its early technical team included leading lights from MIT and the CP/CMS community; and they in turn attracted other strong hires. A major appeal was the fact that, aside from hardware vendors, NCSS was one of very few organizations doing large-scale in-house operating system development. Moreover,

2440-529: The firm's small size, high-profile clients, and rapidly changing application needs meant that an individual developer or support person was likely to encounter many different challenging problems each month. The NCSS diaspora of the late 70s and early 80s helped seed many successful R&D groups and products with independent thinkers. Robert E. Weissman, who led NCSS when Dun & Bradstreet acquired it, later became chairman of Dun & Bradstreet and, after D&B spun IMS Health off, chairman of IMS Health. NCSS

2501-424: The initial shock, the folks at Bell Labs rolled up their sleeves with us and gathered stacks and stacks of printouts that we used to get their data keypunched, which we reloaded into the system. The way we handled this problem so impressed Bell Labs that they went on to become a much larger customer than ever before.... [Customers understand] that technology is fragile, and having confidence in their vendor relationship

National CSS - Misplaced Pages Continue

2562-494: 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. The first version of

2623-530: The loop's first iteration, such a program (let's call it the drain ) will read the remaining output from command , and the loop will then terminate (with results depending on the specifics of the drain). There are a couple of possible ways to avoid this behavior. First, some drains support an option to disable reading from stdin (e.g. ssh -n ). Alternatively, if the drain does not need to read any input from stdin to do something useful, it can be given < /dev/null as input. As all components of

2684-424: The mode of the file. Files could also be symbolically linked between directories. A directory listing by listf : Input-output hardware was mostly standard IBM peripherals . These included six data channels connecting to: 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. Maurice Wilkes witnessed CTSS and

2745-476: The pipe, and the write-only end. The pipe ends appear to be normal, anonymous file descriptors , except that they have no ability to seek. To avoid deadlock and exploit parallelism, the Unix process with one or more new pipes will then, generally, call fork() to create new processes. Each process will then close the end(s) of the pipe that it will not be using before producing or consuming any data. Alternatively,

2806-422: The previous process and produces output for the next process via standard streams . Each | tells the shell to connect the standard output of the command on the left to the standard input of the command on the right by an inter-process communication mechanism called an (anonymous) pipe , implemented in the operating system. Pipes are unidirectional; data flows through the pipeline from left to right. Below

2867-628: The red machine was moved to the Information Processing Center 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 . 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

2928-620: The security breach was extensive, there was apparently no malicious intent or damage done. Instead, a Kilroy was here attitude got a careless hacker into a great deal of hot water. The lessons learned – by NCSS, by D&B (its new masters), by the compromised clients, by the FBI, by the interested newspaper reporters, and ultimately by the reading public – helped raise awareness about security issues, in an industry that had been blithely indifferent to such risks. Compatible Time-Sharing System The Compatible Time-Sharing System ( CTSS )

2989-482: The shell itself is doing no direct processing of the data flowing through the pipeline. However, it's possible for the shell to perform processing directly, using a so-called mill or pipemill (since a while command is used to "mill" over the results from the initial command). This construct generally looks something like: Such pipemill may not perform as intended if the body of the loop includes commands, such as cat and ssh , that read from stdin : on

3050-457: 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 . This became

3111-447: The system. The pipes in the pipeline are anonymous pipes (as opposed to named pipes ), where data written by one process is buffered by the operating system until it is read by the next process, and this uni-directional channel disappears when the processes are completed. The standard shell syntax for anonymous pipes is to list multiple commands, separated by vertical bars (" pipes " in common Unix verbiage). The pipeline concept

SECTION 50

#1733092346197

3172-474: The technology establishment, which had hitherto maintained tight control over all technical decisions. Empowered end users were now able to ask and answer their own questions, without having to deal with the intermediary of a Computer Science professional. This released many frustrations, and helped change expectations about the role of information technology. Agile companies exploited this situation, and out-competed their slower-paced rivals. These changes fostered

3233-628: Was abandoned as unsuccessful. Instead, in 1982, NOMAD was ported to IBM's VM/370 operating system as NOMAD2, in conjunction with major customer Bank of America , and soon VP/CSS was also abandoned. NCSS achieved major successes with large banks, oil companies, pharmaceutical firms, and manufacturers, as well as many smaller clients. Important application areas included database publishing, financial analysis/modeling, engineering, sales analysis, bill-of-materials processing, statistics/crosstabulation, mailing list administration, patent management, and interactive software development. Most customers connected to

3294-488: Was invented by Douglas McIlroy and first described in the man pages of Version 3 Unix . McIlroy noticed that much of the time command shells passed the output file from one program as input to another. The concept of pipelines was championed by Douglas McIlroy at Unix 's ancestral home of Bell Labs , during the development of Unix, shaping its toolbox philosophy . His ideas were implemented in 1973 when ("in one feverish night", wrote McIlroy) Ken Thompson added

3355-455: 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". 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

3416-460: 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. Processor allocation scheduling with a quantum time unit 200 ms, was controlled by

3477-560: Was successfully demonstrated. 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. The following year, on CTSS,

3538-468: Was the first general purpose time-sharing operating system . 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

3599-558: Was the subject of a well-publicized computer hacking scandal. A lengthy New York Times article of 26 July 1981, by Vin McLellan, described how the NCSS master password list had been compromised – and how a thorough follow-up by the FBI became a learning experience for them. They learned all about how (and why) a young, bored technician might poke around a computer system, just to see what interesting things might be found. In this case, although

3660-452: Was their latest technology and we were one of the first to order one. By December 1968, the firm was reselling time. Needing more capital to expand, the company went public in 1970, changing its name to "National CSS" (because "CSS" was not available nationwide). After a couple of hard years, business took off in the mid 70s. NCSS was best known for two products: the VP/CSS operating system, and

3721-474: Was used to develop and test concepts for library automation. 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. CTSS used a modified IBM 7090 mainframe computer that had two 32,768 (32K) 36-bit- word banks of core memory instead of the default configuration which provides only one. One bank

SECTION 60

#1733092346197
#196803