Software engineering is the practical craft and applied science of designing the programmatic nuts, bolts, and assemblies that will be coded into an executable program. This discipline lies between high-level solution architecture and coding.
Objects Oriented Analysis (OOA) - In software engineering, OOA is the process of recognizing what objects will need to implement architecture. Often, a software engineer is responsible for designing classes that have a technical purpose at a lower level of abstraction than business objects. Database connection objects are an example.
Objects Oriented Design (OOD) - Objects are instances of classes. Classes have interfaces that define properties and methods, plus code. Classic object models call for modularity through encapsulation, polymorphism, multiple inheritances, Object oriented design has to do with designing class templates, interfaces, and arranging object relationships.
Component Oriented Design (COD) - Component Oriented design addresses the need for bundles of objects related by coincidence into a single container. In particular, components are handy for distributed computing.
When a component is intended to be instantiated on the same machine that will use it, the component interface generally exposes object interfaces directly. But, if the component will be distributed and accessed over a network, its interface is designed to minimize network traffic.
Practical Considerations for Network Computing - Classic OO can work, but perform miserably in distributed computing. The issue has to do with the amount of network traffic ('round trips') generate by accessing objects.
For each property or method that is accessed, at least one round trip occurs - that is in addition to the round trip to instantiate the object! For that reason, distributed components, such as those for MTS and DCOM, are usually designed to pass data and call methods in the least number of round trips.
Generally, designing objects with traditional interfaces and bundling those objects into components with interfaces optimized to minimize round trips will address this issue. Within the component, there is a control procedure that manages the objects, coordinates execution, and handles the exposed interface.
In effect, the component functions as a sort of batch processor. Knowledge and experience are the key factors in creating high-performance distributed applications.
Fragile Hierarchy Syndrome - When designing objects that inherit from other objects and especially in the case of multiple inheritance, structures and relationships can result that create a tangled web of dependencies - this is fragile hierarchy syndrome.
The best rule is to avoid hierarchies with a depth greater that three. Also, there should be truly compelling reasons to use multiple inheritances. Knowledge and experience are the key factors in creating high-performance distributed applications.