Technical Program
  Invited Speakers
  Technical Papers
  Practitioner Reports
Educators' Symposium
Doctoral Symposium
Student Research Comp.
Turing Lecture
Social Events
Week at a Glance
Final Program (1.5M .pdf)

Find in Program


view, help
Object-Oriented Programming, Systems, Languages and Applications
Home    Program    Housing & Transportation    Registration    Submissions    Wiki    Maps
  > Educators' Symposium

 : Monday

Nifty Assignments

Ballroom C
Monday, 13:30, 1 hour 30 minutes


Opening Paper: Examples that Can Do Harm in Learning Programming
Katherine Malan
University of South Africa

Ken Halland
University of South Africa

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

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

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

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

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...