Before object-oriented techniques were developed, procedural programming languages such as Pascal and C were taught in CS 1 courses. By virtue of the procedural paradigm, the focus of programming was on algorithms. Consequently, teaching methods concentrated on how to develop functions or methods that implement efficient algorithms using the various syntactic structures in the language. When object-oriented approach was brought into the curriculum, teaching methods still maintained the algorithmic focus but within the context of the object-oriented paradigm. The objects-first movement emerged and encouraged instructors to emphasize object modeling as an early focus of instruction. That is, students will start writing code with objects and their behaviors from the beginning of the curriculum.

Most modern programming languages, like Java and C# contain extensive libraries of data structures. Even if a data structure isn't implemented in a library, a quick Google search often returns hundreds or thousands of hits. For these reasons, asking students to implement a standard data structure is becoming a thing of the past. Instead, it is necessary to find data structures closely related to the standard ones, but different enough that students find programming them fun and meaningful. 2D trees provide one such example.

Retaining students in Computer Science may be improved by engaging them in the learning process while preventing them from becoming overly frustrated. While engaging students during lecture is certainly important, most students spend a significant amount of time working on programming projects outside of class. Gaining a deep understanding of student engagement in programming is difficult, since the instructor is seldom present during the process. This paper presents the results of student surveys administered after each programming project for multiple sections of two courses: CS2, and Data Structures and Algorithms. We analyze the data in terms of engagement, frustration and niftiness.

Examples are crucial for helping students learn new ideas. In an objects-first curriculum, the objects presented by the instructor play a key role in motivating and explaining an object-oriented approach. We know the example of a Program class with a HelloWorld() method is a bad choice. So what are good examples of objects for beginning CS students? For non-majors? What are good examples of objects for teaching conditional logic? Looping? Composition? Inheritance? In this session, 00 educators present examples of objects successfully used in their CS0 and CS1 classes. Significant time will be made available for discussion of the examples.

Attracting and retaining quality students is an ongoing concern in Computer Science. Retention can be enhanced by keeping students engaged in the learning process while preventing them from becoming overly frustrated. While engaging students during class is certainly important, most students spend a significant amount of time working on programming projects outside of class. The goal of this research was to collect and analyze some initial data on how engaging and frustrating our students find our programming projects. During the Spring 2006 semester we surveyed our students after each programming project. This paper presents some initial findings from the surveys and discusses strategies on how to improve our projects based on this feedback.

Model-view-controller (MVC) is an important architectural design pattern that frequently does not receive the attention it deserves. It is generally treated as a prescriptive design pattern, where students are taught to use three different categories of objects to construct GUI programs. There are subtle and important aspects of MVC that anyone developing GUIs should know. We approach these issues in our classes by taking relatively simple GUI programs and refactoring them. Our emphasis is on examining the strengths and tradeoffs involved with the various design decisions. We illustrate our approach in this paper using a simulated stopwatch.

Many instructors use program runtimes to illustrate and reinforce algorithm complexity concepts. Hardware, operating systems and compilers all influence the runtimes, but generally not to the extent of making the data difficult to interpret. The Java virtual machine adds an additional layer of software, making it much harder to see the relationship between the runtimes and the underlying algorithm. This paper presents some of the basic issues the author and his students have encountered when analyzing Java program runtimes and briefly discusses strategies to address them.

The event driven paradigm is ubiquitous in modern software. Many texts introduce events when discussing graphical user interfaces, but the event paradigm extends well beyond that domain. Events also play important roles in operating systems, component based systems, reactive systems, middleware, web services and other fields. Computer science educators have an obligation to see that our students thoroughly understand the event paradigm and have some grounding in tools to develop event driven systems. This paper describes an upper division, computer science elective course in event driven programming. The course gives a comprehensive treatment of event driven systems. It appropriately captures the importance of the event paradigm and serves to integrate concepts from several different computing fields, including Programming Languages, Operating Systems, and Software Engineering. It also introduces students to advanced tools and packages designed for developing event driven systems. The course has been taught four times at our institution, having repeatedly received high marks from the students for both its conceptual and technical content.

This paper presents Graph Magic, a package of Java classes that represents graphs. It is specifically designed for undergraduate students to use early in their studies. It combines graph visualization with ease of programming. It allows students to implement graph algorithms using high level, easy to understand methods. Students create graphs for their programs interactively. Their programs manipulate the graphs while the students continue to view them. The emphasis on interactive editing combined with interruptible viewing provides a powerful tool for student exploration of graph concepts and algorithms.

Empirical skills are playing an increasingly important role in the computing profession and our society. In addition to being problem-solvers and designers/engineers, computer scientists must also be capable experimenters in order to develop, test, and evaluate complex hardware and software systems. The widespread use of computers as tools for interdisciplinary research also demands a strong grounding in the scientific method.This panel is designed to promote discussion about innovative methods for integrating empirical skills within the traditional computer science curriculum. Each panelist will define a set of core empirical concepts and skills that they see as essential to computer scientists, with a brief rationale for each. In conjunction, they will describe classroom practices that serve to demonstrate the key concepts and/or develop skills they have identified. Sufficient time will be allocated for discussion and contributions from the audience.

This paper presents an object-oriented approach to the problem of finding optimal binary search trees. We show that object-oriented techniques produce a solution that is an improvement over those created procedurally and that is well within the reach of our undergraduate students. Combining the study of optimality with that of object-oriented design helps the students gain a deeper appreciation of both.

The Common Object Request Broker Architecture (CORBA) provides a middleware infrastructure that allows applications running on different hardware and operating systems, and developed in different languages to work together seamlessly. CORBA supplies high-level libraries and utilities that hide the details of message passing, making it relatively painless to develop distributed systems. We have used CORBA in two different undergraduate courses, CS1 and an advanced elective entitled Event Driven Programming. In CS1 students are presented with a CORBA based email server and develop a simple email client to communicate with it. In Event Driven Programming students use CORBA to develop client-server and peer to peer applications. We have found that CORBA is an ideal infrastructure for introducing distributed computing at both levels. Students are relieved of the necessity to learn low level communication primitives and can concentrate almost entirely on application design and development issues. This paper provides a brief high-level overview of CORBA and then discusses how we have used CORBA in our courses. We also include analysis of some preliminary data analysis on problems students encountered while developing CORBA based applications.

Bioinformatics is the application of computer science techniques to problems in molecular biology. It is generally studied at the graduate level, because most real world bioinformatics problems require an in-depth knowledge of both biological processes and computer algorithms. Modeling some biological processes, however, is well within the reach of undergraduate computer science students. We have introduced CS1 students to basic bioinformatics concepts via a closed lab exercise and a programming project. The students found the activities engaging and fun. This paper discusses the implementation of these activities and some of the results/lessons we learned.