Programming Languages

Design, semantics, and paradigms of programming languages.


foundation tier

Programming Languages addresses design, semantics, and paradigms of programming languages. It sits within Programming and Languages and inherits that area’s core questions about correctness, scale, and tractability. This page surveys the conceptual axes of the topic and points to the references that frame ongoing research and teaching. The intent is to be useful both as an entry point for newcomers and as an index for practitioners cross-checking their mental model against the field’s primary sources.

Work on programming languages can be organised around a few interlocking concerns: the formal objects under study, the algorithms or systems that compute over them, the resource trade-offs (time, memory, communication, statistical efficiency), and the empirical or theoretical guarantees that practitioners rely on. The sources cited below approach the topic from a mix of these angles.

Foundational references

Pierce, Types and Programming Languages (2002) is a standard reference for this material and is used both as a curriculum anchor and as a long-form survey of techniques.

Supporting and complementary work

Sebesta, Concepts of Programming Languages (2018) provides supporting material that complements the primary references — readers comparing approaches will find useful framings, alternative notations, or extensions there. Scott, Programming Language Pragmatics (2015) provides supporting material that complements the primary references — readers comparing approaches will find useful framings, alternative notations, or extensions there.

Open methodological questions in programming languages cluster around how to compose the techniques above under realistic constraints — scale, adversarial inputs, partial observability, and shifting workloads. The cited references give the precise statements, proofs, and empirical evaluations that this overview only sketches; downstream topic pages drill into specific subfields.

Prerequisites

Sources

  • textbook · primary · 2002
    Types and Programming Languages
    pierce-2002
  • textbook · supporting · 2018
    Concepts of Programming Languages
    sebesta-2018
  • textbook · supporting · 2015
    Programming Language Pragmatics
    scott-2015

In context

Where this topic sits in the prerequisite graph. Click any node to jump.

Open in full atlas →

Explore

  1. 01

    Operational Semantics

    Small-step and big-step semantics of programming languages.

  2. 02

    Denotational Semantics

    Domain theory and mathematical meanings of programs.

  3. 03

    Axiomatic Semantics

    Hoare logic and weakest preconditions.

  4. 04

    Functional Programming

    Pure functions, immutability, and higher-order programming.

  5. 05

    Object-Oriented Programming

    Encapsulation, inheritance, polymorphism, and OO design.

  6. 06

    Logic Programming

    Horn clauses, unification, and Prolog-style resolution.

  7. 07

    Concurrent and Parallel Languages

    Actors, CSP, futures, and parallel language constructs.

  8. 08

    Type Systems

    Static and dynamic typing, polymorphism, and type inference.

  9. 09

    Dependent Types

    Types indexed by values, used in proof assistants and verified programming.

  10. 10

    Effect Systems

    Algebraic effects, handlers, and effect tracking.

  11. 11

    Linear and Affine Types

    Substructural type systems for resource control (Rust borrow checking, separation logic precursors).

  12. 12

    Gradual Typing

    Blending static and dynamic typing with runtime checks.

  13. 13

    Macros and Metaprogramming

    Syntactic and procedural macros and reflective metaprogramming.

  14. 14

    Domain-Specific Languages

    Internal and external DSLs and DSL design.

  15. 15

    Probabilistic Programming

    Languages for specifying and inferring over probabilistic models.

  16. 16

    Differentiable Programming

    Languages and frameworks for end-to-end automatic differentiation.

  17. 17

    Array Programming Languages

    Languages and compilers built around array abstractions (APL family, Halide, Triton, JAX/XLA-style).


Review this topic

This page was drafted by an agent and is waiting on expert review. Spotted a wrong prerequisite, a missing concept, a misattributed source, or a factual slip? Tell us — your review opens a tracked issue maintainers act on.