Software Development Management, Part 2, Software Requirements

Posted by on March 18, 2014 in Design, Device Tips

, ,

In a previous Device Tip, I mentioned that in my experience, far and away the area with the most issues in software development is Software Requirements and Specifications. In previous Device Tips I discussed Requirements and Specifications in more detail, so I will not repeat them in this Device Tip. What this Device Tip will focus on is to parse potentially compound Software Requirements into discrete, more easily verifiable Requirements that follow the potential or likely design and/or implementation.

Compound Software Requirements are those that combine multiple individual Requirements into a single statement, such as “the Software shall detect a High Temperature alarm if the temperature is above 50C and shut off the heater and sound the audible alarm”. On the surface this is easily seen as (3) Requirements, but in fact implies (5) separate software functions:

  1. measure the temperature
  2. compare it to a limit
  3. if over the limit, declare an alarm state
  4. turn off the heater, and
  5. sound the audible alarm

It also suggests at least (2) other software functions:

  1. setting the temperature limit
  2. temporarily or permanently silencing the audible alarm

It is also likely that in the software design and/or implementation these (5) or (7) functions will be handled by different functions in the software. So it will be easier to test these functions separately rather than together.

So here’s the tip:

When developing Software Requirements, look for the following potential functions that software might perform with respect to a given overall set of actions

  1. set a limit
  2. measure a value
  3. compare a measured value to a limit
  4. if over or under a limit, transition to a new state
  5. when transitioning to a new state, perform some action (turn something ON or OFF, start or stop an action, etc.)
  6. provide an audible or visible enunciation of a particular condition or state
  7. allow specific audible or visible enunciation to be temporarily or permanently disabled

If separate Software Requirements are written for each of these more specific functions, verification will be significantly easier. Also, once the sub-functions are verified, if the software design and implementation is well partitioned to allow these sub-functions to be used by multiple higher level functions, verification of the sub-functions can be re-used as part of verification of other higher level functions that use those same sub-functions.


More Info On Software Requirments

Smaller, specific Requirements are often referred to as ‘atomic’ Requirements. Correspondingly, compound Requirements can be referred to as ‘molecular’ Requirements. Say you have a molecular Software Requirement:

“The Software shall detect a High Temperature alarm if the temperature is above the User-specified High Temperature Limit and shut off the heater and sound the audible alarm”.

The atomic Software Requirements would be:

  1. The Software shall allow the User to set a High Temperature Limit
  2. The Software shall measure the internal unit temperature
  3. The Software shall compare the measured internal unit temperature to the High Temperature Limit on each reading of the internal unit temperature
  4. The Software shall set a High Temperature state if the measured internal unit temperature is above the High Temperature Limit.
  5. The Software shall shut off the heater in the High Temperature state.
  6. The Software shall provide an audible alarm every second in the High Temperature state.
  7. The Software shall temporarily silence the audible High Temperature alarm for one minute after the Alarm Silence button is pressed.

Here are some of the benefits of specifying these Software Requirements atomically:

  1. The design and implementation of each atomic requirement is clear (read easier)
  2. Other molecular Software Requirements can be derived using some of these atomic Software Requirements (such as measuring the internal unit temperature)
  3. Other atomic Requirements (such as Hardware Requirements) can be derived (i.e. the Hardware shall allow the internal unit temperature to be measured)
  4. These atomic Software Requirements are able to be verified with clear and straightforward tests
  5. Once these atomic Software Requirements have been verified, associated molecular Software Requirements are much more likely to work correctly
  6. When molecular Software Requirements are not working correctly, troubleshooting will likely end up determining which atomic Software Requirement(s) are not working correctly, and then determining why so they can be corrected.

In the end, even the most complex requirements will end up being specified, designed, implemented and often verified atomically.

P.S.: once again, special thanks for Keith Breton of New Frontiers Software for his valuable contributions to this Device Tip including the term ‘atomic Software Requirements’. -BD

Like This Content?

Get more tips like this delivered to your inbox.

Subscribe Now