Pedagogical Pattern #47
Simple and Complete Patterns Step by Step
(Version 1.0)
Erzsébet Angster
Dennis Gabor College
1115 Budapest, Etele ut 68.
angster@okk.szamalk.hu
Intent:
To help students understanding the fundamentals of a certain material fast so that they can apply it effectively and safely.
I show a sample pedagogical pattern for teaching fundamentals of OO design and programming.
Motivation:
It is always hard to begin learning - it often occurs, that students spend a lot of time to be familiar with a certain material (concept/method/procedure/tool). If the material is large and difficult,
it is very hard to catch something concrete, from which one can go step by step.
It is very important for the students to see very small and complete patterns first, then immediately to do the exercise by their own by little modification of the pattern. It is much easier learning this way.
Every student wants to see a pattern for every topics of the material. The basic patterns must be built on each other; they must be evident; they must be easy to follow and modify all over the material.
Applicability:
This pedagogical pattern is well known and applicable everywhere, though
it is not widely used. It is very good in teaching program development,
but especially applicable in teaching OO concepts and OO software
development. Though OO thinking is very natural, the implementation of
OO concepts turned out to be quite hard to understand.
Structure:
The topics of the material are built on each other. Every topic consists of the following parts:
- The teacher shows a simple but complete pattern. The pattern goes into the details exactly to the depth that the problem is wholly understandable and traceable from the beginning to the end.
- Teacher categorizes the elements of the pattern into a small number of category.
- Students modify the pattern
- Students get a problem which they can solve modeled on the given pattern.
Consequences:
- The pattern is applicable in teaching many things.
- Students have success solving small problems quickly.
- Students can understand the related concepts easily.
Example Instances:
I give a sample application structure of teaching OO design and
programming. The pattern has four object stereotypes (categories):
window, control, container and entity. The main OO concepts are
discussed during the course. The topics and the related patterns and
concepts are the following:
- Topic: Object and class. Pattern: it has one window class, and one
instance of that class, a window. Related concepts: classification,
encapsulation, information hiding, messaging.
- Topic: OO design: The pattern has two or three windows of the
previously discussed or developed window class. The pattern has a
control object which controls the windows. Related concepts:
associations, control object, collaboration diagram, class diagram.
- Topic: Inheritance: The pattern has the previously discussed window
class and a specialized window class. The pattern also has a control
object which now controls the special windows. Related concepts:
specialization, inheritance, polymorphism, late binding, visibility.
- Topic: Container class. Implementing the 1:N association: The pattern
has now a control object and several special or not special window
objects. Related concepts: container, iterator, polymorphism, type
casting.
- Topic: Entity objects. Pattern: similar to the previous pattern. In
the container there are also entities. Windows are the interfaces to the
entities. Related concepts: entity object, interface object.
It is very important to show and develop all details. For every problem
the student must see the following things: Simple collaboration diagram;
Class diagram; Class descriptions; Code
Consequences of this pattern instance:
- In spite of the pattern's simplicity, there are infinite variations of
problem specifications to find out.
- The source code can be made in 3GL or 4GL languages, in pure or hybrid
object-oriented languages. It is better to use pure OO language though
to force the student to use OO technique.
- Using a framework, the control, interface and container classes are
ready and reusable.
Related Patterns:
None so far
Resources Needed:
None