T1: Building Cross Language Applications using Ada
Abstract:
Building complex applications often requires putting together pieces of software or
requirements that have not been made to work together in the first place. Thinking of
a project with a high integrity kernel written in Ada, using a set of low level libraries
and drivers written in C or C++, with a graphical interface done in Java and unit tests
driven by python is not thinking of science-fiction anymore. Itʼs actual concrete and
day-to-day work. Unfortunately, having all of these technologies talking one to each
other is not straightforward, and often requires a deep knowledge of both sides of the
technology and extensive manual work.
In this tutorial, we'll first study how to interface directly Ada with native languages,
such as C or C++. We'll then have a deep look at communications with languages
running on virtual machines, such as Java, Python and the .NET framework. Finally,
we'll see how Ada can be interfaced with an arbitrary language using a middleware
solution, such as SOAP or CORBA Weʼll see how the communication can be
manually done using low level features and APIs, and how a substantial part of this
process can be automated using high level binding generators.
Presenter
Quentin Ochem has been working with the
and joined AdaCore in 2005. He is one of the main programmers of the GNATbench Eclipse
plug-in for Ada, and implemented a binding generator from Ada to Java in this context,
which is now distributed as a standalone product by AdaCore. He has been working with the GNAT
Programming Studio scripting capabilities as well, which are based on an Ada/Python
interfacing technology.
Why attend this tutorial?
This tutorial will give a broad overview of the possibilities of communications between
Ada and other languages, presenting advantages and drawbacks of different solutions, plus
state-of-the art information. Any developer facing this kind of issue will get a detailed
view on different solutions currently available.
T2: An Introduction to Parallel and Real-Time Programming with Ada
Abstract:
This tutorial provides an in-depth description of the Ada features used in concurrent and realtime
programming. Concurrent programming is the name given to programming notation and
techniques for expressing potential parallelism and solving the resulting synchronization and
communication problems (Moti Ben-Ari, 1982). The first two thirds of the tutorial will introduce
you to Ada's support for concurrency. Ada has integrated concurrency and synchronization as
part of the language. We will discuss the notion of the task, inter-task communication (entries,
rendezvous, select) and protected objects. We will illustrate these constructs through classical
and practical examples. In the final third of the tutorial, we will discuss Real-Time
programming, that is concurrent programming with the addition of timing constraints. We will
examine the aspects of Ada used to remove non-determinism from our concurrent programs. We
will look at time and clocks, deterministic dispatching, and the resource control features
provided in the Real-Time Systems Annex of Ada 2005.
Presenter
John W. McCormick (PhD, University of California, Los Angeles, 1977) has been Professor
of Computer Science at the University of Northern Iowa since 1996.
Before then, he was a Professor of Computer Science at the State University of New York (SUNY),
Plattsburgh. In 1993, he received the SUNY Chancellor's Award for Excellence in Teaching.
He is the primary author of two introductory Ada textbooks (both in second edition):
"Programming and Problem Solving with Ada" and "Ada Plus Data Structures: An Object-Oriented Approach."
Most of his publications are in the area of computer science education. His papers on the
use of model railroads in his undergraduate real-time systems courses received the award
for best presentation at both the ACM SIGAda and Ada-Europe conferences. He received the
ACM SIGAda Distinguished Service Award in 2002 and the ACM SIGAda Outstanding Ada
Community Contributions award in 2008. He is currently Chair of ACM SIGAda.
Why attend this tutorial?
To learn the fundamentals of concurrent and real-time programming with
T3: Software Tolerance
Abstract:
Software for current safety-critical applications – e.g., flight control systems – is both
large and complex, such that full testing is not feasible. Furthermore, complete proofs of
correctness are at best inherently limited by the potential for specification errors. The
combination of potential specification errors and overall complexity define a problem of
handling unanticipated software faults. “Software fault tolerance” is the use of software
mechanisms to deal with these unanticipated software faults.
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. This leads to a discussion of the issues of concurrency and exceptions in safetycritical
applications and the appropriate application of language features.
Participants will have an appreciation of the necessity for tolerating software faults as
well as a firm foundation for further study and informed application of available
mechanisms. A bibliography of suggested reading is provided to that end.
Presenter
Patrick Rogers is a senior Member of the Technical Staff with Ada Core Technologies,
specializing in high-integrity and real-time application support. A computing professional
since 1975 and an Ada developer since 1980, he has extensive experience in real-time applications
in both embedded bare-board and POSIX-based environments. An experienced lecturer and
trainer since 1981, he has provided numerous tutorials and courses in software fault tolerance,
hard real-time schedulability analysis, object-oriented programming, and the Ada programming
language. He holds B.S. and M.S. degrees in computer science from the University of Houston and
a Ph.D. in computer science from the University of York, England, in the Real-Time Systems Research
Group on the topic of software fault tolerance.
Why attend this tutorial?
Systems software architects and developers responsible for safety-critical software will
gain an appreciation for software fault tolerance facilities, including their limitations, and
will have a firm foundation for informed application of available mechanisms as well as further
study..
T4: Software measures for building dependable software systems
Abstract:
For any software development effort, being able to track progress in the development process
as well as monitoring the system's projected quality attributes levels, is a crucial activity.
For dependable systems, this is even more critical, because developing dependable software
systems is a continuing challenge. It is important to be able to track the emerging attributes
of the system so that corrective action can be performed early enough to avoid costly rework.
The effective and efficient use of software measurement can assist in this goal. One key is to
select and apply the right measures, and to avoid those that do not provide useful information.
There is a temptation to collect metrics with the idea that more data is better.
Such a collection strategy results in wasted effort and at times misleading indicators
such as false positives and false negatives.
This tutorial surveys the range of popular and effective measures, and provides
guidelines for their selection, application, and interpretation. It provides an assessment of
the utility of many popular measures, and makes recommandations for effective subsets that provide
cost-effective and predictive information.
Presenter
Since 1990, Dr. Bail has worked for The MITRE Corporation in McLean, VA as a
Computer Scientist in the Software Engineering and Computing (SWEC) Department. MITRE is a not-for
profit corporation chartered to provide systems engineering services to the U.S. Government
agencies, primarily the DoD, the FAA, and the IRS. Within MITRE, the SWEC supports customer
programs, consulting on various aspects of software development, ranging from requirements elicitation
and management, to design techniques and practice, and to testing. The SWEC particularly focuses
on transitioning emerging technologies into practice. Dr. Bail’s technical areas of focus
include requirements engineering, dependable software design and assessment, error handling
policies, design methodologies, metric definition and application, and verification and validation.
At MITRE, Dr. Bail is currently supporting the U.S. Navy, focusing on the practice of software
engineering as applied to large real-time systems. Prior to 1990, Dr. Bail worked at Intermetrics Inc.
in Bethesda, MD. Since 1989 he has served as an Adjunct Professor at the University of Maryland,
University College where he develops instructional materials and teaches courses in software
engineering, in topics such as Software Requirements, Verification and Validation, Software
Design, Software Engineering, Fault Tolerant Software, and others. Previously, Dr. Bail taught
part-time at The University of Maryland from 1983-1986, in the Computer Science Department for
undergraduate courses in discrete mathematics, computer arhitecture, and programming language theory.
Dr. Bail received a BS in Mathematics from Carnegie Institute of Technology, and an MS and Ph.D.
in Computer Science from the University of Maryland. Dr. Bail has presented tutorials on Cleanroom
Software Engineering, Semi-Formal Development Techniques, Statistical Testing, and Requirements
Engineering for Dependable Systems at SIGAda, Ada-Europe, the NDIA Systems Engineering Conference,
SSTC, and other conferences.
Why attend this tutorial?
Measurement of software systems is a key activity that aids in their development.
Developing a complex software system without collecting appropriate metrics is like flying
a plane in the fog without instruments and radar, It is crucial to collect metrics and to use
them as an integral part of the development process. In order to avoid costly and
time-intensive rework late in the development effort, collecting metrics allows developers
to be able to track the emerging attributes of the system so that corrective action can be performed
early.It is important however to select those measures that provide information that is useful
for the development process. Mindless collection of numbers will only consume time and effort,
and may distract developers from the true risks to the system.
This tutorial will provide the attendee with the basic understanding of the role of
software measures and how they can be used to support the management of a software
development project. The tutorial will also discuss different categories of measures and
how to select specific measures based on the nature of the development effort. The information
presented will help in ensuring that a metrics program will focus on measures that provide
utility and that are cost-effective, ensuring that any emerging issues are identified early
providing an opportunity for correction.
T5: SPARK - The Libre Language and Toolset for High-Assurance Software
Abstract:
SPARK is an annotated sub-language of Ada which is unambiguous and suitable for
rigorous static analysis. It has been extensively used in industrial applications where
safety and security are paramount.
The tutorial, which is extracted from the four-day "Software Engineering with SPARK"
course will cover: The rationale and design goals of SPARK, the core SPARK language, and
SPARK analyses including information flow, exception freedom, and formal verification.
The tutorial will also cover the forthcoming "Libre" release of the SPARK
technology and the research topics that this opens, such as more advanced forms of
analysis and proof, model-checking, and language extensions.
There is currently great interest in the use of static analysis technologies in the
development of high-assurance software, but most tools suffer from the design of contemporary
languages where this style of verification was never a primary design goal. SPARK takes a radical
approach - the language is designed from scratch to permit static analysis which is sound,
deep, fast, modular and can exhibit a very low false-alarm rate. This tutorial therefore
covers both the language design and the capabilities of the tools to show how these issues
are related and solved in the SPARK system. Attendees will therefore come away with an
understanding of what static analysis tools can (and can't) do, and what can be achieved
at the "high end" that SPARK embodies.
More on the presenter:
Rod is a well-known conference speaker. He has presented papers, tutorials and workshops
at many international events including STC, NSA HCSS, and ACM SIGAda. He was the
opening key-note speaker at Ada Europe 2006.
Rod has been involved with the design of both safetyand security-critical software with
Praxis for many years, including significant contributions to many of Praxis' key-note projects
such as SHOLIS, MULTOS CA, Tokeneer, and the development of the SPARK language and
verification tools.
Why attend this tutorial?
To learn about the trade-offs in the design of programming languages and static analysis
tools. To learn about what such tools can and can't offer in terms of soundness, depth,
efficiency and completeness of analysis. To appreciate the SPARK language, and the
capabilities of the SPARK toolset, and how these "fit" into a larger
high-assurance software process. To pro-pose, discuss and learn about research themes
offered by the Libre release of the SPARK technology
T6: Hard Real-Time and Embedded Systems Programming
Abstract:
Although the terms are often used interchangeably, real-time systems need not be
embedded, and embedded systems need not have deadlines. However,
applications in both domains are expensive and labor-intensive, especially
because developers typically have only low-level tools available and must use
techniques that are more ad hoc than analytical. Ada 2005 represents the state-ofthe-
art in real-time programming languages and offers a high-level model for lowlevel
programming that is unsurpassed in expressive power. This intensive course
covers the modern analytical techniques for determining whether deadlines will
be met, the Ada language facilities required to support those analyses, and the
high-level model Ada provides for embedded systems development. In addition,
the issues involved in storage management are covered so that, in addition to
time, equally important storage resources are available when required.
Presenter
Patrick Rogers is a senior Member of the Technical Staff with Ada Core Technologies,
specializing in high-integrity and real-time application support. A computing professional
since 1975 and an Ada developer since 1980, he has extensive experience in real-time applications
in both embedded bare-board and POSIX-based environments. An experienced lecturer and
trainer since 1981, he has provided numerous tutorials and courses in software fault tolerance,
hard real-time schedulability analysis, object-oriented programming, and the Ada programming
language. He holds B.S. and M.S. degrees in computer science from the University of Houston and
a Ph.D. in computer science from the University of York, England, in the Real-Time Systems Research
Group on the topic of software fault tolerance.
Why attend this tutorial?
Developers will understand the fundamentals of schedulability analysis and the unmatched real-time scheduling facilities provided by Ada. In addition, the low-level programming facilities, so often misunderstood, are covered in detail. This tutorial is intended for developers familiar with some of the more advanced features of Ada, including tasking and access types.
T7: Designing Real-Time, Concurrent, and Embedded Software Systems using UML and Ada
Abstract:
The domain of real-time, concurrent, and embedded software is becoming increasing
complex. To effectively develop these systems, greater care must be taken to construct
adequate models of the software and to effectively analyze these designs prior to code
development. In this tutorial, we will discuss modeling and analysis issues specific to realtime,
concurrent, and embedded software systems. Specifically, this tutorial will present
guidelines for modeling these systems using the Unified Modeling Language (UML) version
2. A case study will be introduced to solidify the concepts and participant interaction will be
encouraged in the construction of the models. Analytical methods will also be discussed to
verify that the UML-based designs will produce the desired behavior. Finally, we will
discuss how to proceed from the UML models into an Ada (2005) implementation.
Presenter
Rob Pettit has over 20 years of experience in the software development industry and is an internationally
recognized expert in the field of software design for object-oriented real-time and concurrent systems. In his
current position as Sr. Project Leader for The Aerospace Corporation, Dr. Pettit provides
technical leadership and research direction for the Office of Software Modeling and
Analysis (OSMA), which he helped to found in 2006. In addition to his leadership role for the
OSMA, Dr. Pettit is responsible for oversight, consulting, and mentoring for a number of
object oriented software development projects. Dr. Pettit has also served as the principle
investigator on multiple Aerospace-funded research programs primarily focused on applying
object-oriented technology to real-time embedded systems. Dr. Pettit has taught numerous
industrial courses on software development and object oriented technology; has given
numerous presentations to international conferences and workshops; and has been invited to
speak at international venues related to real-time and embedded software. Dr. Pettit is
also an Adjunct Professor of Computer Science at George Mason University where he teaches
object-oriented software analysis and design for the software engineering master’s
program and where he established a course on mode-driven real-time and embedded software.
Dr. Pettit received his B.S., Computer Science degree in 1991 from the University of
Evansville, his M.S., Software Systems Engineering degree in 1995 from the George Mason
University, and his Ph.D. in Information Technology / Software Engineering from George
Mason University in 2003. Dr. Pettit was the General Co-Chair for the Americas of
IEEE’s 2007 and 2008 International Symposium on Object-oriented Real-time Computing
(ISORC 2007 and ISORC 2008) and is the General Chair for the 2009 ACM/IEEE International
Conference on Model Driven Engineering Languages and Systems (MODELS 2009). Dr. Pettit is
a Senior Member of the IEEE; a member of ACM's SIGAda; and a co-author of Ada 95 Quality
and Style.
Why attend this tutorial?
The domain of real-time, concurrent, and embedded software is becoming increasing complex. To effectively develop these systems, greater care must be taken to construct adequate models of the software and to effectively analyze these designs prior to code development. In this tutorial, we will discuss modeling and analysis issues specific to real-time, concurrent, and embedded software systems. Specifically, this tutorial will present guidelines for modeling these systems using the Unified Modeling Language (UML) version 2. A case study will be introduced to solidify the concepts and participant interaction will be encouraged in the construction of the models. Analytical methods will also be discussed to verify that the UML-based designs will produce the desired behavior. Finally, we will discuss how to proceed from the UML models into an Ada implementation.
This tutorial is structured for software and systems engineers responsible for specifying, modeling, and analyzing real-time, concurrent, and embedded software systems. The tutorial assumes basic knowledge of object-oriented design concepts as well as concepts surrounding real-time and embedded systems. Basic knowledge of the Ada programming language and its features for concurrency are also assumed.
T8: Object-Oriented Programming in Ada 2005
Abstract:
This tutorial will teach attendees how to use the new Ada 2005
language features for object-oriented programming. The tutorial
will include information about annotating primitive operations,
new distinguished-receiver call syntax, interface types,
extended return statements, limited-with and private-with package
dependencies, limited aggregates and box defaults, generic formal
primitive operations, and additions to the predefined language
environment. In particular, it will discuss the full integration
of the language features for concurrency into the type model.
The tutorial is a half-day in duration, and its intended level is
intermediate. Attendees should have a modest experience with Ada
programming in general, and Ada 2005 in particular.
More on the presenter:
Matthew Heaney is a developer at On2 Technologies, where he writes Flash Media authoring tools. He has had a long career using Ada technology, having designed several large real-time systems in Ada. Matthew participated in the standardization of the Ada 2005 container library (which was based on the Charles library, his port of the STL to Ada95), and more recently has been involved in development of bounded container forms. Matthew has presented many Ada tutorials at both SIGAda and Ada-Europe, on the subjects of object-oriented programming, design patterns, system design, and container libraries.
Why attend this tutorial?
This tutorial will teach attendees about the Ada 2005 language features for object-oriented programming. The tutorial will include information about new procedure call syntax, interface types and tagged types, extended return statements, anonymous access return types, implicit aliasing and dereference, limited aggregates, and other improvements. It will also discuss new idioms for subsystem design (including a solution to the problem of mutual package dependencies), and demonstrate with many examples how the features for concurrency have now been fully integrated into the Ada type model.
T9: Execution Time: Analysis, Verification, and Optimization in Reliable Systems
Abstract:
How long does my software take to run...and how can I reduce it?" are key issues for
embedded engineers designing reliable systems. Understanding, verifying, and
improving the timing performance of their real-time products gives successful companies
a key competitive edge.
This tutorial will cover key aspects on-target timing analysis: finding worst case
execution times (WCET) and the worst case path, and why worst case optimization is
not the same as average execution optimization. Practical issues of looking for the
worst-case "hot-spots", identifying timing bugs and verifying optimisation opportunities
will be explained with examples of worst case optimizations.
The tutorial first focuses on understanding execution times of software, why they are
important, why they vary and how to find them. We discuss different sorts of execution
time: minimum, average, maximum measured, worst case and different ways of finding
them. Low-level (e.g. hardware features) and high-level (e.g. path through the software)
issues are discussed and the impact that they have on finding execution times.
Tool support for understanding the timing behaviour, including worst case execution
times is explained.
Finally, methods for reducing (optimization) of the worst-case execution time are
explored.
We make the distinction between average case optimizations and worst-case
optimizations and how worst-case optimizations are important for reliable systems. A
simple procedure for managing and performing software optimization in reliable systems
is suggested with examples and results of optimization of the worst-case execution
times in a large Ada project.
More on the presenter:
Dr Ian Broster is a founder and Director of Rapita Systems Ltd, a company specializing
in software timing analysis. He is an experienced, lively lecturer who has given
numerous training courses, lectures and presentations on this an other topics. He has
been involved with Ada for several years. He earned his PhD at the Real-time Systems
group of University of York
Why attend this tutorial?
Today, software timing analysis doesn't have to be guesswork. This tutorial addresses two key aspects of real-time systems performance: (1) how to gain a clear, detailed, and accurate understanding of the execution time and worst case execution time (WCET) behaviour of real-time embedded software, (2) how to target optimisation effort precisely where it will have the maximum benefit in improving system timing behaviour, for the minimum cost
T10: Modeling for Schedulability Analysis with the UML Profile for MARTE
Abstract:
MARTE, the UML Profile for Modeling and Analysis of Real-Time and Embedded Systems, is
the new standard provided by the Object Management Group to complement UML with modelling
constructs useful for the real-time and embedded systems communities. A challenging
problem in model-based engineering is to integrate models that are commonly used for
system production or software code generation with the information that is relevant to
perform analysis. The goal is to reduce the time required to prepare a design model for
performing analysis and to ensure greater accuracy of an analysis model by directly
associating it with the actual system model.
A large part of modelling constructs in MARTE are specific for analysis, and extend the
capabilities of its predecessor, the "UML Profile for Schedulability, Performance,
and Time" specification by enlarging the kinds of resources, providing new mechanisms
for the specification of non-functional properties, and additional modelling artifacts, as
well as by specifying it for UML2, the latest version of UML.
Considering its role for the enabling of schedulability analysis techniques in a model
driven engineering approach, and being scheduling a key factor in the assessment and
assurance of software reliability, this tutorial presents the capabilities in the MARTE
profile that provide support for schedulability analysis. These annotations are used to
add supplementary information to various kinds of UML elements that can then be
interpreted by specialized tools or domain experts. For instance, fine-grained timing
analyzers can help to determine the worst case execution times of relevant pieces of code,
which are then used in schedulability analysis to predict end-to-end response times. These
annotations are defined in the Schedulability Analysis Modelling (SAM) sub-profile of MARTE.
More on the presenters:
Julio Medina is graduated as Electronics Engineer from the Universidad Nacional de Ingeniería, Perú, in 1987. He obtained the Master in Real-Time Systems and the Doctorate in Telecommunications Engineering from the
Huascar Espinoza is a researcher of the Model Driven Engineering Labs at CEA (French Atomic Energy Commission). He holds a Ph.D. in Computer Science from the
Why attend this tutorial?
UML is a language; MARTE brings additional vocabulary to UML. This tutorial will help in identifying the precise semantics and modelling intent of this additional vocabulary. It is given by significant contributors to the standard, and will show its practical application in the utilization of UML models for schedulability analysis