RedGage

The development and coding phase is solely concerned with producing
working, documented, quality executable code. The exact methodology for a
team to implement code will vary from organization to organization.



DIGS will use Scrum methodology for code development during this phase.
Please review Scrum Development Methodology for additional information.



Code Conventions and Design Patterns



It is up to the Architecture Team to provide developers guidelines for
code conventions (e.g. naming conventions for files, method names or
services). In addition to coding conventions, design patterns are also
important. Design patterns allow the developer to solve common design
challenges using industry best practice solutions. A point worth
mentioning is that 80% of the lifetime cost of a piece of software is
spent in maintenance.

The combination of just these two procedures will greatly reduce overall cost of the application across its life cycle.







Code Reviews



While producing policies and procedures is the Architecture Team’s
mandate, it is the responsibility of the development team to enforce
them. The main mechanism to uphold a high coding standard is to force
developers to show their code in a group setting (i.e. peer code
reviews). Peer code reviews facilitate a non confrontational forum so
developers within and outside of the team can help to review the code.
The group collectively will look for convention mistakes and overall
design flaws. Allowing the development team to be self-governing is
essential to the long term viability of producing high quality code.



Unit Tests



Another way the developer ensures code quality comes in the form of unit
tests. A unit test is an automated piece of code used to test the
functionality of another piece of code. The scope of the test usually
only spans a single function. The developer will group together a larger
number of unit tests in the form of a test suite. The test suite acts a
collection of unit tests that can regression test a component of the
system. Test suites are then grouped together across the entire system
in the form of a testing framework. The testing framework will then act a
central mechanism to regression test the system in its entirety. Any
additional enhancement or code fixes in the future can then be tested in
the larger context of the system to validate system integrity. If any
one of the tests fails then outstanding issues must be resolved. This
approach provides a self-contained check for backwards compatibility of
functionality as the project goes through enhancements over time