Moving Away from Programming and Towards Computer Science in the CS First Year

After completing a pilot study using the Python programming language to transition to Java within our first-year introductory programming sequence, our department opted to make a more radical change. We assert that our students are better served in their first year of study by a focus on problems in computer science and their solutions, rather than programming. Our new introductory sequence emphasizes algorithm development and analysis, object-oriented design, and testing. As in our pilot, programming is first done in Python, switching to Java when object-oriented design and static typing become advantageous. Students reported liking the problem focus of the courses, while the distribution of grades remained similar to those in previous years. As a result, our department will be discontinuing our earlier introductory sequence, and offering the new problem-based one to all the groups of students our department services beginning in Fall 2010

A Pattern for Distributing Turn-Based Games

A common choice of applications used in introductory computer science courses is from the domain of simple games. Games present some interesting design notions including move, outcome, state, and turn. If one focuses on the notion of a turn a new design is revealed that combines the familiar patterns of the Model- View-Controller architecture and Proxy when the game is played over a network

Design Patterns in Parsing

oops3, targeted to Java and C#, is the latest in a family of LL(1) parser generators based on an object-oriented architecture that carries through to the parsers it generates. Moreover, because oops3 employs several design patterns, its rich variety of APIs are nevertheless easy to learn. This paper discusses the use of patterns in the oops3 system and the resulting benefits for users and educators

Functional Parsing — A Multi-Lingual Killer-Application

Monads are used in Haskell to support error handling and a concept of global state such as input/output. Parsing is a killer application for monads. This paper discusses a parser generator implementation for Java and JavaScript and shows how to benefit greatly from object-oriented design patterns based on monads adapted from functional programming. All examples discussed here are available for online use through the links at the end of the paper

Sudoku: A Little Lesson in OOP

Paying only lip service to the principles of object-oriented programming rarely results in the expected benefits. This paper presents a series of designs for a Sudoku application that will lead introductory students through the allimportant process of trial and error. They will see examples of design analysis, criticism, and improvement. The paper concludes with some general pointers why and how the initial mistakes could have been avoided

Introductory programming: a systematic literature review

As computing becomes a mainstream discipline embedded in the school curriculum and acts as an enabler for an increasing range of academic disciplines in higher education, the literature on introductory programming is growing. Although there have been several reviews that focus on specific aspects of introductory programming, there has been no broad overview of the literature exploring recent trends across the breadth of introductory programming. This paper is the report of an ITiCSE working group that conducted a systematic review in order to gain an overview of the introductory programming literature. Partitioning the literature into papers addressing the student, teaching, the curriculum, and assessment, we explore trends, highlight advances in knowledge over the past 15 years, and indicate possible directions for future research

LRP&EC Report on Charge #3 - Dining Charge from AY2018 (10-17-2019)

LRP&EC Report on Charge #3 - Dining Charge from AY2018 (10-17-2019)Academic Senat

Structuring Resilient Distributed Programs with the Activity Model

Although the technology exists to build networks of computers providing a wide range of capabilities that one would like to be able to exploit in solving a problem, programming systems that facilitate the design of distributed programs are rare. This is especially true with regard to the structuring of distributed computations. Thus the focus of the work described in this paper has been to address this question of how to structure a distributed program. The result is the development of a model of activities. A second objective of the project has been to investigate strategies for managing the dynamic behavior of a distributed computation and to provide flexible tools to support implementation of such control. We propose a set of high level language constructs and a support system to allow a designer to specify responses to failures that are appropriate to the particular application under development