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

still a working view ended · each leads to its entry below

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

  1. Programming language (introduction, Definition, Early developments, Classifications, 1980s to 2000s, Type system, Static and dynamic typing), Wikipedia
  2. Programming language design and implementation, Wikipedia
  3. Imperative programming (History of imperative and object-oriented languages), Wikipedia
  4. Assembly language, Wikipedia
  5. Abstract data type (introduction, History), Wikipedia
  6. Object-oriented programming (History), Wikipedia
  7. Simula, Wikipedia
  8. Information hiding, Wikipedia
  9. Smalltalk, Wikipedia
  10. C++, Wikipedia
  11. Java (programming language), Wikipedia
  12. Type system, Wikipedia
  13. Type inference, Wikipedia
  14. Semantics (programming languages) (introduction, History), Wikipedia
  15. Denotational semantics, Wikipedia
  16. Operational semantics, Wikipedia
  17. Domain-specific language, Wikipedia
  18. 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.

  1. 1950-1975
  2. 1957-1985
  3. 1958-Present
  4. 1959-1990
  5. 1960-1990
  6. 1968-1990
  7. 1969-Present
  8. 1969-Present
  9. 1970-2000
  10. 1970-Present
  11. 1970-Present
  12. 1972-Present
  13. 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.

Assembly languageFortranExtensible programmingCOBOLALGOL 60Structured ProgrammingSemanticsType Systems and Type InferenceAbstract data typeConcurrency-Oriented Language DesignDomain-specific languageObject-oriented programmingMemory Safety and Ownership

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.

A city in Nousfarer: a red-carpeted stair climbing terraces to a crowned tower on an acropolis, more towers round it, forest and snowy mountains beyond.
A city in Nousfarer, the game played in the browser.

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 Design

Related fields

Fields its ideas are linked to

More in Programming Languages

See where Language Design sits on the Map of Human Knowledge