Unix is a family of multitasking, multiuser computer operating systems that derive from the original AT&T Unix, development starting in the 1970s at the Bell Labs research center by Ken Thompson, Dennis Ritchie, others. Intended for use inside the Bell System, AT&T licensed Unix to outside parties in the late 1970s, leading to a variety of both academic and commercial Unix variants from vendors including University of California, Microsoft, IBM, Sun Microsystems. In the early 1990s, AT&T sold its rights in Unix to Novell, which sold its Unix business to the Santa Cruz Operation in 1995; the UNIX trademark passed to The Open Group, a neutral industry consortium, which allows the use of the mark for certified operating systems that comply with the Single UNIX Specification. As of 2014, the Unix version with the largest installed base is Apple's macOS. Unix systems are characterized by a modular design, sometimes called the "Unix philosophy"; this concept entails that the operating system provides a set of simple tools that each performs a limited, well-defined function, with a unified filesystem as the main means of communication, a shell scripting and command language to combine the tools to perform complex workflows.
Unix distinguishes itself from its predecessors as the first portable operating system: the entire operating system is written in the C programming language, thus allowing Unix to reach numerous platforms. Unix was meant to be a convenient platform for programmers developing software to be run on it and on other systems, rather than for non-programmers; the system grew larger as the operating system started spreading in academic circles, as users added their own tools to the system and shared them with colleagues. At first, Unix was not designed to be multi-tasking. Unix gained portability, multi-tasking and multi-user capabilities in a time-sharing configuration. Unix systems are characterized by various concepts: the use of plain text for storing data; these concepts are collectively known as the "Unix philosophy". Brian Kernighan and Rob Pike summarize this in The Unix Programming Environment as "the idea that the power of a system comes more from the relationships among programs than from the programs themselves".
In an era when a standard computer consisted of a hard disk for storage and a data terminal for input and output, the Unix file model worked quite well, as I/O was linear. In the 1980s, non-blocking I/O and the set of inter-process communication mechanisms were augmented with Unix domain sockets, shared memory, message queues, semaphores, network sockets were added to support communication with other hosts; as graphical user interfaces developed, the file model proved inadequate to the task of handling asynchronous events such as those generated by a mouse. By the early 1980s, users began seeing Unix as a potential universal operating system, suitable for computers of all sizes; the Unix environment and the client–server program model were essential elements in the development of the Internet and the reshaping of computing as centered in networks rather than in individual computers. Both Unix and the C programming language were developed by AT&T and distributed to government and academic institutions, which led to both being ported to a wider variety of machine families than any other operating system.
Under Unix, the operating system consists of many libraries and utilities along with the master control program, the kernel. The kernel provides services to start and stop programs, handles the file system and other common "low-level" tasks that most programs share, schedules access to avoid conflicts when programs try to access the same resource or device simultaneously. To mediate such access, the kernel has special rights, reflected in the division between user space and kernel space - although in microkernel implementations, like MINIX or Redox, functions such as network protocols may run in user space; the origins of Unix date back to the mid-1960s when the Massachusetts Institute of Technology, Bell Labs, General Electric were developing Multics, a time-sharing operating system for the GE-645 mainframe computer. Multics featured several innovations, but presented severe problems. Frustrated by the size and complexity of Multics, but not by its goals, individual researchers at Bell Labs started withdrawing from the project.
The last to leave were Ken Thompson, Dennis Ritchie, Douglas McIlroy, Joe Ossanna, who decided to reimplement their experiences in a new project of smaller scale. This new operating system was without organizational backing, without a name; the new operating system was a single-tasking system. In 1970, the group coined the name Unics for Uniplexed Information and Computing Service, as a pun on Multics, which stood for Multiplexed Information and Computer Services. Brian Kernighan takes credit for the idea, but adds that "no one can remember" the origin of the final spelling Unix. Dennis Ritchie, Doug McIlroy, Peter G. Neumann credit Kernighan; the operating system was written in assembly language, but in 1973, Version 4 Unix was rewritten in C. Version 4 Unix, still had many PDP-11 dependent codes, is not suitable for porting; the first port to other platform was made five years f
In computing, kill is a command, used in several popular operating systems to send signals to running processes. In Unix and Unix-like operating systems, kill is a command used to send a signal to a process. By default, the message sent, but kill is something of a misnomer. The kill command is a wrapper around the kill system call, which sends signals to processes or process groups on the system, referenced by their numeric process IDs or process group IDs. kill is always provided as a standalone utility as defined by the POSIX standard. However, most shells have built-in kill commands that may differ from it. There are many different signals that can be sent, although the signals in which users are most interested are SIGTERM and SIGKILL; the default signal sent is SIGTERM. Programs that handle this signal can do useful cleanup operations before quitting. However, many programs do not implement a special handler for this signal, so a default signal handler is called instead. Other times a process that has a special handler has gone awry in a way that prevents it from properly handling the signal.
All signals except for SIGKILL and SIGSTOP can be "intercepted" by the process, meaning that a special function can be called when the program receives those signals. The two exceptions SIGKILL and SIGSTOP are only seen by the host system's kernel, providing reliable ways of controlling the execution of processes. SIGKILL kills the process, SIGSTOP pauses it until a SIGCONT is received. Unix provides security mechanisms to prevent unauthorized users from killing other processes. For a process to send a signal to another, the owner of the signaling process must be the same as the owner of the receiving process or be the superuser; the available signals all have different names, are mapped to certain numbers. It is important to note that the specific mapping between numbers and signals can vary between Unix implementations. SIGTERM is numbered 15 while SIGKILL is numbered 9. A process can be sent a SIGTERM signal in four ways: The process can be sent a SIGKILL signal in three ways: Other useful signals include HUP, TRAP, INT, SEGV and ALRM.
HUP sends the SIGHUP signal. Some daemons, including Apache and Sendmail, re-read configuration files upon receiving SIGHUP, so the kill command may be used for this too. A SIGINT signal can be generated simply by pressing CTRL+C in most Unix shells, it is common for CTRL+Z to be mapped to SIGTSTP, for CTRL+\ to be mapped to SIGQUIT, which can force a program to do a core dump. Killall - on some variations of Unix, such as Solaris, this utility is automatically invoked when the system is going through a shutdown, it behaves much like the kill command above, but instead of sending a signal to an individual process, the signal is sent to all processes on the system. However, on others such as IRIX, FreeBSD, an argument is supplied specifying the name of the process to kill. For instance, to kill a process such as an instance of the XMMS music player invoked by xmms, the user would run the command killall xmms; this would kill all processes named xmms, is equivalent to kill `pidof xmms` on systems like Solaris.
Pkill - signals processes based on name and other attributes. It was introduced in Solaris 7 and has since been reimplemented for Linux, NetBSD and OpenBSD. Pkill makes killing processes based on their name much more convenient: e.g. to kill a process named firefox without pkill, one would have to type kill `ps --no-headers -C firefox -o pid` whereas with pkill, one can type pkill firefox. Xkill - if called without any parameters, the mouse cursor changes from an arrow to an "x" icon, the user can click on a window to force the X server to close the connection with the client owning the window; this causes the process to terminate when it detects that its connection to the X server has been closed. The kill command is available as a shell builtin in the OS-9 shell, it is used to kill another process by process ID. Stop the process with the process ID "7": In Microsoft's command-line interpreter Windows PowerShell, kill is a predefined command alias for the Stop-Process cmdlet. Microsoft Windows XP, Vista and 7 include the command taskkill to terminate processes.
The usual syntax for this command is taskkill /im "IMAGENAME". An "unsupported" version of kill was included in several releases of the Microsoft Windows Resource Kits available for Windows 98. GNU versions of kill have been ported via Cygwin and run inside of the Unix environment subsystem that Microsoft Windows Services for UNIX provides. Find all processes beginning with the letter "p" that were developed by Microsoft and use more than 10 MB of memory and kill them: Here is a simpler example, which asks the process Explorer.exe to terminate: This example forces the process to terminate: Processes can be killed by their PID number: Singularity shell, the standard shell for Microsoft Research's microkernel operating system Singularity includes a kill command to terminate background processes. Stop the process with the name "SampleProcess": Stop the process with the process identifier "42": Under Plan 9 from Bell Labs, the kill program does not perform this termination, nor does it take process IDs.
Rather, it takes the actual names of processes an
An operating system is system software that manages computer hardware and software resources and provides common services for computer programs. Time-sharing operating systems schedule tasks for efficient use of the system and may include accounting software for cost allocation of processor time, mass storage and other resources. For hardware functions such as input and output and memory allocation, the operating system acts as an intermediary between programs and the computer hardware, although the application code is executed directly by the hardware and makes system calls to an OS function or is interrupted by it. Operating systems are found on many devices that contain a computer – from cellular phones and video game consoles to web servers and supercomputers; the dominant desktop operating system is Microsoft Windows with a market share of around 82.74%. MacOS by Apple Inc. is in second place, the varieties of Linux are collectively in third place. In the mobile sector, use in 2017 is up to 70% of Google's Android and according to third quarter 2016 data, Android on smartphones is dominant with 87.5 percent and a growth rate 10.3 percent per year, followed by Apple's iOS with 12.1 percent and a per year decrease in market share of 5.2 percent, while other operating systems amount to just 0.3 percent.
Linux distributions are dominant in supercomputing sectors. Other specialized classes of operating systems, such as embedded and real-time systems, exist for many applications. A single-tasking system can only run one program at a time, while a multi-tasking operating system allows more than one program to be running in concurrency; this is achieved by time-sharing, where the available processor time is divided between multiple processes. These processes are each interrupted in time slices by a task-scheduling subsystem of the operating system. Multi-tasking may be characterized in co-operative types. In preemptive multitasking, the operating system slices the CPU time and dedicates a slot to each of the programs. Unix-like operating systems, such as Solaris and Linux—as well as non-Unix-like, such as AmigaOS—support preemptive multitasking. Cooperative multitasking is achieved by relying on each process to provide time to the other processes in a defined manner. 16-bit versions of Microsoft Windows used cooperative multi-tasking.
32-bit versions of both Windows NT and Win9x, used preemptive multi-tasking. Single-user operating systems have no facilities to distinguish users, but may allow multiple programs to run in tandem. A multi-user operating system extends the basic concept of multi-tasking with facilities that identify processes and resources, such as disk space, belonging to multiple users, the system permits multiple users to interact with the system at the same time. Time-sharing operating systems schedule tasks for efficient use of the system and may include accounting software for cost allocation of processor time, mass storage and other resources to multiple users. A distributed operating system manages a group of distinct computers and makes them appear to be a single computer; the development of networked computers that could be linked and communicate with each other gave rise to distributed computing. Distributed computations are carried out on more than one machine; when computers in a group work in cooperation, they form a distributed system.
In an OS, distributed and cloud computing context, templating refers to creating a single virtual machine image as a guest operating system saving it as a tool for multiple running virtual machines. The technique is used both in virtualization and cloud computing management, is common in large server warehouses. Embedded operating systems are designed to be used in embedded computer systems, they are designed to operate on small machines like PDAs with less autonomy. They are able to operate with a limited number of resources, they are compact and efficient by design. Windows CE and Minix 3 are some examples of embedded operating systems. A real-time operating system is an operating system that guarantees to process events or data by a specific moment in time. A real-time operating system may be single- or multi-tasking, but when multitasking, it uses specialized scheduling algorithms so that a deterministic nature of behavior is achieved. An event-driven system switches between tasks based on their priorities or external events while time-sharing operating systems switch tasks based on clock interrupts.
A library operating system is one in which the services that a typical operating system provides, such as networking, are provided in the form of libraries and composed with the application and configuration code to construct a unikernel: a specialized, single address space, machine image that can be deployed to cloud or embedded environments. Early computers were built to perform a series of single tasks, like a calculator. Basic operating system features were developed in the 1950s, such as resident monitor functions that could automatically run different programs in succession to speed up processing. Operating systems did not exist in their more complex forms until the early 1960s. Hardware features were added, that enabled use of runtime libraries and parallel processing; when personal computers became popular in the 1980s, operating systems were made for them similar in concept to those used on larger computers. In the 1940s, the earliest electronic digital systems had no operating systems.
Electronic systems of this time were programmed on rows of mechanical switches or by jumper wires on plug boards. These were special-purpose systems that, for example, generated ballistics tables for the military or controlled the pri
A shell script is a computer program designed to be run by the Unix shell, a command-line interpreter. The various dialects of shell scripts are considered to be scripting languages. Typical operations performed by shell scripts include file manipulation, program execution, printing text. A script which sets up the environment, runs the program, does any necessary cleanup, etc. is called a wrapper. The term is used more to mean the automated mode of running an operating system shell; the typical Unix/Linux/POSIX-compliant installation includes the KornShell in several possible versions such as ksh88, Korn Shell'93 and others. The oldest shell still in common use is the Bourne shell; the C and Tcl shells have syntax quite similar to that of said programming languages, the Korn shells and Bash are developments of the Bourne shell, based on the ALGOL language with elements of a number of others added as well. On the other hand, the various shells plus tools like awk, grep, BASIC, Lisp, C and so forth contributed to the Perl programming language.
Other shells available on a machine or available for download and/or purchase include Almquist shell, PowerShell, Z shell, the Tenex C Shell, a Perl-like shell. Related programs such as shells based on Python, Ruby, C, Perl, Rexx &c in various forms are widely available. Another somewhat common shell is osh, whose manual page states it "is an enhanced, backward-compatible port of the standard command interpreter from Sixth Edition UNIX."Windows-Unix interoperability software such as the MKS Toolkit, Cygwin, UWIN, Interix and others make the above shells and Unix programming available on Windows systems, providing functionality all the way down to signals and other inter-process communication, system calls and APIs. The Hamilton C shell is a Windows shell, similar to the Unix C Shell. Microsoft distributes Windows Services for UNIX for use with its NT-based operating systems in particular, which have a POSIX environmental subsystem. A shell script can provide a convenient variation of a system command where special environment settings, command options, or post-processing apply automatically, but in a way that allows the new script to still act as a normal Unix command.
One example would be to create a version of ls, the command to list files, giving it a shorter command name of l, which would be saved in a user's bin directory as /home/username/bin/l, a default set of command options pre-supplied. Here, the first line indicates which interpreter should execute the rest of the script, the second line makes a listing with options for file format indicators, all files, a size in blocks; the LC_COLLATE=C sets the default collation order to not fold upper and lower case together, not intermix dotfiles with normal filenames as a side effect of ignoring punctuation in the names, the "$@" causes any parameters given to l to pass through as parameters to ls, so that all of the normal options and other syntax known to ls can still be used. The user could simply use l for the most used short listing. Another example of a shell script that could be used as a shortcut would be to print a list of all the files and directories within a given directory. In this case, the shell script would start with its normal starting line of #!/bin/sh.
Following this, the script executes the command clear which clears the terminal of all text before going to the next line. The following line provides the main function of the script; the ls -al command lists the files and directories that are in the directory from which the script is being run. The ls command attributes could be changed to reflect the needs of the user. Note: If an implementation does not have the clear command, try using the clr command instead. Shell scripts allow several commands that would be entered manually at a command-line interface to be executed automatically, without having to wait for a user to trigger each stage of the sequence. For example, in a directory with three C source code files, rather than manually running the four commands required to build the final program from them, one could instead create a C shell script, here named build and kept in the directory with them, which would compile them automatically: The script would allow a user to save the file being edited, pause the editor, just run./build to create the updated program, test it, return to the editor.
Since the 1980s or so, scripts of this type have been replaced with utilities like make which are specialized for building programs. Simple batch jobs are not unusual for isolated tasks, but using shell loops and variables provides much more flexibility to users. A Bash script to convert JPEG images to PNG images, where the image names are provided on the command-line—possibly via wildcards—instead of each being listed within the script, can be created with this file saved in a file like /home/username/bin/jpg2png The jpg2png command can be run on an entire directory full of JPEG images with just /home/username/
Research Unix refers to early versions of the Unix operating system for DEC PDP-7, PDP-11, VAX and Interdata 7/32 and 8/32 computers, developed in the Bell Labs Computing Sciences Research Center. The term Research Unix first appeared in the Bell System Technical Journal to distinguish it from other versions internal to Bell Labs whose code-base had diverged from the primary CSRC version. However, that term was little-used until Version 8 Unix, but has been retroactively applied to earlier versions as well. Prior to V8, the operating system was most called UNIX or the UNIX Time-Sharing System. AT&T licensed Version 5 to educational institutions, Version 6 to commercial sites. Schools paid $200 and others $20,000, discouraging most commercial use, but Version 6 was the most used version into the 1980s. Research Unix versions are referred to by the edition of the manual that describes them, because early versions and the last few were never released outside of Bell Labs, grew organically. So, the first Research Unix would be the First Edition, the last the Tenth Edition.
Another common way of referring to them is Version x Unix. All modern editions of Unix—excepting Unix-like implementations such as Coherent and Linux—derive from the 7th Edition. Starting with the 8th Edition, versions of Research Unix had a close relationship to BSD; this began by using 4.1cBSD as the basis for the 8th Edition. In a Usenet post from 2000, Dennis Ritchie described these versions of Research Unix as being closer to BSD than they were to UNIX System V, which included some BSD code: Research Unix 8th Edition started from BSD 4.1c, but with enormous amounts scooped out and replaced by our own stuff. This continued with 10th; the ordinary user command-set was, I guess, a bit more BSD-flavored than SysVish, but it was pretty eclectic. In 2002, Caldera International released Unix V1-7 and 32V as FOSS under a permissive BSD-like software license. In 2017, Unix Heritage Society and Alcatel-Lucent USA Inc. on behalf of itself and Nokia Bell Laboratories, released v8, v9, v10 under the condition: "will not assert its copyright rights with respect to any non-commercial copying, performance, display or creation of derivative works of Research Unix®1 Editions 8, 9, 10".
Ancient UNIX Systems History of Unix Lions' Commentary on UNIX 6th Edition, with Source Code Inferno - Another operating system from the same team UNIX Evolution by Ian F. Darwin and Geoffrey Collyer Unix heritage - More links and source code for some Research Unix versions The Evolution of the Unix Time-sharing System by Dennis M. Ritchie The Restoration of Early UNIX Artifacts by Warren Toomey, School of IT, Bond University Full Manual Pages documentation for Research Unix 8th Edition. List of new features in Research Unix 9th Edition
Linux is a family of free and open-source software operating systems based on the Linux kernel, an operating system kernel first released on September 17, 1991 by Linus Torvalds. Linux is packaged in a Linux distribution. Distributions include the Linux kernel and supporting system software and libraries, many of which are provided by the GNU Project. Many Linux distributions use the word "Linux" in their name, but the Free Software Foundation uses the name GNU/Linux to emphasize the importance of GNU software, causing some controversy. Popular Linux distributions include Debian and Ubuntu. Commercial distributions include SUSE Linux Enterprise Server. Desktop Linux distributions include a windowing system such as X11 or Wayland, a desktop environment such as GNOME or KDE Plasma. Distributions intended for servers may omit graphics altogether, include a solution stack such as LAMP; because Linux is redistributable, anyone may create a distribution for any purpose. Linux was developed for personal computers based on the Intel x86 architecture, but has since been ported to more platforms than any other operating system.
Linux is the leading operating system on servers and other big iron systems such as mainframe computers, the only OS used on TOP500 supercomputers. It is used by around 2.3 percent of desktop computers. The Chromebook, which runs the Linux kernel-based Chrome OS, dominates the US K–12 education market and represents nearly 20 percent of sub-$300 notebook sales in the US. Linux runs on embedded systems, i.e. devices whose operating system is built into the firmware and is tailored to the system. This includes routers, automation controls, digital video recorders, video game consoles, smartwatches. Many smartphones and tablet computers run other Linux derivatives; because of the dominance of Android on smartphones, Linux has the largest installed base of all general-purpose operating systems. Linux is one of the most prominent examples of open-source software collaboration; the source code may be used and distributed—commercially or non-commercially—by anyone under the terms of its respective licenses, such as the GNU General Public License.
The Unix operating system was conceived and implemented in 1969, at AT&T's Bell Laboratories in the United States by Ken Thompson, Dennis Ritchie, Douglas McIlroy, Joe Ossanna. First released in 1971, Unix was written in assembly language, as was common practice at the time. In a key pioneering approach in 1973, it was rewritten in the C programming language by Dennis Ritchie; the availability of a high-level language implementation of Unix made its porting to different computer platforms easier. Due to an earlier antitrust case forbidding it from entering the computer business, AT&T was required to license the operating system's source code to anyone who asked; as a result, Unix grew and became adopted by academic institutions and businesses. In 1984, AT&T divested itself of Bell Labs; the GNU Project, started in 1983 by Richard Stallman, had the goal of creating a "complete Unix-compatible software system" composed of free software. Work began in 1984. In 1985, Stallman started the Free Software Foundation and wrote the GNU General Public License in 1989.
By the early 1990s, many of the programs required in an operating system were completed, although low-level elements such as device drivers and the kernel, called GNU/Hurd, were stalled and incomplete. Linus Torvalds has stated that if the GNU kernel had been available at the time, he would not have decided to write his own. Although not released until 1992, due to legal complications, development of 386BSD, from which NetBSD, OpenBSD and FreeBSD descended, predated that of Linux. Torvalds has stated that if 386BSD had been available at the time, he would not have created Linux. MINIX was created by Andrew S. Tanenbaum, a computer science professor, released in 1987 as a minimal Unix-like operating system targeted at students and others who wanted to learn the operating system principles. Although the complete source code of MINIX was available, the licensing terms prevented it from being free software until the licensing changed in April 2000. In 1991, while attending the University of Helsinki, Torvalds became curious about operating systems.
Frustrated by the licensing of MINIX, which at the time limited it to educational use only, he began to work on his own operating system kernel, which became the Linux kernel. Torvalds began the development of the Linux kernel on MINIX and applications written for MINIX were used on Linux. Linux matured and further Linux kernel development took place on Linux systems. GNU applications replaced all MINIX components, because it was advantageous to use the available code from the GNU Project with the fledgling operating system. Torvalds initiated a switch from his original license, which prohibited commercial redistribution, to the GNU GPL. Developers worked to integrate GNU components with the Linux kernel, making a functional and free operating system. Linus Torvalds had wanted to call his invention "Freax", a portmant
A command-line interface or command language interpreter known as command-line user interface, console user interface and character user interface, is a means of interacting with a computer program where the user issues commands to the program in the form of successive lines of text. A program which handles the interface is called shell; the CLI was the primary means of interaction with most computer systems on computer terminals in the mid-1960s, continued to be used throughout the 1970s and 1980s on OpenVMS, Unix systems and personal computer systems including MS-DOS, CP/M and Apple DOS. The interface is implemented with a command line shell, a program that accepts commands as text input and converts commands into appropriate operating system functions. Today, many end users if use command-line interfaces and instead rely upon graphical user interfaces and menu-driven interactions. However, many software developers, system administrators and advanced users still rely on command-line interfaces to perform tasks more efficiently, configure their machine, or access programs and program features that are not available through a graphical interface.
Alternatives to the command line include, but are not limited to text user interface menus, keyboard shortcuts, various other desktop metaphors centered on the pointer. Examples of this include the Windows versions 1, 2, 3, 3.1, 3.11, DosShell, Mouse Systems PowerPanel. Programs with command-line interfaces are easier to automate via scripting. Command-line interfaces for software other than operating systems include a number of programming languages such as Tcl/Tk, PHP, others, as well as utilities such as the compression utility WinZip, some FTP and SSH/Telnet clients. Compared with a graphical user interface, a command line requires fewer system resources to implement. Since options to commands are given in a few characters in each command line, an experienced user finds the options easier to access. Automation of repetitive tasks is simplified - most operating systems using a command line interface support some mechanism for storing used sequences in a disk file, for re-use. A command-line history can be kept, allowing repetition of commands.
A command-line system may require paper or online manuals for the user's reference, although a "help" option provides a concise review of the options of a command. The command-line environment may not provide the 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 drop-down menus of a graphical user interface, without repeated reference to manuals. Operating system command line interfaces are distinct programs supplied with the operating system. A program that implements such a text interface is called a command-line interpreter, command processor or shell. Examples of command-line interpreters include DEC's DIGITAL Command Language in OpenVMS and RSX-11, the various Unix shells, CP/M's CCP, DOS's COMMAND. COM, as well as the OS/2 and the Windows CMD. EXE programs, the latter groups being based on DEC's RSX-11 and RSTS CLIs. Under most operating systems, it is possible to replace the default shell program with alternatives.
Although the term'shell' is used to describe a command-line interpreter speaking a'shell' can be any program that constitutes the user-interface, including 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 may have command line interfaces. An application program may support none, any, or all of these three major types of command line interface mechanisms: Parameters: Most operating systems support a means to pass additional information to a program when it is launched; when a program is launched from an OS command line shell, additional text provided along with the program name is passed to the launched program. Interactive command line sessions: After launch, a program may provide an operator with an independent means to enter commands in the form of text. OS inter-process communication: Most operating systems support means of inter-process communication.
Command lines from client processes may be redirected to a CLI program by one of these methods. Some applications support only a CLI, presenting a CLI prompt to the user and acting upon command lines as they are entered. Other programs support both a CLI and a GUI. In some cases, a GUI is 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 support different functionality. For example, all features of MATLAB, a numerical analysis computer program, are available via the CLI, whereas the MATLAB GUI exposes only a subset of features; the early Sierra games, such as the first three King's Quest games, used commands from an internal command line to move the character around in the graphic window. The command-line interface evolved from a form of dialog once conducted by humans over teleprinter machines, in which human operators remotely exchanged inf