Context. The use of standards is considered a vital part of any engineering discipline. So one could expect that standards play an important role in Requirements Engineering (RE) as well. However, little is known about the actual knowledge and use of RE-related standards in industry.Objective. In this article, we investigate to which extent standards and related artifacts such as templates or guidelines are known and used by RE practitioners.Method. To this end, we have conducted a questionnaire-based online survey. We could analyze the replies from 90 RE practitioners using a combination of closed and open-text questions.Results. Our results indicate that the knowledge and use of standards and related artifacts in RE is less widespread than one might expect from an engineering perspective. For example, about 47% of the respondents working as requirements engineers or business analysts do not know the core standard in RE, ISO/IEC/IEEE 29148. Participants in our study mostly use standards by personal decision rather than being imposed by their respective company, customer, or regulator. Beyond insufficient knowledge, we also found cultural and organizational factors impeding the widespread adoption of standards in RE.Conclusions. Overall, our results provide empirically informed insights into the actual use of standards and related artifacts in RE practice and – indirectly – about the value that the current standards create for RE practitioners.

In Requirements Engineering, many modeling tasks require viewing different parts of a model concurrently. However, traditional zoom+scroll navigation uses a single focus zoom, i.e., at a given point in time, a user can zoom in on a single spot in the model only. Therefore, new focus+context navigation techniques have been proposed that allow multiple foci at the same time. In this paper, we report on an experiment with students where we compare the participants' performance when using a requirements modeling tool with traditional zoom+scroll navigation vs. one with so-called FlexiView navigation which is a focus+context technique with multiple foci. The participants had to perform typical modeling tasks such as searching, editing, and traversing a model. All tasks were performed on medium-sized tablets with a tool for manipulating so-called ImitGraphs. ImitGraphs are enriched node-and-edge diagrams that can mimic various diagram types such as class, activity, or goal decomposition diagrams. We found that navigation with FlexiView outperformed zoom+scroll navigation with respect to task completion time, number of mistakes, cognitive load, and user satisfaction.

Enhancing the usability of tools such as requirements modeling tools requires several cycles of testing and improvement. Since this process is costly, it is usually ignored. In this paper, we present an experimental tool which we have developed with two goals: (i) comparing the usability of a new navigation technique for requirements artifacts called FlexiView with traditional zooming and scrolling, and (ii) developing a platform that enables fast implementation and fair usability comparisons of new navigation techniques while producing generalizable results.

Software requirements constantly change, thus impacting all other artifacts of an evolving system. In order to keep the system in a consistent state, changes in requirements should be documented and applied accordingly to all affected artifacts, including acceptance tests. In practice, however, changes in requirements are not always documented nor applied to the affected acceptance tests. This is mostly due to poor communication, lack of time or work overload, and eventually leads to project delays, unintended costs and unsatisfied customers. GuideGen is a tool-supported approach for keeping requirements and acceptance tests aligned. When a requirement is changed, GuideGen automatically generates guidance in natural language on how to modify impacted acceptance tests and communicates this information to the concerned parties. In this paper, we evaluate GuideGen in terms of its perceived usefulness for practitioners and its applicability to real software projects. The evaluation was conducted via interviews with 23 industrial practitioners from ten companies based in Europe. The results indicate that GuideGen is a useful approach that facilitates requirements change management and the communication of changes between requirements and test engineers. The participants also identified potential for improvement, in particular for using GuideGen in large projects.

The cloud paradigm has become increasingly attractive throughout the recent years due to its both technical and economic foreseen impact. Therefore, researchers' and practitioners' attention has been drawn to enhancing the technological characteristics of cloud services, such as performance, scalability or security. However, the topic of identifying and understanding cloud consumers' real needs has largely been ignored. Existing requirements elicitation methods are not appropriate for the cloud computing domain, where consumers are highly heterogeneous and geographically distributed, have frequent change requests and expect services to be delivered at a fast pace. In this paper, we introduce a new approach to requirements elicitation for cloud services, which utilizes consumers' advanced search queries for services to infer requirements that can lead to new cloud solutions. For this, starting from the queries, we build fuzzy Galois lattices that can be used by public cloud providers to analyze market needs and trends, as well as optimum solutions for satisfying the largest populations possible with a minimum set of features implemented. This new approach complements the existing requirements elicitation techniques in that it is a dedicated cloud method which operates with data that already exists, without entailing the active participation of consumers and requirements specialists.

Due to the increasing use of both general-purpose and domain-specific graphical models (e.g., UML diagrams or graphic DSLs) in different stages of software development, software engineers who work with these models spend more time interacting with modeling tools. Thus, the usability of the interaction techniques employed by modeling tools affects the overall productivity of software development. Tool developers and user interface designers rely on the feedback from usability tests to optimize the user interface of tools that provide a graphical editor. Developing a working prototype to test new techniques is costly due to the complexity and variety of graphical models. This results in either tests at the late stages of development when changes are more expensive, or tests with prototypes that only support a subset of the intended graphical models. In order to simplify conducting usability tests, instead of using the intended graphical models in the tests, we propose to use simpler models that require similar interactions when being manipulated. For this purpose, we introduce graphs with additional properties, which we call ImitGraphs. ImitGraphs can be parametrized such that their interaction behavior is similar to that of an intended graphical model. Further, we introduce a method to instruct test participants to create ImitGraphs and manipulate them. ImitGraphs enable tool builders to develop prototypes for usability tests faster and consequently cheaper, thus resulting in more usability tests at early stages of tool development and on a wider range of intended models.

Classifying requirements into functional requirements (FR) and non-functional ones (NFR) is an important task in requirements engineering. However, automated classification of requirements written in natural language is not straightforward, due to the variability of natural language and the absence of a controlled vocabulary. This paper investigates how automated classification of requirements into FR and NFR can be improved and how well several machine learning approaches work in this context. We contribute an approach for preprocessing requirements that standardizes and normalizes requirements before applying classification algorithms. Further, we report on how well several existing machine learning methods perform for automated classification of NFRs into sub-categories such as usability, availability, or performance. Our study is performed on 625 requirements provided by the OpenScience tera-PROMISE repository. We found that our preprocessing improved the performance of an existing classification method. We further found significant differences in the performance of approaches such as Latent Dirichlet Allocation, Biterm Topic Modeling, or Naïve Bayes for the sub-classification of NFRs.

When designing a new presentation front-end called FlexiView for requirements modeling tools, we encountered a general problem: designing such an interface requires a lot of experimentation which is costly when the code of the tool needs to be adapted for every experiment. On the other hand, when using simplified user interface (UI) tools, the results are difficult to generalize. To improve this situation, we are developing an UI experimentation tool which is based on so-called ImitGraphs. ImitGraphs can act as a simple, but accurate substitute for a modeling tool. In this paper, we define requirements for such an UI experimentation tool based on an analysis of the features of existing requirements modeling tools.

Twitter is one of the most popular social networks. Previous research found that users employ Twitter to communicate about software applications via short messages, commonly referred to as tweets, and that these tweets can be useful for requirements engineering and software evolution. However, due to their large number---in the range of thousands per day for popular applications---a manual analysis is unfeasible.In this work we present ALERTme, an approach to automatically classify, group and rank tweets about software applications. We apply machine learning techniques for automatically classifying tweets requesting improvements, topic modeling for grouping semantically related tweets and a weighted function for ranking tweets according to specific attributes, such as content category, sentiment and number of retweets. We ran our approach on 68,108 collected tweets from three software applications and compared its results against software practitioners' judgement. Our results show that ALERTme is an effective approach for filtering, summarizing and ranking tweets about software applications. ALERTme enables the exploitation of Twitter as a feedback channel for information relevant to software evolution, including end-user requirements.

Prioritizing requirements is a crucial ingredient of successful Requirements Engineering (RE). The popular prioritization techniques assume that stakeholders are known and can be mandated to contribute to the prioritization process. This prerequisite no longer holds for many of today's systems where significant stakeholders (end-users, in particular) are outside organizational reach: they are neither known nor can they be identified among the members of the involved organizations. Classic techniques for involving these stakeholders such as polls or questionnaires are neither interactive nor collaborative, which is detrimental for prioritization. Social media enable collaborative prioritization, but fall short in motivating stakeholders outside organizational reach to participate voluntarily. In this light, we are developing the Garuso platform, which combines social media with gamification for motivating stakeholders. While first approaches to employing gamification in RE are promising, research is still in its infancy. Especially, little is known about the influence of the gamification algorithms controlling single game elements on the stakeholders' activities. In this paper we report on a field experiment in which we investigated this influence with Garuso. We found statistically significant differences between different algorithms controlling single game elements on the contributions of stakeholders to the prioritization of requirements.

Requirements documentation is essential for developing software systems of non-trivial size. The cost of creating and maintaining documentation artifacts in terms of time and effort is significantly influenced by the tools with which engineers view, navigate and edit documentation artifacts. However, there is not much evidence about how well documentation tools actually support engineers, particularly when dealing with artifacts that are larger than the available display screen and with multiple artifacts at the same time. Therefore, we conducted an exploratory study based on 29 interviews with software practitioners to understand the current practice of presenting and manipulating artifacts in documentation tools, and how practitioners deal with the challenges encountered. Our study shows that a significant number of artifacts cannot be viewed entirely, even on large screens. Moreover, more than half of the participants use four or more artifacts concurrently. Nevertheless, current tools only provide primitive capabilities for handling concurrent and large artifacts, thus forcing engineers to create, for example, mental images of the currently used artifacts or use workarounds such as hanging printouts to the wall. Our results may trigger new research and help improve requirements engineering tools.

With the emergence and spread of agile processes, the practices of writing and maintaining documentation have drastically changed in the last decade. In this work, we performed a qualitative study to explore the current practices for managing two related types of software documentation: requirements and acceptance tests. We interviewed twenty practitioners from seventeen business units in fifteen companies to investigate the companies' practices for writing, maintaining and linking requirements and acceptance test documentation. The study yields interesting and partially unexpected results. For example, we had expected that tests would be more extensively documented than requirements, while we found a strong linear correlation between the number of requirements and tests in our sample. We also found that technical people are usually not involved in the requirements engineering activities, which often results in misunderstood or underestimated requirements. Acceptance tests are written, in many cases, based on requirements that are not necessarily detailed enough. Also, acceptance tests are not regularly maintained, which occasionally results in confusing features and bugs.

When software engineers collaborate, they frequently use whiteboards or paper for sketching diagrams. This is fast and flexible, but the resulting diagrams cannot be interpreted by software modeling tools. We present FLEXISKETCH TEAM, a tool solution consisting of a significantly extended version of our previous, single-user FLEXISKETCH tool for Android devices and a new desktop tool. Our solution for collaborative, model-based sketching of free-form diagrams allows users to define and re-use diagramming notations on the fly. Several users can work simultaneously on the same model sketch with multiple tablets. The desktop tool provides a shared view of the drawing canvas which can be projected onto an electronic whiteboard. Preliminary results from an exploratory study show that our tool motivates meeting participants to actively take part in sketching as well as defining ad-hoc notations.

Requirements elicitation is indispensable for delivering successful services. Nevertheless, cloud service providers mostly rely on ad-hoc approaches, as there are no dedicated elicitation methods for cloud services. To address this problem, we developed the StakeCloud approach, which helps cloud providers elicit requirements for future cloud services. StakeCloud builds and analyzes fuzzy Galois lattices based on consumers' advanced search queries for cloud services. Our StakeCloud Tool automatically builds the lattice from the given search queries. It provides the requirements analyst with extensive clustering and analysis capabilities as well as means for comparing different newly generated classes of services. These allow identifying the threshold for achieving the largest populations of satisfied consumers with a minimum set of features implemented. Further, our tool enables eliciting real requirements from global consumers unobtrusively.

Whiteboards and paper allow for any kind of notations and are easy to use. Requirements engineers love to use them in creative requirements elicitation and design sessions. However, the resulting diagram sketches cannot be interpreted by software modeling tools. We have developed FlexiSketch as an alternative to whiteboards in previous work. It is a mobile tool for model-based sketching of free-form diagrams that allows the definition and re-use of diagramming notations on the fly. The latest version of the tool, called FlexiSketch Team, supports collaboration with multiple tablets and an electronic whiteboard, such that several users can work simultaneously on the same model sketch. In this paper we present an exploratory study about how novice and experienced engineers sketch and define ad-hoc notations collaboratively in early requirements elicitation sessions when supported by our tool. Results show that participants incrementally build notations by defining language constructs the first time they use them. Participants considered the option to re-use defined constructs to be a big motivational factor for providing type definitions. They found our approach useful for longer sketching sessions and situations where sketches are re-used later on.

Summary Updating the requirements specification when software systems evolve is a manual task that is expensive and time consuming. Therefore, maintainers usually apply the changes to the code directly and leave the requirements unchanged. This results in the requirements rapidly becoming obsolete and useless. In this paper, we propose an approach that supports the maintainer in keeping the requirements specification consistent with the implementation, by identifying the requirements that are impacted whenever the code is changed. Our approach works as follows. First, we analyze the changes that have been applied to the source code and detect if they are likely to impact the requirements or not. Second, we trace the requirements‐impacting changes back to the requirements specification to identify the parts that might need to be modified. The output of the tracing is a list of requirements that are sorted according to their likelihood of being impacted. Automatically identifying the parts of the requirements specification that are likely to need maintenance reduces the effort needed for keeping the requirements up‐to‐date and thus makes the task of the maintainer easier. When applying our approach in three cases studies, 70% to 100% of the impacted requirements were identified within a list that includes less than 20% of the total number of requirements in the specification. Copyright © 2015 John Wiley & Sons, Ltd.

Requirements engineering (RE) is widely recognized as a crucial factor for the success of software projects. Therefore, companies often request assessments of RE processes and resulting artifacts to identify issues and improvement potential. However, industry claims that current assessment approaches do not always fulfill their needs regarding efficiency and effectiveness. Motivated by needs of both, companies asking for an assessment, and a company in the role of an assessor, we have developed a lightweight, tool-supported RE assessment approach. Apart from presenting the approach, we also discuss early experiences we gained from applying our assessment approach in real-world industrial projects.

In software and requirements engineering, requirements elicitation is considered an essential step towards building successful systems. Despite extensive existing research in the field of distributed requirements engineering, the topic of requirements elicitation for cloud systems remains still uncovered. Cloud challenges (e.g., heterogeneous and globally distributed users, volatile requirements, frequent change requests) cannot always be satisfied by existing methods. We present a new approach for eliciting requirements for cloud services by analyzing advanced search queries. Our approach builds fuzzy Galois lattices for the terms that compose advanced search queries, thus enabling a thorough analysis of stored search data. This can support cloud providers in observing requirements clusters and new classes of cloud services, identifying the threshold for achieving satisfied consumers with a minimal set of requirements implemented, and thus designing novel solutions, based on market trends. Moreover, the Galois lattices approach enables large-scale consumers' involvement and ensures the elicitation of real requirements unobtrusively.

Traditionally, metamodeling is an upfront activity performed by experts for defining modeling languages. Modeling tools then typically restrict modelers to using only constructs defined in the metamodel. This is inappropriate when users want to sketch graphical models without any restrictions and only later assign meanings to the sketched elements. Upfront metamodeling also complicates the creation of domain-specific languages, as it requires experts with both domain and metamodeling expertise. In this paper we present a new approach that supports modelers in creating metamodels for diagrams they have sketched or are currently sketching. Metamodels are defined in a semi-automatic, interactive way by annotating diagram elements and automated model analysis. Our approach requires no metamodeling expertise and supports the co-evolution of models and meta-models.

Since 2003, an award has been presented annually at the IEEE International Requirements Engineering Conference for the Most Influential Paper presented at the conference 10 years previously. In 2013, we celebrate 21 years of the Requirements Engineering Conference, and we use this as an opportunity to reflect on the Most Influential Papers to date. Two sessions of the 2013 conference highlight the work of previous award winners and provide the authors with the opportunity to describe the trajectory of their work over the ten years that led to the award, and to discuss its impact since.

Requirements elicitation is widely seen as a crucial step towards delivering successful software. In the context of emerging cloud systems, the question is whether and how the elicitation process differs from that used for traditional systems, and if the current methods suffice. We interviewed 19 cloud providers to gain an in-depth understanding of the state of practice with regard to the adoption and implementation of existing elicitation methods. The results of this exploratory study show that, whereas a few cloud providers try to implement and adapt traditional methods, the large majority uses ad-hoc approaches for identifying consumer needs. There are various causes for this situation, ranging from consumer reachability issues and previous failed attempts, to a complete lack of development strategy. The study suggests that only a small number of the current techniques can be applied successfully in cloud systems, hence showing a need to research new ways of supporting cloud providers. The main contribution of this work lies in revealing what elicitation methods are used by cloud providers and clarifying the challenges related to requirements elicitation posed by the cloud paradigm. Further, we identify some key features for cloud-specific elicitation methods.

Keeping requirements specifications up-to-date when systems evolve is a manual and expensive task. Software engineers have to go through the whole requirements document and look for the requirements that are affected by a change. Consequently, engineers usually apply changes to the implementation directly and leave requirements unchanged. In this paper, we propose an approach for automatically detecting outdated requirements based on changes in the code. Our approach first identifies the changes in the code that are likely to affect requirements. Then it extracts a set of keywords describing the changes. These keywords are traced to the requirements specification, using an existing automated traceability tool, to identify affected requirements. Automatically identifying outdated requirements reduces the effort and time needed for the maintenance of requirements specifications significantly and thus helps preserve the knowledge contained in them. We evaluated our approach in a case study where we analyzed two consecutive source code versions and were able to detect 12 requirements-related changes out of 14 with a precision of 79%. Then we traced a set of keywords we extracted from these changes to the requirements specification. In comparison to simply tracing changed classes to requirements, we got better results in most cases.

Early stage requirements models are often documented using paper and pencil-based approaches. In our current research, we are exploring lightweight modeling tools and approaches that could provide a beneficial alternative. We have developed the FlexiSketch tool prototype which combines support for free-form sketching with lightweight metamodeling capabilities. This creates the possibility for an automatic transcription of the documented information in later modeling stages. The tool is designed to be used on tablet devices.

When performed on a model, a set of operations (e.g., queries or model transformations) rarely uses all the information present in the model. Unintended underuse of a model can indicate various problems: the model may contain more detail than necessary or the operations may be immature or erroneous. Analyzing the footprints of the operations - i.e., the part of a model actually used by an operation - is a simple technique to diagnose and analyze such problems. However, precisely calculating the footprint of an operation is expensive, because it requires analyzing the operation's execution trace.

Companies in the software business often distribute requirements engineering responsibilities over several roles. Product management has overall product responsibility and performs early-phase market-driven requirements engineering. Product development implements the product and performs late-phase solution-oriented requirements engineering. Such shared responsibility provides advantages in the utilization of specific knowledge, skills, and resources, but leads to problems of mutual understanding and coordination. Earlier research proposed a negotiation process, handshaking with implementation proposals, that allows product management and development to achieve agreed requirements understanding. The process found acceptance in industry, but the relative advantages compared with traditional requirements hand-off and analysis had not been understood yet. This paper fills this gap by describing a case of measuring requirements and design volatility and an architect's requirements understanding during requirements hand-off, analysis, and negotiation.

We argue for the creation and use of a very lightweight requirements modeling language as an alternative to textual and pictorial requirements specifications.

For the first time at an RE conference we propose a formal debate on a topic of critical importance to the RE community. The debate format is based on that of the Economist newspaper, in turn derived from the long-standing Oxford Union practices.

The design of the variability of a software product line is crucial to its success and evolution. Meaningful variable features need to be elicited, analyzed, documented and validated when an existing software or reference system evolves into a software product line. These variable features are the main discriminators between individual products and they need to reflect the needs of a large variety of stakeholders adequately. In this paper we present a novel approach, called feature unweaving, that supports the identification and extraction of variable features from a given graphical software requirements model. We have extended our aspect-oriented software product line modeling tool such that it supports feature unweaving: it takes a set of model elements that a domain requirements engineer considers to constitute a variable feature and automatically refactors the model into a semantically equivalent one in which the model elements belonging to this feature are grouped into an aspect. This allows the identification and modeling of variable features in an incremental style. It also substantially reduces both the intellectual and clerical effort required for constructing the variable parts of a software product line requirements model.

Graphical models are omnipresent in the software engineering field, but most current graphical modeling languages do not scale with the increasing size and complexity of today’s systems. The navigation in the diagrams becomes a major problem especially if different aspects of the system are scattered over multiple, only loosely coupled diagrams. In this paper we present the hierarchical navigation capabilities of the Adora modeling tool. The user of this tool can freely control the level of detail in different parts of the model to reduce the size and complexity of the diagrams being displayed. Our fisheye visualization technique makes it possible to integrate all modeling aspects (structure, data, behavior, etc.) in one coherent model while keeping the size and complexity of the diagrams within reasonable limits.

Although the term 'non-functional requirement' has been in use for more than 20 years, there is still no consensus in the requirements engineering community what non-functional requirements are and how we should elicit, document, and validate them. On the other hand, there is a unanimous consensus that non-functional requirements are important and can be critical for the success of a project. This paper surveys the existing definitions of the term, highlights and discusses the problems with the current definitions, and contributes concepts for overcoming these problems.

Hierarchical diagrams are well-suited for visualizing the structure and decomposition of complex systems. However, the current tools poorly support modeling, visualization and navigation of hierarchical models. Especially the line routing algorithms are poorly suited for hierarchical models: for example, they produce lines that run across nodes or overlap with other lines. In this paper, we present a novel algorithm for line routing in hierarchical models. In particular, our algorithm produces an esthetically appealing layout, routes in real-time, and preserves the secondary notation of the diagrams as far as possible

The notion of partial and evolutionary specification has gained attention both in research and industry in the last years. While many people regard this just as a process issue, we are convinced that it is as well a language problem. Unfortunately, UML is not expressive enough to deal with evolutionary information in the system. In this paper, we propose an extension to a graphic modeling language called ADORA which is developed in our research group. We conservatively extend the semantics of some ADORA constructs so that intentional incompleteness can be expressed in the language and define a calculus for refining such specifications. With the help of these extensions, evolutionary specifications can be written in a controlled and systematic way. As the language and its extensions are formally defined, the consistency of evolutionary refinements can be checked mechanically by a tool.

Today, the syntax of visual specification languages such as UML is typically defined using meta-modelling techniques. However, this kind of syntax definition has drawbacks. In particular, graphic meta-models are not powerful enough, so they must be augmented by a textual constraint language. As an alternative, we present a text-based technique for the syntax definition of a graphic specification language. We exploit the fact that in a graphic specification language, most syntactic features are independent of the layout of the graph. So we map the graphic elements to textual ones and define the context-free syntax of this textual language in EBNF. Using our mapping, this grammar also defines the syntax of the graphic language. Simple spatial and context-sensitive constraints are then added by attributing the context-free grammar. Finally, for handling complex structural and dynamic information in the syntax, we give a set of operational rules that work on the attributed EBNF. We explain our syntax definition technique by applying it to the modelling language ADORA, which is being developed in our research group. We also briefly discuss the application of our technique to the syntax definition of UML. We mention the advantages of our method over the metamodeling techniques.

Following the success of the "First Workshop on Scenarios and State Machines: Models, Algorithms, and Tools" held at ICSE 2002 in Orlando [1], this workshop aims at bringing together researchers and practitioners to build a shared understanding on the relation between scenarios and state machines and to gain insight into techniques and tools that may leverage the combination of these approaches to enhance our means for behavior modeling.

Editing graphic models always entails layout problems. Inserting and deleting items requires tedious manual work for shifting existing items and rearranging the diagram layout. Hence, techniques that automatically expand a diagram when space is required for insertion and contract it when free space becomes available are highly desirable. Existing layout generation algorithms are no good solution for that problem: they may completely rearrange a diagram after an editing operation, while users want to preserve the overall visual appearance of a diagram. We have developed a technique which automatically expands or contracts a diagram layout when items are inserted or removed while preserving its overall shape, i.e. the positions of the items relative to each other Our technique has been implemented in a prototype tool. We are using it not just for simplifying editing, but primarily for implementing an aspect-oriented visualization concept.

Most current object modeling methods and tools have weaknesses both in the concepts of hierarchical decomposition and in the visualization of these hierarchies. Some methods do not support hierarchical decomposition at all. Those methods which do employ tools that provide explosive zoom as the only means for the visualization of hierarchies. The authors present an approach for the visualization of hierarchical object models based on the notion of fisheye views. This concept integrates local detail and global context of a view in the same diagram and eases navigation in hierarchical structures without offending the principle of abstraction. The work is part of an effort to create a method and language called ADORA that provides strong support for hierarchical decomposition.

SEED is a database system which supports the data engineering needs of a software engineering environment. It provides information structures that are not incorporated in conventional database systems, but are typical in the software engineering process. This paper describes two principal features of SEED: how to deal with vague and incomplete information without giving up consistency checking, and the management of database versions and variants. A prototype of SEED is used as the database for an existing specification and design tool.