Integration of informal and formal development of object-oriented safety-critical software

The KeY system allows for the integrated informal and formal development of object-oriented Java software. In this paper we report on a major industrial case study involving safety-critical software for the computation of a particular kind of railway timetable used by train conductors. Our case study includes formal specification of requirements both on the analysis and the implementation level. Particular emphasis in our research is placed on the challenge to make authoring and maintenance of formal specifications easier. We demonstrate that the technique of specification patterns as implemented in KeY for the language OCL yields significant improvements.     

VRML testing: making VRML worlds look the same everywhere

NIST tools address problems posed by testing 3D graphics. The article explains the test development strategy and design issues in developing and delivering these testing tools. In 1996, NIST staff met with interested members of the VRML community to discuss various approaches to testing the Virtual Reality Modeling Language (VRML) specification. The standard defines requirements for creating VRML worlds, tools that generate VRML worlds (authoring tools), and tools that interpret and properly render VRML worlds (browsers). It was agreed that VRML worlds, whether generated by hand or through an authoring tool, must be fully compliant with the standard. Furthermore, they must be viewable and reasonably similar in a variety of VRML browsers, regardless of the underlying hardware and software platforms. Consequently, NIST developed metrology tools to support testing VRML content, authoring tools, and browsers. VRML content and the associated authoring tools are tested using a locally developed reference parser, Viper. VRML browsers are tested using a test suite of conformant files, called the VRML Test Suite (VTS). The VTS tests the VRML built-in nodes, VRML extensible components, and base execution model. Finally, the true dynamic nature of VRML is tested using automatic test generation techniques built through extension of the Viper source code. We also address using the Web as a vehicle for delivering these metrology tools     

Towards formal open standards: formalizing a standard’s requirements

Open standardization seems to be very popular among software developers as it simplifies the standard’s adoption by the software engineering. Formal specification methods, while very promising, are being adopted slowly as the industry seems to have little motivation to move into this territory. In this paper the authors present (1) the idea of applying formal specification techniques to open standards’ specifications, and (2) an example of a formal specification of the Rich Site Summary (RSS) v2.0 open standard. The authors provide evidence for the advantages of the open standards formal specification over natural language documentations: formal specifications are more concise, less ambiguous, more complete with respect to the original documentation and, when using certain kinds of specification languages, executable and reusable as they support module inheritance. The merging of formal specification methods and open standards allows (1) a more concrete standard design; (2) an improved understanding of the environment under design; (3) an enforced certain level of precision into the specification, and also (4) provides software engineers with extended property checking/verification capabilities, especially if they opt to use any algebraic specification language. The authors showcase how the RSS standard can be formally specified using an algebraic specification language and demonstrate how can that be beneficial.     

An integrated life-cycle model for software maintenance

An integrated life-cycle model is presented for use in a software maintenance environment. The model represents information about the development and maintenance of software systems, emphasizing relationships between different phases of the software life cycle. It provides the basis for automated tools to assist maintenance personnel in making changes to existing software systems. The model is independent of particular specification, design, and programming languages because it represents only certain `basic' semantic properties of software systems: control flow, data flow, and data structure. The software development processes by which one phase of the software life cycle is derived from another are represented by graph rewriting rules, which indicate how various components of a software system have been implemented. This approach permits analysis of the basic properties of a software system throughout the software life cycle. Examples are given to illustrate the integrated software life-cycle model during evolution     

GDDT—A graphical design and documentation tool for software development

This paper describes “The Graphical Design and Documentation Tool” (GDDT), a general purpose support system for design and documentation. Self documentation and ease of use are presented as important criteria for such tools. Interactive graphics is introduced as a methodology for creating and maintaining hierarchical representations. The graphical representations of various requirements specification techniques and design tools are supported by an extended network model which supports hierarchical decomposition of structures. GDDT is proposed as a general purpose design tool which supports the most common logical constructions of both requirements specification and design methodologies and yet has a high level human interface which makes it easy to learn and use.     

Requirements Analysis for Engineering Computation: A Systematic Approach for Improving Reliability

This paper argues that the reliability of engineering computation can be significantly improved by adopting software engineering methodologies for requirements analysis and specification. The argument centers around the fact that the only way to judge the reliability of a system is by comparison to a specification of the requirements. This paper also points to methods for documenting the requirements. In particular, a requirements template is proposed for specifying engineering computation software. To make the mathematical specification easily understandable by all stakeholders, the requirements documentation employs the technique of using tabular expressions. To clarify the presentation, this paper includes a case study of the documentation for a system for analyzing statically determinant beams.     

Hardware/software codesign and rapid prototyping of embeddedsystems

The complexity and the short time to market of embedded systems require the use of automated techniques during the specification, implementation, and testing phases of such systems. Due to the cost requirements and the timing constraints of such systems, application-specific hardware solutions are often needed, making the codesign of hardware and software a major topic for the design automation of embedded systems. This article describes tools for the analysis, synthesis, and rapid prototyping of distributed embedded real-time systems and presents a complete design flow from specification to implementation     

Formalism and Language Tools for Specification of the Semantics of Software Libraries

The paper considers the specification of the structure and the behavior of software libraries. It describes the existing problems of library specifications. A brief overview of the research field concerned with formalizing the specification of libraries and library functions is presented. The requirements imposed on the formalism designed are established; the formalism based on these requirements allows specification of all the properties of the libraries needed for automation of several classes of problems: defect detection in software, migration of applications into a new environment, and generation of software documentation. Requirements for language tools based on the developed formalism are proposed. The conclusion defines potential directions for further research.     

Specification and design of embedded hardware-software systems

Embedded-system specification and design consists of describing a system's desired functionality and mapping that functionality for implementation by a set of system components such as processors, ASICs, memories, and buses. This paper discusses the key problems of system specification and design, including specification capture, design exploration, hierarchical modeling, software and hardware synthesis, and cosimulation. The authors highlight existing tools and methods for solving those problems and describe a “specify-explore-refine” methodology for meeting today's embedded-system product development requirements     

Conformance checking of PMI representation in CAD model STEP data exchange files

Recommended practices supplement data exchange standards by providing common implementation guidance associated with specific requirements. ISO 10303 (STEP) product data exchange files that conform to recommended practices ensure interoperability between computer-aided design (CAD) systems and with downstream applications such as manufacturing and inspection. Correct implementation of product and manufacturing information (PMI)–annotations associated with a CAD model’s edges and faces such as geometric tolerances, dimensional tolerances, and datum features–in CAD authoring systems and translators is essential for interoperability. This paper discusses an approach implemented in a software tool for checking the conformance of STEP files to the recommended practice for PMI representation.     

Experience with logical code analysis in software maintenance

Formal program specification and logical analysis are often used for program derivation and proofs of correctness. The basic tools include the logic of predicate calculus and Dijkstra's weakest precondition calculations. Recent work has shown that these tools are also very useful in the maintenance phase of the software life-cycle. This paper reports experience working with software maintenance teams to apply formal methods. Formal logical analysis is invaluable for isolating defects, determining code corrections, eliminating side-effects, and code re-engineering. Logical analysis works well in software maintenance because many defects can be isolated to small segments of code. These small segments can then be analyzed manually or with code analysis tools. The result is lowered software maintenance costs due to the benefits of defect prevention, reduction of code complexity metrics, productivity improvements, and better specifications and documentation. It would be beneficial to use logical code analysis in the earlier phases of the software life-cycle, such as quality assurance and inspection.     

Modelling Reactive Multimedia: Design and Authoring

Multimedia document authoring is a multifaceted activity, and authoring tools tend to concentrate on a restricted set of the activities involved in the creation of a multimedia artifact. In particular, a distinction may be drawn between the design and the implementation of a multimedia artifact.This paper presents a comparison of three different authoring paradigms, based on the common case study of a simple interactive animation. We present details of its implementation using the three different authoring tools, MCF, Fran and SMIL 2.0, and we discuss the conclusions that may be drawn from our comparison of the three approaches.Simon Thompson is grateful to the British Council for its funding of travel in support of the work reported here.Supported by an individual research grant from NSERC. This author’s research was performed, in part, at LIRMM, Montpellier, France.Supported by an individual research grant from NSERC.     

A highly modular and extensible architecture for an integrated IMS‐based authoring system: the <e‐Aula> experience

The <e‐Aula> platform is a new experimental e‐learning environment that adheres closely to IMS Global Learning Consortium, Inc. e‐learning standards in order to facilitate their applicability in different learning scenarios. <e‐Aula> is equipped with an integrated modular and extensible architecture for the authoring of IMS‐compliant learning materials focused on the IMS manifest. This manifest‐driven architecture facilitates maintenance and promotes the evolution of the authoring system in <e‐Aula>, both of which are mandatory requirements in the successful production and maintenance of content for many different specialized learning domains. In this paper, we describe this authoring system, its manifest‐driven architecture and its implementation using well‐known and robust Java‐based Web technologies. Copyright © 2006 John Wiley & Sons, Ltd.     

A logical approach to systems engineering artifacts: semantic relationships and dependencies beyond traceability—from requirements to functional and architectural views

Not only system assurance drives a need for semantically richer relationships across various artifacts, work products, and items of information than are implied in the terms “trace and traceability” as used in current standards and textbooks. This paper deals with the task of working out artifacts in software and system development, their representation, and the analysis and documentation of the relationships between their logical contents—herein referred to as tracing and traceability; this is a richer meaning of traceability than in standards like IEEE STD 830. Among others, key tasks in system development are as follows: capturing, analyzing, and documenting system-level requirements, the step to functional system specifications, the step to architectures given by the decomposition of systems into subsystems with their connections and behavioral interactions. Each of these steps produces artifacts for documenting the development, as a basis for a specification and a design rationale, for documentation, for verification, and impact analysis of change requests. Crucial questions are how to represent and formalize the content of these artifacts and how to relate their content to support, in particular, system assurance. When designing multi-functional systems, key artifacts are system-level requirements, functional specifications, and architectures in terms of their subsystem specifications. Links and traces between these artifacts are introduced to relate their contents. Traceability has the goal to relate artifacts. It is required for instance in standards for functional system safety such as the ISO 26262. An approach to specifying semantic relationships is shown, such that the activity of creating and using (navigating through) these relationships can be supported with automation.     

Integration of usability evaluation and model-based software development

Model-based software development is carried out as a well defined process. Depending on the applied approach, different phases can be distinguished, e.g. requirements specification, design, prototyping, implementation and usability evaluation. During this iterative process manifold artifacts are developed and modified, including, e.g. models, source code and usability evaluation data. CASE tools support the development stages well, but lack a seamless integration of usability evaluation methods. We aim at bridging the gap between development and usability evaluation, through enabling the cooperative use of artifacts with the particular tools. As a result of integration usability experts save time to prepare an evaluation and evaluation results can be easier incorporated back into the development process. We show exemplary our work on enhancing the Eclipse framework to support usability evaluation for task model-based software development.     

Dialogue modelling of graphical user interfaces with a production system

In systems development it is essential for a piece of software to be able effectively to incorporate the requirements of the particular task domain that it is intended to address. This paper describes an approach that uses dialogue modelling to carry the requirements derived from task analysis through to the implementation phase of development. A notation based on production systems is used to develop an abstract specification of user and system behaviour which can subsequently be used as the basis for the implementation. The requirements for a computer-based tool are also discussed, with particular attention being given to ways in which the communication and reasoning about such a dialogue design can be supported.     

Enterprise wide application integration platform for CIMS implementation

Adoption of CIMS in manufacturing enterprises requires more advanced tools for application integration. This paper presents the system architecture and services of an integration platform, CIMS Application Integration Platform for Manufacturing Enterprises (MACIP). MACIP integrates a set of application software and application development tools to provide a complete system for CIMS implementation. It includes a communication system, a global information system, three domain application sub-integration platforms, an Internet interface and an operation management and control system. It is based on the Client/Server structure, and employs the object-oriented paradigm and agent technology. System openness, scalability and maintenance are ensured by conforming to international standards and by using effective system design software and management tools. MACIP can significantly reduce the complexity of CIMS implementation.     

A grammar of integrity constraints in medical documentation systems

An essential aspect for the utilization of medical data is their quality, thus a main feature of computer-based medical documentation systems should be to assist the user in complete and plausible data acquisition and maintenance. In this paper we define a grammar for modeling medical documentation systems to increase integrity and completeness of collected data, focusing attention on integrity constraints. An integrity constraint defines requirements that involved entities had to comply with. Furthermore it defines possibly implications in case of failure. The constraints presented in this paper are type constraint, length constraint, domain constraint, key constraint, quantity constraint, reference constraint, search constraint, result constraint, hierarchy constraint, and semantic constraint. Their grammar is declared using a schema in extensible markup language-format (XML-schema). The model introduced here can be used in computer-aided design and implementation of clinical documentation both minimizing effort and ensuring data quality, which was tested by an evaluation based on a specification of a registry for HIV-infected patients.     

The impact of UML documentation on software maintenance: an experimental evaluation

The Unified Modeling Language (UML) is becoming the de facto standard for software analysis and design modeling. However, there is still significant resistance to model-driven development in many software organizations because it is perceived to be expensive and not necessarily cost-effective. Hence, it is important to investigate the benefits obtained from modeling. As a first step in this direction, this paper reports on controlled experiments, spanning two locations, that investigate the impact of UML documentation on software maintenance. Results show that, for complex tasks and past a certain learning curve, the availability of UML documentation may result in significant improvements in the functional correctness of changes as well as the quality of their design. However, there does not seem to be any saving of time. For simpler tasks, the time needed to update the UML documentation may be substantial compared with the potential benefits, thus motivating the need for UML tools with better support for software maintenance.