Lightning Fast Requirements Iterations. Lightning Fast Software Completion
Executable Requirements is a means to create Extremely Rapid Requirements Iterations (ERRI) for existing or new software systems. It may be used for most types of software systems, including Web, Mobile, Client-Server, Control Systems and traditional Enterprise, and works well for systems that require formal specifications and precise audit trails. The method of ERRI is part of the Ultra Agile™ methodology, addressed.
However, ERRI has great value on its own for defining a viable and well tested set of Requirements, regardless of what implementation method is subsequently used to create your software system.
The ERRI process is as follows:
- Specify an initial set of Requirements verbally, and/or via whiteboard
drawings, while a Requirements Analyst encodes them in near real time using the Conversation Engine™ (or CE). This may take as little as several hours and as much as several days, depending on the size and complexity of the system.
- Generate an Executable Requirements (ER) prototype from the Requirements using CE. This takes seconds for each iteration.
Executable Requirements Process
- Have the people who understand the requirements play with the generated ER prototype and experience how it feels to use it and how well it matches their desired functionality and user experience. This ER prototype does everything that was specified in the requirements so far. While it may not have the final look and feel, and may not yet be integrated with your other systems, it enables the user to experience what it is like to use the system that has been described by the requirements.
- Based upon using the ER prototype, describe to the Requirement Analyst any changes in requirements that are desired.
- The Requirements Analyst quickly (minutes) updates the specifications and generates a new ER prototype.
- Repeat (iterate) steps 3 through 5 until everyone is satisfied with how the ER prototype works, and thus with the specified requirements.
- The Conversation Engine™ generates user documentation, automated unit
tests, finite state diagrams, and of course the ER prototype code.
- The diagrams and documentation may then be handed to your development
team for implementation, along with the ER prototype, so that they can see the user experience you desire, and have mathematically precise models
showing how the system should behave.
- Your development team then selects any method they wish to implement the specified system.
- As you and your team have already greatly refined the requirements before the development team started to implement, and have felt the user experience when using the ER prototype system, the system your development team creates is very likely to meet your needs and expectations first time.
The above ERRI process effectively eliminates the most expensive error in software development, that of ambiguous, incomplete, or incorrect requirements. This process also fosters buy-in and mutual understanding of requirements among your team members. Using Executable Requirements substantially reduces the cost and time for software development, and enhances user satisfaction and business results.
The SciSpike team uses this approach for our Custom Development projects, and because this provides us with very precise requirements specifications, we are very comfortable providing fixed price quotes for projects. Executable Requirements provides a “measure twice, cut once” approach, except that you may iterate not just twice, but tens or hundreds of times as you build out the specifications, before handing the requirements specifications to your development team to be "cut once."
For a deeper dive into the benefits of ERRI, please see Petter's blog.