A conceptual framework for requirements engineering

A framework for assessing research and practice in requirements engineering is proposed. The framework is used to survey state of the art research contributions and practice. The framework considers a task activity view of requirements, and elaborates different views of requirements engineering (RE) depending on the starting point of a system development. Another perspective is to analyse RE from different conceptions of products and their properties. RE research is examined within this framework and then placed in the context of how it extends current system development methods and systems analysis techniques.     

Database reverse engineering: From requirements to CARE tools

This paper analyzes the requirements that CASE tools should meet for effective database reverse engineering (DBRE), and proposes a general architecture for data-centered applications reverse engineering CASE environments. First, the paper describes a generic DBMS-independent DBRE methodology, then it analyzes the main characteristics of DBRE activities in order to collect a set of desirable requirements. Finally, it describes DB-MAIN, an operational CASE tool developed according to these requirements. The main features of this tool that are described in this paper are its unique generic specification model, its repository, its transformation toolkit, its user interface, the text processors, the assistants, the methodological control and its functional extensibility. Finally, the paper describes five real-world projects in which the methodology and the CASE tool were applied.     

From types to type requirements: genericity for model-driven engineering

Model-driven engineering (MDE) is a software engineering paradigm that proposes an active use of models during the development process. This paradigm is inherently type-centric, in the sense that models and their manipulation are defined over the types of specific meta-models. This fact hinders the reuse of existing MDE artefacts with other meta-models in new contexts, even if all these meta-models share common characteristics. To increase the reuse opportunities of MDE artefacts, we propose a paradigm shift from type-centric to requirement-centric specifications by bringing genericity into models, meta-models and model management operations. For this purpose, we introduce so-called concepts gathering structural and behavioural requirements for models and meta-models. In this way, model management operations are defined over concepts, enabling the application of the operations to any meta-model satisfying the requirements imposed by the concept. Model templates rely on concepts to define suitable interfaces, hence enabling the definition of reusable model components. Finally, similar to mixin layers, templates can be defined at the meta-model level as well, to define languages in a modular way, as well as layers of functionality to be plugged-in into other meta-models. These ideas have been implemented in MetaDepth, a multi-level meta-modelling tool that integrates action languages from the Epsilon family for model management and code generation.     

Definition of a problem-sensitive conceptual modelling language: foundations and application to software engineering

A conceptual modelling language should provide constructors that can be used to represent the conceptualisation of a problem considering the problem domain. However, software engineering has traditionally focused on implementation concepts.This paper considers the appropriate generic conceptualisation theoretical aspects to identify the conceptual elements for which constructors have to be provided in a problem-sensitive conceptual modelling language. These elements match the formal definition of any conceptualisation and are derived from natural language. By looking at these elements, we have defined a conceptual modelling language that has been successfully applied in knowledge engineering and software engineering.     

Action-oriented conceptual modelling

The aim of this paper is to show how speech act theory can be used in systems development as a theoretical foundation for conceptual modelling. With the traditional notion of the conceptual model as an image of reality, the predominant modelling problem is to analyse how the external reality should be mapped into, and represented in, the system in a ‘true’ way. In contrast to this, we maintain that the main modelling problem should be to analyse the communication acts performed by use of the system within its business context. This implies an integration of traditional conceptual modelling with action-oriented business modelling based on speech act theory. With such an approach, it is possible to reconcile traditional conceptual modelling and the pragmatic aspects of language and computer use. It is argued that such reconciliation is essential to arrive at systems that provide relevant information to users and in which users can trace responsibilities for information, actions and commitments made.     

Phenomenologial foundations of conceptual product modelling in architecture,engineering and construction

The ultimate goal of conceptual modelling in architecture, engineering and construction (AEC) has been to define the data structures that could be used to describe the entire built environment through all its life cycle stages — from inception and design to demolition. In spite of the magnitude and complexity of this task, the theoretical foundations of modelling received little attention. In this paper, the theoretical foundations of the traditional modelling approaches are questioned using phenomenology and hermeneutics as philosophical base. The author exposes the difference between the remodelling of some existing models, the modelling of physical objects and the modelling of psychical, intentional objects. The author concludes that AEC or building product and process models do not model objective reality but the modeller's partial understanding of that reality. Therefore, several correct but different models may and should exist. Future software architectures in AEC should not be built on a unified, centralized model but, on a combination of models, which may not be standardised but whose schemas are encoded in a standard manner.     

From requirements to UML models and back: how automatic processing of text can support requirements engineering

Software engineering is supposed to be a structured process, but manual tasks leave much leeway. Ideally, these tasks lie in the hands of skilled analysts and software engineers. This includes creating the textual specification of the envisioned system as well as creating models for the software engineers. Usually, there is quite a bit of erosion during the process due to requirement changes, implementation decisions, etc. To deliver the software as specified, textual requirements, models, and the actual software need to be synchronized. However, in practice, the cost of manually maintaining consistency is too high. Our requirements engineering feedback system automates the process of keeping textual specification and models consistent when the models change. To improve overall processing of natural language specifications, our approach finds flaws in natural language specifications. In addition to the already published workshop paper, we show how well our tools support even non-software-engineers in improving texts. The case studies show that we can speed up the process of creation texts with fewer flaws significantly.     

Giving voice to requirements engineering

Developers have plenty of reasons to avoid investing in requirements engineering: It is next to impossible to capture user needs completely, and needs are constantly evolving. The gap between software research and practice is no more evident than in the field of requirements engineering. Requirement engineering has a fairly narrow goal - determine a need and define the external behaviour of a solution - but the range of research into requirements is enormous     

Nonfunctional requirements: from elicitation to conceptual models

Nonfunctional requirements (NFRs) have been frequently neglected or forgotten in software design. They have been presented as a second or even third class type of requirement, frequently hidden inside notes. We tackle this problem by treating NFRs as first class requirements. We present a process to elicit NFRs, analyze their interdependencies, and trace them to functional conceptual models. We focus our attention on conceptual models expressed using UML (Unified Modeling Language). Extensions to UML are proposed to allow NFRs to be expressed. We show how to integrate NFRs into the class, sequence, and collaboration diagrams. We also show how use cases and scenarios can be adapted to deal with NFRs. This work was used in three case studies and their results suggest that by using our proposal we can improve the quality of the resulting conceptual models.     

The methodological soundness of requirements engineering papers: a conceptual framework and two case studies

This paper was triggered by concerns about the methodological soundness of many RE papers. We present a conceptual framework that distinguishes design papers from research papers, and show that in this framework, what is called a research paper in RE is often a design paper. We then present and motivate two lists of evaluation criteria, one for research papers and one for design papers. We apply both of these lists to two samples drawn from the set of all submissions to the RE’03 conference. Analysis of these two samples shows that most submissions of the RE’03 conference are design papers, not research papers, and that most design papers present a solution to a problem but neither validate this solution nor investigate the problems that can be solved by this solution. We conclude with a discussion of the soundness of our results and of the possible impact on RE research and practice.     

From safety analysis to software requirements

Software for safety critical systems must deal with the hazards identified by safety analysis. This paper investigates, how the results of one safety analysis technique, fault trees, are interpreted as software safety requirements to be used in the program design process. We propose that fault tree analysis and program development use the same system model. This model is formalized in a real-time, interval logic, based on a conventional dynamic systems model with state evolving over time. Fault trees are interpreted as temporal formulas, and it is shown how such formulas can be used for deriving safety requirements for software components     

From commercial documents to system requirements: an approach for the engineering of novel CBTC solutions

Communications-based train control (CBTC) systems are the new frontier of automated train control and operation. Currently developed CBTC platforms are actually very complex systems including several functionalities, and every installed system, developed by a different company, varies in extent, scope, number, and even names of the implemented functionalities. International standards have emerged, but they remain at a quite abstract level, mostly setting terminology. This paper presents the results of an experience in defining a global model of CBTC, by mixing semi-formal modelling and product line engineering. The effort has been based on an in-depth market analysis, not limiting to particular aspects but considering as far as possible the whole picture. The paper also describes a methodology to derive novel CBTC products from the global model, and to define system requirements for the individual CBTC components. To this end, the proposed methodology employs scenario-based requirements elicitation aided with rapid prototyping. To enhance the quality of the requirements, these are written in a constrained natural language (CNL), and evaluated with natural language processing (NLP) techniques. The final goal is to go toward a formal representation of the requirements for CBTC systems. The overall approach is discussed, and the current experience with the implementation of the method is presented. In particular, we show how the presented methodology has been used in practice to derive a novel CBTC architecture.     

Accommodating mesodata into conceptual modelling methodologies

Mesodata modelling is a recently developed approach for enhancing a data model’s capabilities by providing for more advanced semantics to be associated with the domain of an attribute. Mesodata supplies both an inter-value structure to the domain and a set of operations applicable to that structure that may be used to facilitate additional functionality in a database. We argue that conceptual modelling methodologies would be semantically richer if they were able to express the semantics of complex data types for attribute domains. This paper investigates the accommodation of mesodata into the entity-relationship and object role modelling, presenting the Mesodata Entity-Relationship (MDER) model and Mesodata Object Role Modelling (MDORM), which show how the mesodata concept can be incorporated into conceptual modelling methodologies to include the semantics of complex-domain structures.     

Some conceptual issues in component-assembly modelling

With the growing popularity of component-based design it is important to have a look at, or perhaps revisit, some of the issues in component-assembly modelling, some of which are not dealt with at all or else not resolved. This paper presents a number of conceptual issues and their possible solutions.     

Incorporating ontology-based semantics into conceptual modelling

With the increasing complexity of applications and user needs, recent research has shifted from a data-information level to a human semantic level interaction. Research has begun to address the increasing use and development of ontologies in various applications, strongly motivated by the semantic web initiative. However, existing conceptual models are not rich enough to incorporate ontologies in one single conceptual schema. To improve this situation, it is necessary to refine modelling formalisms and make them more expressive while ensuring they remain semantically sound. We argue that conceptual modelling methodologies would be semantically richer if they were able to express the semantics of a domain that arises in concrete application scenarios. This paper investigates the incorporation of ontologies into three popular conceptual modelling methodologies, presenting the Ontological Entity-Relationship (OntoER) model, Ontological Object Role Modelling (OntoORM) and the Ontological Unified Modelling Language (OntoUML) class diagram. An extended conceptual framework for modelling ontologies and a transformation algorithm for mapping ontological constructs to relational schemata are provided so that querying the database through the conceptualisation of the database can be managed.     

From requirements negotiation to software architecture decisions

Architecture design and requirements negotiations are conceptually tightly related but often performed separately in real-world software development projects. As our prior case studies have revealed, this separation causes uncertainty in requirements negotiation that hinders progress, limits the success of architecture design, and often leads to wasted effort and substantial re-work later in the development life-cycle. Explicit requirements elicitation and negotiation is needed to be able to appropriately consider and evaluate architecture alternatives and the architecture alternatives need be understood during requirements negotiation. This paper propose the WinCBAM framework, extending an architecture design method, called cost benefit analysis method (CBAM) framework to include an explicit requirements negotiation component based on the WinWin methodology. We then provide a retrospective case study that demonstrates the use of the WinCBAM. We show that the integrated method is substantially more powerful than the WinWin and CBAM methods performed separately. The integrated method can assist stakeholders to elicit, explore, evaluate, negotiate, and agree upon software architecture alternatives based on each of their requirement Win conditions. By understanding the architectural implication of requirements they can be negotiated more successfully: potential requirements conflicts can be discovered or alleviated relatively early in the development life-cycle.     

Impediments to requirements engineering during global software development

Developing software when team members are located in widely distributed geographic locations poses many challenges for developers, particularly during the requirements engineering (RE) phase. Using a case study of a large software development project with users located in the UK and software developers from an international software house based in New Zealand, the paper argues that while global RE using electronic communication media may be desirable in achieving economy of resources, social and cultural aspects of RE need to be considered so that lasting relationships with clients may be formed, and RE activities achieved. The main impediments to the process of RE during global software development are communication resulting from differences in shared meanings and context associated with the following: distribution of the clients and the development team; distribution of the development team; cultural differences between the clients and the development team; and cultural differences among the development team.     

Supporting scenario-based requirements engineering

Scenarios have been advocated as a means of improving requirements engineering yet few methods or tools exist to support scenario based RE. The paper reports a method and software assistant tool for scenario based RE that integrates with use case approaches to object oriented development. The method and operation of the tool are illustrated with a financial system case study. Scenarios are used to represent paths of possible behavior through a use case, and these are investigated to elaborate requirements. The method commences by acquisition and modeling of a use case. The use case is then compared with a library of abstract models that represent different application classes. Each model is associated with a set of generic requirements for its class, hence, by identifying the class(es) to which the use case belongs, generic requirements can be reused. Scenario paths are automatically generated from use cases, then exception types are applied to normal event sequences to suggest possible abnormal events resulting from human error. Generic requirements are also attached to exceptions to suggest possible ways of dealing with human error and other types of system failure. Scenarios are validated by rule based frames which detect problematic event patterns. The tool suggests appropriate generic requirements to deal with the problems encountered. The paper concludes with a review of related work and a discussion of the prospects for scenario based RE methods and tools