ACM SIGAda Ada Letters

Brosgol, Benjamin M.

doi: 10.1145/291712.291752pmid: N/A

Java has entered the software arena in unprecedented fashion, upstaging languages and technologies that are longstanding players in the industry. Almost unheard of before 1995, the language and its surrounding technology are attracting increasing attention not merely in the hardware and software communities but also among lay users and in the popular press. This phenomenon has not escaped the attention of academia, and a growing number of colleges and universities are looking at Java as a candidate "foundation" language on which to base computer science curricula.This paper looks at the role of a programming language for teaching computer science courses and compares Ada and Java against the identified criteria. It concludes that Ada is the superior choice, based on technical factors such as its more comprehensive feature set and its methodology-neutral design, and also taking into account external factors including the availability of good but inexpensive compilation environments.Section 1 provides a brief overview of the Java technology. Section 2 identifies the criteria relevant to choosing a programming language for a foundation-level Computer Science course. Section 3 compares Ada and Java with respect to the criteria related to technical aspects of the language, and Section 4 compares the languages with respect to external factors. Section 5 summarizes the conclusions of this analysis.Appendix A furnishes a summary of the Java language. It is assumed that the reader is familiar with Ada, and thus an Ada language summary is not included. Web sites with links to Ada information include SIGAda, Kempe 1 , and AdaIC.

Heinfeld, Blaine W.; Silver, James L.

doi: 10.1145/291712.291753pmid: N/A

This paper describes a software engineering training program that targets personnel with skills in other engineering disciplines. This intensive nine-week program was designed in the fall of 1995. It was offered three times during 1996 and 1997 with modifications that incorporate lessons learned from previous sessions. We will describe key features of the program, give an overview of its implementation, report on our experiences with graduates of the program, and note lessons learned.

Carlisle, Martin C.

doi: 10.1145/291712.291754pmid: N/A

Students find computer graphics one of the most interesting topics in computer science. Unfortunately, writing programs with graphics requires understanding concepts that are usually beyond the scope of an introductory computer science course. For example, in Windows 95, a program that uses graphics must have an event loop that dispatches messages to the appropriate handler. Event loops, messages and handlers are well beyond the grasp of someone just learning about variables! As a result, programming assignments for introductory courses tend to use no graphics, or simple ANSI graphics (see, e.g. Feldman and Koffman 1). These programs compare unfavorably to the graphics of games most students are accustomed to using, and motivation to program in an introductory course may be lost.Ideally, we would like to be able to have students write programs that have more appealing interfaces, yet do not require a large amount of additional conceptual complexity. In fact, the best case would be to have the student write a program as if it were a simple text-based program, and have the compiler automatically add a graphical interface. Languages that provide overloading, such as Ada 95, allow us to accomplish precisely that.This paper describes a library, Graphics_110 (named in honor of our introductory course), which, using overloading, replaces the standard I/O libraries in Ada 95: Ada.Text_IO, Ada.Float_Text_IO, and Ada.Integer_Text_IO. By following a simple contract and replacing calls to the standard libraries with calls to Graphics_110, the student obtains a program, with a Windows-style interface without ever having to worry about the implementation details. Although we use Ada 95 for this paper, the ideas extend to any programming language that provides subtypes and overloading.The next section describes the "contract" the programmer must follow to use the library and the third section describes the implementation of Graphics_110. In each section, we describe how Graphics_110 was used with a battleship game implemented in our introductory course. The final section presents conclusions and ideas for future work.

Hendrix, T. Dean; Cross II, James H.; Teate, Joe C.; Barowski, Larry A.; Mathias, Karl S.

doi: 10.1145/291712.295792pmid: N/A

The idea that representing something visually can help us understand it has long been promoted in common practice and in the literature 1,2,3,4,5,6. Indeed, "a picture is worth a thousand words" has become a standard cliché in our culture. In the case of software, however, one must take great care that it is the correct thousand words that are being conveyed 5. Nonetheless, appropriate visualizations of software can be quite beneficial to programmers, especially when faced with program comprehension tasks. Such tasks exist throughout the software life cycle (e.g., formal technical reviews, debugging, verification, reverse engineering) and in the classroom (e.g., students reading examples from the text or examples from the professor).The GRASP (Graphical Representations of Algorithms, Structures, and Processes) research project at Auburn University seeks to develop tools and techniques for the effective use of graphical representations and visualizations of software. The overall goal of this research is to increase the efficiency of programmer comprehension and understanding of source code, and thereby decrease overall software cost. As an integral part of the research project, the GRASP software engineering tool has been developed as a continuously evolving prototype. The emphasis of the tool to this point has been on visualizing program structure and complexity via the automatic generation of Control Structure Diagrams (CSDs) and Complexity Profile Graphs (CPGs) from Ada source code 7. The current release of GRASP provides generation of CSDs and CPGs together with other program comprehension aids such as syntax coloring, typographical enhancements, and source code folding 8. When coupled with an appropriate compilation system such as GNAT, GRASP becomes an integrated graphical development environment for Ada 95, allowing users to edit, visualize, pretty-print, compile, link, execute and debug Ada software.The GRASP prototype for Ada was first made available to the public in January 1996. Since that time, thousands of copies of GRASP have been downloaded via anonymous file transfer protocol (FTP) and the World Wide Web (WWW) from educational, government, military and commercial sites, both in the United States and abroad. When it was released to the public, GRASP was also made available to users of the Auburn University College of Engineering computer network. GRASP is now used extensively throughout the computer science and engineering curriculum at Auburn University, in approximately three to five courses per quarter.

Kordon, Fabrice; Mounier, Jean-Luc

doi: 10.1145/291712.291755pmid: N/A

Software engineering methodologies rely on various and complex graphical representations and are more useful when associated to CASE (Computer Aided Software Engineering) tools designed to take care of constraints that have to be respected. Now, CASE tools gave way to CASE environments (a set of tools that have a strong coherence in their us). This concept provides enhanced solutions for software reusability while the environment may be adapted to a specific understanding of a design methodology.This paper describes FrameKit, an Ada based framework dedicated to the quick implementation of CASE environments. We summarize first the concepts implemented in FrameKit and illustrate them using a detailed example of a simple tool implementation and integration.

Riehle, Richard

doi: 10.1145/291712.295793pmid: N/A

The creation of reusable software components is an important part of modern software practice. Generic templates are one technique for designing these components. A generic template is a module containing algorithms which can operate on some class of data types where the specific data type is not known until later in the development process. Many languages, including Ada, support this technique. In Ada, generic templates must be type-safe at compile time. We examine some features of Ada which allow us to define the type as an entire package module and to instantiate with that module. The main theme of this paper will be generic formal package parameters.

Lupton, William; Stojkovic, Vojislav

doi: 10.1145/291712.291756pmid: N/A

The world is not a neat and well-ordered place. Incomplete and incorrect information is receiving each moment. Incompleteness arises because the world is inaccessible. Incorrectness arises because the world does not match its model. Complete and correct information is crucial in many situations where the success or failure of an operation depends of the quality of information. When the unexpected or unknown occurs, conditional planning, execution monitoring, or situated planning can help system to recover and get back on the right track. This paper shows how incomplete and incorrect information problems can be solved using conditional planning, execution monitoring and situated planning agents - intelligent knowledge-based software agents.

Needham, Donald M.; Demurjian Sr., Steven A.; McMahon, Margaret M.

doi: 10.1145/291712.291757pmid: N/A

Modeling object interdependency within an object-oriented application requires design-time mechanisms for specifying object interrelationships, as well as software constructs for the runtime maintenance of these relationships. In this paper, we present our technique for the design-time modeling of propagations (our term for the relationships between interdependent objects), with a focus on the concurrently executing portions of our propagation model. We examine our propagation model as implemented using Ada95's tasking constructs, and present the source level mechanisms through which our model achieves concurrency. The concurrency embedded within our approach to propagation modeling allows the development of software applications that more fully utilize environments supportive of multi-tasking.

Davis, Noël; Ransbottom, Scot; Hamilton, Drew

doi: 10.1145/291712.291758pmid: N/A

Modern computer scientists need to understand both the theoretical and practical aspects of computer networking. As computer science teaching methods continue to mature, experiences in mixing theory and application have been shared in the community Marti 96. While the literature is rich with experiences in applied or project based courses in artificial intelligence, architecture, software engineering, data structures and algorithms, few have addressed the challenge of coordinating theory and practice in computer networking courses.Combining theory and practice in a single course on computer networks is difficult because of the complexity and scale of modern networks. Classroom modeling of networks is a technique to illustrate the theoretical aspects of networking through practical models of computer networks. At West Point we are evolving our network course to use network modeling and simple simulation as a visualization tool to show how networks operate and the performance tradeoffs associated with network design decisions. This approach provides the opportunity to do more than teach an undergraduate survey course in computer networking.

Shing, M.; Berzins, V.; Holden, M.; Eagle, C.; Luqi,

doi: 10.1145/291712.291759pmid: N/A

This paper describes the distance learning Software Engineering Master's program offered at the Naval Postgraduate School and presents the lessons from its first class. The program differs from the other software engineering programs in two ways: (1) the curriculum is developed specifically to meet the needs for formal software engineering education for DoD software practitioners with an undergraduate computer science degree and at least two years of software experience, and (2) the program is offered totally via distance learning. The curriculum builds upon the students' scientific knowledge in computer science from their undergraduate education and the insight into software problems from their working experience. It introduces students to a set of engineering practices that enable ordinary practitioners to create sophisticated software systems that work, and teaches students the principles and methods for managing the software development processes.