SOFTWARE DEVELOPMENT
Software Development - Approach

SOFTWARE DEVELOPMENT APPROACH

We recognized that building world class systems requires excellence in both Creative Thinking and Precision Engineering. We couple innovation and learning with artistic flair and technical design excellence then we deliver, accurately and fast with uncompromised quality. To get this right consistently, we use a combination of Agile development methodologies to provide the best possible balance between ensuring flexibility and innovation the Creative aspect, whilst ensuring quality, reliability and repeatability the Engineering aspect.


The complimentary methodologies and frameworks used at Kaizania are:



Scrum

Scrum is an Agile management framework that can help you navigate your project through incremental software development iterations, called Sprints. Scrum offers:


:: A code management practice at the nuts and bolts level of a software project
:: The Code Base is continuously updated to reflect the culmination of everyone’s contribution
:: Integration problems are detected and fixed continuously no last minute hiatus
:: The immediate impact of checking in incomplete or broken code acts as an incentive to developers to learn to work more incrementally with shorter feedback cycles before release dates
:: Early warning of broken/incompatible code
:: Early warning of conflicting changes
:: Constant availability of a “current” build for testing, demo, or release purposes
:: Sets the stage for driving complexity down from the human planning level, where automation cannot help, to the code dependency and unit testing level, where automation can be applied effectively



Unified Process

The Unified Process is an iterative and incremental development process. The Elaboration, Construction and Transition phases are divided into a series of timeboxed iterations. (The Inception phase may also be divided into iterations for a large project.) Each iteration results in an increment, which is a release of the system that contains added or improved functionality compared with the previous release. Although most iterations will include work in most of the process disciplines (e.g. Requirements, Design, Implementation, Testing) the relative effort and emphasis will change over the course of the project.

Architecture Centric:
The Unified Process insists that architecture sit at the heart of the project team’s efforts to shape the system. Since no single model is sufficient to cover all aspects of a system, the Unified Process supports multiple architectural models and views. One of the most important deliverables of the process is the executable architecture baseline which is created during the Elaboration phase. This partial implementation of the system serves to validate the architecture and act as a foundation for remaining development.

Risk Focused:
The Unified Process requires the project team to focus on addressing the most critical risks early in the project life cycle. The deliverables of each iteration, especially in the Elaboration phase, must be selected in order to ensure that the greatest risks are addressed first.


Unified Process offers:

    :: A software engineering best practice framework
    :: Covers the entire software development process
    :: UP is used at Kaizania to ensure all the software engineering roles and responsibilities are covered and to minimize potential project risk, for each and every project we undertake
    :: Attack risk continuously, from project inception through to completion
    :: UP is architecture driven, leading to modular, flexible, scalable systems
    :: UP is supported by a variety of tools.




Continuous Integration

Continuous integration is a set of software engineering practices that speed up the delivery of software by integrating new code frequently. The technique has its origins in the world of Lean where there exists the concept of Autonomation automation with a human touch. In the fast-paced business environments of today, this has a huge competitive advantage.

    :: A code management practice at the nuts and bolts level of a software project
    :: The Code Base is continuously updated to reflect the culmination of everyone’s contribution
    :: Integration problems are detected and fixed continuously no last minute hiatus
    :: The immediate impact of checking in incomplete or broken code acts as an incentive to developers to learn to work more incrementally with shorter feedback cycles before release dates
    :: Early warning of broken/incompatible code
    :: Early warning of conflicting changes
    :: Constant availability of a “current” build for testing, demo, or release purposes
    :: Sets the stage for driving complexity down from the human planning level, where automation cannot help, to the code dependency and unit testing level, where automation can be applied effectively




Test Driven Development (TDD)

Test Driven Development (TDD) is a software development technique that uses short development iterations based on pre-written test cases that define desired improvements or new functions. Each iteration produces code necessary to pass that iteration’s tests. Finally, the programmer or team refactors the code to accommodate changes. A key TDD concept is that preparing tests before coding facilitates rapid feedback changes. Note that test-driven development is a software design method, not merely a method of testing. It helps to build better quality software faster, and reduces risks that can cause the bogdown some projects experience when 99% complete.

    :: Tests are created prior to development taking place
    :: Developers focus on outcome
    :: Unit tests are performed prior to a development work package being considered “done”
    :: Refactoring done early
    :: Versioning and good source-code housekeeping is enhanced
    :: Automated tests are created as work is completed
    :: Regression testing tests complete code-sets or builds and speed up testing of new releases
    :: Code coverage improves