Roughly once per decade, the ACM and IEEE-Computer Society form a joint task force to produce curricular guidelines for undergraduate computer science programs. The latest guidelines document, Computer Science Curricula 2013 (CS2013), was released in December 2013. CS faculty at many institutions are interested in understanding CS2013, evaluating their curricula against it, and adopting some or all of the recommendations. This task is non-trivial at any institution, but it can be particularly challenging at small or liberal arts institutions. For instance, small schools with few faculty are limited in the number of courses they can offer, and many liberal arts colleges place limits on the number of courses that can be required for a major. How might a department with limited resources trade off covering the core while still providing electives to students? A meta-issue involves mapping CS2013 at all: Given the demands on a small department, are there ways to improve and update a curriculum without having to go through a complete CS2013 mapping? In this workshop we will: (1) give a brief overview of CS2013, (2) describe experiences mapping individual courses or an entire curriculum to CS2013, (4) split participants into working groups for course or curricular mapping based on starting points and goals, (4) re-group to share lessons learned from the mapping experience. Laptop Strongly Recommended.

Web-based programming exercises are a useful way for students to practice and master essential concepts and techniques presented in introductory programming courses. Although these systems are used fairly widely, we have a limited understanding of how students use these systems, and what can be learned from the data collected by these systems.

Innovative tools and teaching practices often fail to be adopted by educators in the field, despite evidence of their effectiveness. Naïve models of educational change assume this lack of adoption arises from failure to properly disseminate promising work, but evidence suggests that dissemination via publication is simply not effective. Instead of studying the adoption or rejection of a particular intervention, this paper turns the problem around. We asked educators to describe changes they had made to their teaching practice and analyzed the resulting stories to learn more about: the kinds of changes being made, their motivations for changing their practice, and the means by which they learned of pedagogical innovations. Of the 99 change stories analyzed, only three demonstrate an active search for new practices or materials on the part of teachers, and published materials were consulted in just eight of the stories. Most of the changes occurred locally, without input from outside sources, or involved only personal interaction with other educators. These results have important implications for educational developers, or researchers wishing to propagate information about new teaching materials or techniques.

We often learn of successful pedagogical experiments, but we seldom hear of the the ones that failed. For this special session we solicited submissions from the SIGCSE membership, selected the best from among these, and will have presentations at the session by the selected authors. Our contributions describe pedagogical approaches that seemed to be good ideas but turned out as failures. Contributors will describe their pedagogical experiment, the rationale for the experiment, evidence of failure, and lessons learned.

It is important for students to be able to select and apply the appropriate data structure for the problem to be solved. Testing this knowledge on exams can be difficult, however. We examined 59 data structures final exams and found only 36 that contained questions involving the application of data structures. To promote assessment of this knowledge in the data structures course, we present a framework for classifying apply exam questions, with illustrations from the exams collected. We then show how a number of questions can be developed by varying a single rich apply question along the dimensions of this framework

Is there consensus on what students should learn in CS2? Should they learn to use data structures, understand their specific implementation details, or both? Finally, has the computing education community's answer to the second question changed over time? In this paper, we begin to explore these questions based on an analysis of a key artifact instructors use to assess their students' performance: their final exams. Specifically, we look at two CS2 concepts as covered in those exams: stacks and hashtables.

This paper presents an analysis of the data on representation of women in US liberal arts computer science departments, using 10 years' worth of IPEDS data. What began as a search for departments with exemplary representation ended with the conclusion that the representation data is too unstable to be a useful measure of success: The correlation between average representation values in consecutive five-year periods is small, only r=0.156, and not significantly different from zero (p=0.143, t=1.477) for this set of institutions. Other metrics and sample populations are considered with similar results. This result has important implications for studies assessing the impact of departmental interventions on the representation of women, as well as research on the factors that influence representation.

Data sharing is common, and sometimes even required, in other disciplines. Creating a mechanism for data sharing in computer science education research will benefit both individual researchers and the community. While it is easy to say that data sharing is desirable, it is much more difficult to make it a practical reality.

This paper describes a multi-institutional study that used categorization exercises (known as constrained card sorts) to investigate gender differences in graduating computer science students' learning and perceptions of programming concepts. Our results show that female subjects had significantly less pre-college programming experience than their male counterparts. However, for both males and females, we found no correlation between previous experience and success in the major, as measured by computer science grade point average at graduation. Data also indicated that, by the time students completed their introductory courses, females reported nearly equal levels of mastery as males of the programming concepts. Furthermore, females generally considered the programming concepts to be no more difficult than did the men.

Research on learning suggests the importance of helping students organize their knowledge around meaningful patterns of information. This paper reports on a multi-institutional study to investigate how senior computer science majors articulate and organize their knowledge of programming concepts using a card-sorting technique adopted from knowledge acquisition. We show that card-sorts are an effective means of eliciting students' knowledge structures and suggest they can also be used to help students organize their knowledge throughout the curriculum.

Abstract: This paper describes a multi-institutional study that used a repeated single-criterion card sort to investigate graduating computer science students' knowledge of programming concepts. The study seeks to improve computer science instruction by gaining insight into how graduating students retain and assimilate introductory programming knowledge into their broader understanding of the discipline. A total of 291 card sorts was elicited from 65 undergraduate students in their final year of study at eight colleges and universities throughout the USA. To fully exploit the rich qualitative and quantitative aspects of the card sort data, an integrative analysis process was used that combined content analysis with two measures, normalized minimum spanning tree and edit distance, both developed specifically to analyze card sort data.

Abstract: This paper presents a case study of the use of a repeated single-criterion card sort with an unusually large, diverse participant group. The study, whose goal was to elicit novice programmers' knowledge of programming concepts, involved over 20 researchers from four continents and 276 participants drawn from 20 different institutions. In this paper we present the design of the study and the unexpected result that there were few discernible systematic differences in the population. The study was one of the activities of the National Science Foundation funded Bootstrapping Research in Computer Science Education project (2003).

The rapid growth of wireless communications services and networks has led departments to consider offering elective courses on the topic. Textbooks exist that can help support such a course, but providing students with hands-on wireless networking experience can be difficult and expensive.We present the outline of a wireless networking course that can be offered with minimal resources, and describe our experiences using the approach. The students who took the initial offering of the course gained hands-on experience with wireless networking, did traditional sockets programming, and acquired the theoretical foundations of both traditional and wireless networking.Students implement a simplified IEEE 802.11 Wireless Ethernet MAC layer as a course project. In our case, the implementations took advantage of the Cybiko, a $50 wireless handheld computer targeted at teenagers. Our materials are currently being ported to other platforms, including Bluetooth-enabled Palms and networks of workstations. The latter platform will allow this project to be conducted without any special resources.

No abstract available.

We are developing innovative new laboratory materials that give students a hands-on introduction to both traditional and wireless networking concepts. Our labs are designed around the Cybiko, a powerful multi-functional wireless handheld computer that sells for less than $50. The materials can be used to augment existing networking courses or as the core of a new upper-level course. This paper describes the labs completed to date, our plans for the future, and presents the results of a comparative study using the labs to demonstrate routing algorithms.

Being exposed to well-written code is a valuable experience for students—especially when the code is larger or more complex than they are currently capable of writing. In addition to the mechanics of a particular computation, students learn organization and documentation skills, and general concepts illustrated by the specific program. However, to obtain these benefits, students must thoroughly familiarize themselves with the code. This paper describes recent successes using software bugs as a means to force familiarization with network protocol code. The bugs become tools by which the students learn the inner workings of network protocols. As a side benefit, the approach provides a concrete basis for the discussion of debugging approaches and techniques. The technique is appropriate for any course involving programming, and is especially good for upper-level courses like networks, operating systems, and parallel and distributed programming, where difficult concepts can be illustrated via sample programs.

In this paper, we describe Teapot, a domain-specific language for writing cache coherence protocols. Cache coherence is of concern when parallel and distributed systems make local replicas of shared data to improve scalability and performance. In both distributed shared memory systems and distributed file systems, a coherence protocol maintains agreement among the replicated copies as the underlying data are modified by programs running on the system. Cache coherence protocols are notoriously difficult to implement, debug, and maintain. Moreover, protocols are not off-the-shelf, reusable components, because their details depend on the requirements of the system under consideration. The complexity of engineering coherence protocols can discourage users from experimenting with new, potentially more efficient protocols. We have designed and implemented Teapot, a domain-specific language that attempts to address this complexity. Teapot's language constructs, such as a state-centric control structure and continuations, are better suited to expressing protocol code than those of a typical systems programming language. Teapot also facilitates automatic verification of protocols, so hard to find protocol bugs, such as deadlocks, can be detected and fixed before encountering them on an actual execution. We describe the design rationale of Teapot, present an empirical evaluation of the language using two case studies, and relate the lessons that we learned in building a domain-specific language for systems programming.

Recent shared-memory parallel computer systems offer the exciting possibility of customizing memory coherence protocols to fit an application's semantics and sharing patterns. Custom protocols have been used to achieve message-passing performance---while retaining the convenient programming model of a global address space---and to implement high-level language constructs. Unfortunately, coherence protocols written in a conventional language such as C are difficult to write, debug, understand, or modify. This paper describes Teapot, a small, domain-specific language for writing coherence protocols. Teapot uses continuations to help reduce the complexity of writing protocols. Simple static analysis in the Teapot compiler eliminates much of the overhead of continuations and results in protocols that run nearly as fast as hand-written C code. A Teapot specification can be compiled both to an executable coherence protocol and to input for a model checking system, which permits the specification to be verified. We report our experiences coding and verifying several protocols written in Teapot, along with measurements of the overhead incurred by writing a protocol in a higher-level language.

Higher-level parallel programming languages can be difficult to implement efficiently on parallel machines. This paper shows how a flexible, compiler-controlled memory system can help achieve good performance for language constructs that previously appeared too costly to be practical.