jtf@sei.cmu.edu (John Foreman) (09/20/89)
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.
--
John Foreman jtf@sei.cmu.edu
Software Engineering Institute (412) 268-6417
Pittsburg, pa