Development Tasks, Part 2

This is the second part of a series describing the development tasks for a software project. See Software Development Process and Development Methodology for the context of this topic.

In the previous part we looked at the analysis phase. In this part we will
cover the initial design of the proposed system.

Project Tools

This task is one that is on-going for the life of the project. It is
responsible for setting up and maintaining the various tools that the project
will use.

Initially this might be just a word processor, but it will expand to include
version control products, project planning programs, development environments,
and so on.

At the very least it should include a list of what tools are necessary to build
the system.

Architecture

This task is concerned with the design problems that go beyond the selection of
algorithms and data structures, concentrating on the overall structure of the system.

Structural issues include gross organization and global control structure;
protocols for communication, synchronization, and data access; assignment of
functionality to design elements; physical distribution; composition of design
elements; scaling and performance; and selection among design alternatives.

The output of this task includes multiple views (eg concept model, network model
database distribution, etc), a list of the products that will form part of the
delivered system, and the specification for the interfaces between major internal
components.

Interface Stubs

For each interface create facade classes for each module. Add stub code that
allows each interface to be called and return default values. Define the abstract
interface classes and stub interface classes for any callback style interfaces.

Create test harnesses that call these interfaces. These will evolve into test
harnesses for the modules. The aim is to be able to develop each module in
isolation from the other modules. (See Chaotic Programming.)

This task has the useful side effect of getting the programmers involved in
some actual development very early in the process.

Component Exploration

Third party products rarely behave exactly as expected, or they may be new to
the developers. They need to be well understood if they are to be used successfully.

Build test programs to demonstrate how the components work together. Document
the criteria required to get them to inter-operate as required for the project.

Note that there is some danger that the client will modify their requirements
when they see what the products are capable of.

Migration Planning

Most systems will start life with a body of data that was captured by its
predecessors. That data needs to be converted and loaded into the new system.
This task describes how that is to be achieved. We do this early so that the
ability to load data is designed in from the beginning.

Determine which data will be useful, and organise how it will be extracted
from the existing system and loaded into the new one. Determine how the data
will be cleaned up to get rid of incorrect values.

Test Planning

For every outcome of each use case (for the current increment), describe the test
cases, this includes the number of tests, how the pre-condition state will be
achieved, and how the post-condition state will be validated. Break this into
sections for acceptance testing, system testing, integration testing and unit testing.

Application Specification

The aim is to ensure that everything the programmer needs to know is properly
defined.

For each use case describe how each system attribute is changed.

The deliverables include use case descriptions, class diagrams, details of any
complex algorithms, and an updated data dictionary.

User Interface

Design the user interfaces for the system based on the use cases. This can be
done with a user interface design program which can then generate the classes
necessary to run the interface.

The resulting UI can then be used to confirm the use cases by demonstrating the
system to the users. Obviously you will inform them that this is just the UI and
that there is nothing actually working yet.

In the next part we look at the remainder of the design tasks.


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