Software Requirement Patterns
Learn proven, real-world techniques for specifying software requirements with this practical reference. It details 30 requirement "patterns" offering realistic examples for situation-specific guidance for building effective software requirements. Each pattern explains what a requirement needs to convey, offers potential questions to ask, points out potential pitfalls, suggests extra requirements, and other advice. This book also provides guidance on how to write other kinds of information that belong in a requirements specification, such as assumptions, a glossary, and document history and references, and how to structure a requirements specification.
A disturbing proportion of computer systems are judged to be inadequate; many are not even delivered; more are late or over budget. Studies consistently show one of the single biggest causes is poorly defined requirements: not properly defining what a system is for and what it's supposed to do. Even a modest contribution to improving requirements offers the prospect of saving businesses part of a large sum of wasted investment. This guide emphasizes this important requirement need--determining what a software system needs to do before spending time on development. Expertly written, this book details solutions that have worked in the past, with guidance for modifying patterns to fit individual needs--giving developers the valuable advice they need for building effective software requirements.
Review By: Cathy Bell
05/22/2008I sew and find patterns useful. They save me time when creating something new and make it easy to recreate a favorite item. They can also be altered which allows me to tailor what I'm making to fit a special situation or take into account properties of a special fabric. In his book "Software Requirements Patterns," Stephen Withall shows how software requirement patterns will help us be creative, effective, and flexible when gathering and writing software requirements. We can follow the basic patterns he lays out in the book, but we can also tailor those to fit our particular software project.
The author states in the preface that the book is designed to help us build a good software system--or even an excellent one. The way to accomplish this is by using the software patterns he has identified for us and that by following these patterns we will save effort.
The book begins with a quick synopsis of requirements, such as what are requirements, where in the lifecycle we should gather requirements, and how requirements can fit into the various development methodologies. This leads to an overview as to how requirements should be organized. The author states that this information is only meant to be a basic overview but access to a full version of these introductory chapters is made available on the Web for downloading. The online material is detailed and contains a sample requirement that can be used as a template. This template contains hints, explanations, and examples within the document. Getting into the meat of this discussion, he explains what requirement patterns are, what they should contain, and how they are organized. Chapter four covers how to use the software requirements patterns and, more importantly, how to write your own.
These first four chapters set the scene for the rest of the book. The remainder of the book presents the reader with thirty-seven requirements patterns, containing over four hundred examples of requirements. Many of the patterns are common across systems and those are covered first in each section. But he also provides guidance on some parts of the system that could be obscure and easy to overlook when gathering and writing requirements. Each section explains how this pattern can be applied, discusses when this pattern would fit well, and when it would not make sense to use. Each pattern section concludes with considerations for development and testing. The glossary in the back of the book would be an excellent starting point for those of us that need to create an IT glossary and have been putting off starting one.
The premise of the book is to give us a useful tool that allows us to create better requirements with less effort. For that reason, this is one book I am sure I will turn to again and again. It is well written and easy to read, and the multitude of real life examples should provide most of us with a solid basis for implementing software patterns in our system requirements.