In a world of ad-hoc networks, highly interconnected mobile devices and increasingly large supercomputer clusters, students need models of computation that help them think about dynamic and concurrent systems. Many of the tools currently available for introducing students to concurrency are di#cult to use and are not intrinsically motivating. To provide an authentic, hands-on, and enjoyable introduction to concurrency, we have ported occam-#, a language whose expressive powers are especially compelling for describing communicating dynamic reactive processes, to the LEGO Mindstorms.

It is generally accepted that concurrency can be difficult for students to reason about and to manage. While some studies provide insight into the nature of these difficulties[6], work remains to be done in understanding the aspects of learning about concurrency that are most difficult, and in developing approaches to dealing with this problem. We have conducted instructor interviews and an observational study of students, identified several key difficulties that students encounter, and developed a diagram that we believe will be an aid to understanding and problemsolving. We present the diagram and results of an initial user evaluation. 1.

Programs that use multi-threaded concurrency are known to be difficult to design. Moreover, research in computer-science education suggests that concurrency and synchronization concepts are generally difficult to master. It stands to reason that comprehension tasks may be more complex for programs that employ concurrency than for sequential programs. We believe that external representations, specifically refinements to some of the popular UML modeling notations, should aid students in mastering fundamental concurrency/synchronization concepts and should enable practitioners to better comprehend the dynamically evolving nature of the these programs. In this paper, we present our synchronization adorned UML (saUML) sequence diagram notation that highlights aspects of thread interactions and describe an empirical study of whether these diagrams, as opposed to purely textual representations, help students to better understand concurrent executions and concurrency concepts, as measured by their ability to answer questions about a particular execution of a multi-threaded system. A statistically significant benefit was found from the study. 1.

Learning about concurrency and synchronization is difficult for novices. In prior work, we developed saUML, a refinement of UML sequence diagrams, to address these difficulties and found them to be beneficial when compared to text-only presentations. This paper compares saUML to standard UML sequence diagrams to judge their relative effectiveness in enhancing a novice programmer’s understanding of programs with different levels of synchronization complexity. One experiment compared the two notations when used to understand programs of low synchronization complexity, as judged by their use of only simple synchronization primitives, such as mutex locks. Here, a beneficial trend was observed, but it did not rise to the level of statistical significance. A second experiment compared the two notations on similar tasks but on programs with more complex synchronization constructs, in this case condition synchronization using primitives, such as wait and signal. Here, a significant benefit (p < 0.05) was found to exist.

Today, multicore computers are commonplace and university curricula are lagging behind. We need to work concurrency and parallelism into introductory courses, while also maintaining upper-level specialized courses on the topic. Since teachers may themselves require education on the topic, we feel that it is important to make course materials freely available. This position paper outlines some key components we feel concurrency curricula should have, and then discusses how the course materials we are developing satisfies those components. 1.

A comprehensive understanding of students ' common difficulties in understanding synchronization and concurrency is a prerequisite for developing tools and educational materials to alleviate these difficulties. In this paper we briefly present a study through which we identified students’ misconceptions about concurrency and synchronization, categorized their misunderstandings into a misconception pyramid, and built subject profiles through which we were able to discover the nature and frequency of the misconceptions exhibited by the students in this study. Based on these findings, we developed metrics to capture the breadth and severity of individual subject's misconceptions. We describe these metrics and show how they correlate with other measurements of understanding of concurrency and synchronization. 1.