|< Free Open Study >|| |
The design of applications is an important aspect of the project lifecycle, but one that is often neglected. When we design an application we should aim to enhance the following features:
Let's now take a closer look at each of these aspects of design.
Maintainability describes the amount of effort required to keep an application running correctly. Obviously, in a commercial sense, more maintenance means more time and more money spent. In reality the maintainability of an application is difficult to quantify, but there are techniques that we can use to increase the maintainability of a system.
So what aspects of the application need to be maintained? First of all there is the source code itself. An undocumented, unstructured, and badly-formatted body of source code will be harder to maintain than documented code with a clearly-defined structure. If we make code easy to follow and understand, debugging and code modification usually become faster and easier too. As an example, trying to maintain a very large method that performs a lot of processing will be much more complex than trying to maintain a collection of shorter methods that achieve the same result.
The structure of the application also plays an important part. Designing a meaningful, logically partitioned application will greatly increase the maintainability of the application. In a typical application there might be several distinct parts; for example the user interface, classes that perform business processing, and classes that represent business entities. Introducing structure and making a distinction between these types of classes will increase the maintainability because it will be more apparent to developers how the pieces of the application fit together. Although creating neatly formatted source code is undoubtedly important, knowing how to quickly find the piece of functionality that needs to be fixed is just as important.
One of the goals of OO design and implementation is to strive for reusable components. Reusability is enhanced when a class has a low reliance on other objects, or low coupling, and provides a specialized set of tasks, or high cohesion.
Some degree of reusability is achievable without design, but thinking about the structure beforehand will help to ensure that the classes that we create are reusable across the application. Stepping back to look at the big picture will help in identifying those places in the system where functionality can be reused later if we wish to modify or enhance the application.
Changes in the business require changes in software. The extensibility of our software determines how much can it be extended and enhanced after it has been put into production use.
Ideally, we would like to add functionality to an application without altering the original code - much as we extend existing Java classes.
A good design will attempt to take extensibility into account. Of course it's impossible to foresee every eventual circumstance, such as a drastic change in the business, or other major changes in functional requirements. We can often enhance extensibility by logically partitioning the application into smaller parts, reducing the impact of changes on other parts of the system.
|< Free Open Study >|| |