Position paper for OOPSLA '96 workshop
"Teaching and Learning Object Design in the First Academic Year"
CS1 As An Architectural Design Course
School of Computing Science
Simon Fraser University
Burnaby, B.C., V5A 1S6, Canada
Current CS1 courses purport to teach an introduction to design, often
providing an early introduction to the software engineering lifecycle and
to objects. This paper claims that such courses at best teach only micro-design
- the self-contained design of small isolated data components and algorithms.
Conversely, in real-world design, issues of a macro-perspective which emphasise
the architectural organisation and structural connections between and among
identified components are of significantly more importance than those of
the micro-design perspective. This paper proposes, for a CS1 course, a
case-study-driven approach to teaching object-oriented design from the
macro-design perspective. The design and implementation hierarchy employed
also teaches micro-design and its C++ implementation. Some observations
of the author's experience of teaching such a course are provided.
The claim that modern CS1 curricula and textbooks emphasise and teach
design is often supported by their provision to provide an early introduction
to a basic software engineering lifecycle. Invariably, this methodology
is then applied to small individual procedural and object (data) components.
Emphasis on these localised or low-level design and implementation issues
teaches very little about the processes of design from the perspective
of true problem solving, precisely because students have no context upon
which to evolve their design. Invariably the minimal context which is available
implies the design is self-evident, therefore prompting the students to
do little practical design, while suggesting to them that the important
issues are ones of implementation and syntax.
A simple analogy assists the presentation of this argument. Consider
an architectural problem of building a bathroom. In the CS1 domain, this
bathroom would be fully specified by the instructor. Given this specification,
the bathroom's design is relatively obvious to students. They then perceive
the emphasis to be on its construction, with little need to emphasize design.
Inherently generic and applicable design processes can only be taught and
learned if a design context is provided. Is this bathroom a "portaloo"
on a construction site, an ensuite in a home, or one on a concourse of
a new football stadium? Localised design of the bathroom cannot be made
until a particular context is evident. The issue of bathroom design is
now of relatively less significance that is the architectural specification
and design of the context within which this bathroom resides.
Significant issues, processes and qualities of good design must be addressed
by consdering the constituent architectural components and their organizational
structures and interfaces within the larger context of the problem or product.
The processes of teaching and learning design must emanate from these global
contexts. Invariably, CS1 courses do not address design from this perspective.
This statement is equally valid for object design and for object-oriented
courses which either start "small" with procedural design emphases
or offer an early introduction to simple objects. They avoid the larger
context within which significant and meaningful object-oriented design
issues may be studied.
This author has long employed a "design-in-the-small" pedagogy
-until recently required to teach C++ to CS1 students. Possessing a personal
bias against C, and recognizing that the essential basis of C++ is objects,
it became apparent that the course should emphasize the macro-world of
object application. The resultant course became one of teaching data-driven
design - via ADT's and objects - with C++ introduced when implementation
issues were addressed.
The background commentary leads to 5 propositions.
- The movement towards teaching object oriented CS1 courses should replace
the emphasis on language syntax and implementation tools with an emphasis
on the process of data-driven (object) design applied to large problems,
with specific language issues and syntax raised only as technical concerns
reqired to implement low-level designs.
- The issues of "how" to design (as opposed to "what"
to do as specified by a software engineering lifecycle), the identification
of qualities of good design, and an understanding of applicable design
tools can only be appreciated by studying "large, meaningful"
problems. These are required to provide a significant context within which
to consider the identification of design components and their architectural
and structural connections. The pedagogical perspective must be that of
the development of an architects' drawings for a new house, followed by
the more specific drawings of the various floor and room plans. From these
will flow the detailed designs of the blueprints, and the implementation
of the house itself. Design issues are learned by contact with this hierarchy
of design. Learning must proceed by original design development and/or
the study of existing designs. Appreciation and development of good design
is enhanced via the study of alternative designs for the same product.
Significant-sized problems are required to support these views.
- Even though object design is a data-driven design paradigm, students
must be taught that they are employing in parallel an equally powerful
paradigm - the procedural (algorithmic) paradigm. This is used to specify
both the interactions between and amongst the design components and the
detailed designs of internal methods of the components.
- The typical topic order of a CS1 course is reversed, in that initial
topics must include high-level structural design and full conceptual coverage
of data objects/classes/ADT's.
- The pedagogy employed must simultaneously recognise that while there
is little in a student's background to support this proposed way of thinking,
students do possess practical knowledge and experience of many of the required
concepts, and they can and do react favourably to this challenge.
The author is currently concluding his first offering of a CS1 course
based on the above propositions. The course organization and pedagogy employed:
- Active in-class development of high- to mid-level design heirarchies
for specified problems.
- Emphasis on "how to " design.
- Comparative study of alternative designs for a problem.
- Illustration of basic design issues, tools, strategies, and simple
notations via development of 2 case studies.
- Case-study 1: Application of above to a "small" single object
problem, followed by its detailed design and C++ implementation.
- Case-study 2: Development, during the remainder of the course, of the
design and redesign of a large project composed of numerous data objects.
The full problem was initially specified and the high-level architectural
design was completed. Implementation of the project was via the specification,
design and implementation of a succession of prototypes, each of which
was specified to require the successive development of typical CS1 topics
(ie ADT's/classes, simple data types, subprograms, records, arrays, etc.).
Implementation and syntactic issues of C++ were considered only after detailed
designs were developed (implying that CS1 "tools", such as arrays,
were first considered conceptually with a pseudo-notation).
- Course and design concepts employed students' current knowledge wherever
possible (ie arrays at the design level were easy to teach because of students'
mathematics background; records because each student has a student record,
- Homework assignments, done in groups, ran a project in parallel with
the lecture project.
- Exams emphasised design issues, with associated C++ implementations.
After 12 weeks (of a 13 week course), the author has noted:
- This "think big" design approach to problem solving was very
trying for the first 4-5 weeks for both students and instructor. For students,
their past experiences had not prepared them for such expectations or ways
of thinking. Their immediate interests appeared to be C++ and computer
usage issues. For the instructor, it appeared that the whole class was
floundering - yet it was necessary to persevere with design issues while
resisting imparting C++ issues.
- By weeks 6-8, most students seemed quite content with the ideas.
- Towards the end of the course almost all students' questions and discussions
addressed the broader issues of design and problem solving. There was general
consensus that the effort, creativity and challenge was in the design process,
and that C++ implementation was more of a technical, less interesting process
- Towards the end of the course students were quite receptive to instructor
comments such as: "Well, the design is clear. We understand the conceptual
definition and use of <topic x>. You can look up the C++ syntax to
do the implementation."
- The pedagogy and project employed intuitive objects first. For example
it considered queues and then introduced arrays as a representation of
a queue. Students grasped both concepts much quicker than in past courses
where the standard CS1 topic order did arrays in isolation.
- Due to the semester length, the emphasis on design forced: (a) some
common CS1 topics (ie. recursion, pointer variables) to receive less emphasis
(this would not be such a problem if the CS2 course were designed to follow
on from the CS1 philosophy). (b) topics such as polymorphism and inheritance
to receive minor attention (polymorphism -only for operator overloading;
inheritance - only as a possibility of "nice" things still to
come.) (c) students themselves to discover and to resolve the many "surprises"
resultant from the usage vagaries of C++.
- C++ is probably not the best language for a CS1 design course.
Most typical depth-first topic based CS1 courses and textbooks within
the author's knowledge support, at best, what might be called low-level
or localized design issues. Books such as Savitch , which introduce
object design very early and consistently, address the localized design
issue but do not directly address the issues of "how to" design
solutions to significant problems given in a broader context. The ideas
adopted in this paper employ, only at the lowest level of design and implementation,
the concepts espoused by such authors. Other approaches which introduce
objects quite late (and therefore only support procedural design) are at
the opposite end of the design spectrum proposed in this paper.
 Evans, M.D., "A New Emphasis & Pedagogy for
a CS1 Course", SIGCSE BULLETIN, September, 1996.
 Savitch, Walter, "Problem Solving with C++ The
Object of Programming", Addison-Wesley Publishing Co.Ltd., 1996.
The author is currently employed as a Senior Lecturer in Computing Science
at Simon Fraser University. He has held previous positions as Associate
Professor and Senior Lecturer at, and has obtained post-graduate degrees
in both mathematics and computing science from, universities in both Canada
and Britain. He has been a visiting lecturer at the University of Maryland
(Overseas). His current interests include computing science education and
curricula issues, particularly at the lower division levels.