Designing programming assignments for an AI course presents several challenges. How much programming should there be in an AI course? What kinds of programming assignments should one design? What programming languages and/or platforms would one use? Are the students sufficiently prepared? For anyone looking for answers in this column, here is the punch line: it depends. It depends on the kind of course you are planning, where it fits in your curriculum, what students expect of your course, and what the rest of your department perceives the course to be. I will attempt to highlight some of the major concerns here that will hopefully bring some awareness to these important pedagogical issues the next time you plan your course.

The amount of programming included in the course depends on the level and the department where it is offered. An introductory AI course may have no programming component at all. At the other end of the spectrum, it can be offered as a course with a heavy programming component. If the course is offered outside of a computer science program, it is unlikely to have any computer programming. However, even in a course offered in a computer science program, the amount of programming required of students varies. In most cases, one will encounter anywhere from two to eight assignments in an AI course, not all of which might involve programming. This leads to the next question: What kinds of programming assignments should one design?

In thinking about the kinds of programming assignments there are several choices, some of which come depend on your own pedagogical objectives. The dividing line here lies between a choice of implementing "tools" versus implementing "applications". For some instructors, it is important to expose their students to the specialized algorithms embedded inside most AI tools. For example, learning and implementing pattern matching and/or unification, modeling a backpropagation neural network, implementing a natural language parser of a specific kind, etc. Some AI instructors like to use the programming exercises as a vehicle for learning complex programming techniques. Exercises mentioned above serve that purpose well. Algorithms embedded in tools tend to be quite complex and are a good way of enhancing students' programming skills.

In exercises that involve implementing complete applications, the amount of programming can also vary. Sometimes, in implementing game playing programs for example, the implementation involves a fair amount of programming. In other cases, students may be asked to use existing code, an API, or some AI software, to implement a particular application. Examples of these exercises range from, designing and implementing representations and reasoning rules for a specific domain using a specific KRR platform, writing and implementing a natural language grammar using an NLP package, designing and training a neural net to perform a specific task, or even doing empirical experiments on a given task using a neural net simulation system. The pedagogical goals of such exercises can have many facets: learn to use a specific AI system, learn to concentrate on design issues relating to the topic of the exercise (designing a grammar, chosing a parsing technique, configuration of a neural net, encoding of an individual for a genetic algorithm, etc.), or doing empirical experiments on a given system to understand various parameters and their behavior for a given model (the effects of varying the learning constant, the momentum term, the number of hidden-layer units, etc. on a specific training task).

Next, the issue of programming language and platform to use: What language(s) would you use? Are your students already fluent in the language(s) or do you have to teach the language(s) as a part of the course. The latter scenario, where you have to teach Lisp and/or Prolog can seriously limit the kind and scope of the exercises you assign. In some AI courses, most of the programming is in C, C++, or Java, in which case, most students are already proficient in it. In any case, issues like these can sometimes have a far greater impact on determining the amount and kind of programming assignments in a course.

Over the past decade or so, there has been a growing trend among textbook authors to supplement their texts with software or code that can support a course. Personally, it is not clear to me that one actually gets a lot of mileage out of attached software, but I also know of several colleagues who have relied on such materials rather extensively. Not only are you inheriting a pre-defined teaching approach, if you were using the text faithfully, you are also buying into a programming methodology, bugs and deficiencies included. I'd personally like to see the authors spend their time refining the material in the texts rather than developing, debugging, and maintaining the accompanying software. Besides, such software represents, in almost all cases, toy versions created specifically for assigning tedious assignments for students. That takes me to my last, and perhaps the most important point.

Are your programming exercises a good representation of an aspect of AI practice? Whether they involve tool-building or application development, you should ensure that the assignments relate to actual AI practice. It will not take you very long on the web to locate exercises, still in use, that require students to build OPS5 based toy systems.

So, how should one balance all these issues in designing programming exercises for a 1-semester course? It depends. Examine your own situation, your curriculum, your goals, student preparation, expectations, and then then decide on the amount and kind of programming exercises you will assign. In the end, given that so many local factors go into the design of programming assignments, it should be understood that your instantiation of a successful set of programming exercises may not be easily adopted at another institution. Nevertheless, after putting in all this effort into designing nifty exercises, there should be an easy way to share them with the rest of the teaching community.

What started out as a rant and rave about programming exercises has turned into a call for ideas for nifty exercises. If you think you have a nifty programming assignment, write to me and may be we can arrange for you to do a short write up on it in a future issue of Intelligence.