Object-oriented requirements: reusable, understandable, verifiable

TL;DR

This paper advocates applying object-oriented principles to requirements engineering to enhance reusability, understandability, and verifiability, supported by an online library of reusable templates to promote a unified approach.

Contribution

It introduces an object-oriented approach to requirements and provides an online library of reusable templates as practical tools.

Findings

Object-oriented thinking improves requirement qualities

Reusable templates facilitate requirements reuse

Unified treatment enhances understandability and verifiability

Abstract

Insufficient requirements reusability, understandability and verifiability jeopardize software projects. Empirical studies show little success in improving these qualities separately. Applying object-oriented thinking to requirements leads to their unified treatment. An online library of reusable requirement templates implements recurring requirement structures, offering a starting point for practicing the unified approach.

Figures

Full text

1 Introduction

The industry is not actively applying requirements reuse [1], which is regrettable: it might help, if practiced, not only to save resources in the requirements specification phase, but also to obtain documents of better quality both in content and syntax. It might also decrease the risk of writing low quality requirements and lead to the reuse of design, code, and tests.

Bertrand Meyer in 1985 described seven understandability problems common to natural-language specifications [2] and proposed the process of passing them through a formal notation to produce their more understandable versions. He has more recently given a name to the approach – “The Formal Picnic Approach”111https://tinyurl.com/ycn526rm. The amount of requirements and their volatility have grown, and the seven problems remain valid. Formal picnics should be practiced more actively and should be reusable across projects.

The general problem of reuse finds itself in requirements’ verifiability too. Requirements’ verifiable semantics follows several recurring patterns in most of the cases [3]. If a pattern exists, it should be reused, and to be reused it should be encoded as a template. The template should also be connected to the main instruments of software verification – tests and contracts.

Applying object-oriented thinking to the problems of requirements reusability, understandability and verifiability draws a new roadmap towards addressing them simultaneously. A reusable library of requirement templates, taking the familiar form of object-oriented classes, provides a starting point for practicing the approach. Each template encodes a formal semantics pattern [3] as a generic class reusable across projects and components, for verifying candidate solutions through either testing or program proving.

2 The Problem Explained

2.1 Reusability

Reusability has become a success story in the reuse of code [4] and tests [5], but not requirements. On that side too, many patterns recur again and again, causing undue repetition of effort and mistakes. The practice of industrial projects, however, involves little reuse of requirements. Textual copy and subsequent modification of requirements from previous projects are still the most commonly used requirements reuse techniques [1], which has already been long recognized as deficient in the world of code reuse.

The most critical factors inhibiting the industrial adoption of requirements reuse through software requirement patterns (SRP) catalogues are [1]:

• •

The lack of a well-defined reuse method.

• •

The lack of quality and incompleteness of requirements to reuse.

• •

The lack of convenient tools and access facilities with suitable requirements classification.

Scientific literature studying requirements reuse approaches pays little attention to these factors when measuring the studied approaches [6]. The degree of reuse is the most frequently measured variable, but it is measured under the assumption that the evaluated approach is fully practiced. This assumption does not meet the reality: most of the practitioners who declare to practice requirements reuse approaches, apply them very selectively [1]. Secondary studies, which study other studies, equally ignore the factors that matter to practitioners [6].

2.2 Understandability

Bertrand Meyer, in his work “On Formalism in Specifications”[2], described “the seven sins of the specifier” – a classification of the frequently recurring flaws in requirements specifications. Analyzing a specification of a well-known text-processing problem illustrated that even a small and carefully written natural-language requirements document may suffer from the following problems:

• •

Noise – the presence in the text of an element that does not carry information relevant to any feature of the problem. Variants: redundancy; remorse.

• •

Silence – the existence of a feature of the problem that is not covered by any element of the text.

• •

Overspecification – the presence in the text of an element that corresponds not to a feature of the problem but to features of a possible solution.

• •

Contradiction – the presence in the text of two or more elements that define a feature of the system in an incompatible way.

• •

Ambiguity – the presence in the text of an element that makes it possible to interpret a feature of the problem in at least two different ways.

• •

Forward reference – the presence in the text of an element that uses features of the problem not defined until later in the text.

• •

Wishful thinking – the presence in the text of an element that defines a feature of the problem in such a way that a candidate solution cannot realistically be validated with respect to this feature.

Identified in the times when software processes were following the Waterfall model, which takes good care of every software development lifecycle phase, these problems remain. Nowadays processes pursue continuity, and requirements analysts have little time to process new requirements before passing them to the developers. The processes are iterative and collecting requirements for another iteration often starts before the current iteration finishes. The pace of work lowers availability of expert developers for evaluating the new requirements’ verifiability. The pervasiveness of Internet technologies like Google Search brings problems too. Many sources of unclear origins now offer tons of potentially unchecked information, which is sometimes overly trusted.

Denying the progress makes no sense, however. Requirements engineering tools should help the practitioners to improve the quality of information they consume and rely on. The improved information should be reusable across projects.

2.3 Verifiability

The reusability concern applies to requirements’ verifiability as well. Dwyer et al. analyzed 555 specifications for finite-state verification from different domains and successfully matched 511 of them against 23 known patterns [3]. The patterns were encoded in modeling notations without a guidance on how to reuse them across projects for verifying candidate solutions. The gap still exists, and the state-of-the-practice [1] and literature reviews [6] of requirements reuse approaches, as well as the studies they cite, do not evaluate requirements’ verifiability in the studied approaches.

Requirements reuse approaches should properly address the verifiability aspect: reusing non-verifiable requirements makes little sense. The appraoches should make it clear how to capture and reuse recurring verifiable semantics’ structures.

3 Running Example

Wikipedia represents a notable example of an intensely used and trusted Internet resource. The rest of the discussion relies on a Wikipedia page describing a 24-hour clock222https://tinyurl.com/ybocy485 as a requirements document example. The “24-hour clock” document is prone to the seven requirements understandability problems [2]. It only has few statements relevant to clock behavior:

The 24-hour clock is a way of telling the time in which the day runs from midnight to midnight and is divided into 24 hours, numbered from 0 to 24. 2. 2.

A time in the 24-hour clock is written in the form hours:minutes (for example, 01:23), or hours:minutes:seconds (01:23:45). 3. 3.

Numbers under 10 usually have a zero in front (called a leading zero); e.g. 09:07. 4. 4.

Under the 24-hour clock system, the day begins at midnight, 00:00, and the last minute of the day begins at 23:59 and ends at 24:00, which is identical to 00:00 of the following day. 5. 5.

12:00 can only be mid-day. 6. 6.

Midnight is called 24:00 and is used to mean the end of the day and 00:00 is used to mean the beginning of the day.

The rest of the text is noise. The “or” connective in Statement 2 results in wishful thinking: is it acceptable to decide between the two options for every clock object, or should the decision be taken once and uniformly applied to all objects? None of the requirements after Statement 2 talk about seconds, from which it follows that the author silently made the choice in favor of the “hours:minutes” format. This “sin” falls into the silence category. The “usually” qualification introduces the wishful thinking problem to Statement 3: how are the developers expected to check candidate solutions against this requirement? Statements 4 and 6 result in a contradiction each other: statement 4 says that midnight is 00:00, while statment 6 defines 24:00 as midnight and 00:00 as the beginning of the day. The contradiction may arise as a result of forward referencing: 24:00 and 00:00 are only defined in 6, while first used in 1 and 4. The last part of Statement 4 is a remorse: the author implicitly admits that the first part of the statement was not enough and adds the “which is…” part. Statement 5 introduces an ambiguity, since the document never defines the “mid-day”. Moreover, terms like “mid-day”, “midnight”, “afternoon” should be defined through specific clock states; it is not clear then what the author means by saying that a specific state can only be mid-day/midnight/afternoon: it can be whatever, depending on the terminology.

The illustration of the object-oriented requirements approach handles a fragment of Statement 1.: “the day runs from midnight to midnight”, referred to as “Statement 1.1”. Understanding this requirement’s treatment will suffice to understand the approach. A GitHub repository 333https://tinyurl.com/y6w7nlcs hosts the complete treatment of the “24-hour clock” example.

4 Reuse Methodology

Requirements reuse methodologies are essentially bidimensional [6]. The first dimension, known as development for reuse, describes the procedure of identifying and capturing new requirement patterns. The second dimension, known as development with reuse, describes the process of searching and reusing the captured patterns for specifying new requirements with lower efforts as compared to specifying them without the patterns.

4.1 Development for Reuse

Given a collection of requirements:

Perform the standard commonality and variability analysis on the collection. 2. 2.

Capture the identified commonality in an object-oriented class. 3. 3.

Capture the semantical commonality through a contracted routine [5], [7] to support verification. 4. 4.

Capture the structural commonality through a string function to support formal picnics. 5. 5.

Parameterize the identified variability points through abstraction and genericity.

4.2 Development with Reuse

Given an informal requirement:

Analyze the requirement’s meaning and structure. 2. 2.

Find the most appropriate requirement template class through the IDE’s search facilities. 3. 3.

Inherit from the found template in a new class representing the requirement. 4. 4.

Refine the abstractions into domain definitions. 5. 5.

Replace the genericity with the specified types and domain definitions. 6. 6.

Perform a formal picnic to see if the new string representation of the requirement has a different meaning from the original one. 7. 7.

Verify candidate solutions through running [5] or proving [7] the contracted routine.

5 Technical Artifacts

Two major technical contributions support the method.

5.1 Library of Templates

A ready-to-use GitHub library444https://tinyurl.com/ybd4b5un of template classes captures known requirement patterns [3]. The library represents a result of applying the development for reuse process to the patterns and provides basis for development with reuse. The library is written in Eiffel for readability, but the method scales to other object-oriented languages with support for genericity.

5.2 Library of Multirequirement Patterns

An online OneNote notebook 555https://1drv.ms/u/s!AsXOYPvbmuEyh4IsDdYj-i6V5yX0OA rearranges the original collection of patterns 666http://patterns.projects.cs.ksu.edu in the form of multirequirements [8] to support their understanding. Dwyer et al. have initially developed the patterns in 5 notations: LTL, CTL, GIL, Inca, QRE. Their online collection consists of 5 large pages corresponding to these notations. The alternative collection consists of 23 pages making it possible to study individual patterns in all the 5 notations simultaneously. The representations are clickable and lead to their sources in the original repository developed by Dwyer et al. Each page includes a link leading to the corresponding template in the GitHub library.

6 Applying a Template

The following illustration handles the “Statement 1.1” requirement by applying a reusable template class from the GitHub library. The requirement fits into the “Global Response” pattern [3]. The pattern reads: “S responds to P globally”, for events S and P. It is the most frequently used pattern: out of the 555 analyzed requirements [3], 241 represented this pattern. For “Statement 1.1”, both S and P map to the midnight event: “midnight responds to midnight globally”. This new statement paraphrases the original one, “the day runs from midnight to midnight”.

Class STATEMENT_1_1 (Figure 1(a)) captures the requirement. The class inherits from:

• •

A generic application of class RESPONSE_GLOBAL to classes CLOCK and MIDNIGHT, where RESPONSE_GLOBAL is a generic template encoding the “Global Response” pattern. The RESPONSE_GLOBAL [CLOCK, MIDNIGHT, MIDNIGHT] application reads: “for type CLOCK, MIDNIGHT response to MIDNIGHT globally”.

• •

Class CLOCK_REQUIREMENT recording domain information common to all clock requirements: the fact that the tick routine advances a clock’s state, and the start routine initializes a new clock.

The CLOCK class is a candidate solution implementing the “clock” concept, and the MIDNIGHT class captures the definition of midnight through effecting the deferred holds Boolean function inherited from generic class CONDITION applied to the CLOCK class. The generic application emphasizes the fact that the notion of midnight applies to the notion of clock.

The classes have something in common: the “note” section at the bottom with Web links of two kinds. Links named “Source”, when followed, highlight the fragments in the original requirements documents from which the enclosing requirement classes were derived. Links named “GitHub”, when followed, lead to the enclosing classes’ locations on GitHub. The “Source” link in STATEMENT_1_1, for example, highlights, when followed, the “the day runs from midnight to midnight” phrase in the Google document777https://tinyurl.com/y96rj2v3, and brings the comment on this phrase to the reader’s attention (Figure 1(b)). The comment contains the GitHub link leading back to the STATEMENT_1_1 class on GitHub; this link is identical to the “GitHub” link in the STATEMENT_1_1 class’ “note” section.

7 Formal Picnic

The RESPONSE_GLOBAL class implements its string representation through redefining the standard out function present in all Eiffel classes. Any instruction that expects a string argument, such as print, automatically invokes this function to get the argument’s string representation if the argument has a non-string type.

Routine run of class TESTER (Figure 7) is a configurable entry point of the console application illustrating formal picnics and verification of object-oriented requirements.

Line 11 of TESTER outputs the structured string representation of the STATEMENT_1_1 object-oriented requirement. The .default expression returns the default object of the STATEMENT_1_1 class, and the print instruction puts the object’s string representation to the “Output” window below the “TESTER” window. The requirement’s name, “STATEMENT_1_1”, goes before the colon and its string representation goes after.

The requirements analyst now has two comparable string representations of the requirement: the original and the generated one. Comparing them facilitates analysis and may result in asking clarifying questions to the customer and in additional communication.

8 Verification

The template classes, including RESPONSE_GLOBAL, contain instruments of their own verification in the form of a contracted routine called “verify”. The run routine of the TESTER class may call verify to test a candidate solution.

Line 15 of the TESTER class (Figure 3) tests class CLOCK as a candidate solution of the STATEMENT_1_1 requirement. Line 13 instantiates a CLOCK variable, while lines 14 and 15 use the variable as test input. The following discussion explains the nature of line 14. The line is commented to illustrate the problem that the line fixes when uncommented.

The verify routine has a precondition. For the STATEMENT_1_1 class, the precondition becomes the holds Boolean function from the MIDNIGHT class. This function returns True only for the 24:00 time, and the newly instantiated clock variable is set to time 00:00. Line 14 fixes this mismatch, and its removal crashes the execution. The “Call Stack” window provides information related to the failure: a precondition tagged “p_holds” is violated in STATEMENT_1_1, inherited from the RESPONSE_GLOBAL template class. The testing code should set the clock variable’s state to time 24:00 before testing STATEMENT_1_1; line 14 does exactly this. STATEMENT_0 is a requirement class saying that the midnight state should be in principle achievable by CLOCK. The EXISTENCE_GLOBAL pattern [3] captures this semantics. Line 14 tests CLOCK against STATEMENT_0 by trying to reach the midnight state on the input variable. Uncommenting the line will remove the precondition violation.

The process of deriving STATEMENT_0 is an example of how the verification process may help identify a new requirement and learn a new template.

Program proving and Design by Contract may be used instead of testing. The automatic prover (AutoProof [9] in the context of Eiffel) should be applied to the requirements classes, STATEMENT_0 and STATEMENT_1_1. The prover will statically check the contracted verify routine according to the principles of Hoare logic [10]. The prover will only accept the routine if the CLOCK class has a strong enough and correct contract [7]. The illustration relies on testing because AutoProof, in its current state, requires a lot of additional annotations to check classes like STATEMENT_1_1, and explaining these annotations goes beyond the object-oriented requirements idea’s essentials.

9 Assessment

The approach helps to fix the identified problems undermining the lack of requirements reuse:

• •

The lack of a well-defined reuse method: the reuse method is object-oriented software construction, which is a well-defined method.

• •

The lack of quality and incompleteness of requirements to reuse: the templates library implements the existing collection of specification patterns proven to cover most of the cases, which makes the library complete and quality in that sense.

• •

The lack of convenient tools and access facilities with suitable requirements classification: the tools and access facilities are object-oriented IDEs and GitHub, with all their powerful features. The classification is that of the Dwyer et al.’s collection, proven to be practically relevant.

The approach helps to fix the requirements understandability problems:

• •

Noise: only those requirements remain that fall into an existing verifiable requirement template.

• •

Silence: an attempt to verify existing object-oriented requirements may uncover missing requirements, as it was the case with STATEMENT_0.

• •

Overspecification: only those requirements remain that fall into an existing verifiable requirement template. Implementation details cannot map to a requirement template.

• •

Contradiction: one notion may be defined in only one way, otherwise the IDE will raise a compilation error. The contradiction caused by two inconsistent definitions of midnight was resolved by defining this notion in the form of the MIDNIGHT class.

• •

Ambiguity: little can be done to remove the possibility for different interpretations – the requirements interpretation process is performed by a cognitive agent anyway. If an interpretation is identified as erroneous, however, switching to another template will automatically update both the generated string representation and the underlying verifiable semantics. In other words, the templates may help to reduce the effort spent on fixing the consequences of the misinterpretation.

• •

Forward reference: the approach removes this problem. There is no notion of requirements’ order in the object-oriented approach, and meaningful statements are connected by the standard “client-supplier” relationship, extensively supported by the object-oriented IDEs.

• •

Wishful thinking: only those requirements remain that fall into an existing verifiable requirement template. The compiler will not accept a template’s application in which the verifiable semantics is not fully defined.

The approach helps to fix the requirements verifiability problem. The GitHub library of classes fixes the lack of reusable templates covering the identified verifiable specification patterns. The approach makes it possible to capture and reuse newly identified patterns using the existing object-oriented techniques complemented with contracts.

Besides the benefits, the approach has some limitations:

• •

Requirements analysts’ familiarity with the principles of object-oriented analysis and design.

• •

Software developers’ familiarity with the principles of Hoare logic based reasoning.

10 Supporting Work

The idea to use a programming language as a requirements notation is not new [8], [11], [12], [13] and is well justified. Many groups of stakeholders prefer descriptions of operational activity paths over declarative requirements specifications [14]. A demand exists for educating developers capable of both abstracting in a problem space and automating the transition to a solution space [15].

Other approaches to requirements reuse do not share the aspirations towards connecting the requirements and the solution spaces, as follows both from the state-of-the-practice [1] and the literature [6] studies. The studied approaches focus on reusing natural language, use cases, domain models and several other artifacts disjoint from the solution space.

The decision to express requirements in a programming language may bridge the gap. It may also be the only way to bring the developers closer to the requirements they implement: industry practitioners are generally not keen to switching their tools [16]. The advanced state of code reuse has all chances to skyrocket the state of requirements reuse if the requirements take the form of code.

11 Future Work

Intelligent tools should be embedded into existing text editors for:

• •

Detecting known patterns in what requirements analysts specify manually.

• •

Proposing reusable templates corresponding to the identified patterns.

• •

Identifying new patterns in requirements that do not map to existing patterns.

Natural language processing (NLP) would be an appropriate instrument for implementing these tools [16].