Misplaced Pages

#153846

55-413: DCE/DFS consisted of multiple cooperative components that provided a network file system with strong file system semantics, attempting to mimic the behavior of POSIX local file systems while taking advantage of performance optimizations when possible. A DCE/DFS client system utilized a locally managed cache that would contain copies (or regions) of the original file. The client system would coordinate with

110-519: A flag or switch ) modifies the operation of a command; the effect is determined by the command's program. Options follow the command name on the command line, separated by spaces. A space before the first option is not always required, such as Dir/? and DIR /? in DOS, which have the same effect of listing the DIR command's available options, whereas dir --help (in many versions of Unix) does require

165-507: A help option provides a concise review of the options of a command. The command-line environment may not provide graphical enhancements such as different fonts or extended edit windows found in a GUI. It may be difficult for a new user to become familiar with all the commands and options available, compared with the icons and drop-down menus of a graphical user interface, without reference to manuals. Operating system (OS) command-line interfaces are usually distinct programs supplied with

220-478: A pipeline where the output of one command becomes the input to the next command. One can modify the set of available commands by modifying which paths appear in the PATH environment variable. Under Unix, commands also need be marked as executable files. The directories in the path variable are searched in the order they are given. By re-ordering the path, one can run e.g. \OS2\MDOS\E.EXE instead of \OS2\E.EXE, when

275-438: A CLI, presenting their own prompt to the user and accepting command lines. Other programs support both a CLI and a GUI. In some cases, a GUI is simply a wrapper around a separate CLI executable file . In other cases, a program may provide a CLI as an optional alternative to its GUI. CLIs and GUIs often support different functionality. For example, all features of MATLAB , a numerical analysis computer program, are available via

330-458: A Unix-like CLI. Microsoft provides MKS Inc. 's ksh implementation MKS Korn shell for Windows through their Services for UNIX add-on. Since 2001, the Macintosh operating system macOS has been based on a Unix-like operating system called Darwin . On these computers, users can access a Unix-like command-line interface by running the terminal emulator program called Terminal , which

385-504: A command procedure or script which itself can be treated as a command. These advantages mean that a user must figure out a complex command or series of commands only once, because they can be saved, to be used again. The commands given to a CLI shell are often in one of the following forms: where doSomething is, in effect, a verb , how an adverb (for example, should the command be executed verbosely or quietly ) and toFiles an object or objects (typically one or more files) on which

440-631: A common-denominator system. The POSIX specifications for Unix-like operating systems originally consisted of a single document for the core programming interface , but eventually grew to 19 separate documents (POSIX.1, POSIX.2, etc.). The standardized user command line and scripting interface were based on the UNIX System V shell. Many user-level programs, services, and utilities (including awk , echo , ed ) were also standardized, along with required program-level services (including basic I/O : file , terminal , and network ). POSIX also defines

495-446: A minor update of POSIX.1-2001. It incorporated two minor updates or errata referred to as Technical Corrigenda (TCs). Its contents are available on the web. Base Specifications, Issue 7 (or IEEE Std 1003.1-2008 , 2016 Edition). This standard consists of: IEEE Std 1003.1-2017 (Revision of IEEE Std 1003.1-2008) - IEEE Standard for Information Technology—Portable Operating System Interface (POSIX(R)) Base Specifications, Issue 7

550-588: A pure GUI. This is typically the case with operating system command shells . CLIs are also used by systems with insufficient resources to support a graphical user interface. Some computer language systems (such as Python , Forth , LISP , Rexx , and many dialects of BASIC ) provide an interactive command-line mode to allow for rapid evaluation of code. CLIs are often used by programmers and system administrators, in engineering and scientific environments, and by technically advanced personal computer users. CLIs are also popular among people with visual disabilities since

605-404: A server system where the original copy of the file was stored to ensure that multiple clients accessing the same file would re-fetch a cached copy of the file data when the original file had changed. The advantage of this approach is that it provided very good performance even over slow network connections because most of the file access was actually done to the local cached regions of the file. If

SECTION 10

#1732786532154

660-571: A standard threading library API which is supported by most modern operating systems. In 2008, most parts of POSIX were combined into a single standard (IEEE Std 1003.1-2008 , also known as POSIX.1-2008). As of 2014 , POSIX documentation is divided into two parts: The development of the POSIX standard takes place in the Austin Group (a joint working group among the IEEE, The Open Group , and

715-513: Is active a program is typically invoked by typing its name followed by command-line arguments (if any). For example, in Unix and Unix-like environments, an example of a command-line argument is: file.s is a command-line argument which tells the program rm to remove the file named file.s . Some programming languages, such as C , C++ and Java , allow a program to interpret the command-line arguments by handling them as string parameters in

770-467: Is also a trademark of the IEEE. POSIX is intended to be used by both application and system developers. Originally, the name "POSIX" referred to IEEE Std 1003.1-1988, released in 1988. The family of POSIX standards is formally designated as IEEE 1003 and the ISO/IEC standard number is ISO / IEC 9945. The standards emerged from a project that began in 1984 building on work from related activity in

825-441: Is available from either The Open Group or IEEE. It is technically identical to POSIX.1-2008 with Technical Corrigenda 1 and 2 applied. Its contents are available on the web. IEEE Std 1003.1-2024 - IEEE Standard for Information Technology—Portable Operating System Interface (POSIX(R)) Base Specifications, Issue 8 was published on 14 June 2024. Its contents are available on the web. POSIX mandates 512-byte default block sizes for

880-600: Is found in the Utilities sub-folder of the Applications folder, or by remotely logging into the machine using ssh . Z shell is the default shell for macOS; Bash, tcsh , and the KornShell are also provided. Before macOS Catalina , Bash was the default. A CLI is used whenever a large vocabulary of commands or queries, coupled with a wide (or arbitrary) range of options, can be entered more rapidly as text than with

935-516: Is the grammar that all commands must follow. In the case of operating systems , DOS and Unix each define their own set of rules that all commands must follow. In the case of embedded systems , each vendor, such as Nortel , Juniper Networks or Cisco Systems , defines their own proprietary set of rules. These rules also dictate how a user navigates through the system of commands. The semantics define what sort of operations are possible, on what sort of data these operations can be performed, and how

990-402: The /usr/group association. Richard Stallman suggested the name POSIX to the IEEE instead of the former IEEE-IX . The committee found it more easily pronounceable and memorable, and thus adopted it. Unix was selected as the basis for a standard system interface partly because it was "manufacturer-neutral". However, several major versions of Unix existed—so there was a need to develop

1045-660: The ISO/IEC JTC 1/SC 22 /WG 15). Before 1997, POSIX comprised several standards: After 1997, the Austin Group developed the POSIX revisions. The specifications are known under the name Single UNIX Specification , before they become a POSIX standard when formally approved by the ISO. POSIX.1-2001 (or IEEE Std 1003.1-2001) equates to the Single UNIX Specification, version 3 minus X/Open Curses . This standard consisted of: IEEE Std 1003.1-2004 involved

1100-466: The df and du utilities, reflecting the typical size of blocks on disks. When Richard Stallman and the GNU team were implementing POSIX for the GNU operating system , they objected to this on the grounds that most people think in terms of 1024 byte (or 1 KiB ) blocks. The environment variable POSIX_ME_HARDER was introduced to allow the user to force the standards-compliant behaviour. The variable name

1155-476: The main function . Other languages, such as Python , expose operating system specific API (functionality) through sys module , and in particular sys.argv for command-line arguments . In Unix-like operating systems , a single hyphen used in place of a file name is a special value specifying that a program should handle data coming from the standard input or send data to the standard output . A command-line option or simply option (also known as

SECTION 20

#1732786532154

1210-649: The 1996 Olympics website; DFS was used to synchronize their changes and update Web mirror sites around the world. POSIX The Portable Operating System Interface ( POSIX ; IPA : / ˈ p ɒ z . ɪ k s / ) is a family of standards specified by the IEEE Computer Society for maintaining compatibility between operating systems . POSIX defines application programming interfaces (APIs), along with command line shells and utility interfaces, for software compatibility (portability) with variants of Unix and other operating systems. POSIX

1265-533: The CLI, whereas the MATLAB GUI exposes only a subset of features. In Colossal Cave Adventure from 1975, the user uses a CLI to enter one or two words to explore a cave system. The command-line interface evolved from a form of communication conducted by people over teleprinter (TTY) machines. Sometimes these involved sending an order or a confirmation using telex . Early computer systems often used teleprinter as

1320-524: The PC's serial ports . These were typically used to interface an organization's new PC's with their existing mini- or mainframe computers, or to connect PC to PC. Some of these PCs were running Bulletin Board System software. Early operating system CLIs were implemented as part of resident monitor programs, and could not easily be replaced. The first implementation of the shell as a replaceable component

1375-498: The Windows CMD.EXE programs, the latter groups being based heavily on DEC's RSX-11 and RSTS CLIs. Under most operating systems, it is possible to replace the default shell program with alternatives; examples include 4DOS for DOS, 4OS2 for OS/2, and 4NT / Take Command for Windows. Although the term 'shell' is often used to describe a command-line interpreter, strictly speaking, a 'shell' can be any program that constitutes

1430-696: The automated conformance tests and their certification has not expired and the operating system has not been discontinued. Some versions of the following operating systems had been certified to conform to one or more of the various POSIX standards. This means that they passed the automated conformance tests. The certification has expired and some of the operating systems have been discontinued. The following are not certified as POSIX compliant yet comply in large part: Mostly POSIX compliant environments for OS/2 : Partially POSIX compliant environments for DOS include: The following are not officially certified as POSIX compatible, but they conform in large part to

1485-423: The command In zsh the $ RPROMPT variable controls an optional prompt on the right-hand side of the display. It is not a real prompt in that the location of text entry does not change. It is used to display information on the same line as the prompt, but right-justified. In RISC OS the command prompt is a * symbol, and thus (OS) CLI commands are often referred to as star commands . One can also access

1540-670: The command line interface as the primary user interface replaced by the Graphical User Interface . The command line remained available as an alternative user interface, often used by system administrators and other advanced users for system administration, computer programming and batch processing . In November 2006, Microsoft released version 1.0 of Windows PowerShell (formerly codenamed Monad ), which combined features of traditional Unix shells with their proprietary object-oriented .NET Framework . MinGW and Cygwin are open-source packages for Windows that offer

1595-399: The command should act. The > in the third example is a redirection operator , telling the command-line interpreter to send the output of the command not to its own standard output (the screen) but to the named file. This will overwrite the file. Using >> will redirect the output and append it to the file. Another redirection operator is the vertical bar ( | ), which creates

1650-431: The commands and responses can be displayed using refreshable Braille displays . The general pattern of a command line interface is: In this format, the delimiters between command-line elements are whitespace characters and the end-of-line delimiter is the newline delimiter. This is a widely used (but not universal) convention. A CLI can generally be considered as consisting of syntax and semantics . The syntax

1705-466: The commands. Alternatives to CLIs include GUIs (most notably desktop metaphors with a mouse pointer , such as Microsoft Windows ), text-based user interface menus (such as DOS Shell and IBM AIX SMIT ), and keyboard shortcuts . Compared with a graphical user interface, a command-line interface requires fewer system resources to implement. Since options to commands are given in a few characters in each command line, an experienced user often finds

DCE Distributed File System - Misplaced Pages Continue

1760-407: The current time, user, shell number or working directory) in order, for instance, to make the prompt more informative or visually pleasing, to distinguish sessions on various machines, or to indicate the current level of nesting of commands. On some systems, special tokens in the definition of the prompt can be used to cause external programs to be called by the command-line interpreter while displaying

1815-422: The default is the opposite. Renaming of the executables also works: people often rename their favourite editor to EDIT, for example. The command line allows one to restrict available commands, such as access to advanced internal commands. The Windows CMD.EXE does this. Often, shareware programs will limit the range of commands, including printing a command 'your administrator has disabled running batch files' from

1870-452: The end user. To support this and other advanced DCE/DFS features, a local journaling file system (DCE/LFS also known as Episode ) was developed to provide the full range of support options. IBM has not maintained it since 2005: https://web.archive.org/web/20071009171709/http://www-306.ibm.com/software/stormgmt/dfs/ IBM was working on a replacement for DCE/DFS called ADFS (Advanced Distributed File System). One major goal of this project

1925-501: The features that are commonly considered to produce structured programs. The Bourne shell led to the development of the KornShell (ksh), Almquist shell (ash), and the popular Bourne-again shell (or Bash). Early microcomputers themselves were based on a command-line interface such as CP/M , DOS or AppleSoft BASIC . During the 1980s and 1990s, the introduction of the Apple Macintosh and of Microsoft Windows on PCs saw

1980-506: The first Multics shell was developed by Glenda Schroeder . The first Unix shell , the V6 shell , was developed by Ken Thompson in 1971 at Bell Labs and was modeled after Schroeder's Multics shell. The Bourne shell was introduced in 1977 as a replacement for the V6 shell. Although it is used as an interactive command interpreter, it was also intended as a scripting language and contains most of

2035-412: The grammar represents these operations and data—the symbolic meaning in the syntax. Two different CLIs may agree on either syntax or semantics, but it is only when they agree on both that they can be considered sufficiently similar to allow users to use both CLIs without needing to learn anything, as well as to enable re-use of scripts. A simple CLI will display a prompt, accept a command line typed by

2090-501: The interface mode. At this point, commands from the system mode may not be accessible until the user exits the interface mode and enters the system mode. A command prompt (or just prompt ) is a sequence of (one or more) characters used in a command-line interface to indicate readiness to accept commands. It literally prompts the user to take action. A prompt usually ends with one of the characters $ , % , # , : , > or - and often includes other information, such as

2145-598: The means of interaction with an operator. The mechanical teleprinter was replaced by a "glass tty" , a keyboard and screen emulating the teleprinter. "Smart" terminals permitted additional functions, such as cursor movement over the entire screen, or local editing of data on the terminal for transmission to the computer. As the microcomputer revolution replaced the traditional – minicomputer + terminals – time sharing architecture, hardware terminals were replaced by terminal emulators  — PC software that interpreted terminal signals sent through

2200-706: The mid-1960s, on computer terminals , as an interactive and more user-friendly alternative to the non-interactive interface available with punched cards . Today, most computer users rely on graphical user interfaces ("GUIs") instead of CLIs. However, many programs and operating system utilities lack GUIs, and are intended to be used through CLIs. Knowledge of CLIs is also useful for writing scripts . Programs that have CLIs are generally easy to automate via scripting, since command-lines, being mere lines of text, are easy to specify in code. CLIs are made possible by command-line interpreters or command-line processors , which are programs that read command-lines and carry out

2255-461: The newer C:\> style, unless used on floppy drives A: or B:; on those systems PROMPT $ N$ G can be used to override the automatic default and explicitly switch to the older style. Many Unix systems feature the $ PS1 variable (Prompt String 1), although other variables also may affect the prompt (depending on the shell used). In the Bash shell, a prompt of the form: could be set by issuing

DCE Distributed File System - Misplaced Pages Continue

2310-515: The operating system. A program that implements such a text interface is often called a command-line interpreter, command processor or shell . Examples of command-line interpreters include Nushell , DEC's DIGITAL Command Language (DCL) in OpenVMS and RSX-11 , the various Unix shells ( sh , ksh , csh , tcsh , zsh , Bash , etc.), CP/M 's CCP , DOS ' COMMAND.COM , as well as the OS/2 and

2365-422: The options easier to access. Automation of repetitive tasks is simplified by line editing and history mechanisms for storing frequently used sequences; this may extend to a scripting language that can take parameters and variable options. A command-line history can be kept, allowing review or repetition of commands. A command-line system may require paper or online manuals for the user's reference, although often

2420-468: The path of the current working directory and the hostname . On many Unix and derivative systems , the prompt commonly ends in $ or % if the user is a normal user, but in # if the user is a superuser ("root" in Unix terminology). End-users can often modify prompts. Depending on the environment, they may include colors, special characters, and other elements (like variables and functions for

2475-428: The prompt. Some CLIs, such as those in network routers , have a hierarchy of modes , with a different set of commands supported in each mode. The set of commands are grouped by association with security, system, interface, etc. In these systems the user might traverse through a series of sub-modes. For example, if the CLI had two modes called interface and system , the user might use the command interface to enter

2530-548: The prompt. In DOS' COMMAND.COM and in Windows NT's cmd.exe users can modify the prompt by issuing a PROMPT command or by directly changing the value of the corresponding %PROMPT% environment variable . The default of most modern systems, the C:\>; style is obtained, for instance, with PROMPT $ P$ G . The default of older DOS systems, C> is obtained by just PROMPT , although on some systems this produces

2585-463: The same commands from other command lines (such as the BBC BASIC command line), by preceding the command with a * . A command-line argument or parameter is an item of information provided to a program when it is started. A program can have many command-line arguments that identify sources or destinations of information, or that alter the operation of the program. When a command processor

2640-399: The server failed, the client could continue making changes to the file locally, storing it back to the server when it became available again. DCE/DFS also divorced the concept of logical units of management ( Filesets ) from the underlying volume on which the fileset was stored. In doing this it allowed administrative control of the location for the fileset in a manner that was transparent to

2695-409: The standards by implementing POSIX support via some sort of compatibility feature (usually translation libraries, or a layer atop the kernel). Without these features, they are usually non-compliant. Command-line interface A command-line interface ( CLI ) is a means of interacting with a computer program by inputting lines of text called command-lines . Command-line interfaces emerged in

2750-455: The user terminated by the Enter key , then execute the specified command and provide textual display of results or error messages. Advanced CLIs will validate, interpret and parameter-expand the command line before executing the specified command, and optionally capture or redirect its output. Unlike a button or menu item in a GUI, a command line is typically self-documenting, stating exactly what

2805-410: The user wants done. In addition, command lines usually include many defaults that can be changed to customize the results. Useful command lines can be saved by assigning a character string or alias to represent the full command, or several commands can be grouped to perform a more complex sequence – for instance, compile the program, install it, and run it — creating a single entity, called

SECTION 50

#1732786532154

2860-615: The user-interface, including fully graphically oriented ones. For example, the default Windows GUI is a shell program named EXPLORER.EXE , as defined in the SHELL=EXPLORER.EXE line in the WIN.INI configuration file. These programs are shells, but not CLIs. Application programs (as opposed to operating systems) may also have command-line interfaces. An application program may support none, any, or all of these three major types of command-line interface mechanisms: Some applications support

2915-407: Was later changed to POSIXLY_CORRECT . This variable is now also used for a number of other behaviour quirks. Depending upon the degree of compliance with the standards, one can classify operating systems as fully or partly POSIX compatible. Current versions of the following operating systems have been certified to conform to one or more of the various POSIX standards. This means that they passed

2970-568: Was part of the Multics time-sharing operating system . In 1964, MIT Computation Center staff member Louis Pouzin developed the RUNCOM tool for executing command scripts while allowing argument substitution. Pouzin coined the term shell to describe the technique of using commands like a programming language, and wrote a paper about how to implement the idea in the Multics operating system. Pouzin returned to his native France in 1965, and

3025-599: Was to decouple DFS from the complexities of DCE's cell directory services (CDS) and security services (secd). Another key feature would have been the elimination of enctype limitations associated with DCE/RPC. No public mention of this effort has been made since 2005, leading many to believe the project has been killed. The DCE Distributed File System (DFS) was adopted by the Open Software Foundation in 1989 as part of their Distributed Computing Environment . Staff in several locations simultaneously edited

#153846