Parallel and Distributed Computing (PDC) has increased in importance in recent years, with ABET requiring exposure to PDC topics, and CS2023 recommending at least 9 hours of coverage in required CS courses. However, injecting PDC topics quickly into a course is difficult due to time and expense to set up requisite hardware and lack of readily available materials to adopt for the classroom. In this demo, we -- the CSinParallel project -- present free, web-based, interactive textbooks for learning and practicing various forms of PDC. We developed the backend system and wrote the material based on decades of experience integrating these topics into courses throughout the computer science curriculum. Currently we have two books that educators can readily use: Parallel Computing for Beginners, and Intermediate Parallel and Distributed Computing, along with some additional materials. With just a laptop in class, students can edit and run PDC code examples on remote hardware that is professionally maintained, eliminating the need for instructors to prepare hardware and software. The material spans a range of PDC technology (OpenMP, MPI, CUDA, OpenACC), provides mini assessments as readers work, and is designed so that instructors can add brief modules into existing courses or can be used comprehensively for a course dedicated to PDC. All materials are available on learnpdc.org and the code used in the books is on https://github.com/csinparallel/csinparallel. Additional assignments for a PDC course can be found on https://github.com/csinparallel/pdc-assignments.

Parallel and distributed computing (PDC) concepts are now required topics for accredited undergraduate computer science programs. However, introducing PDC into the CS curriculum is challenging for several reasons, including an instructor's lack of PDC knowledge and difficulties in accessing PDC hardware. This paper addresses both of these challenges by presenting free, interactive, web-based PDC teaching modules using inexpensive Raspberry Pi single board computers (SBCs). Our materials include a free disk image that makes it possible for instructors to build Raspberry Pi clusters in minutes and use our software in a variety of curricular contexts. Our multi-year assessment of these materials on students and faculty members indicates that: (i) our materials increased students' confidence regarding important PDC concepts and motivated them to study PDC further; and (ii) our materials increased faculty members' confidence and preparedness in teaching key PDC concepts at their own institutions. • Free online interactive modules for learning PDC with Raspberry Pis and Pi clusters. • Self-organizing cluster: connects disparate Pis into a working cluster in minutes. • Free disk image pre-loaded with all activities for painless classroom adoption. • Our materials increase student confidence about PDC and motivation to learn more PDC. • Our materials increase faculty confidence and preparedness to teach PDC.

Abstract topics such as recursion are challenging for many computer science students to understand. In this experience report, we explore function sonification-the addition of sound to a function to communicate information about the function's behavior in real-time as it runs-as a pedagogical approach for improving students' understanding of recursion. We present several example iterative and recursive function sonifications, plus spectrograms that illustrate their different sonic behaviors. We also present experimental evidence that using these sonifications significantly improved the understanding of recursion for students who used them, compared to students who used silent (i.e., traditional) versions of the same functions. Based on these experiences, we believe sonification has under-appreciated potential for teaching abstract computing topics.

Much work already exists on algorithm visualization-the graphical representation of an algorithm's behavior-and its benefits for student learning. Visualization, however, offers limited benefit for students with visual impairments. This paper explores algorithm sonification-the representation of an algorithm's behavior using sound. To simplify the creation of sonifications for modern algorithms, this paper presents a new Thread Safe Audio Library (TSAL). To illustrate how to create sonifications, the authors have added TSAL calls to four common sorting algorithm implementations, so that as the program accesses a value being sorted, the program plays a tone whose pitch is scaled to that value's magnitude. In the resulting sonifications, one can (in real time) hear the behavioral differences of the different sorting algorithms as they run, and directly experience how fast (or slow) the algorithms sort the same sequence, compared to one another. This paper presents experimental evidence that the sonifications improve students' long-term recall of the four sorting algorithms' relative speeds. The paper also discusses other potential uses of sonification.

The 2019 ABET computer science criteria requires that all computing students learn parallel and distributed computing (PDC) as undergraduates, and CS2013 recommends at least fifteen hours of PDC in the undergraduate curriculum. Consequently, many educators are looking for easy ways to integrate PDC into courses at their institutions. This hands-on workshop introduces Message Passing Interface (MPI) basics in Python or C/C++ using clusters of Raspberry Pi single-board computers. MPI is a multi-language, platform independent, industry-standard library for PDC. Raspberry Pis are an inexpensive and engaging hardware platform for studying PDC as early as CS1. Participants will experience how to teach distributed computing essentials with MPI by means of reusable, effective "parallel patterns," including single program multiple data (SPMD) execution, send-receive message passing, and parallel loop patterns. No prior experience with MPI, PDC, or the Raspberry Pi is expected; participants will explore short programs designed to help students understand MPI basics, plus longer "exemplar" programs that use MPI to solve significant applied problems. The workshop includes: (i) personal experience with the Raspberry Pi (clusters provided); (ii) instructions on how to deploy Raspberry Pi clusters quickly in the classroom; (iii) self-paced hands-on experimentation with MPI programs; and (iv) a discussion of how to use Raspberry Pi clusters to align courses with CS2013 and ABET. All materials from this workshop are available from CSinParallel.org; participants should bring a laptop to access materials and connect to the Raspberry Pi clusters.

With both CS2013 and the most recent ABET computing criteria requiring coverage of parallel and distributed computing (PDC), many CS faculty are looking for ways to incorporate PDC concepts into their curricula. However, the COVID-19 pandemic and the switch to remote teaching introduces new difficulties to teaching a subject that many already find challenging. This BOF provides a forum for computing educators to discuss strategies they have used to teach PDC remotely. The organizers will share techniques that they have found effective (including the different tradeoffs those techniques involve) and foster a discussion in which others can share novel ways of teaching PDC remotely. The end-goals are: (i) to provide a venue in which those who have taught PDC remotely can share their experiences, in the hopes of identifying best practices; and (ii) to enable participants who are new to PDC to learn from the experiences of faculty who have already taught such courses in this new environment. No laptop required; any materials resulting from this session will be distributed via CSinParallel.org.

As we consider the next fifty years of computing education, a phenomenon that shows no signs of abating is the data deluge, in which commercial companies, the natural sciences, the social sciences, professional sports teams, government agencies, and other institutions are generating ever-increasing quantities of data. To address the challenges posed by the data deluge, the discipline of data science has arisen, and an increasing number of universities are offering undergraduate data science programs. Many of these programs have their origins in a computer science or a statistics department, leading to a data science curriculum that is more heavily weighted toward computing or statistics. By contrast, the data science program described in this paper is a joint endeavor between computer science and statistics that seeks to provide balanced training in both areas. Its broad goals are to produce students who (a) are well-trained in both computer science and statistics, (b) are equipped with specialized data-related skills that are not normally taught in either of those disciplines, and (c) can apply their skills to a domain area. This paper reports on the author's experiences leading the effort to create this program, which has seen good growth, received positive feedback from students, and is successfully preparing students for internships. We offer this report in the hope that it may serve as a model for other institutions considering the addition of an undergraduate data science program.

Teaching parallel and distributed computing (PDC) concepts is an ongoing and pressing concern for many undergraduate educators. The ACM/IEEE CS Joint Task Force on Computing Curricula (CS2013) recommends 15 hours of PDC education in the undergraduate curriculum. Most recently, the 2019 ABET Criteria for Accrediting Computer Science requires coverage of PDC topics. For faculty who are unfamiliar with PDC, the prospect of incorporating parallel computing into their courses can seem very daunting. For example, should PDC concepts be covered in a single required course (perhaps computer systems) or be scattered throughout different courses in the undergraduate curriculum? What languages are the best/easiest for students to learn PDC? How much revision is truly needed? This Birds of a Feather session provides a platform for computing educators to discuss the common challenges they face when attempting to incorporate PDC into their curricula and share potential solutions. Chiefly, the organizers are interested in identifying "gap areas" that hinder a faculty member's ability to integrate PDC into their undergraduate courses. The multiple viewpoints and expertise provided by the BOF leaders should lead to lively discourse and enable experienced faculty to share their strategies with those beginning to add PDC across their curricula. We anticipate that this session will be of interest to all CS faculty looking to integrate PDC into their courses and curricula.

The 2019 ABET computer science criteria requires that all computing students learn parallel and distributed computing (PDC) as undergraduates, and CS2013 recommends at least fifteen hours of PDC in the undergraduate curriculum. Consequently, many educators look for easy ways to integrate PDC into courses at their institutions. This hands-on workshop introduces Message Passing Interface (MPI) basics in C/C++ and Python using clusters of Raspberry Pis. The Message Passing Interface (MPI) is a multi-language, platform independent, industry-standard library for parallel and distributed computing. Raspberry Pis are an inexpensive and engaging hardware platform for studying PDC as early as the first course. Participants will experience how to teach distributed computing essentials with MPI by means of reusable, effective "parallel patterns", including single program multiple data (SPMD) execution, send-receive message passing, the master-worker pattern, parallel loop patterns, and other common patterns, plus longer "exemplar" programs that use MPI to solve significant applied problems. The workshop includes: (i) personal experience with the Raspberry Pi (clusters provided for workshop use); (ii) assembly of Beowulf clusters of Raspberry Pis quickly in the classroom; (iii) self-paced hands-on experimentation with the working MPI programs; and (iv) a discussion of how these may be used to achieve the goals of CS2013 and ABET. No prior experience with MPI, PDC, or the Raspberry Pi is expected. All materials from this workshop will be freely available from CSinParallel.org; participants should bring a laptop to access these materials.

Classic synchronization problems are often used to introduce students to the subtleties of concurrency and synchronization mechanisms, such as semaphores, monitors, locks, and condition variables. The Dining Philosophers, Producers-Consumers, and Readers-Writers are all classic problems in which a correct solution requires the actions of multiple processes or threads to be synchronized. In this paper, we present visualizations for these three problems and describe their use as pedagogical tools to help students build accurate mental models of concurrency abstractions such as starvation, deadlock, livelock, and correct execution. We also present the results of an experiment that indicate students find using these visualizations to be significantly more engaging than reading a textbook, with no significant difference in learning. We do not claim that our visualizations should replace a course text; rather we present them as engaging pedagogical tools to complement the textbook in courses on Operating Systems, Programming Languages, and other courses where concurrency and synchronization are covered.

Classic synchronization problems are often used to introduce students to the subtleties of concurrency and synchronization mechanisms, such as semaphores, monitors, locks, and condition variables. The Dining Philosophers, Producers-Consumers, and Readers-Writers are all classic problems in which a correct solution requires the actions of multiple processes or threads to be synchronized. In this work, we present visualizations for these three problems and demonstrate their use in helping students build accurate mental models of concurrency abstractions. We also present the results of an experiment that indicate students find using these visualizations to be significantly more engaging than reading a textbook, with no significant difference in learning.

The ACM/IEEE CS 2013 report recommends fifteen hours of parallel & distributed computing (PDC) education for every undergraduate. This workshop illustrates the use of the Raspberry Pi as an inexpensive, multicore platform for teaching shared-memory parallel programming. The inexpensive and tactile nature of the Raspberry Pi enables each student to experience her own parallel multiprocessor through sight and touch. In this hands-on workshop, we will teach attendees how they can leverage the Raspberry Pi and the OpenMP library to teach shared-memory parallel concepts in their own classrooms. All CS educators who are interested in learning about the Raspberry Pi, shared memory parallelism, and OpenMP are encouraged to attend. In Part I of the workshop, each participant will connect to and learn about the Raspberry Pi's multicore capabilities. In Part II, each participant will engage in self-paced, hands-on exploration of basic parallel computing concepts using the OpenMP "patternlets" from CSinParallel.org. In Part III, participants will investigate more complex applications, such as numeric integration and drug design and study how these applications can be parallelized using OpenMP. We will conclude the workshop with a series of lightning talks discussing how the Raspberry Pi has been used to teach parallel computing concepts at different institutions. We will also present a summary of student perceptions of the Raspberry Pi. All materials from this workshop will be freely available from CSinParallel.org. Space is limited to 20 participants. A laptop is required.

The Raspberry Pi (R-Pi) is a single board computer priced at 35 USD -- less than the cost of many textbooks. The current model (3B) includes a quad-core ARM 64-bit CPU, 1GB of RAM, a GPU, and numerous communication ports, including USB, HDMI, Ethernet, WiFi and Bluetooth. This combination of low cost and high functionality creates many new pedagogical possibilities for CS educators, ranging from using the R-Pi to teach assembly language to using it as a multiprocessor. Relatedly, mathematics educators have produced an extensive literature on the use of pedagogical tools known as "manipulatives" that have been shown to be effective at starting students through a "concrete, representational, abstract" progression of understanding of an abstract topic. We believe that by using the R-Pi as a manipulative, this same "concrete, representational, abstract" progression can be used to help CS students master many topics that are often taught as abstractions. By providing a "concrete" foundation on which to build, a single board computer like the R-Pi can provide the first step in helping students build mental models of such abstractions, and thus enhance student learning. Experience also indicates that many students find the R-Pi to be a fun and enjoyable way to learn about these abstractions. In this panel session, four CS educators will share their experiences using the R-Pi in their courses, followed by a Q&A conversation between the audience and the panelists.

CS2013 brings parallel and distributed computing (PDC) into the CS curricular mainstream. The Message Passing Interface (MPI) is a platform independent, industry-standard library for parallel and distributed computing. The MPI standard includes support for C, C++, and Fortran; third parties have created implementations for Python and Java. This hands-on workshop introduces MPI basics and applications in C/C++ using Raspberry Pi single-board computers, as an inexpensive and engaging hardware platform for studying PDC. The workshop includes: (i) personal experience with the Raspberry Pi (units provided) accessed via participant laptops (Windows, Mac, or Linux); (ii) assembly of Beowulf clusters of Raspberry Pis quickly in the classroom; (iii) self-paced hands-on experimentation with the working MPI programs; and (iv) a discussion of how such clusters can be used to engage students in and out of the classroom. Participants will experience how to teach distributed computing essentials with MPI by means of reusable, effective "parallel programming patterns," including single program multiple data (SPMD) execution, send-receive message passing, the master-worker, parallel loop, and other common patterns. Participants will then explore more in-depth "exemplar" applications, such as drug design and epidemiology. All materials including the Raspberry Pi software system setup from this workshop will be freely available from CSinParallel.org. No prior experience with MPI, PDC, or the Raspberry Pi is required. Windows, Mac, or Linux laptop required.

With the requirement that parallel & distributed computing (PDC) topics be covered in the core computer science curriculum, educators are exploring new ways to engage students in this area of computing. In this paper, we discuss the use of the Raspberry Pi single-board computer (SBC) to provide students with hands-on multicore learning experiences. We discuss how the authors use the Raspberry Pi to teach parallel computing, and present assessment results that indicate such devices are effective at achieving CS2013 PDC learning outcomes, as well as motivating further study of parallelism. We believe our results are of significant interest to CS educators looking to integrate parallelism in their classrooms, and support the use of other SBCs for teaching parallel computing.

Parallel computing is one of the new knowledge units in the ACM/IEEE CS 2013 curriculum recommendations. This workshop will present the Raspberry Pi as an inexpensive hardware platform for providing each student with her own parallel processor. The tactile and visceral benefits of each student having her own machine and being able to take full advantage of its multicore capabilities are significant. In this hands-on workshop, we show how parallelism can be used to spread the workload of compute-intensive applications across the multiple cores of a Raspberry Pi, and explore its use as an inexpensive hardware platform for teaching parallel computing. CS educators who are interested in learning about parallel computing, OpenMP, and how to teach these concepts on a Raspberry Pi are encouraged to attend. Attendees will enjoy a hands-on hardware/software experience, exploring how parallel computations operate and work in practice. In Part I of the workshop, attendees will set up and explore a Raspberry Pi multi-core computer in small teams. In Part II, each team will use the parallel capabilities of the Raspberry Pi to explore parallel computation through the use of OpenMP "patternlets" published on CSinParallel.org. Part III explores applications of the Raspberry Pi to parallel applications such as image processing and population dynamics, using OpenMP. All materials from this workshop will be freely available from CSinParallel.org.

OpenMP is an industry-standard, platform-independent parallel programming library built into all modern C and C++ compilers. Unlike complex parallel platforms, OpenMP is designed to make it relatively easy to add parallelism to existing sequential programs, as well as write new parallel programs from scratch. In this fun, interactive, hands-on workshop, participants will use OpenMP to learn about a variety of parallel programming concepts, including single program multiple data (SPMD) execution, fork-join threading, parallel loops, parallel blocks, atomic execution, mutual exclusion, and others. Participants will explore 15 short programs designed to help students understand specific parallel concepts, plus several longer programs in which OpenMP is used to solve significant problems. The workshop includes: (i) an introduction to OpenMP, (ii) self-paced hands-on experimentation with the OpenMP programs, and (iii) a discussion of how OpenMP may be used to achieve parallel computing objectives in CS 2013. Participants will also view visual examples that let students see parallelism happening in real time. Participants will need a laptop with an SSH client (e.g., BitVise, PuTTY), or a laptop with a compiler that supports OpenMP (e.g., gcc 4.2 or later, Visual Studio 2008 or later); Linux, Mac, and Windows laptops will be supported. Knowledge of a C-family language (e.g., C, C++, Java, ...) may be helpful but is not required to benefit from the workshop. All materials from this workshop will be freely available from csinparallel.org.

Multicore processors are now the standard CPU architecture, and parallel and distributed computing (PDC) is in the CS2013 core curriculum [9]. It is now the task of CS educators to begin creating pedagogical materials that will help their students understand PDC concepts. In this paper, we present TSGL (the thread-safe graphics library), a C++11 library that safely supports multithreaded graphics. We also present several multithreaded visualizations that illustrate how TSGL can be used to visualize the Parallel Loop design pattern, and present evidence that TSGL can improve student mastery of this parallel abstraction.

Just as a micro-computer is a personal, portable computer, a micro-cluster is a personal, portable, Beowulf cluster. In this special session, six cluster designers will bring and demonstrate micro-clusters they have built using inexpensive single-board computers (SBCs). The educators will describe how they have used their clusters to provide their students with hands-on experience using the shared-memory, distributed-memory, and heterogeneous computing paradigms, and thus achieve the parallel and distributed computing (PDC) objectives of CS 2013 [1].

Map-reduce computation is the on-ramp to data-intensive cloud computing, and arguably the most widely deployed form of parallel/distributed computing. Participants will carry out exercises designed for students at CS1, intermediate, and advanced levels that introduce data-intensive scalable computing concepts using WebMapReduce (WMR), a simplified open-source interface to the dominant Hadoop map-reduce programming environment. WMR supports programming in a choice of languages including Python, Java, C++, and C#. Besides a hands-on experience with introductory teaching materials, the workshop includes an overview of teaching advanced map-reduce programming using WMR, and a comparison of WMR to direct Hadoop programming. All materials will reside on csinparallel.org, and the demonstration WMR system is reservable for participants' courses. Intended audience: CS instructors. Web-enabled laptop required.

CS2013 brings parallel and distributed computing (PDC) into the CS curricular mainstream. The Message Passing Interface (MPI) is a platform independent, industry-standard PDC library that includes support for C, C++, and Fortran; third parties have created implementations for Python and Java. This hands-on workshop introduces MPI basics using parallel patterns, including the single program multiple data (SPMD), send-receive message passing, master-worker, parallel loop, broadcast, reduction, scatter, gather, and barrier patterns. Participants will explore 12 short programs designed to help students understand MPI and PDC basics, plus longer programs that use MPI to solve significant problems. The intended audience is CS educators who want to learn about how message passing can be used to teach PDC. No prior experience with PDC or MPI is required; familiarity with a C-family language and the command-line are helpful but not required. The workshop includes: (i) self-paced hands-on experimentation with the working MPI programs, and (ii) a discussion of how these may be used to achieve the goals of CS2013. Participants will work on a remote Beowulf cluster accessed via SSH, and will need a laptop or a tablet with an SSH client (e.g., BitVise, iSSH), or a laptop with both a recent C/C++ compiler and MPI (e.g., OpenMPI or MPICH) installed. See http://csinparallel.org.

In response to the shift to multicore processors, the ACM-IEEE CS2013 curriculum recommendations [1] include parallel and distributed computing (PDC) as a new core knowledge area. Some of the key concepts in PDC are the distinctions between shared-memory, distributed-memory, and heterogeneous system architectures.

At our comprehensive liberal arts college, we offer a 2-credit hour CS1 course for engineering majors that includes all of the standard learning objectives of a typical 4-credit hour course. To help the students learn the course material in this compressed time frame, we switched our programming language from C++ to Python, and we replaced weekly homework assignments with labs and online problem sets. All other factors in the course were unchanged, including instructor, course and weekly learning objectives, tests, grading criteria, pedagogical style, and even textbook (the textbook came in two versions -- a C++ version and a Python version). This transition offered a unique opportunity to observe, compare, and measure student learning outcomes across the two semesters. Our measured results show a moderate but statistically significantly improvement from the semester using C++ and homework assignments to the semester using Python and online problem sets.

In today's multicore world, every CS student should learn about and gain experience with (at least) shared-memory parallelism. CS Curriculum 2013 acknowledges this by shifting parallel computing from elective status into the core. This paper argues that students should be introduced to parallelism early, that the CS2 (Data Structures) course is a natural place to do so, and reports our experience in doing this. The paper also argues that students should be taught to solve problems using parallel patterns, which are industry-standard best-practice strategies for parallel problem solving. To support such teaching, the paper presents patternlets -- minimalist, scalable, executable programs, each illustrating the behavior of a parallel pattern -- as a useful pedagogical tool for teaching parallel concepts. Several patternlets and their executions are given. The paper presents evidence that this injection of parallelism into CS2 has been successful.

Curriculum 2013 brings parallelism into the CS curricular mainstream. This hands-on workshop is intended for faculty with little or no background in parallel computing. OpenMP is a platform independent, industry-standard library for shared-memory parallel programming supported by all modern C and C++ compilers. The workshop introduces the basics of OpenMP multithreading using parallel patterns, including single program multiple data (SPMD) execution, fork-join threading, and pragmas for parallel loops, parallel blocks, mutual exclusion, etc. The workshop includes: (i) an overview of OpenMP, (ii) self-paced hands-on experimentation with the OpenMP programs, and (iii) a discussion of how these may be used to achieve the goals of Curriculum 2013. Workshop materials will be distributed from csinparallel.org. Participants will receive and explore 15 short programs designed to help students understand multithreading concepts, plus longer programs that use OpenMP to solve significant problems. A participant may explore these programs on their own laptop, provided it has installed a C/C++ compiler that supports OpenMP (e.g., gcc 4.2 or later; Visual Studio 2008 or later). Those comfortable with the command-line may explore the programs on our remote servers using a laptop or tablet with a suitable SSH client. Laptop recommended.

The industry shift to emerging forms of parallel and distributed computing (PDC), including multi-core CPUs, cloud computing, and general-purpose use of GPUs, have naturally led to increased presence of PDC elements undergraduate Computer Science curriculum recommendations, such as the new and substantial "PD" knowledge area in the ACM/IEEE CS2013 recommendations. How can undergraduate students grasp the extensive and complex range of PDC principles and practices, and apply that knowledge in problem solving, while PDC technologies continue to evolve rapidly? Parallel design patterns occur at all computational levels, ranging from low-level concurrent execution patterns (such as message passing or thread pool patterns) to high-level software design patterns suitable for organizing entire systems or their components (such as model-view-control or pipe and filter patterns). The ubiquity of these patterns in all forms of parallel and distributed computation makes parallel patterns relevant and illuminating at all undergraduate levels, and knowledge of those patterns can guide effective problem solving for parallel programs. This panel presents four viewpoints representing various approaches for teaching parallel patterns to CS undergraduates at various academic levels, including short "patternlets" examples, patterns in domain applications and parallel problem solving, and two tools, Seeds and Paraguin, for teaching parallel design patterns to undergraduates.

The ACM-IEEE CS2013 curricular recommendations include a dramatic growth in parallel and distributed computing (PDC) topics, in response to the necessary industry shift toward multicore computing, and to emerging technologies such as cloud computing. How can your institution integrate those recommendations into your undergraduate CS curriculum? In this special session, leaders in PDC education will succinctly present their curricular strategies in relation to CS2013 recommendations, while attendees carry out a workshop-style activity to identify opportunities and assemble resources for blending more PDC content into their own local CS curricula.

The new CS curricular recommendations call for a heightened emphasis on parallel and distributed computing (PDC), in response to the explosive growth of multicore processors and "cloud" distributed computing. How can an educator incorporate this urgent priority into undergraduate CS courses? This panel describes four approaches: exploring GPU architecture and programming in a Computer Organization course; incorporating shared memory parallelism into several core courses; adding the PDC notion of reduction to multiple CS courses; and inserting short PDC modules into many courses at multiple curricular levels. We will illustrate how these contrasting approaches all respond to PDC recommendations within the feasibility constraint of incrementally modifying individual courses.

The emerging CS2013 Curriculum recommendations call for greatly expanded emphasis on parallel and distributed computing (PDC), in response to recent industry changes. CS2013's PDC knowledge units relate to many undergraduate courses. Participants in this BOF will consider responses to CS2013 PDC recommendations that involve multiple undergraduate CS courses at an institution, as opposed to approaches that concentrate PDC topics primarily within a single course. This sharing and brainstorming session will bring together: people having experience with a multi-course or multi-level approach to teaching PDC; people contemplating a multi-course approach to introducing PDC material; and people wishing to provide and/or hear rationale for a multi-course strategy for teaching PDC.

Map-reduce, the cornerstone computational framework for cloud computing applications, has star appeal to draw students to the study of parallelism. Participants will carry out hands-on exercises designed for students at CS1/intermediate/advanced levels that introduce data-intensive scalable computing concepts, using WebMapReduce (WMR), a simplified open-source interface to the widely used Hadoop map-reduce programming environment. These hands-on exercises enable students to perform data-intensive scalable computations carried out on the most widely deployed map-reduce framework, used by Facebook, Microsoft, Yahoo, and other companies. WMR supports programming in a choice of languages (including Java, Python, C++, C#, Scheme); participants will be able to try exercises with languages of their choice. Workshop includes brief introduction to direct Hadoop programming, and information about access to cluster resources supporting WMR. Workshop materials will reside on csinparallel.org, along with WMR software. Intended audience: CS instructors. Laptop required (Windows, Mac, or Linux).

One of the challenges facing the U.S. technological workforce is that as fewer students take computing courses, fewer college graduates are being prepared for computing careers. Besides trying to attract more CS majors, another approach is to (i) design a computing curriculum that appeals to students and faculty from other (non-CS) disciplines, (ii) use special scholarships to attract students to that curriculum, and (iii) sponsor faculty development workshops for non-CS departments. In this paper, we detail this approach, using a new introductory course oriented to science majors, and scholarships funded by the National Science Foundation Scholarships for Science, Technology, Engineering, and Mathematics (NSF S-STEM) program to motivate non-CS majors to take CS courses. We also present several success stories that this approach has produced in its first two years.

Drag-and-drop learning environments like Alice (alice.org) and Scratch (scratch.mit.edu) eliminate syntax errors, making them attractive as ways to introduce programming concepts to students. Alice is closely associated with storytelling, Scratch was designed for creating music videos, and both can be used to create games. Having had students create each kind of project, we began to wonder: Do students learn different things creating games compared to music videos or stories? What programming constructs do students actually use (and hence learn well enough to be able to apply)? To answer these questions, we conducted a quantitative analysis of a collection of over 300 different student projects created using these tools. In examining different kinds of projects, we found significant differences in how frequently the students creating those projects used variables, if statements, loops, and dialog constructs.

It is no longer news that undergraduates in computer science need to learn more about parallelism. The range of options for parallel programming is truly staggering, involving hundreds of languages. How can a CS instructor make informed choices among all the options? This panel provides a guided introduction to parallelism in programming languages and their potential for undergraduate CS education, organized into four progressive categories: low-level libraries and; higher-level libraries and features; programming languages that incorporate parallelism; and frameworks for productive parallel programming. The four panelists will present representative examples in their categories, then present viewpoints on how those categories relate to coursework, curriculum, and trends in parallelism.

Recent industry changes, including multi-core processors, cloud computing, and GPU programming, increase the need to teach parallelism to CS undergraduates. But few CS programs can afford to add new courses or greatly alter syllabi, and the large parallelism body of knowledge relates to many courses. Participants in this BOF will share incremental approaches for adding parallelism to undergraduate CS curricula, where students study parallel computing in brief units. This networking event/ brainstorming session/ swap meet will bring together: " people with sharable parallelism expository readings, hands-on exercises, tech support ideas, etc.; "people wishing to include such materials in their courses; and" people curious about incremental approaches to teaching parallel computing.

The Fulbright Scholar Program is the flagship academic exchange program of the U.S. Department of State that provides the opportunity for U.S. Scholars to teach and/or conduct research at institutions abroad. Every year, approximately 1100 American scholars travel to approximately 125 countries to lecture, conduct research, and participate in a wide variety of academic and professional activities for one or more academic terms, up to one year. The Fulbright Scholar program is open to US Citizens with a Ph.D. or equivalent professional or terminal degree and university teaching experience [1]. In this panel, three computer science professors who have completed a total of five Fulbright grants in the last 12 years offer their experiences, anecdotes, and insights of the Fulbright Scholar program. The goal of the panel is to promote and inform the CS Education community about benefits of the Fulbright Scholar program, address questions or misconceptions regarding the program, and present realistic expectations for both the application process and the program itself. Each of the three panelists will present a 15 minute overview of their Fulbright experiences, leaving ample time for an interactive question and answer period.

Traditional Beowulf clusters have been homogeneous platforms for distributed-memory MIMD parallelism. However, the shift to multicore architectures has made shared-memory MIMD parallelism increasingly important, and inexpensive manycore GPGPUs have revived SIMD parallelism. This paper presents a case study in designing and building a heterogeneous cluster as a learning platform for tera-scale distributed- and shared-memory MIMD parallelism, and GPGPU parallelism.

Each July since 2003, the author has directed summer camps that introduce middle school boys and girls to the basic ideas of computer programming. Prior to 2009, the author used Alice 2.0 to introduce object-based computing. In 2009, the author decided to offer these camps using Scratch, primarily to engage repeat campers but also for variety. This paper provides a detailed overview of this outreach, and documents its success at providing middle school girls with a positive, engaging computing experience. It also discusses the merits of Alice and Scratch for such outreach efforts; and the use of these visually oriented programs by students with disabilities, including blind students.

Although Moore's Law continues to hold at present, Moore's Dividend - where software developers could rely on increasingly faster CPUs to make their software faster - has expired [5]. Instead of manufacturing uni-core CPUs with faster clocks, hardware manufacturers are producing multi-core CPUs, and many-core CPUs (with 32 or more cores) have begun appearing. Traditional sequential applications will not take advantage of these new hardware capabilities, and thus will not run any faster. To gain performance on these new and future hardware platforms, applications must be designed and written in pieces that run simultaneously on different cores. Ideally, the performance of such parallel applications should scale as the number of available cores increases.

Many undergraduate liberal arts institutions offer computer science majors. This article illustrates how quality computer science programs can be realized in a wide variety of liberal arts settings by describing and contrasting the actual programs at five liberal arts colleges: Williams College, Kalamazoo College, the State University of New York at Geneseo, Spelman College, and Calvin College. While the example programs differ in size, mission, and the nature of their home institutions, all take advantage of their liberal arts setting to offer rich computer science educations. Comparing these programs to each other and to the latest ACM/IEEE Computer Society computer science curriculum shows that the liberal arts programs are distinguishable from the ACM/Computer Society recommendations, but at the same time are strong undergraduate majors.

Software testing is an increasingly important topic in engineering reliable software systems, and test-driven development is an increasingly popular methodology for building reliable systems. However, most software engineering instructors' courses are already very full, so that increasing coverage of testing in those courses can only occur at the expense of another topic. In this paper, we argue that testing should be introduced early in the CS curriculum, that the Data Structures (CS2) course is an especially natural place to emphasize unit testing and test-driven development, and that doing is a way to revitalize the CS2 course.

As an immersive, interactive 3D environment, virtual reality (VR) is a way to capture students' imaginations and unleash their creativity. Such a system might be used in Computer Graphics, Gaming, Simulation, and with a suitable API, introductory courses. As such, it offers an excellent means of attracting CS students in a time of dwindling enrollments. However, the cost and complexity of building a VR system has been prohibitive until recently. This paper presents a fully immersive, 2-sensor, six degrees of freedom VR system we built for less than $4000.

A Beowulf cluster is a distributed memory multiprocessor built from commodity off-the-shelf PC hardware, an inexpensive network for inter-process communication, and open-source software. Today's multi-core CPUs make it possible to build a Beowulf cluster that is powerful, small, and inexpensive. This paper describes Microwulf, a Beowulf cluster that cost just $2470 to build, but provides 26.25 Gflops of measured performance. (For comparison: a 1996 Cray T3D MC256-8/464 provided 25.3 Gflops.) This makes Microwulf the first Beowulf with a price/performance ratio below $100/Gflop (for double-precision operations). The system measures just 11" x 12" x 17" (27.9 cm x 30.5 cm x 43.2 cm), runs at room temperature, and plugs into a standard wall outlet. These desirable characteristics combine to make Microwulf an attractive design for most computer science departments and/or individuals.

Research indicates that (i) many women who take CS1 feel less experienced than (and therefore at a disadvantage to) their male counterparts at computer programming, and that (ii) by the time they reach high school, many young women view computing as geeky and for nerds. This paper describes our Imaginary Worlds Camps -- a summer program in which we use Carnegie Mellon's Alice software to address these problems before students reach high school. The preliminary results are quite encouraging.

It is easy for computer science students and educators to write software applications in Java or C++ that are not object-oriented. In this paper, we present the Janus Principle -- a simple software engineering principle (related to the MVC design pattern) whose use produces highly object-oriented code. We demonstrate its effect by developing a simple Java networking application, first without using the Janus Principle, and then using it. Students and educators who follow this principle will write programs containing highly reusable code.

The gender imbalance in computer science in the U.S. and other countries has attracted much attention. This paper presents - for comparison - the computing-related gender ratios in Mauritius, a developing country in the Indian Ocean. These ratios suggest that far from being a universal phenomenon, the gender imbalance in the U.S. is a cultural problem.

Object-centered design (OCD) is a methodology developed to help novice C++ programmers learn to design software. By adapting OCD for use with Java, we can reduce the number of phases in OCD from five to three, and introduce object-oriented design (OOD) in CS-1 instead of CS-2.

A Beowulf cluster is a MIMD multiprocessor built from commodity off-the-shelf personal computers connected via a dedicated network, running free open-source software. Such a cluster can provide a supercomputer's performance at a small fraction of one's cost. For small colleges and universities, the relatively low cost of a Beowulf cluster makes it an attractive alternative to a commercial supercomputer. This paper details our experience building a Beowulf cluster at a four-year comprehensive college.

We describe the experience of three undergraduate computer science programs offering courses on parallel computing. In particular, we offer three different solutions to the problem of equipping a lab and discuss how those solutions may impact the content of the course.

Most people enjoy playing games. Most CS-1 students will enjoy a final project that involves computational game-playing. Chance-It is a simple two-person dice game with many possible strategies at varying levels of sophistication and complexity. These features make the problem of formalizing and encoding a strategy to play Chance-It an interesting final project for CS-1.This paper describes an object-oriented final project for CS-1 in which students build Player1 and Player2 classes to play Chance-It. A ChanceItGame class and driver are provided to coordinate the interactions of these classes. The project provides students with an enjoyable introduction to object-oriented design and the problem of formalizing and codifying human strategy in software. Examples are given in C++, but convert easily to Java.

With Pascal waning in popularity as the CS 1 language of choice, many colleges and universities are considering the adoption of C++ (an imperative and object-oriented hybrid language) as its replacement.An important issue that must be addressed in making such a change is the question of what software design methodology should be taught to CS 1 students.Two common answers are (i) continue teaching structured design in CS 1 and switch to object-oriented design in CS2; or (ii) teach object-oriented design from the outset in CS 1.We believe that both of these approaches have significant drawbacks.To avoid these drawbacks, this paper describes a graduated approach to object-oriented design that we call object-centered design.The approach introduces students to object-oriented design by the end of CS2 without an abrupt paradigm shift, and without requiring an early introduction of inheritance.

For years, disciplines such as Physics and Chemistry have utilized

The problem of correctly identifying the faulty processors and links in a distributed system where faulty behavior is unrestricted (Byzantine) is examined. A very general class of algorithms called evidence-based diagnosis algorithms is proposed that encompasses all past approaches to the diagnosis problem. An algorithm is presented which is proven optimal in this class. It is further shown that, in the worst case, no evidence-based diagnosis algorithm can guarantee that its diagnosis is both correct and complete, when evidence can be false. It is argued both analytically and from experimental data that in systems of N processors of which t can be faulty, the complexity of this algorithm is O(max(2 to the power of t/sup 2/, N/sup 2/)).>

The class of evidence-based diagnosis algorithms is developed to identify Byzantine (and any other faulty) processors. Such algorithms are said to be fair if they identify no failure-free processor as faulty. This paper makes two significant contributions: (i) it introduces a very general and simple formal model of the evidence-based diagnosis algorithms; and (ii) it derives a simple fair diagnosis algorithm, which is proved optimal for a large class of algorithms. It is further demonstrated that no fair evidence-based diagnosis algorithm can guarantee the identification of all faulty processors (completeness). Several insights into the behavior of the algorithm are presented.>