Ed Seidewitz

Toward a general object-oriented software development methodology

An object is an abstract software model of a problem domain entity. Objects are packages of both data and operations of that data (Goldberg 83, Booch 83). The Ada (tm) package construct is representative of this general notion of an object. Object-oriented design is the technique of using objects as the basic unit of modularity in systems design. The Software Engineering Laboratory at the Goddard Space Flight Center is currently involved in a pilot program to develop a flight dynamics simulator in Ada (approximately 40,000 statements) using object-oriented methods. Several authors have applied object-oriented concepts to Ada (e.g., Booch 83, Cherry 85). It was found that these methodologies are limited. As a result a more general approach was synthesized with allows a designer to apply powerful object-oriented principles to a wide range of applications and at all stages of design. An overview is provided of this approach. Further, how object-oriented design fits into the overall software life-cycle is considered.

General object-oriented software development: background and experience

A project involving the development of a simulation system in Ada in parallel with a similar Fortran development has been undertaken. As part of the project, the Ada development team evaluated object-oriented and process-oriented design methodologies for Ada. Finding these methodologies limited in various ways, the team created a general object-oriented development methodology that they applied to the project. The author provides some background on the development of the methodology, describes the main principles of the approach, and presents some experiences using the methodology, including a general comparison of the Ada an Fortran simulator designs.<<ETX>>

Object-oriented programming in Smalltalk and ADA

Though Ada and Modula-2 are not object-oriented languages, an object-oriented viewpoint is crucial for effective use of their module facilities. It is therefore instructive to compare the capabilities of a modular language such as Ada with an archetypal object-oriented language such as Smalltalk. The comparison in this paper is in terms of the basic properties of encapsulation, inheritance and binding, with examples given in both languages. This comparison highlights the strengths and weaknesses of both types of languages from an object-oriented perspective. It also provides a basis for the application of experience from Smalltalk and other object-oriented languages to increasingly widely used modular languages such as Ada and Modula-2.

An object-oriented approach to parameterized software in Ada

A parameterized software system is one that can be configured by selecting generalized models and providing specific parameter values to fit those models into a general design [Stark 1990]. This is in contrast to the top-down development approach where a system is designed first, and software is reused only when it fits into the design. The concept of parameterized software is particularly useful in a development environment such as the Goddard Space Flight Center Flight Dynamics Division (FDD), where successive systems have similar characteristics.

Genericity versus inheritance reconsidered: self-reference using generics

As shown by the work of Bertrand Meyer, it is possible to simulate genericity using inheritance, but not vice-versa. This is because genericity is a parameterization mechanism with no way to deal with the polymorphic typing introduced using inheritance. Nevertheless, if we focus on the use of inheritance as an implementation technique, its key feature is the dynamic binding of self-referential operation calls. This turns out to be basically a parameterization mechanism that can in fact be simulated using generics and static binding. And for some applications this approach may actually be of more than academic interest.

Objects and domain engineering (panel)

Domain engineering is a field that has been emerging as a key component of any domainspecific reuse strategy. Domain engineering is a means of analysing and modelling a problem domain with a view to reusing the concepts of that domain across multiple software systems. There are domain analysis approaches currently available that are not based on object-oriented techniques, yet an object-oriented approach would seem to some to be the most suitable for domain engineering.

Developing software for large-scale reuse (panel)

Software reuse is a simple idea: reduce the cost of software development by developing less new software. In practice, however, achieving software reuse on a large scale has been frustratingly difficult. Nevertheless, as the complexity and cost of software systems continues to rise, there has been growing interest in really trying to make large-scale reuse a reality. Interest in reuse has been particularly. strong in both the Ada and objectoriented programming communities. This panel brings together key experts from these communities to discuss the issues, problems and potentials of reuse. This discussion is continued from the first meeting of this panel at the Tenth Washington Ada Symposium last June.

Panel summary: finding safety in numbers: new languages for safe multicore programming and modeling

This panel brings together designers of both traditional programming languages, and designers of behavioral specification languages for modeling systems, in each case with a concern for the challenges of multicore programming. Furthermore, several of these efforts have attempted to provide data-race-free programming models, so that multicore programmers need not be faced with the added burden of trying to debug race conditions on top of the existing challenges of building reliable systems.

Generalized support software: domain analysis and implementation: experience report submitted to OOPSLA'94

For the past five years, the Flight Dynamics Division (FDD) at NASA’s Goddard Space Flight Center has been carrying out a detailed domain analysis effort and is now beginning to implement Generalized Support Software (GSS) based on this analysis GSS is part of the larger Flight Dynamics Distributed System (FDDS), and is designed to run under the FDDS User Interface / Executive (UIX). The FDD is transitioning from a mainframe based environment to FDDS based systems running on engineering workstations The GSS will be a library of highly reusable components that may be conjigured within the standard FDDS architecture to quickly produce low-cost satellite ground support systems. The estimates for the first release is that this library will contain approximately 200,000 lines of code. The main driver for developing generalized software is development cost and schedule improvement. The goal is to ultimately have at least 80 percent of all software required for a spacecraft mission (within the domain supported by the GSS) to be configured from the generalized components. Domain Analysis