[GAP] advice on Ada in general programming languages course

[Ted Baker]

Dear GAP discussion list members:

I'm looking for ideas on how to "hook" students on Ada in the
course I am scheduled to teach next fall.  In particular, I am
interested in hearing if anyone else has taught a course like this
before and how they worked Ada into it, and whether you are aware
of any reference materials and Ada software artifacts or tools
that would fit this course.  I am also hearing comments/criticisms
on some of the ideas I have been considedring.

This our undergraduate course "COP4020: Programming Languages".  I
will be taking over responsibility for this course from another
instructor, Robert van Engelen, for at least the past five years.
(see http://www.cs.fsu.edu/~engelen/courses/COP4020/syllabus.html
for a description of his course).  There are some strong pragmatic
reasons for preserving some degree of continuity, even to the
point of reusing the same textbook and some of the teaching
materials Robert has built up over the years, but I do have the
freedom to change what I will.

The course has always included a few bits about Ada, along with
several other programming languages.  I'm looking for ways to
increase the students' exposure to Ada, without pushing out other
critical content and without generating a backlash against Ada.

For context, I will describe the course briefly.  It has a sort of
fragmented personality, pulled in several directions, each of
which could be a course in itself, including:

  a. Programming paradigms (e.g., procedural, functional, 
     object-oriented, data flow, logic programming)...
     We usually have covered at least a functional langauge (LISP/Scheme)
     and a logic language (Prolog).
  b. Language implementation (compilation
     techniques, runtime implementation models, linking,
     shared libraries, etc.)
     We usually require students to program a recursive descent parser,
     and possibly an interpreter.  We cover activation records,
     heap management, parameter passing mechanisms.
  c. Formal programming language description techniques.
     We usually cover at least BNF and
     precondition-postcondition axiomatic proofs of correctness.
  d. Sampler of a diverse collection of actual languages outside
     of C, C++, and Java.
  e. History of language design evolution.

The above topics are not likely to be covered in any other
undergraduate course, excepting exposure to finite automata and
context-free languages in a theory course, and
precondition-postcondition logic in an elective on formal methods
in software engineering.  Which areas do you think I should be
willing to cut to put in more about Ada?

I have heard from several students who took this course that they
did not find it satisfying.  The main complaints seemed to be: (1)
boredom at reviewing basic programming constructs (variables,
types, loops, parameters) that they already thought they
understood well enough; (2) lack of new material that they felt
they would be able to put to practical use in today's programming
world.  Some of them felt the portions on language implementation
were interesting and potentially useful.  Others would have
preferred to learn enough of some language that they could
actually put it to use.  While students do not always have enough
perspective to appreciate what will be valuable to them later,
there is no doubt that they learn better when they are interested,
so I am giving these matters consideration.  I'm guessing the
students will be more motivated if I slant the course toward
programming language implementation techniques, and they may
tolerate more Ada if they are actually using it to program for the
course, even if they have a prejudice that Ada is not a language
they are likely to be asked about when they look for a job.

One of the ideas I have played with is to have them work on a toy
programming language implementation, using Ada as the
implementation language.  One of the times I taught this course
before (it was more than 10 years ago) I had students do a
primitive LISP interpreter in Modula.  I was thinking of perhaps
doing that in Ada this time.  Another time I had students make
additions (e.g., function parameters with full closures) to a
Pascal-S translator/intepreter which I had translated myself from
Pascal to Ada.  One idea, suggested by a colleague, is that I
update that project to generate code for the JVM (instead of
Wirth's byte code), and thereby work in also a study of the JVM.
That might help to hook the students (who seem to like Java),
though I worry that adding the JVM to the course along with more
Ada might mean pushing out much of the other content.  I also
considered the possibility of having them use Ada to write a toy
Prolog implementation.  Before I spend time writing something from
scratch, are you aware of any up-to-date toy language
implementations written in Ada 95 that I could use as a starting
point? Any other ideas for projects?

--Ted