How languages want you to think
A programming paradigm is the underlying philosophy of how you structure code. The four classic families are procedural, object-oriented, functional and logic, with concurrent models layered on top. This reference lists major languages with their primary paradigm, typing discipline and origin year so you can see how each one expects you to organise a program.
The paradigms explained
Procedural
Procedural code is a sequence of instructions that operate on shared data. You call functions, modify variables, and control flow with loops and conditionals. C is the canonical procedural language, and its influence is visible in Go, which adopts the same top-to-bottom readability but adds goroutines for concurrency. Most programmers learn procedural style first because it mirrors how a computer actually executes instructions.
Object-oriented
Object-oriented programming bundles state and the behaviour that acts on it into objects. The key concepts are encapsulation (hiding internal state), inheritance (extending behaviour), and polymorphism (different objects responding to the same message differently). Java made OOP ubiquitous; Ruby pushed it further by making everything — including integers and classes — an object. C# and Kotlin blend OOP with modern type systems that catch more errors at compile time.
Functional
Functional programming treats computation as the evaluation of pure functions: given the same inputs, a function always returns the same output and causes no side effects. Immutability and first-class functions (functions passed as arguments, returned from other functions) are the core tools. Haskell enforces purity strictly; Clojure, Elixir, and F# are functional-first but pragmatic. Even JavaScript and Python have absorbed map, filter, and reduce because functional style makes certain kinds of data transformation cleaner and more testable.
Logic
Logic programming inverts the control model entirely. In Prolog, you state facts and rules and then ask queries; the engine uses backtracking to find answers. You describe what is true, not how to compute it. Logic programming never became mainstream for general application development, but it remains influential in areas like constraint satisfaction, parsing, and AI reasoning.
How it works
Paradigms describe the dominant style a language encourages, though most languages support several. The broad map:
Imperative → Procedural (C, Go) · Object-oriented (Java, Ruby, C#)
Declarative → Functional (Haskell, Clojure, Elixir) · Logic (Prolog) · Query (SQL)
Concurrent → Actor model (Erlang, Elixir) · CSP (Go)Procedural and OOP code is imperative — you spell out how to compute a result. Functional and logic code is declarative — you describe what the result is and let the runtime work out the steps. The filter searches names, paradigms and typing so you can compare languages at a glance.
Choosing a paradigm for a problem
Paradigm choice is partly language choice, but within a multi-paradigm language you still make decisions. Use object-oriented style when you have a set of entities with distinct state and behaviour — a game, a UI framework, a domain model. Use functional style when transforming collections of data — pipelines, reports, event streams. Use procedural style when control flow is simple and performance is critical. Mix as needed: most real programs use all three within different layers.