| Program |
 |
|
|
|
| Find in Program |
|
|
|
|
| Page |
|
|
|
|
| Basket |
|
|
|
|
|
|
Nifty Assignments
Ballroom C
Monday, 13:30, 1 hour 30 minutes | 7 | · | 8 | · | 9 | · | 10 | · | 11 | · | 12 | · | 13 | · | 14 | · | 15 | · | 16 | · | 17 | · | 18 | · | 19 | · | 20 | · | 21 |
- Opening Paper: Examples that Can Do Harm in Learning Programming
- Katherine Malan
University of South Africa
malankm@unisa.ac.za
Ken Halland
University of South Africa
hallakj@unisa.ac.za
Examples form an integral part of learning to program. In this
paper we argue that the role of examples should go beyond merely
illustrating concepts or principles and should b programmers.
We identify four common pitfalls to avoid when designing examples
for teaching programming. We show how examples that are too
abstract or too complex can be harmful in explaining new concepts
to students. We also show how some examples used to illustrate
new concepts can undermine previously taught concepts by not
applying these concepts consistently. Finally, we show how some
examples can do harm by undermining the very concept they are
introducing. The aim of this paper is to encourage educators to
think critically about examples before using them.
- Abstract Factories and the Shape Calculator
- Eric Cheng, Dung Nguyen, Mathias Ricken, and Stephen Wong
Rice University
dxnguyen@cs.rice.edu
The assignment presents an orchestrated step-by-step process to
create a GUI application that dynamically loads an arbitrary shape,
displays it on the screen and computes its area. The shape can
have an arbitrary set of configuration properties (e.g., width,
height, color, etc.). This is very difficult to achieve using
conditional statements but is straightforward using the abstract
factory design pattern. This assignment serves as an introduction
to GUI programming in Java, where the GUI programming, which
besides being a valuable skill unto itself, is used to emphasize
and illustrate compelling usage of encapsulation, inheritance
and polymorphism. It is targeted at CS1 students in an
objects-first curriculum.
- Using the Game of Life to Introduce Design Patterns to Freshmen
- Michael Wick
University of Wisconsin, Eau Claire
wickmr@uwec.edu
Understanding design patterns is an important aspect of modern
software development. Frequently, design patterns are introduced
late into an undergraduate curriculum, typically in a junior or
senior design course. We believe that design patterns deserve
a more ubiquitous role in the undergraduate curriculum. In
particular, we have found that with slight modifications and
simplifications we are able to effectively introduce specific
design patterns in our first programming course. Further, the
necessary modifications and/or simplifications do not interfere
with the primary message of each design pattern but rather
highlight it. This presentation demonstrates a nifty assignment
in which students refactor a traditional implementation of the
classic Game of Life using the Command and Visitor design patterns.
We have found this assignment to be particularly enjoyable for
the students and quite effective in demonstrating the separation
of concerns that are central to each of these two design patterns.
- From Concrete to Abstract, the Power of Generalization
- Chris Nevison
Colgate University
chris@cs.colgate.edu
In this assignment students are given a program that solves a maze,
with a display that shows the steps toward the solution. The given
program has three variations of an iterative search (implemented
using the strategy pattern), depth-first search, breadth-first
search, best-first search (the latter using a priority queue). The
students are asked to disentangle the problem-specific aspects of
this code from the search strategy so as to define an abstract
problem solver that can be applied to any problem fitting the
model of step-by-step searching of a solution space. This requires
three steps: defining appropriate interfaces that specify the
information about the problem needed by the abstract solver,
defining the abstract solver to find a solution using these
interfaces, and defining the maze problem so as to implement these
interfaces. With the abstract solver created, students should also
be able to implement other problems fitting this model, such as the
word-ladder game or a search in a graph for a Hamiltonian circuit,
so that the abstract solver can be applied to them. The assignment
demonstrates the power of generalization using abstract classes and
interfaces as a bridge between concrete problems and the solution
algorithm. This assignment is intended for a course in software
engineering or an advanced programming course with emphasis on
design. Students should already be familiar with object-oriented
programming, inheritance, abstract classes and interfaces.
- Marine Biology Simulation
- Eric Cheng, Dung Nguyen, Mathias Ricken, and Stephen Wong
Rice University
dxnguyen@cs.rice.edu
We redesigned the AP Marine Biology Simulation to enhance its
robustness, security, flexibility and extensibility. This
assignment uses it as a framework for a case study in the second
semester of an objects-first curriculum. The students extend the
system by adding new components such as new fish and new
environments. The students learn the inner workings of the
framework by rewriting critical portions of it. JUnit tests
are used to specify and enforce behavioral contracts of the
various components in the system. The assignment serves as a
compelling example of how to use design patterns to capture
appropriate abstractions and demonstrates the power derived
from them. Test-driven development via unit testing provides
immediate feedback regarding the correctness of their work
while maintaining the freedom to implement code in different ways.
- Activity Session: Crafting Nifty Assignments
- Details to follow...
|
