Because of the growing importance of concurrent programming, many people are trying to figure out where in the curriculum to introduce students to concurrency. In this paper we discuss the use of concurrency in an introductory computer science course. This course, which has been taught for ten years, introduces concurrency in the context of event-driven programming. It also makes use of graphics and animations with the support of a library that reduces the syntactic overhead of using these constructs. Students learn to use separate threads in a way that enables them to write programs that match their intuitions of the world. While the separate threads do interact, programs are selected so that race conditions are generally not an issue.

Assignments determine much of what students actually take away from a course. Sadly, creating successful assignments is difficult and error prone. With that in mind, the Nifty Assignments session is about promoting and sharing successful assignment ideas, and more importantly, making the assignment materials available for others to adopt.

We describe a new introductory course based on an unusual approach to the development of a breadth-first curriculum. The course focuses on exploring examples that illustrate a broad collection of the facets of computer science, but it draws all of these examples from a single subfield, computer networks. We demonstrate how this approach provides a more coherent educational experience for students while emphasizing the essentials that tie all of the fields of our discipline together.

Squint is a Java library developed to support the use of event-driven programming and network applications in programming examples for a CS1 curriculum. We present the design of the library, emphasizing techniques employed to minimize the effort students expend learning features specific to the library. We also compare Squint to an established library that supports event-driven programming in CS1, emphasizing ways in which the two libraries support similar pedagogical approaches.

The approach to teaching recursion in introductory programming courses has changed little during the transition from procedural to object-oriented languages. It is still common to present recursion late in the course and to focus on traditional, procedural examples such as calculating factorials or solving the Towers of Hanoi puzzle. In this paper, we propose that the shift to object-oriented programming techniques calls for a significant shift in our approach to teaching recursion. First, we argue that in the context of object-oriented programming students should be introduced to examples of simple recursive structures such as linked lists and methods that process them, before being introduced to traditional procedural examples. Second, we believe that this material should be presented before students are introduced to structures such as arrays. In our experience, the early presentation of recursive structures provides the opportunity to reinforce the fundamentals of defining and using classes and better prepares students to appreciate the reasons to use classes to encapsulate access to other data structures when they are presented.

We have recently designed a CS 1 course that integrates event-driven programming from the very start. Our experience teaching this course runs counter to the prevailing sense that these techniques would add complexity to the content of CS 1. Instead, we found that they were simple to present and that they also simplified the presentation of other material in the course. In this paper, we explain the approach we used to introduce event-driven methods and discuss the factors underlying our success.

This paper argues that current approaches to teaching the introductory course for the CS major fail to provide students with an accurate sense of the nature of our field. We propose that an introductory course focused on a single sub-field of our discipline could better prepare potential majors by using that sub-field as a vehicle to present an overview of the techniques and principles fundamental to computer science. We discuss our experience with such a course based on the field of computer networks.

In this paper we describe a library we have developed that supports an "OO-from-the-beginning" approach to CS 1. The use of real graphics "objects" and event-driven programming are important components of our approach. The design of interactive graphical programs helps students to both use objects and write methods early while designing and implementing interesting programs.

Over the last several years, much interesting work has been done in modelling object-oriented programming languages in terms of extensions of the bounded second-order lambda calculus, F . Unfortunately, it has recently been shown by Pierce ([Pie92]) that type checking F is undecidable. Moreover, he showed that the undecidability arises in the seemingly simpler problem of determining whether one type is a subtype of another. In [Bru93a, Bru93b], the first author introduced a statically-typed, functional, object-oriented programming language, TOOPL, which supports classes, objects, methods, instance variables, subtypes, and inheritance. The semantics of TOOPL is based on F , so the question arises whether type checking in this language is decidable. In this paper we show that type checking for TOOPLE, a minor variant of TOOPL (Typed Object-Oriented Programming Language), is decidable. The proof proceeds by showing that subtyping is decidable, that all terms of TOOPLE have minimum types...

The conventional storage allocation scheme for block structured languages requires the allocation of stack space and the building of a dmplay with each procedure call.Several techniques have been proposed for analyzing the call graph of a program that make it possible to eliminate these operations from many call sequences.In this paper.we compare these techniques and propose an improved allocation scheme which can substantially reduce allocation overhead, even in the presence of recursion and support for separate compilation.

The choice of binding time disciplines has major consequences for both the run-time efficiency of programs and the convenience of the language expressing algorithms. Late storage binding time, dynamic allocation, provides the flexibility necessary to implement the complex data structures common in today's object oriented style of programming. In this paper we show that compile-time lifetime analysis can be applied to programs written in languages with static type systems and dynamically allocated objects, to provide earlier storage binding time for objects, while maintaining all the advantages of dynamic allocation.

The conventional storage allocation scheme for block structured languages requires the allocation of stack space and the building of a display with each procedure call. This paper describes a technique for analyzing the call graph of a program in a block structured language that makes it possible to eliminate these operations from many call sequences, even in the presence of recursion.