Let TRI-Ada's accomplished instructors get you up to speed quickly with the topic of your choice.
TU1 - Software Reuse Metrics, Reusability Metrics, and Economic Models. Jeffrey Poulin, Lockheed Martin Federal Systems.
This tutorial will explain how to apply reuse metrics, reuse economics, and reuse return-on-investment (ROI) models in diverse organizations and programming languages. How do we measure the level of reuse on a project? (Handle generated code, COTS, internal vs. external reuse, etc.) How do we quantify the financial benefits of reuse? (Justify reuse investments based on cost-benefits, etc.) How do we identify the most reusable components? (Locate reusable components in existing code and build for reuse.)
TU2 - Introduction to Open Systems. Trish Oberndorf & Carol Sledge, SEI.
This half-day presentation provides participants with a high-level understanding and appreciation of the transition to an open-systems approach for systems acquisition. It provides practical definitions, the basics of an open systems approach, an understanding of the issues involved in open systems, and knowledge of what to look for based on the experiences of real DoD programs. After attending this session, participants will be better prepared to incorporate open systems into their approach to engineering and acquiring systems. They will know what to expect of their team and have more knowledge about opportunities to collaborate with other organizations.
Prerequisites: Familiarity with systems acquisition.
TU3 - CoRE for Requirements, ADARTSSM for Design Rob Pettit, Software Productivity Consortium.
The CoRE and ADARTS tutorial provides an overview of the Consortium Requirements Engineering (CoRE) and the Ada-based Design Approach for Real-Time Systems (ADARTS) methods. CoRE is a method for analyzing, specifying, and managing real-time software requirements. ADARTS 3.0 is one of the Consortium's most widely-used technologies for developing real-time systems and is the standard design method for several major programs. CoRE and ADARTS 3.0 provide the analyst and designer with defined, repeatable methods consisting of an iterative series of activities. Both methods lead the designer to produce well-defined work products and system/software architectural views that aid in understanding and setting up the system.
Prerequisites: Basic understanding of software
engineering principles and development processes. Experience in
designing real-time systems is helpful but is not required.
TU4 - How Ada 95 Promotes Safe Programming Practices. David Naiditch, Hughes Aircraft Company
Using code examples, this tutorial illustrates how Ada 95 features can minimize unsafe Ada 83 programming practices. In particular, Ada 95 provides elegant and safe solutions to problems that have traditionally required Ada programmers to resort to unchecked programming.
Prerequisites: Familiarity with Ada 83.
TU5 - A Risk-Based Approach to Software Metrics. Harry Joiner, System Resources Corporation.
Controlling software projects means managing the risk factors to the project's cost, schedule, and quality objectives. The team that identifies these factors up front and develops customizable metrics can get information early enough to take corrective steps. This permits frank communications among the project personnel. The session will use specific examples to show how proper trend analysis ensures that the team can cohesively assess and manage risks.
Prerequisites: No special training in metrics required.
TU6 - Software Component Engineering Using Ada 95: Applying Explicit Design Principles in a Disciplined Way. David Gibson & Bruce Weide, Ohio State University.
This tutorial presents the RESOLVE/Ada 95 discipline for constructing reusable software components in Ada 95. To improve software quality and programmer productivity, the discipline demands four properties of all software components: composability (with other components designed under the discipline), correctness (relative to a formal behavioral specification), reusability, and understandability. RESOLVE/Ada 95 is a comprehensive set of principles governing component design, execution, testing, and usage.
Prerequisites: Workshop participants should be
experienced Ada programmers -- preferably practicing software
engineers with a familiarity with the new language features of
Level: Intermediate - Advanced
TU7 - Product Line Management and Engineering. Steven Wartik, Software Productivity Consortium.
Software managers and technologists can learn to apply the concepts of product lines to software. The tutorial's emphasis is conceptual rather than practical, but includes pointers to real projects that have used product lines. It will cover the benefits of product lines and discuss the Synthesis methodology for identifying, analyzing, and setting up product lines. The session will also describe a practical approach for adopting Synthesis.
Level: Novice - Intermediate
TU8 - Ada 95 for Ada 83 Programmers. Norman Cohen, IBM Thomas J. Watson Research Center.
This tutorial is designed to introduce Ada 95. Particular attention will be placed on the new features of the language, such as object orientation, inheritance, protected records, and hierarchical libraries.
Prerequisites: Some knowledge of Ada 83 is beneficial.
TU9 - Guaranteeing Real-Time Performance Using Rate Monotonic Analysis. Ray Obenza, SEI.
Rate monotonic analysis (RMA) is a simple, practical, mathematically sound way to meet response-time requirements. Today, engineers are using RMA to analyze real-time system designs, to identify and eliminate unbounded priority inversion, and to meet hard deadlines at all times. They can also use RMA to show when designs meet average-case performance requirements. RMA is a collection of quantitative methods and algorithms that allow engineers to understand, analyze, and predict the timing behavior of their designs. This session introduces RMA and provides information for evaluating its usefulness within an organization. The tutorial explains RMA for practical use on real-world systems and employs a case study to tie the concepts together.
Prerequisites: None. Participants may find bringing a
TU10 - Domain Engineering, Sholom Cohen & Pat Donohoe, SEI
Domain engineering is a process for building reusable software assets. It is based on understanding the commonality and variability among related software systems and on building domain models, architectures, and components accordingly. These become building blocks for applications. This tutorial addresses the technical issues and engineering tradeoffs involved in creating reusable software assets for product lines. Its focus is a model- and architecture-based approach to systematic software reuse that exploits commonality and manages variability. Attendees will learn how the assets become the technology base of an application engineering process. Examples include current product-line approaches from various organizations.
TU11 - Visual Ada 95 Development for WIN32 Howard Steward & Paul Whittington, Idaho National Engineering Laboratory.
This tutorial will provide beginning to advanced instruction in Ada for WIN32 platforms using the new Visual AdaSAGE environment. It will cover object-oriented development using visual components, ActiveX controls, custom controls, JAVA and JVM, integration with SAGE and other popular data base engines, and graphical user interface development for Windows 95 and Windows NT.
Prerequisites: A familiarity with the Ada programming
languages is helpful. Novice to intermediate in the morning, advanced
in the afternoon.
Level: Novice - Intermediate (am) - Advanced (pm)
TU12 - Object-Oriented Programming with Ada 95. Stephane Barbey & Alfred Strohmeier, Swiss Federal Institute of Technology in Lausanne.
This tutorial provides a comprehensive view of object-oriented programming with Ada 95. It covers the new OO features of the language and their integration into good programming practice. Example applications demonstrate proper use of the new features.
Prerequisites: Familiarity with Ada is helpful. This
tutorial will also be of interest to those familiar with other OO programming
Level: Novice - Intermediate
TU13 - Ada Design Issues. Patricia Lawlis & Karyl Adams, C.J. Kemp Systems, Inc.
This course emphasizes the aspects of software design that practitioners must address in nontraditional manners to use Ada effectively. What differences in this language guide the design process? A comparison of traditional and newer design introduces the essential aspects of Ada-based design. The tutorial emphasizes design architecture and the packaging, algorithmic, and data abstractions within Ada.
Prerequisites: Training or experience in basic software
TU14 - Elements of Software Architecture with Ada 95. Magnus Kempe, KSCE, Switzerland.
Software architecture deals with design problems beyond algorithms and data structures. It makes possible large-scale software systems with stable foundations. This tutorial provides a practical introduction to software architecture with Ada 95 and shows how to use, evaluate, and write architectural elements. The topics covered include: the nature and value of software architecture; architectural styles and structures (e.g., subsystems, layers); design for adaptability (e.g., genericity, object-orientation, table-driven mechanisms); proven, fundamental elements of software architecture in Ada 95 (e.g., containers, filters, model-view-controller, blackboard); and finally, finding and creating useful architectural elements. Participants can immediately apply this to Ada 95 systems.
Prerequisites: The material requires knowledge of
generics and object-oriented mechanisms but no previous
acquaintance with software architecture.
TU15 - Object-Oriented Experiences and Future Trends. Mohamed Fayad, University of Nevada.
This tutorial reviews good and bad characteristics of several object-oriented techniques (OMT, Use Case Approach, Unified Approach, O-ET). It identifies aspects of these techniques to avoid. Participants will consider five case studies and the lessons learned, as well as some solutions and strategies to existing problems with OO.
Prerequisites: A general familiarity with OO concepts
and software engineering principles
TU16 - Object-Oriented Analysis and Design for Ada 95 with Colbert's Object-Oriented Software Development Method. Edward Colbert, Absolute Software Co., Inc.
This tutorial will explore Colbert's Object-Oriented Software Development method (OOSD) and its support for Ada, including Ada 95. OOSD focuses on the objects of a problem throughout development and is particularly compatible with Ada. OOSD addresses real-time issues, quickly communicates the information developed during analysis and design, and allows for exceptionally high re-use of both design representation and code. It is in use in may types of systems.
Prerequisites: General familiarity with OO concepts,
and languages such as Ada 83. Familiarity with Ada 95, and experience
developing large real-time or distributed systems, are useful,
but not required.
SA1 - Object-Oriented Features and Programming in Ada 95. Eugene Bingue, David Cook & Leslie Dupaix, The ASEET Team.
This tutorial is an introduction to Ada and Ada 95, with emphasis on features new in Ada 95.
Prerequisites: No knowledge of Ada is required.
Familiarity with some programming language is desirable, but not required.
SA2 - Ada and the Web Bob Munck.
This tutorial will present the basics of WWW and Internet technology, from the basic protocols to recent innovations like audio/video streaming, to provide a foundation for discussing how Ada 95 can have an important role in Web software. By far the largest use of this technology is now in "Intranets," internal corporate information systems using Web technology. The tutorial will explore emerging approaches to making legacy data bases and applications available on Intranets, and the reasons that Ada 95 is the best choice for such work.
SA3 - An Introduction to Software Capability Maturity ModelSM-Based Software Process Improvement. George Winters, SEI.
This tutorial introduces software process improvement and the capability maturity model, IDEAL approach, and tools that support IDEAL. It is intended for those unfamiliar with the topics, and is appropriate for practitioners, managers, and executives who seek an overview of the area and of software process improvement tools and their application and integration.
SA4 - Artificial Intelligence with Ada Janet Faye Johns, The MITRE Corporation.
Artificial Intelligence (AI) harnesses the power of knowledge. AI techniques create systems to perform useful intelligent tasks. With them, innumerable systems used by real people accomplish everyday tasks. This tutorial introduces the building blocks of an AI system and focuses on rule-based systems. It develops such a system, in order to illustrate how Ada 95 can build AI.
Prerequisites: General understanding of Ada and a
general interest in Artificial Intelligence.
SA6 - Programming Distributed Applications with Ada 95 and an Inside Look at the GNAT Implementation. Yvon Kermarrec & Laurent Pautet, Telecom Bretagne.
This tutorial will explain how to use Ada 95 for distributed applications. It will also discuss how various GNAT implementations achieve distributed components.
Prerequisites: Knowledge of Ada and Ada tasking.
SA7 - Design of Concurrent Software in Ada 9.5 Bo I. Sanden, Colorado Technical University.
Ada 95 is one of the few industry-strength languages that combine OO and concurrency. This tutorial shows participants how to use the concurrency features to design solutions to practical problems. The tutorial goes beyond traditional, textbook examples of concurrency. It introduces and uses the entity-life modeling (ELM) design approach. The session provides design heuristics and design patterns for different application types.
Prerequisites: Knowledge of the Ada 95 tasking syntax.
SA8 - Concurrency for Ada Programmers Bryce Bardin, Ada Consulting and Training
This tutorial covers the fundamentals of the Ada tasking model and how it applies to both monoprocessor and multiprocessor targets. Attendees will learn about the Ada constructs that support concurrency (tasks and protected objects), the way that Ada tasks are scheduled for execution, and the manner in which tasks interact with both other tasks and protected objects.
Prerequisites:Basic understanding of sequential
programming in Ada 83 or 95.