I always heard it called
Modular Programming, but then again, I am old, and predate object oriented programming.
The idea was that your main logic calls modules that do things, and only keeps track of the variables/values it needs to do the higher level logic, keeping the nitty gritty inside the modules. This way you could completely replace the module later, and not break the rest of the program.
This required you to be rigorous with your containment and implementation of your modules. (As opposed to the pejoratively named alternative, which was "Spaghetti Code.")
I have seen the same basic idea carried over into OOP, and then extended. To me, the main feature of OOP is the object hierarchy model, which basically treats things as if they were giant arrays with lots of disparate members. For some things, this is quite handy. For others, (especially for object classes that lack good documentation) it makes the object into a black box that rattles a little when you shake it.*
*I dont know how many times I have had to probe the shit out of an object's heirarchy and manually document its members and sub-members. (Granted, I was using the VBA interface for a CAD program, and I was probing undocumented objects not listed in the developer's documentation to learn how to make use of them. The programming interface treated all the CAD operations as objects, with all the options for the operations as members in their hierarchies. I needed to know what and where to poke to programatically alter CAD files for automation tasks.)
My first experiences with it (again, because I am old, and have seen the entire computer revolution from the 80s onwards) were in implementing actually sane programs in the various flavors of BASIC that were baked into really old computers. Your main routine could be very short and sweet, but call subroutines like they were modules, and pass variables as needed. Using GOSUB instead of GOTO saved you a great deal of problems-- GOTO principally used line numbers, and those could change as you modified programs, causing all kinds of chaos. (later incarnations let you use a label instead of a line number, but the result was still ugly.)