Unix systems are characterized by a modular design that is sometimes called the "Unix philosophy".
According to this philosophy, the operating system should provide a
set of simple tools, each of which performs a limited, well-defined
function. A unified filesystem (the Unix filesystem) and an inter-process communication mechanism known as "pipes" serve as the main means of communication, and a shell scripting and command language (the Unix shell) is used to combine the tools to perform complex workflows.
Unix distinguishes itself from its predecessors as the first portable operating system: almost the entire operating system is written in the C programming language, which allows Unix to operate on numerous platforms.
Unix was originally 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, and as users added their own tools to the system and
shared them with colleagues.
At first, Unix was not designed to be portable or for multi-tasking. Later, Unix gradually 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; a hierarchical file system; treating devices and certain types of inter-process communication (IPC) as files; and the use of a large number of software tools, small programs that can be strung together through a command-line interpreter using pipes,
as opposed to using a single monolithic program that includes all of
the same functionality. 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".
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.
The Unix 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, and
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 distinction of kernel space from user space, the latter being a priority realm where most application programs operate.
The origins of Unix date back to the mid-1960s when the Massachusetts Institute of Technology, Bell Labs, and General Electric were developing Multics, a time-sharing operating system for the GE-645 mainframe computer.
Multics featured several innovations,
but also 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, and Joe Ossanna,
who decided to reimplement their experiences in a new project of
smaller scale. This new operating system was initially without
organizational backing, and also 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, and Peter G. Neumann also credit Kernighan.
The operating system was originally written in assembly language,
but in 1973, Version 4 Unix was rewritten in C. Version 4 Unix, however, still had many PDP-11
dependent codes, and was not suitable for porting. The first port to
another platform was made five years later (1978) for the Interdata 8/32.
In 1974, Ken Robinson of the Department of Computer Science at University of New South Wales (UNSW) in Australia
requested a copy of Unix for their PDP-11/40 minicomputer from Dennis
Ritchie at Bell Labs. This 1975 installation made UNSW the first
university outside the United States to run Unix.
Bell Labs produced several versions of Unix that are collectively referred to as Research Unix. In 1975, the first source license for UNIX was sold to Donald B. Gillies at the University of Illinois at Urbana–Champaign Department of Computer Science (UIUC).
UIUC graduate student Greg Chesson, who had worked on the Unix kernel
at Bell Labs, was instrumental in negotiating the terms of the license.
During the late 1970s and early 1980s, the influence of Unix in academic circles led to large-scale adoption of Unix (BSD and System V)
by commercial startups, which in turn led to Unix fragmenting into
multiple, similar but often slightly mutually-incompatible systems
including DYNIX, HP-UX, SunOS/Solaris, AIX, and Xenix. In the late 1980s, AT&T Unix System Laboratories and Sun Microsystems developed System V Release 4 (SVR4), which was subsequently adopted by many commercial Unix vendors.
In the 1990s, Unix and Unix-like systems grew in popularity and became the operating system of choice for over 90% of the world's top 500 fastest supercomputers, as BSD and Linux distributions were developed through collaboration by a worldwide network of programmers. In 2000, Apple released Darwin, also a Unix system, which became the core of the Mac OS X operating system, later renamed macOS.
In the late 1980s, an open operating system standardization effort now known as POSIX provided a common baseline for all operating systems; IEEE
based POSIX around the common structure of the major competing variants
of the Unix system, publishing the first POSIX standard in 1988. In the
early 1990s, a separate but very similar effort was started by an
industry consortium, the Common Open Software Environment (COSE) initiative, which eventually became the Single UNIX Specification (SUS) administered by The Open Group. Starting in 1998, the Open Group and IEEE started the Austin Group,
to provide a common definition of POSIX and the Single UNIX
Specification, which, by 2008, had become the Open Group Base
Specification.
In 1999, in an effort towards compatibility, several Unix system vendors agreed on SVR4's Executable and Linkable Format
(ELF) as the standard for binary and object code files. The common
format allows substantial binary compatibility among different Unix
systems operating on the same CPU architecture.
The Filesystem Hierarchy Standard was created to provide a reference directory layout for Unix-like operating systems; it has mainly been used in Linux.
Components
The Unix system is composed of several components that were
originally packaged together. By including the development environment,
libraries, documents and the portable, modifiable source code for all of
these components, in addition to the kernel
of an operating system, Unix was a self-contained software system. This
was one of the key reasons it emerged as an important teaching and
learning tool and has had such a broad influence.
The inclusion of these components did not make the system large –
the original V7 UNIX distribution, consisting of copies of all of the
compiled binaries plus all of the source code and documentation occupied
less than 10 MB and arrived on a single nine-track magnetic tape. The printed documentation, typeset from the online sources, was contained in two volumes.
The names and filesystem locations of the Unix components have
changed substantially across the history of the system. Nonetheless, the
V7 implementation is considered by many to have the canonical early structure:
Kernel – source code in /usr/sys, composed of several sub-components:
conf – configuration and machine-dependent parts, including boot code
dev – device drivers for control of hardware (and some pseudo-hardware)
sys – operating system "kernel", handling memory management, process scheduling, system calls, etc.
h – header files, defining key structures within the system and important system-specific invariables
Development environment – early versions of Unix contained a development environment sufficient to recreate the entire system from source code:
cc – C language compiler (first appeared in V3 Unix)
as – machine-language assembler for the machine
ld – linker, for combining object files
lib – object-code libraries (installed in /lib or /usr/lib). libc,
the system library with C run-time support, was the primary library,
but there have always been additional libraries for things such as
mathematical functions (libm) or database access. V7 Unix introduced the first version of the modern "Standard I/O" library stdio as part of the system library. Later implementations increased the number of libraries significantly.
make – build manager (introduced in PWB/UNIX), for effectively automating the build process
include – header files for software development, defining standard interfaces and system invariants
Other languages – V7 Unix contained a Fortran-77 compiler, a programmable arbitrary-precision calculator (bc, dc), and the awk
scripting language; later versions and implementations contain many
other language compilers and toolsets. Early BSD releases included Pascal tools, and many modern Unix systems also include the GNU Compiler Collection as well as or instead of a proprietary compiler system.
Other tools – including an object-code archive manager (ar), symbol-table lister (nm), compiler-development tools (e.g. lex & yacc), and debugging tools.
Commands – Unix makes little distinction between commands (user-level programs) for system operation and maintenance (e.g. cron), commands of general utility (e.g. grep),
and more general-purpose applications such as the text formatting and
typesetting package. Nonetheless, some major categories are:
sh – the "shell" programmable command-line interpreter, the primary user interface on Unix before window systems appeared, and even afterward (within a "command window").
Utilities – the core toolkit of the Unix command set, including cp, ls, grep, find and many others. Subcategories include:
System utilities – administrative tools such as mkfs, fsck, and many others.
User utilities – environment management tools such as passwd, kill, and others.
Document formatting – Unix systems were used from the outset
for document preparation and typesetting systems, and included many
related programs such as nroff, troff, tbl, eqn, refer, and pic. Some modern Unix systems also include packages such as TeX and Ghostscript.
Graphics – the plot subsystem provided facilities for
producing simple vector plots in a device-independent format, with
device-specific interpreters to display such files. Modern Unix systems
also generally include X11 as a standard windowing system and GUI, and many support OpenGL.
Communications – early Unix systems contained no inter-system communication, but did include the inter-user communication programs mail and write. V7 introduced the early inter-system communication system UUCP, and systems beginning with BSD release 4.1c included TCP/IP utilities.
Documentation – Unix was the first operating system to include all of its documentation online in machine-readable form. The documentation included:
man – manual pages for each command, library component, system call, header file, etc.
doc – longer documents detailing major subsystems, such as the C language and troff
Plan 9 from Bell Labs extends Unix design principles and was developed as a successor to Unix.
The Unix system had a significant impact on other operating systems.
It achieved its reputation by its interactivity, by providing the
software at a nominal fee for educational use, by running on inexpensive
hardware, and by being easy to adapt and move to different machines.
Unix was originally written in assembly language, but was soon rewritten in C, a high-level programming language. Although this followed the lead of Multics and Burroughs, it was Unix that popularized the idea.
Unix had a drastically simplified file model compared to many
contemporary operating systems: treating all kinds of files as simple
byte arrays. The file system hierarchy contained machine services and
devices (such as printers, terminals, or disk drives), providing a uniform interface, but at the expense of occasionally requiring additional mechanisms such as ioctl and mode flags to access features of the hardware that did not fit the simple "stream of bytes" model. The Plan 9 operating system pushed this model even further and eliminated the need for additional mechanisms.
Unix also popularized the hierarchical file system with
arbitrarily nested subdirectories, originally introduced by Multics.
Other common operating systems of the era had ways to divide a storage
device into multiple directories or sections, but they had a fixed
number of levels, often only one level. Several major proprietary
operating systems eventually added recursive subdirectory capabilities
also patterned after Multics. DEC's RSX-11M's "group, user" hierarchy evolved into VMS directories, CP/M's volumes evolved into MS-DOS 2.0+ subdirectories, and HP's MPE group.account hierarchy and IBM's SSP and OS/400 library systems were folded into broader POSIX file systems.
Making the command interpreter an ordinary user-level program,
with additional commands provided as separate programs, was another
Multics innovation popularized by Unix. The Unix shell used the same language for interactive commands as for scripting (shell scripts – there was no separate job control language like IBM's JCL).
Since the shell and OS commands were "just another program", the user
could choose (or even write) their own shell. New commands could be
added without changing the shell itself. Unix's innovative command-line
syntax for creating modular chains of producer-consumer processes (pipelines) made a powerful programming paradigm (coroutines) widely available. Many later command-line interpreters have been inspired by the Unix shell.
A fundamental simplifying assumption of Unix was its focus on newline-delimited
text for nearly all file formats. There were no "binary" editors in the
original version of Unix – the entire system was configured using
textual shell command scripts. The common denominator in the I/O system
was the byte – unlike "record-based" file systems.
The focus on text for representing nearly everything made Unix pipes
especially useful and encouraged the development of simple, general
tools that could be easily combined to perform more complicated ad hoc
tasks. The focus on text and bytes made the system far more scalable
and portable than other systems. Over time, text-based applications have
also proven popular in application areas, such as printing languages (PostScript, ODF), and at the application layer of the Internet protocols, e.g., FTP, SMTP, HTTP, SOAP, and SIP.
Unix popularized a syntax for regular expressions
that found widespread use. The Unix programming interface became the
basis for a widely implemented operating system interface standard
(POSIX, see above). The C programming language soon spread beyond Unix, and is now ubiquitous in systems and applications programming.
Early Unix developers were important in bringing the concepts of modularity and reusability into software engineering
practice, spawning a "software tools" movement. Over time, the leading
developers of Unix (and programs that ran on it) established a set of
cultural norms for developing software, norms which became as important
and influential as the technology of Unix itself; this has been termed
the Unix philosophy.
The TCP/IP networking protocols were quickly implemented on the Unix versions widely used on relatively inexpensive computers, which contributed to the Internet explosion of worldwide real-time connectivity, and which formed the basis for implementations on many other platforms.
The Unix policy of extensive on-line documentation and (for many
years) ready access to all system source code raised programmer
expectations, and contributed to the launch of the free software movement in 1983.
In 1983, Richard Stallman announced the GNU (short for "GNU's Not Unix") project, an ambitious effort to create a free softwareUnix-like
system; "free" in the sense that everyone who received a copy would be
free to use, study, modify, and redistribute it. The GNU project's own
kernel development project, GNU Hurd, had not yet produced a working kernel, but in 1991 Linus Torvalds released the kernel Linux as free software under the GNU General Public License. In addition to their use in the GNU operating system, many GNU packages – such as the GNU Compiler Collection (and the rest of the GNU toolchain), the GNU C library and the GNU core utilities – have gone on to play central roles in other free Unix systems as well.
A free derivative of BSD Unix, 386BSD, was released in 1992 and led to the NetBSD and FreeBSD
projects. With the 1994 settlement of a lawsuit brought against the
University of California and Berkeley Software Design Inc. (USL v. BSDi) by Unix System Laboratories,
it was clarified that Berkeley had the right to distribute BSD Unix for
free if it so desired. Since then, BSD Unix has been developed in
several different product branches, including OpenBSD and DragonFly BSD.
Linux and BSD are increasingly filling the market needs
traditionally served by proprietary Unix operating systems, as well as
expanding into new markets such as the consumer desktop and mobile and
embedded devices. Because of the modular design of the Unix model,
sharing components is relatively common; consequently, most or all Unix
and Unix-like systems include at least some BSD code, and some systems
also include GNU utilities in their distributions.
In a 1999 interview, Dennis Ritchie voiced his opinion that Linux
and BSD operating systems are a continuation of the basis of the Unix
design, and are derivatives of Unix:
I think the Linux phenomenon is
quite delightful, because it draws so strongly on the basis that Unix
provided. Linux seems to be the among the healthiest of the direct Unix
derivatives, though there are also the various BSD systems as well as
the more official offerings from the workstation and mainframe
manufacturers.
In the same interview, he states that he views both Unix and Linux as
"the continuation of ideas that were started by Ken and me and many
others, many years ago".
OpenSolaris was the free software counterpart to Solaris developed by Sun Microsystems, which included a CDDL-licensed kernel and a primarily GNU userland. However, Oracle
discontinued the project upon their acquisition of Sun, which prompted a
group of former Sun employees and members of the OpenSolaris community
to fork OpenSolaris into the illumos kernel. As of 2014, illumos remains the only active open-source System V derivative.
ARPANET
In May 1975, RFC 681 described the development of Network Unix by the Center for Advanced Computation at the University of Illinois Urbana-Champaign. The Unix system was said to "present several interesting capabilities as an ARPANET mini-host". At the time, Unix required a license from Bell Telephone Laboratories
that cost US$20,000 for non-university institutions, while universities
could obtain a license for a nominal fee of $150. It was noted that
Bell was "open to suggestions" for an ARPANET-wide license.
The RFC specifically mentions that Unix "offers powerful local processing facilities in terms of user programs, several compilers, an editor based on QED, a versatile document preparation system, and an efficient file system featuring sophisticated access control, mountable and de-mountable volumes, and a unified treatment of peripherals as special files." The latter permitted the Network Control Program (NCP) to be integrated within the Unix file system, treating network connections as special files that could be accessed through standard Unix I/O calls,
which included the added benefit of closing all connections on program
exit, should the user neglect to do so. The modular design of Unix
allowed them "to minimize the amount of code added to the basic Unix kernel", with much of the NCP code in a swappable user process, running only when needed.
In October 1993, Novell, the company that owned the rights to the Unix System V source at the time, transferred the trademarks of Unix to the X/Open Company (now The Open Group), and in 1995 sold the related business operations to Santa Cruz Operation (SCO). Whether Novell also sold the copyrights to the actual software was the subject of a federal lawsuit in 2006, SCO v. Novell,
which Novell won. The case was appealed, but on August 30, 2011, the
United States Court of Appeals for the Tenth Circuit affirmed the trial
decisions, closing the case. Unix vendor SCO Group Inc. accused Novell of slander of title.
The present owner of the trademark UNIX is The Open Group, an industry standards consortium. Only systems fully compliant with and certified to the Single UNIX Specification qualify as "UNIX" (others are called "Unix-like").
By decree of The Open Group, the term "UNIX" refers more to a
class of operating systems than to a specific implementation of an
operating system; those operating systems which meet The Open Group's
Single UNIX Specification should be able to bear the UNIX 98 or UNIX 03
trademarks today, after the operating system's vendor pays a
substantial certification fee and annual trademark royalties to The Open
Group. Systems that have been licensed to use the UNIX trademark include AIX, EulerOS, HP-UX, Inspur K-UX, IRIX, macOS, Solaris, Tru64 UNIX (formerly "Digital UNIX", or OSF/1), and z/OS. Notably, EulerOS and Inspur K-UX are Linux distributions certified as UNIX 03 compliant.
Sometimes a representation like Un*x, *NIX, or *N?X is used to indicate all operating systems similar to Unix. This comes from the use of the asterisk (*)
and the question mark characters as wildcard indicators in many
utilities. This notation is also used to describe other Unix-like
systems that have not met the requirements for UNIX branding from the
Open Group.
The Open Group requests that UNIX is always used as an adjective followed by a generic term such as system to help avoid the creation of a genericized trademark.
Unix was the original formatting, but the usage of UNIX remains widespread because it was once typeset in small caps (Unix). According to Dennis Ritchie, when presenting the original Unix paper to the third Operating Systems Symposium of the American Association for Computing Machinery (ACM), "we had a new typesetter and troff had just been invented and we were intoxicated by being able to produce small caps".
Many of the operating system's predecessors and contemporaries used
all-uppercase lettering, so many people wrote the name in upper case due
to force of habit. It is not an acronym.
Trademark names can be registered by different entities in
different countries and trademark laws in some countries allow the same
trademark name to be controlled by two different entities if each entity
uses the trademark in easily distinguishable categories. The result is
that Unix has been used as a brand name for various products including
bookshelves, ink pens, bottled glue, diapers, hair driers and food
containers.
Several plural forms of Unix are used casually to refer to
multiple brands of Unix and Unix-like systems. Most common is the
conventional Unixes, but Unices, treating Unix as a Latin noun of the third declension, is also popular. The pseudo-Anglo-Saxon plural form Unixen is not common, although occasionally seen. Sun Microsystems, developer of the Solaris variant, has asserted that the term Unix is itself plural, referencing its many implementations.
Machine code is a strictly numerical language which is designed
to run as fast as possible, and may be considered as the lowest-level
representation of a compiled or assembled computer program or as a primitive and hardware-dependent
programming language. While it is possible to write programs directly
in machine code, managing individual bits and calculating numerical addresses
and constants manually is tedious and error-prone. For this reason,
programs are very rarely written directly in machine code in modern
contexts, but may be done for low level debugging, program patching (especially when assembler source is not available) and assembly language disassembly.
The majority of practical programs today are written in higher-level languages or assembly language. The source code is then translated to executable machine code by utilities such as compilers, assemblers, and linkers, with the important exception of interpreted programs, which are not translated into machine code. However, the interpreter
itself, which may be seen as an executor or processor performing the
instructions of the source code, typically consists of directly
executable machine code (generated from assembly or high-level language
source code).
Machine code is by definition the lowest level of programming
detail visible to the programmer, but internally many processors use microcode or optimise and transform machine code instructions into sequences of micro-ops. This is not generally considered to be a machine code.
Instruction set
Every processor or processor family has its own instruction set. Instructions are patterns of bits,
digits or characters that correspond to machine commands. Thus, the
instruction set is specific to a class of processors using (mostly) the
same architecture. Successor or derivative processor designs often
include instructions of a predecessor and may add new additional
instructions. Occasionally, a successor design will discontinue or alter
the meaning of some instruction code (typically because it is needed
for new purposes), affecting code compatibility to some extent; even
compatible processors may show slightly different behavior for some
instructions, but this is rarely a problem. Systems may also differ in
other details, such as memory arrangement, operating systems, or peripheral devices.
Because a program normally relies on such factors, different systems
will typically not run the same machine code, even when the same type of
processor is used.
A processor's instruction set may have all instructions of the
same length, or it may have variable-length instructions. How the
patterns are organized varies with the particular architecture and type
of instruction. Most instructions have one or more opcode fields which specifies the basic instruction type (such as arithmetic, logical, jump, etc.), the operation (such as add or compare), and other fields that may give the type of the operand(s), the addressing mode(s),
the addressing offset(s) or index, or the operand value itself (such
constant operands contained in an instruction are called immediates).
Not all machines or individual instructions have explicit operands. An accumulator machine
has a combined left operand and result in an implicit accumulator for
most arithmetic instructions. Other architectures (such as 8086 and the
x86-family) have accumulator versions of common instructions, with the
accumulator regarded as one of the general registers by longer
instructions. A stack machine
has most or all of its operands on an implicit stack. Special purpose
instructions also often lack explicit operands (CPUID in the x86
architecture writes values into four implicit destination registers, for
instance). This distinction between explicit and implicit operands is
important in code generators, especially in the register allocation
and live range tracking parts. A good code optimizer can track implicit
as well as explicit operands which may allow more frequent constant propagation, constant folding
of registers (a register assigned the result of a constant expression
freed up by replacing it by that constant) and other code enhancements.
Programs
A computer program is a list of instructions that can be executed by a central processing unit
(CPU). A program's execution is done in order for the CPU that is
executing it to solve a problem and thus accomplish a result. While
simple processors are able to execute instructions one after another, superscalar processors are capable of executing many instructions simultaneously.
Program flow
may be influenced by special 'jump' instructions that transfer
execution to an address (and hence instruction) other than the next
numerically sequential address. Whether these Conditional jumps occur is dependent upon a condition such as a value being greater than, less than, or equal to another value.
Assembly languages
A much more human friendly rendition of machine language, called assembly language, uses mnemonic codes to refer to machine code instructions, rather than using the instructions' numeric values directly, and uses symbolic names to refer to storage locations and sometimes registers. For example, on the Zilog Z80 processor, the machine code 00000101, which causes the CPU to decrement the Bprocessor register, would be represented in assembly language as DEC B.
Example
The MIPS architecture
provides a specific example for a machine code whose instructions are
always 32 bits long. The general type of instruction is given by the op (operation) field, the highest 6 bits. J-type (jump) and I-type (immediate) instructions are fully specified by op. R-type (register) instructions include an additional field funct to determine the exact operation. The fields used in these types are:
In some computer architectures, the machine code is implemented by an even more fundamental underlying layer called microcode,
providing a common machine language interface across a line or family
of different models of computer with widely different underlying dataflows. This is done to facilitate porting of machine language programs between different models. An example of this use is the IBM System/360
family of computers and their successors. With dataflow path widths of
8 bits to 64 bits and beyond, they nevertheless present a common
architecture at the machine language level across the entire line.
Using microcode to implement an emulator
enables the computer to present the architecture of an entirely
different computer. The System/360 line used this to allow porting
programs from earlier IBM machines to the new family of computers, e.g.
an IBM 1401/1440/1460 emulator on the IBM S/360 model 40.
Relationship to bytecode
Machine code is generally different from bytecode
(also known as p-code), which is either executed by an interpreter or
itself compiled into machine code for faster (direct) execution. An
exception is when a processor is designed to use a particular bytecode
directly as its machine code, such as is the case with Java processors.
Machine code and assembly code are sometimes called native code when referring to platform-dependent parts of language features or libraries.
Storing in memory
The Harvard architecture is a computer architecture with physically separate storage and signal pathways for the code (instructions) and data. Today, most processors implement such separate signal pathways for performance reasons but implement a Modified Harvard architecture, so they can support tasks like loading an executable program from disk storage as data and then executing it. Harvard architecture is contrasted to the Von Neumann architecture, where data and code are stored in the same memory which is read by the processor allowing the computer to execute commands.
From the point of view of a process, the code space is the part of its address space where the code in execution is stored. In multitasking systems this comprises the program's code segment and usually shared libraries. In multi-threading environment, different threads of one process share code space along with data space, which reduces the overhead of context switching considerably as compared to process switching.
Readability by humans
Pamela Samuelson wrote that machine code is so unreadable that the United States Copyright Office cannot identify whether a particular encoded program is an original work of authorship; however, the US Copyright Office does allow for copyright registration of computer programs and a program's machine code can sometimes be decompiled in order to make its functioning more easily understandable to humans.
However, the output of a decompiler or disassembler will be missing the
comments and symbolic references, so while the output may be easier to
read than the object code, it will still be more difficult than the
original source code. This problem does not exist for object-code
formats like SQUOZE, where the source code is included in the file.
Cognitive science professor Douglas Hofstadter has compared machine code to genetic code, saying that "Looking at a program written in machine language is vaguely comparable to looking at a DNA molecule atom by atom."
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 usually executed directly by the hardware and frequently 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 general-purpose desktop operating system is Microsoft Windows with a market share of around 76.45%. macOS by Apple Inc. is in second place (17.72%), and the varieties of Linux are collectively in third place (1.73%). In the mobile sector (including smartphones and tablets), Android's share is up to 72% in the year 2020.
According to third quarter 2016 data, Android's share on smartphones is
dominant with 87.5 percent with also a growth rate of 10.3 percent per
year, followed by Apple's iOS
with 12.1 percent with 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 the server and supercomputing sectors. Other
specialized classes of operating systems (special-purpose operating
systems), such as embedded and real-time systems, exist for many applications. Security-focused operating systems also exist. Some operating systems have low system requirements (e.g. light-weight Linux distribution). Others may have higher system requirements.
Some operating systems require installation or may come pre-installed with purchased computers (OEM-installation), whereas others may run directly from media (i.e. live cd) or flash memory (i.e. USB stick).
Types of operating systems
Single-tasking and multi-tasking
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 repeatedly in time slices
by a task-scheduling subsystem of the operating system. Multi-tasking
may be characterized in preemptive and 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- and multi-user
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, and 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 also
include accounting software for cost allocation of processor time, mass
storage, printing, and other resources to multiple users.
Distributed
A distributed operating system manages a group of distinct, networked computers and makes them appear to be a single computer, as all computations are distributed (divided amongst the constituent computers).
Templated
In the distributed and cloud computing context of an OS, templating refers to creating a single virtual machine image as a guest operating system, then saving it as a tool for multiple running virtual machines. The technique is used both in virtualization and cloud computing management, and is common in large server warehouses.
Embedded
Embedded operating systems are designed to be used in embedded computer systems.
They are designed to operate on small machines with less autonomy (e.g.
PDAs). They are very compact and extremely efficient by design, and are
able to operate with a limited amount of resources. Windows CE and Minix 3 are some examples of embedded operating systems.
Real-time
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. Such an event-driven system switches
between tasks based on their priorities or external events, whereas
time-sharing operating systems switch tasks based on clock interrupts.
Library
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.
History
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 modern
and more complex forms until the early 1960s. Hardware features were added, that enabled use of runtime libraries, interrupts, 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 plugboards.
These were special-purpose systems that, for example, generated
ballistics tables for the military or controlled the printing of payroll
checks from data on punched paper cards. After programmable
general-purpose computers were invented, machine languages (consisting
of strings of the binary digits 0 and 1 on punched paper tape) were
introduced that sped up the programming process (Stern, 1981).
OS/360 was used on most IBM mainframe computers beginning in 1966, including computers used by the Apollo program.
In the early 1950s, a computer could execute only one program at a
time. Each user had sole use of the computer for a limited period and
would arrive at a scheduled time with their program and data on punched
paper cards or punched tape. The program would be loaded into the machine, and the machine would be set to work until the program completed or crashed. Programs could generally be debugged via a front panel using toggle switches and panel lights. It is said that Alan Turing was a master of this on the early Manchester Mark 1 machine, and he was already deriving the primitive conception of an operating system from the principles of the universal Turing machine.
Later machines came with libraries of programs, which would be
linked to a user's program to assist in operations such as input and
output and compiling (generating machine code from human-readable symbolic code).
This was the genesis of the modern-day operating system. However,
machines still ran a single job at a time. At Cambridge University in
England, the job queue was at one time a washing line (clothesline) from
which tapes were hung with different colored clothes-pegs to indicate
job priority.
An improvement was the Atlas Supervisor. Introduced with the Manchester Atlas in 1962, it is considered by many to be the first recognisable modern operating system. Brinch Hansen described it as "the most significant breakthrough in the history of operating systems."
Mainframes
Through the 1950s, many major features were pioneered in the field of operating systems on mainframe computers, including batch processing, input/output interrupting, buffering, multitasking, spooling, runtime libraries, link-loading, and programs for sorting
records in files. These features were included or not included in
application software at the option of application programmers, rather
than in a separate operating system used by all applications. In 1959,
the SHARE Operating System was released as an integrated utility for the IBM 704, and later in the 709 and 7090 mainframes, although it was quickly supplanted by IBSYS/IBJOB on the 709, 7090 and 7094.
During the 1960s, IBM's OS/360
introduced the concept of a single OS spanning an entire product line,
which was crucial for the success of the System/360 machines. IBM's
current mainframe operating systems are distant descendants of this original system and modern machines are backwards-compatible with applications written for OS/360.
OS/360 also pioneered the concept that the operating system keeps
track of all of the system resources that are used, including program
and data space allocation in main memory and file space in secondary
storage, and file locking during updates. When a process is terminated for any reason, all of these resources are re-claimed by the operating system.
The alternative CP-67 system for the S/360-67 started a whole line of IBM operating systems focused on the concept of virtual machines. Other operating systems used on IBM S/360 series mainframes included systems developed by IBM: DOS/360[a] (Disk Operating System), TSS/360 (Time Sharing System), TOS/360 (Tape Operating System), BOS/360 (Basic Operating System), and ACP (Airline Control Program), as well as a few non-IBM systems: MTS (Michigan Terminal System), MUSIC (Multi-User System for Interactive Computing), and ORVYL (Stanford Timesharing System).
Control Data Corporation developed the SCOPE operating system in the 1960s, for batch processing. In cooperation with the University of Minnesota, the Kronos and later the NOS
operating systems were developed during the 1970s, which supported
simultaneous batch and timesharing use. Like many commercial timesharing
systems, its interface was an extension of the Dartmouth BASIC
operating systems, one of the pioneering efforts in timesharing and
programming languages. In the late 1970s, Control Data and the
University of Illinois developed the PLATO
operating system, which used plasma panel displays and long-distance
time sharing networks. Plato was remarkably innovative for its time,
featuring real-time chat, and multi-user graphical games.
In 1961, Burroughs Corporation introduced the B5000 with the MCP (Master Control Program) operating system. The B5000 was a stack machine designed to exclusively support high-level languages with no assembler;[b] indeed, the MCP was the first OS to be written exclusively in a high-level language (ESPOL, a dialect of ALGOL). MCP also introduced many other ground-breaking innovations, such as being the first commercial implementation of virtual memory. During development of the AS/400,
IBM made an approach to Burroughs to license MCP to run on the AS/400
hardware. This proposal was declined by Burroughs management to protect
its existing hardware production. MCP is still in use today in the Unisys company's MCP/ClearPath line of computers.
UNIVAC, the first commercial computer manufacturer, produced a series of EXEC operating systems.
Like all early main-frame systems, this batch-oriented system managed
magnetic drums, disks, card readers and line printers. In the 1970s,
UNIVAC produced the Real-Time Basic (RTB) system to support large-scale
time sharing, also patterned after the Dartmouth BC system.
Digital Equipment Corporation developed many operating systems for its various computer lines, including TOPS-10 and TOPS-20
time sharing systems for the 36-bit PDP-10 class systems. Before the
widespread use of UNIX, TOPS-10 was a particularly popular system in
universities, and in the early ARPANET community. RT-11 was a single-user real-time OS for the PDP-11 class minicomputer, and RSX-11 was the corresponding multi-user OS.
From the late 1960s through the late 1970s, several hardware
capabilities evolved that allowed similar or ported software to run on
more than one system. Early systems had utilized microprogramming to implement features on their systems in order to permit different underlying computer architectures
to appear to be the same as others in a series. In fact, most 360s
after the 360/40 (except the 360/44, 360/75, 360/91, 360/95 and 360/195)
were microprogrammed implementations.
The enormous investment in software for these systems made since
the 1960s caused most of the original computer manufacturers to continue
to develop compatible operating systems along with the hardware.
Notable supported mainframe operating systems include:
PC DOS was an early personal computer OS that featured a command line interface.
Mac OS by Apple Computer became the first widespread OS to feature a graphical user interface. Many of its features such as windows and icons would later become commonplace in GUIs.
The first microcomputers
did not have the capacity or need for the elaborate operating systems
that had been developed for mainframes and minis; minimalistic operating
systems were developed, often loaded from ROM and known as monitors. One notable early disk operating system was CP/M, which was supported on many early microcomputers and was closely imitated by Microsoft's MS-DOS, which became widely popular as the operating system chosen for the IBM PC (IBM's version of it was called IBM DOS or PC DOS). In the 1980s, Apple Computer Inc. (now Apple Inc.) abandoned its popular Apple II series of microcomputers to introduce the Apple Macintosh computer with an innovative graphical user interface (GUI) to the Mac OS.
The introduction of the Intel 80386 CPU chip in October 1985, with 32-bit architecture and paging capabilities, provided personal computers with the ability to run multitasking operating systems like those of earlier minicomputers and mainframes. Microsoft responded to this progress by hiring Dave Cutler, who had developed the VMS operating system for Digital Equipment Corporation. He would lead the development of the Windows NT operating system, which continues to serve as the basis for Microsoft's operating systems line. Steve Jobs, a co-founder of Apple Inc., started NeXT Computer Inc., which developed the NEXTSTEP operating system. NEXTSTEP would later be acquired by Apple Inc. and used, along with code from FreeBSD as the core of Mac OS X (macOS after latest name change).
The GNU Project was started by activist and programmer Richard Stallman with the goal of creating a complete free software replacement to the proprietary UNIX
operating system. While the project was highly successful in
duplicating the functionality of various parts of UNIX, development of
the GNU Hurd kernel proved to be unproductive. In 1991, Finnish computer science student Linus Torvalds, with cooperation from volunteers collaborating over the Internet, released the first version of the Linux kernel. It was soon merged with the GNU user space components and system software
to form a complete operating system. Since then, the combination of the
two major components has usually been referred to as simply "Linux" by
the software industry, a naming convention that Stallman and the Free Software Foundation remain opposed to, preferring the name GNU/Linux. The Berkeley Software Distribution, known as BSD, is the UNIX derivative distributed by the University of California, Berkeley, starting in the 1970s. Freely distributed and ported to many minicomputers, it eventually also gained a following for use on PCs, mainly as FreeBSD, NetBSD and OpenBSD.
Unix was originally written in assembly language. Ken Thompson wrote B, mainly based on BCPL, based on his experience in the MULTICS project. B was replaced by C,
and Unix, rewritten in C, developed into a large, complex family of
inter-related operating systems which have been influential in every
modern operating system.
The Unix-like family is a diverse group of operating systems, with several major sub-categories including System V, BSD, and Linux. The name "UNIX" is a trademark of The Open Group
which licenses it for use with any operating system that has been shown
to conform to their definitions. "UNIX-like" is commonly used to refer
to the large set of operating systems which resemble the original UNIX.
Unix-like systems run on a wide variety of computer architectures. They are used heavily for servers in business, as well as workstations in academic and engineering environments. Free UNIX variants, such as Linux and BSD, are popular in these areas.
Four operating systems are certified by The Open Group (holder of the Unix trademark) as Unix. HP's HP-UX and IBM's AIX
are both descendants of the original System V Unix and are designed to
run only on their respective vendor's hardware. In contrast, Sun Microsystems's Solaris can run on multiple types of hardware, including x86 and Sparc servers, and PCs. Apple's macOS, a replacement for Apple's earlier (non-Unix) Mac OS, is a hybrid kernel-based BSD variant derived from NeXTSTEP, Mach, and FreeBSD.
Unix interoperability was sought by establishing the POSIX
standard. The POSIX standard can be applied to any operating system,
although it was originally created for various Unix variants.
A subgroup of the Unix family is the Berkeley Software Distribution family, which includes FreeBSD, NetBSD, and OpenBSD. These operating systems are most commonly found on webservers,
although they can also function as a personal computer OS. The Internet
owes much of its existence to BSD, as many of the protocols now
commonly used by computers to connect, send and receive data over a
network were widely implemented and refined in BSD. The World Wide Web was also first demonstrated on a number of computers running an OS based on BSD called NeXTSTEP.
In 1974, University of California, Berkeley
installed its first Unix system. Over time, students and staff in the
computer science department there began adding new programs to make
things easier, such as text editors. When Berkeley received new VAX
computers in 1978 with Unix installed, the school's undergraduates
modified Unix even more in order to take advantage of the computer's
hardware possibilities. The Defense Advanced Research Projects Agency of the US Department of Defense
took interest, and decided to fund the project. Many schools,
corporations, and government organizations took notice and started to
use Berkeley's version of Unix instead of the official one distributed
by AT&T.
Steve Jobs, upon leaving Apple Inc. in 1985, formed NeXT Inc., a company that manufactured high-end computers running on a variation of BSD called NeXTSTEP. One of these computers was used by Tim Berners-Lee as the first webserver to create the World Wide Web.
Developers like Keith Bostic
encouraged the project to replace any non-free code that originated
with Bell Labs. Once this was done, however, AT&T sued. After two
years of legal disputes, the BSD project spawned a number of free
derivatives, such as NetBSD and FreeBSD (both in 1993), and OpenBSD (from NetBSD in 1995).
macOS
macOS (formerly "Mac OS X" and later "OS X") is a line of open core graphical operating systems developed, marketed, and sold by Apple Inc., the latest of which is pre-loaded on all currently shipping Macintosh computers. macOS is the successor to the original classic Mac OS, which had been Apple's primary operating system since 1984. Unlike its predecessor, macOS is a UNIX operating system built on technology that had been developed at NeXT through the second half of the 1980s and up until Apple purchased the company in early 1997.
The operating system was first released in 1999 as Mac OS X Server 1.0, followed in March 2001 by a client version (Mac OS X v10.0 "Cheetah"). Since then, six more distinct "client" and "server" editions of macOS have been released, until the two were merged in OS X 10.7 "Lion".
Prior to its merging with macOS, the server edition – macOS Server – was architecturally identical to its desktop counterpart and usually ran on Apple's line of Macintosh server hardware. macOS Server included work group management and administration software tools that provide simplified access to key network services, including a mail transfer agent, a Samba server, an LDAP server, a domain name server, and others. With Mac OS X v10.7 Lion,
all server aspects of Mac OS X Server have been integrated into the
client version and the product re-branded as "OS X" (dropping "Mac" from
the name). The server tools are now offered as an application.
The Linux kernel originated in 1991, as a project of Linus Torvalds,
while a university student in Finland. He posted information about his
project on a newsgroup for computer students and programmers, and
received support and assistance from volunteers who succeeded in
creating a complete and functional kernel.
Linux is Unix-like, but was developed without any Unix code, unlike BSD and its variants. Because of its open license model, the Linux kernel
code is available for study and modification, which resulted in its use
on a wide range of computing machinery from supercomputers to
smart-watches. Although estimates suggest that Linux is used on only 1.82% of all "desktop" (or laptop) PCs, it has been widely adopted for use in servers and embedded systems such as cell phones. Linux has superseded Unix on many platforms and is used on most supercomputers including the top 385. Many of the same computers are also on Green500
(but in different order), and Linux runs on the top 10. Linux is also
commonly used on other small energy-efficient computers, such as smartphones and smartwatches. The Linux kernel is used in some popular distributions, such as Red Hat, Debian, Ubuntu, Linux Mint and Google's Android, Chrome OS, and Chromium OS.
Microsoft Windows
Microsoft Windows is a family of proprietary operating systems designed by Microsoft Corporation
and primarily targeted to Intel architecture based computers, with an
estimated 88.9 percent total usage share on Web connected computers. The latest version is Windows 10.
In 2011, Windows 7 overtook Windows XP as most common version in use.
Microsoft Windows was first released in 1985, as an operating environment running on top of MS-DOS, which was the standard operating system shipped on most Intel architecture personal computers at the time. In 1995, Windows 95 was released which only used MS-DOS as a bootstrap. For backwards compatibility, Win9x could run real-mode MS-DOS and 16-bit Windows 3.x drivers. Windows ME, released in 2000, was the last version in the Win9x family. Later versions have all been based on the Windows NTkernel. Current client versions of Windows run on IA-32, x86-64 and 32-bit ARMmicroprocessors. In addition Itanium is still supported in older server version Windows Server 2008 R2. In the past, Windows NT supported additional architectures.
Server editions of Windows are widely used. In recent years,
Microsoft has expended significant capital in an effort to promote the
use of Windows as a server operating system.
However, Windows' usage on servers is not as widespread as on personal
computers as Windows competes against Linux and BSD for server market
share.
ReactOS
is a Windows-alternative operating system, which is being developed on
the principles of Windows – without using any of Microsoft's code.
Other
There have been many operating systems that were significant in their day but are no longer so, such as AmigaOS; OS/2 from IBM and Microsoft; classic Mac OS, the non-Unix precursor to Apple's macOS; BeOS; XTS-300; RISC OS; MorphOS; Haiku; BareMetal and FreeMint.
Some are still used in niche markets and continue to be developed as
minority platforms for enthusiast communities and specialist
applications. OpenVMS, formerly from DEC, is still under active development by VMS Software Inc.
Yet other operating systems are used almost exclusively in academia,
for operating systems education or to do research on operating system
concepts. A typical example of a system that fulfills both roles is MINIX, while for example Singularity is used purely for research. Another example is the Oberon System designed at ETH Zürich by Niklaus Wirth, Jürg Gutknecht
and a group of students at the former Computer Systems Institute in the
1980s. It was used mainly for research, teaching, and daily work in
Wirth's group.
Other operating systems have failed to win significant market
share, but have introduced innovations that have influenced mainstream
operating systems, not least Bell Labs' Plan 9.
Components
The components of an operating system all exist in order to make the
different parts of a computer work together. All user software needs to
go through the operating system in order to use any of the hardware,
whether it be as simple as a mouse or keyboard or as complex as an
Internet component.
Kernel
A kernel connects the application software to the hardware of a computer.
With the aid of the firmware and device drivers,
the kernel provides the most basic level of control over all of the
computer's hardware devices. It manages memory access for programs in
the RAM,
it determines which programs get access to which hardware resources, it
sets up or resets the CPU's operating states for optimal operation at
all times, and it organizes the data for long-term non-volatile storage with file systems on such media as disks, tapes, flash memory, etc.
Program execution
The operating system provides an interface between an application
program and the computer hardware, so that an application program can
interact with the hardware only by obeying rules and procedures
programmed into the operating system. The operating system is also a
set of services which simplify development and execution of application
programs. Executing an application program involves the creation of a
process by the operating system kernel
which assigns memory space and other resources, establishes a priority
for the process in multi-tasking systems, loads program binary code into
memory, and initiates execution of the application program which then
interacts with the user and with hardware devices.
Interrupts
Interrupts
are central to operating systems, as they provide an efficient way for
the operating system to interact with and react to its environment. The
alternative – having the operating system "watch" the various sources
of input for events (polling) that require action – can be found in
older systems with very small stacks (50 or 60 bytes) but is unusual in modern systems with large stacks. Interrupt-based
programming is directly supported by most modern CPUs. Interrupts
provide a computer with a way of automatically saving local register
contexts, and running specific code in response to events. Even very
basic computers support hardware interrupts, and allow the programmer to
specify code which may be run when that event takes place.
When an interrupt is received, the computer's hardware
automatically suspends whatever program is currently running, saves its
status, and runs computer code previously associated with the interrupt;
this is analogous to placing a bookmark in a book in response to a
phone call. In modern operating systems, interrupts are handled by the
operating system's kernel. Interrupts may come from either the computer's hardware or the running program.
When a hardware device triggers an interrupt, the operating
system's kernel decides how to deal with this event, generally by
running some processing code. The amount of code being run depends on
the priority of the interrupt (for example: a person usually responds to
a smoke detector alarm before answering the phone). The processing of
hardware interrupts is a task that is usually delegated to software
called a device driver,
which may be part of the operating system's kernel, part of another
program, or both. Device drivers may then relay information to a running
program by various means.
A program may also trigger an interrupt to the operating system.
If a program wishes to access hardware, for example, it may interrupt
the operating system's kernel, which causes control to be passed back to
the kernel. The kernel then processes the request. If a program wishes
additional resources (or wishes to shed resources) such as memory, it
triggers an interrupt to get the kernel's attention.
Modes
Privilege rings for the x86 microprocessor architecture available in protected mode. Operating systems determine which processes run in each mode.
Modern computers support multiple modes of operation. CPUs with this capability offer at least two modes: user mode and supervisor mode.
In general terms, supervisor mode operation allows unrestricted access
to all machine resources, including all MPU instructions. User mode
operation sets limits on instruction use and typically disallows direct
access to machine resources. CPUs might have other modes similar to user
mode as well, such as the virtual modes in order to emulate older
processor types, such as 16-bit processors on a 32-bit one, or 32-bit
processors on a 64-bit one.
At power-on or reset, the system begins in supervisor mode. Once an operating system kernel has been loaded and started, the boundary between user mode and supervisor mode (also known as kernel mode) can be established.
Supervisor mode is used by the kernel for low level tasks that
need unrestricted access to hardware, such as controlling how memory is
accessed, and communicating with devices such as disk drives and video
display devices. User mode, in contrast, is used for almost everything
else. Application programs, such as word processors and database
managers, operate within user mode, and can only access machine
resources by turning control over to the kernel, a process which causes a
switch to supervisor mode. Typically, the transfer of control to the
kernel is achieved by executing a software interrupt instruction, such as the Motorola 68000 TRAP
instruction. The software interrupt causes the processor to switch
from user mode to supervisor mode and begin executing code that allows
the kernel to take control.
In user mode, programs usually have access to a restricted set of
processor instructions, and generally cannot execute any instructions
that could potentially cause disruption to the system's operation. In
supervisor mode, instruction execution restrictions are typically
removed, allowing the kernel unrestricted access to all machine
resources.
The term "user mode resource" generally refers to one or more CPU
registers, which contain information that the running program isn't
allowed to alter. Attempts to alter these resources generally causes a
switch to supervisor mode, where the operating system can deal with the
illegal operation the program was attempting, for example, by forcibly
terminating ("killing") the program.
Memory management
Among other things, a multiprogramming operating system kernel
must be responsible for managing all system memory which is currently
in use by programs. This ensures that a program does not interfere with
memory already in use by another program. Since programs time share,
each program must have independent access to memory.
Cooperative memory management, used by many early operating systems, assumes that all programs make voluntary use of the kernel's
memory manager, and do not exceed their allocated memory. This system
of memory management is almost never seen any more, since programs often
contain bugs which can cause them to exceed their allocated memory. If a
program fails, it may cause memory used by one or more other programs
to be affected or overwritten. Malicious programs or viruses may
purposefully alter another program's memory, or may affect the operation
of the operating system itself. With cooperative memory management, it
takes only one misbehaved program to crash the system.
Memory protection enables the kernel to limit a process' access to the computer's memory. Various methods of memory protection exist, including memory segmentation and paging. All methods require some level of hardware support (such as the 80286 MMU), which doesn't exist in all computers.
In both segmentation and paging, certain protected mode
registers specify to the CPU what memory address it should allow a
running program to access. Attempts to access other addresses trigger an
interrupt which cause the CPU to re-enter supervisor mode, placing the kernel in charge. This is called a segmentation violation
or Seg-V for short, and since it is both difficult to assign a
meaningful result to such an operation, and because it is usually a sign
of a misbehaving program, the kernel generally resorts to terminating the offending program, and reports the error.
Windows versions 3.1 through ME had some level of memory protection, but programs could easily circumvent the need to use it. A general protection fault would be produced, indicating a segmentation violation had occurred; however, the system would often crash anyway.
Virtual memory
Many
operating systems can "trick" programs into using memory scattered
around the hard disk and RAM as if it is one continuous chunk of memory,
called virtual memory.
The use of virtual memory addressing (such as paging or segmentation)
means that the kernel can choose what memory each program may use at
any given time, allowing the operating system to use the same memory
locations for multiple tasks.
If a program tries to access memory that isn't in its current
range of accessible memory, but nonetheless has been allocated to it,
the kernel is interrupted in the same way as it would if the program
were to exceed its allocated memory. (See section on memory management.)
Under UNIX this kind of interrupt is referred to as a page fault.
When the kernel detects a page fault it generally adjusts the
virtual memory range of the program which triggered it, granting it
access to the memory requested. This gives the kernel discretionary
power over where a particular application's memory is stored, or even
whether or not it has actually been allocated yet.
In modern operating systems, memory which is accessed less
frequently can be temporarily stored on disk or other media to make that
space available for use by other programs. This is called swapping,
as an area of memory can be used by multiple programs, and what that
memory area contains can be swapped or exchanged on demand.
"Virtual memory" provides the programmer or the user with the
perception that there is a much larger amount of RAM in the computer
than is really there.
Multitasking
Multitasking
refers to the running of multiple independent computer programs on the
same computer; giving the appearance that it is performing the tasks at
the same time. Since most computers can do at most one or two things at
one time, this is generally done via time-sharing, which means that each
program uses a share of the computer's time to execute.
An operating system kernel contains a scheduling
program which determines how much time each process spends executing,
and in which order execution control should be passed to programs.
Control is passed to a process by the kernel, which allows the program
access to the CPU
and memory. Later, control is returned to the kernel through some
mechanism, so that another program may be allowed to use the CPU. This
so-called passing of control between the kernel and applications is
called a context switch.
An early model which governed the allocation of time to programs was called cooperative multitasking.
In this model, when control is passed to a program by the kernel, it
may execute for as long as it wants before explicitly returning control
to the kernel. This means that a malicious or malfunctioning program may
not only prevent any other programs from using the CPU, but it can hang
the entire system if it enters an infinite loop.
Modern operating systems extend the concepts of application
preemption to device drivers and kernel code, so that the operating
system has preemptive control over internal run-times as well.
The philosophy governing preemptive multitasking
is that of ensuring that all programs are given regular time on the
CPU. This implies that all programs must be limited in how much time
they are allowed to spend on the CPU without being interrupted. To
accomplish this, modern operating system kernels make use of a timed
interrupt. A protected mode
timer is set by the kernel which triggers a return to supervisor mode
after the specified time has elapsed. (See above sections on Interrupts
and Dual Mode Operation.)
On many single user operating systems cooperative multitasking is
perfectly adequate, as home computers generally run a small number of
well tested programs. The AmigaOS is an exception, having preemptive multitasking from its first version. Windows NT was the first version of Microsoft Windows which enforced preemptive multitasking, but it didn't reach the home user market until Windows XP (since Windows NT was targeted at professionals).
Disk access and file systems
File
systems allow users and programs to organize and sort files on a
computer, often through the use of directories (or "folders").
Access to data stored on disks is a central feature of all operating systems. Computers store data on disks using files,
which are structured in specific ways in order to allow for faster
access, higher reliability, and to make better use of the drive's
available space. The specific way in which files are stored on a disk is
called a file system,
and enables files to have names and attributes. It also allows them to
be stored in a hierarchy of directories or folders arranged in a directory tree.
Early operating systems generally supported a single type of disk
drive and only one kind of file system. Early file systems were limited
in their capacity, speed, and in the kinds of file names and directory
structures they could use. These limitations often reflected limitations
in the operating systems they were designed for, making it very
difficult for an operating system to support more than one file system.
While many simpler operating systems support a limited range of options for accessing storage systems, operating systems like UNIX and Linux support a technology known as a virtual file system or VFS. An operating system such as UNIX supports a wide array of storage devices, regardless of their design or file systems, allowing them to be accessed through a common application programming interface
(API). This makes it unnecessary for programs to have any knowledge
about the device they are accessing. A VFS allows the operating system
to provide programs with access to an unlimited number of devices with
an infinite variety of file systems installed on them, through the use
of specific device drivers and file system drivers.
A connected storage device, such as a hard drive, is accessed through a device driver.
The device driver understands the specific language of the drive and is
able to translate that language into a standard language used by the
operating system to access all disk drives. On UNIX, this is the
language of block devices.
When the kernel has an appropriate device driver in place, it can
then access the contents of the disk drive in raw format, which may
contain one or more file systems. A file system driver is used to
translate the commands used to access each specific file system into a
standard set of commands that the operating system can use to talk to
all file systems. Programs can then deal with these file systems on the
basis of filenames, and directories/folders, contained within a
hierarchical structure. They can create, delete, open, and close files,
as well as gather various information about them, including access
permissions, size, free space, and creation and modification dates.
Various differences between file systems make supporting all file systems difficult. Allowed characters in file names, case sensitivity, and the presence of various kinds of file attributes
makes the implementation of a single interface for every file system a
daunting task. Operating systems tend to recommend using (and so support
natively) file systems specifically designed for them; for example, NTFS in Windows and ext3 and ReiserFS
in Linux. However, in practice, third party drivers are usually
available to give support for the most widely used file systems in most
general-purpose operating systems (for example, NTFS is available in
Linux through NTFS-3g, and ext2/3 and ReiserFS are available in Windows through third-party software).
Support for file systems is highly varied among modern operating
systems, although there are several common file systems which almost all
operating systems include support and drivers for. Operating systems
vary on file system support and on the disk formats they may be
installed on. Under Windows, each file system is usually limited in
application to certain media; for example, CDs must use ISO 9660 or UDF, and as of Windows Vista,
NTFS is the only file system which the operating system can be
installed on. It is possible to install Linux onto many types of file
systems. Unlike other operating systems, Linux and UNIX allow any file
system to be used regardless of the media it is stored in, whether it is
a hard drive, a disc (CD, DVD...), a USB flash drive, or even contained
within a file located on another file system.
Device drivers
A device driver
is a specific type of computer software developed to allow interaction
with hardware devices. Typically this constitutes an interface for
communicating with the device, through the specific computer bus or
communications subsystem that the hardware is connected to, providing
commands to and/or receiving data from the device, and on the other end,
the requisite interfaces to the operating system and software
applications. It is a specialized hardware-dependent computer program
which is also operating system specific that enables another program,
typically an operating system or applications software package or
computer program running under the operating system kernel, to interact
transparently with a hardware device, and usually provides the requisite
interrupt handling necessary for any necessary asynchronous
time-dependent hardware interfacing needs.
The key design goal of device drivers is abstraction.
Every model of hardware (even within the same class of device) is
different. Newer models also are released by manufacturers that provide
more reliable or better performance and these newer models are often
controlled differently. Computers and their operating systems cannot be
expected to know how to control every device, both now and in the
future. To solve this problem, operating systems essentially dictate how
every type of device should be controlled. The function of the device
driver is then to translate these operating system mandated function
calls into device specific calls. In theory a new device, which is
controlled in a new manner, should function correctly if a suitable
driver is available. This new driver ensures that the device appears to
operate as usual from the operating system's point of view.
Under versions of Windows before Vista and versions of Linux
before 2.6, all driver execution was co-operative, meaning that if a
driver entered an infinite loop it would freeze the system. More recent
revisions of these operating systems incorporate kernel preemption,
where the kernel interrupts the driver to give it tasks, and then
separates itself from the process until it receives a response from the
device driver, or gives it more tasks to do.
Networking
Currently most operating systems support a variety of networking
protocols, hardware, and applications for using them. This means that
computers running dissimilar operating systems can participate in a
common network for sharing resources such as computing,
files, printers, and scanners using either wired or wireless
connections. Networks can essentially allow a computer's operating
system to access the resources of a remote computer to support the same
functions as it could if those resources were connected directly to the
local computer. This includes everything from simple communication, to
using networked file systems or even sharing another computer's graphics
or sound hardware. Some network services allow the resources of a
computer to be accessed transparently, such as SSH which allows networked users direct access to a computer's command line interface.
Client/server networking allows a program on a computer, called a
client, to connect via a network to another computer, called a server.
Servers offer (or host) various services to other network computers and
users. These services are usually provided through ports or numbered
access points beyond the server's IP address.
Each port number is usually associated with a maximum of one running
program, which is responsible for handling requests to that port. A
daemon, being a user program, can in turn access the local hardware
resources of that computer by passing requests to the operating system
kernel.
Many operating systems support one or more vendor-specific or open networking protocols as well, for example, SNA on IBM systems, DECnet on systems from Digital Equipment Corporation, and Microsoft-specific protocols (SMB) on Windows. Specific protocols for specific tasks may also be supported such as NFS for file access. Protocols like ESound, or esd can be easily extended over the network to provide sound from local applications, on a remote system's sound hardware.
Security
A computer being secure depends on a number of technologies working
properly. A modern operating system provides access to a number of
resources, which are available to software running on the system, and to
external devices like networks via the kernel.
The operating system must be capable of distinguishing between
requests which should be allowed to be processed, and others which
should not be processed. While some systems may simply distinguish
between "privileged" and "non-privileged", systems commonly have a form
of requester identity, such as a user name. To establish identity there may be a process of authentication.
Often a username must be quoted, and each username may have a password.
Other methods of authentication, such as magnetic cards or biometric
data, might be used instead. In some cases, especially connections from
the network, resources may be accessed with no authentication at all
(such as reading files over a network share). Also covered by the
concept of requester identity is authorization; the
particular services and resources accessible by the requester once
logged into a system are tied to either the requester's user account or
to the variously configured groups of users to which the requester
belongs.
In addition to the allow or disallow model of security, a system
with a high level of security also offers auditing options. These would
allow tracking of requests for access to resources (such as, "who has
been reading this file?"). Internal security, or security from an
already running program is only possible if all possibly harmful
requests must be carried out through interrupts to the operating system
kernel. If programs can directly access hardware and resources, they
cannot be secured.
External security involves a request from outside the computer,
such as a login at a connected console or some kind of network
connection. External requests are often passed through device drivers to
the operating system's kernel, where they can be passed onto
applications, or carried out directly. Security of operating systems has
long been a concern because of highly sensitive data held on computers,
both of a commercial and military nature. The United States GovernmentDepartment of Defense (DoD) created the Trusted Computer System Evaluation Criteria
(TCSEC) which is a standard that sets basic requirements for assessing
the effectiveness of security. This became of vital importance to
operating system makers, because the TCSEC was used to evaluate,
classify and select trusted operating systems being considered for the processing, storage and retrieval of sensitive or classified information.
Network services include offerings such as file sharing, print services, email, web sites, and file transfer protocols (FTP), most of which can have compromised security. At the front line of security are hardware devices known as firewalls
or intrusion detection/prevention systems. At the operating system
level, there are a number of software firewalls available, as well as
intrusion detection/prevention systems. Most modern operating systems
include a software firewall, which is enabled by default. A software
firewall can be configured to allow or deny network traffic to or from a
service or application running on the operating system. Therefore, one
can install and be running an insecure service, such as Telnet or FTP,
and not have to be threatened by a security breach because the firewall
would deny all traffic trying to connect to the service on that port.
An alternative strategy, and the only sandbox strategy available in systems that do not meet the Popek and Goldberg virtualization requirements, is where the operating system is not running user programs as native code, but instead either emulates a processor or provides a host for a p-code based system such as Java.
Internal security is especially relevant for multi-user systems;
it allows each user of the system to have private files that the other
users cannot tamper with or read. Internal security is also vital if
auditing is to be of any use, since a program can potentially bypass the
operating system, inclusive of bypassing auditing.
User interface
A screenshot of the Bash
command line. Each command is typed out after the 'prompt', and then
its output appears below, working its way down the screen. The current
command prompt is at the bottom.
A screenshot of the KDE Plasma 5
graphical user interface. Programs take the form of images on the
screen, and the files, folders (directories), and applications take the
form of icons and symbols. A mouse is used to navigate the computer.
Most of the modern computer systems support graphical user interfaces (GUI), and often include them. In some computer systems, such as the original implementation of the classic Mac OS, the GUI is integrated into the kernel.
While technically a graphical user interface is not an operating
system service, incorporating support for one into the operating system
kernel can allow the GUI to be more responsive by reducing the number of
context switches required for the GUI to perform its output functions. Other operating systems are modular,
separating the graphics subsystem from the kernel and the Operating
System. In the 1980s UNIX, VMS and many others had operating systems
that were built this way. Linux and macOS are also built this way.
Modern releases of Microsoft Windows such as Windows Vista implement a graphics subsystem that is mostly in user-space; however the graphics drawing routines of versions between Windows NT 4.0 and Windows Server 2003 exist mostly in kernel space. Windows 9x had very little distinction between the interface and the kernel.
Many computer operating systems allow the user to install or create any user interface they desire. The X Window System in conjunction with GNOME or KDE Plasma 5 is a commonly found setup on most Unix and Unix-like (BSD, Linux, Solaris) systems. A number of Windows shell replacements have been released for Microsoft Windows, which offer alternatives to the included Windows shell, but the shell itself cannot be separated from Windows.
Numerous Unix-based GUIs have existed over time, most derived
from X11. Competition among the various vendors of Unix (HP, IBM, Sun)
led to much fragmentation, though an effort to standardize in the 1990s
to COSE and CDE failed for various reasons, and were eventually eclipsed by the widespread adoption of GNOME and K Desktop Environment. Prior to free software-based
toolkits and desktop environments, Motif was the prevalent
toolkit/desktop combination (and was the basis upon which CDE was
developed).
Graphical user interfaces evolve over time. For example, Windows
has modified its user interface almost every time a new major version of
Windows is released, and the Mac OS GUI changed dramatically with the
introduction of Mac OS X in 1999.
Real-time operating systems
A real-time operating system (RTOS) is an operating system intended for applications with fixed deadlines (real-time computing). Such applications include some small embedded systems, automobile engine controllers, industrial robots, spacecraft, industrial control, and some large-scale computing systems.
Some embedded systems use operating systems such as Palm OS, BSD, and Linux, although such operating systems do not support real-time computing.
Operating system development as a hobby
A hobby operating system may be classified as one whose code has not
been directly derived from an existing operating system, and has few
users and active developers.
In some cases, hobby development is in support of a "homebrew" computing device, for example, a simple single-board computer powered by a 6502 microprocessor.
Or, development may be for an architecture already in widespread use.
Operating system development may come from entirely new concepts, or
may commence by modeling an existing operating system. In either case,
the hobbyist is his/her own developer, or may interact with a small and
sometimes unstructured group of individuals who have like interests.
Examples of a hobby operating system include Syllable and TempleOS.
Diversity of operating systems and portability
Application software is generally written for use on a specific operating system, and sometimes even for specific hardware.
When porting the application to run on another OS, the functionality
required by that application may be implemented differently by that OS
(the names of functions, meaning of arguments, etc.) requiring the
application to be adapted, changed, or otherwise maintained.
Unix was the first operating system not written in assembly language, making it very portable to systems different from its native PDP-11.
This cost in supporting operating systems diversity can be avoided by instead writing applications against software platforms such as Java or Qt. These abstractions have already borne the cost of adaptation to specific operating systems and their system libraries.
Another approach is for operating system vendors to adopt standards. For example, POSIX and OS abstraction layers provide commonalities that reduce porting costs.
_and_Dennis_Ritchie_at_PDP-11_(2876612463).jpg)
.png)
