Most of articles and source code on this site are parts of older programs and documents that I decided to use here for demonstration purposes. The articles are not intended to be comprehensive, but an introduction to ideas and concepts related to the topics. If you have any questions or comments, feel free to contact me at jimsmith@engineerjames.com .

After writing software for some years I realized that engineering practices in just about every domain emerge from the same objectives, reuse of components within and outside the application domain this implies the second which is compatibility with other systems that may not be an obvious client of a particular component at its current stage of development. Components in an application are only what they are by agreement. One component can play different roles in several applications or domains. A third design objective I would like to mention is scalability which is the ability of a component to efficiently increase or change its functionality.

Reuse of software comes in more than one flavor, software developers that are new to the idea may apply the wrong technique to accomplish component reuse. My personal experience has shown me that more experienced developers that used development methods that did not promote reuse or intend to promote reuse still could not write code that benefited from the tools and programming languages that were designed to implement reusable system components. The reason for this is that developing for reuse is not language dependent it is a design consideration and that implies a thought process geared toward reusable systems. Designing for reuse is not trivial.

Reuse in software development refers to the reuse of binaries through a service/object oriented design. Each component should be designed in such a way that its internal interface is condensed, causing any interaction with its outside world to occur within fixed margins. Reuse can be accomplished within a single application, client/server and distributed systems. All implementation will use the same high level approach:


* Create components that implements a portion of system functionality

* Make each component as independent as possible without using redundancy

* Define what the component does exactly and how it is used

* Combine components to create new components when possible instead of writing new components from scratch

A component should seal in a facet of the system's implementation at specific levels of functionality. Reuse depends on the components having enough granularity to allow decomposition of the system at small functional intervals. An example would be a electronic circuit, each component in the circuit is isolated enough to be removed and interrogated outside of the circuit. After we accomplish this we need to consider how these components can be configured and combined to meet needs that are not part of the current application or even the domain.