Visual Support for Incremental Abstraction and Refinement in Ada 95
If a graphical representation effectively
supports well-defined cognitive processes employed during comprehension
tasks, comprehension efficiency can be increased. GRASP is a software engineering
tool which uniquely combines a source code diagramming technique, the control
structure diagram (CSD), with other comprehension aids such as complexity
visualization, syntax coloring, and source code folding. The synergistic
combination of these features in GRASP has the potential to be a powerful
aid in any activity where source code is expected to be read. The primary
focus of GRASP is to improve the comprehension efficiency of software,
and, as a result, improve reliability and reduce costs during design, implementation,
testing, maintenance and reenginering. This paper will focus on the specific
combination of source code diagramming and folding for Ada 95 in GRASP.
RAPID : Towards A "Visual Ada"
More and more, computer programs are
becoming increasingly visual. Unfortunately, graphical interface programming
tends to be both highly complicated and system dependent. Various languages
and graphical user interface (GUI) design tools have been developed to
simplify this process. RAPID (the Rapid Ada Portable Interface Designer)
is the first free, multi-platform, GUI design tool written entirely in
and for Ada. By using the RAPID toolset, the programmer can quickly lay
out a user interface through a visual design process, then have the toolset
automatically generate Ada code that will create that interface.
An Application Engineering Workbench for Tailoring Ada Flight Components
The Reusable Software Architecture
for Spacecraft (RSAS) program has developed Software Reuse Engineering
"Workbench" that automates the production of satellite flight software.
The Workbench houses a generic software architecture that can be tailored
to specific satellite flight applications through the use of provided tools.
It captures the experience of flight system experts, guiding users through
the specification process, then automatically selecting and tailoring software
assets according to the needs of the system. The RSAS Workbench is based
on the Software Productivity Consortium’s concept of Synthesis. A "family"
of flight software solutions has been defined, including the commonalities
and variabilities between these solutions. Through the use of a "decision
model", the user is guided to one of the solutions, and flight software
is tailored accordingly.
A Comparison of the Concurrency Features of Ada and Java
Ada and Java are unusual in providing direct language support for concurrency: the task in Ada and the thread in Java. Although they offer roughly equivalent functionality -- the ability to define units of concurrent execution with control over mutual exclusion, synchronization, communication, and timing -- the two languages have some major differences. This paper compares and contrasts the concurrency-related facilities in Ada and Java, focusing on their expressive power, support for software engineering, and performance.
Using Java APIs with Native Ada Compilers
Ada95 is an ISO standard Object Oriented programming language specifically designed to support the cost effective development of robust, maintainable software. Because of this, Ada is widely used in the development of critical systems such as commercial aircraft. However, despite its advantages and general purpose nature, Ada is not often used for the development of main stream applications. This is partly because of Ada’s poor integration with contemporary technologies such as Graphical User Interfaces. Described within this paper is a technique which uses the Java Native Interface to provide Ada programmers with immediate access to any software that has a Java API, thus substantially improving the suitability of Ada for the development of a wide range of applications.
A Portable Implementation of the Distributed Systems Annex in Java
This paper describes an implementation
of the Distributed Systems Annex of Ada95. The use of Java to build the
Partition Communication Subsystem provides portability and Internet compatibility
of distributed applications while retaining the advantages of Ada at the
application level. The implementation is done partially in Ada and partially
in Java: stubs are generated by the GNAT compiler and the processing of
the streams (marshalling and unmarshalling) is done in Ada, while the processing
of the messages required to implement the PCS is done in Java for maximal
portability.
11:00 am -
12:30 pm
Converting Ada 83 Serving Tasks to Ada 95 Protected Objects
Protected objects are new features of Ada 95 that overcomes
limitations of tasks in Ada 83, supports more efficient communication,
and provides mutually exclusive access to shared data. Transforming large
concurrent software systems that were written in Ada 83 to software systems
using protected objects would make maintenance easier and improve system
performance dramatically. In this paper the semantics of rendezvous and
protected objects are examined, a group of hypotheses is developed, an
algorithm that converts serving tasks written in Ada 83 into protected
objects in Ada 95 is presented, and finally an example is given to demonstrate
applications of this algorithm.
Extensible Protected Types in Ada-EPT
This paper proposes extensions to Ada 95 to make protected types more
object-oriented; in particular, we consider the notion of a tagged protected
type. The semantic implications of this extension are considered along
with how they can be implemented. Finally, we show an example of extensible
protected types and draw conclusions.
Object-oriented systems exhibit the
property encapsulation, i.e., that the attributes and methods of a class
are defined in a single syntactic structure. Objects communicate with each
other through message passing. Each object has the potential to be an executable
entity and thus, implicitly, has the potential for concurrency. By transforming
objects to processes, this concurrency is made explicit. A methodology
has been developed for transforming an arbitrary object-oriented program
into a process-oriented program. The transformation algorithms are language-neutral
and have been applied to arbitrarily chosen examples from two different
languages. For this effort, the target language for the process- oriented
systems was Ada 95. The object-oriented systems were written in Ada 95
and Sather. This paper describes the methodology and the essential algorithms
for performing the structural and procedural transformations. It also discusses
some of the language-specific issues that were encountered during the transformation
process and offers some suggestions for future work.
Testing Generic Ada Packages with APE
Despite substantial research on methods
and tools for testing reusable modules, little help is available for the
tester in the field. Commercial tools for system testing are widely available,
but tools for module testing are hard to find. This paper presents a practical
approach to testing Ada packages using the Ada Package Exerciser (APE).
The APE tool generates test drivers for Ada packages from test scripts
written by the tester. The generated test drivers provide test inputs and
check output correctness automatically, so that it is practical to rerun
the tests after every change to the pack- age implementation or its environment.
The testing approach and the APE tool are described in detail, and illustrated
with a simple example and a commercially developed package. Specialized
techniques for testing generic packages and for performing random testing
are presented.
Dependency Analysis of Ada Programs
The use of Software Testing and Analysis
(STA) methods is not yet a standard practice in software development. It
is plausible that this is due to the following three facts: most available
tools offer only clerical, rather than semantic, help; more advanced tools
have been tested only in the laboratory setting and their real potential
is yet unknown; and tools tend to support rather disparate verification
activities, not integrated into the development process. We believe that
to achieve such an integration and provide a measure of semantic support,
the STA-based verification methodologies should be centered around a common
conceptual framework. Towards that goal, we analyze the advantages and
drawbacks of program dependencies as the basis for static (source code
based) and dynamic (execution based) STA techniques. It is demonstrated
that the dependencies, introduced for compiler optimization, cannot always
be directly applied to support the STA needs. To meet those needs, two
approaches are advanced: a set of modifications to the standard dependencies
and a novel Path Analysis that identifies dependencies on individual program
paths.
Specification and Code Generation Tool for Message Translation and Validation
This paper describes the Message Translation
and Validation (MTV) problem common to most computer-based applications,
and a model-based solution to the problem that is supported by a tool.
An early version of the MTV model was used by Granite Sentry Phase II in
the late eighties and later by the Air Force PRISM program at ESC in the
nineties. Accel obtained an SBIR Phase I and II contract to extend the
MTV model, convert it from Ada83 to Ada95, and to provide tool support
to ease the specification of message formats and automate the MTV code
generation. This paper will describe the solution and benefits, its usage,
some lessons learned, and future directions.