Daniel E. Stevenson

Concurrent CS: preparing students for a multicore world

Current trends in microprocessor design are fundamentally changing the way that performance is extracted from computer systems. The previous programming model of sequential uniprocessor execution is being replaced quickly with a need to write software for tightly-coupled shared memory multiprocessor systems. Academicians and business leaders have both challenged programmers to update their skill sets to effectively tackle software development for these newer platforms [2]. At the University of Wisconsin - Eau Claire, we have taken steps early in our curriculum to introduce our students to concurrent programming. Our approach is not to add parallel programming as a separate class, but to integrate concurrency concepts into traditional material throughout a students coursework, beginning in CS1. Our goal is for students to gain both familiarity and confidence in using parallelism to their advantage. This paper describes the programming process we seek to introduce to our students and provides example assignments that illustrate the ease of integrating this process into a typical 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.

Developing real-world programming assignments for CS1

Instructors have struggled to generate good programming assignments for the CS1 course. In attempting to deal with this issue ourselves, we have generated two real-world programming assignments that can be solved by most students yet generate challenges for advanced students. We present our overall criteria for a quality programming assignment in CS1, details of the two example assignments, and other issues stemming from the generation and management of these assignments.

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.

Hybrid and custom data structures: evolution of the data structures course

The topic of data structures has historically been taught with two major focuses: first, the basic definition and implementation of a small set of basic data structures (e.g. list, stack, queue, tree, graph), and second, the usage of these basic data structures as provided by a data structures framework in solving larger application problems. We see a further evolution of data structures to include new generations of hybrid and custom data structures, implying that our students must not only understand how to use these new data structures but that they continue to understand low-level implementation issues so that they can develop the next generation of data structures needed in the future. We suggest that the data structures course evolve to reflect these new generations of data structures.

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.

Steganography and cartography: interesting assignments that reinforce machine representation, bit manipulation, and discrete structures concepts

Todays generation of students crave assignments that are relevant to their world, both in terms of graphical interfaces and, more importantly, the application area. To be fully engaged they must find the application of importance. However, we have found that many assignments in computer science attempt to engage the students by moving further and further away from the underlying machine representations. This causes a disconnect between the applications our students write and the material we present on machine representations and architecture. We present examples of assignments based from the fields of Steganography and Cartography that we have found to be valuable in helping to reinforce the importance of machine representations with todays students. We found that the students were excited and intrigued to see how their discipline could play a vital role in the war on terrorism and how what they were learning in their CS 1 course was directly relevant to what they heard on the nightly news and experience on a daily basis via the Internet.

Implementing object equivalence in Java using the template method design pattern

A standard practice in object-oriented programming is to implement an operation, called equals in Java, for testing the equality of two objects. The equals method should be defined for every new Java class, but because of the intricacies of inheritance, casting, and dynamic typing, equals is often quite difficult to write correctly. And unfortunately many textbooks present flawed implementations of this operation. In this paper, we present a semantically correct technique for testing object equivalence, a technique that simultaneously brings together important mathematical foundations (equivalence relations), practical programming issues (inheritance, casting, dynamic typing), and sound software design (design patterns) in a natural and compelling way. While Java is used to demonstrate how the semantic flaws are corrected and the design improved using our techniques, the design is general enough that it will be clear how the same ideas could easily be extended to other languages such as C++.

Building an autonomous vehicle by integrating lego mindstorms and a web cam

There are many possible ways to integrate Lego Mindstorms robots into the standard computer science curriculum. This paper presents a way to use these robots to teach image processing or vision by building an autonomous vehicle. The vehicle uses an off-the-shelf web cam for all of its navigation. Integration of the camera, robot, and controlling computer is discussed, as are the image processing units used, the structure of a state machine controlling them, and the cross-cutting concern of reducing both input and output noise throughout all aspects of the project.

Approaches to teaching the programming languages course: a potpourri

The release of Curriculum 2001 coupled with the increasing importance of the World Wide Web and the changes in pedagogy enabled by new technologies has made the choices about what to teach in the programming languages course and how to teach it more varied . Each of the members of this panel approaches their version of the course differently and will speak about their vision of the course, their style, their techniques and the materials they use. By sharing our versions of the course and generating discussion, we hope to provide others with additional ideas to consider including in their courses and to gain inspiration for inclusions in ours.