Sunday Full-Day Tutorials (9:00am - 5:30pm)
SF1: Real-Time Java for Ada Programmers
Level -- Intermediate. Audience should be familiar with Ada and have a basic knowledge of Java
Although the term “real-time Java” may sound self-contradictory, serious technical activity has been underway since early 1999 on extending the Java platform to satisfy the requirements for real-time systems, and several implementations exist. This work is relevant to the Ada community as both a challenge and an opportunity: on the one hand, it may compete with Ada in the real-time marketplace, but on the other hand some of its ideas may be worthy of consideration in a future version of the Ada language.
This tutorial will focus on the Real-Time Specification for Java (“RTSJ”), which was developed by the Real-Time for Java Expert Group under the auspices of Sun Microsystems’ Java Community Process. The tutorial will analyze/critique the Java platform with respect to real-time support, summarize/illustrate the main elements of the RTSJ, and compare/contrast the design with Ada’s real-time features. The tutorial will also outline the main aspects of the J-Consortium’s “Core Extensions” (a competing real-time Java approach), will summarize a proposed high-integrity profile for the RTSJ, and will provide a status update on the real-time Java work and its usage and prospects.
SF2: An Introduction to Ada for programmers
Eugene W.P. Bingue, David A. Cook, Les Dupaix
Level --Beginner, but attendees should have some experience with a high-level programming language.
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.
Sunday Morning Tutorials (9:00am - 12:30pm)
SA1: SPARK: A Safer Way to Program
The general goal of SPARK is to provide a language which increases the likelihood of the program behaving as intended. That is to reduce to an acceptable level the risks of disaster arising as a result of any residual error in the program. This tutorial will provide an intense summary of the key features of SPARK that facilitate the development of high-integrity software that satisfies the requirements of rigorous standards such as DO-178B Level A, EAL Level 4+, etc.
This tutorial is designed for students who are very familiar with Ada and understand the key concerns associated with developing software for safety-critical and secure domains.
Sunday Afternoon Tutorials (2:00 - 5:30pm)
SP1: A#: Programming PDAs and .NET devices with Ada
Martin C. Carlisle
Level -- Intermediate.
Attendees should be familiar with Ada 95. Preferable to have a basic knowledge of C# or Java.
This tutorial describes A#, an Ada environment for programming the Windows .NET and .NET Compact Frameworks. Attendees will learn how to create Ada applications that take advantage of the rich set of libraries available with the .NET Framework, and also how to deploy Ada applications onto PDAs using the .NET Compact Framework.
Attendees will also learn how to create multilanguage applications combining both C# and Ada. In particular, attendees will learn how to create a user-interface with Visual Studio .NET, and use Ada for the computation behind this interface.
This tutorial will be very hands-on. Attendees should bring laptop computers on which A# will be installed.
Monday Full-Day Tutorials (9:00am - 5:30pm)
MF1: Best Practices for Software Quality Specification, Testing and Certification of COTS and Bespoken Systems
Level -- Intermediate. Basic knowledge in mathematics and some knowledge of software methods and tools are required.
The seminar will cover the principles and the normative quality characteristics as well as the standardized procedures of information quality assurance resp. software system quality assurance (comprising V&V, test, measurement and assessment) for procedural, object-oriented and agent-based dependable software systems.
Attendees will exercise proven techniques for goal-directed measurement, scaling and assessment for software certification. Assessment of both the software product as well as the software process will be discussed with respect to its relevance for such acceptance assessments. A standardized process model for measurement, assessment and certification of dependable software will be used to make the attendees familiar with this comprehensive assessment procedure and to learn how to embed it into today’s standardized or non-standardized software processes.
Emphasis will be given to selected advanced topics depending on the needs of participants.
Monday Morning Tutorials (9:00am - 12:30pm)
MA1: SAE Architecture Analysis and Design Language (AADL)
Level - Intermediate.
The Architecture Analysis and Design Language (AADL) is an architecture description language (ADL) that has been developed under the auspices of the International Society of Automotive Engineers (SAE), Avionics Systems Division (ASD) Embedded Computing Systems Committee (AS-2). The AADL was approved as an SAE standard in November of 2004. In 2005, the SAE AADL standard was extended with the approval of four annexes: Graphical AADL Notation, AADL Meta Model and Interchange Formats, Language Compliance and Application Program Interface, and the Error Model. Recently, a Behavior Annex has been published for use with the AADL models.
The AADL language has been defined to provide a consistent and concise notation, both textual and graphical, to be used to develop models of complex, real-time, critical systems such as those used in automotive, avionics, medical, robotic, and space-based systems. The AADL provides the notation to perform various types of analysis of the complex critical systems.
In the early stages of design, the AADL enables the definition of the preliminary connectivity between application and execution platform components. As an AADL model is developed, additional components and properties are specified. The properties provide the information needed by analysis tools to determine the behavior and performance of the system being modeled. The AADL has been designed to facilitate the development of tools that provide automatic code generation of the system both in terms of the application software components and the underlying execution environment. The AADL may be used to verify an actual system against the specified model. With automatic code generation, the AADL offers a system model that maintains significant information about a system that is useful throughout the lifetime of the system. Thus, the AADL offers support for all stages of system development.
This tutorial will provide an introduction to the AADL language from a textual and graphical perspective. It will also give some guidelines regarding the relationship between existing systems and the generation of AADL models. The tutorial will present a mapping between programming languages such as C and Ada and the AADL. Several uses of the AADL in the design and analysis of safety-critical real-time systems will be demonstrated. The tutorial will close with a short summary of AADL tools will be provided in this tutorial.
This tutorial is suitable for senior software and systems engineers as an introductory course; the tutorial does not presume prior knowledge of AADL. The course is also useful to software and systems managers responsible for the development and integration of complex critical systems. The attendees should have an understanding of the fundamentals of the development of complex, critical real-time systems.
Attendees may learn more about AADL at
MA2: New Features of Ada 2005
Martin C. Carlisle
Level -- Intermediate.
Ada 2005 adds a lot of new features to Ada that enhance its safety, readability, and expressiveness. In particular, significant enhancements have been made to access types, object-oriented programming, real-time programming, exception handling and the predefined library. This is a hands-on tutorial where participants will have the opportunity to experiment with new Ada 2005 features. To maximize the experience, participants should bring a laptop computer with an Ada 2005 environment (e.g. AdaGIDE and GNAT --
http://adagide.martincarlisle.com). Prior experience with Ada is assumed.
Monday Afternoon Tutorials (2:00 - 5:30pm)
MP1: The Ada 2005 Standard Container Library
Level -- Intermediate.
The Ada 2005 standard container library comprises sequence containers (vectors and doubly-linked lists) for inserting elements at specified positions, and associative containers (sets and maps) which position elements in order by key. The library is general, flexible, and efficient, and elegantly solves many common programming problems.
Attendees should have a modest experience with Ada programming. This tutorial will familiarize attendees with the new standard container library (described in AI-302).
This tutorial provides an overview of the standard container library, describing its design and philosophy and presenting techniques for using the library most effectively. Containers are divided into two main categories: sequence containers, to insert elements at specified positions, and associative containers, which insert elements in order by key. The library includes vectors and lists (from the former category), and hashed and sorted sets and maps (from the latter). All containers have variants to support elements (or keys) that have an indefinite subtype. Containers have various mechanisms (including both active and passive iterators) for designating and accessing container elements.
Why should you attend the tutorial? The standard container library is an important addition to the Ada language, since developers need data structures with semantics more sophisticated than simple arrays or linked lists. For example, one often needs to map an element to some other type (typically String), but an array is not general enough since it only provides support for mapping to a discrete index subtype. The developer also needs abstractions that scale well to large numbers of elements, with specified time behavior. The standard container library solves these kinds of problems, and thus greatly simplifies many programming tasks that would be tedious or just very difficult otherwise. You should attend this tutorial to learn about the standard container library, what features it provides, and how it solves typical programming problems.
The course outline is:
- general library design and philosophy
- design goals such as flexibility, efficiency, and safety
- composable primitives for assembling more complex abstractions
- time complexity: each container is optimized differently
- static vs. dynamic polymorphism
- active vs. passive iterators; container machine model
- mechanisms for accessing elements (both constant and variable views)
- vectors: random-access; optimized for insertion at back end
- doubly-linked lists: insertion is O(1) at all positions
- sets: element value determines its position
- sets.generic_keys: for key-based manipulation of set elements
- maps: key associated with element determines its position
- ordered ("strict weak ordering") vs. hashed
- conditional insertion: to combine find with insert
- operations and techniques for optimizing insertions
MP2: Real-time and Parallel Processing in Ada
Eugene W.P. Bingue, David A. Cook, Les Dupaix
Level -- Intermediate. This tutorial assumes basic knowledge or experience with the Ada programming language.
This tutorial covers two of the major problems with parallel and real-time programming - time management and storage management. Parallel processing, whether on single-processor machines or multiple processors, has many pitfalls. We will examine these potential pitfalls, and discuss ways to avoid common problems, such as deadlocks and race conditions. We will also discuss how to write code that efficiently passes data with other parallel processes. The basics of parallel processing are covered, leading to a discussion and examples using Ada tasking. In addition, the Ada Real-Time Systems Annex is also covered.