Why is the UNIX / functional style of composing and injecting smaller functions so much rarer than the Beck/Fowler/Bob refactor-to-objects style when it comes to writing maintainable, "beautiful" software?
In my private projects, I tend to write small functions that do one or perhaps two things, which I later compose into larger functions that form my API(s). Here, I try to inject dependencies either by higher order functions, or smaller interfaces, just so that I can keep track of side effects (as this is usually where I find my bugs).
I find this approach very nice, especially if I can name modules sensibly.
However, whenever I study design and architecture, the vast majority of books / courses / articles tend to fall into the Kent Beck, Martin Fowler, Bob Martin type of approach where everything eventually becomes an object.
Is this better (maintainability, reliability, easy to change) than just writing procedural code with the same level of care, testing and refactoring as the "refactor to objects" crowd?
To me, it seems that SLOC explodes, and now there's a new layer of complexity needed to handle the lifetimes of all the new allocations that weren't there before. The tangible improvement in before-and-after examples tend to be the removal of anti patterns and code smells rather than reinventing Smalltalk wherever possible.
I have only been working professionally for three years, so I assume that I'm missing the forest for the trees here.