Algorithmic Decomposition Versus Object-Oriented Decomposition
Traditional programming techniques have used algorithmic decomposition. Algorithmic or functional decomposition views software as a process. It decomposes the software into modules that represents steps of a process. These modules are implemented by language constructs such as functions in C. The data structures required to implement the program are a secondary concern, which is addressed after the project has been decomposed into functional modules.
Object-oriented decomposition views software as a set of well-defined objects that model entities in the application domain. These objects interact with each other to form a software system. Functional decomposition is addressed after the system has been decomposed into objects. An object is an entity that performs computations and has a local state. It may therefore be viewed as a combination of data and procedural elements.
Object-oriented approach is a method of implementation in which
1) Objects are the fundamental building blocks.
2) Each object is an instance of some type or class.
3) Classes are related to each other by inheritance relationships.
The principal advantage of object-oriented decomposition is that it encourages the reuse of software. This results in flexible software systems that can evolve as system requirements change. It allows a programmer to use object-oriented programming languages effectively. Object-oriented decomposition is also more intuitive than algorithm-oriented decomposition because objects naturally model entities in the application domain.
Object-oriented design is a design strategy where system designers think in terms of ‘things’ instead of operations or functions. The executing system is made up of interacting objects that maintain their own local state and provide operations on that state information. They hide information about the representation of the state and hence limit access to it. An object-oriented design process involves
designing the object classes and the relationships between these classes. When the design is realised as an executing program, the required objects are created dynamically using the class definitions.
Object-oriented systems should be maintainable as the objects are independent. They may be understood and modified as stand-alone entities. Changing the implementation of an object or adding services should not affect other system objects. Because objects are associated with things, there is often a clear mapping between real-world entities (such as hardware components) and their controlling objects in the system. This improves the understandability and hence the maintainability of the design.
The two approaches are similar in that both believe that the way to develop a complex system is by using the philosophy of divide-and-conquer; that is break up a complex software design project into a number of simpler subprojects, and then tackle these subprojects individually. The two approaches disagree on how a project should be decomposed.