Glossary of Requirements Engineering Terms

acceptance criteria: Conditions that a software product must satisfy to be accepted by a user, customer, or other stakeholder.

acceptance test: A test that evaluates anticipated usage scenarios to determine the software's acceptability. Used in agile development both to express details about a user story and to determine whether a user story is fully and correctly implemented.

activity diagram: An analysis model that depicts a process flow proceeding from one activity to another. Similar to a flowchart.

actor: A person performing a specific role, a software system, or a hardware device that interacts with a system to achieve a useful goal. Also called a user role.

agile development: A term used for software development methods characterized by continuous collaboration between developers and customers, limited documentation of requirements in the form of user stories and corresponding acceptance tests, and rapid and frequent delivery of small increments of useful functionality. Agile development methods include Extreme Programming, Scrum, Feature-Driven Development, Lean Software Development, and Kanban.

allocation: See requirements allocation.

alternative flow: A path through a use case that leads to success but that involves a variation from the normal flow in the specifics of the task or in the actor's interaction with the system.

analysis, requirements: The process of classifying requirements information into various categories, evaluating requirements for desirable qualities, representing requirements in different forms, deriving detailed requirements from high-level requirements, negotiating priorities, and related activities.

analyst: See business analyst.

application: See product.

architecture: The structure of a system, including any software, hardware, and human components that make up the system, the interfaces and relationships between those components, and the component behaviors that are visible to other components.

assumption: A statement that is believed to be true in the absence of proof or definitive knowledge.

attribute, quality: See quality attribute.

attribute, requirement: See requirement attribute.

BA: See business analyst.

backlog, product: On an agile project, the prioritized list of work remaining for the project. A backlog can contain user stories, business processes, change requests, infrastructure development, and defect stories. Work items from the backlog are allocated to upcoming iterations based on their priority.

baseline, requirements: A snapshot in time that represents the current agreed-upon, reviewed, and approved set of requirements, often defining the contents of a specific product release or development iteration. Serves as the basis for further development work.

big data: A collection of data that is characterized as large volume (much data exists), high velocity (data flows rapidly into an organization), and/or highly complex (the data is diverse). Managing big data entails understanding how to discover, collect, store, and process the data quickly and effectively.

business analyst (BA): The role on a project team that has primary responsibility for working with stakeholder representatives to elicit, analyze, specify, validate, and manage the project's requirements. Also called a requirements analyst, system analyst, requirements engineer, requirements manager, business systems analyst, and simply analyst.

business analytics system: A software system used to convert large and complex data sets into meaningful information from which to make decisions.

business objective: A financial or nonfinancial business benefit that an organization expects to receive as a result of a project or some other initiative.

business objectives model: A visual representation of a hierarchy of business problems and business objectives.

business requirement: A set of information that describes a business need that leads to one or more projects to deliver a solution and the desired ultimate business outcomes. The business requirements include business opportunities, business objectives, success metrics, a vision statement, and scope and limitations.

business rule: A policy, guideline, standard, regulation, or computational formula that defines or constrains some aspect of the business.

cardinality: The number of instances of a particular data entity that logically relates to an instance of another entity. Possibilities are one-to-one, one-to-many, and many-to-many.

change control board: The group of people responsible for deciding to accept or reject proposed changes on a software project, including changes in requirements.

class: A description of a set of objects having common properties and behaviors, which typically correspond to real-world items (persons, places, or things) in the business or problem domain.

class diagram: An analysis model that shows a set of system or problem domain classes, their interfaces, and their relationships.

constraint: A restriction that is imposed on the choices available to the developer for the design and construction of a product. Other types of constraints can restrict the options available to project managers. Business rules often impose constraints on business operations and hence on software systems.

context diagram: An analysis model that depicts a system at a high level of abstraction. The context diagram identifies objects outside the system that exchange data with the system, but it shows nothing about the system's internal structure or behavior.

COTS (commercial off-the-shelf) product: A software package purchased from a vendor and either used as a self-contained solution to a problem or integrated, customized, and/or extended to satisfy customer needs.

CRUD matrix: A table that correlates system actions with data entities to show where each data item is created, read, updated, and deleted.

customer: An individual or organization that derives either direct or indirect benefit from a product. Software customers might request, pay for, select, specify, use, or receive the output generated by a software product.

dashboard report: A screen display or printed report that uses multiple textual and/or graphical representations of data to provide a consolidated, multidimensional view of what is going on in an organization or a process.

data dictionary: A collection of definitions for the data elements and data structures that are relevant to the problem domain.

data flow diagram: An analysis model that depicts the processes, data stores, external entities, and flows among them that characterize the behavior of data flowing through business processes or software systems.

decision rule: An agreed-upon way by which a body of people arrives at a decision.

decision table: An analysis model in the form of a matrix that shows all combinations of values for a set of conditions and indicates the expected system action in response to each combination.

decision tree: An analysis model that visually depicts the actions a system takes in response to specific combinations of a set of conditions.

dependency: As used in requirements specification, a reliance that a project has on a factor, event, or group outside its control.

dialog map: An analysis model that depicts a user interface architecture, showing the display elements and the navigations permitted between them.

ecosystem map: An analysis model that shows a set of systems that interact with each other and the nature of their relationships. Unlike a context diagram, an ecosystem map shows systems that have a relationship even if there is no direct interface between them.

elicitation, requirements: The process of identifying requirements from various sources through interviews, workshops, focus groups, observations, document analysis, and other mechanisms.

embedded system: A system that contains hardware components controlled by software running on a dedicated computer that is incorporated as part of a larger product.

entity: An item in the business domain about which data is collected and stored.

entity-relationship diagram: An analysis model that identifies the logical relationships between pairs of entities. Used for modeling data.

epic: A user story on an agile project that is too large to implement in one development iteration. It is subdivided into smaller stories that each can be fully implemented in a single iteration.

event: A trigger or stimulus that takes place in a system's environment that leads to a system response, such as a functional behavior or a change in state.

event-response table: A list of the external or time-triggered events that could affect the system and a description of how the system is to respond to each event.

evolutionary prototype: A fully functional prototype created as a skeleton or an initial increment of the final product, which is fleshed out and extended incrementally as requirements become clear and ready for implementation.

exception: A condition that can prevent a use case from concluding successfully. Unless some recovery mechanism is possible, the use case's postconditions are not reached and the actor's goal is not achieved.

extend relationship: A construct in which an alternative course in a use case interrupts the normal sequence of steps. The steps that the actor follows when executing the alternative course can be packaged into an extension use case that is invoked to complete the alternative.

external entity: An object in a context diagram or a data flow diagram that represents a user class, actor, software system, or hardware device that is external to the system being described but interfaces to it in some fashion. Also called a terminator.

external interface requirement: A description of a connection between a software system and a user, another software system, or a hardware device.

facilitator: A person who is responsible for planning and leading a group activity, such as a requirements elicitation workshop.

feature: One or more logically related system capabilities that provide value to a user and are described by a set of functional requirements.

feature tree: An analysis model that depicts the features planned for a product in a hierarchical tree, showing up to two levels of subfeatures beneath each main feature.

flowchart: An analysis model that shows the processing steps and decision points in the logic of a process. Similar to an activity diagram.

function point: A measure of software size, based on the number and complexity of internal logical files, external interface files, external inputs, outputs, and queries.

functional requirement: A description of a behavior that a software system will exhibit under specific conditions.

gap analysis: A comparison of the current state to an alternative or potential state for a system, process, or other aspect of a business situation, to identify significant differences between them.

gold plating: Unnecessary or excessively complex functionality that is specified or built into a product, sometimes without customer approval.

green-field project: A project in which new software or a new system is developed.

horizontal prototype: See mock-up.

include relationship: A construct in which several steps that recur in multiple use cases are factored out into a separate sub-use case, which the other use cases then invoke when needed.

inspection: A type of formal peer review that involves a trained team of individuals who follow a well-defined process to examine a work product carefully for defects.

issue, requirement: A defect, open question, or decision regarding a requirement. Examples include items flagged as TBD, pending decisions, information that is needed, and conflicts awaiting resolution.

iteration: An uninterrupted development period, typically one to four weeks in duration, during which a development team implements a defined set of functionality selected from the product backlog or baselined requirements for the product.

mock-up: A partial or possible representation of a user interface for a software system. Used to evaluate usability and to assess the completeness and correctness of requirements. Could be executable or could be in the form of a paper prototype. Also called a horizontal prototype.

navigation map: See dialog map.

nonfunctional requirement: A description of a property or characteristic that a software system must exhibit or a constraint that it must respect, other than an observable system behavior.

normal flow: The default sequence of steps in a use case, which leads to satisfying the use case’s postconditions and letting the user achieve his goal. Also known as the normal course, main course, normal sequence, and main success scenario.

operational profile: A suite of scenarios that represents the expected usage pattern of a software product.

paper prototype: A nonexecutable mock-up of a software system’s user interface using inexpensive, low-tech screen sketches.

peer review: An activity in which one or more persons other than the author of a work product examine that product with the intent of finding defects and improvement opportunities.

pilot: A controlled execution of a new solution (such as a process, tool, software system, or training course) with the objective of evaluating the solution under real conditions to assess its readiness for general deployment.

Planguage: A keyword-oriented language developed by Tom Gilb that enables precise and quantitative specification of requirements, particularly nonfunctional requirements.

postcondition: A condition that describes the state of a system after a use case is successfully completed.

precondition: A condition that must be satisfied or a state the system must be in before a use case can begin.

prioritization: The act of determining which requirements for a software product are the most important for achieving business success and the sequence in which requirements should be implemented.

procedure: A step-by-step description of a course of action to be taken to perform a specified activity, describing how the activity is to be accomplished.

process: A sequence of activities performed for a particular purpose. A process description is a documented definition of those activities.

process assets: Items such as templates, forms, checklists, policies, procedures, process descriptions, and sample work products that are collected to assist an organization's effective application of software development practices.

process flow: The sequential steps of a business process or the operations of a proposed software system. Often represented by using an activity diagram, flowchart, swimlane diagram, or other modeling notation.

product: Whatever ultimate deliverable a project is developing. In this book, product, application, system, and solution are used interchangeably.

product backlog: See backlog, product.

product champion: A designated representative of a specific user class who supplies the user requirements for the group that he or she represents.

product owner: A role, typically on an agile project team, that represents the customer and that is responsible for setting the product vision, providing project boundaries and constraints, prioritizing the contents of the product backlog, and making product decisions.

proof of concept: A prototype that implements a portion of a software-containing system that slices through multiple layers of the architecture. Used to evaluate technical feasibility and performance. Also called a vertical prototype.

prototype: A partial, preliminary, or possible implementation of a software system. Used to explore and validate requirements and design approaches. Types of prototypes are evolutionary and throwaway; paper and electronic; and mock-up and proof-of-concept.

quality attribute: A nonfunctional requirement that describes a service or performance characteristic of a product. Types of quality attributes include usability, portability, maintainability, integrity, efficiency, reliability, and robustness. Quality attribute requirements describe the extent to which a software product must demonstrate desired characteristics.

quality-of-service requirement: See quality attribute.

real-time system: A hardware and software system that must produce a response within a specified time after an initiating event.

requirement: A statement of a customer need or objective, or of a condition or capability that a product must possess to satisfy such a need or objective. A property that a product must have to provide value to a stakeholder.

requirement attribute: Descriptive information about a requirement that enriches its definition beyond the statement of intended functionality. Example attribute types are origin, rationale, priority, owner, release number, and version number.

requirement pattern: A systematic approach to specifying a particular type of requirement.

requirements allocation: The process of apportioning system requirements among various architectural subsystems and components.

requirements analysis: See analysis, requirements.

requirements analyst: See business analyst.

requirements development: The process of defining a project's scope, identifying user classes and user representatives, and eliciting, analyzing, specifying, and validating requirements. The product of requirements development is a set of documented requirements that defines some portion of the product to be built.

requirements engineer: See business analyst.

requirements engineering: The subdiscipline of systems engineering and software engineering that encompasses all project activities associated with understanding a product's necessary capabilities and attributes. Includes both requirements development and requirements management.

requirements management: The process of working with a defined set of requirements throughout the product's development process and its operational life. Includes tracking requirements status, managing changes to requirements, controlling versions of requirements specifications, and tracing individual requirements to other requirements and system elements.

requirements specification: See software requirements specification and specification, requirements.

requirements traceability matrix: A table that depicts logical links between individual functional requirements and other system artifacts, including other functional requirements, user requirements, business requirements, architecture and design elements, code modules, tests, and business rules.

retrospective: A review in which project participants reflect on the project's activities and outcomes with the intent of identifying ways to make the next project be even more successful.

reuse, requirements: The act of using existing requirements knowledge in multiple systems that share some similar functionality.

review: See peer review.

risk: A condition that could cause some loss or otherwise threaten the success of a project.

root cause analysis: An activity that seeks to understand the underlying factors that contribute to an observed problem.

scenario: A description of a specific interaction between a user and a system to accomplish some goal. Alternatively, an instance of usage of the system, or a specific path through a use case.

scope: The portion of the ultimate product vision that the current project will address. The scope draws the boundary between what's in and what's out for a project that creates a specific release or for a single development iteration.

scope creep: A condition in which the scope of a project continues to increase in an uncontrolled fashion throughout the development process.

software development life cycle: A sequence of activities by which a software product is defined, designed, built, and verified.

software requirements specification (SRS): A collection of the functional and nonfunctional requirements for a software product.

solution: All of the components delivered by a project to achieve a set of business objectives specified by an organization, including software, hardware, business processes, user manuals, and training.

specification, requirements: The process of documenting a software application's requirements in a structured, shareable, and manageable form. Also, the product from this process. (see software requirements specification).

sprint: See iteration.

SRS: See software requirements specification.

stakeholder: An individual, group, or organization that is actively involved in a project, is affected by its process or outcome, or can influence its process or outcome.

state machine diagram: An analysis model that shows the sequence of states that an object in a system goes through during its lifetime in response to specific events that take place, or that shows the possible states of the system as a whole. Similar to a state-transition diagram.

state table: An analysis model that shows in matrix form the various states that a system, or an object in the system, can be in, and which of the possible transitions between states are allowed.

state-transition diagram: An analysis model that visually depicts the various states in which a system or an object in the system can exist, the permitted transitions that can take place between states, and the conditions and/or events that trigger each transition. Similar to a state machine or statechart diagram.

story: See user story.

subject matter expert: An individual who has extensive experience and knowledge in a domain and who is recognized as an authoritative source of information about the domain.

swimlane diagram: An analysis model that shows the sequential steps of a business process flow or the operations of a proposed software system. The process is subdivided into visual components called lanes, which show the systems or actors that execute the steps.

system: A product that contains multiple software and/or hardware subsystems. Colloquially, system also is used interchangeably in this book with application, product, and solution to refer to whatever software-containing deliverable a team is building.

system requirement: A high-level requirement for a product that contains multiple subsystems, which could be all software or software and hardware.

TBD: Abbreviation for to be determined. TBD serves as a placeholder when you know you are missing some requirements information. See issue, requirement.

template: A pattern to be used as a guide for producing a complete document or other item.

throwaway prototype: A prototype that is created with the intent of discarding it after it has served its purpose of clarifying and validating requirements and/or design alternatives.

tracing: The process of defining logical links between one system element (user requirement, functional requirement, business rule, design component, code module, test, and the like) and another. Also called traceability.

UML: An abbreviation for the Unified Modeling Language, which describes a set of standard notations for creating various visual models of systems, particularly for object-oriented software development.

usage scenario: See scenario.

use case: A description of a set of logically related possible interactions between an actor and a system that results in an outcome that provides value to the actor. Can encompass multiple scenarios.

use case diagram: An analysis model that identifies the actors who can interact with a system to accomplish valuable goals and the various use cases that each actor might be involved with.

user: A customer who will interact with a system either directly or indirectly (for example, by using outputs from the system but not generating those outputs personally). Also called end user.

user class: A group of users for a system who have similar characteristics and requirements for the system. Members of a user class function as actors when interacting with the system through use cases.

user requirement: A goal or task that specific classes of users must be able to perform with a system, or a desired product attribute. Use cases, user stories, and scenarios are common ways to represent user requirements.

user role: See actor.

user story: A format to capture user requirements on agile projects in the form of one or two sentences that articulate a user need or describe a unit of desired functionality, as well as stating the benefit of the functionality to the user.

validation: The process of evaluating a project deliverable to determine whether it satisfies customer needs. Often stated as "Are we building the right product?"

verification: The process of evaluating a project deliverable to determine whether it satisfies the specifications on which it was based. Often stated as "Are we building the product right?"

vertical prototype: See proof of concept.

vision: A statement that describes the strategic concept or the ultimate purpose and form of a new system.

vision and scope document: A collection of the business requirements for a new system, including business objectives, success criteria, a product vision statement, and a project scope description.

waterfall development life cycle: A model of the software development process in which the various activities of requirements, design, coding, testing, and deployment are performed sequentially with little overlap or iteration.

wireframe: A kind of throwaway mock-up prototype that is often used for preliminary webpage design.

work product: Any interim or final deliverable created for a software project.