Table of contents of the article:
What is Portable Operating System Interface (POSIX)?
POSIX (Portable Operating System Interface) is a set of standard operating system interfaces based on the operating system Unix . The most recent POSIX specification – IEEE Std 1003.1-2017 – defines a standard interface and environment that can be used by an operating system ( OS ) to provide access to POSIX-compliant applications. The standard also defines a command interpreter ( shell ) and common utility programs. POSIX supports the pPortability of applications at the source code level so that applications can be built to run on any POSIX-compliant operating system.
A brief history of the POSIX standard
POSIX interfaces were originally developed under the auspices of IEEE . However, the POSIX standard is now under development and maintenance by the Austin Common Standards Revision Group, commonly referred to as Austin Group .
The Austin Group is a joint working group composed of members of the IEEE, the Open Group and the Joint Technical Committee 1 of the International Organization for Standardization ( ISO ) and of the International Electrotechnical Commission (IEC). IEEE owns the POSIX trademark. The Open Group, owner of the Unix trademark, is a global consortium that develops technology standards.
POSIX was born out of a need to make applications more portable across different systems. In the early days of computing, programmers had to rewrite their applications for every model of computer and operating system. This began to change when IBM introduced its System/360 line of computers, all of which could run the same operating system, OS/360. With these new systems, applications could be made more portable, saving huge amounts of development time.
When UNIX was born, around the same time, it also showed promise in that it could run on machines from different manufacturers. However, as UNIX started making different versions, porting code across these UNIX variants became difficult. The promise of UNIX portability was losing ground.
To solve this portability problem, POSIX was formed in the 80s. The standard was based on AT&T's System V UNIX and BSD UNIX, the two largest variants at the time. It is important to note that POSIX was not formed to control the way operating systems were built: any company was free to design its own UNIX variant however they liked. POSIX was only concerned with how an application interfaces with the operating system. In programmer language, an interface is the method by which one program's code can communicate with another program. The interface expects Program A to provide a specific type of information to Program B. Likewise, Program A expects Program B to respond with a specific type of data.
What is the POSIX standard?
In a word: portability.
Over 60 years ago, programmers had to completely rewrite code if they wanted their software to work on more than one system. This didn't happen very often due to the expense involved, but portability became a feature in the mid-60s, not via POSIX, but in the mainframe arena.
Over the years, the POSIX specification has continued to be revised and retooled. At one time, each standard was informally called POSIX, followed by a decimal and then the standard number. For example, POSIX.1 was the standard for an application programming interface in the language C and POSIX.2 was the standard shell and utility interface for the operating system. These standards have been officially referred to as IEEE Std 1003.1 and IEEE Std 1003.2, respectively.
There have also been amendments to the core standard, such as IEEE Std 1003.1b-1993, which dealt with real-time extensions. However, all the various specifications have been merged into one standard, IEEE Std 1003.1 , which was last updated in 2017 and released in 2018. Officially, it's called IEEE Std 1003.1-2017. However, it is also referred to as POSIX.1-2017 or, more informally, POSIX.1.
The POSIX standard has other names as well. The Open Group calls it The Open Group Base Specifications Issue 7, 2018 edition, and ISO/IEC calls it ISO/IEC 9945:2009. ISO/IEC adopted the standard in 2009 and added Technical Corrigendum 1 in late 2012 and Technical Corrigendum 2 in March 2017, putting it on par with IEEE Std 1003.1-2017.
The POSIX.1-2017 specification defines the core services needed to build POSIX-compliant applications. They establish standard semantics and syntax to help developers write portable applications. POSIX.1 consists of the following four volumes:
- Basic definitions. Provides common definitions for the specification, including terms, concepts, syntax, service functions, and command line information
- System interfaces. Provides details on interface terms and concepts and defines the functional interfaces available to applications that access POSIX-compliant systems.
- Shells and utilities. Describes the commands and utilities available to applications that access POSIX-compliant systems, including the command language used on those systems.
- Rationale. Includes historical information about the contents of the standard and why some features were added or removed.
POSIX.1 takes a “write once, adopt everywhere” approach to the specification by providing a number of core services needed to build applications efficiently. The standard emphasizes structures and features that are important to application development, rather than focusing on the techniques needed to achieve these capabilities. The POSIX standard is designed to be used by both system integrators, systems engineers and application developers.
The POSIX standard allows developers to build applications, tools and platforms on many operating systems using much of the same code. It's not a requirement at all to write code to the standard, but it helps, in a big way, when you want to port your code to other systems.
Basically, POSIX is geared towards OS designers and software developers, but as users of a system, we are influenced by POSIX whether we realize it or not. It's because of the standard that we're able to work on a UNIX or Linux system and take that work to another system and work on it without a hitch. As users, we gain numerous benefits in terms of usability and data reuse between systems.