Daniel Aceituna

Evaluating the use of model-based requirements verification method: A feasibility study

Requirements engineering is one of the most important and critical phases in the software development life cycle, and should be carefully performed to build high quality and reliable software. However, requirements are typically gathered through various sources and represented in natural language (NL), making requirements engineering a difficult, fault prone, and a challenging task. To address this challenge, we propose a model-based requirements verification method called NLtoSTD, which transforms NL requirements into a state transition diagram (STD) that can be verified through automated reasoning. This paper analyzes the effect of NLtoSTD method in improving the quality of requirements. To do so, we conducted an empirical study at North Dakota State University in which the participants employed the NLtoSTD method during the inspection of requirement documents to identify the amibiguities and incompleteness of requirements. The experiment results show that the proposed method is capable of finding ambiguities and missing functionalities in a set of NL requirements, and provided us with insights and feedback to improve the method. The results are promising and have motivated the refinement of NLtoSTD method and future empirical evaluation.

Exposing the susceptibility of off-nominal behaviors in reactive system requirements

Requirements are typically specified on the assumption that the systems operating environment will behave in what is considered to be an expected and nominal manner. When gathering requirements, one concern is whether the requirements are too incomplete to account for every possible, unintended, off-nominal behavior (ONB) that the operating environment can create in the system. In this paper, we present a semi-automated approach, based on the causal component model (CCM), which can expose, within a set of requirements, whether ONBs can result in undesired system states. We demonstrate how the CCM approach exposes and helps address potential off-nominal behavior problems in a set of requirements that represents a real-world product. Our case study shows that the approach can expose susceptibility to ONBs and can supply information in correcting requirements.

A systematic approach to transforming system requirements into model checking specifications

We propose a method that addresses the following dilemma: model checking can formally expose off-nominal behaviors and unintended scenarios in the requirements of concurrent reactive systems. Requirements engineers and non-technical stakeholders who are the system domain experts can greatly benefit from jointly using model checking during the elicitation, analysis, and verification of system requirements. However, model checking is formal verification and many requirements engineers and domain experts typically lack the knowledge and training needed to apply model checking to the formal verification of requirements. To get full advantages of model checking and domain experts’ knowledge in verifying the system, we proposed a front end framework to model checking and evaluated our approach using a real world application.

Model-based requirements verification method

ContextRequirements engineering is one of the most important and critical phases in the software development life cycle, and should be carefully performed to build high quality and reliable software. However, requirements are typically gathered through various sources and are represented in natural language (NL), making requirements engineering a difficult, fault prone, and a challenging task. ObjectiveTo ensure high-quality software, we need effective requirements verification methods that can clearly handle and address inherently ambiguous nature of NL specifications. The objective of this paper is to propose a method that can address the challenges with NL requirements verification and to evaluate our proposed method through controlled experiments. MethodWe propose a model-based requirements verification method, called NLtoSTD, which transforms NL requirements into a State Transition Diagram (STD) that can help to detect and to eliminate ambiguities and incompleteness. The paper describes the NLtoSTD method to detect requirement faults, thereby improving the quality of the requirements. To evaluate the NLtoSTD method, we conducted two controlled experiments at North Dakota State University in which the participants employed the NLtoSTD method and a traditional fault checklist during the inspection of requirement documents to identify the ambiguities and incompleteness of the requirements. ResultsTwo experiment results show that the NLtoSTD method can be more effective in exposing the missing functionality and, in some cases, more ambiguous information than the fault-checklist method. Our experiments also revealed areas of improvement that benefit the methods applicability in the future. ConclusionWe presented a new approach, NLtoSTD, to verify requirements documents and two controlled experiments assessing our approach. The results are promising and have motivated the refinement of the NLtoSTD method and future empirical evaluation.

Interactive requirements validation for reactive systems through virtual requirements prototype

Adequate requirements validation can prevent errors from propagating into later development phases, and eventually improve the quality of software systems. However, validating natural language requirements is often difficult and error-prone. An effective means of requirements validation for embedded software systems has been to build a working model of the requirements in the form of a physical prototype that stakeholders can interact with. However, physical prototyping can be costly, and time consuming, extending the time it takes to obtain and implement stakeholder feedback. We have developed a requirements validation technique, called Virtual Requirements Prototype (VRP), that reduces cost and stakeholder feedback time by allowing stakeholders to validate embedded software requirements through the interaction with a virtual prototype.

SQ^(2)E: An Approach to Requirements Validation with Scenario Question

Adequate requirements validation could prevent errors from propagating into later development phase, and eventually improve the quality of software systems. However, often validating textual requirements is difficult and error prone. We develop a feedback-based requirements validation methodology that provides an interactive and systematic way to validate a requirements model. Our approach is based on the notion of querying a model, which is built from a requirements specification, with scenario questions, in order to determine whether the models behavior satisfies the given requirements. To investigate feasibility of our approach, we implemented a Scenario Question Query Engine (SQ2E), which uses scenario questions to query a model, and performed a preliminary case study using a real-world application. The results show that the approach we proposed was effective in detecting both expected and unexpected behaviors in a model. We believe that our approach could improve the quality of requirements and ultimately the quality of software systems.

A combinatorial approach for exposing off-nominal behaviors

Off-nominal behaviors (ONBs) have been a major concern in the areas of embedded systems and safety-critical systems. To address ONB problems, some researchers have proposed model-based approaches that can expose ONBs by analyzing natural language requirements documents. While these approaches produced promising results, they require a lot of human effort and time. In this paper, to reduce human effort and time, we propose a combinatorial–based approach, Combinatorial Causal Component Model (Combi-CCM), which uses structured requirements patterns and combinations generated using the IPOG algorithm. We conducted an empirical study using several requirements documents to evaluate our approach, and our results indicate that the proposed approach can reduce human effort and time while maintaining the same ONB exposure ability obtained by the control techniques.

Addressing the state explosion problem when visualizing off-nominal behaviors in a set of reactive requirements

Reactive systems with a large degree of human interaction can be vulnerable to off-nominal behaviors (ONBs) that arise from the human operator’s unpredictability. In prior research, we have addressed the ONB problems by developing an approach to translating a set of reactive requirements into the rule-based causal component model (CCM). The CCM’s analysis involved expanding the CCM rules into a larger set of rules that encompass the system’s entire state space, displaying both nominal and off-nominal behaviors as transition paths. However, a major limitation of CCM is the potential for state explosion, which grows as a function of the system’s component states. In this paper, we introduce the causal scenario model (CSM), which uses the same rule-based approach, while addressing the state explosion problem associated with CCM. The CSM grows as a function of system components and provides a visually concise alternative to CCM, while still providing information useful in the exposing and addressing of ONBs during the requirements analysis phase. We introduce CSM and demonstrate the effectiveness of CSM, using a case study that would be more difficult to visualize using CCM, and most other state-based modeling techniques.