← all systems · see it in The System
Programming language
A programming language is an engineered language for expressing computer programs, typically allowing software to be written in a human readable manner. The practice (the people who design, implement and write in languages) and the structure (syntax, semantics, implementations) are both walked here. The 'engineered language' wording is disputed in the encyclopedia itself (C-1415).
Properties published scienceour proposal
Sourced fields, and our own readings.
| born at | 1940s (first programmable computers and their languages); first compiler for a high-level language 1951 (Boehm); A-0 compiler May 1952; Fortran 1956-1957 |
| born precision | decade |
| boundary | Inside: the language's definition (syntax, static and dynamic semantics, the specification), its implementations (compilers, interpreters, just-in-time compilers, run-time systems with their garbage collectors), its standard library, and the practice of the people who design it, implement it and write in it (programmers, maintainers, proposal authors). Outside: the hardware and operating system the programs run on, the programs and software written in it (software runs on it), other languages (partners and ancestors), the mathematics it borrows (lambda calculus, type theory), natural language, models that generate code, and attackers. Where 'programming language' ends and 'computer language' or 'formal specification language' begins is disputed (C-1415). |
| nested level | Built from its definition, implementations, library and practitioners; sits as software's L5 ('the program in a programming language') and as one carrier of algorithms (algorithm L3); carries programs and software that run on it. |
| scale | technological |
Measures (27) published science
| characteristic clock: feature release (Python) | 12 months |
| development time of one feature version (Python) | about 17 months |
| releases before a deprecated feature is removed (Python) | at least 2 releases |
| characteristic clock: garbage-collection reclamation cycle (LISP on the IBM 704) | several seconds |
| interpreter slowdown against a compiled executable | 10 to 100 times slower |
| average energy per benchmark solution: compiled languages | 120 J |
| average energy per benchmark solution: virtual-machine languages | 576 J |
| average energy per benchmark solution: interpreted languages | 2365 J |
| normalized energy, Python against C (27 languages, global results) | 75.88 (C = 1.00) ratio |
| per-hand-off efficiency, compiled against interpreted (energy) | about 0.05 (120 J / 2365 J) ratio |
| memory a garbage collector needs to match explicit management | 5 times |
| share of security vulnerabilities caused by memory-safety issues (Microsoft, 2019) | 70 percent |
| share of severe Chromium security bugs caused by memory-safety problems (Google, 2020) | 70 percent |
| Rust memory-safety bug reports studied (all CVEs to 2020-12-31) | 186 reports |
| integer-overflow locations in SPEC CINT2000 | over 200 distinct locations |
| Codex training corpus: public repositories | 54 million repositories |
| Codex training corpus: Python files | 179 GB |
| Codex pass rate on HumanEval, one sample | 28.8 percent |
| Codex pass rate on HumanEval, 100 samples | 70.2 percent |
| variance in Python learning explained by language aptitude | 17 percent |
| variance in Python learning explained by fluid reasoning and working memory | 34 percent |
| experience of expert programmers in the code-logic fMRI study | average 11 years |
| Rosetta Code solution programs compared | 7,087 programs, 745 tasks, 8 languages count |
| languages with a significant defect association after reanalysis | 4 of 11 languages |
| projects and programmers in the adoption study | over 200,000 SourceForge projects; 590,000 Ohloh projects; surveys of 1,000-13,000 programmers count |
| programming languages used by one software project | five or more (commonly) languages |
| first self-hosting compiler of a widely used language (LISP) | 1962 year |
Open contentions (5) open contention
Where sources or readings disagree. Both stay on the map.
- C-736 When a system first throws away its excess energy and later learns to store it for reuse, is that one process that grew or two separate ones?
booked: The map keeps both readings side by side and rules neither. A few examples fit the 'one process that grew' reading, but it hasn't been tested.
the other reading: the toll and its stashing are two different Functions - C-1122 Does reading computer code use the brain's language areas?
booked: The map follows the findings that reading code engages reasoning networks rather than the language network, and keeps earlier contrary results alongside.
the other reading: earlier studies cited by Ivanova found left-lateralized activity roughly in language regions - C-1410 Do some programming languages lead to more bugs?
booked: The map follows the reanalysis finding small or no effects, and keeps the original claim alongside.
the other reading: Ray et al. (as Berger et al. report it): some languages have a greater association with defects; functional languages fewer; Nanz and Furia 2015: compiled strongly typed languages are less prone to runtime failures than interpreted or weakly typed ones - C-1415 What exactly is a programming language?
booked: The map uses the encyclopedia's definition and keeps the dispute over its wording, and the wider readings, alongside.
the other reading: the 'engineered language' wording is tagged disputed on the encyclopedia page (October 2026); programming languages are a subset of computer languages, or the two are different concepts; Reynolds: a formal specification language, and even input formats that affect a computer's behaviour, are programming languages too, though not Turing-complete - C-1418 Is learning to program more like learning a language or like problem-solving?
booked: The map keeps both: language aptitude predicts learning speed, while reading code runs on the brain's problem-solving networks.
the other reading: learning to program resembles second natural-language learning in adulthood (Prat et al.); code is a cultural symbol system closer to formal logic and math (Liu et al.; Ivanova et al.)
Partners and parts published science
Built from / builds (13)
- Software
- Compiler
- Syntax (lexical and grammatical structure)
- Semantics (static and dynamic)
- Type system
- Run-time system and garbage collector
- Standard library
- Specification
- Programmers and language communities
- Languages competing for programmers and projects
- The eternal war in memory (top-level competition)
- Computer science (the field: the practice and the computation it studies)
- Competition between recursion and iteration for a program's control flow
Sits inside / holds (3)
Trades with (valence) (24)
- Syntax: how a language combines words into phrases and sentences (constituency and dependency, word order, agreement, recursion), how speakers build and parse it, how children learn it, how it differs across languages, and the field that studies it via sys:acoustic-wave · Programming language gain
- Recursion: defining or computing a thing in terms of smaller versions of itself, as computer science and mathematics describe it, with its base cases, call stack, recursive data, induction, and its sightings in language and nature via sys:written-record · Programming language gain
- Turing machine: the abstract machine that reads and writes one symbol at a time on an unbounded tape by a finite table of rules, the model of computation of logic and computer science via sys:written-record · Programming language gain
- Human (Homo sapiens) via sys:written-record · Programming language gain
- Language (human language) via sys:written-record · Programming language gain
- Grammar (the structure of a language, as linguistics describes it) via sys:written-record · Programming language gain
- Writing (the practice of marking language on a surface, and the script plus rules it works with) via sys:written-record · Programming language gain
- Software via sys:written-record · Programming language gain
- Large language model via sys:written-record · Programming language mixed
- Algorithm (the practice of step-by-step procedures and the structure they compute) via sys:written-record · Programming language gain
- Operating system via sys:computer-hardware · Programming language gain
- Lambda calculus via sys:mental-representation · Programming language gain
- Open-source software via sys:written-record · Programming language gain
- Information security via sys:written-record · Programming language mixed
- Computer hardware via sys:computer-hardware · Programming language gain
- Software engineering via sys:written-record · Programming language gain
- Compiler via sys:written-record · Programming language gain
- Database via sys:written-record · Programming language gain
- Software vulnerability via sys:written-record · Programming language gain
- Secure software development via sys:software · Programming language gain
- Formal security policy model via sys:programming-language · Programming language gain
- Computer science (the field: the practice and the computation it studies) via sys:sensory-environment · Programming language gain
- Data structure via sys:written-record · Programming language gain
- Mathematical logic: the field that studies logic within mathematics (model theory, proof theory, set theory, computability theory) and the formal systems, structures and limit results it works on via sys:written-record · Programming language gain
expressed by (25)
- Generation/Synthesis
- Recombination/Composition
- Scaffolding/Enablement (Meta-Tooling)
- Templating / Standardization
- Quality Improvement/Refinement
- Interoperability/Transduction (Bridging)
- Encapsulation & Modularity (Abstraction)
- Amplification/Scale-Up (Manufacture & Distribution)
- Evolvability/Plasticity Engineering (Design for Future Variation)
- Internal Coordination/Regulation
- Sensing/Scanning
- Hypothesis/Goal Selection
- Uncertainty Reduction/Learning
- Trail-Marking / Externalized Memory (Stigmergy)
- Social Learning / Public Information Use
- Resource Denial/Attrition
- Reactive Response
- Physical/Virtual Barrier
- Technique-Based Identification (a.k.a. Technique-Based Detection)
- Self-Monitoring
- Validation of Effectiveness
- Resilience & Repair
- Quality Control & Error Correction
- Bridging Supply Gaps (Store & Dormancy)
- Scheduled Build-and-Dismantle (On-Demand Structure)
floor filled by (27)
- Software
- Recursion: defining or computing a thing in terms of smaller versions of itself, as computer science and mathematics describe it, with its base cases, call stack, recursive data, induction, and its sightings in language and nature
- Algorithm (the practice of step-by-step procedures and the structure they compute)
- Human (Homo sapiens)
- Grammar (the structure of a language, as linguistics describes it)
- Written record (durable external marks: texts, archives, canon)
- Large language model
- Operating system
- Lambda calculus
- Compiler
- Open-source software
- Computer hardware
- Semantics (static and dynamic)
- Type system
- Run-time system and garbage collector
- Standard library
- Specification
- Programmers and language communities
- Python
- Regular grammar (Type-3)
- Context-free grammar (Type-2)
- ALGOL
- Software engineering
- Software vulnerability
- Secure software development
- Computer science (the field: the practice and the computation it studies)
- Data structure
Kinds (12)
- Domain-specific / proprietary language
- Machine code
- Imperative language
- Functional language
- Logic language
- Object-oriented language
- Scripting language
- Visual (graphical) language
- High-level language (3GL)
- Assembly language (2GL)
- Security-typed programming language
- Cedar authorization language
wired (1)
Notes published science
- Ken Thompson once taught a C compiler what the escape '\v' means by writing it as the number 11, then deleted the number: the compiler kept 'knowing' it, passing the knowledge to every compiler it built from then on. He called it 'as close to a "learning" program as I have seen', and used the same trick to show a trojan could live in a compiler with no trace in any source code (src:thompson-1984-trusting).
- The same ten programming problems cost 120 joules on average in compiled languages, 576 in languages on a virtual machine and 2,365 in interpreted ones; on the global table Python used about 76 times the energy of C. Each layer of translation between the program and the chip pays its toll in heat (src:pereira-2017-energy).
- When expert programmers read code, the brain's general problem-solving network lights up strongly and the language network barely at all, even though code looks like text (src:ivanova-2020-code). Yet how well people pick up Python is predicted more by their language-learning aptitude (17% of the variance) than by numeracy (2%) (src:prat-2020-aptitude).
Layers
The ways it takes in its world, where they meet, and how it acts back, each from L1 (where it meets the world) up.
a language across time: proposals, versions, dialects and descendants (secondary stack)
- L1: An idea for the language, posted for discussion
- L2: The proposal document (PEP): design, rationale, record of decisions
- L3: Review and resolution against acceptance criteria
- L4: Versions on a clock: feature releases every twelve months; deprecations removed after at least two releases
- L5: Adoption: developers learn, choose and forget languages; libraries and existing code pull them
- L6: Descent: new languages built from components of earlier ones, in bursts tied to new niches
a programming language as language designers and implementers describe it: source text up to the programs people express and run with it (reader's view)
- L1: Source text: characters typed by programmers (or generated by models) in files; a few languages are graphical
- L2: Lexical structure: the lexer breaks text into tokens (words, numbers, symbols), defined by regular expressions
- L3: Syntax: the parser builds a tree by the grammar's rules (BNF, mostly context-free)
- L4: Static semantics: names bound to definitions, types checked, definite assignment; the type system
- L5: Implementation and dynamic semantics: compiler, interpreter or JIT turns the program into machine code; the run-time system (garbage collector, exception handling) runs it
- L6: Abstractions and agreement: the specification, standard library, paradigms and abstract data types programmers think in
- L7: Programs expressed and run: computations people intend, fully specified, acting on the world through the machine
the boardroom (shared floors)
- L4: Static semantics and the type system: names bound, types checked, the program's meaning fixed before it runs
- L5: The implementation: compiler, interpreter or JIT and the run-time system (garbage collector, exception handling)
- L6: The specification, standard library and the abstractions and paradigms the community shares
- L7: Programs people mean and run: the language's bet that its abstractions help them deliver
way in: Code generated by language models
- L1: A corpus of code written in the language
- L2: A model fine-tuned on it
- L3: Sampled programs checked by unit tests
way in: Mathematics and logic (lambda calculus, type theory, formal semantics)
- L1: A universal model of computation
- L2: Type systems for the lambda calculus (Hindley-Milner)
- L3: Formal semantics, with limited uptake outside academia
way in: Natural language (names, keywords, the statistics of human communication)
- L1: Software as human communication with natural-language statistics
- L2: Names and formatting carry no meaning for the machine
- L3: Language aptitude predicts how fast people learn a programming language
way in: Other people's code: libraries and existing code
- L1: Libraries and existing code in the language
- L2: Reached through interfaces that hide their representation
- L3: Names bound to their definitions
way in: Runtime errors (overflow, bad index, null)
- L1: The hardware result: overflow wraps and condition bits are set
- L2: The language's check: an error raised (or, in C/C++, undefined behaviour)
- L3: An exception handler is triggered
- L4: Termination or resumption
way in: Source text written by programmers
- L1: Characters typed into source files
- L2: The lexer turns them into tokens
- L3: The parser builds the parse tree
way in: The community's proposals and feedback (language evolution)
- L1: An idea for the language
- L2: Written as a design document
- L3: Discussed; consensus built by the champion
- L4: Resolved against acceptance criteria
- L5: Implemented and merged
way in: The heap: free storage running out (the garbage collector's channel)
- L1: Free storage: registers on the free-storage list, taken by cons
- L2: Exhaustion noticed: no free register left
- L3: Marking: everything reachable from the base registers is marked
- L4: Unreachable memory is garbage, reclaimed
way in: The language reading itself (self-hosting compilers, macros)
- L1: A compiler written in the language it compiles
- L2: Constructs that run during parsing
- L3: What the binary knows is passed to its next build
way in: The machine: processor, memory and instruction set the language is built for
- L1: Memory holding data and instructions, a separate CPU
- L2: Machine language: instructions the processor executes directly
- L3: The compiler's back end: CPU-specific optimisation and code generation
- L4: The language's central elements mirror the machine: variables, assignment, iteration
way in: The program's inputs at run time (through the operating system)
- L1: The program's inputs
- L2: Delivered by the operating system
- L3: The standard library's input functions
- L4: Read into typed values
way in: The running program's own behaviour (profile statistics)
- L1: The program running in its environment
- L2: Statistics collected by the JIT (how often code runs, which types turn up)
way in: What the programmer means (the inner channel: a computation held in mind)
- L1: The concepts a computation involves, held by the programmer
- L2: Code read and written in the brain's fronto-parietal networks (multiple demand system; logic-overlapping network)
- L3: Learned conventions of the language: its rules and syntax for logical operations
way out: Code that becomes training data for models
- L1: Collected into a training corpus
- L7: Programs written and published
way out: Descendant languages and dialects
- L1: A new language in the record (most imperative languages descend from ALGOL 60)
- L6: Components passed on to new languages
way out: Energy spent running programs
- L1: Joules drawn per solution
- L5: The implementation kind sets the cost: compiled, virtual machine or interpreted
way out: Error messages and warnings back to the programmer
- L1: A diagnostic shown to the programmer; the fault may lie far earlier in the program
- L4: A type error or undeclared name is flagged
way out: Machine code executed by the hardware
- L1: Executed by the hardware with the help of the operating system
- L3: Back end: code generation for the target CPU
- L5: Compiled ahead of time, interpreted, or JIT-compiled
way out: Specifications, design records and libraries published
- L1: Text in the shared record
- L4: A feature release each October
- L6: Design decisions documented
way out: The program's behaviour on the world (outputs through the operating system)
- L1: External behaviour
- L5: Executed
- L7: The intended computation
Who fills each layer
- L5: Compiler
Sources (41) published science
McCarthy 1960, Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I, Communications of the ACM 3(4), doi:10.1145/367177.367199 (behind its links)
Just-in-time compilation (Wikipedia, via Wikimedia Enterprise) (behind its links)
Meyerovich LA, Rabkin AS 2013. Empirical analysis of programming language adoption. OOPSLA 2013 (author copy) (behind its links)
PEP 1: PEP Purpose and Guidelines (Python Enhancement Proposal; primary governance document) (behind its links)
Thompson K 1984. Reflections on trusting trust (Turing Award lecture). Communications of the ACM 27(8):761-763. doi:10.1145/358198.358210 (behind its links)
Szekeres L, Payer M, Wei T, Song D 2013. SoK: Eternal war in memory. IEEE Symposium on Security and Privacy (author copy) (behind its links)
Valverde S, Sole RV 2015. Punctuated equilibrium in the large-scale evolution of programming languages. J R Soc Interface 12:20150249. doi:10.1098/rsif.2015.0249 (behind its links)
Compiler (Wikipedia, rev 1373605841, 2026-09-06, via Wikimedia Enterprise) (behind its links)
PEP 602: Annual Release Cycle for Python (primary governance document) (behind its links)
Pereira et al. 2017, Energy Efficiency across Programming Languages, SLE'17, doi:10.1145/3136014.3136031 (behind its links)
Garbage collection (computer science) (encyclopedia) (behind its links)
Memory safety (Wikipedia, via Wikimedia Enterprise) (behind its links)
Xu H et al. 2021. Memory-safety challenge considered solved? An in-depth study with all Rust CVEs. arXiv:2003.03296 (TOSEM) (behind its links)
Dietz W, Li P, Regehr J, Adve V 2012. Understanding integer overflow in C/C++. ICSE 2012 (author copy) (behind its links)
Chen M et al. 2021. Evaluating large language models trained on code. arXiv:2107.03374 (behind its links)
Liu et al. 2020, Computer code comprehension shares neural resources with formal logical inference in the fronto-parietal network, eLife, doi:10.7554/eLife.59340 (behind its links)
Nanz S, Furia CA 2015. A comparative study of programming languages in Rosetta Code. arXiv:1409.0252 (ICSE 2015) (behind its links)
Berger ED, Hollenbeck C, Maj P, Vitek O, Vitek J 2019. On the impact of programming languages on code quality: a reproduction study. arXiv:1901.10220 (TOPLAS) (behind its links)
Bootstrapping (compilers) (Wikipedia, rev 1323208297, 2025-11-20, via Wikimedia Enterprise) (behind its links)
Type system (Wikipedia, via Wikimedia Enterprise) (behind its links)
Software (encyclopedia) (behind its links)
Computer science (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Ivanova et al. 2020, Comprehension of computer code relies primarily on domain-general executive brain regions, eLife 9:e58906, doi:10.7554/eLife.58906 (behind its links)
Allamanis M, Barr ET, Devanbu P, Sutton C 2018. A survey of machine learning for big code and naturalness. arXiv:1709.06182 (ACM Computing Surveys) (behind its links)
Lambda calculus (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Chomsky hierarchy (Wikipedia, via Wikimedia Enterprise) (behind its links)
Recursion (computer science) (Wikipedia, via Wikimedia Enterprise snapshot 2026-10-01) (behind its links)
Turing machine (Wikipedia, rev 1380238390, 2026-10-14, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Hoffmann M, Nagle F, Zhou Y (2024) The Value of Open Source Software. Harvard Business School Working Paper 24-038 (behind its links)
Database (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Vander Stoep J, Rebert A (Google). Eliminating Memory Safety Vulnerabilities at the Source. Google Security Blog, September 2024 (behind its links)
Sabelfeld A, Myers AC (2003). Language-Based Information-Flow Security. IEEE Journal on Selected Areas in Communications 21(1), January 2003 (behind its links)
Linked list (encyclopedia, Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Mathematical logic (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Integer overflow (Wikipedia, via Wikimedia Enterprise) (behind its links)
Hindley-Milner type system (Wikipedia, via Wikimedia Enterprise) (behind its links)
Rice's theorem (Wikipedia, via Wikimedia Enterprise) (behind its links)