Design and code traceability using a PDL metrics tool

This paper describes an analysis tool that extracts complexity metrics from Program Design Language (PDL) as contained in design specification documents. The tool analyzes pseudocode and computes token-count metrics of PDL complexity on a module by module basis. We used the tool to measure consistency within and across modules and for assessing traceability between PDL and the corresponding source code. In applications of the tool we were able to identify PDL descriptions that were too detailed, those lacking sufficient detail, identify inconsistent PDL descriptions, and measure traceability between the PDL description and the corresponding source code

Lessons learned applying CASE methods/tools to Ada software development projects

This paper describes the lessons learned from introducing CASE methods/tools into organizations and applying them to actual Ada software development projects. This paper will be useful to any organization planning to introduce a software engineering environment (SEE) or evolving an existing one. It contains management level lessons learned, as well as lessons learned in using specific SEE tools/methods. The experiences presented are from Alpha Test projects established under the STARS (Software Technology for Adaptable and Reliable Systems) project. They reflect the front end efforts by those projects to understand the tools/methods, initial experiences in their introduction and use, and later experiences in the use of specific tools/methods and the introduction of new ones

Product assurance policies and procedures for flight dynamics software development

The product assurance policies and procedures necessary to support flight dynamics software development projects for Goddard Space Flight Center are presented. The quality assurance and configuration management methods and tools for each phase of the software development life cycles are described, from requirements analysis through acceptance testing; maintenance and operation are not addressed

Development of a comprehensive software engineering environment

The generation of a set of tools for software lifecycle is a recurring theme in the software engineering literature. The development of such tools and their integration into a software development environment is a difficult task because of the magnitude (number of variables) and the complexity (combinatorics) of the software lifecycle process. An initial development of a global approach was initiated in 1982 as the Software Development Workbench (SDW). Continuing efforts focus on tool development, tool integration, human interfacing, data dictionaries, and testing algorithms. Current efforts are emphasizing natural language interfaces, expert system software development associates and distributed environments with Ada as the target language. The current implementation of the SDW is on a VAX-11/780. Other software development tools are being networked through engineering workstations

Manager's handbook for software development, revision 1

Methods and aids for the management of software development projects are presented. The recommendations are based on analyses and experiences of the Software Engineering Laboratory (SEL) with flight dynamics software development. The management aspects of the following subjects are described: organizing the project, producing a development plan, estimating costs, scheduling, staffing, preparing deliverable documents, using management tools, monitoring the project, conducting reviews, auditing, testing, and certifying

Software technology insertion: A study of success factors

Managing software development in large organizations has become increasingly difficult due to increasing technical complexity, stricter government standards, a shortage of experienced software engineers, competitive pressure for improved productivity and quality, the need to co-develop hardware and software together, and the rapid changes in both hardware and software technology. The 'software factory' approach to software development minimizes risks while maximizing productivity and quality through standardization, automation, and training. However, in practice, this approach is relatively inflexible when adopting new software technologies. The methods that a large multi-project software engineering organization can use to increase the likelihood of successful software technology insertion (STI), especially in a standardized engineering environment, are described

Managers Handbook for Software Development

Methods and aids for the management of software development projects are presented. The recommendations are based on analyses and experiences with flight dynamics software development. The management aspects of organizing the project, producing a development plan, estimation costs, scheduling, staffing, preparing deliverable documents, using management tools, monitoring the project, conducting reviews, auditing, testing, and certifying are described

An approach to impact analysis in software maintenance

Impact analysis is a software maintenance activity, which consists of determining the scope of a requested change, as a basis for planning and implementing it. After a change request has been specified (change understanding) and the initial part of the system to be changed has been identified (change localization), impact analysis helps to understand consequences of the change on other parts of the system. Induced changes, also named ripple effects, among software components are detected. Most existing approaches perform impact analysis for changes occurring at the code level. In this thesis, concepts developed to perform impact analysis at the code level are applied to trace changes occurring at the design level. The method consists of proposing an activity model addressing the different steps of impact analysis and a data model on which propagations of changes can be traced. The method is validated with a case study applied to a system from the aerospace field. The tools we developed on PCTE help for consistency checks in HOOD based designs during editing. Our data-model based on an Entity Relationship notation describes a way to model HOOD diagrams in PCTE and further on to propagate changes on the repository. Examples chosen address the design phase of a simple engine system. We show that addressing modifications at a higher level of abstraction than the code eases understanding and localization of changes. It also limits the propagation of ripple effects (i.e., unexpected behaviour of the system) by detecting secondary changes at an earlier stage