| |
|
|
T1: Developing Web-aware
Applications in Ada with AWS
Monday June 20th, morning
This tutorial describes AWS, the Ada Web Server,
and how to use it for the development of web-aware applications.
It describes the principles of AWS, from the most basic functionalities
to the more advanced ones (Authentication, SOAP interface, session
management, hotplugs, multi-server applications, etc.) The seminar
emphasises practical usage of AWS, and presents design patterns that
have proved effective for developing existing applications. It compares
the development process with AWS to other techniques. The tutorial
provides attendees with the information needed to assess whether AWS
is appropriate to their needs, and the necessary knowledge to start
writing full-scale Web applications.
More details
T2: Correctness by Construction—A Manifesto for High Integrity Engineering
Monday June 20th, morning
This tutorial presents the Correctness by Construction high
integrity approach to systems and software engineering. Correctness
by Construction is based on a set of principles, distilled from
practical project experience, to realize systems and software
engineering outputs with very low defect rate and very high resilience
to change. These principles can be applied most effectively to new
developments and upgrades. However some of the same principles can
also be applied retrospectively to improve the maintainability and
upgradability of existing systems.
More details
T3: Real-Time Java for Ada Programmers
Monday June 20th, full day
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.
More details
T4: SAE Architecture Analysis and Design Language
Monday June 20th, afternoon
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. The
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. This tutorial will
provide an introduction to the AADL language from a textual and graphical
perspective. It will also demonstrate the relationship between existing
systems and AADL models. The tutorial will present several uses of the
AADL in the design and analysis of safety-critical real-time systems.
The tutorial will also demonstrate the relationship between AADL models
and UML models.
More details
T5: High-Integrity Ravenscar Using SPARK
Afternoon June 20th, morning
SPARK is a well-established, unambiguous and fully-analysable
annotated subset of Ada. In its original form SPARK excluded all
forms of concurrency because weaknesses in the Ada tasking model
made it incompatible with the design goals of SPARK. The advent of
the Ravenscar Profile has provided an opportunity to extend SPARK
to include concurrency and to enable the SPARK Examiner to analyse
concurrent programs.
More details
T6: Ada 2005
Friday June 24th, morning
This tutorial will give an overview of the Ada 2005 language. The presenters are four of the key members of the ARG: John Barnes}, Alan Burns, Pascal Leroy (chair of ARG) and \Tucker Taft.
Note the tutorial is at a reduced price for those attending the main
conference (and includes lunch).
More details
T7: Software Safety Cases
Friday June 24th, full day
This Tutorial is not available.
Current best practice in the development of safety critical software requires the construction of a software safety case to demonstrate the acceptability of software in its system context. This is a process that should go hand in hand with software development to ensure that appropriate software safety evidence is obtained. This tutorial explains the role safety cases play in the development and certification of safety critical software. Specifically, the tutorial will consider the construction and presentation of software safety cases.
T8: Programming with the Ada 2005 Standard Container Library
Friday June 24th, afternoon
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.
More details
T9: Software Fault Tolerance
Friday June 24th, afternoon
This half-day tutorial explores the software-based techniques
and mechanisms available for tolerating unanticipated software
design faults in safety-critical systems. We examine the rationale
for tolerating software faults, the similarities to mechanisms for
tolerating hardware faults, and the advantages and disadvantages
of the common techniques. Special attention is paid to the
concept of design diversity as the underlying theory for the
most widely-used mechanisms (e.g., N-Version Programming) and, in
particular, whether design diversity can achieve the extremely low
failure rates required for safety-critical systems. The mechanisms
explored are illustrated with concrete implementations using Ada 95.
This leads to a discussion of the issues of concurrency and exceptions
in safety-critical applications and the appropriate application of
language features.
More details
T10: Requirement Engineering for Dependable Systems
Friday June 24th, morning
This tutorial will examine in detail the nature and role of requirements.
It will discuss the various types of requirements and their role in
development, as well as their impact to system success. The different
ways that requirements need to be handled will be analyzed, and
recommended techniques for process improvements will be discussed.
An overview of traditional approaches will be provided, with an
assessment of their strengths and weaknesses. In addition, a set
of common challenges will be presented, together with strategies for
how to manage them. Sample challenges include the impact of changing
requirements and uncertain operational environments. While the tutorial
will not specifically address particular approaches to requirements
definition (such as tools and techniques), it will characterize classes
of these techniques, and provide recommendations for how to select the
appropriate ones for projects of interest.
More details
