For the last several years a group of educators has met several times at various meetings including SIGCSE, ChiliPLoP, and OOPSLA as the Elementary Patterns Working Group. All of us are interested in finding more effective ways to teach object-oriented concepts to novices, especially in the first computer science course. In addition to the core group, there are many other educators in the US and a few others interested in our work and who have put it to use in various ways.
Most of the members of the group would agree with most of what I have to say here, though they are personal observations.
The most important message, and perhaps the most controversial, is that teaching objects well requires new pedagogy. The teaching methodology used to teach procedural programming will not work, or at least, will not work well enough. For this reason, I've been developing pedagogical patterns to try to address this new way of teaching. A number of these patterns have been submitted to EuroPLoP 2000 and can be found at http://csis.pace.edu/~bergin/PedPat1.3.html. They form the beginning of a long work that attempts to build a pattern language for the design of courses introducing object-orientation from the beginning.
The next message is that educators must come to realize that object-orientation is not a simple addendum to procedural programming. It is more than a large scale structuring technique for procedural elements. Indeed, the thought processes of object programmers can be shown to be quite different than those of procedural programmers. This is the basis for saying that object-orientation is a paradigm shift from procedural methods. Too many educators seem to believe that object-orientation is just about classes, or just about classes and inheritance. If this were so, then object-orientation wouldn't have the benefits it does and would, indeed, be just a simple extension and could be effectively taught that way. This has been discussed at length in "Why Procedural is the Wrong First Paradigm is OOP is the Goal", at http://csis.pace.edu/~bergin/papers/Whynotproceduralfirst.html.
Instead, however, object-orientation is really about polymorphic run-time
function dispatch, and this changes the game radically. The deep meaning
of this is that the focus of control in programs changes from a client centered
view appropriate in procedural programming to a server centered view in object
programming. This requires a change in mental model for the programmer--a paradigm
shift. The aim of the new pedagogy is to avoid the disruption that will necessarily
occur if our students are made to suffer the negative consequences of moving
through this shift. In industry, experience shows that to completely make the
shift requires approximately eighteen months, during which the programs written
are not well structured either procedurally or with objects. This is because
the two paradigms fight each other in the programmer's mind. Two recent papers
that illustrate the differences between procedural programming and object programming
are:
Understanding Object-Oriented Programming at: http://csis.pace.edu/~bergin/ppoop.html.
Moving Toward Object-Oriented Programming and Patterns at:
http://csis.pace.edu/~bergin/persongender.html.
Thirdly, we have found that patterns and pattern languages can be an effective
supplement to this pedagogy. Some of the patterns we use are the simpler ones
from the standard software pattern movements. We use Strategy, Null Object,
Decorator, Singleton, Immutable, and Factory, among others. This helps show
good object design in simple ways and also introduces the student to patterns
so that they may later read the literature to gain more. We try to develop simple
pattern languages around these otherwise discrete patterns as well, using, for
example, Null Object, Singleton, and Strategy together to build lists. This
example can be found in
Object Oriented Lists at:
http://csis.pace.edu/~bergin/patterns/List.html.
The Elementary Patterns Working Group has undertaken a larger body of work as well. We have been writing patterns and pattern languages intended specifically for novices--Elementary Patterns. These patterns describe software solutions at a very low level. Indeed they describe things well known by every working programmer, but which are often mystifying to novices. Patterns and pattern languages have been developed for
These ideas have been informing our courses for a few years now. They have also been employed by others in developing courses and lab exercises. For example see Alyce Faulstich Brady's labs at: http://max.cs.kzoo.edu/~abrady/CS420W00/Labs/index.shtml. Look especially at the second and third week labs, which incorporate the Selection and Loop pattern languages.
The Elementary Patterns Home Page can be found at: http://www.cs.uni.edu/~wallingf/patterns/elementary/
The core members of the Elementary Patterns Working Group currently include myself, Eugene Wallingford, Robert Duvall, Owen Astrachan, Ed Epp, and Rick Mercer
April 15, 2000