This tutorial will present the advantages of Ada 95 as a foundation introductory programming language for undergraduate computing curricula, including details of prototypical first- and second-level courses. Ada 95 combines the clear syntax and programming discipline of Pascal with a range of standard, industrial-strength features for encapsulation, template- and inheritance-based object-oriented programming, and language-defined multitasking.

What differentiates architecture from design is that architecture is outward looking, viewing the system in context, while design concentrates on the inward structure of the system itself. Thus, while all systems have an architecture, the challenge for systems development is to articulate a ``good'' architecture for the target system.

The tutorial begins with an overview of architecture as a major part of the system life cycle. Within this framework, we describe the steps in developing an architecture, showing the responsibilities of system architects, acquisition authorities, user representatives, design engineers and maintainers, and the resulting architectural products. Our approach designates some architectural products as the responsibility of the client; this ensures that the system can meet client needs.

We then present an approach to architectural description, based on a ``architectural metamodel,'' allowing an architecture to be described as a set of interrelated views, where each view is composed of components, connections and constraints. We demonstrate the selection and definition of architectural views from case studies based on existing systems from the domains of Command and Control and Information Systems.

The tutorial concludes with a look at related work, including ISO's Reference Model for Open Distributed Processing, IEEE's Recommended Practice for Architectural Description and the US DOD's C4ISR Architecture Framework .
 

Fusion is an object-oriented software development method. It is a full-coverage method, providing for all of analysis, design, and implementation. By integrating and extending existing approaches, Fusion provides a direct route from a requirements definition through to an implementation. The advantage of the Fusion method is that it offers not only notations for describing models, but a process for development.No specific knowledge in object-oriented methodology is required.
 

This tutorial is a gentle introduction to Ada 95. It assumes no prior experience with Ada, although some experience with another programming language would be helpful. It discusses the basic concepts of the language, and includes topics such as strong typing, tasking, exception handling, generics and packages. This tutorial is designed inform participants of the capabilities of the Ada 95 programming language, to dispel common myths about the lanaguge ("It's too hard to learn". "No tools are available". "Compilers cost a lot, and don't perform well"). to the language, and will cover reasons why Ada is a superior language for maintainable, robust and reliable code development.
 

The objectives of this tutorial are:
 

• Explain the important elements of the Java technology. Aspects of the technology that will be covered include: The Java programming language, the Java virtual machine and its performance, the Java API, the JNI (the interface that allows native aplications to interface with Java), as well as how to use Java technology in embedded applications.

• Help managers and developers understand the opportunities represented by this emerging technology, which spans applications ranging from internet applets to fully featured information systems running on mainframes, PCs or workstations as well as internet appliances and embedded systems such as intelligent automobiles, smart cards, telephones with built-in Web browsers and state-of-the-art cellular telephones.

• Provide a road map for project managers and software engineers to help them understand where Ada fits in the world of Java and how companies can take advantage of their Ada investments for the Java platform. More importantly, this tutorial will illustrate how the use of Ada can provide a competitive advantage on this emerging platform.

•  Explain how to write Ada applications for the Java platform using the GNAT compiler, which has recently been targeted to this platform. This includes writing new Ada applications as well as porting existing Ada code. Seamless interoperability between Ada and the Java programming language along with the use of the Java API (Application Programming Interface) from Ada will be discussed in depth. The tutorial will also show how native code written in Ada can use the Java API directly without the need to port the Ada code to the Java virtual machine.

The tutorial will contain down-to-earth examples to help participants acquire a concrete grasp of the concepts presented.
 

This tutorial is oriented towards providing SIGAda volunteers with the basic information to effectively disseminate information using the WWW. The tutorial addresses effective designs for web pages, the use of html for developing one's own web pages, incorporation of graphics, the use of ftp for posting pages to the network provider, and several automated tools (both UNIX-based and PC-based) useful to streamline the process. Strategies for announcements, configuration management, on-line mailing lists, on-line databases, and use of other document formats will be addressed for not only US dissemination, but also the international community. The use of the ACM host machine will be used as the model. Although the tutorial is specifically designed to support the needs of SIGAda Working Groups and SIGAda Chapters, the information will be useful to all interested in learning how to set up a WWW Home Page.
 

This tutorial/panel, designed for intermediate to experienced Ada programmers, will show how to develop and implement Ada programs on a Windows 95 or Windows NT platform. Participants will be provided a technical solution in one of the many areas of concern, such as GUI, OCX, and Active-X. An overview of the Windows API will be the starting point with a introduction into alternate GUI's such as TCL/TK.
 

This tutorial is aimed at Ada 95 developers interested in using CORBA technology in their Ada 95 applications to create high-performance distributed client/server applications and/or to mix Ada 95 with other languages on heterogeneous computing environments. This tutorial assumes that the audience members can write and understand programs in Ada 95. Familiarity with object-oriented programming in Ada 95 will be helpful. No background or experience with CORBA is assumed.
 

This tutorial is directed toward students and educators as well as professional Ada programmers. The techniques presented have the dual advantage of being both useful and fun.

We will go beyond the normal introductory course in Ada to explore a number of interesting non-standard ways of using Ada. Many of the techniques have been inspired by the author's experiences with the programming paradigms used by programmers of Lisp and various functional programming languages.

The tutorial shows how we can reduce complexity and improve readability of Ada programs by using a number of declarative techniques to replace potentially complex and involved procedural code. These techniques include

(1) declarative techniques for encapsulating control structures,

(2) a flexible, data-driven technique that, for want of a better term, I have called "template-driven programming,"

(3) use of inheritance and iterators to define generalized applications, and

(4) a technique based on lazy evaluation for the creation and manipulation of infinite data structures.
 

For this tutorial, some exposure to Ada 95 and OOP is helpful but not strictly necessary. Knowledge of Ada 83 is quite useful

This tutorial will cover consist of four parts, designed to incrementally increase your understanding of Java: 

1. Part one will cover Java fundamentals, basic properties of classes, and run-time models. 
2. Part Two will cover lexical properties, expressions and statements, data type topics, OOP: inheritance, polymorphism, dynamic binding, and interfaces.
3. Part Three will cover exceptions, threads, advanced OO features (cloning, inner classes). 
4. Part Four will cover the Abstract Windowing Toolkit and applets.

Expected benefit to participants: After the tutorial the participants will know how to write Java applications and applets, and how Java compares with other languages, particularly Ada.
 

Internet programming typically requires many disparate languages and technologies. This tutorial presents a unified approach for using Ada for both client and server-side Internet programming. Detailed information and many working programs are presented to teach Ada programmers how to build Java applets and CGI (Common Gateway Interface) programs in Ada
 

The tutorial will present the "object-based" constructs of Ada 83 (packages and private types), followed by the constructs of Ada 95 that support full object-oriented programming: tagged types and extensions, inheritance, class-wide types used for dynamic polymorphism and child packages for building hierarchial subsystems. The presentation is built around a large case-study: discrete event simulation.

The intended audience is software engineers with elementary knowledge of Ada or with extensive experience in other languages for OOP, who are interested in learning the Ada 95 constructs for OOP. No specific experience in Ada will be assumed. Participants can expect to come away with a full understanding of the conceptual foundation of the OOP constructs in Ada 95 and how they are used.
 

The morning tutorial is designed to introduce the Texel/William OO process, which provides technical project infra-structure that comes from process (parts, phases, activities and steps) , products (including a precise definition of product content), and metrics (including a precise definition of project progress metrics and project content). The OO methodology presented is notation independent, iterative, incremental, and based on use cases. 
 

This tutorial will introduce the SEI Personal Software Process (PSP). PSP is a self-improvement process designed to help programmers control, manage, and improve the way they work. Properly used, PSP allows developers to gather and interpret their historical data to better make and meet commitments, and also to improve personal quality. It can also be used to made the routine elements of your job (not just code development) more predictable and efficient. No experience with a particular programming language is required. The only requirements for attending this tutorial are experience in either code development or project management. After attending this tutorial, attendees will see the benefits of PSP on both a personal level and from a managerial perspective.
 

The afternoon tutorial is a presentation of sample tailorings of the process from real project experience. Experience in a programming language is not required. Experience in project management or OO design or architectural design would be beneficial.
 

The tutorial will explain, how you can build your own development and program analysis tools when working with GNAT. The existing GNAT toolset and different approaches to tool development will be presented. One of the tool development technologies, ASIS (the Ada Semantic Interface Specification), will be discussed in details. The discussion will include presenting of some existing ASIS-based tools and of the ASIS implementation for GNAT.

Description of the topic:

GNAT is the fully-validated multi-platform industrial-strength Ada 95 implementation. It already includes a number of tools to be used in program development process, and it also gives various possibilities to develop your own tools. One of these possibilities is the implementation of the ASIS Draft Standard for GNAT. ASIS is an interface between an Ada environment and any tool requiring information from it. ASIS has been designed to be independent of the underlying Ada environment implementation, thus supporting portability of software engineering tools and providing a set of high-level abstractions for tool development. The tools to be considered at the tutorial include, but are not limited to library management tools, metric tools, style checkers, code optimization tools etc.