Quality and Standards
Forge Research upholds excellent quality
and standards in all of our processes.
Software development methods and software
quality are complementary.
We actively take the best ideas from
process initiatives worldwide and tailor them to our
needs. Our Software Engineering Process Group (SEPG)
controls the development process. The process is controlled
for the developers by the developers. Our clients ask
us to build complex critical systems and insist on a
robust quality process. We have passed audits by a number
of our clients to ensure that our quality processes
Forge considers testing to be an important
part of the development lifecycle.
The Forge approach to Risk Management
is characterised by a number of factors:
- Rigorous requirements definition.
From the outset in a project Forge endeavours to obtain
the most precise definition of the customer's requirements.
Hence, both the client and Forge understand what has
to be done and a properly costed development plan
can be agreed upon.
- Proper closure between project phases.
Forge's development lifecycle ensures that the various
phases of a project are closed prior to subsequent
phases being completed. This guarantees that the design
meets the requirements and the implementation meets
the design and so on thus minimizing the risk of incompleteness.
- Early identification of difficult
project activities. We uphold that the important matter
is identifying complexities early on and "bounding"
- Ensuring that staff of adequate experience
are assigned to tasks. Forge will always assign the
right person to the task. When members of the junior
staff are given tasks they are always well supervised
by senior developers.
- Regular progress reviews. Forge undertakes
regular internal project reviews within Forge. We
project this review process to the client to ensure
visibility of the state of the development and any
issues that arise from it.
- Regular system and component design
reviews. The review process at all levels is critical
to success of any project. Forge developers are steeped
in the discipline of peer review.
- Regular code reviews. While it is
not possible to review every piece of code that developers
produce, we take judicious samples, to ensure that
developers are following Forge coding standards and
they guide the developers to use high quality coding
patterns and techniques.
- A rigorous test regime. From unit
testing to high level load testing, the Forge test
regime is actively enforced.
- Use of prototypes. Judicious use of
prototypes can go a long way towards ensuring that
requirements can be met with little risk.
- Use of proven third party code rather
than development where possible. Forge knows that
good quality, tested, third party code is an important
basis of reducing risk in any of our projects.
- Rigorous change process that fully
involves the client. Once a system has been delivered
there will inevitably be changes as it and the business
co-evolve. Forge adopts a meticulous approach to change
management by using a formal method that fully involves
the client. Of course, Forge designs are modular so
that changes can be implemented with less risk of
adding defects to the rest of the system.
The deployment considerations
in Forge's software development process can be summarised
- We employ flexible strategies.
Forge tailors deployment strategies to the client's
- Forge policy and practice is to isolate
the executable code from its environment as much as
possible, thereby allowing deployment almost anywhere.
- Our philosophy is to deploy systems
in a complete form so that the client can extract
and run them with minimum configuration. Any needed
configuration is always well documented.
- System deployment is script-based,
making maximum use of scripts.
- We always develop with the objective
of our components being used in a distributed architecture.
- We endeavour always to make our components
work across different platforms.
- We isolate our components from
the environment in which they run as much as possible
so that there will be minimal, if any, changes if
their environment changes.
- Forge makes extensive use of industry-standard
- Forge develops its own patterns as
the need arises.
- Forge is especially accomplished
in using and developing patterns for distributed processing.
- Forge maintains a library of patterns
to fertilise the development process.
- Forge uses a proven configuration
management system for its code and supporting files
based on CVS augmented by the capability to work with
multiple parallel versions if necessary.
- Documentation is version controlled
and a history of each document is maintained.