Printer Friendly

Ada experience in the undergraduate curriculum.

This article assesses the current state of the Ada language as used in computing curricula, with particular reference to undergraduate computing programs. The main points discussed in this article are:

* Use of Ada in the universities and colleges is growing slowly but monotonically. Perhaps 10% of academic institutions teach Ada in at least one course of some kind.

* We have identified 48 institutions in which Ada is introduced as the language of the first course and 31 more in which Ada is introduced in the second or third course, still early enough to propagate through the upper-level curriculum. These numbers have grown slowly each year for the last 10 years.

* Of the institutions using Ada as an important language in their programs, most can be considered teaching rather than research institutions, and most have no particular ties to the federal government.

* Of the institutions that have attempted Ada recently at the introductory level, we are aware of only one (a two-year college), that gave it up for another language. In schools that give Ada a serious attempt, teachers and students generally react favorably and tend to stay with it.

* Fourteen textbooks are currently available that use Ada as their language of discourse and are oriented to specific undergraduate courses. Six of these are suitable for use in a CSI-level introductory course with no programming prerequisites. Several more are nearing completion.

* Of the more than 250 Ada compilers holding government-based validations, most are still rather expensive, even after typical academic discounts. However, enough affordable systems are available for typical academic computing platforms to enable institutions to license them for fees well within their budgets.

* With the recent release of New York University's Ada/Ed for free distribution, it is now feasible for teachers to distribute, at no cost to their employers or their students, a quite robust personal Ada system that appears to be adequate for any reasonable introductory course sequence. A compiler to be included in the Free Software Foundation distribution is under development at New York University with Ada 9X Project funding; release is planned for 1993.

The remainder of this article is organized in four sections: Institutions in which Ada is taught; Ada-related textbooks suitable for undergraduate courses; Ada compilers on the campus; and First-person profiles of institutions in which Ada is important.

Institutions in Which Ada is Taught

During the summer and fall of 1991, the Ada Information Clearinghouse (AdaIC), operated by IIT Research Institute under contract from the Ada Joint Program Office (AJPO), conducted a survey to develop version 6.0 of the Catalog of Resources in Education and Software Engineering (CREASE). Over 3,400 survey forms were mailed to institutions of higher education, using ACM and other mailing lists. Copies of the survey were also distributed electronically, and at various conferences.

Over 650 responses were received from 576 different institutions. Over 500 responses were from four-year colleges and universities. The remainder were from two-year colleges, technical schools, training companies, and Department of Defense (DoD) schools. Ada is even taught at two high schools. Two hundred and six responding institutions teach courses in Ada. Course content varies. Frequently reported are pure "language" courses intended to teach Ada syntax and semantics to advanced students; comparative languages courses; project courses in software engineering or real-time systems.

Table 1 lists degree-granting institutions reporting that Ada is the primary language of instruction in their undergraduate computing programs, introduced in their equivalent of CS1. Table 2 shows institutions reporting that Ada is introduced for the first time in the second or CS2 course, or in the third or Data Structures course. We have assembled these tables using CREASE data as a starting point, augmented by a number of institutions, especially those outside the United States, that are not found in the CREASE volume. Information on the non-CREASE institutions came from various sources, including publishers' textbook adoption lists and email communications with faculty. Some information came from the so-called "Reid Report," an informal electronic list maintained by Richard J. Reid of Michigan State University, which categorizes computer science programs according to the language taught in the first course.

It is difficult to collect this kind of data, given the diversity of institutions of higher education and the lack of central reporting services on such issues as programming languages. We have done our utmost to make the tables complete and verifiable, and apologize for errors of commission or omission that may have crept in.

It is obvious from Tables 1 and 2 that many different kinds of institutions are represented: large and samll, public, private, and religious-affiliated, geographically dispersed. It is equally obvious that with only a few exceptions, these are primarily non-Ph.D.-granting teaching institutions with no particular connections to the federal government or, in particular, the DoD.
Table 1.  Undergraduate institutions in which Ada is apparently
the
first language studied by entering majors
Allan Hancock College, California
Birmingham Southern College, Alabama
California State University, Long Beach
California State University, Northridge
California Polytechnic State University, San Luis Obispo
Chalmers University of Technology, Sweden
Conservatoire National des Arts et Metiers, Paris, France
Cranfield Institute of Technology, United Kingdom
Cypress College, California
Embry-Riddle Aeronautical University, Florida
Florida Institute of Technology
Fayetteville State University, North Carolina
Flinders University, Australia
The George Washington University, Washington, D.C.
Indiana-Purdue University, Ft. Wayne
Jerusalem College of Technology, Israel
LeMoyne College, New York
Marion County Technical Center, West Virginia
Marshall University, West Virginia
Muskingum College, Ohio
Norwich University, Vermont
Oklahoma City University
Otterbein College, Ohio
Phillip Institute of Technology, Australia
Portsmouth Polytechnic, United Kingdom
Saint Mary College, Kansas
Sam Houston State University, Texas
San Diego Mesa College, California
South Bank University, London, United Kingdom
Southern Arkansas University
State University of New York at Plattsburgh
Stockton State College, New Jersey
Swinburne University of Technology, Australia
University of Adelaide, Australia
University of Aston, United Kingdom
University of Bradford, United Kingdom
University of Canberra, Australia
University of Dayton, Ohio
University of Lancaster, United Kingdom
University of Liverpool, United Kingdom
University of New Orleans
University of South Dakota
University of South Florida
University of Stafford, United Kingdom
University of Wales, Aberystwyth, United Kingdom
University of Washington
University of York, United Kingdom
West Virginia University


Also apparent is that not all the service academies are represented, nor are most of the major research universities. Many of the latter institutions teach courses using Ada, but they do not introduce Ada in the first year, or consider Ada to be more than just one of a number of languages studied. We can only speculate on the reasons for these schools not using Ada. Anecdotally, we infer that "political correctness"--aversion to Ada's DoD origins--plays a role in some places. Equally anecdotally, we have come to believe that many more schools avoid Ada out of ignorance about its possibilities, or for purely inertial or economic reasons, than disdain it on ideological grounds.

Ada-Related Textbooks Suitable for Undergraduate Courses

Many dozens of textbooks and monographs involving Ada have appeared since Ada's announcement in 1979. The vast majority of these books have been of two types:

* texts oriented to upper-level undergraduates and graduate students, covering topics such as concurrency and software engineering

* texts aimed at the "conversion market"--experienced programmers in industry wishing to learn the language without what they perceive as undue pedagogical baggage

For quite some time, teachers wishing to introduce Ada to first-and second-year undergraduates were frustrated by the lack of texts for that purpose; particularly lacking was material combining the Ada language with the conceptual and pedagogical elements most teachers expect in books for CS1 and CS2.

The last several years have seen a change in this unfortunate state of affairs. This section summarizes the current situation; a further reading list at the end of this article organizes Ada reference texts into three categories.

Textbooks for the First-Year Computer Science Courses

Six recently published texts are written specifically to support CS1-level courses; an Ada supplement exists for a language-independent CSI text. At least three more texts at this level are known to be nearing publication. One older text introducing Ada at the level of CS2 and data structures is under revision, an Ada supplement has appeared for a language-independent data structures text, and several more books at this level are said to be "in the pipeline" for publication in the next year or two.

Several of the new introductory texts are based, in whole or in part, on successful works that use Pascal or Modula-2; author teams of an introductory-text expert and an Ada expert are increasingly available. As a member of such a team, this writer can confirm from personal experience that the discussions among authors regarding the details of adapting traditional CS1 and CS2 pedagogical material for Ada are stimulating to all concerned, and beneficial both for introductory courses and for Ada. Ada is a very powerful vehicle for implementing the evolution of CS1 and CS2 courses to heavier emphasis on modules and systems, rather than monolithic programs, from the beginning of the learning process.

Table 2. Undergraduate institutions in which Ada is first introduced in CS2 or Data Structures Briar Cliff College, Iowa California Polytechnic State University, Pomona California State University, Fullerton College of West Virginia, Beckley Daniel Webster College, New Hampshire Florida International University Gallaudet University, Washington, DC Georgia State University Indiana University, New Albany Lenoir Rhyne College, North Carolina Mesa State College, Colorado Monterey Peninsula College, California Murray State University, Kentucky National University, California Northern Arizona University Northern Kentucky University Northeast Missouri University Oglethorpe University, Georgia Ohio University, Athens Pennsylvania State University, Harrisburg Portland State University, Oregon Rose Hulman Institute of Technology, Indiana Southwest Baptist College, Missouri Shippensburg University, Pennsylvania Swiss Federal Institute of Technology, Lausanne United States Air Force Academy, Colorado University of Alaska, Fairbanks University of Missouri, Columbia University of Richmond, Virginia University of Scranton, Pennsylvania Western New England College, Massachusetts

Textbooks Supporting Upper-Level Undergraduate Courses

In addition to these texts supporting the first two or three courses, there are a number of other Ada-related books specifically targeted to classical computer science courses, or at least organized so they can be used in such courses. Courses currently supported by texts in which Ada is used prominently or exclusively include advanced data structures, file structures, algorithms, compiler construction, comparative languages (including object-oriented languages), and concurrent programming. The reader is referred to the further reading list for details.

Many of these books, including most at the CS1/CS2 level, are augmented by software distributions, typically in diskette form, for immediate use by the individual student or at least for distribution by the teacher. This is a welcome trend in education. It reduces the amount of keyboarding a student must do, and makes it possible for many introductory projects to be "enhancement" exercises involving the modification of existing correct code instead of its production from scratch. Since an Ada text will typically introduce a fair number of reusable packages, diskette distribution leaves teacher and student alike with a useful software library, in machine-readable form, to be exploited in subsequent courses.

In summary, the large number of texts in production, and published recently, indicates confidence among authors and publishers that Ada is here to stay and collegiate use will increase.

Ada Compilers on the Campus

We know from surveys and from textbook adoption data that Pascal is still squarely in first place among languages for introductory computing courses. Given the extremely poor standardization of Pascal implementations, we infer that portability is not an important issue in computer science departments. Given the disparity of equipment to be found on most campuses, we are puzzled by the apparent lack of focus on this issue in departmental curriculum committees. Because of the strong Ada standard, Ada programs, especially those that do not use explicit system calls or machine-specific features such as graphics, display an extraordinarily high degree of machine independence. This is an important benefit: Students and teachers are not required to learn a new language simply to move from a personal computer to a workstation or central system. We see evidence that many faculty members are simply not aware of the reality of Ada program portability, which is discussed in a 1992 SIGCSE conference paper by the author [3].

Informal discussions with faculty members around the U.S. reveal three persistent perceptions about Ada's viability on the campus: * Ada compilers are not very reliable * Ada compilers require unacceptably high machine resources * the price of Ada compilers is simply too high for the institution's software budget to absorb

Reliability

Early releases of Ada compilers--as with their immature counterparts for other languages--were often bugridden. Each bug in an Ada compiler came as an unwelcome surprise to users who believed that validation--correct behavior according to a finite set of tests--somehow guaranteed perfection. In fact the Ada Compiler Validation Capability (ACVC) was not, and cannot be, revealed wisdom; it was--is--just a set of test programs. The ACVC has evolved, and the compiler developers have expended great effort to perfect their products.

At the present time, there are occasional bugs reported, usually from the same sort of subtle interactions between features that plague compilers for any language with many features. One bug is one too many for a critical project in industry; on the other hand, student programs rarely encounter compiler bugs anymore. Moreover, the strength of the validation process ensures that unless the program uses easy-to-identify machine-dependent features, all validated compilers will yield executables with similar behavior. All currently available Ada compilers are validated.

Machine Resources

There is no denying that Ada is a larger lanuage than C or standard Pascal, and one in which intermodule consistency checking is of prime importance. Ada compilers therefore need to do more than Pascal or C compilers. On the other hand, teachers of Ada know that an Ada program, once compiled successfully, is quite likely to execute successfully or at least abort on a well-defined exception propagating through a well-defined call chain. Ada programs do not terminate with "bus error--core dumped" messages.

The increased resources invested at compilation time are therefore recovered at execution time: Debugging is easier and therefore more economical of machine time and space. Executable programs are often larger, but no longer inherently slower, than comparable executables from Pascal or C compilers. In a student environment, the increased size of executables is attributable in large part to a combination of run-time checks and "dead code" linked in by code generators. Code optimization can often reduce program size, but reducing the size of a student program is often not worth the extra machine resources required.

Not to be ignored is that compiler validation emphasizes correctness--conformance to the standard--and not performance. An old saw has it that "it's easier to make a correct program fast than a fast program correct." Given that Ada compilers were required to be validated in order to be "legal"--and still must be validated if they are to be used for government work--it is easy to see why optimization was originally a secondary concern. However, Ada compiler developers have invested heavily in their optimizers, and benchmarks have shown that optimized Ada executables often perform comparably to, and sometimes better than, executables from compilers for other languages.

The availability of compilers that can run on minimally configured MS/DOS and Macintosh computers is an important breakthrough for education. Even on a medium-speed computer with as little as IBM of RAM, compilation time is tolerable, the more so because Ada's separate compilation facilities inherently avoid unnecessary recompilations. Student programs, which are usually interactive, generally run faster than the human eye can follow, and so "fast enough is fast enough."

Much of a compiler's activity calls for disk operations, especially on a desktop machine with minimal RAM. Therefore, compilation speed is determined more by hard-disk characteristics than by raw CPU speed. This observation is borne out by tests in which the compiler's entire file system is loaded into a "RAM disk"--compilation speed increases by several hundred percent. Now that a "minimal" desktop computer is an 80386- or 68030-based machine with several MB of memory, genuine performance problems with Ada compilers for these computers are past history.

To summarize, students, teachers, and academic lab managers need no longer fear that an Ada compiler will degrade performance and "bring the computer to its knees."

Ada Compiler Economics

The AdaIC survey reports that of all schools responding, 361 (63%) teach no Ada courses at all, yet 457 (83%) said that they would consider teaching Ada if a compiler were made available to them at no cost. Only 91 schools said they would not teach Ada. Needless to say, these numbers are not definitive because they represent only faculty conjectures on a survey form. On the other hand, we believe they are indicative of the economic disincentive to introduce Ada into the curriculum, caused by the historically high license fees charged by Ada compiler vendors. Even when the usual academic discounts are taken into account, Ada licenses for typical academic servers and workstations have been quite high compared to the cost of Pascal, C, C++, Modula-2, Lisp, and other languages. The popularity and robustness of the Free Software Foundation (GNU) systems for Lisp, C, and C++, which are distributed at no cost, are especially damaging to the case for Ada on the campus, especially in an era of very tight software budgets.

Nearly all Ada compilers were developed to support serious industrial software development, specifically for government projects in which rapid bug fixes are essential. Compiler vendors assert that the cost of developing and supporting a validatable compiler demands a high license fee. This is small consolation to a college with a limited software budget: an 80% academic discount on a fee of $20,000 is still $4,000. It is easy to understand that a faculty faced with such a high fee will choose instead to forgo Ada.

Several compiler vendors, notably Alsys, Meridian, and RR Software, have responded in several ways to very recently, C was the language most students selected. Now, largely because of the investment in learning Ada most students make prior to taking data structures, Ada is becoming more popular as well. We are informally seeking to assess the ways in which Ada and C help (or hinder) student programmers in the class.

In the master's curriculum Ada has had at least two positive impacts. It has directly affected our introductory Structures of Programming Languages course, where it frequently shares center stage with C++. Ada has also played a positive role as the language of emphasis in recent instruction in software engineering.

It is probably fair to say that OCU's computer science faculty is largely C-oriented--especially in the master's program. The commitment to Ada made in the undergraduate curriculum was based on our premise that an emphasis on Ada first and then C would make a more effective use of student time and money than an approach starting with Pascal (our strategy before the selection of Ada). The results of the switch from Pascal to Ada have been largely positive; however, the role of Ada at Oklahoma City University will be continually reevaluated in terms of changing departmental goals, as is true of every other aspect of our computer science curriculum.

State University of New York (SUNY) at Plattsburgh

John McCormick, Associate Professor, Department of Computer Science. SUNY at Plattsburgh is a liberal arts college with no engineering programs. We have around 5,500 undergraduate students. The Computer Science Department is a small department with six full-time faculty members and less than 100 majors. Ada was first introduced to the curriculum in a senior-level Real-Time Systems course in 1989. This is the capstone course of our Computer-Controlled Systems study option. In the course, students write software to monitor and control a large model railroad.

Until the 1991-92 academic year, students did not have any prior experience with Ada. They came with Pascal or Modula-2 as their primary language. During the first four or five weeks of the semester we devoted extra class sessions to teaching Ada. The computer-controlled model railroad provided a strong incentive for the students to learn the language in a short time. By the end of the fifth week, students were fairly comfortable with Ada's basic features and the "advanced" features such as generic units, tasking, and representation clauses needed for their course project. The remainder of the semester was devoted to designing and implementing railroad-control software. Course projects with 5,000 to 15,000 lines of Ada code were produced by teams of two to four students.

Before 1989, the C language was used in the Real-Time Systems course. While statistics were not collected prior to the introduction of Ada, it is apparent that students produce working systems significantly faster with Ada than in the years C was used. Being able to devote more classroom time to software engineering issues and less to dealing with run-time problems encountered by novice C programmers has been a welcome change. Details on this course can be found in "A Model Railroad for Ada and Software Engineering," in this issue of Communications.

Because of the overwhelming success of Ada in the Real-Time Systems course and problems experienced with Pascal and Modula-2 in our Data Structures courses, the SUNY-Plattsburgh Computer Science department decided to select Ada as the primary language of our curriculum. Ada was taught for the first time in our CS1 course in the Fall 1991 semester and for the first time in our CS2 course in the Spring 1992 semester. Ada will move up through the rest of the curriculum over the next few years. While we did not expect or receive any major benefits from this choice in the CS1 course, we are pleased to find that Ada is not, as some had feared, more difficult to teach than the "simpler" languages taught previously. In fact, many of Ada's features simplified problems encountered with Pascal and Modula-2. We eagerly anticipate a payoff in courses with large programming projects similar to the one we received in the Real-Time Systems course. We also anticipate even better railroad projects with students entering the course with an Ada background.

University of Adelaide, Australia

Michael Oudshoorn, Lecturer, Department of Computer Science. Ada replaced Pascal as the principal teaching language within the Department of Computer Science in January 1990. Since that time, Ada has been used exclusively in the first and second years of the degree program. The third- and honors-year students also tend to employ Ada unless there is a need to use another language (for example SISAL in the functional programming course).

First-year students are introduced to most of the language, leaving generics and tasking until the second year. The switch to Ada was relatively painless and certainly beneficial. Students are able to better cope with the control mechanisms, parameter-passing mechanisms and function value return in Ada than they were in Pascal. The consistency offered by Ada over Pascal has also made life simpler for the students.

Ada's library management facility has helped make it easier to teach good software engineering principles from the beginning rather than teaching students to write monolithic Pascal programs.

The major programming-related subjects in the first two years of the undergraduate degree are:

* Introduction to Computer Science. This first-year course has a class size of 200, and uses the CS1 text by Bover et al.

* Introduction to Programming and Applications. This first-year course has a class size of 90, using the same text.

* Concepts of Computer Science. This first-year course has a class size of 90, using the same text.

* Programming and Data Structures. This second-year course has a class size of 200, using Barnes; Booch's books are used as references.

In addition to using Ada as the undergraduate teaching language, the department also offers professional development courses to defense personnel and defense contractors in Adelaide. These courses are one-week intensive training sessions and are highly praised by those attending. Many people have commented that Ada is not as large or as messy as the "folklore" would have them believe.

University of Liverpool, United Kingdom

Michael J.R. Shave, Professor, Department of Computer Science. We have been using Ada as the first teaching language for our computer science students for the past four years (having previously used Algo168!). Prior to changing to Ada, some critics said it was far too complex a language for students to cope with. However, I am pleased to say we have found it an excellent teaching medium, and even students with no previous experience in computing have had no difficulty in coping. Of course, we teach only a limited subset of standard features in the first term. At the other extreme, Ada is also a good choice for confounding and educating would-be "whiz kids" who have already used Pascal or Basic at school or on home computers--we have never yet had any student who has previously used Ada!

Ada remains the core language for subsequent modules in the degree program; it goes without saying that students gain experience in a wide variety of other languages as well--including Fortran, Pascal, Cobol, C, and Prolog.

The University of New Orleans

Jaime Nino, Associate Professor, Department of Computer Science. The University of New Orleans, created in 1958, is a Carnegie classification Doctoral II state institution with a strong undergraduate tradition and a complementary rapidly growing graduate program. This institution predominantly serves the educational needs of the New Orleans metropolitan area. Enrollment at UNO is approximately 16,000 students, making it the second-largest university in the state.

The Department of Computer Science, established in 1979, offers an accredited bachelor's degree in computer science. The department initiated the master's degree program in the fall of 1991. The department consists of 12 full-time faculty members and several adjunct instructors.

The computer science curriculum contains a sequence of three basic three-credit-hour courses in which software development is taught:

* Introduction to Computer Science introduces the student to computer science in general and software development in particular. The goal of this course is to present the fundamentals of program development using a modern programming language.

* Structure of Algorithms emphasizes software design, verification, and testing.

* Data Structures focuses on data type specification, design, and implementation.

The decision to adopt Ada was made within the context of a curriculum restructure finalized in the spring of 1984. Pascal had been used as the main programming language since 1974. Shortcomings of the language in adequately supporting the teaching efforts were identified during this period, convincing us we had reached and exceeded the limits and possibilities of this language. In the spring of 1984 the department chose Ada as the primary programming language to be used throughout the entire curriculum. One advantage of Ada is its adherence to a standard and the compiler validation program. An additional advantage of Ada is its design characteristics as a programming language supporting tasking and the principles and methodologies developed in software engineering.

Ada was phased into the curriculum, course by course, starting in the fall of 1984. In subsequent years the use of Ada was expanded to upper-level junior and senior courses such as File Processing, Programming Languages, Compiler Design, Analysis of Algorithms, Operating Systems and Data Models and Software Engineering.

We currently teach Ada to approximately 400 students per year in the three basic courses and File Organization.

Positive experiences using Ada:

* It supports modern software design to include reusability, team programming, information hiding, separate complication.

* Good compliers are available: we have used Dec-Ada since 1986. Students are buying OpenAda for their PCs.

* Good textbooks. We currently use Feldman and Koffman.

* It supports the entire curriculum, providing a uniform environment for teaching.

* Students will be provided with a better foundation and knowledge of software design and implementation.

Negative experiences using Ada:

* Instructors must redesign teaching methodology to teach Ada and its power effectively. Pascal style and methodology do not carry over to Ada.

* Basic language constructs take longer and are more complicated to teach than basic language constructs in Pascal. Thus, first and second programming courses require more effort from the instructor, but these extra efforts will be beneficial.

* It is useful (required?) to have a mature library of software units.

University of Wales, Aberystwyth, United Kingdom

Fred Long, Lecturer, Department of Computer Science. The Department of Computer Science at the University of Wales, Aberystwyth, UK, chose Ada as the main programming language in 1986. The undergraduate curriculum is firmly oriented toward software engineering and Ada is a very good vehicle for teaching good software engineering practice.

The first-year class usually has about 70 students, but not all of them graduate in computing. Usually, about 50 students graduate each year in single or joint honors computer science. The first-year course concentrates on program design, and the high-level structuring facilities of Ada are taught with good results. The University of Wales system requires that students spend only one-third of their time studying computer science in their first year. They must spend another one-sixth of their time studying a mathematics course designed specifically for them. The remaining half of students' time is spent on a subject of their choice--accounting, mathematics, physics, and information science are common choices.

In the second year, one core course concentrates on programming and algorithm design. Generics are taught in detail (students are introduced to generic instantiation in their first year so they can use input/output routines). The main thrust of this course is the concept of abstract data types, and Ada is an ideal language in which to teach this. Another core course discusses concurrency, and Ada tasking is taught here. Software engineering concepts are also taught in the second year and Ada is used to reinforce the ideas. There is a "group project" in which students are required to produce a piece of software (in Ada) working in groups of about six students. The emphasis is on working as a team: management, planning, communications.

Students are introduced to other programming languages in their second year--there is a "case studies" course in which they are introduced to the C programming language (the emphasis here is on good software engineering practice) and they are taught functional language ML), familiarizing them with programming paradigms other than the imperative style of Ada.

The computer science undergraduate program is three years in duration, but many of our students spend a year in industry between their second and third years of study. They find the software engineering concepts learned in the second year very useful when they go into industry.

The third year of the program has one core course on advanced software engineering in which the students are introduced to project support environments and formal methods. There are a number of optional courses, including courses on artificial intelligence in which they use the Poplog environment and the Pop 11 and Lisp languages. A quarter of the third year is taken up with a major project. Projects are very varied but many are implemented in Ada.

Our experience with Ada as the main teaching language at the University of Wales has been good. Most important, student reaction has, on the whole, proved very positive and we are convinced that the quality of our courses has improved significantly as a result of the switch to Ada. The one serious difficulty we experience is that interfaces between Ada and other system software (such as SunView, X Windows, or the basic operating system calls) either do not exist or are mysterious, undocumented and bug-ridden. The result is, too often, that students who have spent two years of their course learning to write good programs in Ada have to resort to C for large parts of their final-year projects.

University of Washington Richard Pattis, Lecturer, Department of Computer Science and Engineering. The University of Washington enrolls about 33,000 students annually: 24,000 undergraduates and 9,000 graduate/professional students. It employs about 2,700 full-time teaching faculty.

The Computer Science and Engineering Department comprises about 30 faculty members, whose research interests include parallel computing (hardware and software), VLSI, theory of computation, graphics and vision, computer architecture, real-time systems, performance analysis, programming languages and compliers, and artificial intelligence (learning, planning, and model-based reasoning).

Our department enrolls about 125 new undergraduate majors each year (80 in the Computer Science program, administered by the College of Arts and Sciences; and 45 in the Computer Engineering program, administered by the Engineering College). Students must apply to enter our undergraduate degree programs. Of those that we accept, almost 100% ultimately graduate. UW is on the quarter system: classes meet for three quarters during the academic year. Some classes meet during the summer quarter. At the undergraduate level, our department currently teaches two premajor introductory courses, 14 courses restricted to our majors (the typical undergraduate major will take about 10 of these courses), and four courses open to nonmajors. We try to restrict enrollment in each majors' course to 40 students.

Prior to our adoption of Ada, we taught our introductory programming course in Pascal (prior to 1984) and Modula-2 (1984 to 1988). The switch from Pascal to Modula-2 was motivated by our desire to teach students how to decompose and build large programs by using software components, and to write such components in a general and protected way. The switch from Modula-2 to Ada was made for technical reasons: we felt that the increased overhead in learning many of Ada's powerful features (in CS1-CS2) would pay for itself in increased programmer productivity (in subsequent courses).

We began teaching Ada in CS1 in fall 1988; in winter 1988 we also began teaching Ada in CS2. Our switch to Ada in these low-level courses has had a domino or "trickle-up" effect in the undergraduate major. In fall 1989 (after students taking these two courses began entering the Computer Science major), Ada became the dominant language in our Data Structures course. Starting in fall 1990, Ada became the primary language used in Compiler Construction (where students modify a compiler written as more than a dozen packages) and began to be used in Operating Systems (where students learn about concurrency in general and Ada's tasking model in particular--they predominantly do their programming assignments in Ada).

During the fall 1990, our department spearheaded an effort to unify all of UW's introductory programming courses; as a result, effective with the Winter 1992 quarter, the Ada-based CS1-level course is required of all preengineering majors. Some Fortran is taught at the end of this course; a Fortran project is done which involves a translation into Fortran of an earlier project coded in Ada. The unification tripled the annual enrollment in this course, which is now over 1,000 students; enrollment in the CS2-level course is several hundred students.

Students are taught from the beginning that a project is more than just a correct program: Design, documentation, and test plan are important components of the graded work. Program sizes in the first course range in size from 100 or so lines to a final project of about 400 lines plus another 200 or so in imported packages. In the second course projects of at least one thousand lines' length, including a number of imported packages, are typical. Computer support for these courses currently is a fast DECSystem, running DEC and Alsys compiler products under ULTRIX. The CS1-level course has been using Ada/Ed on this system, because its speed of compilation, disk utilization, and quality of error messages make it--for programs of class-project size--superior to the commercial systems. Indeed, many CS2-level students used it in preference to the commercial compiler also available to them, and a number of students used the DOS version successfully on their home computers.

The consolidated CS1-level course has now been taught twice. A striking effect of the consolidation is that the course attracts a substantial number of upper-division students in nonengineering majors, including technical majors such as mathematics but also nontechnical ones such as sociology and French. Students of both types appear to fall on a similar performance curve; there is, in particular, no evidence that students in nontechnical fields find Ada more difficult than do their technical counterparts. Indeed, Ada does not seem to be more difficult for students than Fortran, whereas Modula-2 and Pascal were. The challenge for the teachers of this course is to give students who do not continue in another computing course a sufficiently balanced sampling of programming structures and techniques so they will not be lost if they need to write or read a small program later in their university careers. This is, of course, the challenge facing all teachers of isolated service courses in computing; it is made only marginally more difficult by the use of a language with Ada's richness.

As a result of the switch to Ada at the UW, many of the feeder community colleges--which need to provide an equivalent curriculum for the first two years of preengineering courses--are contemplating an early change to Ada in their own introductory programming courses.

University of York, United Kingdom

Ian Wand, Professor, Department of Computer Science. In our experience changing to Ada as a first language has been worth the effort. We have been teaching Ada to final-year undergraduates since 1986 as a specialized programming language for sophisticated software engineering. This short course for experienced programmers was assessed by the submission of a single program exercise which usually involved both tasking and graphics. Problems included a simulation which would detect the collision of ships crossing the English Channel and a maze-hunting game, including the 3D presentation of the view down a maze corridor.

By 1989 we had developed sufficient confidence in both the language and in our implementation to use Ada for all introductory teaching of programming. It has been used for all Computer Science first-year students since then. Our principal motivation for introducing Ada was to get language support for modern methods of program design and construction, particularly Abstract Data Types (ADTs).

All our students have had a sophisticated mathematical background, and most have had a similar background in physics. About 75% of our first-year class have some programming experience. Most of the new students come directly from secondary school; perhaps 10% have been in the workforce. On balance the older students find the course more difficult than the 18-year-olds.

The first-year students study programming, data structures and algorithms to the point where they can write programs of modest size (say, less than one thousand lines) and can make informed choices of both algorithm and data structure. They must also be able to test and document their programs in a considered way. the need for inexpensive compilers for academic Unix and VMS networks, and for individual desktop computers.

* An "industrial-strength" Unix or VMS compilation system--fully validated, with a useful set of support libraries, debugger, and development environment--can be licensed for as little as $600, with a small annual support fee.

* A student or teacher can purchase a full system for an MS/DOS or Macintosh system for $100 or less (much less in lab quantities).

* Both Digital Equipment Corporation and IBM make their Ada compilation systems available to academic computer centers, at little or no cost, as part of their academic software consortia.

No-Cost Ada Systems

In February 1992, New York University made its Ada/Ed translator/interpreter available for anonymous ftp at no cost. Source code in C for Unix and 80386/80486-based MS/DOS platforms is provided, as is a set of executables for the MS/DOS machines.

Our experience with this system has been that it is robust enough to handle not only all the programs in a typical CS1 or CS2 distribution, such as those described in a typical textbook, but also a number of concurrent programs including Portable Dining Philosophers [3]. Ada/Ed's validation is several years old at this writing, but most recent additions to the validation tests have been in the area of machine-dependent features that would not be supported in any case by an interpretive system.

Some readers may remember that the original Ada/Ed was developed in large part to be a test bed for the ACVC, and was designed to be rapidly modifiable rather than fast and compact. Indeed, Ada/Ed received the very first validation certificate in 1983. The current C-based version operates on current-generation MS/DOS platforms with compilation speed comparable to that of a commercial compiler, and interpretive execution which is "fast enough," that is, faster than the interactive user can type or understand displayed output.

It is therefore now feasible for teachers to distribute, at no cost to their departments or their students, a personal Ada system that appears to be quite adequate for any reasonable introductory course sequence.

The Unix version of Ada/Ed is also receiving considerable attention. For example, at the University of Washington in Seattle, Ada/Ed has been used on a large Ultrix-based DEC-System, as the Ada system supporting a first-quarter CSI-level course enrolling about 350 students. Ada/Ed was chosen over two commercial compilers mainly because its error messages are the most easily understood by beginners. Students, teachers, and system managers are all pleased that Ada/Ed compiles first-year student projects faster than the commercial compilers, and compiled output is compact. Interpretive execution also means that no large executable files are produced, and this is an important consideration for disk-poor academic laboratories.

One might question just why an Ada translator should be written in C. Since bootstrapping the translator to a new platform does not require an Ada compiler, distributing the source code in C is an advantage for schools that possess Unix computers but do not have an Ada compiler. Ada/Ed is now positioned to play the role many hoped it would play 10 years ago, namely providing a "starter" system to academic departments and individuals.

In June 1992, New York University announced it had contracted with the Ada 9X Project Office to develop a full Ada 9X compilation system to be made available at no cost, with source code, as part of the Free Software Foundation software distribution known as GNU C Compiler (GCC). This project is cosponsored by DARPA and AJPO; two phased releases are expected during 1993. This system is known colloquially as the GNU NYU Ada Translator, or GNAT.

The availability of source code for a translator is an important educational benefit. The compiler text itself is a very useful artifact, to be used as an example in research projects and advanced courses. More important is the fact that given source code, teachers and students can apply their ingenuity to "adding educational value." For example, we have received and distributed to students a working version of Ada/Ed for the Amiga family, for which until now there has been no Ada implementation. Projects are under way to enhance the DOS version, especially the run-time tracing capabilities, and to produce a version for the Apple Macintosh.

Ada/Ed and GNAT therefore serve an important educational purpose. Moreover, they relieve the pressure on commercial Ada vendors, who have focused their attention on industry and have not rushed to produce products tailored to the specific needs of education (fast compilation of small programs, friendly error messages, novice-oriented environments). Finally, the availability of a freely distributed Ada 9X system can serve to propagate Ada 9X through the educational system in the way that Lisp, Pascal, Modula-2, C, and C++ have propagated. This can only serve to hasten the acceptance of Ada 9X in both academia and industry.

First-Person Profiles of Institutions in which Ada Is the CS1 or CS2 Language

We have collected brief "first-person" accounts from faculty members responsible for integrating Ada in a number of institutions in the U.S. and elsewhere to convey to the reader the ways in which Ada is being integrated into undergraduate programs. Profiles are given, in alphabetical order, for the following college and universities:

* California State Polytechnic University, San Luis Obispo

* The George Washington University, Washington, D.C.

* LeMoyne College, Syracuse, New York

* Oklahoma City University, Oklahoma

* State University of New York at Plattsburgh

* University of Adelaide, Australia

* University of Liverpool, United Kingdom

* University of New Orleans, Louisiana

* University of Wales, Aberystwyth, United Kingdom

* University of Washington, Seattle

* University of York, United Kingdom

* West Virginia University

These institutions are representative of those in which Ada is introduced in the first or second course and propagated throughout the curriculum.

Several common themes run through these reports:

* Teachers and students do not find Ada significantly more difficult to learn and teach than alternative languages, and student reaction is generally favorable.

* Modern Ada compilers do not seem to put an undue load on the computers used for support, and large courses can therefore be handled.

* Ada propagates well through a computing curriculum, as students move from first-year to later courses.

* Even the first-year courses put a fairly heavy emphasis on principles beyond code correctness: design and user documentation, test plans, code style (the growing first-year emphasis on software engineering principles is hardly unique to "Ada schools").

* Faculties continue to be frustrated by the lack of student-oriented Ada development environments on the one hand, especially for the Apple Macintosh family, and by the lack of stable and well-documented bindings to now-standard application environments such as Microsoft Windows and X Windows.

In these brief sketches, textbooks are generally referred to by the name of the author--See the "Further Reading" list at the end of this article for publication information.

California State Polytechnic University, San Luis Obispo

Neil Webre, Professor, Department of Computer Science. Cal Poly uses Ada to support the concepts and theory of the first four quarters of coursework in computer science and computer engineering. (The two degree programs enroll 700 students.) Numerous students from outside these majors also enroll in these courses. The courses are CS1 (450 students annually) CS2 (350), Data Structures (250), and File Structures (150).

We chose Ada, after prior experience with Pascal and Modula-2, because its syntax is not arcane, it supports the object-based and object-oriented paradigms, it has a strong standard and is widely available, and it supports sound software engineering principles as well as ACM's Curriculum 91.

The change to Ada was made in the fall quarter, 1990. Unix was chosen as a common system environment. At this writing (winter 1992), we have just completed the phase-in period for Ada, having introduced it in each of the four courses in successive quarters. Another one-quarter sophomore fundamentals course uses C and C++ to support its instructional material--CS1 is a prerequisite for this course.

Ada has more than lived up to our expectations and met our objectives. It is a superb instructional language. Advanced courses in the upper division are beginning to receive students who have been through the fundamentals courses supported by Ada, C, and C++. Instructors of upper-division courses often allow students a language of their own choice to accomplish assigned projects. We expect significant use of Ada, but have no data yet. Some upper-division courses in networking and communications, real-time systems, and software engineering have used Ada as the primary support language.

The George Washington University

Michael Feldman, Professor, Department of Electrical Engineering and Computer Science. The George Washington University is a private institution in central Washington, D.C. Total undergraduate enrollment is about 5,000; total student population is around 16,000. The Department of Electrical Engineering and Computer Science, with about 40 full-time faculty members, offers accredited bachelor's degree programs in electrical engineering and computer engineering, and computer science; we have about 300 undergraduates. We also offer the master's, professional, and doctor of science degrees in various EE and computer science subdisciplines, and award about 100 master's and 10-20 doctoral degrees per year in computer science.

For many years, Ada has been the language of our undergraduate data structures course, at the level of CS2/CS7. Ada was used as the algorithm design language from 1981 to 1986, at which time it became the required coding language. This course enrolls as many as 200 students per year, including many graduate students who are making up undergraduate work or just using the course as a vehicle for learning Ada. Most students in this course use the Irvine compiler on an HP9000/835, a combination of a very fast compiler on a very fast machine. Many students own their own computers and have purchased Meridian compilers for them. The high degree of program portability afforded by the validation process is a definite asset here: projects can be assigned without regard for the compiler to be used by the students.

Student reaction to Ada as a coding language is generally favorable, once they have discarded some unfortunate habits--excessive reliance on global variables, deeply nested procedures--learned from the monolithic style of Pascal [2]. Reaction is quite mixed to the allocation of 70% of the project grade to design and user documentation, code style and aesthetics, and test plan. Students with outside programming experience tend to be more offended than the others at the notion that only 30% is allocated to whether the program actually executed correctly. Though we do not emphasize the term "software engineering," students soon realize software engineering principle and practice is an intrinsic and serious part of this course.

Ada appears explicitly in several other courses. The undergraduate and graduate compiler courses use the Ada-oriented Crafting a Compiler by Fischer and LeBlanc as the primary text. Student projects in both courses are often done in Ada, but students may choose the implementation language and some prefer to use lex/yacc/C. Most graduate students are required to take the comparative languages course (about 200 students per year) in which Ada is one of several languages taught and compared. Finally, the graduate course in concurrent programming heavily emphasizes Ada tasking, using as the main text Ben-Ari's Principles of Concurrent and Distributed Programming. Students study a number of languages in the course; projects can be in any language, and many students choose Ada.

A continuing development project is SmallAda, a compiler/interpreter derived (through many steps) from Wirth's Pascal/S. This system supports the "Pascal subset" of Ada together with a reasonably complete implementation of tasking. The DOS and Macintosh versions of this system allow students to observe tasking behavior by opening a window for each task in which the source code for that task is scrolled as it executes. A configurable task scheduler allows the user to select one of seven different task-scheduling algorithms. Controlled experimentation is being done to assess the effectiveness of this monitoring system as a tool for learning about, and debugging, concurrent programs. The SmallAda software has matured over five years as a series of student projects with no external funding, and has been distributed at no cost to well over 100 educational and industrial sites [1]. Work is under way to integrate the SmallAda user interface and monitoring facilities with Ada/Ed.

We have collected a fair number of Ada compilers for our Unix machines, and are trying to use our workstation lab in part as a neutral facility in which students can explore the user interfaces, performance trade-offs, and other capabilities of Ada systems on a level playing field. Given our Washington location and student demographics, we believe we can contribute well to the Ada community by providing this "compiler collection" for comparative study. We are also interested in acquiring various CASE tools for a similar purpose.

We believe that although comparing differences among compilers makes for very interesting advanced-level study, the similarities among them guaranteed by validation offer a very powerful reason for Ada being the main programming language. We have developed some programs designed to illustrate this, involving packages, tasking, and other Ada features; these have been tested on nearly every major compiler family and found to be entirely portable [3].

Our CS1-level course has traditionally been taught using microcomputers with extended Pascal dialects. Effective with the Fall 1992 semester, we are converting this course, and several of its successor courses, to use Ada instead. We believe the students will benefit greatly from using a single powerful yet standard language across several development platforms, and that eliminating the change of language in the data structures course will free student and teacher energy for more fundamental matters.

Le Moyne College

James Smith, Professor, Department of Computer Science. Le Moyne College is a small (approximately 1,900 students) Jesuit-sponsored four-year coeducational institution located in Syracuse, N.Y. The college seeks to combine an extensive humanities-oriented core curriculum with strong majors in arts, sciences, and business. The major in computer science began in 1979, and, as has been the case elsewhere, the number of students selecting this program has declined over the final years of the 1980s and into the current decade. At present, the department has four full-time faculty members. Like most small institutions, Le Moyne operates with considerably limited resources. Computer science instruction is supported by the college's VAX/VMS system, some IBM PS/2 microcomputers, and a MicroVAX II/ULTRIX system. The Ada capabilities consist of a DEC VAX compiler and Meridian software for the microcomputers.

In the early 1980s, juniors in the computer science major were required to take a course called Projects in Programming, in which they were required to learn almost entirely on their own a language unfamiliar to them (initially Fortran) and use it to implement a semester-long project by working in programming groups. In the Spring 1987 semester, this course was succeeded by Software Engineering Project, in which the students learned much (though by no means all) of Ada, and applied it in a team software development setting.

In the Fall 1987 semester, Le Moyne began using Ada as the principal language of its computer science major, with students starting it at the beginning of their freshman year in the courses ACM designates as CS1-CS2. Since that time, Ada has expanded upward through the curriculum, and as of the 1990-91 academic year, Le Moyne has had no computer science majors who began their program at the college with a language other than Ada.

In initiating the original elective course, the department was taking account of the future employment needs of its majors, as well as the immediate needs of continuing education students in the region. The main reason, however, for the introduction of Ada in this case, and indeed the exclusive reason for its subsequent adoption in the mainstream courses of the major (starting with CS1) was the programming features of the language itself. Here was a language in which the concepts and constructs of up-to-date programming methodology could be directly implemented. The key to this changeover was the realization that there is no need to teach an entire language in a semester--or even in a year. The students get acquainted with most of Ada in the first year; however, concurrency and low-level features are left for later.

From its fall 1987 inception, the Ada-based CS1 course has included such Ada features as packages, exception handling, unconstrained array types, and generics. The CS2 course itself consists mainly of traditional Data Structures material, including access types and recursion, presented in Ada fashion. Abstract Data Types provide a good setting for taking up private types and information hiding, and there is plenty of room for developing standard data structures in generic packages [4].

The Software Engineering Project course continues to call for coding in Ada, although students now come to this course well versed in Ada, having covered all but some of the low-level features of the language. File Structures, a sophomore course, is now taught with Ada as its language of implementation.

It was the original intent of the department to introduce tasking in the course on Operating Systems, since it is at that point that the concepts of concurrency and process synchronization have traditionally been acquired. However, since Ada permits dealing with concurrency at the language level, without explicit attention to that of the operating system or hardware, tasking is now presented and used in the File Structures course.

Ada also appears in the courses in compiler writing and computer graphics. In the former course, C is not entirely abandoned, and lex and yacc are employed. In support of the graphics course, a departmental faculty member has developed an Ada package of fundamental graphics routines for the PS/2 microcomputers. This package makes some use of ROM-BIOS interrupts for procedures that are not time-critical (e.g., changing mode, setting colors), but its basic routine for drawing a line segment (including a point, treated as a degenerate segment) calls assembly code for direct access to appropriate registers and latches, yielding speed equivalent to that of Turbo Pascal or Turbo C++. With this package at hand, students may then develop their own Ada graphics packages for various figures, for fill, for windowing and clipping, and so on [7].

Student reaction to the use of Ada throughout the curriculum--in particular, in CS1-CS2--has been favorable. It has been no more difficult to teach these courses with Ada than with Pascal. If anything, many programming concepts have been easier to implement, and students appear to have no more difficulty using Ada than did their predecessors who used Pascal. Undoubtedly, it would be possible to overwhelm freshmen with Ada by insisting on more syntactic intricacies than they need to know at a given time; however, this can readily be avoided. Finally, students are happily unaware that what they are being asked to learn is considered by some computer science educators to be "impossible."

The reaction from professionals in computer science and computer science education is that Le Moyne's approach has been both too radical and too conservative. Those computer science educators who are holding firmly to Pascal consider the idea of teaching first-semester freshmen about exception handling, packages, and generics is really "far out." On the other hand, some members of the software engineering community seem to think that if the very first computing concept/construct offered to freshmen is anything other than a package, things are off to a bad start.

Oklahoma City University

Larry Sells, Professor, Department of Computer Science. Although the undergraduate computer science faculty at Oklahoma City University had discussed the possibility of switching to Ada as the language of choice for its CS1 and CS2-level courses for over a year previously, a starting point for our serious involvement with Ada was fall 1989, the first semester in which our course called Ada was offered. This experimental course was designed to give staff and students the opportunity to try out our new VAX Ada compiler and to learn something about how easy or difficult Ada is to learn.

The initial experiment was successful enough that the department made the commitment to teach Ada in CS1 and CS2, and by fall 1989 all incoming students were required to take our introductory one-year sequence using Ada. Since then we have been averaging about 90 students and 70 students per year, respectively, in the two courses.

We are still trying to assess the impact of Ada on both our undergraduate and master's curricula. In the undergraduate curriculum, the biggest impact of Ada so far has been in its relationship to data structures. Our approach is to teach this course as a concepts course rather than a language class, allowing students to program in Ada, C, or Pascal. Until The course is run over three terms (23 weeks) with courses on programming and algorithms' data structures intermixed and taught by two different lecturers. There are weekly problem classes supervised by a third lecturer and graduate demonstrators. The students produce weekly assignments and submit documented solutions to two large problems.

The course is assessed by an examination taken in the seventh week of the third term plus the second documented program. About 10% of the students fail the course--a figure that seems quite independent of the programming language used.

The textbooks we recommend are Skansholm, Barnes, and Sedgewick's Algorithms. The Booch components book is also referenced. Students with no previous programming experience find Skansholm essential.

Subsequent course units, in the second and third years of the program, deal with parallelism, real-time programming, software engineering, including a team project, and with other nonimperative programming paradigms. They also cover a range of more formal topics, including mathematical techniques for specification.

Our experience with Ada has been positive. Students find it no more difficult than Pascal and find the separate compilation facilities, and the integration with Unix 'make' in our system, a definite advantage. Furthermore, it gives them a much better grounding for later courses. On the negative side our Ada compiler, though much faster than most others we know, does take longer than compilers for simpler languages. This sometimes causes frustration near deadlines. An increasing number of our students have their own computers, and move source files readily between their PCs and our systems. Ada's portability has been invaluable. We have rarely had difficulty with moving programs between the two environments, although the modest capacity of some PC-based Ada compilers can be a barrier to more complex programs, even at the first-year student level.

In summary, Ada has been a positive step forward in the teaching of programming and software engineering. At the moment we Ada enthusiasts are holding our own against the functional programming movement who would like to swing all introductory programming in their direction! Many of the employers of our graduates find their Ada expertise extremely valuable.

West Virginia University

Frances Van Scoy, Associate Professor, Department of Statistics and Computer Science. West Virginia University has approximately 23,000 students, 1,600 full-time faculty, and 178 degree programs. The freshman course sequence for precomputer science majors is based on Ada. Approximately 225 students take the first course each year.

The Department of Statistics and Computer Science has 16 tenuretrack faculty in computer science (as well as 8 tenure-track faculty in statistics). The department has approximately 330 undergraduate computer science majors and 60 graduate majors. Approximately 65 bachelor's degrees and 25 master's degrees in computer science are awarded each year. The first students entered the computer science Ph.D. program in 1989.

From the establishment of the department in the late 1960s until 1973 the language emphasized in the freshman course sequence was Fortran. PL/I was then used from 1973 to 1989. Between 1979 and 1985, the department considered changing the language from PL/I to Pascal, C, or Modula-2, but none of these languages had majority support from the faculty.

Some faculty were working with Ada at WVU as early as 1980. They taught units on Ada in various courses including operating systems, principles of programming languages, and parallel processing. In 1981 two faculty taught a continuing education course on Ada to the local community. Also during the early 1980s several graduate students implemented portions of the language as their master's projects.

In 1986 the department offered its first full-credit course in Ada: an elective for juniors, seniors, and master's students based on Booch's Software Engineering with Ada [1].

In the Spring 1987 semester, at the request of and with support from Carnegie Mellon University's Software Engineering Institute, the department taught an experimental Ada-based introductory computer science course. As a result of the experiences of that semester, the faculty decided to adopt Ada as the language used in the freshman sequence beginning in fall 1989.

The design of the first course reflects the following concerns:

* Emphasis on Ada software development--many students lack any computing experience. (There is a local belief that students need some concrete experiences in a discipline before studying abstract principles.)

* Early emphasis on concepts rarely found outside of Ada and Modula-2--some experienced students have learned bad habits.

* Emphasis on abstraction, information hiding, object-oriented development, and software reuse-students should be taught a proper software engineering mindset.

* Emphasis on reading Ada code before writing Ada code--a person learns a first natural language by observing examples.

* Emphasis on reuse of existing Ada code--there is an increasing regional and national emphasis on reusability (e.g., three national Ada-oriented reuse projects are located in north central West Virginia and employ alumni of our program).

* Experience in designing and implementing complete Ada programs--students will be expected to write complete programs in later courses and on part-time jobs.

There was concern within the department that teaching a language perceived to be complex would hurt the retention rate for our first course. We have been pleased to observe no significant drop in enrollment or retention after the change from PL/I to Ada, and grade distribution has been approximately the same as it was with PL/I.

We are nearing the end of the third academic year of teaching Ada as a first programming language to all freshmen premajors. The transition has been a smooth one.

After developing a new freshman sequence based on Ada and incorporating concepts such as programming by components into these courses, we realized that the entire undergraduate curriculum needed revision. We undertook this revision and are phasing this new curriculum in one year at a time.

Area high school teachers have expressed an interest in Ada as well. As a result during Fall 1991 semester the department offered a course on Teaching Ada for high school teachers. Eleven teachers from three counties participated in the course, and the local high school is now offering an Ada course.

We see two kinds of support for an Ada-based freshman course that are not currently available. For instance, we need a large library of well-designed Ada library units. Abstract data types are not enough. We need examples that specifically illustrate key features of Ada, kinds of objects and operations, other software design issues as well as a large collection of components which can be combined by students into interesting systems. There are several issues related to building such a collection:

* Preparation--who designs, implements, tests and documents them?

* Distribution--how are they distributed to students (hard copy, on file server)?

* Maintenance--who fixes bugs? How are corrected versions distributed?

* Teaching--how do you demonstrate reuse (and give assignments requiring reuse) without spending too much course time teaching course-specific packages?

Another need is for a student-oriented programming environment. Regardless of the programming language used, students learning to write programs must learn operating system commands and editor commands as well as language syntax. In addition, students learning Ada must also learn commands for library management. Regardless of language, students should have access to visualization and debugging tools.

Our advice to other departments would be:

* Do your homework. Faculty need to be prepared. Learning syntax from a textbook is not sufficient preparation to teach an Ada course. (Some of our faculty attended workshops taught by government or industrial trainers.)

* Choose the textbook for the freshman course carefully.

* Expect changes in your entire curriculum.

Conclusions

Ada has been slow to "catch fire" as a language for undergraduate teaching, but seems now to be doing so. In the United Kingdom and Australia, Ada is the primary language in a significant proportion of undergraduate curricula. In the U.S. with over 2,000 colleges and universities teaching computing, the proportion is smaller but increasing steadily. The necessary critical mass is being produced by a combination of affordable and reliable validated compilers, textbooks tailored to undergraduate courses, and an enthusiastic group of experienced undergraduate teachers "getting the word out." The timely emergence of the Ada 9X standard and a freely available conforming compiler can be expected to contribute heavily to the acceptance of Ada in the educational system.

Acknowledgments

We are indebted to the Ada Information Clearinghouse, and in particular to its manager, Susan Carlson, for providing us with raw data and advance summaries of the CREASE survey results.

References

[1.] Booch, G. Software Engineering with Ada, Second ed. Benjamin/Cummings, Menlo Park, Calif., 1987.

[2.] Feldman, M.B. Small-Ada: Personal computer courseware for studying concurrent programming. In Proceedings of the Twenty-first ACM-SIGCSE Technical Symposium on Computer Science Education (Washington, D.C., Feb. 1990).

[3.] Feldman, M.B. Teaching Data Structures with Ada: An eight-year perspective. SIGCSE Bull. (June 1990).

[4.] Feldman, M.B. The portable dining philosophers: A movable feast of concurrency and software engineering. In Proceedings of the Twenty-third ACM-SIGCSE Technical Symposium on Computer Science Education (Kanas City, Mo., Mar. 1992).

[5.] Frank, T.S. and Smith, J.F. Ada as a CS1-CS2 language. SIGCSE Bull. 22,2 (June 1990), 47-51.

[6.] McCormick, J.W. A laboratory for teaching the development of real-time software systems. SIGCSE Bull. 23 (1991), 260-264.

[7.] McCormick, J.W. Using a model railroad to teach Ada and software engineering. In Proceedings of TRI-Ada '91 (San Jose, Calif., 1991), 511-514.

[8.] Smith, J.F. The aftermath of Ada: Reaping the benefits of CS1-CS2 Ada. In Proceedings of the Sixth Annual Eastern Small College Computing Conference 6, 2 (Oct. 1990), 102-105.

Further Reading

As cochair of the SIGAda Education Committee, and a denizen of the Internet newsgroups, I am often asked to give references for "Ada textbooks." This list responds to these many queries. It is far from exhaustive, merely a selected list of 26 books being used successfully in undergraduate computer science courses.

The six books in Group 1 are written especially for students without programming experience, who are learning Ada for their first language. Most of these can also cover at least part of a typical CS2-level course. The seven books in Group 2 use Ada as their language of discourse but are "subject-oriented:" data structures, file structures, compilers, and comparative languages. The 13 books in Group 3 are either Ada books focusing on the language features or more general books that use Ada, at least in part, but do not fit obviously into a standard curriculum "pigeonhole."

Group 1: Books Suitable for a First Course in Programming

Bover, D.C.C., Maciunas, K.J. and Oudshoorn, M.J. Ada: A First Course in Programming and Software Engineering. Addison-Wesley, Reading, Mass., 1992.

Culwin, F. Ada: A Developmental Approach. Prentice Hall, Englewood Cliffs, N.J., 1992.

Feldman, M.B. and Koffman, E.B. Ada: Problem Solving and Program Design. Addison-Wesley, Reading, Mass., 1991.

Savitch, W.J. and Petersen, C.G. Ada: an Introduction to the Art and Science of Programming. Benjamin/Cummings, Menlo Park, Calif., 1992.

Skansholm, J. Ada from the Beginning. Addison-Wesley, Reading, Mass., 1988.

Volper, D. and Katz, M. Introduction to Programming Using Ada. Prentice Hall, Englewood Cliffs, N.J., 1990.

Group 2: Other Books Intended for Undergraduate Courses

Ben-Ari, M. Principles of Concurrent and Distributed Programming. Prentice Hall, Englewood Cliffs, N.J., 1990. (Operating Systems/concurrency) Feldman, M.B. Data Structures with Ada. Prentice Hall, 1985 (now distributed by Addison-Wesley). (CS2/data structures)

Fischer, C. and LeBlanc, R. Crafting a Compiler. Benjamin/Cummings, Menlo park, Calif., 1988. (compilers) Lomuto, N. Problem-Solving Methods with Examples in Ada. Prentice Hall, Englewood Cliffs, N.J., 1987. (algorithms) Miller, N.E. and Petersen, C.G. File Structures with Ada. Benjamin/Cummings, Menlo Park, Calif., 1990. (file structures)

Schneider, G.M. and Bruell, S.C. Concepts in Data Structures and Software Development (with Ada Supplement by P. Texel). West Publishing Co., St. Paul, Minn., 1991. (CS2/data structures)

Sebesta, R.W. Concepts of Programming Languages. Benjamin/Cummings, Menlo Park, Calif., 1989. (comparative languages)

Group 3: A Selection of Other Ada-Related Books

Barnes, J.C.P. Programming in Ada, Third ed. Addison-Wesley, Reading, Mass., 1989.

Booch, G. Object-Oriented Design, with Applications. Benjamin/Cummings, Menlo Park, Calif., 1991.

Booch, G. Software Components with Ada. Benjamin/Cummings, Menlo Park, Calif., 1987.

Booch, G. Software Engineering with Ada, Second ed. Benjamin/Cummings, Menlo Park, Calif., 1987.

Bryan, D.L. and Mendal, G.O. Exploring Ada, Vol. 1 and 2. Prentice Hall, Englewood Cliffs, N.J., 1990 and 1992 respectively.

Burns, A. Concurrent Programming in Ada. Cambridge University Press, Cambridge, U.K., 1985.

Cohen, N. Ada as a Second Language. McGraw Hill, New York, N.Y., 1986. Gauthier, M. Ada: Un Apprentissage (in French). Dunod, Paris, France, 1989.

Gehani, N. Ada: an Advanced Introduction (2nd edition). Prentice Hall, Englewood Cliffs, N.J., 1989.

Gehani, N. Ada: Concurrent Programming (2nd edition). Silicon Press, Summit, N.J., 1991.

Nyberg, K., Ed. The Annotated Ada Reference Manual (2nd edition). Grebyn Corporation, Vienna, Va., 1991.

Shumate, K. Understanding Ada (2nd edition). John Wiley, New York, N.Y., 1989.

Watt, D.A., Wichmann, B.A. and Findlay, W. Ada Language and Methodology. Prentice Hall, Englewood Cliffs, N.J., 1987.
COPYRIGHT 1992 Association for Computing Machinery, Inc.
No portion of this article can be reproduced without the express written permission from the copyright holder.
Copyright 1992 Gale, Cengage Learning. All rights reserved.

Article Details
Printer friendly Cite/link Email Feedback
Author:Feldman, Michael B.
Publication:Communications of the ACM
Date:Nov 1, 1992
Words:12063
Previous Article:A technical tour of Ada.
Next Article:A model railroad for Ada and software engineering.
Topics:

Terms of use | Privacy policy | Copyright © 2020 Farlex, Inc. | Feedback | For webmasters