Donald M. Needham

A Software Fault Tree Metric

Analysis of software fault trees exposes hardware and software failure events that lead to unsafe system states, and provides insight on improving safety throughout each phase of the software lifecycle. Software product lines have emerged as an effort to achieve reuse, enhance quality, and reduce development costs of safety-critical systems. Safety-critical product lines amplify the need for improved analysis techniques and metrics for evaluating safety-critical systems since design flaws can be carried forward though product line generations. This paper presents a key node safety metric for measuring the inherent safety modeled by software fault trees. Definitions related to fault tree structure that impact the metrics composition are provided, and the mathematical basis for the metric is examined. The metric is applied to an embedded control system as well as to a collection of software fault tree product lines that include mutations expected to improve or degrade the safety of the system. The effectiveness of the metric is analyzed, and observations made during the experiments are discussed

Producing reusable object-oriented components: a domain-and-organization-specific perspective

Developing reusable object-oriented software requires a designer to determine how to structure a software system so as to achieve the necessary functionality, while at the same time increasing the reuse potential of the software. We introduce a set of reusability metrics intended to be iteratively applied during the design and implementation parts of the software life-cycle to help guide the production and identification of reusable components. Component identification centers on the applications domain, with reuse focusing specifically on an organizations future systems. Our approach requires the developer to subjectively categorize classes, identify component boundaries, and specify where components are related. Our metrics provide reuse valuations on the couplings between components. Based upon the results of applying our metrics, we provide refactoring guidelines to increase the separation between components in a manner that improves component reusability. We include an application of our metrics to a commercial objec-oriented framework.

ADAM: a language-independent, object-oriented, design environment for modeling inheritance and relationship variants in Ada 95, C++, and Eiffel

The ADAM environment provides a languageindependent, object-oriented platform from which Ada 95, C++, and/or Eiffel code can be automatically generated from a single design. ADAM provides design capabilities that support variants of inheritance and relationships, from different perspectives. A software engineer designing a database application has different needs than one concerned with a graphical user interface, and the variants are intended to allow each need to be met. The main purpose is to offer software engineers alternatives during design, thereby allowing behavior to more precisely match an applications requirements. By providing software engineers the ability to specifically choose and customize behavior for an application, from which the environment then automatically generates code, a more disciplined approach to design and development is promoted. Moreover, all of the inheritance and relationship variants generate code in a controlled and consistent fashion, resulting in predictable application behavior and improved readability of generated code, and hopefully leading toward a more understandable and maintainable software product. This paper examines ADAM and its inheritance/relationship variants, in a common design platform from which code in multiple object-oriented languages can be generated. We have chosen to also present C++ and Eiffel since they offer an interesting contrast to the capabilities supported by Ada 95, and they demonstrate the languageindependence of the ADAM environment.

An analysis of a CORBA-based approach to accessing geospatial information via the Internet

Access to the National Imagery and Mapping Agencys (NIMAs) Vector Product Format data is essential to the evolution of digital mapping products. Currently, users of NIMA data must have software to view the data resident on their own computer systems, and must obtain the data on CD-ROM or other storage media. This paper examines the design of an object-oriented (OO) digital mapping database prototype, called the Geospatial Information Database (GIDB). The GIDB provides accessibility to NIMA mapping data over the Internet in a CORBA-compliant manner. We describe a software solution to create a thin client product to enable viewing and manipulation of NIMA mapping data, and utilize n-tier concepts for data manipulation on the server side. We discuss difficulties encountered during the modeling and implementation stages of our development of the GIDB, as well as examine improvements made to increase the efficiency of our system.

Anatomy, dissection, and mechanics of an introductory cyber-security course's curriculum at the United States naval academy

Due to the high priority of cyber-security education, the United States Naval Academy rapidly developed and implemented a new cyber-security course that is required for all of its first-year students. During the fall semester in 2011, half of the incoming class (about 600 students) took the course through a total of 31 sections offered by 16 instructors from a variety of disciplines and backgrounds. In the following spring semester, the remaining half of the first-year students will take the course. This paper explains the motivation that instigated and drove course development, the curriculum, teaching mechanics implemented, personnel required, as well as challenges and lessons learned from the first offering of the course. The information contained in this paper will be useful to those thinking of implementing a technical course required of all students at the same level in an institution (in our case first-year students) and particularly those interested in implementing such a course in cyber security.

A reusability measurement framework and tool for Ada 95

This paper presents a framework which analyzes and measures the reusability of object-oriented (00) designs. Our approach relies on reuse-specific subjective characterizations of packages and hierarchical libraries, and on a set of metrics that objectively measures the dependencies among packages based on those characterizations. We have developed a prototype tool which can parse Ada 95 applications, measure their reuse potential according to our framework, and automatically advise software designers/developers on the ways to improve their products’ reusability. We intend to incorporate this tool into a design/development environment to promote an iterative process that evolves design/code to a more reusable state.

An Ada95 basis for propagation modeling

Representing dynamic interdependencies between design objects is an essential part of modeling the critical software communications found in complex software systems. Current software development methodologies, computer aided software engineering (CASE) environments and computer aided design (CAD) systems lack the ability to represent and manipulate these interdo pendencies, even though the specific information needing representation is often well understood by the designer. This paper examines the modeling of propagations, which are captured using design-level triggers for specifying dynamic behavior across object types. We present propagation constructs built upon the object-oriented features of the Ada95 programming language. Cur emphasis is to report upon our use of object-oriented propagations as part of our software engineering research environment ADAM, (short for Active Design and Analyses Modeling), to model appropriate change notification upon a decision to alter the supporting geometry data structures for rapid prototyping in the manufacturing domain. An example of the propagations involved in the maintenance of topological invariance in the industrial domain is examined.

Object-oriented design abstractions and code generation front ends to CAD systems

Our object-oriented software engineering environment, ADAM, is used for mechanical design abstraction to support both conceptual design and CAD-model instantiation. At the conceptual design level, ADAM supports the representation of design intent and provides the framework needed to model feature inter-dependencies. ADAM allows: 1. separation of design intent, feature specification and geometry instantiation from the representation of a part 2. design independence from the implementation environment, 3. avenues for automated support of a standardized design process, and 4. automatic code generation in a CAD-model instantiation language based upon conceptual design abstractions.

A software fault tree key node metric

Analysis of software fault trees exposes failure events that can impact safety within safety-critical software product lines. This paper presents a software fault tree key node safety metric for measuring software safety within product lines. Fault tree structures impacting the metrics composition are provided, and the mathematical basis for the metric is defined. The metric is applied to an embedded control system as well as to a series of experiments expected to either improve or degrade system safety. The effectiveness of the metric is analyzed, and lessons learned during the application of the metric are discussed.

Object modeling to localize knowledge for feature interrelationships

Effective object-oriented software support of knowledge intensive CAD requires extension of the object-oriented paradigm because its hierarchies are fundamentally based upon ancestral relations. Propagations are proposed as an extension to facilitate modeling of interrelationships between features. Such object modeling provides an effective software tool for localized perspectives upon design knowledge stored in rule and case bases. These local views show promise as a means to avoid the combinatorial explosions common to knowledge based systems, as will be discussed with respect to a completed industrial example and to ongoing work on rapid prototyping data.