A shell is software that provides an interface for users of an operating system to access the services of a kernel. However, the term is also applied very loosely to applications and may include any software that is "built around" a particular component, such as web browsers and email clients that are "shells" for HTML rendering engines. The name shell originates from shells being an outer layer of interface between the user and the internals of the operating system (the kernel).
Operating system shells generally fall into one of two categories: command-line and graphical. Command-line shells provide a command-line interface (CLI) to the operating system, while graphical shells like the Windows Shell[1][2][3] provide a graphical user interface (GUI). In either category the primary purpose of the shell is to invoke or "launch" another program; however, shells frequently have additional capabilities such as viewing the contents of directories.
The relative merits of CLI- and GUI-based shells are often debated. CLI proponents claim that certain operations can be performed much faster under CLI shells than under GUI shells (such as moving files, for example). However, GUI proponents advocate the comparative usability and simplicity of GUI shells. The best choice is often determined by the way in which a computer will be used. On a server mainly used for data transfers and processing with expert administration, a CLI is likely to be the best choice. However, a GUI would be more appropriate for a computer to be used for image or video editing and the development of the above data.
In expert systems, a shell is a piece of software that is an "empty" expert system without the knowledge base for any particular application.[4]
History
The first Unix shell, Ken Thompson's sh,[5] was modeled after the Multics shell,[6] itself modeled after the RUNCOM[7] program Louis Pouzin showed to the Multics Team. The 'rc' suffix on some Unix configuration files (e.g. ".vimrc"), is a remnant of the RUNCOM ancestry of Unix shells.[citation needed]
Practically all modern operating system shells can be used in both interactive and batch mode, the latter usually by specifying the name of a text file with commands listed therein. Batch mode use of shells usually involves structures, conditionals, variables, and other elements of programming languages; some have the bare essentials needed for such a purpose, others are very sophisticated programming languages in and of themselves. Conversely, some programming languages can be used interactively from an operating system shell or in a purpose-built programmer.
Text (CLI) shells
A command-line interface (CLI) is an operating system shell that uses alphanumeric characters typed on a keyboard to provide instructions and data to the operating system, interactively. For example, a teletypewriter can send codes representing keystrokes to a command interpreter program running on the computer; the command interpreter parses the sequence of keystrokes and responds with an error message if it cannot recognize the sequence of characters, or it may carry out some other program action such as loading an application program, listing files, logging in a user and many others. Operating systems such as UNIX have a large variety of shell programs with different commands, syntax and capabilities. Some operating systems had only a single style of command interface; commodity operating systems such as MS-DOS came with a standard command interface but third-party interfaces were also often available, providing additional features or functions such as menuing or remote program execution.
Application programs may also implement a command-line interface. For example, in Unix-like systems, the telnet program has a number of commands for controlling a link to a remote computer system. Since the commands to the program are made of the same keystrokes as the data being sent to a remote computer, some means of distinguishing the two are required. An escape sequence can be defined, using either a special local keystroke that is never passed on but always interpreted by the local system. The program becomes modal, switching between interpreting commands from the keyboard or passing keystrokes on as data to be processed.
A feature of many command-line shells is the ability to save sequences of commands for re-use. A data file can contain sequences of commands which the CLI can be made to follow as if typed in by a user. Special features in the CLI may apply when it is carrying out these stored instructions. Such batch files (script files) can be used repeatedly to automate routine operations such as initializing a set of programs when a system is restarted. The command-line shell may offer features such as Command-line completion, where the interpreter expands commands based on a few characters input by the user. A command-line interpreter may offer a history function, so that the user can recall earlier commands issued to the system and repeat them, possibly with some editing.
Since all commands to the operating system had to be typed by the user, short command names and compact systems for representing program options were common. Short names were sometimes hard for a user to recall, and early systems lacked the storage resources to provide a detailed on-line user instruction guide.
Graphical shells
A graphical user interface (GUI) represents programs and data using visual symbols instead of text. Graphical user interfaces became feasible as the cost of interactive computer graphic hardware declined. Most graphical user interfaces develop the metaphor of an "electronic desktop", where data files are represented as if paper documents on a desk, and application programs similarly have graphical representations instead of being invoked by command names.
On Microsoft Windows
Modern versions of the Microsoft Windows operating system use the Windows shell as their shell, also known as Windows Explorer. Windows Explorer provides the familiar desktop environment, start menu, and task bar, as well as a graphical user interface for accessing the file management functions of the operating system. Older versions also include Program Manager (progam.exe), which was the shell for the 3.x series of Microsoft Windows, and which in fact ships with later versions of Windows of both the 95 and NT types at least through Windows XP. The interfaces of Windows versions 1 and 2 were markedly different.
Desktop applications, like iTVmediaPlayer, are also considered shells, as long as they use a third-party engine. Likewise, many individuals and developers dissatisfied with the interface of Windows Explorer have developed software that either alters the functioning and appearance of the shell or replaces it entirely. WindowBlinds by StarDock is a good example of the former sort of application. LiteStep, SharpE and Emerge Desktop are good examples of the latter.
Interoperability programmes and purpose-designed software lets Windows users use equivalents of many of the various Unix-based GUIs discussed below, as well as Macintosh. An equivalent of the OS/2 Presentation Manager for version 3.0 can run some OS/2 programmes under some conditions using the OS/2 environmental subsystem in versions of Windows NT. For an example of the first, X Window-type environments can be run using combinations of Windows/Unix interoperability packages, communications suites such as Hummingbird Connectivity, and/or X server programmes for Windows such as WinAxe and others.
On X Window System
Graphical (GUI) shells typically build on top of a windowing system. In case of the X Window System, there are both independent X window managers, and complete desktop environments which depend on a window manager.
X Window System environments (mainly for Unix-like operating systems):
- independent X window managers, such as:
- desktop shells, such as:
- full desktop environments, such as:
On other platforms
- DOS Shell
- Finder (for Mac OS X)
- Doors CS, MirageOS, Ion, and CrunchyOS (for TI-83 and TI-84 series graphing calculators)
- OS/2 environments:
See also
References
- ^ Esposito, Dino. "New Graphical Interface: Enhance Your Programs with New Windows XP Shell Features". MSDN Magazine (November 2001). http://msdn.microsoft.com/en-us/magaz ine/cc302214.aspx. Retrieved September 11, 2012.
- ^ Esposito, Dino (December 1998). Visual C++ Windows shell programming. Apress. ISBN 978-1861001849.
- ^ Seely, Scott (June 15, 2000). Windows Shell Programming. Prentice Hall PTR. ISBN 978-0130254962.
- ^ British Computer Society: The BCS glossary of ICT and computing terms, Pearson Education, 2005, ISBN 0-13-147957-1, ISBN 978-0-13-147957-9, page 135
- ^ "V6 Thompson Shell Port - History". V6shell.org. http://v6shell.org/history/. Retrieved 2012-08-14.
- ^ Tom Van Vleck (1995-02-05). "Unix and Multics". Multicians.org. http://www.multicians.org/unix.html. Retrieved 2012-08-14.
- ^ Louis Pouzin (2000-11-25). "The Origin of the Shell". Multicians.org. http://www.multicians.org/shell.html. Retrieved 2012-08-14.
Window management topics |
|---|
| | | Methods | - Tiling
- Stacking
- Dynamic
- Compositing
- Re-parenting
|
|---|
| | | Tiling examples | |
|---|
| | | Stacking examples | |
|---|
| | | Compositing examples | |
|---|
| | | Systems with WMs | |
|---|
| | | Components | |
|---|
| | | Related reading | |
|---|
|
