SEI Documents List
[2007] [2006] [2005] [2004] [2003] [2002] [2001] [2000] [1999] [1998] [1997] [1996] [1995] [1994] [1993] [1992] [1991] [1990] [1989] [1988] [1987] [1986] [PDF]
1989 Reports
Curriculum Modules and Support Materials
SEI-CM-14-2.1,
ADA236125
Intellectual Property Protection For Software
Samuelson, P. & Deasy, K.
This module provides an overview of the U.S. intellectual property laws that form the framework within which legal rights in software are created, allocated, and enforced. The primary forms of intellectual property protection that are likely to apply to software are copyright, patent, and trade secret laws, which are discussed with particular emphasis on the controversial issues arising in their application to software. Also included is a brief introduction to government software acquisition regulations, trademark, trade dress, and related unfair competition issues that may affect software engineering decisions, and to the Semiconductor Chip Protection Act.
http://www.sei.cmu.edu/publications/documents/cms/cm.014.html
SEI-CM-2-2,
ADA236118
Introduction to Software Design
Budgen, D.
This curriculum module provides an introduction to the principles and concepts relevant to the design of large programs and systems. It examines the role and context of the design activity as a form of problem-solving process, describes how this is supported by current design methods, and considers the strategies, strengths, limitations, and main domains of application of these methods.
http://www.sei.cmu.edu/publications/documents/cms/cm.002.html
SEI-CM-22-1.0,
ADA235701
Software Design Methods for Real-Time Systems
Gomaa, H.
This module describes the concepts and methods used in the software design of real-time systems. It outlines the characteristics of real-time systems, describes the role of software design in real-time system development, surveys and compares some software design methods for real-time systems, and outlines techniques for the verification and validation of real-time designs. For each design method treated, its emphasis, concepts on which it is based, steps used in its application, and an assessment of the method are provided.
http://www.sei.cmu.edu/publications/documents/cms/cm.022.html
SEI-CM-16-1.1,
ADA235-996
Software Development Using VDM
Storbank Pedersen, J.
This module introduces the Vienna Development Method (VDM) approach to software development. The method is oriented toward a formal model view of the software to be developed. The emphasis of the module is on formal specification and systematic development of programs using VDM. A major part of the module deals with the particular specification language (and abstraction mechanisms) used in VDM.
http://www.sei.cmu.edu/publications/documents/cms/cm.016.html
SEI-CM-21-1.0,
ADA237048
Software Project Management
Tomayko, J. & Hallman, H.
Software project management encompasses the knowledge, techniques, and tools necessary to manage the development of software products. This curriculum module discusses material that managers need to create a plan for software development, using effective estimation of size and effort, and to execute that plan with attention to productivity and quality. Within this context, topics such as risk management, alternative life-cycle models, development team organization, and management of technical people are also discussed.
http://www.sei.cmu.edu/publications/documents/cms/cm.021.html
SEI-CM-9-1.2,
ADA236119
Unit Testing and Analysis
Morell, L.
This module examines the techniques, assessment, and management of unit testing and analysis. Testing and analysis strategies are categorized according to whether their coverage goal is functional, structural, error-oriented, or a combination of these. Mastery of the material in this module allows the software engineer to define, conduct, and evaluate unit tests and analyses and to assess new techniques proposed in the literature.
http://www.sei.cmu.edu/publications/documents/cms/cm.009.html
SEI-CM-17-1.1,
ADA235699
User Interface Development
Perlman, G.
This module covers the issues, information sources, and methods used in the design, implementation, and evaluation of user interfaces, the parts of software systems designed to interact with people. User interface design draws on the experiences of designers, current trends in input/output technology, cognitive psychology, human factors (ergonomics) research, guidelines and standards, and on the feedback from evaluating working systems. User interface implementation applies modern software development techniques to building user interfaces. User interface evaluation can be based on empirical evaluation of working systems or on the predictive evaluation of system design specifications.
http://www.sei.cmu.edu/publications/documents/cms/cm.016.html
SEI-SM-3-1.0,
ADA236122
Support Materials for The Software Technical Review Process
Cross, J., ed.
This support materials package includes materials helpful in teaching a course on the software technical review process.
http://www.sei.cmu.edu/publications/documents/cms/sm.003.html
Educational Materials
CMU/SEI-89-EM-002,
ADA235777
APSE Interactive Monitor: A Software Artifact for Software Engineering Education
Engle, C.; Ford, G.; & Tomayko, J.
In 1987 the SEI began a search for a well-documented ADA system, developed under government contract, that could be used in software engineering education. The APSE Interactive Monitor (AIM) was determined to be appropriate for this purpose. This system acts as an interface between a user of an ADA programming support environment (APSE) and the programs that the user executes in the APSE. It provides facilities to support the concurrent execution of multiple interactive programs, each of which has access to a virtual terminal. Educational uses of the system are described, including use as a case study and as the basis for exercises. Software engineering topics that can be taught with the system include software maintenance, configuration management, software documentation, cost estimation, and object-oriented design.
http://www.sei.cmu.edu/publications/documents/ems/89.em.002.html
CMU/SEI-89-EM-001,
ADA235779
Software Maintenance Exercises for a Software Engineering Project Course
Engle, C.; Ford, G.; & Korson, T.
This report provides an operational software system of 10,000 lines of ADA and several exercises based on that system. Concepts such as configuration management, regression testing, code reviews, and stepwise abstraction can be taught with these exercises.
http://www.sei.cmu.edu/publications/documents/ems/89.em.001.html
Special Reports
CMU/SEI-89-SR-014,
ADA250349
Conformance Criteria for the SAME Approach to Binding ADA Programs to SQL
Moore, J.
The structured query language (SQL), ADA Module Extensions (SAME) form a method for the design and construction of ADA database applications. The method is explained in a companion document: Guidelines for the Use of the SAME. In order to enable the method to be referenced in requests for proposals (RFPs) and development contracts, there must be some method to determine if a given software design and implementation conform to the SAME guidelines. Such conformance criteria are contained in this report.
http://www.sei.cmu.edu/publications/documents/89.reports/89.sr.014.html
CMU/SEI-89-SR-018,
ADA275239
Recommendations from the AIA/SEI Workshop on Research Advances Required for Real-Time Software Systems in the 1990s
Sweet, W.; Gagliardi, M.; Klein, M.; Little, R.; Van Scoy, R.; Veltre, R.; & Weinstock,
C.
The Aerospace Industries Association (AIA) and the Software Engineering Institute sponsored a workshop to facilitate clear communication between the implementors of future software-critical large systems and the professionals who sponsor or perform software-related research. The workshop was held at the SEI in Pittsburgh, Pennsylvania, on September 13-14, 1989. At the workshop, a representative group of designers of major upcoming software systems discussed among themselves and with representatives of the research community the areas of software system technology that require research advances to successfully implement these systems. The results of the discussions are summarized in this report.
CMU/SEI-89-SR-005,
ADA253172
SAME Standard Package Installation Guide
Graham, M.
This document outlines the procedures for installing the SQL ADA Module Extensions (SAME) standard packages. It assumes that the source of these packages has been off-loaded from the distribution medium to a machine with the desired ADA compiler.
http://www.sei.cmu.edu/publications/documents/89.reports/89.sr.005.html
Technical Reports
CMU/SEI-89-TR-013,
ADA207717
ADA Adoption Handbook: Compiler Evaluation and Selection Version 1.0
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.013.html
CMU/SEI-89-TR-017,
ADA211573
Adoption of Software Engineering Innovations in Organizations
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.017.html
CMU/SEI-89-TR-026,
ADA219066
CASE Planning and the Software Process
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.026.html
CMU/SEI-89-TR-025,
ADA226696
Classifying Software Design Methods
Wood, W. & Long, J.
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.025.html
CMU/SEI-89-TR-009,
ADA206575
Command, Control, Communications, and Intelligence Node: A Durra Application Example
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 (C3I) node using reusable components. The experiment involves writing task descriptions and type declarations for a subset of the TRW testbed, a collection of C3I 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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.009.html
CMU/SEI-89-TR-036,
ADA219187
Comparative Evaluations of Four Specification Methods for Real-Time Systems
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.036.html
CMU/SEI-89-TR-007,
ADA219065
Conducting SEI-Assisted Software Process Assessments
Olson, T.; Humphrey, W.; & Kitson, D.
This report describes software process assessment as it is performed in organizations with the assistance of the Software Engineering Institute. 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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.007.html
CMU/SEI-89-TR-040,
ADA228034
Dark Porting and Extension Guide Kernel Version 3.0
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.040.html
CMU/SEI-89-TR-032,
ADA219290
Durra Application Debugger/Monitor, The
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.032.html
CMU/SEI-89-TR-034,
ADA219293
Durra: A Task-Level Description Language Reference Manual
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.034.html
CMU/SEI-89-TR-033,
ADA223761
Durra: A Task-Level Description Language User's Manual
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.033.html
CMU/SEI-89-TR-016,
ADA228027
Guidelines for the Use of the SAME
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.016.html
CMU/SEI-89-TR-023,
ADA219326
Hartstone: Synthetic Benchmark Requirements for Hard Real-Time Applications
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.023.html
CMU/SEI-89-TR-004,
ADA206574
Human-Machine Interaction Considerations for Interactive Software
Bass, L. & Coutaz, J.
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.004.html
CMU/SEI-89-TR-015,
ADA209607
Implementing Priority Inheritance Algorithms in an ADA Runtime System
Borger, M. & Ragunathan, R.
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 33 (1988). Strategies and possible alternatives are discussed for implementing these protocols in an ADA runtime system targeted to a uniprocessor execution environment.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.015.html
CMU/SEI-89-TR-038,
ADA223762
Inertial Navigation System Simulator Program: Top-Level Design
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, a schedulability analysis of the INS is described within the framework of the task set developed in this top- level design.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.038.html
CMU/SEI-89-TR-035,
ADA219294
Inertial Navigation System Simulator: Behavioral Specification
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.035.html
CMU/SEI-89-TR-019,
ADA219295
Kernel Architecture Manual
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.019.html
CMU/SEI-89-TR-012,
ADA219189
Model Solution for C3I Message Translation and Validation, A
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.012.html
CMU/SEI-89-TR-005,
ADA219190
Object-Oriented Solution Example: A Flight Simulator Electrical System, An
Lee, K. & Rissman, M.
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.005.html
CMU/SEI-89-TR-008,
ADA207415
Performance and Reliability Enhancement of the Durra Runtime Environment
Weinstock, C.
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.008.html
CMU/SEI-89-TR-006,
ADA206779
Proceedings of the Workshop on Executive Software Issues August 2-3 and November 18, 1988
Martin, D.; Carey, S.; Coticchia, M.; Fowler, P.; & Maher, J.
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.006.html
CMU/SEI-89-TR-018,
ADA211514
Real-Time Locking Protocol, A
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.018.html
CMU/SEI-89-TR-014,
ADA211397
Real-Time Scheduling Theory and ADA
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-033. 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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.014.html
CMU/SEI-89-TR-022,
ADA219020
Real-Time Software Engineering in ADA: Observations and Guidelines
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.022.html
CMU/SEI-89-TR-003,
ADA227426
Role of Assessment in Software Process Improvement, The
Kitson, D. & Humphrey, W.
This report discusses the role of assessment in improving an organization's software capabilities; specifically, the ability of the organization's projects to consistently meet cost, schedule, and quality objectives. Software process assessments are described from both a conceptual and pragmatic point of view. Underlying concepts of software process, software process management, and software process maturity are discussed. Collectively, these constitute a framework for software process assessment and improvement.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.003.html
CMU/SEI-89-TR-011,
ADA211344
Scheduling Sporadic and Aperiodic Events in a Hard Real-Time System
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.011.html
CMU/SEI-89-TR-021,
ADA219018
SEI Report on Graduate Software Engineering Education, 1989
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.021.html
CMU/SEI-89-TR-002,
ADA211636
Software Process Modeling: Principles of Entity Process Models
Humphrey, W. & Kellner, M.
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.002.html
CMU/SEI-89-TR-001,
ADA206573
State of Software Engineering Practice: A Preliminary Report, The
Humphrey, W.; Kitson, D.; & Kasse, T.
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.001.html
CMU/SEI-89-TR-024,
ADA219019
Temporal Logic Case Study
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.024.html
CMU/SEI-89-TR-028,
ADA219188
Understanding the Adoption of ADA: A Field Study Report
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.028.html
CMU/SEI-89-TR-020,
ADA192292
Version Description and Installation Guide
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.020.html
CMU/SEI-89-TR-030,
ADA219064
What a Software Engineer Needs to Know: I. Program Vocabulary
Shaw, M.; Giuse, D.; & Reddy, R.
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.
http://www.sei.cmu.edu/publications/documents/89.reports/89.tr.030.html
[2007] [2006] [2005] [2004] [2003] [2002] [2001] [2000] [1999] [1998] [1997] [1996] [1995] [1994] [1993] [1992] [1991] [1990] [1989] [1988] [1987] [1986] [PDF]