Functional programming is a declarative paradigm that treats computation as the evaluation of mathematical functions. Rather than describing step-by-step procedures that mutate state, functional programs describe what the result should be, letting the runtime determine how to compute it. Languages such as Haskell, Erlang, Clojure, and F# are primarily functional, while many mainstream languages now incorporate functional features. The paradigm emphasizes immutability, pure functions, and the avoidance of side effects, standing in contrast to imperative programming, which uses loops, mutations, and explicit control flow to describe how a task is performed.
A pure function always returns the same output for the same input and has no observable side effects. The simple addition function \( a + b \) is pure: given the same arguments, it always yields the same result, and it does not modify any external state. By contrast, a function like \( \text{Math.random}() \) is impure because its output varies and because the act of calling it interacts with a global random state. Purity gives rise to referential transparency, the property that any expression can be replaced by its value without changing the program's behavior, which enables equational reasoning, aggressive compiler optimizations, and dramatically simpler testing — there is no need to set up or tear down external state, no mocking of dependencies, and tests are independent and can run in parallel.
Side effects are any observable changes a function makes beyond returning a value: modifying global or external variables, writing to files or databases, printing to the console, making network requests, or mutating input arguments. Functional programming aims to isolate side effects from core logic rather than eliminate them entirely, since real programs must eventually interact with the outside world. Immutability complements this goal by ensuring that once a data structure is created, it cannot be changed; instead of mutating data, programs create new copies with the desired modifications. This combination of purity, isolation of effects, and immutability is the cornerstone of functional design and brings benefits such as easier reasoning about code, thread safety without locks, and simpler debugging.