POSIX.1

= = =[|A Backgrounder on IEEE Std 1003.1, 2003 Edition]=

//This paper is derived from the Preface to the standard and provides information on the background, audience and purpose of this version of IEEE Std 1003.1.//

The 2003 Edition of IEEE Std 1003.1 (known as "POSIX.1") has been jointly developed by the IEEE and The Open Group. It is simultaneously an IEEE Standard, an ISO/IEC Standard, and an Open Group Technical Standard.

Background
The developers of this standard represent a cross section of hardware manufacturers, vendors of operating systems and other software development tools, software designers, consultants, academics, authors, applications programmers, and others. Conceptually, this standard describes a set of fundamental services needed for the efficient construction of application programs. Access to these services has been provided by defining an interface, using the C programming language, a command interpreter, and common utility programs that establish standard semantics and syntax. Since this interface enables application writers to write portable applications-it was developed with that goal in mind-it has been designated POSIX,[| 1] an acronym for Portable Operating System Interface.

Although originated to refer to the original IEEE Std 1003.1-1988, the name POSIX more correctly refers to a //family// of related standards: IEEE Std 1003.//n// and the parts of ISO/IEC 9945. In earlier editions of the IEEE standard, the term POSIX was used as a synonym for IEEE Std 1003.1-1988. A preferred term, POSIX.1, emerged. This maintained the advantages of readability of the symbol ``POSIX'' without being ambiguous with the POSIX family of standards.

Audience
The intended audience for this standard is all persons concerned with an industry-wide standard operating system based on the UNIX system. This includes at least four groups of people:
 * 1) Persons buying hardware and software systems
 * 2) Persons managing companies that are deciding on future corporate computing directions
 * 3) Persons implementing operating systems, and especially
 * 4) Persons developing applications where portability is an objective

Purpose
Several principles guided the development of this standard: > The basic goal was to promote portability of application programs across UNIX system environments by developing a clear, consistent, and unambiguous standard for the interface specification of a portable operating system based on the UNIX system documentation. This standard codifies the common, existing definition of the UNIX system. > This standard defines an interface, not an implementation. No distinction is made between library functions and system calls; both are referred to as functions. No details of the implementation of any function are given (although historical practice is sometimes indicated in the RATIONALE section). Symbolic names are given for constants (such as signals and error numbers) rather than numbers. > This standard has been written so that a program written and translated for execution on one conforming implementation may also be translated for execution on another conforming implementation. This standard does not guarantee that executable (object or binary) code will execute under a different conforming implementation than that for which it was translated, even if the underlying hardware is identical. > The system interfaces and header definitions are written in terms of the standard C language as specified in the ISO C standard. > There was no intention to specify all aspects of an operating system. System administration facilities and functions are excluded from this standard, and functions usable only by the superuser have not been included. Still, an implementation of the standard interface may also implement features not in this standard. This standard is also not concerned with hardware constraints or system maintenance. > In keeping with the historical design principles of the UNIX system, the mandatory core facilities of this standard have been kept as minimal as possible. Additional capabilities have been added as optional extensions. > The developers of this standard endeavored to make all specified functions implementable across a wide range of existing and potential systems, including: > No direct references to this goal appear in this standard, but some results of it are mentioned in the Rationale (Informative) volume. > When the original version of IEEE Std 1003.1 was published, there were no known historical implementations that did not have to change. However, there was a broad consensus on a set of functions, types, definitions, and concepts that formed an interface that was common to most historical implementations. > The adoption of the 1988 and 1990 IEEE system interface standards, the 1992 IEEE shell and utilities standard, the various Open Group (formerly X/Open) specifications, and the subsequent revisions and addenda to all of them have consolidated this consensus, and this revision reflects the significantly increased level of consensus arrived at since the original versions. The earlier standards and their modifications specified a number of areas where consensus had not been reached before, and these are now reflected in this revision. The authors of the original versions tried, as much as possible, to follow the principles below when creating new specifications: > This revision tries to minimize the number of changes required to implementations which conform to the earlier versions of the approved standards to bring them into conformance with the current standard. Specifically, the scope of this work excluded doing any ``new'' work, but rather collecting into a single document what had been spread across a number of documents, and presenting it in what had been proven in practice to be a more effective way. Some changes to prior conforming implementations were unavoidable, primarily as a consequence of resolving conflicts found in prior revisions, or which became apparent when bringing the various pieces together. > However, since it references the 1999 version of the ISO C standard, and no longer supports ``Common Usage C'', there are a number of unavoidable changes. Applications portability is similarly affected. > This standard is specifically not a codification of a particular vendor's product. > It should be noted that implementations will have different kinds of extensions. Some will reflect ``historical usage'' and will be preserved for execution of pre-existing applications. These functions should be considered ``obsolescent'' and the standard functions used for new applications. Some extensions will represent functions beyond the scope of this standard. These need to be used with careful management to be able to adapt to future extensions of this standard and/or port to implementations that provide these services in a different manner. > A goal of this standard was to minimize additional work for the developers of applications. However, because every known historical implementation will have to change at least slightly to conform, some applications will have to change.
 * Application-Oriented
 * Interface, Not Implementation
 * Source, Not Object, Portability
 * The C Language
 * No Superuser, No System Administration
 * Minimal Interface, Minimally Defined
 * Broadly Implementable
 * 1) All of the current major systems that are ultimately derived from the original UNIX system code (Version 7 or later)
 * 2) Compatible systems that are not derived from the original UNIX system code
 * 3) Emulations hosted on entirely different operating systems
 * 4) Networked systems
 * 5) Distributed systems
 * 6) Systems running on a broad range of hardware
 * Minimal Changes to Historical Implementations
 * 1) By standardizing an interface like one in an historical implementation; for example, directories
 * 2) By specifying an interface that is readily implementable in terms of, and backwards-compatible with, historical implementations, such as the extended //tar// format defined in the //pax// utility
 * 3) By specifying an interface that, when added to an historical implementation, will not conflict with it; for example, the //sigaction// function
 * Minimal Changes to Existing Application Code