In this post, I just examine how OO can be argued to result in better resource utilization. Resource here is the software programmer/developer. we may be able to use them parellaly without much complications and overheads if we adopt OO. Resource's specific skills are effectively used too.
If the software system to be developed is very extensive, containing a lot of modules, we will have to adopt certain strategies to make the process convenient and faster enough.
say for example if the total system contains 1 million lines of code, line 1 to the last line sequentially typing is impossible, obviously. In order to get out of this mayhem we may go for structured or object oriented programming. we may partition them to Modules/components and will assign to different people to get the work done in a parallel fashion. Later we will integrate these parts together to form the total system. One effective technique here to conceptualize components with interfaces specified, and then to assemble them together once materialized.
The car maker's example:
This carmaker only manufactures the metal body. He get components like dashboard, windscreen etc from other suppliers as specified by him [read.. interface specification!]
He then assembles them to form the final Car.
vendor A: supplies windscreen-as per the specifications my car maker
vendor B: supplies dashboard as specified by carmaker
vendor C: he is big guy, he makes engine/power train as per the published specification, so our car maker got a copy of the specification and made the car-body etc accordingly.
vendor D: He supplies lights, shades etc.
This way other vendors as well supply a lot many things necessary for the 'final car'.
What makes this possible.
I would say "Specifications".... ie, INTERFACES
interface dashboard
{
length=100 units,
width=10 units,
color=transparent,
}
OR
interface engine
{
accelerate(),
decelerate(),
kill(),
}
Some form of specifications makes it possible to stick them together as a whole unit, to perform with data passed in between them.
- Advantage I notice here is the effective utilization of resources and their expertise in one realm.
- Also the process is parallel, cutting down the time for delivery
These two things are quite different aspects of OO-other than reducing complexity (earlier described).
So
- Mans inability to manage greater levels of complexity,
- Time loss due to sequential processing,
- Inadequate use of resource (developer) expertise
are addressed effectively through object orientation or with the use of interfaces.
--let me coin the word--->Component based/interface based programming.
Again, please don’t misunderstand that Object Orientation is the only methodology that addresses these. There are other paradigms which addresses these and more or less successful but OO has the significant advantage over others as it matches how we see & manages things in a real life scenarios, like an assembly line.
to summarize
- confirm to specifications while creating components
- parellely create them
- assemble them together
