Development Methodology

The development phases outlined in "The Software Development Process" are
just the broad categories of tasks that need to be undertaken. The methodology
outlines all the potential tasks that a software project might need. It is
important, however, for the project manager to tailor these tasks according
to the needs of the particular project.

Analysis Phase

This phase attempts to define what it is that is required. It should avoid any
attempt to constrain the design; we want all options open to the designers so
they can come up with the best solution.

The analysis phase tasks include preparing a vision statement, preliminary
analysis, feasibility studies, modelling of existing systems, and requirements
gathering. For most real world projects there will also be some sort of approval
process to get the funding for the development.

Design Phase

The design phase starts with the software architecture and steadily refines the
design until it is ready to be handed to the programmers. The level of detail
required is highly dependent on the nature of the project. For a small project
in a well defined environment you could do the whole thing around a white board
in a few hours. At the other extreme it could take a large team many months and
produce a huge amount of documentation.

The design tasks includes developing the software architecture, planning the
migration from existing systems, developing the interfaces between the components
of the system (and to external systems), exploring the capabilities and limitations
of the proposed COTS products, defining the test strategy, creating a data dictionary,
creating use case and class diagrams, designing the user interfaces, designing support
for testing, designing the persistent storage, and designing any code generation
utilities that are required.

In parallel with the design tasks, it will also be necessary to set up the
development and testing environments, procure all the support tools required,
and recruit the team members into the project.

Implementation Phase

The programmers can often start with the interfaces to the components. These
should be well defined quite early in the design process. Stub and test versions of
each interface can be developed so that each component can be developed in
isolation by relying on the interface tests.

Similarly stub versions of the user interfaces can be developed and presented
to the client as a prototype of the application. This will confirm that the
requirements are correct and will set up the client's expectations for the
project.

The implementation phase includes the coding of the application programs and
libraries, the unit testing, the development of the documentation and the
development of the deployment guide. Testing of each use case should be done
as part of the implementation, preferably using some automated capability.
Quality control processes such as code reviews must be part of the schedule.

A generalisation task should be scheduled. This allows the designers and programmers
to revisit the design and re-factor some of the code. This will make the next
increment and later maintenance much easier.

Test Phase

The test phase is responsible for testing the assembled components (integration
testing) and testing the system in its enterprise context (system testing).

The test phase will also include the client's acceptance testing, so you will
need to support that.

Finally each round of development should finish off with a review so that
the development process itself can adapt to the team's strengths and weaknesses.

-- the next few blogs will expand the description of these tasks.


This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.