Pedagogical Pattern #10
Programming in the Tiny, Small, Large (TSL) Pattern
(Version 1.0)
Billy B.L. Lim
Illinois State University
Applied Computer Science Department
Normal, IL 61790 USA
bllim@ilstu.edu
Intent:
To introduce software concepts, especially those that require a number of
iterations for various depths.
Motivation:
When introducing new software concepts, it is often the case that the
students do not completely grasp the concepts until they get to practice the concepts in
some programming exercises. This is especially true when introducing
object-oriented concepts to students who have seen only the procedural paradigm. Experience shows
that the paradigm shift that has been so widely talked about can really make the
learning of objects very difficult.
The pattern of pedagogy described here stresses the importance of a
3-stage reinforcement of the lectures presented in class. The three stages, detailed in the
STRUCTURE section given below, permit an instructor to monitor the students' progress in a
topic-by-topic basis, to test if the students can combine the topics and apply them in a
larger setting, and to solve a "real-world" problem using all concepts discussed (and thus
seeing the "big picture"), respectively.
It should be noted that the use of this pattern, in part or as a whole, is
not a revolutionary concept. This discussion merely emphasizes the importance of carrying out
the pattern (all three parts of it!) in a consistent manner as the author's experience
shows that if any of the three is not practiced consistently, the learning of an already difficult
subject matter can be made even more difficult.
Applicability:
The TSL pattern can be used to introduce any software concepts, whether
they are programming related or not. The examples used in this article just happen
to be related to object-oriented programming.
Structure:
Tiny:
This part involves setting up homework assignments that typically take
only a few days to complete. (More accurately, students are given only a few days to
complete. The work itself should only take a little while.)
This type of assignments permits the instructor to reinforce materials
taught in class and more importantly, get immediate feedback from the students so that further
clarification and/or elaboration of the materials may be given. Multiple questions may
be assigned in a homework of type "tiny," each focusing on a specific topic of interest.
Examples of "tiny" assignments include simple class definition with data
and behaviors, exploring the difference between private, public, and protected access
control (for C++ only), using self and super pseudo variables (for Smalltalk only), and
testing the effect of including/excluding the keyword virtual when defining member functions
(for C++ only).
Small:
Assignments of type "Programming in the Small" represent those that are
do-able in weeks rather than days, unlike those of type "tiny." This type of
assignments allows an instructor to give a more in-depth study of certain topics that are deemed
central to the course. This next step, which can be a much more elaborate one, is a
natural progression after the students have had a chance to learn the individual topics with
the "tiny" assignments.
An example of a "small" assignment is one that involves the development of
one or more classes with a fair number of responsibilities in a class library. For
instance, students may be asked to develop a string class that supports 10-20 responsibilities.
This will allow the reinforcement of multiple ideas discussed in lectures such as class
definition, operator overloading, the danger of using default assignment operator (if using
C++), constructors (if using C++), etc.
Another example, one that may be appropriate for introductory students
(e.g., CS1), involves designing and implementing a calculator. If the students are
initially exposed to the procedural paradigm first, then a procedural approach to this problem
will involve functional decomposition of the calculator features, with each feature
implemented in a function.
Then the students may be asked to re-do the calculator assignment but this
time with the notion of a calculator object that is responsible for all those features
implemented before. With this, the students can compare and contrast the two approaches and
see the similarities and differences. They may also be asked to extend, through
inheritance, the original calculator with more functionality.
Large:
This part involves a comprehensive term project that spans the entire
semester. This all-encompassing project, which consists of several milestones, allows the
students to apply all the concepts studied in class and enables them to see the "big
picture" through the development of a "real-world" application. The milestones involved may
include proposal, CRC cards, use cases, object diagrams, class definitions, GUI design,
prototype, full implementation, etc. depending on the type of courses being offered.
An example of a project for a junior/senior level course is the development
of an application that makes use of certain class libraries that are made
available to the students. These libraries are typically GUI and/or foundation classes based. The
application might also involve the creation of several new classes by the students
themselves. Typically, these new classes are very much domain specific (e.g., Policy class for an
insurance application, RentalItem class for a rental application, etc.).
Consequences:
- The TSL pattern allows students to see not only the forests and the
trees, but also the "leafs" within individual trees. They can grasp abstract concepts early in
the course through "tiny" assignments before they embark on a more challenging one.
This reinforcement, while tiny, is often overlooked by many educators and thus
students are left making a "large" jump while they are doing an assignment that is thought
to be "small" by the instructor.
- With TSL, a three-prong reinforcement is established and students are
actively, constantly, and progressively participating in class activities. This type of student
involvement makes the learning fun and keep the students' interests on the topics high.
- Then, with the "small" and "large" assignments, students get to see and
eventually appreciate the beauty of object-oriented technology. Having worked on the
individual pieces and having combined those pieces together give them the "big
picture" and the "ah-huh" feeling that every student should feel after completing the
course.
Implementation:
Issues to consider:
- One of the most important issues when implementing the TSL pattern is
time management. With the "tiny" part, students are given a "tiny" assignment
almost every week. In a course that meets three times a week, say Mondays, Wednesdays,
and Fridays, a homework may be given on a Monday and it is due back on the Friday of
the same week. The Wednesday in between may be used to clarify homework
requirements if needed. That amounts to approximately 12-14 "tiny" ones and that can be
exhausting for both the students and the instructor.
A partial solution (for the instructor) might be to grade only a portion
of the assignment and discuss the non-graded ones in class. Students would have done (or at
least thought about) the problem sets and that makes the discussions easier to follow.
As for the students, the number of assignments can be relaxed a little bit if the
students are following the materials well.
- For the "small" assignments, approximately 4-5 may be given in a
16-week semester. This gives the students sufficient time to devise a solution (which should be a
major part of the total time), learn the development environment (since "tiny" assignments
may not require the use of a computer), implement the solution, clean up their code, and
provide a solid documentation for their work.
- As for the "large" assignment, there is only one since this is a term
project. Depending on the level of the course, a team consisting of two, three, or four may be
formed by the instructor or the students themselves. Much like group projects in other
courses, students will be asked to report on group activities, perform self-evaluations,
hold regular meetings, and give final presentations. This typically takes up a lot of the students' time and hopefully they learn to delegate work and to be responsible for work assigned to them. Otherwise, they will see that they cannot complete the work by themselves or that the pieces do not come together when they are combined at the end of the semester.
Related Pattern:
The individual components in LDLL (Lab-Discussion-Lecture-Lab) pattern.
Example Instances:
This pattern has been used to teach:
- Smalltalk Programming
- C++ Programming
- OO Analysis and Design
- database design
Even though this pattern is called "Programming in the Tiny, Small, Large
(TSL)," it is general enough for one to use it in analysis, design, and
many other things, whether they are computer-related or not.