EVOPEDIA

← 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 at1940s (first programmable computers and their languages); first compiler for a high-level language 1951 (Boehm); A-0 compiler May 1952; Fortran 1956-1957
born precisiondecade
boundaryInside: 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 levelBuilt 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.
scaletechnological

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 executable10 to 100 times slower
average energy per benchmark solution: compiled languages120 J
average energy per benchmark solution: virtual-machine languages576 J
average energy per benchmark solution: interpreted languages2365 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 management5 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 CINT2000over 200 distinct locations
Codex training corpus: public repositories54 million repositories
Codex training corpus: Python files179 GB
Codex pass rate on HumanEval, one sample28.8 percent
Codex pass rate on HumanEval, 100 samples70.2 percent
variance in Python learning explained by language aptitude17 percent
variance in Python learning explained by fluid reasoning and working memory34 percent
experience of expert programmers in the code-logic fMRI studyaverage 11 years
Rosetta Code solution programs compared7,087 programs, 745 tasks, 8 languages count
languages with a significant defect association after reanalysis4 of 11 languages
projects and programmers in the adoption studyover 200,000 SourceForge projects; 590,000 Ohloh projects; surveys of 1,000-13,000 programmers count
programming languages used by one software projectfive 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.

Partners and parts published science

Built from / builds (13)

Sits inside / holds (3)

Trades with (valence) (24)

expressed by (25)

floor filled by (27)

Kinds (12)

wired (1)

Notes published science

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)

  1. L1: An idea for the language, posted for discussion
  2. L2: The proposal document (PEP): design, rationale, record of decisions
  3. L3: Review and resolution against acceptance criteria
  4. L4: Versions on a clock: feature releases every twelve months; deprecations removed after at least two releases
  5. L5: Adoption: developers learn, choose and forget languages; libraries and existing code pull them
  6. 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)

  1. L1: Source text: characters typed by programmers (or generated by models) in files; a few languages are graphical
  2. L2: Lexical structure: the lexer breaks text into tokens (words, numbers, symbols), defined by regular expressions
  3. L3: Syntax: the parser builds a tree by the grammar's rules (BNF, mostly context-free)
  4. L4: Static semantics: names bound to definitions, types checked, definite assignment; the type system
  5. 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
  6. L6: Abstractions and agreement: the specification, standard library, paradigms and abstract data types programmers think in
  7. L7: Programs expressed and run: computations people intend, fully specified, acting on the world through the machine

the boardroom (shared floors)

  1. L4: Static semantics and the type system: names bound, types checked, the program's meaning fixed before it runs
  2. L5: The implementation: compiler, interpreter or JIT and the run-time system (garbage collector, exception handling)
  3. L6: The specification, standard library and the abstractions and paradigms the community shares
  4. L7: Programs people mean and run: the language's bet that its abstractions help them deliver

way in: Code generated by language models

  1. L1: A corpus of code written in the language
  2. L2: A model fine-tuned on it
  3. L3: Sampled programs checked by unit tests

way in: Mathematics and logic (lambda calculus, type theory, formal semantics)

  1. L1: A universal model of computation
  2. L2: Type systems for the lambda calculus (Hindley-Milner)
  3. L3: Formal semantics, with limited uptake outside academia

way in: Natural language (names, keywords, the statistics of human communication)

  1. L1: Software as human communication with natural-language statistics
  2. L2: Names and formatting carry no meaning for the machine
  3. L3: Language aptitude predicts how fast people learn a programming language

way in: Other people's code: libraries and existing code

  1. L1: Libraries and existing code in the language
  2. L2: Reached through interfaces that hide their representation
  3. L3: Names bound to their definitions

way in: Runtime errors (overflow, bad index, null)

  1. L1: The hardware result: overflow wraps and condition bits are set
  2. L2: The language's check: an error raised (or, in C/C++, undefined behaviour)
  3. L3: An exception handler is triggered
  4. L4: Termination or resumption

way in: Source text written by programmers

  1. L1: Characters typed into source files
  2. L2: The lexer turns them into tokens
  3. L3: The parser builds the parse tree

way in: The community's proposals and feedback (language evolution)

  1. L1: An idea for the language
  2. L2: Written as a design document
  3. L3: Discussed; consensus built by the champion
  4. L4: Resolved against acceptance criteria
  5. L5: Implemented and merged

way in: The heap: free storage running out (the garbage collector's channel)

  1. L1: Free storage: registers on the free-storage list, taken by cons
  2. L2: Exhaustion noticed: no free register left
  3. L3: Marking: everything reachable from the base registers is marked
  4. L4: Unreachable memory is garbage, reclaimed

way in: The language reading itself (self-hosting compilers, macros)

  1. L1: A compiler written in the language it compiles
  2. L2: Constructs that run during parsing
  3. 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

  1. L1: Memory holding data and instructions, a separate CPU
  2. L2: Machine language: instructions the processor executes directly
  3. L3: The compiler's back end: CPU-specific optimisation and code generation
  4. 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)

  1. L1: The program's inputs
  2. L2: Delivered by the operating system
  3. L3: The standard library's input functions
  4. L4: Read into typed values

way in: The running program's own behaviour (profile statistics)

  1. L1: The program running in its environment
  2. 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)

  1. L1: The concepts a computation involves, held by the programmer
  2. L2: Code read and written in the brain's fronto-parietal networks (multiple demand system; logic-overlapping network)
  3. L3: Learned conventions of the language: its rules and syntax for logical operations

way out: Code that becomes training data for models

  1. L1: Collected into a training corpus
  2. L7: Programs written and published

way out: Descendant languages and dialects

  1. L1: A new language in the record (most imperative languages descend from ALGOL 60)
  2. L6: Components passed on to new languages

way out: Energy spent running programs

  1. L1: Joules drawn per solution
  2. L5: The implementation kind sets the cost: compiled, virtual machine or interpreted

way out: Error messages and warnings back to the programmer

  1. L1: A diagnostic shown to the programmer; the fault may lie far earlier in the program
  2. L4: A type error or undeclared name is flagged

way out: Machine code executed by the hardware

  1. L1: Executed by the hardware with the help of the operating system
  2. L3: Back end: code generation for the target CPU
  3. L5: Compiled ahead of time, interpreted, or JIT-compiled

way out: Specifications, design records and libraries published

  1. L1: Text in the shared record
  2. L4: A feature release each October
  3. L6: Design decisions documented

way out: The program's behaviour on the world (outputs through the operating system)

  1. L1: External behaviour
  2. L5: Executed
  3. L7: The intended computation

Who fills each layer

Sources (41) published science

Programming language (Wikipedia via Wikimedia Enterprise, cached research/showcase/cache/wme)
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)
Prat CS et al. 2020. Relating natural language aptitude to individual differences in learning programming languages. Scientific Reports 10:3817. doi:10.1038/s41598-020-60661-8 (CC BY) (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)
Cutler JW, Disselkoen C, Eline A, et al. (2024). Cedar: A New Language for Expressive, Fast, Safe, and Analyzable Authorization (extended version). arXiv:2403.04651 (CC BY 4.0) (behind its links)
Rice's theorem (Wikipedia, via Wikimedia Enterprise) (behind its links)
Covariance and contravariance (computer science) (Wikipedia, via Wikimedia Enterprise) (behind its links)