In the first part I made the case that paradigms are ways of thinking, not teams to join. This is where that gets concrete — because in real code you almost never write in a single paradigm. You mix them, usually without announcing it, and the skill that actually matters is choosing the right one for each part of the problem.
The multi-paradigm reality
Here's what the tutorials rarely say plainly: the industry settled the paradigm wars by refusing to pick a winner. Modern languages are deliberately multi-paradigm. Scala, Kotlin, even C++ let you write object-oriented and functional code side by side. The mainstream ones absorbed each other's best ideas — Java, once the poster child for rigid OOP, grew lambdas and streams; Python was multi-paradigm from day one. A typical file today has objects modelling the domain, functional-style transformations over collections, and plain imperative steps holding it together. Nobody flags which is which, because it doesn't matter — each part uses whatever fits.
How the mixing actually looks
A shape you'll see constantly: objects for structure, functions for behaviour. You model the nouns of your system as objects — a user, an order — because they have identity and state worth bundling. Then you process them with functional-style pipelines: map, filter, reduce, no mutation, easy to test. And underneath, imperative code does the unavoidable step-by-step work of talking to a database or a network. That's three paradigms in one function, and it isn't a mess — it's each tool doing the job it's best at.
The judgment is in the seams. Reach for objects when identity and encapsulation help. Reach for functional pipelines when you're transforming data and want no surprises. Drop to plain imperative when the task genuinely is a sequence of side effects. Getting those choices right is most of what makes code readable to the next person.
Declarative and reactive, where they fit
Two more worth naming, because they show up more than beginners expect. Declarative styles — SQL, configuration, query builders — win whenever you can describe the what and let a well-built engine handle the how; you'll almost always regret hand-rolling what a declarative tool gives you for free. And reactive or event-driven approaches suit systems that respond to streams of things happening over time — UI events, message queues, live data. You don't choose these on ideology; you choose them because the problem is shaped that way.
The skill underneath all of it
Strip it back and the meta-skill isn't mastering any single paradigm. It's building a mental library of them and developing the taste to reach for the right one without thinking too hard. That taste comes from writing code in each style long enough to feel their failure modes — the OO hierarchy that metastasised, the functional gymnastics forced onto a stateful problem, the imperative sprawl that should have been a three-line pipeline.
That's the honest end of a paradigms series. There's no destination where you become "a functional programmer" or "an OO programmer" and stop. There's just a growing set of lenses, and the steady, unglamorous skill of knowing which one to look through for the problem in front of you. The paradigm was never the point. The problem is.
