[GAP] advice on Ada in general programming languages course

[Anthony S Ruocco]

For one of my projects, students liked the idea of seperate specs and bodies - and the idea of sepearte compilations.  The 'project' does not need to be all that complex.  Develop a set of specs, have stduents create the bodies then compile into a single executable.  You can even do it by piece-wise adding each students contribution. 
  
Tony Ruocco  
  
----- Original Message ----- 
From: Ted Baker 
Sent: Thu Apr 21 09:53:22 EDT 2005 
To: GNAT Academic Program discussion list 
Subject: [GAP] advice on Ada in general programming languages course
  
  
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 

_______________________________________________ 
GAP mailing list 
GAP at gnat.info 
/no-more-mailman.html 
To unsubscribe from this list, please contact the GAP GNAT Tracker administrator 
within your organization.