SIGAda 2011 Home

Register Online Now

Hotel Rates, Reservations, Travel

Reception Dinner & Program

Exhibiting and Sponsorship Opportunities

Additional Promotional Opportunities

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 be demonstrated.

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
Andrew Coombes

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
Ben Brosgol

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 be useful.

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:

1. The Ada type model
2. High level support for low level programming
1. Representation clauses and pragmas
2. Device drivers
3. Interrupt handlers
3. The task
1. Defining
2. Life cycle
3. Hierarchies
4. Communication and synchronization based on shared objects.
1. The protected object
1. Mutual exclusion
2. Synchronization
3. Entry queues
2. Pragmas for simple shared objects
3. Some useful concurrent patterns
5. Communication and synchronization based on direct interaction
1. The rendezvous
2. Selective accept statements
3. Entry call options
6. Real-time systems and scheduling concepts
1. Task characteristics
1. Context
2. States
3. Properties
2. Schedulers
1. Scheduler classifications
2. Fixed priority scheduling
3. Dynamic priority scheduling with Earliest Deadline First
3. Task dependencies
1. Shared resource problem and protocols
2. Precedence constraints
4. Cheddar, a free real time scheduling tool
7. Real-time programming with Ada
1. Expressing time
2. Implementing periodic tasks
3. Handling shared resources
4. The Ada scheduling model
5. Ravenscar
6. 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
Tucker Taft

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
Jean-Pierre Rosen

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.