Quality and Standards

Forge Research upholds excellent quality and standards in all of our processes.

	Software Development Methods and Software Quality
	Quality
	Testing
	Risk Management
	Deployment
	Component Development
	Patterns
	Configuration Management

Software development methods and software quality are complementary.

	The Forge Development Process closely adheres to industry standards such as those formulated by IEC, IEEE and SEI. Our software development strategy is continuously under review.
	Forge's Quality Management Strategy is captured in a document called Quality Management Overview, which is regularly reviewed. This document forms the basis for the Software Development Plan, which is written up for each Forge project.
	Design and code reviews are called at appropriate stages in the development. Software developers can also instigate reviews or inspections of their code, and are actively encouraged to do so.
	Forge uses checklists extensively to ensure that software and documents meet requirements before being tested or reviewed.
	As part of our process development, the Forge Software Engineering Process Group (SEPG) meets fortnightly to discuss and improve our development practices. It is composed of developers and testers.
	Forge has a culture of active knowledge sharing, for instance by means of news groups and regular presentations on technical and process related topics for the entire development team.

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 are acceptable.

Forge considers testing to be an important part of the development lifecycle.

	Developers undertake unit testing using state-of-the-art unit testing tools.
	The System Test Plan is produced early in the development cycle.
	The Production Test Specification is produced on the basis of the use cases and other requirements captured in the System Requirements Specification early in the project and expanded upon with the aid of design specifications as they become available.
	The Test Team produces automated scripts and harnesses, sometimes in collaboration with the development team, using modern user interface and load testing tools.
	Tests are conducted in a self-contained controllable environment.
	Defects are raised, tracked and promptly acted on through our online defect tracking system.
	The customer receives the following documentation, a Test Plan, a Production Test Specification, a test results document and a known defect list for each release.

The Forge approach to Risk Management is characterised by a number of factors:

1. 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.



2. 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.



3. Early identification of difficult project activities. We uphold that the important matter is identifying complexities early on and "bounding" them.



4. 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.



5. 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.



6. 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.



7. 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.



8. A rigorous test regime. From unit testing to high level load testing, the Forge test regime is actively enforced.



9. Use of prototypes. Judicious use of prototypes can go a long way towards ensuring that requirements can be met with little risk.



10. 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.



11. 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 as follows:

1. We employ flexible strategies. Forge tailors deployment strategies to the client's needs.



2. Forge policy and practice is to isolate the executable code from its environment as much as possible, thereby allowing deployment almost anywhere.



3. 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.



4. System deployment is script-based, making maximum use of scripts.

1. We always develop with the objective of our components being used in a distributed architecture.



2. We endeavour always to make our components work across different platforms.



3. 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.

1. Forge makes extensive use of industry-standard software patterns.



2. Forge develops its own patterns as the need arises.



3. Forge is especially accomplished in using and developing patterns for distributed processing.



4. Forge maintains a library of patterns to fertilise the development process.

1. 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.



2. Documentation is version controlled and a history of each document is maintained.