Programming Paradigms

Choosing a programming paradigm is a design decision that shapes how you model state and behavior, how you reason about concurrency, and how you operate software in production. The goal is not to be dogmatic but to be intentional: select a dominant style per component, then mix paradigms at boundaries where it improves clarity or operability. Tie your choice to explicit quality attributes (e.g., latency, throughput, safety, evolvability) and the surrounding system semantics.

At a glance, you can think of paradigms as lenses for structuring computation:

Procedural/Structured emphasizes clear control flow and localized mutation—great for I/O orchestration.
Object‑Oriented centers on encapsulated domain behavior and stable interfaces.
Functional favors pure transforms and immutability for correctness and parallelism.
Event‑Driven & Reactive models asynchronous streams, backpressure, and temporal coupling.
Declarative & Logic states the “what” (rules, queries) instead of the “how”.
Actor Model isolates state behind message boundaries with supervision.

Use the quick decision aid below to pick a default and then refine based on the component’s responsibilities, team expertise, and runtime constraints. Keep the broader architecture in view: connector choices, backpressure, idempotency, and failure modes often matter more than syntax or language features.

A vertical decision aid to select a dominant paradigm per component.

What you’ll take away

How to choose a paradigm against constraints (latency, throughput, safety, changeability)
Where it fits in your architecture: connectors, backpressure, idempotency, supervision
Trade‑offs and review cues to avoid over‑abstraction and accidental complexity

📄️ Influence of Programming Paradigms on Architecture

How paradigm choices shape boundaries, data flow, concurrency, and operations—and how to choose wisely.

📄️ Object-Oriented Programming

Explore Object-Oriented Programming (OOP), a paradigm for modeling systems as collections of collaborating objects.

📄️ Declarative & Logic Programming

"In a declarative system, you don't tell the computer what to do. You tell it what you want."

📄️ Event-Driven & Reactive

Event-Driven Architecture (EDA) is a paradigm where systems respond to events—immutable facts about something that has happened. Producers publish events without knowing who will consume them, enabling loose coupling and asynchronicity. Reactive programming is a related paradigm that focuses on composing asynchronous and event-based programs with observable streams, providing tools for managing backpressure and complex data flows.

📄️ Dataflow & Stream Processing

Dataflow programming is a paradigm that models a program as a directed graph of data flowing between operations. Stream processing applies this model to unbounded, continuous streams of data, treating data not as a static collection but as a series of events in motion. It's the foundation for real-time analytics, large-scale event processing, and reactive systems.

📄️ Aspect-Oriented Programming

Learn about Aspect-Oriented Programming (AOP), a paradigm for modularizing cross-cutting concerns like logging and security.

📄️ Actor Model

The Actor Model is a mathematical model of concurrent computation that treats "actors" as the universal primitives of a system. An actor is an independent computational entity that communicates with other actors exclusively by exchanging messages. Each actor has a private state, which it can modify only in response to a message, and a mailbox to buffer incoming messages. This model provides a powerful foundation for building highly concurrent, distributed, and fault-tolerant systems.

📄️ Functional Programming

Pure functions, immutability, and composition for correctness, concurrency, and testability.

📄️ Procedural / Structured Programming

Disciplined control flow for linear workflows and I/O orchestration; strengths, trade-offs, and when to use.