Code Reuse
Code reuse and code generation tools produce more robust code and are preferable to writing code by hand. Existing code
has often already been tested and even deployed, making it more stable and well understood than new code. Source code
created from a code generation tool (such as a visual modeling tool) automates dreary coding tasks such as creating
getters and setters.
There are many places to harvest code for reuse:
-
Internal (corporate) code libraries.
-
3rd party libraries.
-
Built-in language libraries.
-
Code samples from tutuorials, examples, books, etc.
-
Local code guru or knowledgable colleague
-
Existing system code
-
Open source products (be sure to follow any licensing agreements)
Transforming the Design into the Implementation
Transforming the design into code implements the system structure in the chosen source language. It also implements the
system behavior defined in the functional requirements. Implementing the system behavior means writing the code that
allows different parts of the application (classes or components) to collaborate in realizing the behavior of the
system.
There are various techniques for automatically transforming design to implementation. Here are some examples:
-
Platform-specific visual models can be used to generate an initial code framework. This framework can be further
elaborated with additional code not specified in the design.
-
Models can be detailed and used to generate an implementation. Both structure (class and package diagrams) and
behavior diagrams (such as state and activity diagram) can be used to generate executable code. These prototypes
can be further refined as needed.
-
The design may be platform independent to varying degrees. Platform specific design models or even code can be
generated via transformations that apply various rules to map high level abstractions platform specific elements.
This is the focus of the Object Management Group (OMG) Model Driven Architecture (MDA) (http://www.omg.org) initiative.
-
Standard patterns can be applied to generate design and code elements from related design and implementation. For
example, a standard transformation pattern can be applied to a data table to create java classes to access the data
table. Another example is using an Eclipse Modeling Framework (http://www.eclipse.org/emf/) model to generate code for storing data that matches the model and
to generate a user interface implementation for populating data. A pattern or transformation engine can be used to
create the implementation, or the implementation can be done by hand. Pattern engines are easier and more reliable,
but hand-written code implementing a defined pattern will have fewer errors than hand-written code implementing a
novel or unique design.
In all cases, however, some design abstraction (classes, components, etc) is detailed to become the
implementation.
|
