In Part 2, we discussed Modularity and Abstraction. In this article, we explain how Anticipation of Change, Generality and Incremental Development help in successful Software Engineering.
Anticipation of Change
Software, even when it is developed and commissioned for production, undergoes changes. When there are changes, additional costs will be incurred. A design goal in software development is to ensure cost is kept to a minimum. One approach is to anticipate where changes are likely to occur and make provisions for the changes during the design stage. We need to provide tools for storing and retrieving documents, and for managing source code and object code. These tools must also be worked into the overall configuration management of a system. Besides, as part of the anticipation of change exercise, human resource management must be taken into consideration. Staff turnover is likely and managers should consider the impact such events have on the overall software system’s maintenance.
Before starting off on a new software development project, a software engineer should always consider what might be the underlying, hidden general problem that requires the solution. The general problem may not be as complex as the original problem and there may also be a ready-made solution that is capable of satisfying the requirements.
To illustrate, suppose you are asked to develop a taxonomy system. Categories for the taxonomy have earlier been defined and given to you. You are required to provide a sophisticated search facility that is able to search into the meta-data (such as the title, creator of document, date of creation, last modified date, and document type) and contents of the documents in the taxonomy. You may be tempted to build a customized solution but it may be better for you to consider what the underlying general problems might be before you embark on the software construction process. A quick survey of this problem reveals the need to develop three facilities: Text processing facility including search; Document filtering facility (to process the different document types); Presentation facility (to illustrate the taxonomy as a tree-based structure). These facilities are certainly not new and may have already been developed and archived in some libraries. If so, they are likely to be well-tested and more stable than if you had to start on your own from the beginning.
Instead of developing these facilities from scratch, you might want to examine how the archived solutions might help you in this problem. This, in a nutshell, highlights the essence of the generality principle which encourages software reuse. However, a generalized solution may be more costly, in terms of speed or execution, memory requirements, or development time, than a specialized solution that is tailored to the original problem. Software engineers therefore have to evaluate how this trade-off may affect the overall cost and efficiency of the development project.
It is not always possible in a software development project to know all the functional requirements in the beginning. With only partial requirements available, systems are often built on a piecemeal basis, incrementally adding on to the whole as more information is available.
The principle of incremental development can be applied to situations where it is unclear how the functionalities of a system match up to the needs and expectations of customers. By developing an initial subset of the application for experimentation by customers, valuable feedback on the usefulness of the application can be gathered. Consequently, improvements based on the feedback are made to the application Through an iterative process of continuously seeking improvements to the application the final system can be produced.
Incremental development is evolutionary. Each stage of the application development has changes that are improvements to the previous increment. Changes must therefore be anticipated in the design of the solutions.
Documentation and the management of documentation are crucial to the success of a project. Without proper documentation, incremental development can be problematic, and there can be only problems when trying to respond to the inevitable changes.
This post is part of the series: Software Engineering Principles
- Seven Strategies for Successful Software Engineering: Part 1
- Seven Strategies for Successful Software Engineering: Part 2
- Seven Strategies for Successful Software Engineering: Part 3