Writing Software Requirements
This article discusses the 2011 revisions to the IEEE 830 standard for requirements analysis. What are the phases of software requirement engineering?
Also pay special attention to the section of types of software requirements and the unique quality of each type. It is important to identify and include more than just the functional requirements to have a quality system.
What is a software requirement?
A software requirement, simply stated, is something that matters to someone who matters.
A software requirement may take the form of anything from a high-level, abstract statement of a service or constraint to a detailed, formal specification. Software requirements must serve many purposes during the software engineering process, and so this
is the reason that there is so much variation in how they are written and presented.
My main approach to writing requirements can vary in format from project to project, but I tend to prepare a list of software requirements in a computer spreadsheet program like Microsoft Excel or Google Docs, or Open Office Spreadsheet. This requirements
document is always dated, ranked, the source of the requirements is always noted for traceability, and it is usually accompanied and supplemented by a catalog of use cases and a functional specification document with mockups and wireframes.
What are the characteristics of good software requirements?
The IEEE has a standard, IEEE 830, that lays out the characteristics according to the IEEE of good software requirements:
1. Correct: The SRS, or software requirements specification, should correctly describe the system behavior. It is not productive to have a requirements document that describes implausible or impossible expected system behavior or user goals.
2. Unambiguous: Software requirements should be written in such a manner as they are not subject to different interpretations. The use of specific and appropriate language can help avoid ambiguity in interpretation.
3. Complete: the software requirements document should completely describe the system's expected behaviors and feature set.
4. Consistent: Requirements for the system under discussion must not contradict each other.
5. Ranked: You must rank your software requirements for importance. Each software requirement has its own level of importance and criticality, and they are not all equal. By ranking the requirements, software designers ensure that guidance is given to the development team regarding effective prioritization.
6. Verifiable: If the requirement cannot be verified as having been met, then the requirement itself is written poorly. The requirements have to be testable.
7. Modifiable: The requirements must be easy to modify or change.
8. Traceable: The requirements must be traceable, and it is essential that traceability information has been provided, as the requirements document provides the starting point in the traceability chain. I have written elsewhere in this blog at length about the importance of software requirements traceability and have provided examples of software requirement traceability matrixes. Many software development organizations use proprietary CASE software tools and other methods to enforce traceability policies that stipulate how much traceability information regarding requirements must be maintained.
What are some wording and language best practices for software requirements?
I have many years of hard won expertise in writing software requirements. About this topic I have discovered many tips and tricks of the trade that can serve you well as excellent best practices. I suggest that you invent and use a standard format for all of your requirements and requirements documents, including use cases and functional specifications. You should take great care to use language in a consistent way when writing your software requirements.
I recommend that you use "Shall" when you are writing mandatory software requirements, such as "The system shall provide a facility for a store manager to enter an alternate shipping address onto the order confirmation page".
I recommend that you use "Should" for desirable software requirements, such as "The system should enable the use of as many payment gateways as have been configured by engineering prior to the current release".
Feel free to boldface or otherwise emphasize or highlight key parts of the requirement. This holds true for use cases ad functional specification documents as well.
I recommend that unless it is absolutely necessary, you should avoid technical language or implementation details in your requirements documents.
What do bad software requirements look like?
hat makes software requirements "Bad" software requirements? Well, lack of specificity is one way requirements can be reckoned to be poor. Another way in which software requirements can fail to serve their purpose in the software development effort is when they are written in a way in which they are they are not verifiable. If, for instance, a software requirements engineer were to write a software requirement in which he or she stated the system under discussion was to be "completely reliable", what exactly would they mean, and how would "reliable" be quantified? If a percentage is used in the writing of a software requirement, the whole or the baseline percentage and boundaries should be specified.
The following are some examples of very poor software requirements - you really don't want to write software requirements which look like these, trust me:
"The system shall be completely reliable"
"The system shall be maintainable"
"Order rejections shall be less than 99%"
"The system shall be fast"
"The system should use artificial intelligence"
"The system should be totally modular"
What do good software requirements look like?
I have already mentioned IEEE standard 830, which can serve as a fundamental basis guide for you when you set out to write your own software requirements, but let me emphasize a few key points here before setting some example good software requirements before you.
Make sure that your requirements are traceable, verifiable, and specific. Ensure that when you write your software requirements that you quantify any specific qualities that you write about as desirable User goals or User Stories. Make sure you rank your requirements for software development and date them, notating the source of the requirement, the venue of the requirement's origin, the primary internal and external stakeholders, and the DRI, or directly responsible individual, who is assigned to sheparding that requirement through development. Make sure that you use "Shall" for mandatory requirements and "Should" for optional, or "nice to have" requirements.
"The response time for the system to present the checkout page upon an order button click on a product detail page shall be less than 500ms"
"95% of all transactions on the public-facing webstore portal shall be processed in less than 4s"
"MTBF for the domain controller server shall be 5000 hours of continuous operation"
"The system shall present the closest 5 stores to the user on the map page, provided that 5 stores are within the user-defined search radius"
How do you rank software requirements?
For the most part, I generally advocate a three level rating system for software requirements: mandatory, desirable, and optional. The mandatory requirements cannot be sacrificed, desirable requirements are important but could be sacrificed if necessary to meet schedule or budgetary concerns. Optional requirements are ones which may not be developed, simply due to the fact that they have been rated as being "nice to have".
Ranking of software requirements comes in handy when the development team needs to make tradeoffs. For example, if time or work force is limited, the development team's focus can then be placed on the higher ranked requirements.
What is the role of the requirements document in the software development process?
The requirements document is the official statement of what is required of the system developers. The requirements document should include both a definition and a specification of requirements. However, the requirements document is not a design document. To the extent that it is possible, the requirements document should be a set of statements regarding what the system should do, not how it should do it. In the real world, the requirements document does tend to contain some design specifications, which can box in the programmers later if carried too far.
Precise software specifications provide the fundamentals for analyzing the requirements, validating that they are the stakeholder's intentions, defining what the designers have to build, and verifying that they have done so correctly.
Requirements allow the system's programmers and software engineers to know the motivation for development of the system under construction. Software requirements also help the engineers manage the process of evolving the software over time and across suites of related software products and web-based services.
Who typically uses software requirements documents?
There are a great variety of stakeholders, both internal and external, who utilize the requirements documents throughout a typical software development project lifecycle. Each of these stakeholders will have a different perspective on the requirements document and they will each put the requirements document to a different use:
1. Customers or clients: will desire to, as completely as possible, express how their needs can be met. They continue to do this throughout the software development lifecycle process as their perceptions of their own needs change.
2. Developers or programmers: will attempt to create a software design that will satisfy all of the requirements laid out by the system designers.
3. QA personnel and testers: will use the requirements document as a basis for writing and conducting the tests they will use to verify that the system functions as it was designed.
4. Managers and project leaders: will use the requirements document as a contract to bid upon the system and then control the production of the software throughout the software development lifecycle.
5. System and Maintenance engineers: will use the requirements document as evidence of what the designers of the system had originally intended for it to do, using this as a guide for continuing evolution and maintenance efforts.
What is software requirements engineering?
Software requirements engineering is a subset or subdiscipline of software engineering that is focused on determining and specifying the functions, constraints, and user goals of the software system being designed.
The software requirements engineering process begins with a discovery project or feasibility study which leads to a discovery project findings document or project feasibility report. There are instances, rare though they may be, when a software development project feasibility study will actually conclude that the best course of action for a development organization is to not move forward with the development project. Feasibility studies can help your discovery team uncover answers to questions such as these:
1. Is a new technology needed for us to develop the system under discussion? What expenses will be involved in acquiring this new technology or resources experienced in working with it?
2. What is the impact, in all aspects, of not constructing the proposed system?
3. What are the current problems the system under discussion is proposed to alleviate?
4. How will the proposed system alleviated these concerns?
5. What will be some of the development and integration problems encountered by the system's design and programming project teams?
Software requirements engineering is strongly influenced by computer science and systems engineering, however, as developing software is an art, not a science, and since developing software is a human endeavor not generally considered a "true" engineering discipline, software requirements engineering draws upon a number of different disciplines and fields of study. Particularly with respect to understanding the user goals and needs and desires of humans, individuals with a diverse background in anthropology, philosophy, cognitive psychology, linguistics and other liberal arts fields often make superb requirements elicitators and software requirements engineers. It is oftentimes business analysts who take the fore in requirements elicitation and gathering in many organizations.
Software requirements engineering for a software development project has a few typical phases:
1. Requirements elicitation and gathering is always a necessary step, as frequently primary internal and external project stakeholders do not know what they want, the requirements can be deeply "hidden" within a client organization, prior requirements may not be validated or verifiable, and even completely incorrect. This is the phase of the project which will largely determine the success or failure of the project.
2. Requirements modeling is a way in which the written, prose requirements are presented in another format. Although effectively doing this can prove difficult for novices, many techniques such as use case modeling, UML diagrams, user stories and user goals can help system designers and requirements engineers and business analysts represent the requirements in a more easily comprehensible or shareable form.
3. Analyzing requirements is the process whereby the requirements are checked for consistency, correctness, completeness, sufficient detail, and writing style and format.
4. Requirements change management is a requisite activity for business analysts and software requirements engineers, as requirements are changing all the time and this process is to be expected and prepared for.
What different types of software requirements are there?
Even though there are many different types of forms software requirements may take, in my own experience a requirements document may encorporate a few different types of requirements within the same document, sometimes subdivided into sections or categorized. I wanted to take some time to explain a little about each of the types of software requirements so that when you are discussing requirements with stakeholders internal and external, as well as your project team, you can more easily express what you mean in terms of what type of requirements and for what purpose you wish to write them.
There is quite a bit of overlap in the functions of each of the types of software requirements I'm about to discuss. Keep this in mind, and remember that one of the points of this excercise is to familiarize yourself with the lingo. Knowing what each of these terms for software requirements refers to can help you forget about classifying your requirements and instead focus on just getting the requirements down on paper (or rather into your computer spreadsheet program or requirements management database) quickly.
1. Functional requirements are generally written from a bird's-eye viewpoint, or at a high level, although they can also be very detailed, and contain annotations and notes, as well as references to other materials such as screen and page mockups and flow diagrams. They can describe not only what the system under construction should do, but also what it should not do.
2. Nonfunctional requirements are boundary conditions or externalities to the system under construction which will effect the performance envelope or capabilities of the system once it is operation. These types of requirements may include things such as environmental constraints, compliance with federal and state laws or industry regulations, safety standards, timing constraints, quality or uptime properties, programming languages to be used, etc.
3. Design constraint requirements include nonfunctional requirements that relate to hardware limitations and industry standards compliance.
4. Logical database requirements include things such as required data models or database schemas, data entity relationship diagrams (ERDs) stipulating database requirements, data entities and their required relationships, data retention and data integrity constraints, as well as database requirements that specify data access frequency of use data and accessing capabilities.
5. Domain requirements are a type of nonfunctional requirement which has been dictated to the system designers by the application's domain of operation. For example, a health care application software system may have data integrity and security domain requirements which are derived from the HIPAA health care industry standards regarding private health care information (PHI). Domain requirements may impose new functional requirements or boundary conditions on existing requirements.
6. System attribute requirements are functional requirements which include information regarding the desired system availability, reliability, maintainability, portability and security.
7. Interface specifications are yet another type of functional requirements for software systems which are defined in terms of specifying how the system should interoperate with other software systems. There are many types of formalized notation systems used to specify these types of interfaces, including UML, or unified modeling language diagrams. The interface specifications focus on defining the data entities to be exchanged with other software systems, their structures and representations, as well as defining the interfaces themselves.
7. Performance requirements quantify the desired performance of the system being constructed. Performance requirements are a type of functional requirement, and there are two major types of performance requirements, those that measure or stipulate the performance of static system objects, processes or events, and those that stipulate the performance of dynamic system objects, processes or events. Performance requirements for software system generally take the form of numerically expressed time constraints. A software system's static performance requirements might include things such as the number of simultaneous users the system would need to support at any given moment of time, whereby a system's dynamic performance requirements might include such constraints as the number of work orders that would need to be processed by the system within certain time periods for both normal and peak workload conditions.
How are software requirements validated?
It is important to ensure that the requirements for the software system under construction accurately represent not only what the software developers and programmers are building, but also what the customer or client originally desired. Validation is very important, as catching requirement errors early on in the software development lifecycle reduces expense greatly. Rectifying a requirements error after delivery may cost up to 100 times the cost of fixing an implementation error.
The IEEE has developed another standard, IEEE 830, for best practices for validating software requirements. The IEEE 830 standard lays out some suggested process improvements and gateways, including:
1. Requirements reviews.
2. Manual systematic analysis of the requirements.
3. Software prototyping.
4. Using an executable model of the system in order to verify the requirements.
5. Test case generation.
6. Developing test cases from the requirements in order to validate that they are in fact testable and verifiable requirements as written.
7. Automated consistency analysis.
What is software requirements modeling?
There are a number of different techniques which can be used to model software requirements. Some of these software requirements modeling techniques I have discussed at length elsewhere in this hub tech insider blog, and some of the other techniques for modeling requirements I will explore in more detail within these pages in future articles. User stories, user goals, use cases, and UML diagrams are some of the techniques oftentimes used to model software requirements, but there are many others including formal methods, natural languages, and structured diagrams.
The reason that modeling techniques are used in addition to prose requirements is that English, or any other natural language, inherently adds difficulty to the process of communicating requirements for the production of software. These difficulties can include lack of precision and clarity of language to the improper mixing of functional and nonfunctional requirements. The needless overcomplexity of combining requirements until they no longer make sense, in a weird amalgamation of needs, is a common problem, as is ambiguity of language.
How do you conduct a requirements elicitation and gathering session?
There are many common problems encountered when elicitating requirements for a software system to be constructed. Requirements elicitation is a process in which requirements engineers or business analysts work with customers in order to determine the proposed system's operational constraints, services, and application scope. There are many people involved in most requirements elicitation and gathering phases of a software development project, and they are collectively known as project stakeholders. Project stakeholders may include domain experts, managers, engineers, end users, and other internal and external personnel.
One of the primary concerns of the requirements engineer is eliciting requirements from stakeholders who are not sure what it is they really want from the system under discussion. Stakeholders can in fact introduce many serious detrimental issues into the requirements gathering and elicitation process that you should be aware of. These can include expressing requirements in their own, often incorrect terminology, providing conflicting requirements, and the introduction by stakeholders of organizational politics and other bureaucratic externalities which may unduly influence the requirements. It is not at all uncommon for stakeholders to feel free to change the requirements at will in response to new stakeholders who may emerge mid-project, as well as shifting business environments. All of these detrimental factors must be carefully monitored and counteracted by the requirements engineer when necessary.
Source: HubTechInsider, https://hubtechinsider.wordpress.com/2011/07/28/how-do-you-write-software-requirements-what-are-software-requirements-what-is-a-software-requirement/
This work is licensed under a Creative Commons Attribution 3.0 License.