Software today is ubiquitous and impacts all aspects of life; thus making it imperative to bring predictability, productivity and quality in the software development process. Software development life cycles, abstraction mechanisms, development platforms and the tools to support these have been evolving over the years, attempting to transport software development from the realms of art into the realms of engineering.

At the early stages of evolution of software engineering, attempts were made to borrow successful ideas from other classical engineering branches and implant them into the software development process. These attempts to replicate the linear progression from requirements to design to construction, which worked well in classical engineering, have met with stunning failure in many software development projects.

Software development is evolutionary in nature and requires all the stakeholders to actively engage and discover the various dimensions of the software. As the software evolves, greater is the discovery and the opportunity to provide feedback. Classical engineering processes which force freezing of artifacts at each stage, with changes at later stage being expensive exceptions, are counter intuitive in the domain of software development.

The above realizations have led to the development of Agile processes that focus on continuous iterative delivery of useful working software based on customer priority, thus enabling collaborative involvement of all the stakeholders.

Short iteration cycles and micro-deliverable based methodology

Agile methods break the feature to be developed into self contained prioritized stories. These stories are bucketed into short duration iterations that typically last from one to four weeks. In each iteration a team works through the full software development cycle including planning, requirement analysis, design, coding, unit testing and acceptance testing when a working product is demonstrated to stakeholders.

This approach improves status visibility, creates fine-grained project control, enables early feedback from QA and customers, lets the project adapt to changes quickly, improves developer motivation and reduces schedule risk.

Communication and collaboration

Agile methods emphasize continuous active communication through verbal and other means such as e-mail, IM, wiki and miscellaneous collaboration platforms. Team size is typically kept small (4-8 people) to help make team communication and collaboration easier.

Continuous builds

Short iteration cycles and distributed teams mandate that code must always be kept in a buildable state rather than end of the cycle rush at system integration and building the release.

Test driven development

Test driven development ensures verifiability of software through a suit of unit tests defined by the developers. Automated frameworks have made this approach practical, and when integrated with the continuous build process ensures that the code is kept not only in the buildable state but also in the verifiable state as defined by the unit test suite. Other than keeping the code in verifiable state, test driven development also has other advantages:

  • writing test cases ensures that the developer has understood the requirements
  • test cases become an integral part of requirements and code documentation
  • greatly improves the quality of code as it forces the developer to minimize the dependencies

Design patterns and refactoring

Use of design patterns is highly recommended in Agile as they not only assist in developing software that conforms to design principles, but also help in communication within the engineering team. Agile methodology would generally suggest avoiding over engineering till the need for the same are felt. However the code is continuously improved through reviews and code refactoring.


Agile emphasizes working software as the primary measure of progress. This, combined with the preference for verbal communication, produces less written documentation than other methods—though, in an agile project, documentation and other artifacts rank equally with working product.

The litmus test to decide whether a piece of documentation or artifact is a critical deliverable is to identify whether that artifact is kept live, or it slowly becomes stale and is not updated with time. In Agile the critical artifacts are- documented code, automated unit test cases, QA test plan and QA test cases. These are live elements of the software and are to be always current.

Process Tools

Agile methodologies can be implemented successfully only with the support of right set of automation tools. It is important to have tools for:

  • tracking iterations, stories, tasks, issues and bugs
  • knowledge/document sharing
  • shared source repository
  • build automation
  • continuous integration
  • automated unit test framework

There are different flavors of Agile that have evolved including Extreme Programming, Feature Driven Development, Scrum, DSDM and Lean Software Development. An organization may choose any of these and further adapt it to suit its requirements.

Agile @ Metacube

Metacube since its inception has been working with product companies at various stages of maturity. The primary business model at Metacube has been to set up extended engineering teams for these companies, where our team integrates with their in house team to develop, enhance and maintain their product suite. Most of these product companies are working with one or the other flavor of agile processes, requiring us to adapt to their process. This has provided us very rich experience in agile processes, and we have successfully created agile teams ranging from a couple of engineers to 50+ engineers.

Our experience not only helps us in quickly adapting to the process being followed by the client, but also allows us to help early stage customers in choosing and implementing an agile process. Over the last couple of years we have found that most companies are adopting variants of the SCRUM methodology.

Metacube also has expertise in a cross section of tools that enable agile development. Some of the tools that we have experience on include:

  • Source repository (Subversion, CVS)
  • Build automation (Maven, Ant)
  • Continuous integration (Cruise Control, Continuum)
  • Bug/Task trackers (Rally, Jira, Test Director, Mantis, Bugzilla)
  • Collaboration tools (wiki, Google Apps, Sharepoint)
  • Code review tools (PMD, CheckStyle)
  • Automated unit testing (JUnit, NUnit, JMock, EasyMock, JUnitEE)
  • Automated system testing (Selenium, QTP, Silk)