Michael R. Wick

Digital gaming as a vehicle for learning

1. Summary During the past two years there has been a resurgence of interest in how to use digital games (e.g. video games, computer games and simulations) to support instruction in a variety of fields[3,9]. The focus is on how to exploit the rich interactivity of 3-D, multiplayer virtual worlds. Computer science education has, for the most part, taken a different approach: rather than having our students play video games to learn concepts we ask them to build games to learn concepts [2,5,6,7,8]. In the process of building games, students become immersed in gaming. Yet neither the IEEE/ACM CC2001 [1] curricular recommendations, nor the ABET/CAC [4] criteria mention the notion of gaming. This panel addresses the still controversial question of whether gaming is a legitimate component of computing, and if so, where does it fit within the curriculum. Regardless of where or how gaming falls within the curriculum, it is touted as an approach that will be attractive to a diverse audience, thus increasing potential enrollment into more traditional computer science courses. However, implementing a fully robust, modern, visually compelling, multi-player game from scratch as a semester-long project is problematic. The members of this panel will share a range of experiences in how to exploit a game format to meet particular pedagogic goals. The holy grail of modern commercial game design remains the “First Person Shooter,” (FPS) a game in which a character views a 3-D world from a first person, rather than map or textbased perspective, and with weapon (gun) in hand, moves through an interactive story to attain some goal. Typically there is a lot of shooting and consequent blood and guts. The genre, despite its violent roots, supports some of the most sophisticated techniques of computer graphics, animation and visualization. FPS open source game engines also provide compelling vehicles through which to teach good software design including design approaches for agent-based artificial intelligence and peer-to-peer networks. As a group we will each present our views on this controversy and suggest ways in which FPS can leave its violent roots in a manner similar to how the “kill text” button in early text editors became a more benign “cut” or “copy.” There appear to be four approaches to incorporating digital gaming into CS curriculum: (1) to support foundations courses, e.g. CS 1, (2) to provide specialized content at the upper level to prepare students for the gaming and animation industry, (3) to provide a curriculum encompassing thematic approach to CS in order to make CS and game development accessible to a more diverse population, (4) to provide trans-disciplinary experiences for CS students where they learn to interact with experts from other disciplines. A unique aspect of this panel is that all of us have had experience of some sort with all of these approaches. Consequently, the names attached to the sections below reflect a somewhat arbitrary assignment by the moderator. Like any good game, each of us will assume a role and run with it, supporting our assigned character. The format of the session will consists of a brief overview, a short presentation of each approach, a set of challenges to the audience, and hopefully, a lively interactive discussion of the place of gaming in the curriculum.

Using testing and JUnit across the curriculum

While the usage of unit-testing frameworks such as JUnit has greatly increased over the last several years, it is not immediately apparent to students and instructors how to best use tools like JUnit and how to integrate testing across a computer science curriculum. We have worked over the last four semesters to infuse testing and JUnit across our curriculum, building from having students use JUnit to having them write their own test cases to building larger integration and use case testing systems to studying JUnit as an example of good application of design patterns. We have found that, based on this increased presentation and structuring of the usage of JUnit and testing, students have an increased understanding and appreciation of the overall value of testing in software development.

Teaching design patterns in CS1: a closed laboratory sequence based on the game of life

Design patterns are an important element of todays undergraduate curricula. However, their inherent complexities often make them difficult for entry-level students to even partially grasp. In this paper, we describe the latest in our continuing efforts to build educational materials appropriate for infusing design patterns in entry-level computer science courses.

Kaleidoscope: using design patterns in CS1

Most computer science curricula include design patterns during the junior/senior software development sequence. We present a simplified application of two classic design patterns that is specifically targeted at students in their first programming course. We also include suggested pedagogy on how to develop the concepts necessary to implement and appreciate the application.

Implementing CC2001: a breadth-first introductory course for a just-in-time curriculum design

A first course in computer science that loosely follows the Computing Curricula 2001 report is described. This course blends theory and practice, highlights algorithm design, introduces a modest amount of imperative programming, and uses an Internet algorithmics theme to tie the topics together and keep the course both challenging and interesting to those with and without previous computing experience.

Second generation expert system explanation

Explanation has long been cited as one of the key advantages of the expert system methodology. Most current approaches to expert system explanation view explanation as an “add-on” to the expert system’s domain problem solving. This is in direct conflict with findings on human explanation. For humans, explanation is a complex problem-solving process of reconstructing an explanation based on a partial memory of the problem-solving episodes. Further, this process of explanation is at the same level as the original domain problem solving; working on the current state to reconstruct a plausible explanation. Recently, a new direction has emerged in expert systems, namely the study of second generation expert systems. These new expert systems view domain problem solving as an interaction and combination of several explicit reasoning processes or representations (i.e., causal, heuristic, planning). This chapter discusses two related projects that investigate the natural role of explanation in such second generation expert systems.

Expert system explanation in retrospect: a case study in the evolution of expert system explanation

Abstract Over the last two decades, expert systems have grown from a novel research interest to a thriving industrial technology. Constant during this transition has been the emphasis on the importance of an expert systems ability to explain its solutions to the user. As expert systems have moved from research to practice, the “users” of these systems have progressed from almost exclusively the authors of the system (i.e., the knowledge engineers), to highly trained domain experts, and are now beginning to include the novice end user. However, the methods used to produce expert system explanations have remained relatively constant. This article retrospectively examines the underlying assumptions of these methods and identifies how they fail to meet the changing needs of todays expert system end users. Three expert system projects are described to illustrate the evolution of expert system explanation methodology motivated by the failure of earlier techniques to satisfy end user explanation requirements.

Bridging the conceptual gap: assessing the impact on student attitudes toward programming

In this paper, we describe an experiment designed to test the effect of a novel first day lecture on student attitudes toward programming. The lecture does not require any knowledge of a specific language or a specific paradigm. Student evaluation surveys indicate that the lecture is effective at helping students to see programming as more than the simple creation of an artifact but rather as a systematic problem-solving process.

Seven design rules for teaching students sound encapsulation and abstraction of object properties and member data

Because encapsulation is a difficult concept for students to implement correctly, we propose a set of seven software design rules to be used as an aid for teaching the appropriate design and use of encapsulation of object properties.

Comparing the template method and strategy design patterns in a genetic algorithm application

We present a genetic algorithm software project that serves to give students direct experience with choosing among multiple potentially applicable design patterns. We carefully constructed this project to illustrate the power of design patterns in supporting encapsulation while at the same time providing a single context in which to compare and contrast similar design pattern alternatives.