When developing a project you must have a clear strategy
in place to ensure that the work is done as it needs to be done
. For large projects , one of the best ways of doing this is :-
- have , as the technical project manager \ project
architect , a good idea what you want to achieve overall .
- write a set of requirement spec's .
- take the project through stages - evolve and iterate it . Make
the aim to always have something demonstrate-able .
- divide the project up into modules and components .
- design frameworks for the components to be bound to the modules
by . A framework provides structure to the program . A framework
basically consists of :-
- an interface from the module to the component - typically
a structure that points to a characteristic table and a function
table that allows the module to operate the component .
- an interface from the component to the module - basically
a function table in the module that allows the component to
call functions such as allocating memory blocks , passing those
blocks , sending event messages etc. .
- provide the initial framework specifications and component specifications
to the developers .
- develop the associated modules - the frameworks . The modules
contain all the common handling and inteligence - for example
- if the components are codecs then they would just be doing the
conversion from the encoded audio and video to the raw audio and
video , the module - to which they are dynamically bound , would
be handling all the inter task communication and all the conversion
from asynchronous to synchronous access and all the linkages and
passing down the chain of the data blocks etc. .
- develop the initial set of components . In developing the components
- start off with a simple set of components - then expand - evolve
- those components and their associated structure .
- develop the test harnesses and test those components .
- Iterate those components - ie. expand their functionality .
The project is then taken through multiple iterations until it
is complete . The idea is to start off with a simple but working
project then to evolve and expand it until it is a fully working
project . This process has the following advantages :-
- it ensures that the project is kept very much in touch with
the reality .
- it is a staged approach that can be moved along in an easy
- success by success - manner .
- it allows the test harness to be developed in parallel .
- it avoids unecessary complexity .
- it allows the project details to be designed as the project
progresses and the corresponding structures unfolds .
- it allows the progress of the project to be closely monitored
and adjustments made if necessary .
It is a different way of working from what many people are used
to but if it is done right it produces good results . The developers
have to understand that both the frameworks and the component
specifications will be evolved .
A way to look at it is - a program is like a higher order mammal
- it starts off as an embryo - simple in it's structure - it then
grows - expands - evolves - until it becomes the higher order
mammal that it was intended to be .
Basicaly - a project , that is being started from scratch , should
be taken through in stages and evolved . The idea is to keep each
set of work small , to develop in stages , to verify each stage
, and to evolve the project .
Very important - before starting the process you must have a
very good idea of where you want to go and how you want to do
it . You don't need to plan it to the n'th degree but you do need
to make the fundamental design decisions correctly before starting
- as you develop the project you will be developing on top of
structures that you have already developed - the quality of the
design of the structure will dictate how successful you are in
both business and in engineering terms .
Documentation is very important - both in the code and associated
with the code . Each stage must be specified - the requirements
for the stage must be written down . When a bug is found it must
be noted down . It's solution must be specified . As each bug
is fixed the altered code must be checked in . Likewise with the
completion of each stage of development .
It is vitally important to concentrate on what is actually happening
- the process is a means - not an end in itself .
Keep things relaxed working atmosphere wise , and tight engineering
wise . Methodology and structure are vitally important .