leff@CSVAX.SEAS.SMU.EDU (Laurence Leff) (07/11/90)
Software Engineering Institute Information Management Annotated list of available documents for external distribution. Part III of VI 1 January 1986 - 29 June 1990 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-89-TR-20, ADA192292 Bamberger, J. et al Version Description and Installation Guide 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 Kernel and needing an awareness of changes from the previous release. CMU/SEI-89-TR-21, ADA219018 Ardis, M. and Ford, G. 1989 SEI Report on Graduate Software Engineering Education 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. CMU/SEI-89-TR-22, ADA219020 Borger, M. and Klein, M., Real-Time Software Engineering in Ada: Observations and Guidelines 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. CMU/SEI-89-TR-23, ADA219326 Weiderman, N. Hartstone: Synthetic Benchmark Requirements for Hard Real-Time Applications 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. CMU/SEI-89-TR-24, ADA219019 Wood, W. Temporal Logic Case Study 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. CMU/SEI-89-TR-25, ADA211573 Wood, W. Classifying Software Design Methods 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. CMU/SEI-89-TR-26, ADA219066 Humphrey, W. CASE Planning and the Software Process 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. CMU/SEI-89-TR-28, ADA219188 Smith, G. et al Understanding the Adoption of Ada: A Field Study Report In 1983, the U.S. Department of Defense (DoD) established a policy requiring the use of Ada 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. CMU/SEI-89-TR-30, ADA219064 Shaw, M. et al What a Software Engineer Needs to Know: I. Program Vocabulary 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. CMU/SEI-89-TR-32, ADA192290 Doubleday, D. The Durra Application Debugger/Monitor 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. CMU/SEI-89-TR-33 Barbacci, M. et al Durra: A Task-Level Description Language User's Manual Durra is a language designed to support the development of large-grained parallel programming applications. This is 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. CMU/SEI-89-TR-34, ADA219293 Barbacci, M. and Wing, J. Durra: A Task-Level Description Language Reference Manual Durra is a language designed to support the development of large-grained parallel programming applications. These applications are often computation-int ensive, 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. CMU/SEI-89-TR-35, ADA219294 Landherr, S. et al Inertial Navigation System Simulator: Behavioral Specification 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. CMU/SEI-89-TR-36, ADA219187 Wood, D. and Wood, W. Comparative Evaluations of Four Specification Methods for Real-Time Systems 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. CMU/SEI-89-TR-38 Fowler, K. Inertial Navigation System Simulator Program: Top-Level Design 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. CMU/SEI-89-TR-40, ADA219291 Bamberger, J. et al Dark Porting and Extension Guide Kernel Version 3.0 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. --