MFELDMAN@GWUVM.BITNET (Michael Feldman) (02/19/89)
Now that we seem to be in another round of "Ada in Universities" discussion, I thought I'd weigh in with a little chat about my own experience here. I warn you that this piece is a tad long, so those of you not interested in Ada in the university computer-science curriculum can hit your delete key now. I hope to keep the rest of you from getting bored. At George Washington University, Ada is the language of our data structures course, and has been for 4 years [DISCLAIMER: I wrote the book for this course]. (There are other courses too, but let's keep it simple.) We are located in central DC, midway between the White House and Watergate; several subway stops from the Pentagon. I got involved with learning and teaching Ada back about '81, at which time Ada was, of course, only a proposal. But it appeared to beat the dickens out of any other "real" language for teaching data structures. [ASIDE: my publisher talked me into putting out a second version of my book, with Modula-2 as the coding language; the conversion project make me like Ada even more for this stuff. That's a discussion for another time.] Many of our students are from other countries, with no hope of ever getting a job in the U.S. DoD world. Many of our students are U.S. citizens but don't much care to work in the DoD world, anyway. Then there are the grad students who are in fact working in the DoD-related industry here. Teaching Ada as the (required) design and coding language of the (required) data structures course has gotten somewhere around 600 students to learn (some) Ada. Often they use it in subsequent courses when they have a choice. What I am leading up to here is a re-iteration of my long-standing view that Ada really _should_ be seen as "just another programming language." Before Ed Berard and Bill Wolfe jump on me too hard, let me explain this heresy. I have no quarrel with the view that Ada can be seen as more than the language, rather a culture. Certainly it can. Certainly it oughta be. I have no quarrel with the view that software engineering should be taught more resolutely and systematically in academic computer science. I agree. (Details of why it isn't, in most schools, has nothing to with this discussion or of Ada; let's save it for another time). But let's get real. Lots of good software engineering gets done using other languages as the coding tool (pick up your favorite well-done commercial package: was it written in Ada?). Obviously Ada helps; that's why I presume we're all interested in it. But it's not essential. OK. If you agree with that Ada isn't _required_ for software engineering, perhaps you will agree that software engineering isn't _required_ for Ada. That is, given the way knowledge is chopped into little course-sized hunks in a curriculum, why can't Ada be taught _everywhere_ in the curriculum, just like Pascal often is (OK, the Turbo version, which sorta supports ADTs)? Data structures with Ada; operating systems with Ada; graphics with Ada; data processing with Ada; you get the idea. My experience tells me that students will in general learn what you decide to make 'em learn. If we say Ada is the main language, they will learn it as easily as they currently learn Pascal. More easily than C or Modula-2, because (most of) Ada is more uniform syntactically and semantically than either of those. My students usually come out of the data structures course actually _liking_ Ada; the foreign students' like for Ada cannot be dismissed as mere job-hungriness. What we have here, I'm convinced, is a perception problem among _faculty_, not students. Ada has a certain mystique, which we in the Ada business have at times fostered. It's also expensive to buy (see below). And there are undeniably those who will always see it as a DoD toy and reject it for ideological reasons. On the other hand, many teachers are open-minded, and this gives us all a golden opportunity that we should grab. The time is ripe for schools to change away from vanilla Pascal as the language of choice. In February each year the SIGCSE (SIG on Computer Science Education) meets; this is the only conference exclusively devoted to CS education issues. I can't go this year, but let me tell you what I learned last year. I participated in a panel on teaching concurrency, and organized, with Carl Brandon, a birds-of-a-feather session on teaching Ada. Further, I attended several sessions on freshman courses. This was my third CSE conference, and in each one the openmindedness toward Ada increased. Here is the gist of the "what shall we do in the freshman course" discussion (if any of you were there, correct me if you wish). (I'm only focusing on language-related issues here). There's a constituency that says "stick with vanilla Pascal"; freshmen shouldn't focus on the language details, rather on the formalisms of algorithm development at the program level. This group was pretty quiet. Most speakers on stage and in the audience believed that students should have a language they can grow into as they progress. The analogy with natural language: English doesn't change as a kid grows, the kid just learns more of the language. Ada isn't nearly as large as English; even still, you don't need to swallow it in one gulp. There's a constituency that goes with Turbo Pascal. Many schools have large labs of PCs; many schools encourage students to buy their own (I use the term PC generically: personally I prefer Macs; obviously Macs are included in this discussion). Turbo Pascal can carry a student through a number of courses, with the nice development environment and the use of units (which are sorta like packages but don't support private types, sadly). My objection to this position is that I don't think Philippe Kahn should unilaterally set the standard for the content of a programming language. Turbo is a de facto standard _only_ in the DOS world; the Mac version is a (somewhat) different language, not even fully compatible at the syntax level with the DOS one, which only makes my point stronger. There is a small group who've tried C with freshmen. The consensus seems to be that freshmen have enough to worry about without falling unwittingly into all of C's "gotcha's". C is OK for upperclass students, but wrong for freshmen (whew! I'm glad they came to that conclusion too!). Then there are the Modula-2 proponents, a growing number. Some of them genuinely like M2. But syntactically it's weirder than Ada (why would a new language be case-sensitive? why shouldn't functions be able to return records?) and only a little bit standard (although to their great credit the M2 compiler writers are converging on a standard even though there's no government forcing them too, and even though Wirth apparently isn't participating). What made this conference different from preceding ones is that a number of people said they'd prefer Ada, but can't really"sell it" yet to the committees in their departments, because the price is simply too high right now. The development environments are, in general, tailored (and priced) for industry, and there are _no_ textbooks suitable for freshmen. (Putnam Texel's is pretty close, but still makes enough assumptions that a rank beginner in programming would be confused). The bottom line is that we've moved from an era of CSE speakers dumping on Ada (for reasons I'm sure you can all imagine) to an era of CS faculty - and not just a few - being ready to go for Ada when the materials are available. And they're openminded not just because they think it'll increase their students' marketability. I think the word is finally getting out that Ada just might _really_ be the right language! I'm quite optimistic about Ada compilers: the price of compilers and environments is coming down, to the point where we have a handful of DOS-world systems in the $100. ballpark. The recent piece by Rich Pattis describes some interesting experiences with acquiring site licenses for Ada; what made it happen was a grant from Boeing, a "sugar daddy" as he put it. And when it happened, the University of Washington switched from M2. It seems to me that the Ada user community could well emulate Boeing. Think about it: a university site license for the PC compilers is in the $10,000 ballpark. This is, I guess, roughly one programmer-month's worth. Or equivalent to sending perhaps 3-4 employees out of town for a 5-day short course. Could this kind of money be liberated to give the university down the street a shot at getting Ada _really_ going in their curriculum? $10000 is, believe it or not, a helluva lotta money for some schools to come up with, and the decision to spend it is an _agonizing_ committee process. Seems to me that if each company adopted a school or two in their area, a little money could go a long, long way. Do you agree? About textbooks: I don't have as ready a solution here. I speak to editors now and then; publishers are _very_ conservative these days, and don't seem thrilled about taking the risk of a freshman-level Ada book. Somehow we need to convince the publishers that they'll make $$ selling Ada books for first-year students. Do any of you have ideas about how to get the word out to publishers? Can you get your friends in the local universities to write to publishers and say that they'll switch to Ada when the books are there to teach with? Are there potential authors out there? [DISCLAIMER: I am a potential author]. I am aware of at least 3 people doing a nice job teaching Ada to freshmen as their first and primary language: Carl Brandon (Vermont Technical College); David Rudd (University of New Orleans); and Rich Pattis (University of Washington at Seattle). Who else is out there that you know of? To conclude: I am not minimizing the problems of re-educating people in industry by focusing on the University structure here.[DISCLAIMER: I do a bit of re-educating myself]. But I think we should look to the long term. In my vision of the long term, Ada will simply be the language of choice in undergraduate computer science, not a "niche" languge suitable only for seniors and grad students (we teach it successfully to sophomores). We ought to work on filling the pipeline with graduates who speak Ada as their "mother tongue," learning C, Lisp, etc., as second or third languages, just as most students do now but with Pascal as the mother tongue. The typical Info-Ada reader may be in a position, either in a school or in a neighboring company or agency, to influence the speed of arrival of the long term. How can we work together to do this? I'd love to continue the discussion with any interested party, either in the Info-Ada forum or by private E-mail. Hope I hear from some of you. ------------------------------------------------------------------------ Michael B. Feldman, Professor residence address for USNail: Dept. of Elect. Engrg. and Comp. Sci Michael B. Feldman The George Washington University 6218 Wagner Lane Washington, DC 20052 U.S.A. Bethesda, MD 20816 U.S.A. +1-202-994-5253 MFELDMAN@GWUVM.BITNET MFELDMAN@GWUSUN.GWU.EDU Acknowledge-To: Michael Feldman <MFELDMAN@GWUVM>
vanscoy@a.cs.wvu.wvnet.edu (Frances L VanScoy) (02/21/89)
During spring semester 1987, West Virginia University taught an experimental CS 1 in Ada at the request of and with some support (hardware and software) from the Software Engineering Institute. Beginning with fall semester 1989, Ada will be the primary language used in our freshman and sophomore majors courses. Frances L. Van Scoy Associate Professor of Computer Science Department of Statistics and Computer Science West Virginia University Morgantown, West Virginia 26506 304-293-3607 vanscoy@a.cs.wvu.wvnet.edu Frances L. Van Scoy Associate Professor of Computer Science Department of Statistics and Computer Science West Virginia University