TRI-Ada 89 update -- tutorial descriptions (DRAFT) 
Author Message
 TRI-Ada 89 update -- tutorial descriptions (DRAFT)

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.

--------------------------------------------------      



Thu, 17 Dec 1992 11:24:00 GMT  
 
 [ 1 post ] 

 Relevant Pages 

1. TRI-Ada 89 update -- Conference program (DRAFT)

2. TRI-Ada 89 update -- overview (DRAFT)

3. TRI-Ada 89 update: Opening Plenary 2

4. TRI-Ada 89 update: Expected Keynote Speakers

5. TRI-Ada '91 (2of5) Conference Information - Tutorial Descriptions

6. final attendance figures from TRI-Ada 89

7. Directions to the Convention Center for TRI-Ada 89

8. HOTEL SHUTTLE SERVICE Information -- TRI-Ada 89

9. Special briefing at TRI-Ada '89

10. TRI-Ada 89: 4th track

11. vendor user group meetings at TRI-Ada 89

12. 4th track at TRI-Ada '89

 

 
Powered by phpBB® Forum Software