Sunday Full-Day Tutorials (9:00am - 5:30pm)
SF1: Introduction to Ada
Michael B. Feldman
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, including types, packages, syntax rules, and
other Ada programming constructs. In the afternoon, we will cover Ada’s
object-oriented programming and concurrent-programming features. Many examples
will be shown; freely downloadable Ada programming environments and tools will
Sunday Morning Tutorials (9:00am - 12:30pm)
SA1: Service-Oriented Architecture (SOA) Concepts and Implementations
Ricky E. Sward, Jeff Boleng
Level — Intermediate.
This tutorial explains how to implement a Service-Oriented Architecture (SOA)
for reliable systems using Enterprise Service Bus (ESB) technologies.
The first half of the tutorial describes terms of Service-Oriented Architectures (SOA)
including service, service registry, service provider, service consumer, Simple Object
Access Protocol (SOAP), Representational State Transfer (REST), and Web Service Description
Language (WSDL). Several examples of REST and SOAP web services are provided using the
Ada Web Server (AWS). This tutorial also presents principles of SOA including loose
coupling, encapsulation, composibility of web services, and statelessness of web services.
The tutorial covers the benefits of SOA and organizations that are supporting SOA infrastructure.
The second half of the tutorial covers Enterprise Service Bus (ESB) technologies including
definitions, capabilities, benefits and drawbacks. The tutorial discusses the difference
between SOA and an ESB, as well as some of the commercially available ESB solutions on the
market. The Mule ESB is explored in more detail and several examples are given. Several
examples of using an ESB in a SOA application are given using AWS as an Ada implementation.
An AWS server is built in the examples and connected to the ESB providing REST and SOAP web
services. AWS allows the developer to expose services in a high-integrity system using the
Ada and SPARK programming languages.
SA2: How to measure and optimize reliable embedded software
Level — Intermediate.
This tutorial explores some of the challenges of developing reliable embedded systems,
focusing on non-functional properties that are particularly important to test "on-target".
These include software performance/timing, worst case execution time (WCET), code coverage and memory use.
The tutorial explains and compares different techniques for measurement and analysis of
software on embedded targets including tracing methods, in-memory analysis and using
hardware support. It shows how those techniques can be used for verification of non-functional
properties on-target, including in the context of DO178B/C and the new ISO26262 standard to
meet the requirements for safety.
The tutorial also explains how to how to benefit from measurement and analysis techniques
in other ways such as focused optimization, faster debugging and supporting software management processes.
There will be an opportunity for hands-on work, with a competition and prize.
On-target measurement of non-functional requirements is a fundamental part of reliable
system development. We focus on three non-functional requirements that need to be
addressed as part of reliable systems: code coverage, on-target performance and
memory usage. The tutorial explores techniques for measuring and analyzing the
on-target behavior, and how to relate those techniques to a safety argument in
avionic and automotive safety standards.
There are other benefits of performing on-target measurement too, such as being able
to optimize software efficiently and debugging of problems - the tutorial will show
some practical techniques that can be used to improve embedded software development.
The tutorial covers:
- On-target measurement techniques
- Worst case execution time analysis
- Software optimization
- Code coverage measurement
- Memory usage measurement
- Software standards DO178B, DO178C, ISO26262
- Tool support for measuring, analyzing and optimizing.
Sunday Afternoon Tutorials (2:00 - 5:30pm)
SP1: DO-178C: The Next Avionics Safety Standard
Level — Intermediate.
The commercial avionics community's DO-178B software safety certification requirements
document is being updated to take into account twenty years of experience, and the new
version (DO-178C) is close to completion. This half-day tutorial covers the core of the
DO-178C standard, including the new treatment of tool qualification, as well the supplements
on Object-Oriented and Other Technologies, Model-Based Design, and Formal Methods.
No previous knowledge of DO-178B is assumed.
SP2: Improving the Quality of Ada Software with Range Analysis
Jeff Chapple, Jay Abraham
Level — Intermediate.
Ada is a strong language with built-in mechanisms that naturally lead to safer and less risky
software programs. This is possible because Ada is a structured and strongly typed language
with built-in run-time protection mechanisms. For example, subtyping allows for specification
of ranges for variable. The compiler can detect illegal values for these variables as well as
insert run-time range checks during compilation so that violating specified ranges result in
a Constraint_Error during run-time.
For complex embedded systems where quality and safety are imperative, the Ada programming
language alone may not provide sufficient quality and safety margins. Demonstrating run-time
robustness with exhaustive dynamic testing is not possible. Formal methods with mathematical
proofs enables precise determination of some properties of a complex system without the need
for exhaustive analysis. This technique can be exploited statically to exhaustively determine
dynamic runtime behavior of software programs.
Coupling the Ada language with these state of the art verification solutions may improve the
predictability of quality and safety. This tutorial examines software verification and testing
approaches that have been applied to Ada programs. These techniques will be compared and
contrasted with formal methods based these techniques that can statically produce accurate
range analysis variables in Ada programs. Concrete technical examples will be explored to
see how these verification techniques, in particular the use of range analysis, can be used
to improve the quality and safety of complex software systems that are developed in Ada.
This tutorial will span approximately four hours. Presentations will be interspersed with live
demonstrations showing how Ada software can fail with run-time errors and how these errors can
be detected and debugged. Formal methods based techniques to achieve runtime verification and
role of range analysis will be discussed. Slices of Ada source code will be analyzed from a
runtime verification perspective to gauge the effectiveness of this technique. The role of
range analysis for Ada programs will be shown with examples. Questions and interaction with
the audience will be highly encouraged.
Monday Full-Day Tutorials (9:00am - 5:30pm)
MF1: Building Embedded Real-Time Applications
John W. McCormick, Frank Singhoff
Level — Beginning to intermediate. Some experience with the sequential aspects of Ada would
Ada is arguably the most appropriate language for development of embedded real-time
applications. This tutorial provides an introduction to the features of Ada that makes it
appropriate in this domain. Topics covered include:
- The Ada type model
- High level support for low level programming
- Representation clauses and pragmas
- Device drivers
- Interrupt handlers
- The task
- Life cycle
- Communication and synchronization based on shared objects.
- The protected object
- Mutual exclusion
- Entry queues
- Pragmas for simple shared objects
- Some useful concurrent patterns
- Communication and synchronization based on direct interaction
- The rendezvous
- Selective accept statements
- Entry call options
- Real-time systems and scheduling concepts
- Task characteristics
- Scheduler classifications
- Fixed priority scheduling
- Dynamic priority scheduling with Earliest Deadline First
- Task dependencies
- Shared resource problem and protocols
- Precedence constraints
- Cheddar, a free real time scheduling tool
- Real-time programming with Ada
- Expressing time
- Implementing periodic tasks
- Handling shared resources
- The Ada scheduling model
- POSIX 1003.1b and its Ada binding
We would like participants to bring a laptop computer. We will install
GNAT and Cheddar for some hands-on exercises.
Monday Morning Tutorials (9:00am - 12:30pm)
MA1: Experimenting with ParaSail – Parallel Specification amd Implementation Language
Level — Beginner
Here is a chance to experiment with a new language designed to support the safe, secure, and
productive development of parallel programs. ParaSail is a new language with pervasive parallelism
coupled with extensive compile-time checking of annotations in the form of assertions, preconditions,
postconditions, etc. ParaSail does all checking at compile time, and eliminates race conditions,
null dereferences, uninitialized data access, numeric overflow, out of bounds indexing, etc. as well
as statically checking the truth of all user-written assertions. After a short introduction to the
language, attendees will receive a prototype ParaSail compiler and an accompanying ParaSail Virtual
Machine interpreter for writing and testing ParaSail programs. The tutorial/workshop will finish
with a group discussion and feedback on the experience of using this new language.
Monday Afternoon Tutorials (2:00 - 5:30pm)
MP1: Ada coding standards
Level — Intermediate
Most companies have developed coding standards (often because having one is a requirement for certification),
but few have conducted a real analysis of the value, consistency, and efficiency of the coding standard.
This tutorial presents the challenges of establishing a coding standard, not just for the sake of having one,
but with the goal of actually improving the quality of software. This implies not only having "good" rules,
but also having rules that are understood, accepted, and adhered to by the programming team.
The issues of automatically checking the rules is also fundamental: experience shows that no manual checking
can cover the programming rules to a satisfactory extent. The tutorial presents the tools available, then
goes into deeper details using AdaControl, a free rules checking tool.
Attendees are invited to bring their own code and computers, for practical experiment of how automatic
checking can help discover violations that have escaped the most thorough reviews.