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.

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

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.

Developing sophomore-level programming assignments that are both interesting to students and that have a good balance between low-level and high-level concepts is a difficult thing to do. The PNG Palette Permuter is a large assignment that does achieve this balance while still being based on topics such as encryption and image processing which students find interesting and relevant. Specifically, the Permuter involves compression, encryption, and steganography. This paper presents this project and discusses the interesting high and low-level issues that occur.

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.

The traditional way to teach Prolog is to have students start by writing recursive mathematical definitions of the problems they are trying to solve. While this is an effective technique, it does not fit well into a Programming Languages course that uses a single demonstration language to illustrate the different paradigms. Thus, we have developed an approach to introduce students to Prolog via our demonstration language, Scheme. Additionally, we performed an experiment to determine if the Scheme to Prolog approach is as effective at introducing Prolog as the more traditional recursive mathematical definition approach.

Today's 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 today's 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.

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.

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.

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.

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

Inheritance is a central topic in most introductory object-oriented programming courses and frequently the most challenging for students to comprehend. The difficulties students experience often center around the rather complicated and obscure dynamic method invocation algorithms used in languages like C++ and Java. We present a visual model for teaching inheritance that captures the essential aspects of these algorithms yet is easy for students to comprehend and apply.

The Programming Languages course is often a critical turning point in an undergraduate education where students begin to think more abstractly about programming languages and the design paradigms that use them. Traditional approaches to presenting this material often fail to achieve a number of important goals. We present an approach to Programming Languages that uses a single demonstration language (Scheme) and a collection of fundamental building blocks to study a variety of programming paradigms.

Image related computations are becoming mainstream in today's computing environment. However, Computer Science departments still offer image related courses mostly as electives or at the graduate level. As imaging's importance increases, one needs to consider its coverage at the core courses. Most departments cannot afford to add another course into their curriculum at this level, so the only remaining choice is to integrate image related applications into the existing core courses. This paper addresses this issue as it relates to an Algorithms course. The specific prerequisites and goals of our Algorithms course are described. The image related applications that have been adopted are presented and their impact on the course is discussed.

Images taken with wide angle and inexpensive medium angle lenses show substantial distortion, which will cause many computer vision applications to malfunction. Parametric calibration algorithms cannot handle the wide range of possible distortion functions and they require a known image center, expensive equipment, and/or estimation of unneeded parameters. We present a new algorithm to remove distortion. It is similar to the plumb line method but it: (a) uses images of spheres rather than lines, (b) corrects to stereographic rather than perspective projection, (c) calibrates aspect ratio, and (d) uses a nonparametric distortion model.

Presents a method for calibrating intrinsic and extrinsic camera parameters. This algorithm can easily be modified by other users to suit their particular calibration needs, without requiring a high-precision calibration target or complicated linear algebra. The algorithm uses controlled motions and a single light source to simulate calibration targets in convenient 3D locations. These convenient calibration targets enable us to simplify the calibration algorithm and gather dense data for lens distortion. Dense data makes the distortion correction more accurate than traditional low-order polynomial fits, and allows us to calibrate wide-angle lenses (>70/spl deg/ field of view).>