Misplaced Pages

#110889

86-502: CMS Pipelines provides a CMS command, PIPE . The argument string to the PIPE command is the pipeline specification. PIPE selects programs to run and chains them together in a pipeline to pump data through. Because CMS programs and utilities don't provide a device independent stdin and stdout interface, CMS Pipelines has a built-in library of programs that can be called in a pipeline specification. These built-in programs interface to

172-401: A computer or a computing system. Most early computers only had a front panel to input or display bits and had to be connected to a terminal to print or input text through a keyboard. Teleprinters were used as early-day hard-copy terminals and predated the use of a computer screen by decades. The computer would typically transmit a line of data which would be printed on paper, and accept

258-582: A terminal (or pseudo terminal ) which is ultimately linked to a user's keyboard . On POSIX systems, the file descriptor for standard input is 0 (zero); the POSIX <unistd.h> definition is STDIN_FILENO ; the corresponding C <stdio.h> abstraction is provided via the FILE* stdin global variable. Similarly, the global C++ std::cin variable of type <iostream> provides an abstraction via C++ streams . Similar abstractions exist in

344-478: A built-in keyboard and display for the console. Some Unix-like operating systems such as Linux and FreeBSD have virtual consoles to provide several text terminals on a single computer. The fundamental type of application running on a text terminal is a command-line interpreter or shell , which prompts for commands from the user and executes each command after a press of Return . This includes Unix shells and some interactive programming environments. In

430-710: A complete GUI programmed and compiled in C/C++ using Qt , GTK , or other equivalent proprietary widget framework. The Services menu , as implemented on NeXTSTEP and Mac OS X , is also analogous to standard streams. On these operating systems, graphical applications can provide functionality through a system-wide menu that operates on the current selection in the GUI, no matter in what application. Some GUI programs, primarily on Unix, still write debug information to standard error. Others (such as many Unix media players) may read files from standard input. Popular Windows programs that open

516-409: A computer program and its environment when it begins execution. The three input/output (I/O) connections are called standard input ( stdin ), standard output ( stdout ) and standard error ( stderr ). Originally I/O happened via a physically connected system console (input via keyboard, output via monitor), but standard streams abstract this. When a command is executed via an interactive shell ,

602-430: A field that may have previously required a full screen-full of characters to be re-sent from the computer, possibly over a slow modem line. Around the mid-1980s most intelligent terminals, costing less than most dumb terminals would have a few years earlier, could provide enough user-friendly local editing of data and send the completed form to the main computer. Providing even more processing possibilities, workstations like

688-530: A green or amber screen. Typically terminals communicate with the computer via a serial port via a null modem cable, often using an EIA RS-232 or RS-422 or RS-423 or a current loop serial interface. IBM systems typically communicated over a Bus and Tag channel, a coaxial cable using a proprietary protocol, a communications link using Binary Synchronous Communications or IBM's SNA protocol, but for many DEC, Data General and NCR (and so on) computers there were many visual display suppliers competing against

774-622: A keyboard in 1941, as did the Z4 in 1942–1945. However, these consoles could only be used to enter numeric inputs and were thus analogous to those of calculating machines; programs, commands, and other data were entered via paper tape. Both machines had a row of display lamps for results. In 1956, the Whirlwind Mark ;I computer became the first computer equipped with a keyboard-printer combination with which to support direct input of data and commands and output of results. That device

860-461: A library such as ncurses . For more complex operations, the programs can use terminal specific ioctl system calls. For an application, the simplest way to use a terminal is to simply write and read text strings to and from it sequentially. The output text is scrolled, so that only the last several lines (typically 24) are visible. Unix systems typically buffer the input text until the Enter key

946-636: A line of data from a keyboard over a serial or other interface. Starting in the mid-1970s with microcomputers such as the Sphere 1 , Sol-20 , and Apple I , display circuitry and keyboards began to be integrated into personal and workstation computer systems, with the computer handling character generation and outputting to a CRT display such as a computer monitor or, sometimes, a consumer TV, but most larger computers continued to require terminals. Early terminals were inexpensive devices but very slow compared to punched cards or paper tape for input; with

SECTION 10

#1732802268111

1032-613: A microprocessor is built in, but not all terminals with microprocessors did any real processing of input: the main computer to which it was attached would have to respond quickly to each keystroke. The term "intelligent" in this context dates from 1969. Notable examples include the IBM 2250 , predecessor to the IBM 3250 and IBM 5080, and IBM 2260 , predecessor to the IBM 3270 , introduced with System/360 in 1964. Most terminals were connected to minicomputers or mainframe computers and often had

1118-489: A pipeline is typed as a CMS command, all stages are written on a single line. The concept of a simple pipeline is extended in these ways: CMS Pipelines offers several features to improve the robustness of programs: John Hartmann, of IBM Denmark, started development of CMS Pipelines in 1980. The product was marketed by IBM as a separate product during the 80's and integrated in VM/ESA late 1991. With each release of VM,

1204-431: A program is run as a daemon , its standard error stream is redirected into a log file, typically for error analysis purposes. Streams may be used to chain applications, meaning that the output stream of one program can be redirected to be the input stream to another application. In many operating systems this is expressed by listing the application names, separated by the vertical bar character, for this reason often called

1290-594: A real-world terminal, sometimes allowing concurrent use of local programs and access to a distant terminal host system, either over a direct serial connection or over a network using, e.g., SSH . Today few if any dedicated computer terminals are being manufactured, as time sharing on large computers has been replaced by personal computers, handheld devices and workstations with graphical user interfaces. User interactions with servers use either software such as Web browsers , or terminal emulators, with connections over high-speed networks. The console of Konrad Zuse 's Z3 had

1376-485: A separate console window in addition to their GUI windows are the emulators pSX and DOSBox . GTK-server can use stdin as a communication interface with an interpreted program to realize a GUI. The Common Lisp Interface Manager paradigm "presents" GUI elements sent to an extended output stream. System console A computer terminal is an electronic or electromechanical hardware device that can be used for entering data into, and transcribing data from,

1462-593: A sequence of codes were sent to the terminal to try to read the cursor's position or the 25th line's contents using a sequence of different manufacturer's control code sequences, and the terminal-generated response would determine a single-digit number (such as 6 for Data General Dasher terminals, 4 for ADM 3A/5/11/12 terminals, 0 or 2 for TTYs with no special features) that would be available to programs to say which set of codes to use. The great majority of terminals were monochrome, manufacturers variously offering green, white or amber and sometimes blue screen phosphors. (Amber

1548-472: A shell, most of the commands are small applications themselves. Another important application type is that of the text editor . A text editor typically occupies the full area of display, displays one or more text documents, and allows the user to edit the documents. The text editor has, for many uses, been replaced by the word processor , which usually provides rich formatting features that the text editor lacks. The first word processors used text to communicate

1634-537: A single output stream. The output is written to the new disk file. The secondary output of locate (marked by the second occurrence of the a: label) contains the records that did not meet the selection criterion. These records are translated to upper case (by the xlate stage) and passed to the secondary input stream of faninany (marked by the second occurrence of the i: label). The pipeline topology in this example consists of two connected pipelines. The end character (the ? in this example) separates

1720-455: A standard, AlphaWindows , that would allow a single CRT screen to implement multiple windows, each of which was to behave as a distinct terminal. Unfortunately, like I2O , this suffered from being run as a closed standard: non-members were unable to obtain even minimal information and there was no realistic way a small company or independent developer could join the consortium. An intelligent terminal does its own processing, usually implying

1806-446: A terminal as "intelligent" was its ability to process user-input within the terminal—not interrupting the main computer at each keystroke—and send a block of data at a time (for example: when the user has finished a whole field or form). Most terminals in the early 1980s, such as ADM-3A, TVI912, Data General D2, DEC VT52 , despite the introduction of ANSI terminals in 1978, were essentially "dumb" terminals, although some of them (such as

SECTION 20

#1732802268111

1892-456: A typical application the host sends the terminal a preformatted panel containing both static data and fields into which data may be entered. The terminal operator keys data, such as updates in a database entry, into the appropriate fields. When entry is complete (or ENTER or PF key pressed on 3270s), a block of data, usually just the data entered by the operator (modified data), is sent to the host in one transmission. The 3270 terminal buffer (at

1978-402: Is " thin client ". A thin client typically uses a protocol like X11 for Unix terminals, or RDP for Microsoft Windows. The bandwidth needed depends on the protocol used, the resolution, and the color depth . Modern graphic terminals allow display of images in color, and of text in varying sizes, colors, and fonts (type faces). In the early 1990s, an industry consortium attempted to define

2064-406: Is a serial computer interface for text entry and display. Information is presented as an array of pre-selected formed characters . When such devices use a video display such as a cathode-ray tube , they are called a " video display unit " or "visual display unit" (VDU) or "video display terminal" (VDT). The system console is often a text terminal used to operate a computer. Modern computers have

2150-420: Is a stream independent of standard output and can be redirected separately. This solves the semi-predicate problem , allowing output and errors to be distinguished, and is analogous to a function returning a pair of values – see Semipredicate problem § Multivalued return . The usual destination is the text terminal which started the program to provide the best chance of being seen even if standard output

2236-522: Is a type of computer terminal that communicates with its host in blocks of data, as opposed to a character-oriented terminal that communicates with its host one character at a time. A block-oriented terminal may be card-oriented, display-oriented, keyboard-display, keyboard-printer, printer or some combination. The IBM 3270 is perhaps the most familiar implementation of a block-oriented display terminal, but most mainframe computer manufacturers and several other companies produced them. The description below

2322-495: Is achieved via RS-232 serial links, Ethernet or other proprietary protocols . Character-oriented terminals can be "dumb" or "smart". 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. In this context dumb terminals are sometimes dubbed glass Teletypes , for they essentially have

2408-462: Is in terms of the 3270, but similar considerations apply to other types. Block-oriented terminals typically incorporate a buffer which stores one screen or more of data, and also stores data attributes, not only indicating appearance (color, brightness, blinking, etc.) but also marking the data as being enterable by the terminal operator vs. protected against entry, as allowing the entry of only numeric information vs. allowing any characters, etc. In

2494-400: Is limited, the number of concurrent lines that can be displayed at one time is limited. Vector-mode displays were historically important but are no longer used. Practically all modern graphic displays are raster-mode, descended from the picture scanning techniques used for television , in which the visual elements are a rectangular array of pixels . Since the raster image is only perceptible to

2580-444: Is pressed, so the application receives a ready string of text. In this mode, the application need not know much about the terminal. For many interactive applications this is not sufficient. One of the common enhancements is command-line editing (assisted with such libraries as readline ); it also may give access to command history. This is very helpful for various interactive command-line interpreters. Even more advanced interactivity

2666-428: Is provided with full-screen applications. Those applications completely control the screen layout; also they respond to key-pressing immediately. This mode is very useful for text editors, file managers and web browsers . In addition, such programs control the color and brightness of text on the screen, and decorate it with underline, blinking and special characters (e.g. box-drawing characters ). To achieve all this,

CMS Pipelines - Misplaced Pages Continue

2752-418: Is redirected (so not readily observed). For example, output of a program in a pipeline is redirected to input of the next program or a text file, but errors from each program still go directly to the text terminal so they can be reviewed by the user in real time. It is acceptable and normal to direct standard output and standard error to the same destination, such as the text terminal. Messages appear in

2838-445: The <unistd.h> header file provides the symbol STDERR_FILENO ; the corresponding C <stdio.h> variable is FILE* stderr . The C++ <iostream> standard header provides two variables associated with this stream: std::cerr and std::clog , the former being unbuffered and the latter using the same buffering mechanism as all other C++ streams. Bourne -style shells allow standard error to be redirected to

2924-430: The C programming language , the standard input, output, and error streams are attached to the existing Unix file descriptors 0, 1 and 2 respectively. In a POSIX environment the < unistd.h > definitions STDIN_FILENO , STDOUT_FILENO or STDERR_FILENO should be used instead rather than magic numbers . File pointers stdin , stdout , and stderr are also provided. Ken Thompson (designer and implementer of

3010-520: The CMS Pipelines code was upgraded as well until it was functionally frozen at the 1.1.10 level in VM/ESA 2.3 in 1997. Since then, the latest level of CMS Pipelines has been available for download from the CMS Pipelines homepage for users who wish to explore new function. The current level of CMS Pipelines is included in the z/VM releases again since z/VM 6.4, available since November 11, 2016. An implementation of CMS Pipelines for TSO

3096-509: The IBM 2741 (1965) and the DECwriter (1970). Respective top speeds of teletypes, IBM 2741 and the LA30 (an early DECwriter) were 10, 15 and 30 characters per second. Although at that time "paper was king" the speed of interaction was relatively limited. The DECwriter was the last major printing-terminal product. It faded away after 1980 under pressure from video display units (VDUs), with

3182-750: The Intel 8080 . This made them inexpensive and they quickly became extremely popular input-output devices on many types of computer system, often replacing earlier and more expensive printing terminals. After 1970 several suppliers gravitated to a set of common standards: The experimental era of serial VDUs culminated with the VT100 in 1978. By the early 1980s, there were dozens of manufacturers of terminals, including Lear-Siegler , ADDS , Data General, DEC , Hazeltine Corporation , Heath/Zenith , Hewlett-Packard , IBM, TeleVideo , Volker-Craig, and Wyse , many of which had incompatible command sequences (although many used

3268-506: The VT220 terminal strongly influenced the Model M shipped on IBM PCs from 1985, and through it all later computer keyboards. Although flat-panel displays were available since the 1950s, cathode-ray tubes continued to dominate the market until the personal computer had made serious inroads into the display terminal market. By the time cathode-ray tubes on PCs were replaced by flatscreens after

3354-400: The pipeline character. A well-known example is the use of a pagination application, such as more , providing the user control over the display of the output stream on the display. In most operating systems predating Unix , programs had to explicitly connect to the appropriate input and output devices. OS-specific intricacies caused this to be a tedious programming task. On many systems it

3440-418: The read operation. Not all programs require stream input. For example, the dir and ls programs (which display file names contained in a directory) may take command-line arguments , but perform their operations without any stream data input. Unless redirected , standard input is inherited from the parent process. In the case of an interactive shell, that is usually associated with the input device of

3526-584: The ASR Teletype models, included a paper tape reader and punch which could record output such as a program listing. The data on the tape could be re-entered into the computer using the tape reader on the teletype, or printed to paper. Teletypes used the current loop interface that was already used in telegraphy. A less expensive Read Only (RO) configuration was available for the Teletype. Custom-designs keyboard/printer terminals that came later included

CMS Pipelines - Misplaced Pages Continue

3612-446: The advent of time-sharing systems, terminals slowly pushed these older forms of interaction from the industry. Related developments were the improvement of terminal technology and the introduction of inexpensive video displays . Early Teletypes only printed out with a communications speed of only 75 baud or 10 5-bit characters per second, and by the 1970s speeds of video terminals had improved to 2400 or 9600 2400 bit/s . Similarly,

3698-642: The application must deal not only with plain text strings, but also with control characters and escape sequences, which allow moving the cursor to an arbitrary position, clearing portions of the screen, changing colors and displaying special characters, and also responding to function keys. The great problem here is that there are many different terminals and terminal emulators, each with its own set of escape sequences. In order to overcome this, special libraries (such as curses ) have been created, together with terminal description databases, such as Termcap and Terminfo. A block-oriented terminal or block mode terminal

3784-428: The built-in programs. A simple example that reads a disk file, separates records containing the string "Hello" from those that do not. The selected records are modified by appending the string "World!" to each of them; the other records are translated to upper case. The two streams are then combined and the records are written to a new output file. In this example, the < stage reads the input disk file and passes

3870-569: The computer manufacturer for terminals to expand the systems. In fact, the instruction design for the Intel 8008 was originally conceived at Computer Terminal Corporation as the processor for the Datapoint 2200 . From the introduction of the IBM 3270 , and the DEC VT100 (1978), the user and programmer could notice significant advantages in VDU technology improvements, yet not all programmers used

3956-600: The development of the VDU were the Univac Uniscope and the IBM 2260 , both in 1964. These were block-mode terminals designed to display a page at a time, using proprietary protocols; in contrast to character-mode devices, they enter data from the keyboard into a display buffer rather than transmitting them immediately. In contrast to later character-mode devices, the Uniscope used synchronous serial communication over an EIA RS-232 interface to communicate between

4042-479: The device) could be updated on a single character basis, if necessary, because of the existence of a "set buffer address order" (SBA), that usually preceded any data to be written/overwritten within the buffer. A complete buffer could also be read or replaced using the READ BUFFER command or WRITE command (unformatted or formatted in the case of the 3270). Block-oriented terminals cause less system load on

4128-423: The display, as well as the ability to switch emulation modes to mimic competitor's models, that became increasingly important selling features during the 1980s especially, when buyers could mix and match different suppliers' equipment to a greater extent than before. The advance in microprocessors and lower memory costs made it possible for the terminal to handle editing operations such as inserting characters within

4214-564: The early ADM-3 as a starting point). The great variations in the control codes between makers gave rise to software that identified and grouped terminal types so the system software would correctly display input forms using the appropriate control codes; In Unix-like systems the termcap or terminfo files, the stty utility, and the TERM environment variable would be used; in Data General's Business BASIC software, for example, at login-time

4300-478: The equivalent burden had to be orchestrated by the program. Since Unix provided standard streams, the Unix C runtime environment was obliged to support it as well. As a result, most C runtime environments (and C's descendants ), regardless of the operating system, provide equivalent functionality. Standard input is a stream from which a program reads its input data. The program requests data transfers by use of

4386-624: The fact that early character-mode terminals were often deployed to replace teletype machines as a way to reduce operating costs. The next generation of VDUs went beyond teletype emulation with an addressable cursor that gave them the ability to paint two-dimensional displays on the screen. Very early VDUs with cursor addressibility included the VT05 and the Hazeltine 2000 operating in character mode, both from 1970. Despite this capability, early devices of this type were often called "Glass TTYs". Later,

SECTION 50

#1732802268111

4472-460: The features of the new terminals ( backward compatibility in the VT100 and later TeleVideo terminals, for example, with "dumb terminals" allowed programmers to continue to use older software). Some dumb terminals had been able to respond to a few escape sequences without needing microprocessors: they used multiple printed circuit boards with many integrated circuits ; the single factor that classed

4558-548: The host and less network traffic than character-oriented terminals. They also appear more responsive to the user, especially over slow connections, since editing within a field is done locally rather than depending on echoing from the host system. Early terminals had limited editing capabilities – 3270 terminals, for example, only could check entries as valid numerics. Subsequent "smart" or "intelligent" terminals incorporated microprocessors and supported more local processing. Programmers of block-oriented terminals often used

4644-505: The host computer for its processing power is called a " dumb terminal " or a thin client . In the era of serial ( RS-232 ) terminals there was a conflicting usage of the term "smart terminal" as a dumb terminal with no user-accessible local computing power but a particularly rich set of control codes for manipulating the display; this conflict was not resolved before hardware serial terminals became obsolete. A personal computer can run terminal emulator software that replicates functions of

4730-429: The human eye as a whole for a very short time, the raster must be refreshed many times per second to give the appearance of a persistent display. The electronic demands of refreshing display memory meant that graphic terminals were developed much later than text terminals, and initially cost much more. Most terminals today are graphical; that is, they can show images on the screen. The modern term for graphical terminal

4816-436: The individual pipelines in the pipeline set. Records read from the input file pass through either of the two routes of the pipeline topology. Because neither of the routes contain stages that need to buffer records, CMS Pipelines ensures that records arrive at faninany in the order in which they passed through locate . The example pipeline is presented in 'portrait form' with the individual stages on separate lines. When

4902-498: The intrinsic ISO_FORTRAN_ENV module was standardized to include the named constants INPUT_UNIT , OUTPUT_UNIT , and ERROR_UNIT to portably specify the unit numbers. ALGOL 60 was criticized for having no standard file access. ALGOL 68 's input and output facilities were collectively referred to as the transput. Koster coordinated the definition of the transput standard. The model included three standard channels: stand in , stand out , and stand back . In

4988-812: The last revision (the DECwriter IV of 1982) abandoning the classic teletypewriter form for one more resembling a desktop printer. A video display unit (VDU) displays information on a screen rather than printing text to paper and typically uses a cathode-ray tube (CRT). VDUs in the 1950s were typically designed for displaying graphical data rather than text and were used in, e.g., experimental computers at institutions like MIT ; computers used in academia, government and business, sold under brand names like DEC , ERA , IBM and UNIVAC ; military computers supporting specific defence applications such as ballistic missile warning systems and radar/air defence coordination systems like BUIC and SAGE . Two early landmarks in

5074-431: The later ADM and TVI models) did have a primitive block-send capability. Common early uses of local processing power included features that had little to do with off-loading data processing from the host computer but added useful features such as printing to a local printer, buffered serial data transmission and serial handshaking (to accommodate higher serial transfer speeds), and more sophisticated character attributes for

5160-404: The multiplexer and the host, while the 2260 used either a channel connection or asynchronous serial communication between the 2848 and the host. The 2265, related to the 2260, also used asynchronous serial communication. The Datapoint 3300 from Computer Terminal Corporation , announced in 1967 and shipped in 1969, was a character-mode device that emulated a Model 33 Teletype . This reflects

5246-534: The operating system, and perform many utility functions. Data on CMS is structured in logical records rather than a stream of bytes. For textual data a line of text corresponds to a logical record. In CMS Pipelines the data is passed between the stages as logical records. CMS Pipelines users issue pipeline commands from the terminal or in EXEC procedures. Users can write programs in REXX that can be used in addition to

SECTION 60

#1732802268111

5332-407: The operator attempted to enter more data into the field than allowed. A graphical terminal can display images as well as text. Graphical terminals are divided into vector-mode terminals, and raster mode . A vector-mode display directly draws lines on the face of a cathode-ray tube under control of the host computer system. The lines are continuously formed, but since the speed of electronics

5418-604: The original Unix operating system) modified sort in Version 5 Unix to accept "-" as representing standard input, which spread to other utilities and became a part of the operating system as a special file in Version 8 . Diagnostics were part of standard output through Version 6 , after which Dennis M. Ritchie created the concept of standard error. In Java , the standard streams are referred to by System.in (for stdin), System.out (for stdout), and System.err (for stderr). In C# and other .NET languages,

5504-544: The parent process. In the case of an interactive shell, that is usually the text terminal which initiated the program. The file descriptor for standard output is 1 (one); the POSIX <unistd.h> definition is STDOUT_FILENO ; the corresponding C <stdio.h> variable is FILE* stdout ; similarly, the C++ <iostream> variable is std::cout . Standard error is another output stream typically used by programs to output error messages or diagnostics. It

5590-425: The records to the next stage in the pipeline. The locate stage separates the input stream into two output streams. The primary output of locate (records containing Hello) passes the records to the insert stage. The insert stage modifies the input records as specified in its arguments and passes them to its output. The output is connected to faninany that combines records from all input streams to form

5676-573: The same destination that standard output is directed to using csh -style shells allow standard error to be redirected to the same destination that standard output is directed to using Standard error was added to Unix in the 1970s after several wasted phototypesetting runs ended with error messages being typeset instead of displayed on the user's terminal. Fortran has the equivalent of Unix file descriptors: By convention, many Fortran implementations use unit numbers UNIT=5 for stdin, UNIT=6 for stdout and UNIT=0 for stderr. In Fortran-2003,

5762-472: The same limited functionality as does a mechanical Teletype. This type of dumb terminal is still supported on modern Unix-like systems by setting the environment variable TERM to dumb . Smart or intelligent terminals are those that also have the ability to process escape sequences, in particular the VT52, VT100 or ANSI escape sequences. A text terminal , or often just terminal (sometimes text console )

5848-415: The same order as the program writes them, unless buffering is involved. For example, in common situations the standard error stream is unbuffered but the standard output stream is line-buffered; in this case, text written to standard error later may appear on the terminal earlier, if the standard output stream buffer is not yet full. The file descriptor for standard error is defined by POSIX as 2 (two);

5934-413: The screen usually causes the terminal to scroll down one line, entering data into the last screen position on a block-oriented terminal usually causes the cursor to wrap — move to the start of the first enterable field. Programmers might "protect" the last screen position to prevent inadvertent wrap. Likewise a protected field following an enterable field might lock the keyboard and sound an audible alarm if

6020-415: The simplest form, a text terminal is like a file. Writing to the file displays the text and reading from the file produces what the user enters. In Unix-like operating systems, there are several character special files that correspond to available text terminals. For other operations, there are special escape sequences , control characters and termios functions that a program can use, most easily via

6106-441: The speed of remote batch terminals had improved to 4800 bit/s at the beginning of the decade and 19.6 kbps by the end of the decade, with higher speeds possible on more expensive terminals. The function of a terminal is typically confined to transcription and input of data; a device with significant local, programmable data-processing capability may be called a "smart terminal" or fat client . A terminal that depends on

6192-412: The standard I/O libraries of practically every programming language . Standard output is a stream to which a program writes its output data. The program requests data transfer with the write operation. Not all programs generate output. For example, the file rename command (variously called mv , move , or ren ) is silent on success. Unless redirected , standard output is inherited from

6278-580: The standard streams are referred to by System.Console.In (for stdin), System.Console.Out (for stdout) and System.Console.Error (for stderr). Basic read and write capabilities for the stdin and stdout streams are also accessible directly through the class System.Console (e.g. System.Console.WriteLine() can be used instead of System.Console.Out.WriteLine() ). System.Console.In , System.Console.Out and System.Console.Error are System.IO.TextReader (stdin) and System.IO.TextWriter (stdout, stderr) objects, which only allow access to

6364-752: The standard streams of the process. The following example, written in Python , shows how to redirect the standard input both to the standard output and to a text file. Graphical user interfaces (GUIs) do not always make use of the standard streams; they do when GUIs are wrappers of underlying scripts and/or console programs, for instance the Synaptic package manager GUI, which wraps apt commands in Debian and/or Ubuntu. GUIs created with scripting tools like Zenity and KDialog by KDE project make use of stdin, stdout, and stderr, and are based on simple scripts rather than

6450-452: The streams are typically connected to the text terminal on which the shell is running, but can be changed with redirection or a pipeline . More generally, a child process inherits the standard streams of its parent process . Users generally know standard streams as input and output channels that handle data coming from an input device, or that write data from the application. The data may be text with any encoding, or binary data . When

6536-494: The structure of the document, but later word processors operate in a graphical environment and provide a WYSIWYG simulation of the formatted output. However, text editors are still used for documents containing markup such as DocBook or LaTeX . Programs such as Telix and Minicom control a modem and the local terminal to let the user interact with remote servers. On the Internet , telnet and ssh work similarly. In

6622-511: The technique of storing context information for the transaction in progress on the screen, possibly in a hidden field, rather than depending on a running program to keep track of status. This was the precursor of the HTML technique of storing context in the URL as data to be passed as arguments to a CGI program. Unlike a character-oriented terminal, where typing a character into the last position of

6708-474: The term "glass TTY" tended to be restrospectively narrowed to devices without full cursor addressibility. The classic era of the VDU began in the early 1970s and was closely intertwined with the rise of time sharing computers . Important early products were the ADM-3A , VT52 , and VT100 . These devices used no complicated CPU , instead relying on individual logic gates , LSI chips, or microprocessors such as

6794-531: The underlying standard streams on a text basis. Full binary access to the standard streams must be performed through the System.IO.Stream objects returned by System.Console.OpenStandardInput() , System.Console.OpenStandardOutput() and System.Console.OpenStandardError() respectively. When applying the System.Diagnostics.Process class one can use the instance properties StandardInput , StandardOutput , and StandardError of that class to access

6880-417: The year 2000, the hardware computer terminal was nearly obsolete. A character-oriented terminal is a type of computer terminal that communicates with its host one character at a time, as opposed to a block-oriented terminal that communicates in blocks of data. It is the most common type of data terminal, because it is easy to implement and program. Connection to the mainframe computer or terminal server

6966-603: Was a Friden Flexowriter , which would continue to serve this purpose on many other early computers well into the 1960s. Early user terminals connected to computers were, like the Flexowriter, electromechanical teleprinters /teletypewriters (TeleTYpewriter, TTY), such as the Teletype Model ;33 , originally used for telegraphy ; early Teletypes were typically configured as Keyboard Send-Receive (KSR) or Automatic Send-Receive (ASR). Some terminals, such as

7052-499: Was claimed to reduce eye strain). Terminals with modest color capability were also available but not widely used; for example, a color version of the popular Wyse WY50, the WY350, offered 64 shades on each character cell. VDUs were eventually displaced from most applications by networked personal computers, at first slowly after 1985 and with increasing speed in the 1990s. However, they had a lasting influence on PCs. The keyboard layout of

7138-443: Was communicating with . Older operating systems forced upon the programmer a record structure and frequently non-orthogonal data semantics and device control. Unix eliminated this complexity with the concept of a data stream: an ordered sequence of data bytes which can be read until the end of file . A program may also write bytes as desired and need not, and cannot easily declare their count or grouping. Another Unix breakthrough

7224-423: Was necessary to obtain control of environment settings, access a local file table, determine the intended data set, and handle hardware correctly in the case of a punch card reader , magnetic tape drive , disk drive , line printer , card punch, or interactive terminal. One of Unix's several groundbreaking advances was abstract devices , which removed the need for a program to know or care what kind of devices it

7310-636: Was released in 1995 as BatchPipeWorks in the BatchPipes/MVS product. The up-to-date TSO implementation has been available as a Service Offering from IBM Denmark until 2010. Both versions are maintained from a single source code base and commonly referred to as CMS/TSO Pipelines . The specification is available in the Author's Edition. Stdin In computer programming , standard streams are preconnected input and output communication channels between

7396-412: Was to automatically associate input and output to terminal keyboard and terminal display, respectively, by default — the program (and programmer) did absolutely nothing to establish input and output for a typical input-process-output program (unless it chose a different paradigm). In contrast, previous operating systems usually required some—often complex— job control language to establish connections, or

#110889