How much programming? What kind?
Deepak Kumar
Department of Mathematics & Computer Science
Bryn Mawr College Bryn Mawr, PA 19010

Curriculum Descant
From ACM Intelligence Magazine
Volume 12, Number 1, January 2001
ACM Press


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.


Fall 1997
Inaugural Installment of the new column.
(Deepak Kumar)

Summer 1998
Teaching about Embedded Agents
Using small robots in AI Courses
(Deepak Kumar)

Fall 1998
Robot Competitions as Class Projects
A report of the 1998 AAAI Robot Competition and how robot competitions have been successfully incorporated in the curriculum at Swarthmore College and The University of Arkansas
Lisa Meeden & Doug Blank)

Winter 1998
Nilsson's New Synthesis
A review of Nils Nilsson's new AI textbook
(Deepak Kumar)

Spring 1999
Pedagogical Dimensions of Game Playing
The role of a game playing programming exercise in an AI course
(Deepak Kumar)

Summer 1999
A New Life for AI Artifacts
A call for the use of AI research software in AI courses
(Deepak Kumar)

Fall 1999
Beyond Introductory AI
The possibility of advanced AI courses in the undergraduate curriculum
(Deepak Kumar)

January 2000
The AI Education Repository
A look back at AAAI's Fall 1994 Symposium on Improving the Instruction of Introductory AI and the resulting educational repository
(Deepak Kumar)

Spring 2000
Interdisciplinary AI
A challenge to AI instructors for designing a truly interdisciplinary AI course
(Richard Wyatt)

Summer 2000
Teaching "New AI"
Authors of a new text (and a new take) on AI present their case
(Rolf Pfeifer)

Fall 2000
Ethical and Social Implications of AI: Stories and Plays
Descriptions of thought provoking stories and plays that raise ethical and social issues concerning the use of AI
(Richard Epstein)

January 2001
How much programming? What kind?
A discussion on the kinds of programming exercises in AI courses
(Deepak Kumar)

Spring 2001
Predisciplinary AI
A follow-up to Richard Wyatt's column (above) and a proposal for a freshman-level course on AI
(Deepak Kumar)

Spring 2001
Machine Learning for the Masses
Machine Learning comes of age in undergraduate AI courses
(Clare Congdon)

About Curriculum Descant
Curriculum Descant has been a regular column in ACM's Intelligence magazine (formerly published as ACM SIGART's Bulletin). The column is edited by Deepak Kumar. The column features short essays on any topic relating to the teaching of AI from any one willing to contribute. If you would like to contribute an essay, please contact Deepak Kumar.