- Atlas
- Computer Science
- Programming Paradigms
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
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
- Programming paradigm (introduction, Assembly, Procedural languages, History, Declarative languages, Overview, Object-oriented programming), Wikipedia
- Structured program theorem (introduction, Origin and variants), Wikipedia
- Program structure tree, Wikipedia
- Imperative programming (History of imperative and object-oriented languages), Wikipedia
- Structured programming (History, introduction), Wikipedia
- Procedural programming, Wikipedia
- Lambda calculus (introduction, History), Wikipedia
- Functional programming (introduction, History), Wikipedia
- Declarative programming, Wikipedia
- Assignment (computer science), Wikipedia
- Generic programming, Wikipedia
- Logic programming (History), Wikipedia
- 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.
- 1957-Present
- 1958-Present
Functional programming
How can computation be built from pure functions?
- 1966-1990
Structured programming
How should control flow be structured to be readable?
- 1967-Present
Object-oriented programming
How should programs model interacting entities?
- 1970-Present
- 1970-Present
Procedural programming
How should a program be decomposed into procedures?
- 1972-Present
Logic programming
How can computation be expressed as logical deduction?
- 1980-Present
Multi-paradigm programming
Can one language support several styles at once?
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.
Structured programming grew out of Imperative programming
Structured programming arose as a direct response to the unstructured control flow (arbitrary GOTO jumps) that characterized early imperative programs. Dijkstra's 1968 letter 'Go To Statement Considered Harmful' attacked the prevailing imperative practice and proposed restricting control flow to sequence, selection, and iteration.
Carried by Edsger W. Dijkstra; Go To Statement Considered Harmful (1968); Corrado Böhm.
Object-oriented programming grew out of Imperative programming
Object-oriented programming arose from simulation work that found the prevailing procedural/imperative style inadequate for modeling many interacting entities. Simula 67 grouped data and operations into classes and objects, defining itself against the step-by-step statement model.
Carried by Ole-Johan Dahl; Kristen Nygaard; Simula 67 (1967).
Declarative programming reacted against Imperative programming
Declarative programming defined itself against the imperative model of step-by-step statements that change machine state. The declarative label was coined to contrast with imperative programming, describing programs that state what is wanted rather than how to achieve it.
Declarative programming influenced by Functional programming
Declarative programming as a broad label drew on the functional tradition's emphasis on describing what a function computes rather than how, and on logic programming's statement of facts and rules. The functional and logic paradigms supplied the concrete models of 'what' rather than 'how' computation.
Carried by John McCarthy.
Multi-paradigm programming influenced by Functional programming
Multi-paradigm programming incorporated functional features such as first-class functions and immutable data alongside other styles. Mainstream languages absorbed functional constructs, making functional programming one of the paradigms combined in multi-paradigm designs.
Multi-paradigm programming influenced by Object-oriented programming
Multi-paradigm languages such as C++ combined object-oriented classes with procedural and other styles, making object orientation one of the paradigms a single language could support. The rise of C++ in the 1980s exemplified the multi-paradigm approach.
Carried by Bjarne Stroustrup; C++.
Logic programming rival of Functional programming
Functional and logic programming were contemporary research traditions that both sought to make programs mathematical and declarative, but they competed as alternative foundations: functions and application versus facts, rules, and proof search. Neither grew out of the other.
Carried by John McCarthy; Alain Colmerauer; Robert Kowalski.
Multi-paradigm programming influenced by Structured programming
Multi-paradigm programming absorbed the structured-programming discipline of control flow and decomposition as one component among several. Languages designed to support multiple styles retained structured control constructs as a baseline.
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.
Functional programming influenced by Lambda calculus in Pl Semantics
Church's lambda calculus supplied the formal core of functional programming: function abstraction and application, and the notion that computation is evaluation of expressions, taken up by Lisp's designers.
Carried by Alonzo Church; John McCarthy.
Functional programming influenced by Lambda Calculus in Computability
The computability-theoretic lambda calculus provided the reduction and substitution model that functional languages implement; McCarthy's Lisp drew directly on it as a notation for functions.
Carried by Alonzo Church; John McCarthy.
Object-oriented programming influenced Object-oriented and object-relational databases in Databases
Object-oriented databases adopted the object-oriented programming paradigm's core notions of objects, classes and inheritance and extended them with persistence and transactions. The paradigm provided the conceptual vocabulary of the database models.
Object-oriented programming influenced Object-Oriented Analysis in Requirements Engineering
Object-oriented analysis took the object, class and inheritance concepts of object-oriented programming, including the Simula and Smalltalk lineage, and applied them at the analysis level. The analysis methods were explicitly modelled on the programming paradigm.
Carried by Sally Shlaer; Stephen Mellor; Grady Booch.
Object-oriented programming influenced Object-Oriented Analysis and Design in Systems Analysis And Design
The object concept originated in the 1960s with Simula's class-based simulation language and Kristensen and Dahl's work, which established objects, classes and inheritance. These programming-language ideas were the direct source of the object model that OO analysis and design methods later formalised.
Carried by Simula 67 (1967); Ole-Johan Dahl; Kristen Nygaard.
Object-oriented programming influenced Object-oriented data modeling in Data Modeling
The earlier object-oriented programming tradition (Simula 67, Smalltalk) supplied the object, class and inheritance concepts that object-oriented data models adopted for persistence. Object-oriented data modeling is essentially OOP concepts applied to database schemas.
Carried by Simula 67; Smalltalk.
Logic programming led to Deductive database in Computational Logic
Deductive databases are a branch of logic programming, using its rule-based declarative style with database-oriented restrictions. The paradigm passed directly into Datalog and deductive database systems.
Carried by Alain Colmerauer; Robert Kowalski.
Logic programming influenced Probabilistic Programming in Probabilistic Ai
Probabilistic programming grew directly out of logic programming: the probabilistic logic programming line (PRISM, ICL, ProbLog) added probabilities to Prolog-style clauses, and Church and Anglican carried the same declarative-program-as-model idea into functional and Lisp settings. The slogan that a probabilistic program is a probability model executed by inference comes from this tradition.
Carried by ProbLog; Church (2008).
Logic programming led to Deductive databases and Datalog in Database Theory
Datalog is a restricted form of the logic programming paradigm; deductive databases adopted its clause-based representation and resolution/fixpoint evaluation as their foundation.
Logic programming led to Answer Set Programming in Knowledge Representation Reasoning
ASP is a branch of the logic programming paradigm, reusing its rule-based syntax and declarative reading while replacing Prolog's procedural semantics with stable-model semantics.
Imperative programming influenced Navigational data models in Nosql Systems
Navigational database APIs were imperative: programs navigated record by record with currency indicators and explicit find/get calls, so the data model presupposed imperative control flow. CODASYL DBTG specifications codified this style.
Carried by CODASYL Data Base Task Group Report (1969).
Imperative programming led to Object-oriented programming in Software Engineering
Object-oriented programming grew out of imperative programming: Simula 67 extended Algol's imperative statements with classes and objects, and Smalltalk and C++ kept assignment and control flow as the operational core.
Carried by Simula 67 (1967); Ole-Johan Dahl; Kristen Nygaard.

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 ParadigmsRelated fields
Fields its ideas are linked to
- Programming Languages 8 links
- Language Design 7 links
- Software Engineering 7 links
- Design Patterns 3 links
- Knowledge Representation Reasoning 2 links
- Databases 2 links
- Logic 2 links
- Probabilistic Ai 1 link
- Computer Animation 1 link
- Data Modeling 1 link
- Database Theory 1 link
- Nosql Systems 1 link
More in Programming Languages
- Compiler Design
- Concurrency Models
- Language Design
- Pl Semantics
- Program Analysis
- Programming Languages
- Type Systems
See where Programming Paradigms sits on the Map of Human Knowledge