Programming Paradigms

A programming paradigm is a style of organizing what a program says and how it says it: whether the programmer issues step-by-step commands, defines mathematical functions, states facts and asks questions, or builds objects that bundle data with behavior.

8 frameworks, from 1957 to today · Programming Languages · Computer Science

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

Overview

A programming paradigm is a style of organizing what a program says and how it says it: whether the programmer issues step-by-step commands, defines mathematical functions, states facts and asks questions, or builds objects that bundle data with behavior1. The word comes from the Greek paradeigma, a pattern or model, and in programming languages it names a family of conventions about how computation should be structured. Paradigms matter because they shape what is easy to write, what is easy to get right, and what kinds of mistakes a language can catch before a program ever runs. The history of paradigms is largely a history of programmers discovering that certain ways of organizing code make large programs tractable—and of language designers building notations that make those ways natural.

Machine Code and the First Imperative Languages

The earliest programs were written in the machine's own language: sequences of numeric operation codes and addresses, entered by hand. This was imperative in the plainest sense—each instruction told the machine to do one thing—but it was also unreadable and unportable. The first great step was the assembler, which let programmers write mnemonics instead of numbers, and then the first high-level languages, which let them write formulas and loops in something closer to mathematics1.

FORTRAN, released by IBM in 1957, is the landmark. It let scientists write arithmetic expressions and DO loops that a compiler translated into machine instructions. Its design was driven by a concrete problem: numerical computation on the IBM 704, where hand-coded assembly was slow to write and error-prone. FORTRAN's success established the imperative paradigm as the default: a program is a sequence of statements that change the state of the machine, one after another. COBOL (1959) applied the same model to business data processing, and ALGOL 60 (1960) gave the imperative tradition a rigorous syntactic and semantic foundation that influenced nearly every later language.

Structured Programming and the Discipline of Control Flow

By the late 1950s and 1960s, programs had grown large enough that their control flow—the order in which statements execute—became the central problem1. Programs were written with arbitrary jumps, the GOTO statement, which could leap anywhere in the code1. This made programs hard to read and hard to reason about: a reader could not tell, from a stretch of code, how control had arrived there or where it would go1.

The response was structured programming1. Its most famous statement is Edsger Dijkstra's 1968 letter "Go To Statement Considered Harmful," which argued that unrestricted jumps destroy the correspondence between the text of a program and the progress of its execution. The constructive proposal, developed in the late 1960s and crystallized in work by Corrado Böhm and Giuseppe Jacopini (1966) and later by Dijkstra and others, was that any program could be written using only a small set of control structures: sequence, selection (if-then-else), and iteration (while loops)2. These structures have a single entry and a single exit, so control flow becomes a nested hierarchy that a reader can follow3.

The practical payoff was enormous. Languages such as ALGOL and Pascal (1970) built these structures into their syntax, and the idea that programs should be decomposed into small, comprehensible units—procedures and functions—became standard45. Structured programming is the ancestor of what is now called procedural programming: organizing a program as a collection of procedures that each perform a well-defined task, with control flowing through calls and returns rather than jumps16. The distinction between the two terms is loose in practice; structured programming names the discipline of control flow, procedural programming the organization around procedures5.

The Functional Tradition: Computation as Mathematics

A rival conception grew out of mathematical logic. In the 1930s, Alonzo Church developed the lambda calculus, a formal system in which everything is a function and computation is the application of functions to arguments7. This was not a programming language but a foundation for mathematics; its importance for programming emerged later, when researchers noticed that the lambda calculus offered a precise, compositional model of computation7.

The functional paradigm treats a program as a collection of function definitions and applications, and it emphasizes pure functions—functions whose output depends only on their inputs and which have no side effects such as changing a global variable or printing to the screen18. This makes programs easier to reason about: a function call can be replaced by its result without changing the program's meaning, a property called referential transparency910.

The first functional programming language was Lisp, designed by John McCarthy in 1958–19608. Lisp represented programs and data in the same form—nested lists—and introduced garbage collection, the automatic reclamation of memory no longer in use. Its influence was broad, but for years functional programming remained a research tradition rather than a mainstream one8. A key development was the ML family, beginning at the University of Edinburgh in the early 1970s, which combined functional programming with a sophisticated type system and type inference—the compiler deduces types without the programmer writing them11. Haskell, standardized in 1990, took purity further by making side effects explicit through a type-level distinction, and it popularized lazy evaluation, in which an expression is computed only when its value is needed. The functional tradition's central claim—that programs built from composable, side-effect-free functions are easier to test and reason about—has steadily gained ground, and functional features such as first-class functions and immutable data have been absorbed into many mainstream languages.

Logic Programming: Stating Facts and Asking Questions

A third paradigm came from automated theorem proving. In the 1960s and early 1970s, researchers asked whether a program could be written as a set of logical statements rather than as a sequence of instructions12. The landmark result was Prolog, developed by Alain Colmerauer and Philippe Roussel in Marseille around 1972, building on work by Robert Kowalski on the resolution principle and on the idea that computation could be viewed as logical deduction.

In logic programming, a program is a set of facts and rules13. For example, one writes that Socrates is a man and that all men are mortal, and then asks whether Socrates is mortal; the system searches for a proof13. The programmer does not specify how to compute the answer, only what is true1. This is the clearest case of declarative programming—a broad label for paradigms in which the programmer describes the desired result rather than the steps to achieve it1. Prolog's search mechanism, backtracking, tries alternatives and retreats when a path fails, which makes it well suited to problems such as parsing, symbolic reasoning, and constraint solving. Logic programming never became a mainstream general-purpose style, but it remains influential in artificial intelligence, databases (the query language Datalog descends from it), and program analysis.

Object-Oriented Programming: Bundling Data with Behavior

The fourth major paradigm arose from simulation. In the 1960s, Ole-Johan Dahl and Kristen Nygaard at the Norwegian Computing Center were building simulation programs for ships and other systems, and they found that the prevailing procedural style made it hard to model many interacting entities. Their answer, embodied in the language Simula 67, was to group data and the operations on that data into a single unit, the class, and to create objects—instances of classes—that could hold their own state and respond to messages.

Simula introduced the core ideas: encapsulation (hiding a class's internal data behind a public interface), inheritance (defining a new class in terms of an existing one, reusing and extending its behavior), and, in a limited form, polymorphism (the ability of different classes to respond to the same operation in their own way). These ideas were carried forward and popularized by Smalltalk, developed at Xerox PARC in the 1970s by Alan Kay and colleagues, which made objects and message-passing the whole of the language and introduced a graphical programming environment. The 1980s brought C++, Bjarne Stroustrup's extension of C with classes, which made object-oriented programming available to systems programmers; and the 1990s brought Java, whose design emphasized portability and whose class-based model became widely taught.

Object-oriented programming's claim was that large programs are best organized around the entities they model, with each entity responsible for its own data and behavior1. Its supporters found this convincing because it localized change: modifying one class need not disturb others, and inheritance allowed shared behavior to be written once1. The paradigm became the dominant organizing style for application software from the 1990s onward, though its critics argued that deep inheritance hierarchies can become brittle and that encapsulation is often honored in the breach.

Declarative and Multi-Paradigm Programming

The term declarative programming gathers the functional and logic traditions under one banner: the programmer specifies what is wanted—a function's value, a logical consequence, a database query—rather than how to compute it step by step1. The contrast with imperative programming is the oldest divide in the field. In practice the line is blurry: most functional languages allow controlled side effects, and SQL, the standard database query language standardized in the 1980s, is declarative in spirit while being executed by imperative machinery underneath.

As languages matured, designers stopped treating paradigms as exclusive. Multi-paradigm programming—supporting several styles in one language—became common1. Common Lisp (standardized in the 1980s) combined functional and imperative features and later added an object system; Python, created by Guido van Rossum in the late 1980s and released in 1991, mixed imperative, object-oriented, and functional features from the start; and languages such as Scala (2003) and later versions of Java and C# deliberately blended object-oriented and functional styles. The rationale was practical: different problems suit different organizations, and a language that permits several styles lets programmers choose.

The Present

Today the major paradigms coexist rather than compete for supremacy. Imperative and procedural programming remain the backbone of systems and application code; object-oriented design organizes most large software; functional programming's ideas—immutable data, first-class functions, composable abstractions—have been absorbed into mainstream languages and are central to distributed and concurrent systems; and logic programming persists in specialized domains such as databases, verification, and knowledge representation. The open questions are old ones in new dress: how to combine the safety of declarative reasoning with the control that imperative code provides, how to make concurrency tractable within each paradigm, and how much of a program's structure a compiler or type system can check before it runs. The history of paradigms is, in the end, a history of answers to a single question: what organization of a program makes it easiest to write correctly and to change with confidence.

References

  1. Programming paradigm (introduction, Assembly, Procedural languages, History, Declarative languages, Overview, Object-oriented programming), Wikipedia
  2. Structured program theorem (introduction, Origin and variants), Wikipedia
  3. Program structure tree, Wikipedia
  4. Imperative programming (History of imperative and object-oriented languages), Wikipedia
  5. Structured programming (History, introduction), Wikipedia
  6. Procedural programming, Wikipedia
  7. Lambda calculus (introduction, History), Wikipedia
  8. Functional programming (introduction, History), Wikipedia
  9. Declarative programming, Wikipedia
  10. Assignment (computer science), Wikipedia
  11. Generic programming, Wikipedia
  12. Logic programming (History), Wikipedia
  13. Prolog, Wikipedia

The frameworks of Programming Paradigms

Each framework is a way of working the field has used: when it held, and the question it answers.

  1. 1957-Present

    Imperative programming

    How does the machine change state step by step?

    Fly to its tower in Nousfarer

  2. 1958-Present

    Functional programming

    How can computation be built from pure functions?

    Fly to its tower in Nousfarer

  3. 1966-1990

    Structured programming

    How should control flow be structured to be readable?

    Fly to its tower in Nousfarer

  4. 1967-Present

    Object-oriented programming

    How should programs model interacting entities?

    Fly to its tower in Nousfarer

  5. 1970-Present

    Declarative programming

    How can a program state what rather than how?

    Fly to its tower in Nousfarer

  6. 1970-Present

    Procedural programming

    How should a program be decomposed into procedures?

    Fly to its tower in Nousfarer

  7. 1972-Present

    Logic programming

    How can computation be expressed as logical deduction?

    Fly to its tower in Nousfarer

  8. 1980-Present

    Multi-paradigm programming

    Can one language support several styles at once?

    Fly to its tower in Nousfarer

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.

Imperative programmingFunctional programmingStructured programmingObject-oriented programmingDeclarative programmingProcedural programmingLogic programmingMulti-paradigm programming

Beyond the field

Where Programming Paradigms's ideas came from in other fields, and what they led to there: the strongest 12 of 45 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.

Programming Paradigms is a planet in Nousfarer

Its city has a tower for each of these 8 frameworks. Land, walk in, and climb one concept at a time.

Land on Programming Paradigms

Related fields

Fields its ideas are linked to

More in Programming Languages

See where Programming Paradigms sits on the Map of Human Knowledge