# System programming language

> Mediated Wiki article. Canonical URL: https://mediated.wiki/source/System_programming_language
> Markdown URL: https://mediated.wiki/source/System_programming_language.md
> Source: https://en.wikipedia.org/wiki/System_programming_language
> Source revision: 1334112948
> License: Creative Commons Attribution-ShareAlike 4.0 International (https://creativecommons.org/licenses/by-sa/4.0/)

Class of computer programming languages

For the HP language of the same name, see [Systems Programming Language](/source/Systems_Programming_Language).

This article needs more citations. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "System programming language" – news · newspapers · books · scholar · JSTOR (April 2022) (Learn how and when to remove this message)

A **system programming language** is a [programming language](/source/Programming_language) used for [system programming](/source/System_programming); such languages are designed for writing [system software](/source/System_software), which usually requires different development approaches when compared with application software. [Edsger Dijkstra](/source/Edsger_W._Dijkstra) referred to these languages as **machine oriented high order languages**, or **mohol**.[1]

[General-purpose programming languages](/source/General-purpose_programming_language) tend to focus on generic features to allow programs written in the language to use the same code on different [computing platforms](/source/Computing_platform). Examples of such languages include [ALGOL](/source/ALGOL) and [Pascal](/source/Pascal_(programming_language)). This generic quality typically comes at the cost of denying direct access to the machine's internal workings, and this often has negative effects on performance.

System languages, in contrast, are designed not for compatibility, but for performance and ease of access to the underlying [computer hardware](/source/Computer_hardware) while still providing [high-level programming](/source/High-level_programming_language) concepts like [structured programming](/source/Structured_programming). Examples include [Executive Systems Problem Oriented Language](/source/Executive_Systems_Problem_Oriented_Language) (ESPOL) and [Systems Programming Language](/source/Systems_Programming_Language) (SPL), both of which are ALGOL-like in [syntax](/source/Syntax_(programming_languages)) but tuned to their respective platforms. Others are [cross-platform software](/source/Cross-platform_software), but designed to work close to the hardware, like [BLISS](/source/BLISS), [JOVIAL](/source/JOVIAL), and [BCPL](/source/BCPL).

Some languages straddle the system and application domains, bridging the gap between these uses. The canonical example is [C](/source/C_(programming_language)), which is used widely for both system and application programming. [PL/I](/source/PL%2FI) was an early example. Some modern languages also do this such as [Rust](/source/Rust_(programming_language)) and [Swift](/source/Swift_(programming_language)).

## Features

In contrast with application languages, system programming languages typically offer more-direct access to the physical hardware of the machine: an archetypical system programming language in this sense was [BCPL](/source/BCPL). System programming languages often lack built-in [input/output](/source/Input%2Foutput) (I/O) facilities because a system-software project usually develops its own I/O mechanisms or builds on basic monitor I/O or screen management facilities. The distinction between languages used for system programming and application programming became blurred over time with the widespread popularity of [PL/I](/source/PL%2FI), [C](/source/C_(programming_language)) and [Pascal](/source/Pascal_(programming_language)).

## History

The earliest system software was written in [assembly language](/source/Assembly_language) mostly because no alternative existed, but also for reasons including efficiency of [object code](/source/Object_code), [compiling](/source/Compiler) time, and ease of debugging. Application languages such as [FORTRAN](/source/FORTRAN) were used for system programming, although they usually still required some routines to be written in assembly language.[2]

### Mid-level languages

Mid-level languages "have much of the [syntax](/source/Syntax_(programming_languages)) and facilities of a higher level language, but also provide direct access in the language (and often an assembly language) to machine features."[2] The earliest of these was [ESPOL](/source/Executive_Systems_Problem_Oriented_Language) on Burroughs mainframes in about 1960, followed by [Niklaus Wirth](/source/Niklaus_Wirth)'s [PL360](/source/PL360) (first written on a Burroughs system as a [cross compiler](/source/Cross_compiler)), which had the general syntax of [ALGOL 60](/source/ALGOL_60) but whose statements directly manipulated CPU registers and memory. Other languages in this category include [MOL-360](/source/MOL-360) and [PL/S](/source/PL%2FS).

As an example, a typical PL360 statement is R9 := R8 and R7 shll 8 or R6, signifying that registers 8 and 7 should be and'ed together, the result shifted left 8 bits, the result of that or'ed with the contents of register 6, and the final result placed into register 9.[3]

### Higher-level languages

While PL360 is at the semantic level of assembly language, another kind of system programming language operates at a higher semantic level, but has specific extensions designed to make the language suitable for system programming. An early example of this kind of language is LRLTRAN,[4] which extended Fortran with features for character and bit manipulation, pointers, and directly addressed jump tables.

Subsequently, languages such as C were developed, where the combination of features was sufficient to write system software, and a [compiler](/source/Compiler) could be developed that generated efficient object programs on modest hardware. Such a language generally omits features that cannot be implemented efficiently, and adds a small number of machine-dependent features needed to access specific hardware abilities; [inline assembly](/source/Inline_assembly) code, such as C's asm statement, is often used for this purpose. Although many such languages were developed,[1] C and [C++](/source/C%2B%2B) are the ones which survived.

## Major languages

Language Originator Birth date Influenced by Used for JOVIAL System Development Corporation 1960 ALGOL 58 Many systems, mostly military ESPOL Burroughs Corporation 1961 ALGOL 60 MCP PL/I IBM, SHARE 1964 ALGOL, FORTRAN, some COBOL Multics, Stratus VOS. Dialects used in PRIMOS, IBM CPF, IBM OS/400. PL/S IBM 1960s PL/I OS/360 and successors Edinburgh IMP University of Edinburgh 1966 ALGOL 60, Atlas Autocode Edinburgh Multiple Access System BCPL Martin Richards 1967 CPL Xerox Alto Executive, TRIPOS PL360 Niklaus Wirth 1968 ALGOL 60 ALGOL W Pascal Niklaus Wirth 1970 ALGOL W Apollo AEGIS, MacApp, UCSD p-System, VAXELN, Lisa OS, PERQ OS BLISS Carnegie Mellon University 1970 ALGOL, PL/I[5] OpenVMS (portions), Hydra Language for Systems Development (LSD or LSyD) R. Daniel Bergeron, et al. (Brown University) 1971 PL/I C Dennis Ritchie 1972 BCPL, B Many operating system kernels, including most Unix-like systems; SQLite System Programming Language (SPL) Hewlett-Packard 1972 ALGOL 60, ESPOL HP 3000 system software, including MPE PL/M Gary Kildall 1973 PL/I, XPL CP/M, ISIS, iRMX NEWP Burroughs 1970s ESPOL, ALGOL MCP PL.8 IBM 1970s PL/I compiler development, AIX (versions 1 and 2 only), IBM mainframe firmware PL-6 Honeywell, Inc. 1970s PL/I CP-6 SYMPL CDC 1970s JOVIAL NOS subsystems, most compilers, FSE editor Transaction Application Language (TAL) Tandem Computers 1970s SPL, C, Pascal NonStop OS Mesa Xerox PARC 1976 Pascal, ALGOL 68 Pilot, GlobalView Modula-2 Niklaus Wirth 1978 Pascal, Mesa Medos-2, portions of IBM OS/400 and PRIMOS. Modula-2+ variant used in ARX, Topaz. C++ Bjarne Stroustrup 1979 C, Simula BeOS, Haiku, Serenity OS, Symbian. Portions of IBM i, macOS, Microsoft Windows. S3 ICL 1980s ALGOL 68 ICL VME Ada Jean Ichbiah, S. Tucker Taft 1983 ALGOL 68, Pascal, C++, Eiffel Military,[6] aerospace[7] mass transportation,[citation needed] high-integrity computation, operating system kernels,[8][9][10] iMAX 432, BiiN/OS Oberon Niklaus Wirth 1987 Modula-2 Oberon System Modula-3 DEC SRC, Olivetti 1988 Modula-2+ SPIN D Digital Mars 2001 C++ Nim Andreas Rumpf 2008 Python, Ada, Lisp, Oberon, C++, Modula-3, Object Pascal Go Google 2009 Oberon, C, Pascal Kubernetes, Docker Rust Mozilla Research[11] 2010 C++, Haskell, Erlang, Ruby Servo, RedoxOS. Portions of the Linux kernel and of Microsoft Windows. Swift Apple Inc. 2014 C, Objective-C, D, Rust macOS, iOS, watchOS, and tvOS app development [a] Zig Andrew Kelley 2016 C, C++, LLVM IR, Go, Rust Bun, TigerBeetle, Mach engine,[12] Ghostty Mojo Modular Inc.[13] 2023 C, C++, Python, Rust, Swift, Zig

## See also

- [Computer programming portal](https://en.wikipedia.org/wiki/Portal:Computer_programming)

- [Ousterhout's dichotomy](/source/Ousterhout's_dichotomy)

- [PreScheme](/source/PreScheme)

## Notes

1. **[^](#cite_ref-12)** Swift uses [Automatic Reference Counting](/source/Automatic_Reference_Counting)

## References

1. ^ [***a***](#cite_ref-MOHLconfer_1-0) [***b***](#cite_ref-MOHLconfer_1-1) van der Poel, W. L.; Maarssen, L. A., eds. (27–31 August 1973). *Machine oriented higher level languages*. IFIP Working Conference on Machine Oriented Higher Level Languages (MOHL). Trondheim, Norway: International Federation for Information Processing. Proceedings published 1974.

1. ^ [***a***](#cite_ref-Sammet_2-0) [***b***](#cite_ref-Sammet_2-1) Sammet, Jean (October 1971). ["Brief Survey of Languages Used for Systems Implementation"](https://doi.org/10.1145%2F942596.807055). *ACM SIGPLAN Notices*. **6** (9): 1–19. [doi](/source/Doi_(identifier)):[10.1145/942596.807055](https://doi.org/10.1145%2F942596.807055).

1. **[^](#cite_ref-3)** [Wirth, Niklaus](/source/Niklaus_Wirth) (1968). "PL360, A Programming Language for the 360 Computers". *Journal of the ACM*. **15** (1): 37–74. [doi](/source/Doi_(identifier)):[10.1145/321439.321442](https://doi.org/10.1145%2F321439.321442).

1. **[^](#cite_ref-4)** Mendicino, Sam F.; Hughes, Robert A.; Martin, Jeanne T.; McMahon, Frank H.; Ranelletti, John E.; Zwakenberg, Richard G. (1968). "The LRLTRAN Compiler". *Communications of the ACM*. **11** (11): 747–755. [doi](/source/Doi_(identifier)):[10.1145/364139.364154](https://doi.org/10.1145%2F364139.364154).

1. **[^](#cite_ref-5)** Wulf, W. A.; Russell, D. B.; Haberman, A. N. (December 1971). "BLISS: A Language for Systems Programming". *Communications of the ACM*. **14** (12): 780–790. [CiteSeerX](/source/CiteSeerX_(identifier)) [10.1.1.691.9765](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.691.9765). [doi](/source/Doi_(identifier)):[10.1145/362919.362936](https://doi.org/10.1145%2F362919.362936).

1. **[^](#cite_ref-6)** ["Case Study, BAE Systems Eurofighter Typhoon"](https://www.adacore.com/uploads/customers/CaseStudy_Eurofighter.pdf) (PDF).

1. **[^](#cite_ref-7)** ["What programming languages are used for equipment onboard aircraft?"](https://aviation.stackexchange.com/questions/3608/what-programming-languages-are-used-for-equipment-onboard-aircraft#15486).

1. **[^](#cite_ref-8)** ["Ironclad"](https://ironclad.nongnu.org/).

1. **[^](#cite_ref-9)** ["M2OS. RTOS with simple tasking support for small microcontrollers"](https://m2os.unican.es/).

1. **[^](#cite_ref-10)** ["Jgrivera67/HiRTOS"](https://github.com/jgrivera67/HiRTOS). *[GitHub](/source/GitHub)*.

1. **[^](#cite_ref-11)** ["Mozilla Research Projects"](https://web.archive.org/web/20140104070627/https://www.mozilla.org/en-US/research/projects/). Archived from [the original](https://www.mozilla.org/en-US/research/projects/) on 2014-01-04.

1. **[^](#cite_ref-13)** ["Mach: Zig game engine & graphics toolkit"](https://machengine.org).

1. **[^](#cite_ref-14)** ["Modular Inc."](https://www.modular.com/) *www.modular.com*. Retrieved 2024-03-25.

## External links

- Corbató, Fernando (1969-05-06). ["PL/I as a Tool for System Programming"](https://web.archive.org/web/20120921035455/http://home.roadrunner.com/~pflass/PLI/plisprg.html). *Datamation*: 68–76. Archived from [the original](http://home.roadrunner.com/~pflass/PLI/plisprg.html) on 2012-09-21. Retrieved 2012-01-23.

v t e Programming paradigms Imperative Structured Jackson structures Block-structured Modular Non-structured Procedural Programming in the large and in the small Design by contract Invariant-based Nested function Object-oriented Class-based, Prototype-based, Object-based Agent Immutable object Persistent Uniform function call syntax Declarative Functional Recursive Anonymous function (Partial application) Higher-order Purely functional Total Strict GADTs Dependent types Functional logic Point-free style Expression-oriented Applicative, Concatenative Function-level, Value-level Monad Dataflow Flow-based Reactive (Functional reactive) Signals Streams Synchronous Logic Abductive logic Answer set Constraint (Constraint logic) Inductive logic Nondeterministic Ontology Probabilistic logic Query Domain- specific language (DSL) Algebraic modeling Array Automata-based (Action) Command (Spacecraft) Differentiable End-user Grammar-oriented Interface description Language-oriented List comprehension Low-code Modeling Natural language Non-English-based Page description Pipes and filters Probabilistic Quantum Scientific Scripting Set-theoretic Simulation Stack-based System Tactile Templating Transformation (Graph rewriting, Production, Pattern) Visual Concurrent, parallel Actor-based Automatic mutual exclusion Choreographic programming Concurrent logic (Concurrent constraint logic) Concurrent OO Macroprogramming Multitier programming Organic computing Parallel programming models Partitioned global address space Process-oriented Relativistic programming Service-oriented Structured concurrency Metaprogramming Attribute-oriented Automatic (Inductive) Dynamic Extensible Generic Homoiconicity Interactive Macro (Hygienic) Metalinguistic abstraction Multi-stage Program synthesis (Bayesian, by demonstration, by example, vibe coding) Reflective Self-modifying code Symbolic Template Separation of concerns Aspects Components Data-driven Data-oriented Event-driven Features Literate Roles Subjects Comparisons/Lists Comparison (multi-paradigm, object-oriented, functional), List (OO, by type)

---
Adapted from the Wikipedia article [System programming language](https://en.wikipedia.org/wiki/System_programming_language) by Wikipedia contributors ([contributor history](https://en.wikipedia.org/wiki/System_programming_language?action=history)). Available under [Creative Commons Attribution-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-sa/4.0/). Changes may have been made.