leff@smu.UUCP (Laurence Leff) (08/15/89)
PART IV of V
Software Engineering Institute Carnegie Mellon University
Information Management
Pittsburgh, Pennsylvania 15213
1 January 1986 -- 4 August 1989 Annotated list of available documents.
Technical reports that have DTIC numbers are available from the Defense
Technical Information Center (DTIC) and the National Technical Information
Service (NTIS). (As an example, ADA169705 is the DTIC number for the SEI
report Toward a Reform of the Defense Department Software Acquisition Policy.)
If you wish to request a copy of one of the following reports, please contact
either DTIC or NTIS directly.
DTIC Defense Technical Information Center
ATTN: FDRA
Cameron Station
Alexandria VA 22304-6145
NTIS National Technical Information Service
U.S. Department of Commerce
Springfield, VA 22161
CMU/SEI-88-TR-5, ADA200085
Bass, Hardy, Hoyt, Little, Seacord
Introduction to the Serpent User Interface
Management System
Serpent is an example of the class of systems known as a User Interface
Management System. It uses the X Window System to interact with the end user,
and is useful both as a portion of a production system and as a separate
prototyping tool. Serpent supports the development and execution of the user
interface of a system. It provides an editor with which to specify the user
interface and a runtime system that communicates with the application to get
the data to display. The system then uses the specification previously output
from the editor to decide how to display that data. This report provides a
technical overview of Serpent, its components, the module used in specifying
the user interface, and the editor used in constructing the user interface.
CMU/SEI-88-TR-6, ADA196664
Bass, Hardy, Hoyt, Little, Seacord
Serpent Runtime Architecture and Dialogue Model
This paper describes the runtime architecture and dialogue model of the Serpent
User Interface Management System (UIMS). Serpent uses existing software systems
to create a UIMS based on a structured production model to specify the
dialogue, and uses a database approach for communication between its internal
layers. The model for the dialogue in Serpent supports simultaneity of
subdialogues and presents the dialogue specifier with a model that views data
as mapping from the application to the presentation. The database approach for
communication between the layers provides a model that application programmers
understand well and find easy to use. The approach also provides the power
necessary to decouple the application structures from the structures implicit
in the user interface.
CMU/SEI-88-TR-7, ADA197490
Feiler, Smeaton
The Project Management Experiment
This report covers a project management (PM) experiment, one of six experiments
that examine different functional areas of Ada programming environments. The PM
experiment was designed as part of the Evaluation of Ada Environments Project.
This report describes the environment-independent part of the experiment: the
activities covering the functional area, the evaluation criteria, and an
experiment scenario to be performed on different environments. The experiment
as it stands has been validated through internal and external review and
through application to several environments that support project management.
CMU/SEI-88-TR-8, ADA197416
Wood, Pethia, Roberts, Firth
A Guide to the Assessment of Software Development Methods
Over the past decade, the term "software engineering methods" has been attached
to a variety of procedures and techniques that attempt to provide an orderly,
systematic way of developing software. Existing methods approach the task of
software engineering in different ways. Deciding which methods to use to reduce
development costs and improve the quality of products is a difficult task. This
report outlines a five- step process and an organized set of questions that
provide method assessors with a systematic way to improve their understanding
of and form opinions about the ability of existing methods to meet their
organization's needs.
CMU/SEI-88-TR-9, ADA197137
Kellner, Hansen
Software Process Modeling
An SEI objective is to provide leadership in software engineering and in the
transition of new software engineering technology into practice. This paper
discusses a software process modeling case study conducted at the SEI.
CMU/SEI-88-TR-11, ADA197671
Feiler, Smeaton
Managing Development of Very Large Systems: Implications for Integrated
Environment Architectures
Version and configuration control are mechanisms for managing source code and
system builds. In the development of very large systems, built by large teams,
development management is the dominant factor. In this paper we examine
management support for development through integrated environments and
investigate the implications for environment architectures. We do so by
defining a project scenario that is to be performed with integrated project
support environments. The scenario has been carefully designed to not only
determine the scope of management functionality provided by a particular
environment, but also to probe implications for the architecture of
environments. The implications discussed in this paper are: focus on user
activities; the integration of project management and development support
concepts; the ability to reinforce and avoid conflict with particular
organizational models; the ability to support evolution and change of the
product, environment, and organization; and the capability for adaptation and
insertion into a work environment. The scenario is part of a methodology for
evaluation of environments currently used at the Software Engineering
Institute.
CMU/SEI-88-TR-13
Holibaugh, Perry
Phase I Testbed Description: Requirements and Selection Guidelines
The Application of Reusable Software Components Project has constructed a reuse
testbed for conducting software engineering experiments in software
reusability. The hardware and system software of the testbed will provide a
distributed computing environment with file-server capability for the storage
of reusable components and other artifacts of the development process. The
testbed will support a variety of domain-independent and domain-dependent
reusable components. The testbed will also support tools that foster reuse.
This document contains the requirements and selection criteria for the testbed
hardware, software, reusable resources, and an environment. For each of these
four testbed resources, the requirements are grouped into five areas: support
of experiments, maximization of experience and reusability, applicability to
problem domains, acceleration of technology transition, and advancing the state
of the practice in reuse.
CMU/SEI-88-TR-15,
Feiler, Dart, Downey
Evaluation of the Rational Environment
This report presents an analysis of the Rational R1000 Development System for
Ada, also called the Rational Environment. The evaluation combined the use of
the Software Engineering Institute (SEI) methodology for evaluation of Ada
environments, an analysis of functionality not covered by that methodology, and
an assessment of the novel environment architecture of the Rational
Environment. In addition to this report, Experiment Transcripts for the
Evaluation of the Rational Environment, by Grace Downey, Mitchell Bassman, and
Carl Dahlke (CMU/SEI-88-TR-21) contains support material for the experimental
results. The support material is the result of performing experiments based on
the SEI's environment evaluation methodology. It consists of transcripts of
the experiments, the detailed answers to the evaluative questions, and the
detailed performance results.
CMU/SEI-88-TR-16, ADA198933
Bamberger, Colket, Firth, Klein, D., Van Scoy
Kernel Facilities Definition
This document defines the conceptual design of the Kernel by specifying 1) the
underlying models, assumptions, and 2) restrictions that govern the design and
implementation of the Kernel; and the behavioral and performance requirements
to which the Kernel is built. This document is the requirements and top level
design document for the Kernel.
CMU/SEI-88-TR-17, ADA199482
Bamberger, Colket, Firth, Klein, D., Van Scoy
Distributed Ada Real-Time Kernel
This paper addresses two distinct needs of real-time applications:
distribution and hard real-time scheduling mechanisms. Specifically, this
paper rejects both the notion of modifying the Ada language to achieve needed
real-time solutions and the current fad of extensively modifying the Ada
compiler and/or vendor-supplied runtime system. Instead, this paper defines
the functionality of a Distributed Ada Real-time kernel (hereafter called the
Kernel). The goal of the Kernel is to support effectively the execution of
distributed, real-time Ada applications in an embedded computer environment by
returning control to the user, where it belongs.
CMU/SEI-88-TR-18,
Barbacci, Doubleday, Weinstock
The Durra Runtime Environment
Durra is a language designed to support PMS-level programming. PMS stands for
Processor-Memory-Switch, the name of the highest level in the hierarchy of
digital systems. An application or PMS-level program is written in Durra as a
set of task descriptions and type declarations that prescribes a way to manage
the resources of a heterogeneous machine network. The application describes
the tasks to be instantiated and executed as concurrent processes, the types of
data to be exchanged by the processes, and the intermediate queues required to
store the data as they move from producer to consumer processes.
This report describes the Durra Runtime Environment. The environment consists
of three active components: the application tasks, the Durra server, and the
Durra scheduler. After compiling the type declarations, the component task
descriptions, and the application description, the application can be executed
by starting an instance of the server on each processor, starting an instance
of the scheduler on one of the processors, and downloading the component task
implementations (i.e., the programs) to the processors. The scheduler receives
as an argument the name of the file containing the scheduler program generated
by the compilation of the application description. This step initiates the
execution of the application.
CMU/SEI-88-TR-19, ADA199481
Barbacci, Doubleday
Generalized Image Library: A Durra Application Example
Durra is a language designed to support the construction of distributed
applications using concurrent, coarse-grain tasks running on networks of
heterogeneous processors. An application written in Durra describes the tasks
to be instantiated and executed as concurrent processes, the types of data to
be exchanged by the processes, and the intermediate queues required to store
the data as they move from producer to consumer processes.
This report describes an experiment in writing task descriptions and type
declarations for a subset of the Generalized Image Library, a collection of
utilities developed at the Department of Computer Science at Carnegie Mellon
University. The experiment illustrates the development of a typical Durra
application. This is a three step process: first, a collection of tasks
(programs) is designed and implemented (these are the GIL programs); second, a
collection of task descriptions corresponding to the task implementations is
written in Durra, compiled, and stored in a library; and finally, an
application description is written in Durra and compiled, resulting in a set of
resource allocation and scheduling commands to be interpreted at runtime. A
few sample application descriptions were developed as part of the experiment
and are also reported in this document.
CMU/SEI-88-TR-20, ADA199429
Barbacci
MasterTask: The Durra Task Emulator
Durra is a language designed to support the construction of distributed
applications using concurrent, coarse-grain tasks running on networks of
heterogeneous processors. An application written in Durra describes the tasks
to be instantiated and executed as concurrent processes, the types of data to
be exchanged by the processes, and the intermediate queues required to store
the data as they move from producer to consumer processes.
The tasks and types available to an application developer are described by a
collection of Durra task descriptions and type declarations stored in a
library. One of the components of a task description is a specification of the
external timing behavior of the task. It describes the sequence of input and
output port operations and the amount of processing time spent between port
operations.
This report describes MasterTask, a program that can emulate any task in an
application by interpreting the timing expression describing the behavior of
the task, performing the input and output port operations in the proper
sequence and at the proper time.
MasterTask is useful to both application developers and task developers.
Application developers can build early prototypes of an application by using
MasterTask as a substitute for task implementations that have yet to be
written. Task developers can experiment with and evaluate proposed changes in
task behavior or performance by rewriting and reinterpreting the corresponding
timing expression.
CMU/SEI-88-TR-21, ADA204634
Downey, Bassman, Dahlke (Computer Sciences Corporation)
Experiment Transcripts for the Evaluation of the Rational Environment
This report supplements the report Evaluation of the Rational Environment
(CMU/SEI-88-TR-15). It contains the instantiation of the experiments presented
in the Evaluation of Ada Environments by Nelson Weiderman, et al.
(CMU/SEI-87-TR-1). Overall conclusions and analysis of the Rational
Environment can be found in Evaluation of the Rational Environment.
CMU/SEI-88-TR-22, ADA204399
Perry
Perspective on Software Reuse
This report presents a perspective on software reuse in the context of "ideal"
software development capabilities. Software reuse is viewed as a means of
achievingMor at least approximatingM the idea capabilities. A generic
application and development model is proposed for unifying various types of
software reuse. The model can be initially formulated as a project family
architecture and produced from a domain features analysis. The approach
presented in this report is intended to lead to a reuse strategy and
methodology for software development.
CMU/SEI-88-TR-23, ADA204850
Meyers, Weiderman
Functional Performance Specification for an Inertial Navigation System
This document defines the functional and performance requirements for the
inertial navigation system simulator that interfaces with the external computer
system (ECS) simulator. Both the INS simulator and the ECS simulator are being
developed in Ada by the Real-Time Embedded Systems Testbed Project at the
Software Engineering Institute (SEI). The INS simulator is similar to a
real-world INS, but has reduced functionality. This document provides
specifications for the major functions of the INS simulator.
CMU/SEI-88-TR-24
Meyers, Weiderman
System Specification Document: Shipboard Inertial Navigation System Simulator
and External Computer
This document specifies high-level requirements for a shipboard inertial
navigation system (INS) simulator and an external computer system that will
interface with the inertial navigation system.
CMU/SEI-88-TR-25, ADA200611
Meyers, Mumm Functional Performance Specification for an
External Computer System Simulator
This document defines the functional and performance requirements for the
external computer system (ECS) simulator that interfaces with the inertial
navigation system simulator. Both the ECS simulator and the INS simulator are
being developed in Ada by the Real-Time Embedded Systems Testbed Project at the
Software Engineering Institute (SEI). The ECS simulator is similar to a
real-world ECS, but has reduced functionality. This document provides
specifications for the major functions of the ECS simulator.
CMU/SEI-88-TR-26, ADA204757
Pedersen, Klein, M.
Using the Vienna Development Method (VDM to Formalize
a Communication Protocol)
The Vienna Development Method (VDM is based upon iterative refinement of formal
specifications written in the model-oriented specification language, Meta-IV.
VDM is also an informal collection of experiences in formal specification
within several application domains. This paper provides an example of how VDM
might be used in the area of communications, a new domain for VDM.
CMU/SEI-88-TR-30, ADA204849
Lee, Rissman, D'Ippolito, Plinta, Van Scoy
An OOD Paradigm for Flight Simulators, 2nd Edition
This report presents a paradigm for object-oriented implementation of flight
simulators. It is a result of work on the Ada Simulator Validation Program
(ASV) carried out by members of the technical staff at the SEI.
CMU/SEI-88-TR-33, ADA205048
Sha, Goodenough
Real-Time Scheduling Theory and Ada
The Ada tasking model was intended to facilitate the management of concurrency
in a priority-driven scheduling environment. In this paper, we will review
some important results of a prioritty-based scheduling theory, illustrate its
applications with examples, discuss its implications for the Ada tasking model,
and suggest workarounds that permit us to implement analytical scheduling
algorithms within the existing framework of Ada.
CMU/SEI-88-TR-34, ADA207544
Sha, Rajkumar, Lehoczky, Ramamritham,
Mode Change Protocols for Priority-Driven Preemptive Scheduling
In many real-time applications, the set of tasks in the system as well as the
characteristics of the tasks change during system execution. Specifically, the
system moves from one mode of execution to another as its mission progresses.
A mode change is characterized by the deletion of some tasks, addition of new
tasks, or changes in the parameters of certain tasks, e.g., increasing the
sampling rate to obtain a more accurate result. This paper discusses a
protocol for systematically accomplishing mode change in the context of a
priority-driven preemptive scheduling environment.
CMU/SEI-89-TR-1, ADA206573
Humphrey, Kitson, Kasse
The State of Software Engineering Practice: A Preliminary Report
This is the first in a series of SEI reports to provide periodic updates on the
state of software engineering practice in the DoD software community. The SEI
has developed, and is refining, a process framework and assessment methodology
for characterizing the processes used by software organizations to develop and
evolve software products. This report provides a brief overview of the process
framework and assessment approach, describes assessment results obtained to
date, and discusses implications of the current state of the practice for both
customerrs and suppliers of DoD software.
CMU/SEI-89-TR-1
Humphrey, Kitson, Kasse
The State of Software Engineering Practice: A Preliminary Report
This is the first in a series of SEI reports to provide periodic updates on the
state of software engineering practice in the DoD software community. The SEI
has developed, and is refining, a process framework and assessment methodology
for characterizing the processes used by software organizations to develop and
evolve software products. This report provides a brief overview of the process
framework and assessment approach, describes assessment results obtained to
date, and discusses implications of the current state of the practice for both
customers and suppliers of DoD software.
CMU/SEI-89-TR-2
Humphrey, Kellner
Software Process Modeling: Principles of Entity Process Models
A defined software process is needed to provide organizations with a consistent
framework for performing their work and improving the way they do it. An
overall framework for modeling simplifies the task of producing process models,
permits them to be tailored to individual needs, and facilitates process
evolution. This paper outlines the principles of entity process models and
suggests ways in which they can help to address some of the problems with more
conventional approaches to modeling software processes.
CMU/SEI-89-TR-4, ADA206574
Bass, Coutaz
Human-Machine Interaction Considerations
This document introduces current concepts and techniques relevant to the design
and implementation of user interfaces. A user interface refers to those
aspects of a system that the user refers to, perceives, knows, and understands.
A user interface is implemented by code that mediates between a user and a
system. This document covers both aspects.
CMU/SEI-89-TR-5, ESD-TR-89-5
Lee, K., Rissman, M.
An Object-Oriented Solution Example: A Flight Simulator Electrical System
This report describes an implementation of a subset of an aircraft flight
simulator electrical system. It is a result of work on the Ada Simulator
Validation Program (ASVP) carried out by members of the technical staff (MTS)
at the SEI. The MTS developed a paradigm for describing and implementing
flight simulator systems in general. The paradigm is a model for implementing
systems of objects. The objects are described in a form of design
specification called an object diagram. This report has been prepared to
demonstrate a full implementation of a system: package specifications and
bodies. The intent is to provide an example; the code is functional, but there
is no assurance of robustness.
CMU/SEI-89-TR-6, ADA206779
Editors: Martin, D., Carey, Coticchia, Fowler, Maher
Proceedings of the Workshop on Executive Software Issues
August 2-3 and November 18, 1988
These proceedings document the results of two sessions of the Workshop on
Executive Software Issues held at the Software Engineering Institute on August
2-3 and November 18, 1988. The purpose of the workshop was to define the
issues that should be brought to the attention of executives in the defense
industry, government, and academia and to propose resolutions to those issues.
The issues discussed were divided into three broad categories: national
strategy, acquisition, and building large complex systems. Described in the
proceedings are the major issues and recommended actions.
CMU/SEI-89-TR-7
Olson, Humphrey, Kitson
Conducting SEI-Assisted Software Process Assessments
This report describes software process assessment as it is performed in
organizations with the assistance of the Software Engineering Institute (SEI).
A software process assessment is an appraisal or review of an organization's
software process (e.g., software development process). The main objectives of
such an assessment are to understand the state of practice in an organization,
to identify key areas for improvement, and to initiate the actions that
facilitate those improvements. This report is specifically addressed to the
organizations and assessment team members that may be involved in an
SEI-assisted software process assessment.
CMU/SEI-89-TR-8, ADA207445
Weinstock
Performance and Reliability Enhancement of the Durra Runtime Environment
Durra is a language designed to support PMS-level programming. PMS stands for
Processor Memory Switch, the name of the highest level in the hierarchy of
digital systems. An application or PMS-level program is written in Durra as a
set of task descriptions and type declarations that prescribes a way to manage
the resources of a heterogeneous machine network. The application describes
the tasks to be instantiated and executed as concurrent processes, the types of
data to be exchanged by the processes, and the intermediate queues required to
store the data as they move from producer to consumer processes.
A runtime environment for Durra has been operational for some time. There are
two major problems with this initial implementation: it makes no significant
attempt to tune the performance of the system, and reliability has not been
designed into the system. This report describes a new design for the Durra
runtime environment that addresses these two issues. The new runtime
environment consists of two major components: a local executive which runs on
every processor and is responsible for process and queue management, and a
global executive which runs replicated on several processors and is responsible
for configuration management and reliability services.
CMU/SEI-89-TR-9, ADA206575
Barbacci, Doubleday, Weinstock, Baur, Bixler, Heins
Command, Control, Communications, and Intelligence Node: A
Durra Application Example
Durra is a language designed to support the construction of distributed
applications using concurrent, coarse-grain tasks running on networks of
heterogeneous processors. An application written in Durra describes the tasks
to be instantiated and executed as concurrent processes, the types of data to
be exchanged by the processes, and the intermediate queues required to store
the data as they move from producer to consumer processes. This report
describes an experiment in implementing a command, control, communications and
intelligence (C3I) node using reusable components. The experiment involves
writing task descriptions and type declarations for a subset of the TRW
3
testbed, a collection of C I software modules developed by TRW Defense Systems
Group. The experiment illustrates the development of a typical Durra
application. This is a three-step process: first, a collection of tasks
(programs) is designed and implemented (these are the testbed programs);
second, a collection of task descriptions corresponding to the task
implementations is written in Durra, compiled, and stored in a library; and
finally, an application description is written in Durra and compiled, resulting
in a set of resource allocation and scheduling commands to be interpreted at
runtime.
CMU/SEI-89-TR-10, ADA207545
McSteen, Schmick, Editors
Software Engineering Education Directory
This directory provides information about software engineering courses and
software engineering degree programs that are available in the United States
and Canada.
-------listing continued in next post-------
--
But who were they all in your sleep last night, first one then the next,
with their menace, wild sempahore, and lusts? I hardly know where you find
the strength come morning. August Kleinzahler