Pedagogical Pattern #23
Model and Implement Pattern
(Version 2.0)
Alan O'Callaghan
Chair, Object Technology Group
De Montfort University
School of Computing Sciences
The Gateway
LEICESTER LE1 9BH aoc@dmu.ac.uk
Motivation:
Traditional Computer Science teaching requires a decidedly bottom-up
approach demanding that students learn numbering systems, the principles of digital design,
a procedural programming language and then, scaling up, some analysis and design. The approach
to programming is syntax-driven rather than, as all "real world" computing demands, problem-driven. An alternative approach which stresses programming as a means to solving problems is required.
Forces:
First year students' grasp of abstraction is insufficient for a "pure modelling" course.
Learners respond to hands-on exercises and the achievement of creating software that works.
Traditional curricula reinforce a bottom-up approach in which analysis and design are regarded
as "high level" techniques to be encountered much later in the course. The effect is to impose a
machine-view architecture on problem-solving approaches.
An appreciation of OT requires early and often exposure to conceptual modelling, software
design, and implementation.
Applicability:
Applies to all levels in Higher Education computing curricula where "real-world" problems (ie.
Non-computing) problems have to be solved using software. It is less important for students
studying hardware, digital design or electronic engineering.
Applies also to learners being reskilled in industry.
Requires a suitable interactive, graphical programming environment e.g., SmallTalk rather than
C++, for best results, or alternatively, a robust, mature and wide-ranging library of classes which
learners can use as components in creating a solution to a problem.
Definitely does not require competence in a specific analysis/design method or notation
Consequences:
Early understanding of a programming environment (e.g., language compiler)
as a tool providing a means to an end, rather than as a means in itself.
Greater understanding of software as a tool for solving "real world" problems rather than as an
instruction set for the machine.
Early exposure to the modelling power of objects.
Firmer ground established for "scaling up" to analysis, design and implementation of large-scale
systems later on in a course.
Implementation:
Requires a suitable programming environment (see above)
Requires a prepared set of logical problems, and a defined set of software components that can be
put together (after some analysis) to provide an executable solution.
Implies a restructuring of the wider curriculum, perhaps in the form of Meyer's inverted
curriculum [Meyer 1994], to take care of important notions in Computer Science which are
traditionally taught early on.
Examples of Use:
De Montfort University in the UK have applied this pattern in programming subjects since 1993,
when it was applied to a Modula-2 course. Its success led to the embracement of OT in early
programming modules such that from 1996-7 Java is taught as a first programming language in
some courses. From 1997-8, SmallTalk - currently taught in the application of this pattern from
the Second Year - will also be available at Level One.
Related Patterns:
Can be regarded as a special variant of PDR [Lilly 1996]
References
[Gamma 1994] Gamma E., et al. 1994. Design Patterns for Reuse.
Addison-Wesley, Reading, MA.
[Lilly 1996] Lilly, s. 1996. "Patterns for Pedagogy" in Object Magazine 1/96.