90,424 research outputs found
The Synonym management process in SAREL
The specification phase is one of the most important and least supported
parts of the software development process. The SAREL system has been
conceived as a knowledge-based tool to improve the specification phase.
The purpose of SAREL (Assistance System for Writing Software
Specifications in Natural Language) is to assist engineers in the
creation of software specifications written in Natural Language (NL).
These documents are divided into several parts. We can distinguish the
Introduction and the Overall Description as parts that should be used in
the Knowledge Base construction. The information contained in the
Specific Requirements Section corresponds to the information represented
in the Requirements Base. In order to obtain high-quality software
requirements specification the writing norms that define the linguistic
restrictions required and the software engineering constraints related
to the quality factors have been taken into account. One of the controls
performed is the lexical analysis that verifies the words belong to the
application domain lexicon which consists of the Required and the
Extended lexicon. In this sense a synonym management process is needed
in order to get a quality software specification. The aim of this paper
is to present the synonym management process performed during the
Knowledge Base construction. Such process makes use of the Spanish
Wordnet developed inside the Eurowordnet project. This process generates
both the Required lexicon and the Extended lexicon that will be used
during the Requirements Base construction.Postprint (published version
Using NLP tools in the specification phase
The software quality control is one of the main topics in the Software
Engineering area. To put the effort in the quality control during the
specification phase leads us to detect possible mistakes in an early
steps and, easily, to correct them before the design and implementation
steps start. In this framework the goal of SAREL system, a
knowledge-based system, is twofold. On one hand, to help software
engineers in the creation of quality Software Requirements
Specifications. On the other hand, to analyze the correspondence between
two different conceptual representations associated with two different
Software Requirements Specification documents.
For the first goal, a set of NLP and Knowledge management tools is
applied to obtain a conceptual representation that can be validated and
managed by the software engineer.
For the second goal we have established some correspondence measures in
order to get a comparison between two conceptual representations. This
information will be useful during the interaction.Postprint (published version
Designing and Documenting the Behavior of Software
The development and maintenance of today's software systems is an increasingly effort-consuming and error-prone task. A major cause of this problem is the lack of formal and human-readable documentation of software design. In practice, software design is often informally documented (e.g. texts in a natural language, `boxes-and-arrows' diagrams without well-defined syntax and semantics, etc.), or not documented at all. Therefore, the design cannot be properly communicated between software engineers, it cannot be formally analyzed, and the conformance of an implementation to the design cannot be formally verified.\ud
\ud
In this chapter, we address this problem for the design and documentation of the behavior implemented in procedural programs. We introduce a solution that consists of three components: The first component is a graphical language called VisuaL, which enables engineers to specify constraints on the possible sequences of function calls from a given program. Since the specifications may be inconsistent with each other, the second component of our solution is a tool called CheckDesign, which automatically\ud
verifies the consistency between multiple specifications written in VisuaL. The third component is a tool called CheckSource, which automatically verifies that a given implementation conforms to the corresponding specifications written in VisuaL.\ud
\ud
This solution has been evaluated empirically through controlled experiments with 71 participants: 23 professional developers of ASML, and 49 Computer Science M.Sc. students. These experiments showed that, with statistical significance of 0.01, the solution reduced the effort of typical maintenance tasks by 75% and\ud
prevented one error per 140 lines of source code
Requirements modelling and formal analysis using graph operations
The increasing complexity of enterprise systems requires a more advanced
analysis of the representation of services expected than is currently possible.
Consequently, the specification stage, which could be facilitated by formal
verification, becomes very important to the system life-cycle. This paper presents
a formal modelling approach, which may be used in order to better represent
the reality of the system and to verify the awaited or existing system’s properties,
taking into account the environmental characteristics. For that, we firstly propose
a formalization process based upon properties specification, and secondly we
use Conceptual Graphs operations to develop reasoning mechanisms of verifying
requirements statements. The graphic visualization of these reasoning enables us
to correctly capture the system specifications by making it easier to determine if
desired properties hold. It is applied to the field of Enterprise modelling
The REVERE project:Experiments with the application of probabilistic NLP to systems engineering
Despite natural language’s well-documented shortcomings as a medium for precise technical description, its use in software-intensive systems engineering remains inescapable. This poses many problems for engineers who must derive problem understanding and synthesise precise solution descriptions from free text. This is true both for the largely unstructured textual descriptions from which system requirements are derived, and for more formal documents, such as standards, which impose requirements on system development processes. This paper describes experiments that we have carried out in the REVERE1 project to investigate the use of probabilistic natural language processing techniques to provide systems engineering support
ENCOMPASS: A SAGA based environment for the compositon of programs and specifications, appendix A
ENCOMPASS is an example integrated software engineering environment being constructed by the SAGA project. ENCOMPASS supports the specification, design, construction and maintenance of efficient, validated, and verified programs in a modular programming language. The life cycle paradigm, schema of software configurations, and hierarchical library structure used by ENCOMPASS is presented. In ENCOMPASS, the software life cycle is viewed as a sequence of developments, each of which reuses components from the previous ones. Each development proceeds through the phases planning, requirements definition, validation, design, implementation, and system integration. The components in a software system are modeled as entities which have relationships between them. An entity may have different versions and different views of the same project are allowed. The simple entities supported by ENCOMPASS may be combined into modules which may be collected into projects. ENCOMPASS supports multiple programmers and projects using a hierarchical library system containing a workspace for each programmer; a project library for each project, and a global library common to all projects
Recommended from our members
Requirements for software engineering languages
This paper analyzes the concepts of software construction embodied in the Draco system. The analysis relates specific mechanisms in Draco to particular software engineering (SE) principles and suggests future research needed to extend the approach. The purpose of the analysis is to help researchers understand Draco better and thus be able to direct in productive directions future research on this type of software engineering tool
- …