- Atlas
- Computer Science
- Language Design
Language Design
Language Design: A History of Deciding What Programs May Say Language design is the part of programming-languages research that decides what a language lets a programmer express, what it forbids, and what its constructs mean.
13 frameworks, from 1950 to today · Programming Languages · Computer Science
- Assembly language 1950-1975
- Fortran 1957-1985
- Extensible programming 1958-Present
- COBOL 1959-1990
- ALGOL 60 1960-1990
- Structured Programming 1968-1990
- Semantics 1969-Present
- Type Systems and Type Inference 1969-Present
- Abstract data type 1970-2000
- Concurrency-Oriented Language Design 1970-Present
- Domain-specific language 1970-Present
- Object-oriented programming 1972-Present
- Memory Safety and Ownership 2010-Present
Overview
Language Design: A History of Deciding What Programs May Say
Language design is the part of programming-languages research that decides what a language lets a programmer express, what it forbids, and what its constructs mean1. It is not the same as building a compiler, though the two grew up together: a designer chooses the abstractions—variables, functions, objects, types, threads—and a compiler or interpreter makes them run12. The stakes are practical. Every abstraction that a language makes easy is one that thousands of programs will use, and every guarantee it enforces is a class of bug that programmers no longer have to find by hand. The history of the field is a sequence of answers to the question: which notations make correct programs easy to write and wrong ones hard to write?
From Machine Codes to Symbolic Assembly
The earliest programming was raw machine code, written as numbers13. The first real design step was the assembler, which let a programmer write mnemonic names for instructions and symbolic labels for addresses, and let the machine translate them14. Assemblers appeared in the early 1950s on machines such as the UNIVAC and the IBM 701; the idea of a program that translates a notation into machine code was itself the founding move of the field. Assembly remained close to the hardware—one line per instruction—but it established a pattern that would recur: raise the notation one level, and let a translator absorb the bookkeeping4.
Algebraic Formula Languages and the First Compilers
The decisive break came with languages that looked like mathematics rather than like hardware. FORTRAN, designed at IBM under John Backus and released in 1957, let scientists write arithmetic formulas over arrays and loops, and a compiler translated them into efficient machine code. The claim that a compiler could produce code nearly as good as hand-written assembly was controversial, and FORTRAN's success settled it. ALGOL 60, a committee design published in 1960, went further: it introduced block structure, recursive procedures, and a formal grammar (Backus–Naur form) for describing syntax. ALGOL's grammar was a design tool as much as a documentation device—it made the language's structure precise enough to be parsed mechanically, and it became the model for describing every later language. COBOL, from the same era, aimed at business data processing with English-like syntax, showing that language design is always design for a particular community of users.
Structured Programming and Control Flow
By the late 1960s, programs had grown large enough that their control flow—the tangle of jumps and gotos—became the main source of incomprehensibility. Edsger Dijkstra's 1968 letter "Go To Statement Considered Harmful" argued that a program's progress should be readable from its text, which unrestricted jumps destroy. The structured-programming movement that followed promoted sequencing, selection, and iteration as the only control constructs, and languages such as Pascal (Niklaus Wirth, 1970) were designed around them. The point was not aesthetics: structured control flow made programs amenable to reasoning and to systematic translation, and it shaped how a generation was taught to program.
Abstract Data Types and Information Hiding
The next problem was data. A program that manipulates a stack or a queue should not depend on whether it is stored as an array or a linked list. The answer was the abstract data type: a type defined by its operations, with its representation hidden5. Simula 67, designed by Ole-Johan Dahl and Kristen Nygaard in Norway, had already bundled data and procedures into classes; work by Barbara Liskov and others in the 1970s, and languages such as CLU, made the abstraction explicit567. The principle—information hiding—meant that a module's internals could change without breaking its users, and it became a cornerstone of large-scale design58.
Object-Oriented Design
Simula's classes grew into the object-oriented style: objects that carry both state and behavior, classes that inherit from one another, and dynamic dispatch, where the operation invoked depends on the object's runtime type167. Smalltalk, developed at Xerox PARC in the 1970s, made objects and messages the whole language69. C++ (Bjarne Stroustrup, early 1980s) brought classes and inheritance to C with an eye on performance, and Java (1995) made objects and garbage collection mainstream110113. The design question these languages posed—how to organize large systems around interacting entities—became the dominant way a generation of programmers thought about software structure.
Type Systems and Type Inference
Types are the language's way of stating what a value is and what operations make sense on it112. Early type systems were simple checks; the deeper idea was that types could be inferred rather than written113. The Hindley–Milner type system, developed in the late 1960s and 1970s and used in the ML family, lets a programmer write a function without type annotations and have the compiler deduce the most general type, rejecting programs that could apply an operation to the wrong kind of value. This was a genuine design advance: it gave strong static guarantees without the burden of annotation. Later work extended types to polymorphism, modules, and effects, and type systems became the main mechanism by which languages enforce safety.
Formal Semantics
If a language is to be trusted, its meaning must be stated precisely. Formal semantics gives mathematical accounts of what programs do1415. Operational semantics describes execution as a sequence of steps; denotational semantics maps programs to mathematical objects; axiomatic semantics, notably C. A. R. Hoare's 1969 logic, gives rules for reasoning about what a program guarantees141516. These were not idle exercises: they let designers prove properties of their languages and let compilers be checked against a specification. The field's later move toward mechanized proof—languages whose semantics are formalized in a proof assistant—descends directly from this work.
Extensible Languages and Macros
A recurring frustration is that a language cannot anticipate every need. Extensible languages let programmers add new syntax or semantics. Lisp, from 1958 onward, made this foundational: its macro facility lets a program transform code before evaluation, so a user can define new control forms. Later systems, from Scheme's hygienic macros to modern macro systems in Rust and other languages, refined the idea so that extensions do not accidentally capture the user's variables. The design tension—flexibility versus predictability—remains live.
Concurrency-Oriented Language Design
As machines gained multiple processors, languages had to say how concurrent computations interact. Early designs offered threads and locks, which are powerful but error-prone. Alternatives claimed different ground: message passing, as in Erlang, where processes communicate by sending messages and failures are isolated; the actor model, from Carl Hewitt's work in the 1970s; and data-parallel and functional approaches that avoid shared mutable state. Each design choice is a bet about where concurrency bugs come from and what notation prevents them.
Domain-Specific Languages
Not every problem wants a general-purpose language. A domain-specific language is built for one narrow task—querying a database (SQL), describing hardware, or specifying a grammar—and gains power by restricting what can be said17. The tradition runs from early report generators and SQL (developed at IBM in the 1970s) to modern embedded and external DSLs. The design lesson is that a smaller language, tailored to its users, can be more expressive within its domain than any general language.
The Present
Today's language design draws on all of these threads. Type systems have grown richer, with dependent types and effect systems moving from research into practice. Memory safety and ownership—as in Rust's borrow checker—show that new static guarantees can be designed and adopted18. Concurrency models continue to compete, and domain-specific languages proliferate. The open questions are the old ones in new dress: how to give programmers strong guarantees without burdening them, how to make extensions safe, and how to state a language's meaning precisely enough that both people and machines can rely on it.
References
- Programming language (introduction, Definition, Early developments, Classifications, 1980s to 2000s, Type system, Static and dynamic typing), Wikipedia
- Programming language design and implementation, Wikipedia
- Imperative programming (History of imperative and object-oriented languages), Wikipedia
- Assembly language, Wikipedia
- Abstract data type (introduction, History), Wikipedia
- Object-oriented programming (History), Wikipedia
- Simula, Wikipedia
- Information hiding, Wikipedia
- Smalltalk, Wikipedia
- C++, Wikipedia
- Java (programming language), Wikipedia
- Type system, Wikipedia
- Type inference, Wikipedia
- Semantics (programming languages) (introduction, History), Wikipedia
- Denotational semantics, Wikipedia
- Operational semantics, Wikipedia
- Domain-specific language, Wikipedia
- Rust (programming language), Wikipedia
The frameworks of Language Design
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1950-1975
- 1957-1985
- 1958-Present
- 1959-1990
- 1960-1990
- 1968-1990
- 1969-Present
- 1969-Present
- 1970-2000
- 1970-Present
- 1970-Present
- 1972-Present
- 2010-Present
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Semantics influenced by ALGOL 60
ALGOL 60 was the first language whose syntax was formally specified, and it became the standard object of study for formal semantics. Hoare's 1969 axiomatic logic and the operational and denotational accounts that followed were written for ALGOL-like languages.
Carried by C. A. R. Hoare; Peter Landin.
Fortran influenced by Assembly language
FORTRAN's designers at IBM, led by John Backus, worked against the assumption that compiled code could not match hand-written assembly, and the compiler's early success in producing efficient machine code settled that debate. The symbolic-notation-over-machine-code pattern established by assemblers is the move FORTRAN repeated at a higher level.
Carried by John Backus.
COBOL rival of Fortran
COBOL and FORTRAN were near-contemporary answers to the same question of what a high-level language should look like, one aimed at business data processing with English-like syntax and the other at scientific computation with algebraic formulas. They competed for the same institutional users and standardisation efforts in the late 1950s.
Carried by CODASYL.
ALGOL 60 reacted against Fortran
ALGOL 60 was designed by a committee that deliberately rejected FORTRAN's ad hoc, machine-oriented syntax in favour of a formal grammar and block structure. The Backus–Naur form used to define ALGOL grew out of the notation work done for FORTRAN's report.
Carried by John Backus; Report on the Algorithmic Language ALGOL 60 (1960).
Structured Programming influenced by ALGOL 60
ALGOL 60's block structure and its restriction of control flow to structured constructs gave the structured-programming movement its working model of readable control flow. Dijkstra's argument against the goto was made in the context of ALGOL-style programs and was taken up by Wirth, whose Pascal refined ALGOL's control constructs.
Carried by Edsger W. Dijkstra; Niklaus Wirth.
Abstract data type influenced by ALGOL 60
The abstract-data-type work of Liskov and others was formulated for ALGOL-family languages, and CLU was designed as an ALGOL-like language extended with clusters and information hiding. The module and type constructs were added to an ALGOL-style base.
Carried by Barbara Liskov; CLU.
Abstract data type influenced by Structured Programming
Structured programming's insistence on modular, readable program structure fed directly into the information-hiding modules of the 1970s. Parnas's work on decomposing systems into modules framed information hiding as the next step in making large programs comprehensible.
Carried by David Parnas.
Memory Safety and Ownership grew out of Type Systems and Type Inference
Rust's ownership and borrowing rules are a type-system mechanism: the compiler tracks lifetimes and aliasing as part of type checking, so memory safety is enforced by the same static analysis tradition that produced type inference and effect systems. The borrow checker is a refinement of the type system as the language's enforcement mechanism.
Type Systems and Type Inference influenced by Abstract data type
Abstract data types posed the question of how a type system can express an interface separately from its representation, which drove work on existential and module types. Type systems for modules and abstract types were developed to give static guarantees to information hiding.
Carried by John C. Reynolds.
Domain-specific language influenced by Extensible programming
The extensible-language tradition, especially Lisp macros, showed that a language could be grown toward a particular problem by adding notation, a move that embedded domain-specific languages later adopted. Macro-based extension is one of the routes by which a general language is specialised to a domain.
Object-oriented programming influenced by ALGOL 60
Simula 67 was designed as an extension of ALGOL 60, adding classes and objects to an ALGOL base; its syntax and block structure carried over directly. The object-oriented style that grew from Simula thus inherited ALGOL's notation.
Carried by Ole-Johan Dahl; Kristen Nygaard; Simula 67.
Object-oriented programming influenced by Structured Programming
The object-oriented style absorbed structured programming's discipline of clear control flow and modular decomposition, and languages such as C++ combined structured control constructs with classes. The teaching of structured design shaped how objects were presented as units of program structure.
Carried by Bjarne Stroustrup.
Memory Safety and Ownership influenced by Concurrency-Oriented Language Design
Concurrency-oriented designs that avoided shared mutable state, notably message-passing and functional approaches, prepared the ground for ownership-based memory safety, which extends the same concern with preventing data races to the type system. Rust's borrow checker enforces at compile time what those designs sought by discipline.
Beyond the field
Where Language Design's ideas came from in other fields, and what they led to there: the strongest 12 of 54 links.
Fortran influenced Imperative programming in Programming Languages
Fortran's assignment statements, DO loops and statement sequencing established the imperative style that later imperative languages adopted. Its design was the working model for subsequent imperative programming.
Carried by John Backus; Fortran (1957).
ALGOL 60 influenced by Formal grammar and parsing theory in Compiler Design
The ALGOL 60 report introduced Backus-Naur Form to define the language's syntax, and this formal grammar notation became the basis of parsing theory and compiler construction. BNF directly enabled the development of formal parsing methods.
Carried by John Backus; Peter Naur; ALGOL 60 Report (1960).
Structured Programming influenced Structured Design in Software Engineering
Structured Design applied structured programming's top-down, single-entry single-exit decomposition to the design of module hierarchies, transforming program structure principles into design heuristics.
Carried by Edward Yourdon; Larry Constantine.
Type Systems and Type Inference influenced by Type Theory in Foundations Of Mathematics
The foundational type theories of Russell and Whitehead are the source of the type discipline later adopted in programming languages. Church's formulation of simple type theory made the passage into computability and language design explicit.
Carried by Bertrand Russell; Alonzo Church.
Type Systems and Type Inference grew out of Simply Typed Lambda Calculus in Type Systems
The simply typed lambda calculus, formulated by Church in 1940, is the direct formal core of programming-language type systems and type inference. Hindley and Milner's inference algorithms operate on exactly this calculus.
Carried by Alonzo Church; J. Roger Hindley; Robin Milner.
Type Systems and Type Inference influenced by Theory of Types in Type Systems
Russell's ramified theory of types, and the simple theory of types extracted from it, supplied the basic idea of stratifying objects into types that underlies programming-language type systems. Church's typed lambda calculus carried this into computability and thence into language design.
Carried by Bertrand Russell; Alonzo Church.
Type Systems and Type Inference influenced by Type theory in Logic
Programming-language type theory descends directly from Russell's and Whitehead's logicist type theory, mediated by Church's simply typed lambda calculus. The Curry-Howard correspondence later made the logic and the programming language the same object.
Carried by Bertrand Russell; Alfred North Whitehead; Alonzo Church.
Type Systems and Type Inference influenced by Simple Theory of Types in Type Theory
Church's simple theory of types, formulated in the 1930s-40s, is the direct ancestor of the simply typed lambda calculus and hence of programming-language type systems. Its stratification of functions by type is the core idea later type systems formalise.
Carried by Alonzo Church.
Type Systems and Type Inference influenced by Type Theory in Mathematical Logic
Mathematical type theory, from Russell through Church and later Martin-Löf, is the direct ancestor of programming-language type systems. The typed lambda calculus and its proof-theoretic semantics were taken over wholesale into language design.
Carried by Alonzo Church; Per Martin-Löf.
Object-oriented programming influenced Object-Oriented Analysis and Design in Systems Analysis And Design
Simula 67 introduced classes, objects and inheritance, and Smalltalk extended them into a full programming environment; these language concepts were the direct source of the object model that OO analysis and design methods later formalised for analysis and design.
Carried by Simula 67 (1967); Smalltalk (1980).
Assembly language influenced Imperative programming in Programming Languages
Assembly language's step-by-step instruction sequencing and explicit storage mutation were the direct model for the imperative paradigm's notion of a program as a sequence of state-changing commands. Early high-level imperative languages were conceived as more readable assembly.
Assembly language influenced Compilation and implementation in Programming Languages
Early compilers such as the Fortran compiler translated source into machine code, and assembly language was the intermediate and target notation programmers and compiler writers worked with. The techniques of symbol tables, relocation and code generation were carried over from assembler practice into compiling.
Carried by John Backus.

Language Design is a planet in Nousfarer
Its city has a tower for each of these 13 frameworks. Land, walk in, and climb one concept at a time.
Land on Language DesignRelated fields
Fields its ideas are linked to
- Programming Languages 10 links
- Type Systems 8 links
- Programming Paradigms 7 links
- Compiler Design 6 links
- Computer Architecture 3 links
- Concurrency Models 3 links
- Digital Systems 2 links
- Type Theory 2 links
- Mathematical Logic 2 links
- Software Architecture 2 links
- Instruction Set Architecture 1 link
- Systems Analysis And Design 1 link
More in Programming Languages
- Compiler Design
- Concurrency Models
- Pl Semantics
- Program Analysis
- Programming Languages
- Programming Paradigms
- Type Systems
See where Language Design sits on the Map of Human Knowledge