The StoneHenge blog

Agile Software Development is a relentless focus on providing a continuous stream of business value even in the face of constant change. At StoneHenge Partners, we have adapted 10 to the 12 agile principles into our Nimble℠ method to insure our clients receive business value and testable iterations of code throughout the software development life cycle.

This step alone significantly reduces project risk and cost by preventing defects, which is the largest source of budget overruns ... finding and repairing software defects.

Below is a diagram showing the ten steps we follow, in each iteration of code development, in order to prevent defects in subsequent iterations. Following this diagram is a comparison between the 12 principles of Agile and our Nimble℠ method of software development to better explain how Nimble℠ really is working with Agility.

Principles behind the Agile Manifesto

Here are the 12 principles of the Agile Alliance, and my comments on how we follow these principles are in italics below.

  1. Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.

Our #1 area of focus is on creating software that solves the Client's business problem.

  2. Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.

Through the use of Function Point Analysis (FPA) to size projects we quickly size the impact of change including the impacts to cost and schedule so we may assist Clients in making business decisions.

  3. Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.

As mentioned above, we deliver testable iterations of code throughout the project life cycle. These iterations are typically 2 to 4 weeks in length.

  4. Business people and developers must work together daily throughout the project.

We do not solely rely on written requirements specs created in the early stages of a project's lifecycle. As our development team starts a new iteration, they will involve a Client SME and verbally confirm, enhance and update the original requirements.

  5. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.

We certainly utilize motivated individuals on our software development teams, but we build projects around the Client's functional requirements, so we can accurately quote price and delivery. We do this by using FPA, the only ISO approved methodology to size software development projects.

  6. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.

Our software development team uses daily scrum meetings to facilitate this face-to-face conversation and to quickly identify and resolve issues and delays. A Client SME is frequently involved in these scrums.

  7. Working software is the primary measure of progress.

We measure the percentage of functionality delivered throughout the software development lifecycle.

  8. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.

Once we have sized a project with FPA, we utilize a combination of our internal and industry productivity rate factors to calculate the total project effort required by role. The (+/-) 5% accuracy of this tool not only allows us to build a sustainable project plan, but it allows us to deliver results on-time and on budget to our Client.

  9. Continuous attention to technical excellence and good design enhances agility.

We utilize design tools like wireframe diagrams and functional component diagrams to graphically define functional requirements so we may accurately size projects and quickly identify and respond to change.

  10. Simplicity--the art of maximizing the amount of work not done--is essential.

We utilize iterative develop to reduce and prevent defects as described above. In addition, we utilize a collaborative modeling tool called Enterprise Architect, from Sparx Systems, to minimize the effort to document and maintain requirements.

  11. The best architectures, requirements, and designs emerge from self-organizing teams.

We create a logical functional component model of the entire application, when applying FPA during the discovery phase, and the Dev team uses it as a guide, when defining the technical design within each iteration. This functional component model graphically identifies all known logical files and interfaces and assists in preventing design errors.

  12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.

This is the key to a successful project and cannot be emphasized enough. As you can see in step 10 in the above defect removal diagram, we take time to learn from past mistakes in order to prevent them in the next iteration.