🚀 go-pugleaf

Software Engineering Institute
Information Management
Software Engineering Institute Documents





HOW TO ACCESS SEI REPORTS ELECTRONICALLY

The Software Engineering Institute (SEI) has begun electronic
distribution of some-not all-of its publications. The
procedure by which you can obtain electronic copies of SEI
reports is described on pages 1 and 2 of this document. Since
many SEI reports are yet unavailable in electronic form,
instructions for obtaining hardcopies of such reports appear
on page 5 of this document.

FTP File transfer protocol (FTP) is a facility that allows
files to be transferred to and from remote network sites.
Brief instructions for using FTP are provided below; if you
require additional information about FTP, contact your system
administrator.

SEI DIRECTORY NAME
The directories listed in /pub/documents contain files that
are accessible via anonymous FTP.


SEI MACHINE ADDRESS
The SEI machine address is:

		ftp.sei.cmu.edu
                      or 
		128.237.2.179


INSTRUCTIONS
If you are working at a UNIX machine connected to the Internet, use the 
following procedure to access SEI files.


TO CONNECT TO THE SEI FTP MACHINE
1	At your Unix prompt, type:

ftp ftp.sei.cmu.edu

2	At the login prompt, type:

anonymous

3	At the password prompt, 
type:

your electronic mail address 
(e.g., jones@cs.xsu.edu)

4	Change to the documents 
directory by typing:

cd /pub/documents

5	Get the READ.ME file by 
typing:

get READ.ME

You should now have a copy of the READ.ME file on your home 
machine.

Repeat Steps 1- 5 from the above procedure to obtain the
documents you want. Step 5 may be repeated as many times as
needed to obtain the desired documents; otherwise, terminate
the process, as is indicated below:

6	Terminate the FTP process 
by typing:

quit


COPYRIGHT NOTE
Some of the files may be temporarily read-protected pending the 
resolution of some copyright issues.
File format

The documents in /pub/documents are formatted as PostScript
files, and thus may be printed on a PostScript printer at
your site. All PostScript files have a .ps suffix.


FIGURES
Some of the files contain figures that have not yet been made
available electronically. Until this is resolved, such files
(ones containing figures markers) will print without figures.
Until the figures are made available electronically, feel
free to contact one of the distribution centers (listed
below) to obtain hardcopies of the documents.


PRINTER
Most of the documents use several of the following PostScript
fonts: Helvetica, Times, New Century Schoolbook, Courier, and
Symbol. Be certain to use a printer that can support these
fonts.  All files MUST be printed with the pages in the order
that they appear in the file. Some print spoolers attempt to
reverse the pages before printing so that the output page
stack will be in the proper order. This may cause the files
to fail to be printed. A common symptom of such a page order
error is having the file printed almost entirely in Courier
font.  Test print

You may want to test these procedures before downloading
large documents. For that purpose, a short test document
appears in the /pub/documents directory in file testTR.ps.
It is a three page excerpt from a technical report; the
second page should be blank.  Photocopying

Documents in PostScript form are intended to be reproduced as
two- sided documents. The left and right margins will be
different widths on odd- and even-numbered pages. If you
choose to make a two-sided document from the printed
original, you may wish to check the first few pages and
insert a blank page wherever needed (such as after the title
page on some documents) to ensure that the pagination is
correct.

THE ANNOTATED LISTING
Documents appearing in the annotated listing that are denoted
with the following icon are available via anonymous FTP:


QUESTIONS
If you cannot print a file, first verify that the print
failure is not due to a problem at your site. Next, reread
and retry the above instructions.  Lastly, if the problem
remains, send electronic mail to bjz@sei.cmu.edu describing
the hardware/operating system being used, the type of printer
on which you're attempting to print the document, and a
description of the problem.



HOW TO ORDER BOUND COPIES OF SEI REPORTS
Software Engineering Institute (SEI) technical reports are
available from Research Access, Inc. (RAI), National
Technical Information Service (NTIS), or the Defense
Technical Information Center (DTIC).  (Note: To order
documents from DTIC, you must provide the DTIC accession
number for the desired report. As an example, "ADA235641" is
the DTIC number for the SEI report Rate Monotonic Analysis
for Real-Time Systems.)

DISTRIBUTING CENTERS
If you wish to request a bound copy of an SEI report, please
contact RAI, NTIS, or DTIC directly. The addresses are
provided below. Several SEI reports have not yet been filed
with DTIC; therefore, they do not have DTIC accession
numbers.

RAI
Research Access Inc.
3400 Forbes Avenue
Suite 302
Pittsburgh, PA 15213
Telephone: 1800 685-6510
FAX: (412) 682-6530


DTIC
Defense Technical Information Center
ATTN: FDRA Cameron Station
Alexandria, VA 22304-6145
Telephone: (703) 274-7633

(Note that DTIC limits distribution to government contractors
who have established a DTIC account.).


NTIS
National Technical Information Service
U.S. Department of Commerce
Springfield, VA 22161-2103
Telephone: (703) 487-4600



			-----begin Part 2 (of 5) -----

Formal Development of Ada Programs Using Z and Anna: A Case Study
CMU/SEI-91-TR-1, ADA235698
Place, P., Wood, W.

This report describes a method for the formal development of
Ada programs from a formal specification written in Z.
ANNotated Ada (Anna) is used as an intermediate language
linking the more abstract Z specifications to the concrete
Ada program. The method relies on the notion that successive
small transformations of a specification are easier to verify
than a few large transformations. Essentially the method uses
three notations for the representation of the system: an
implementation-independent notation for the specification of
the system, an implementation-dependent notation for the
representation of a lower level specification of the system,
and the implementation language. Z and Anna are outlined
briefly and examples of transformations are presented. A
simple Z specification has been chosen and the
transformations presented in the report are transformations
of the Z specification into Anna. Conclusions are drawn about
the development method presented.


STARS/Users Workshop: Final Report - Issues for Discussion Groups 
CMU/SEI-90-TR-32, ADA235776
Bamberger, J., (editor)

The STARS (Software Technology for Adaptable, Reliable
Systems) Program is focused on providing the DoD software
community with a software engineering environment, repository
technology, and process models. This STARS Workshop was
targeted toward increasing the communication between the
STARS Program and the builders of software- dependent
systems. This was the first of many public discussion hosted
by the STARS Program. This workshop was hosted by the SEI.


SQL Ada Module Description Language SAMeDL Version 3.75, The
CMU/SEI-90-TR-26, ADA235781
Graham, M.

This document is a reference manual for the SQL Ada Module
Description Language (SAMeDL). The SAMeDL is used to describe
database services needed by Ada application programs.


Tool Version Management Technology: A Case Study
CMU/SEI-90-TR-25, ADA235639
Feiler, P., Downey, G.

This report describes a portion of the problem of maintaining
tools for the purpose of software development. It discusses
an innovative solution to tool version management available
in the commercially available Network Software Environment
from Sun Microsystems, Inc. It applies NSE mechanisms to
solve three problems that are common to the use and
management of tools for software development.


Software Engineering Process Group Guide
CMU/SEI-90-TR-24, ADA235784
Fowler, P., Rifkin, S.

Improving the of software systems development and maintenance
is the most reliable way to improve product quality. This
document offers guidance on how to establish a software
engineering process group (SEPG) and related software
engineering process improvement functions. The process group
works with line organizations to improve process quality by
helping to assess current status, plan and implement
improvements, and transfer technology to facilitate
improvement in practice.


Transaction-Oriented Configuration Management: A Case Study
CMU/SEI-90-TR-23, ADA235510
Feiler, P., Downey, G.

Software configuration management (SCM) is a key element of
the software development process. A number of new
configuration management techniques in commercial SCM tools
and environments with SCM capabilities have been observed.
This report illustrates some of the advances in SCM concepts
by example of a particular commercial system: the Sun Network
Software Environment (NSE). NSE embodies a transaction model
of configuration management. In order to demonstrate the
capabilities and limitations of the transaction model, NSE is
applied to three problem areas for configuration management:
adaptation for parallel development and team support,
development and maintenance in software families and
development in a distributed and heterogeneous network.


Design Space and Design Rules for User Interface Software Architecture, A
CMU/SEI-90-TR-22, ADA237049
Lane, T.G. 

The architecture of a user interface software system can be
described in terms of a fairly small number of key functional
and structural choices. This report presents a "design space"
that identifies these key choices and classifies the
alternatives available for each choice.  The design space is
a useful framework for organizing and applying design
knowledge.  The report presents a set of design rules
expressed in the terms of the design space. These rules can
help a software designer to make good structural choices
based on the functional requirements for a user interface
system. Extension of this work might eventually provide
automated assistance for structural design.


Feature-Oriented Domain Analysis (FODA) Feasibility Study 
CMU/SEI-90-TR-21, ADA235785
Kang, K., Cohen, S., Hess, J., Novak, W., Peterson, A.

Successful software reuse requires the systematic discovery
and exploitation of commonality across related software
systems. By examining related software systems and the
underlying theory of the class of systems they represent,
domain analysis can provide a generic description of the
requirements of that class of systems and a set of approaches
for their implementation. This report will establish methods
for performing a domain analysis and describe the products of
the domain analysis process. To illustrate the application of
domain analysis to a representative class of software
systems, this report will provide a domain analysis of window
management system software.


Prospects for an Engineering Discipline of Software
CMU/SEI-90-TR-20, ADA235751
Shaw, M. 

Software Engineering is not yet a true engineering
discipline, but it has the potential to become one. Older
engineering fields offer glimpses of the character software
engineering might have. From these hints and an assessment of
the current state of software practice, we can project some
characteristics software engineering will have and suggest
some steps toward an engineering discipline of software.

This paper begins by examining the usual practice of
engineering and the way it has evolved in other disciplines.
This discussion provides a historical context for assessing
the current practice of software production and setting out
an agenda for attaining an engineering practice.


Analysis of Input/Output Paradigms for Real-Time Systems, An
CMU/SEI-90-TR-19, ADA226724
Klein, M., Rayla, T.

The correctness of a real-time system with hard deadline
requirements depends both on the logical correctness and on
the timing correctness of the system. The principles of rate
monotonic scheduling have proven to be very useful in
providing a framework for designing, analyzing, and modifying
the timing and concurrency aspects of real-time systems. This
paper illustrates how to build a mathematical model of the
schedulability of a real-time system, taking into
consideration such factors as preemption, synchronization,
non- preemptibility, interrupts, and process idle time. In
particular, this paper illustrates how these principles can
be applied to input/output interfaces (e.g., to devices or
local area networks) to predict the timing behavior of
various design alternatives.


Studying Software Architecture Through Design Spaces and Rules
CMU/SEI-90-TR-18, ADA235737
Lane, T.G. 

This report argues that the overall structure of software
systems ("software architecture") is usefully studied by
constructing design spaces. A design space identifies the key
functional and structural choices made in creating a system
design, and it classifies the alternatives available for each
choice. Rules can be formulated to relate choices within a
design space. Sets of such rules are a valuable design aid
and offer a promising route to automatic structural design.
By codifying design practice, design spaces can also aid
software maintenance and training. To support this argument,
the report describes a design space and associated rules for
user interface software, and it discusses an experiment that
validated these design rules by comparing their predictions
to real system designs.


Experiences Porting the Distributed Ada Real-Time Kernel
CMU/SEI-90-TR-17, ADA226693
Tomayko, J.E., Smith, B. 

The Distributed Ada Real-Time Kernel (DARK) is a mechanism
for supporting the execution of distributed real-time Ada
applications in embedded computer systems. It provides a
solution to scheduling and distributing tasks without
modifying the Ada language or vendor-supplied run time
systems. An important test of the utility of the Kernel is
whether or not it can be ported to different hardware
architectures and still function effectively. As part of an
independent research and development project, Boeing Military
Airplanes and The Wichita State University became
co-acceptors of a copy of DARK for the purpose of
demonstrating a port to a 68000-based distributed
architecture. This technical report describes the experiences
in accomplishing the port.


Informatics for a New Century: Computing Education for 1990s and Beyond
CMU/SEI-90-TR-15, ADA235783
Shaw, M. 

Information technology and computer science have not only
reshaped computation, communication, and commerce; they have
expanded the basic models and paradigms of many disciplines.
Informatics education has obligations to all the communities
that rely on information technology, not just the computing
professionals. Serving this extended audience well requires
changes in the content and presentation of computing
curricula. This paper sketches the coming needs for
information processing and analyzes the populations that will
require informatics education. It considers curriculum
requirements through two examples, one outside the
traditional boundary of computer science and one inside.


CASE Tool Integration and Standardization
CMU/SEI-90-TR-14, ADA235640
Zarrella, P.

CASE tool users are faced with the task of coordinating tools
and data from a variety of sources spanning the entire
software development life cycle. Despite much discussion and
increased standardization activity, complete, transparent
CASE tool integration is still a long way from realization.
There are a number of factors which have complicated the tool
integration scenario and a number of actions being taken in
an attempt to resolve the problems. The implications of these
concerns can be examined from the perspectives of
single-vendor, multiple-vendor, operating environment,
development process, and end-user integration. In addition to
specific technical and methodological solutions, standards
efforts are viewed as a possible path to tool integration. To
date, formal efforts have done little to resolve the
integration problems, but de facto standards may well become
the cornerstone of future CASE tool evolution.


National Software Capacity: Near-Term Study
CMU/SEI-90-TR-12, ADA226694
Siegel, J., Stewman, S., Kondra, S., Larkey, P., Wagner, W. Gary

This study provides an initial assessment of the U.S.'s
industrial capacity to produce MCCR software. A survey of
senior government and industry people showed that 90 percent
of them expected a serious problem with the nation's capacity
to produce military software over the next 5 years. They
ranked acquisition and labor factors as contributing most to
the failure of military system development contracts to meet
schedule or costs. The study team also analyzed available
data about the supply of labor (new graduates and experienced
scientists and engineers) and three aspects of demand (Ada
systems, PDSS, and related commercial applications) before
concluding there is a serious capacity problem. The report
describes labor, organizational, and technological issues
affecting software production capacity and concludes with
some preliminary recommendations for DoD and industry
initiatives.


Spectrum of Functionality in Configuration Management Systems
CMU/SEI-90-TR-11, ADA235753
Dart, S. 

The Software Environments Project at the Software Engineering
Institute has found considerable progress concerning support
for software configuration management (CM) in environments
and tools. This paper's intent is to highlight a spectrum of
features provided by existing CM systems. The spectrum shows
features as being extensions or generalizations of other
features and these extensions represent the progress. As part
of presenting the features, the scope of issues concerning
users of CM systems is discussed. No single CM system
provides all the functionality required by the different
kinds of users of CM systems.  Rather, each CM system
addresses some part of a spectrum of functionality. To
complete the report, several configuration management systems
are briefly described.


Generic Avionics Software Specification
CMU/SEI-90-TR-8, ADA235752
Locke, D., Goodenough, J.

This report informally specifies the general functions, data
interactions, and timing constraints for an avionics mission
control computer system typical of those found in some
existing U.S. Navy/Marine Corps aircraft. Avionics functions
and equipment are described only to the extent needed to
specify MCC behavior, with primary emphasis being given to
timing constraints and data interactions. The specification
is intended to allow a wide variety of possible
implementation approaches and was developed primarily to
exemplify timing requirements and functional interactions in
a typical real-time system.

The specification consists of an introductory description of
the environment in which the mission computer operates
followed by a functional description of the requirements
imposed on the mission computer. The functional description
is minimal and serves mainly to characterize computer
workload and data interactions. An appendix contains a
summary of the timing requirements together with an analysis
of the expected CPU load for a particular attack scenario.


Hartstone Benchmark Results and Analysis
CMU/SEI-90-TR-7, ADA226817
Donohoe, P. 

Hartstone is a series of timing requirements for testing a
system's ability to handle hard real-time applications. It is
specified as a set of processes with well-defined workloads
and timing constraints. The name Hartstone derives from HArd
Real Time and the fact that the workloads are based on the
well-known Whetstone benchmark. This report describes the
results obtained by running Version 1.0 of the Hartstone
benchmark, an Ada implementation of one of the requirements,
on a number of compiler/target processor combinations. The
characteristics and expected behavior of the benchmark are
described, actual results are presented and analyzed, and the
lessons learned about the compilers and processors, and the
benchmark itself, are discussed. Nothing in this report
should be taken as an endorsement of, or an indictment of, a
particular product. Users of Ada technology are encouraged to
experiment with the Hartstone benchmark relative to their own
particular application requirements.


Implementing Sporadic Servers in Ada
CMU/SEI-90-TR-6, ADA226723
Sprunt, B., Sha, L. 

The purpose of this paper is to present the data structures
and algorithms for implementing sporadic servers in real-time
systems programmed in Ada. The sporadic server algorithm is
an extension of the rate monotonic scheduling algorithm.
Sporadic servers are tasks created to provide limited and
usually high-priority service for other tasks, especially
aperiodic tasks. Sporadic servers can be used to guarantee
deadlines for hard-deadline aperiodic tasks and provide
substantial improvements in average response times for soft-
deadline aperiodic tasks over polling techniques. Sporadic
servers also provide a mechanism for implementing the Period
Transformation technique that can guarantee that a critical
set of periodic tasks will always meet their deadlines during
a transient overload. Sporadic servers can also aid fault
detection and containment in a real-time system by limiting
the maximum execution time consumed by a task and detecting
attempts to exceed a specified limit. This paper discusses
two types of implementations for the sporadic server
algorithm: (1) a partial implementation using an Ada task
that requires no modifications to the Ada runtime system and
(2) a full implementation within the Ada runtime system. The
overhead due to the runtime sporadic server implementation
and options for reducing this overhead are discussed. The
interaction of sporadic servers and the priority ceiling
protocol is also defined.


Survey of Formal Specification Techniques for Reactive Systems
CMU/SEI-90-TR-5, ADA22374
Place, P., Wood, W.

Formal methods are being considered for the description of
many systems including systems with real-time constraints and
multiple concurrently executing processes. This report
develops a set of evaluation criteria and evaluates
Communicating Sequential Processes (CSP), the Vienna
Development Method (VDM), and temporal logic. The evaluation
is based on specifications, written with each of the
techniques, of an example avionics system.


Software Engineering Education Directory
CMU/SEI-90-TR-4, ADA223740
McSteen, W., Gottier, B., Schmick, M., 

This directory provides a information about software
engineering courses and software engineering degree programs
offered by universities, primarily in the United States.



1990 SEI Report on Undergraduate Software Engineering Education
CMU/SEI-90-TR-3, ADA223881
Ford, G. 

Fundamental issues of software engineering education are
presented and discussed in the context of undergraduate
programs. Included are discussions of the definition of
software engineering and its differences from computer
science, the need for undergraduate software engineering
education, possible accreditation of undergraduate programs,
and prospects for professional certification and licensing of
software engineers. The objectives and content of an
undergraduate program are described, as are strategies for
the evolution and implementation of such programs. An
appendix presents a report on the 1989 SEI Workshop on an
Undergraduate Software Engineering Curriculum.


Dark Porting and Extension Guide Kernel Version 3.0
CMU/SEI-89-TR-40, ADA228034
Bamberger, J., Coddington, T., Firth, R., Klein, D., Stinchcomb, D., Van Scoy, R.

This document describes the modifications made to the
Distributed Ada Real-Time Kernel (DARK) software when porting
it form its original execution environment, the 68020-based
testbed built at the Software Engineering Institute, to a
VAX/VMS system. This document also contains information about
logical extensions to the Kernel, and the impacts thereof,
should the Kernel be used in operational systems.


Inertial Navigation System Simulator Program: Top-Level Design
CMU/SEI-89-TR-38, ADA223762
Fowler, K. 

Hard-real time systems have consistently proven to be some of
the most difficult for successful software implementation.
Attributes often associated with the intractable nature of
real-time are concurrency, severe timing constraints, the
complexity of real-world devices, and limited resources. In
this experiment, an actual embedded hard real-time
application (Inertial Navigation Set, AN/WSN-5) is simulated
and ported to a variety of target processors. The effort is
specifically directed at investigating the capability of Ada
for providing program development solutions in the hard
real-time regime. Special emphasis is focused on applying the
built-in concurrency capabilities of Ada. The effort contends
with typical cross-targeting issues such as board-level
execution and memory configuration, device communications,
and runtime debugging of the application. This report
presents the top-level design of the application and
addresses the solution in terms of a concurrency abstraction.
Beginning with a classical data flow analysis of the
requirements, Ada tasks are derived from analyzable
categories, specifically periodics, aperiodics, and servers.
This classification scheme is predicated on work actively
being conducted on a scheduling technique that quantifies the
effect of task preemption and blocking, behavior fundamental
to the concept of parallelism in Ada. In a corollary report
[Borger, M. 89], a schedulability analysis of the INS is
described within the framework of the task set developed in
this top-level design.


Comparative Evaluations of Four Specification Methods for Real-Time Systems
CMU/SEI-89-TR-36, ADA219187
Wood, D., Wood, W. 

A number of methods have been proposed in the last decade for
the specification of system and software requirements for
time-critical systems. The emerging CASE technology is based
heavily on a subset of these methods; yet little objective
attention has been paid to the methods themselves. This
report describes our objective evaluation of four methods
(identified as ESML, Harel, Hatley-Pirbhai, and Ward-Mellor),
from identification through detailed assessment. We have
avoided the use of small sample problems as the sole basis of
our evaluation. We depart from this approach by involving
software developers from various application domains,
including extended interviews of those who have applied the
methods to large-scale projects. The resulting
recommendations and conclusions focus on method selection
criteria, and on the large-grained impact of using these
methods on a given project.

The primary audience of this report is the software
development practitioner involved in the method selection or
adoption process. The paper attempts to provide proper
context to assist the practitioner in making appropriate
method adoption decisions. Secondarily, the results of the
paper also should be of to tool vendors, method developers,
and program managers.


Inertial Navigation System Simulator: Behavioral Specification
CMU/SEI-89-TR-35, ADA219294
Landherr, S., Klein, M.

The Real-Time Embedded Systems Testbed (REST) Project at the
Software Engineering Institute is specifying and developing a
representative real-time application. This document augments
an original set of specifications written by a Navy
affiliate. The purpose of this behavioral specification is to
clarify and augment the original.


Durra: A Task-Level Description Language Reference Manual
CMU/SEI-89-TR-34, ADA219293
Barbacci, M., Wing, J. 

Durra is a language designed to support the development of
large-grained parallel programming applications. These
applications are often computation-intensive, or have real-
time requirements that require efficient concurrent execution
of multiple tasks, devoted to specific pieces of the
application. During execution time the application tasks run
on possibly separate processors, and communicate with each
other by sending messages of different types across various
communication links. The application developer is responsible
for prescribing a way to manage all of these resources. We
call this prescription a task- level application description.
It describes the tasks to be executed, the possible
assignments of processes to processors, the data paths
between the processors, and the intermediate queues required
to store the data as they move from source to destination
processes. Durra is a task-level description language, a
notation in which to write these application descriptions.

This document is a revised version of the original reference manual. It describes the syntax 
and semantics of the language and incorporates all the language changes introduced as a 
result of our experiences writing task and application descriptions in Durra. A companion 
document, Durra: A Task-Level Description Language User's Manual describes how to use 
the compiler, runtime environment, and support tools.


Durra: A Task-Level Description Language User's Manual
CMU/SEI-89-TR-33, ADA223761
Barbacci, M., Doubleday, D., Weinstock, C.

Durra is a language designed to support the development of
large-grained parallel programming applications. This is the
manual for users of the Durra compiler, runtime system, and
support tools. Additional documents that describe the syntax
and semantics of the language and the runtime environment are
cited in the bibliography section.


Durra Application Debugger/Monitor, The
CMU/SEI-89-TR-32, ADA219290
Doubleday, D 

Durra is a language designed to support the construction of
distributed applications using concurrent, coarse-grained
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 the Durra application debugger/monitor,
a program that works in conjunction with the Durra runtime
software to help the developer locate errors and/or
performance bottlenecks in a Durra application.


What a Software Engineer Needs to Know: I. Program Vocabulary
CMU/SEI-89-TR-30, ADA219064
Shaw, M., Giuse, D. (School of Computer Science, Carnegie Mellon University), Reddy, R. 
(School of Computer Science, Carnegie Mellon University).

Software development, like any complex task, requires a wide
variety of knowledge and skills. We examine one particular
kind of knowledge, the programming language vocabulary of the
programmer, by gathering statistics on large bodies of code
in three languages. This data shows that most of the
identifiers in programs are either uses of built- in or
standard library definitions or highly idiomatic uses of
local variables. We interpret this result in light of general
results on expertise and language acquisition. We conclude
that tools to support the vocabulary component of software
development are wanting, and this part of an engineer's
education is at best haphazard, and we recommend ways to
improve the situation.


Understanding the Adoption of Ada: A Field Study Report
CMU/SEI-89-TR-28, ADA219188
Smith, G., Hefley, W.

In 1983, the U.S. Department of Defense (DoD) established for
the development of all new DoD mission-critical computer
applications. A multi-industry field study was conducted with
seven business units from DoD contractors that have made
decisions about the adoption and use of Ada. This report
examines the extent to which the Ada adoption behavior of
these contractors is influenced by their expectations of the
technological opportunity provided by Ada, market demand for
Ada, and appropriability conditions in the product market of
firms. Findings indicate contractor decisions about adopting
Ada are influenced both by the technical merits of the
language and the economic impact on the firm.


CASE Planning and the Software Process
CMU/SEI-89-TR-26, ADA219066
Humphrey, W. 

Automating a software process both magnifies its strengths
and accentuates its weaknesses.  Automation can make an
effective process more effective, but it can make a chaotic
process even worse-and at considerable expense. Anyone who
buys expensive tools to solve an ill- defined problem is
likely to be disappointed. Unless procuring such tools is
part of a thoughtful software process improvement plan, the
purchase could be an expensive mistake.

This report discusses software process maturity and its
relationship to planning and installing computer-aided
software engineering (CASE) systems. While process is not a
magic answer (there isn't one), the key issues are discussed
from a process perspective, and guidelines are given for
avoiding the most common pitfalls. Since CASE systems can
involve significant investment, an economic justification may
be necessary. The relevant financial considerations are
therefore discussed, and some basic steps for producing such
justifications are outlined. Finally, some key considerations
for introducing and using CASE systems are discussed.


Classifying Software Design Methods
CMU/SEI-89-TR-25, ADA226696
Wood, W. 

A few mature and popular methods are currently being used to
specify and design real- time embedded systems software, and
these methods are the basis for a large number of tools
automating the process. Unfortunately, some of the tools
support only parts of a method, while others support a
mixture of different methods. Because of the large number of
tools involved, companies selecting tools for their
particular needs are faced with a significant problem. As a
result, the choice of tools often depends on the best
salesperson rather than on the most appropriate method,
leading to disappointment on the part of end users of the
tools. The Software Engineering Institute has had a project
underway for some time that provides a basis for selecting
methods and tools. This paper describes some of the results
of this effort with respect to classifying design methods for
Ada-based software.


Temporal Logic Case Study
CMU/SEI-89-TR-24, ADA219019
Wood, W. 

This report is a case study applying temporal logic to
specify the operation of a bank of identical elevators
servicing a number of floors in a building. The goal of the
study was to understand the application of temporal logic in
a problem domain that is appropriate for the method, and to
determine some of the strengths and weaknesses of temporal
logic in this domain. The case study uses a finite state
machine language to build a model of the system
specification, and verifies that the temporal logic
specifications are consistent using this model. The
specification aspires to be complete, consistent, and
unambiguous.


Hartstone: Synthetic Benchmark Requirements for Hard Real-Time Applications
CMU/SEI-89-TR-23, ADA219326
Weiderman, N. 

The purpose of this paper is to define the operational
concept for a series of benchmark requirements to be used to
test the ability of a system to handle hard real-time
applications.  Implementations of such benchmarks would be
useful in evaluating scheduling algorithms, protocols, and
design paradigms, as well as processors, languages,
compilers, and operating systems. Several Ada programs are
under development to test standard versions of the benchmark
requirements and will be released into the public domain.


Real-Time Software Engineering in Ada: Observations and Guidelines
CMU/SEI-89-TR-22, ADA219020
Borger, M., Klein, M., 

Two important aspects of developing a real-time system are
controlling devices and managing concurrency. In this report,
we present several techniques for controlling devices with
Ada and several Ada tasking paradigms for managing
concurrency. The material presented in this report is taken
from our experiences in developing a real-time embedded
system in Ada, and we use examples from this system to
illustrate the various methods we present. We begin by
describing our experiences using Ada to control devices.
Specifically, we identify issues related to accessing device
registers and handling interrupts, and present techniques for
dealing with such issues. We then recount our experiences
using Ada to manage concurrency. Specifically, we present
coding paradigms for implementing periodicity and
constructing synchronization mechanisms. We illustrate
analytical methods for determining the schedulability of a
task set. We then discuss the effect of aperiodic processing
requirements on the schedulability of a task set.


1989 SEI Report on Graduate Software Engineering Education
CMU/SEI-89-TR-21, ADA219018
Ardis, M., Ford, G.

This annual report on graduate software engineering education
describes recent SEI educational activities, including the
1988 SEI Curriculum Design Workshop. A model curriculum for a
professional Master of Software Engineering degree is
presented, including detailed descriptions of six core
courses. Fifteen university graduate programs in software
engineering are surveyed.


Version Description and Installation Guide
CMU/SEI-89-TR-20, ADA192292
Bamberger, J., Coddington, T., Firth, R., Klein, D., Stinchcomb, D., Van Scoy, R.

This document characterizes a specific version of the
Distributed Ada Real-Time Kernel (DARK) software artifact and
supplies documentation for its installation and use. This
document is geared toward: the engineer responsible for
installing the Kernel, engineers responsible for porting and
maintaining the Kernel, and engineers using the Kernel and
needing an awareness of changes from the previous release.


Kernel Architecture Manual
CMU/SEI-89-TR-19, ADA219295
Bamberger, J. 

This document contains the detailed design description of the
Kernel. he overall system architecture and the rationale for
it are presented as relevant to both the application (i.e.,
the external view of the Kernel) and the Kernel maintainer
(i.e., the internal view of the Kernel). This document
presents the algorithms and data structures needed to
implement the functionality defined in the Kernel Facilities
Definition. This document also contains an in-depth
description of the communication protocol used by the Kernel,
both the network software and hardware that compose the DARK
testbed at the SEI, and a detailed enumeration of all
compiler dependencies exploited by Kernel software. his
document is geared toward engineers responsible for porting
and maintaining the Kernel and engineers requiring detailed
information about the internals of the Kernel.


Real-Time Locking Protocol, A
CMU/SEI-89-TR-18, ADA211514
Sha, L., Ragunathan, R., Sang, S., Chun-Hyon, C.

When a database system is used in a real-time application,
the concurrency control protocol must satisfy not only the
consistency of shared data but also the timing constraints of
the application. In this paper, we examine a priority-driven
two-phase lock protocol called the read- or write-priority
ceiling protocol. We show that this protocol is free of
deadlock, and in addition a high-priority transaction can be
blocked by lower priority transactions for at most the
duration of a single embedded transaction. We then evaluate
system performance experimentally.


Adoption of Software Engineering Innovations in Organizations
CMU/SEI-89-TR-17, ADA211573
Bayer, J., Melone, N. 

Designing effective strategies to facilitate the adoption of
new software engineering technologies is a complex endeavor.
This document describes the experiences of organizations in
the defense industry that have considered and in many cases
adopted any one of five software engineering technologies:
structured programming, program design languages, software
cost models, complexity metrics, and Ada. In all, 296
respondents participated in the entire study. These
respondents represented approximately 120 business units
within approximately 75 defense contractor organizations.
Data were collected using a structured survey instrument
administered over the telephone.

This report examines the motivations behind technology
acquisition and adoption decisions, the use of various
technology transfer mechanisms during the stages of the
adoption process, and the relationship between technology
transfer mechanisms and the timing, pass through, and
smoothness of adoption process stages. Adoption is assumed to
be a multi-stage process that may proceed in a linear or
non-linear fashion. Also explored is the relationship between
managerial level of the advocate (i.e., top management,
middle management, technical management, and broad-based
support) and the speed and smoothness of technology
acquisition and adoption.

Analysis of data supports the notion that organizations and
change agents (e.g., the Department of Defense) should
carefully tailor transition mechanisms and the choice of
technology advocate to the specific stage of the adoption
process, rather than adopt a single strategy for the entire
process. Moreover, a single adoption strategy is not
applicable to all technologies. These strategies must also be
tailored depending on the subtleties of the particular
technology.


Guidelines for the Use of the SAME
CMU/SEI-89-TR-16, ADA228027
Graham, M. 

These guidelines describe the Structured Query Language (SQL)
Ada Module Extensions, or SAME, a method for the construction
of Ada applications that access database management systems
whose data manipulation language is SQL. As its name implies,
the SAME extends the module language defined in the ANSI SQL
standard to fit the needs of Ada. The defining characteristic
of the use of the module language is that the SQL statements
appear together, physically separated from the Ada
application, in an object called the module. The Ada
application accesses the module through procedure calls.

The primary audience for this document consists of
application developers and technicians creating Ada
applications for SQL database management systems. The
document contains a complete description of the SAME,
including its motivation.


Implementing Priority Inheritance Algorithms in an Ada Runtime System
CMU/SEI-89-TR-15, ADA209607
Borger, M., Ragunathan, R. (Carnegie Mellon University). 

This paper presents a high-level design-in the form of
necessary data structures, mechanisms, and algorithms-for
implementing the basic priority inheritance and priority
ceiling protocols in an Ada runtime system. Both of these
protocols solve the unbounded priority inversion problem,
where a high-priority task can be forced to wait for a lower
priority task for an arbitrary duration of time. The
protocols and their implementation also address the issues of
non-deterministic selection of open alternatives and FIFO
entry call queues. These protocols allow the timing analysis
of a given set of Ada tasks in order to guarantee their
deadlines in real-time systems. Importantly, it is possible
to implement the protocols within the current semantics of
the Ada language given the interpretations of Ada rules
described by Goodenough and Sha in the Software Engineering
Institute Technical Report CMU/SEI-88-TR-33.  Strategies and
possible alternatives are discussed for implementing these
protocols in an Ada runtime system targeted to a uniprocessor
execution environment.


Real-Time Scheduling Theory and Ada
CMU/SEI-89-TR-14, ADA211397
Sha, L., Goodenough, J. 

The Ada tasking model was intended to support the management
of concurrency in a priority-driven scheduling environment.
In this paper, we review some important results of a
priority-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. This paper is a revision of
CMU/SEI-88-TR-33. The most important revisions affect our
discussion of aperiodic tasks and our analysis of how to
support the priority ceiling protocol.  A shortened version
is also being presented at the 1989 Ada-Europe Conference.


Ada Adoption Handbook: Compiler Evaluation and Selection Version 1.0
CMU/SEI-89-TR-13, ADA207717
Weiderman, N. 

The evaluation and selection of an Ada compilation system for
a project is a complex and costly process. Failure to
thoroughly evaluate an Ada compilation system for a
particular user application will increase project risk and
may result in cost and schedule overruns.  The purpose of
this handbook is to convince the reader of the difficulty and
importance of evaluating an Ada compilation system (even when
there is no freedom of choice). The handbook describes the
dimensions along which a compilation system should be
evaluated, enumerates some of the criteria that should be
considered along each dimension, and provides guidance with
respect to a strategy for evaluation. The handbook does not
provide a cookbook for evaluation and selection. Nor does it
provide information on specific compilation systems or
compare different compilation systems. Rather it serves as a
reference document to inform users of the options available
when evaluating and selecting an Ada compilation system.


Model Solution for C3I Message Translation and Validation, A
CMU/SEI-89-TR-12, ADA219189
Plinta, C., Lee, K., Rissman, M.

This document describes an artifact, the Message Translation
and Validation (MTV) model solution. The MTV model solution
is a general solution, written in Ada, that can be used in a
system required to convert between different message
representations. These message representations can be
character-based, bit-based, and internal (i.e., Ada values).
This document provides designers with enough information to
determine whether this solution is applicable to their
particular problem. It gives detailed designers the
information needed to specify solutions to their particular
problem using the MTV model solution. Finally, it describes
the MTV model solution in enough detail to enable a
maintainer or adapter to understand the solution.


Scheduling Sporadic and Aperiodic Events in a Hard Real-Time System
CMU/SEI-89-TR-11, ADA211344
Sprunt, B., Sha, L. 

A real-time system consists of both aperiodic and periodic
tasks. Periodic tasks have regular arrival times and hard
deadlines. Aperiodic tasks have irregular arrival times and
either soft or hard deadlines. In this paper, we present a
new algorithm, the Sporadic Server algorithm, that greatly
improves response times for soft-deadline aperiodic tasks and
can guarantee hard deadlines for both periodic and aperiodic
tasks. The operation of the Sporadic Server algorithm, its
performance, and schedulability analysis are discussed and
compared with previous, published aperiodic service
algorithms.


Command, Control, Communications, and Intelligence Node: A Durra Application Example
CMU/SEI-89-TR-9, ADA206575
Barbacci, M., Doubleday, D., Weinstock, C.

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 (C#I) node using reusable components. The
experiment involves writing task descriptions and type
declarations for a subset of the TRW 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.


		-----end Part 2 (of 5) -----

Barbara Zayas			Software Engineering Institute
(bjz@sei.cmu.edu)		(412) 268-6378
===========================================================================
Co-moderator:  Richard Golding, Computer & Information Sciences, UC Santa Cruz
	    compdoc-techreports-request@ftp.cse.ucsc.edu