SIGAda 2002

Sunday Full-Day Tutorials (9:00am - 5:30pm)

SF1: Introduction to Ada and Ada 95
David A. Cook, Leslie Dupaix, and Eugene Bingue

This tutorial is designed for those who have some familiarity with a programming language, but who are new to Ada. In the morning, we will discuss the basics of programming in Ada, to include typing, packages, syntax rules, and other Ada programming constructs. In the afternoon, we will cover the concepts of object-oriented programming, and show how object-oriented design can easily be implemented using Ada. Simple Ada programs will be constructed during the class, and the attendees will also see how to use various Ada programming environments and tools that can be downloaded for free over the web.

SF2: CORBA for Embedded Systems
S. Ron Oliver

The Tutorial will begin with an overview of CORBA. The attendee need have no prior knowledge of CORBA. The session will also include a brief introduction to Distributed Computing, in general, including fundamentals of Concurrent and Real Time systems, and of Computer Networks. Thus, the attendee need not be highly experienced in these subjects. However, treatment of this introductory background material will necessarily be limited, so some familiarity with it will be useful. The morning session and about half the afternoon session will include discussions of the CORBA Principles, Interface Definition Language (IDL), Client programs, Object (server) programs, and CORBAServices. The afternoon session will end with a discussion of more advanced features of CORBA 3, including minimumCORBA and Real Time CORBA. These topics will be of particular interest to those who might wish to use CORBA for Embedded Systems. It will begin with a brief introduction to Embedded Systems and an overview of advanced CORBA features that could not be covered in the morning session. All examples for the tutorial will be based on the highly successful TopGraph'X product, ORBAda, and the Ada95 programming language.

SF3: Introduction to the Common Criteria for Information Technology Security Evaluation (CC) and the Underlying Concepts of Trust in Computer Systems
Michael McEvilley

The Common Criteria (CC) is an international standard (ISO 15408) that is used to articulate the requirements for the development and verification of the security capabilities in products and systems. The articulation of security requirements is accomplished by employing the requirements specification framework defined by the CC to create security specifications. These specifications, referred to as the Protection Profile (PP) and Security Target (ST), express security requirements based upon the functional and assurance criteria catalogs also defined by the CC.

The CC and its accompanying Common Evaluation Methodology form the technical basis for an international cooperative program whereby participants agree to trust the results of independently conducted product security evaluations.

This tutorial will present a technical introduction to the Common Criteria with focus on the principles of establishing trust through disciplined, structured and rigorous software engineering and verification activities. Discussion of the overlap between security and safety principles and the application of the CC by the Ada community will be included.

Monday Full-Day Tutorials (8:30am - 5:00pm)

MF1: SPARK, an "Intensive Overview"
Rod Chapman

SPARK is an annotated sub-language of Ada which is unambiguous and suitable for rigorous static analysis. The tutorial will cover: the rationale of SPARK; the core language and annotations; data-and information-flow analysis, SPARK program design; and verification techniques such as proof of partial correctness and freedom from exceptions. The tutorial is intended primarily for those with current or recent experience of software development in Ada, especially those who will work on or lead safety critical or other high integrity developments, although detailed knowledge of Ada is not a prerequisite.

Attendees will be encouraged to bring laptop computers on which the SPARK Examiner will be installed and used for practical exercises.

Monday Morning Tutorials (9am - 12:30pm)

MA1: Introduction to Tasking
Les Dupaix and Eugene Bingue

In most languages, writing potentially parallel code is very difficult - hard to implement and hard to test. Tasking, a construct of Ada, allows developers to design and code parallelism with great ease. This tutorial is targeted at developers who want to understand how Ada tasking works, and see how to build Ada tasks. Knowledge of basic Ada syntax is all that is required. There will be multiple examples of Ada code showing how to correctly design and code Ada tasks. This tutorial is designed for those who wish an introductory tutorial on Ada tasking.

MA2: Implementing Design Patterns in Ada 95
Matthew Heaney

A design pattern is a description of how a group of objects collaborate to solve a general problem in a specific context. Although Ada is a feature-rich language, it is sometimes not obvious how to actually implement many design patterns, and knowledge of certain advanced language features is often necessary. Accordingly, I present several idioms for object-oriented programming in Ada95, including using controlled types and smart pointers to perform memory management, and for using access discriminants to implement Java-style interfaces.

Monday Afternoon Tutorials (1:30 - 5:30pm)

MP1: Exceptions (What You Always Wanted to Know About Exceptions, But Were Afraid To Ask)
Currie Colket

Exception processing was considered by Jean Ichbiah to be one of the 3 most important features of the Ada language. It has the power to detect serious problems in the execution of a program and return one back to a known safe state with high integrity. As such, it can be a very powerful tool for developing high quality software. Unfortunately many developers do not use the full power of exceptions. Frequently the use of exceptions is to simply log the problem and continue execution, allowing things to gracefully degrade. In the case of Ariane 5, exceptions were raised appropriately, but the result had not been well thought out, resulting in a disaster.

This tutorial will start at the basics, discussing the Ada 83 concept of exceptions. To be effective, exceptions and their handling must be addressed at the design level and not at the code level where it is frequently performed today. This presentation will discuss several alternative approaches to addressing error handling in the design using exceptions. Ada 95 introduced some important changes to the exception area making them more effective. In particular, the addition of package Ada.Exceptions provides excellent facilities to support debugging and provides a mechanism to eliminate erroneous mapping of raised exceptions.

MP2: Embedded / Real-Time Ada95
Pat Rogers

This advanced tutorial focuses on two major requirements for real-time systems: storage management and time management. We examine the potential pitfalls associated with Ada's storage facilities and explore in detail how to write predictable user-defined storage managers that are seamlessly integrated with the language. We then explore how to use offline schedulability analysis and predictable tasking to ensure application timing behaviour. This part forms the bulk of the tutorial. The required analysis theory -- explained in concrete terms and examples -- is covered to a sufficient detail (fear not!) so that the Ada Real-Time Systems Annex, covered in the last part of the tutorial, will be abundantly clear.

Back to Main Page
updated 8 October 2002 - cgr