From mboxrd@z Thu Jan 1 00:00:00 1970 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me X-Spam-Level: X-Spam-Status: No, score=-0.8 required=5.0 tests=BAYES_00,INVALID_DATE autolearn=no autolearn_force=no version=3.4.4 Path: utzoo!utgpu!jarvis.csri.toronto.edu!mailrus!tut.cis.ohio-state.edu!ucbvax!SEI.CMU.EDU!jtf From: jtf@SEI.CMU.EDU (John Foreman) Newsgroups: comp.lang.ada Subject: TRI-Ada 89 update -- tutorial descriptions (DRAFT) Message-ID: <8907301124.AA23649@cf.sei.cmu.edu> Date: 30 Jul 89 11:24:40 GMT Sender: daemon@ucbvax.BERKELEY.EDU Organization: The Internet List-Id: TRI-Ada has 4 full day tutorials and 4 half day tutorials. Selection of 2 half day tutorials is the equivalent of a full day tutorial. All tutorials are on Monday, 23 October. Full day tutorials are: 1. Introduction to Ada 2. An Analytical Approach to Real-Time Systems Design in Ada 3. Software Inspections 4. Software Development Technologies (a 3 part tutorial, consisting of 3 2-hour sessions) Half day tutorials are: (pick one "a" and one "b" 5a. Designing for Reuse 5b. Numerical programming in Ada 6a. Compiler Validation: Policy and Issues 6b. Compiler Evaluation and Selection Detailed Abstracts follow: ----------------------------------- Tutorial 1: Introduction to Ada Topics to be covered: * Ada's Support for Software Engineering * Exceptions * Ada Program Units * Generics * Types * Tasks * Control Statements Who should attend: Anyone, with little to no knowledge of Ada, having a genuine interest in learning the primary constructs of the language. Program managers and software engineers with experience in other high order languages should find this discussion helpful in their evaluation of Ada's support for software engineering. Prerequisites: Knowledge of a high order programming language Presenter(s): Captain Roger D. Beauman, USAF Captain Michael S. Simpson, USAF ------------------------------------------------------------------ Tutorial 2: An Analytical Approach to Real-Time Systems Design in Ada Presenter(s): John B. Goodenough, Lui Sha, Mark H. Klein, and Mark W. Borger, Software Engineering Institute Thomas Ralya, IBM Robert K. Page, Naval Weapons Center Abstract: This tutorial will cover the use of rate monotonic scheduling theory for developing hard real-time systems using Ada tasks. We will present Ada tasking paradigms for dealing with a mixture of periodic and aperiodic requirements. We will also present an overview of the theoretical aspects of rate monotonic scheduling. Illustrative examples will be drawn from case studies. No prior knowledge of rate monotonic theory will be assumed. At the end of the tutorial, attendees will understand the advantages and limitations of the theory and will understand how it can be used with validated Ada compilers. ----------------------------------------------- Tutorial 3: SOFTWARE INSPECTIONS Presenter(s): Don O'Neill, Software Engineering Institute Software Inspections can be used to set the standard of excellence for software engineered products in the organization. Furthermore, they can discipline the operation of the organization in meeting the standards set. An important objective in software inspections is to promote completeness and correctness in the product, but software inspections are more than a hunt for errors. They also promote adherence to project style and rules of construction, compliance with the technology practices of the organization, examination of the product from the user's viewpoint as well as the producer's, and the systematic collection of process and product metrics data. This session provides a tutorial on software inspection methodology. There are several components to the methodology for software inspections: a structured review process integrated with the life cycle activities, defined roles of participants featuring a moderator and other participants, a system of checklists governing the review of the product as well as the structured review process itself, and forms and reports providing consistency in building a process management data base. The Software Inspections tutorial equips attendees with the knowledge they need to organize, conduct, and report on rigorous software inspections, including how to fulfill the roles of moderator, producer, reviewer, recorder, and reader. ---------------------------------------------------- Tutorial 4: SOFTWARE DEVELOPMENT TECHNOLOGIES (3-part tutorial, consisting of 3 2-hour sessions) Part 1: Software First Life Cycle (Jim Moore, IBM) The traditional "Waterfall" life cycle is the result of years of evolution and improvement in the art of managing the development of software systems to improve the probability of meeting requirements while remaining within planned schedule and budget. Nevertheless, very large software systems continue to encounter difficulty in meeting their functional and resource objectives. There is reason to believe that many of the remaining difficulties are inherent in the waterfall life-cycle itself and can be addressed only by creating innovative alternative approaches to the management of the software life cycle. The DARPA STARS (Software Technology for Adaptable, Reliable Systems) Program is experimenting with a "Software-First" Life Cycle which exploits new technologies for machine-independent software and software component reuse. The Software-First Life Cycle is characterized by delaying the freezing of requirements and the selection of hardware to the latest possible point in the life cycle. This tutorial will explore critical issues in the definition of a usable Software-First Life Cycle. ------------------------------------------------- Part 2 : Ada Knowledgeable Tools (Rowan Maclaren, Compass) A programming environment provides an interface to a collection of tools and a framework within which the tools operate, thus encouraging a particular approach to software problems. Tools in a programming environment for Ada can use knowledge of Ada to provide considerable support for a variety of tasks. In this section of the tutorial, we will examine the role of such language-knowledgeable tools in an environment. We will also examine environment construction techniques used to construct Ada programming support tools. We will describe Ada tool prototypes in two research projects: the DAPSE (Distributed Ada Programming Support Environment) research project and the DIANA (Descriptive Intermediate Attributed Notation for Ada) Tools Suite Investigation, a STARS (Software Technology for Adaptable Reliable Systems) task. These language tool prototypes were all built, either in whole or in part, by using tool generators. Generator technology is widely recognized as an efficient and reliable approach to building language-knowledgeable tools. Generators can be used when an application domain is understood well enough to isolate the language-dependent portions from the language-independent portions. The input to a generator specifies the language and specifies the relation between the language and the application. We will examine an example of generator technology that is particularly supportive of Ada. Our approach is to allow multiple views of the same data, namely the program units in the Ada library, depending on the context of the user's task. While the Ada text of an individual compilation unit is the most common way to view an Ada program, a software engineer may benefit from other ways of visualizing an Ada program or aspects of an Ada program. The inputs to this generator are a specification of Ada, a specification of a visualization of Ada, and a mapping from one to the other. This technology could be used to relate Ada programs to documentation systems, to provide a view of the Ada program library, and to provide a notation for specifying the distribution configuration of an Ada program. ------------------------------------------------- Part 3: Domain-Specific Technology (Jim Solderitsch, Unisys) Each application domain is different -- characterized by its own specific set of circumstances, requirements and constraints. Yet, different application domains have much in common -- algorithms, data structures and interfaces. Significant productivity enhancements in system design and implementation can be achieved through technology that can represent, and make available, information that captures both the uniqueness and sameness of individual domains. Software domains that possess a high degree of cohesiveness and controlled variability can be served by a software generation approach. New application software can be generated from high-level specifications written in specially constructed domain-specific languages. Software domains which are less amenable to software generation can be supported through a "knowledge base" that captures important facets and processes that characterize software systems previously developed for the domain. This tutorial will present how these two forms of domain-specific support can enrich the software production process and will illustrate the advantages of a domain-specific approach by describing two specific forms of this technology. -------------------------------------------------- ** HALF Day tutorials ** -------------------------------------------------- Tutorial 5a: Designing for reuse: Is Ada class-conscious? Presenter(s): Sholom Cohen, Software Engineering Institute The expressive power of Ada can have a significant effect on the success of software reuse. This is being proven in the area of abstract data types and in reusable interfaces for domain independent subsystems, such as user interfaces and data base management systems. Ada's standardization, its level of portability, and the generic facility have all contributed to the success in these areas, and are essential ingredients in many commercial products. When applied to more complex abstractions, especially in domain specific areas, reuse in general and generics in particular pose more serious design problems. This type of reusable software has been termed "intermediate" in a study by Ripken and Levy of Rational, and it is the design of this type of reusable software - complex and domain-specific - that is the focus of this tutorial. The first half of the tutorial will examine techniques for designing complex, domain-specific reusable software, and will explore the application of object-oriented programming concepts to the task. While the concepts of "class" and "inheritance" are not part of the Ada language, this tutorial takes the position that these properties of object-oriented programming are relevant in establishing design methods for Ada. The second half of this tutorial will consist of a panel, briefly presenting similar approaches for designing reusable software. This tutorial is not intended as a style guide for developing software that has "high reusability" as a design criteria. It is a technical discussion of design and language issues for constructing complex, domain specific reusable software. It assumes a strong background in Ada development concepts, especially generics. Some knowledge of the concepts of object-oriented programming is also recommended. ----------------------------------------------------------- Tutorial 5b: Numerical Programming in Ada Presenter(s): DR. P.T.P. Tang, Argonne National Laboratory JON S. SQUIRE, Numerics Rapporteur Group ISO/IEC/JTC1/SC22/WG9 This tutorial will cover Numerical Programming in Ada. Ada allows more control over accurate numerical results than other languages. Both theoretical and practical examples will be presented. Interesting uses of Ada generics will show how to write portable, accurate numerical packages that work over a wide range of precisions. Hard copy of the lecture notes and a PC diskette will be provided to each participant. ---------------------------------------------------------------- Tutorial 6a: Compiler validation: policy and issues Presenter(s): Mike Ryer, Intermetrics The tutorial will examime the fundamentals and process of Ada compiler validation, and then discuss the real-world implications to program managers developing embedded systems, in light of the new validation policy (version 2.0, May 89). -------------------------------------------------------------------- Tutorial 6b: Compiler Evaluation and Selection Presenter(s): Nelson Weiderman, Software Engineering Institute 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 tutorial is to reveal both the importance and difficulty of Ada compiler evaluation. The tutorial describes the state of the practice for evaluating Ada systems and gives an overview of the existing technology for evaluation. Among the specific topics to be included are a clarification of the differences between validation and evaluation; the necessary steps in a selection process; a summary of the evaluation issues for an Ada compiler including time and space issues at compile time, link time, and run time; benchmarking issues and overviews of three major test suites that are currently available; support tool issues including the program library system, linker/loader support, and support for debugging; special needs and benchmarks for real-time applications; and guidance on sources of information for evaluation and selection of Ada compilation systems. --------------------------------------------------