Agile Modeling

What is Agile Modeling?

Agile Modeling (AM) is a practice-based methodology for modeling and documentation of software-based systems. It is intended to be a collection of values, principles, and practices for modeling software that can be applied on a software development project in a more flexible manner than traditional modeling methods.[15]

The Need for a Better Modeling Methodology:

The extremely high failure rates commonly associated with system-development, whose estimates range from 50%-75%, it appears that there should be ample room for improvement in development efforts, whatever shape or form they take.[8] 

Agile Modeling with its core principles and best practices solutions in place represents a possible step in the right direction to improve the rate of system development failures. To achieve that, developers must have the courage to commit people and resource to the effort and pain involved in managing the changes that will occur as a result of implementing the Agile Modeling methodology.[8]

To successfully develop and implement the Agile Modeling methodology, the people involved in working on the model must be ready to follow the Agile Modeling Core Principles and must adhere to the Agile Modelings' best practices. The Core Principles and Best Practices of Agile Modeling are outlined and explained below. 

Agile Modeling Core Principles:

  • Model with a Purpose
    Many developers worry about their work when they are creating models. What they are not doing is stepping back and asking why the're developing the models and who they are developing it for. [15]
  • Assume Simplicity
    Keep models as simple as possible and assume the simplest solution is the best solution. Only model what you need today and trust that you can remodel later if needed.[20]
  • Embrace Change
    Change happens on a project as understanding grows. Rather than fight changes to your models, accept them and have the courage to rebuild.
  • Enabling the Next Effort is Your Secondary Goal
    Others might need to extend or improve your project after you leave. Leave enough documentation and models to enable the next person or team to improve or make changes to the model.
  • Incremental Change
    It is very hard for a model to be complete the first time it's developed. Models change over time as the project develops. Always make small changes to models as required.
  • Maximize Stakeholder Investment 
    The team must be in it to produce software to maximize return for the customer. The team must strive to develop software that meets the needs of the stakeholders. 
  • Multiple Models
    There are many ways of modeling solutions; choose those that fit best according to the given situation. 
  • Quality Work
     Nobody likes sloppy work. The people doing the work don't like it because it's something they can't be proud of, the people coming along later to refactor the work (for whatever reason) don't like it because it's harder to understand and to update, and the end users won't like the work because it's likely fragile and/or doesn't meet their expectations.[15]
  • Rapid Feedback
    Getting quick feedback on the model will close the loop of understanding the model. The best process is to model a little, show the model for review and then model again. This insures accuracy of the model while increasing the developers own knowledge. [20]
  • Software is Your Primary Goal
    Models are a means to the end; the en is to build software for your customer. Documentation and modeling must directly support the goal of software development.
  • Travel Light
    Traveling light means that you have just enough documentation about the models that you are developing. If it's too little documentation the developing team might loose its way; too much and the developing team will have forgotten that the primary goal is not writing documentation but software and building the right models. 

Agile Modeling Best Practices:

There are several modeling-oriented best practices. The best practices for Agile Modeling methodology are outlined below: [15]

  1. Active Stakeholder Participation- Stakeholders should provide information in a timely manner, make decisions in a timely manner, and be as actively involved in the development process through the use of inclusive tools and techniques.
  2.  Architecture Envisioning- At the beginning of an agile project, the team will need to do some initial, high-level architectural modeling to identify a viable technical strategy for your solution.
  3. Iteration Modeling - At the beginning of each iteration, you will do a bit of modeling as part of your iteration planning activities.
  4. Just Barely Good Enough (JBGE) Artifacts-  A model or document needs to be sufficient for the situation at hand and no more.
  5. Lookahead Modeling - Sometimes required so as to reduce overall risk.
  6.  Model Storming - Throughout an iteration you will model storm on a Just in Time (JIT) basis for a few minutes to explore the details behind a requirement or to think through a design issue.
  7. Multiple Models- Each type of model has its strengths and weaknesses. An effective developer will need a range of models in their intellectual toolkit enabling them to apply the right model in the most appropriate manner for the situation at hand.
  8. Prioritized Requirements - Agile teams implement requirements in priority order, as defined by their stakeholders, so as to provide the greatest return on investment (ROI) possible.
  9. Requirements Envisioning - At the beginning of an agile project you will need to invest some time to identify the scope of the project and to create the initial prioritized stack of requirements.
  10. Test Driven Development(TDD) - Write a single test, either at the requirements or design level, and then just enough code to fulfill that test. TDD is a JIT (Just in Time) approach to detailed requirements specification and a confirmatory approach to testing.

Subpages (1): Best Practices Map