The performance of computational devices is steadily increasing. Recently, the main contributor to the increasing performance has been an increasing number of cores rather than increased performance for individual cores. This trend is not only visible in high-end de-vices, such as powerful workstations, but also in low-end devices such as smartphones and many embedded devices. Due to this trend, and to the ubiquity of multicore systems, it is increasingly important for computer science students to have at least some familiarity with working with concurrent programs, as they are likely to encounter such programs in some shape or form in their future professional careers. In this thesis, we use the term concurrent programming to emphasize the focus on concurrency in a programming context, as opposed to concurrency in isolation. 

Prior work has shown that students struggle with learning concurrent programming. This is not surprising in and of itself, as concurrency is generally considered to be a difficult topic. To help students learn concurrent programming, it is important to consider why they find the topic difficult. As such, the first part of this thesis aims to gain better insights into these difficulties. This is done partly by studying prior work in the literature and partly by conducting new research. The results show that the struggles are not only due to the difficulty involved in understanding the new concepts related to concurrency. Rather, a large portion of students’ struggles can be attributed to the fact that the non-determinism in concurrent programs requires a more formal approach to programming. The transition from an informal approach, where students are able to rely on ad-hoc testing, to a more formal approach is difficult in and of itself, but it also highlights problems in students’ understanding of fundamental programming skills. For example, without a detailed enough understanding of scope, aliasing and references it is difficult to reason about what data is shared between threads. 

In light of these results, the remainder of this thesis describes ways of helping students learn concurrent programming. This is achieved by developing a program visualization tool, called Progvis, which is capable of visualizing the behavior of concurrent programs written in the C language. Progvis is unique in the sense that it focuses not only on concurrency, but also illustrates how concurrency interacts with the fundamental concepts that were found to be problematic. As such, it is able to give students a complete and accurate picture of the visualized program’s behavior. To further help students, Progvis also includes a model-checker that can automatically find concurrency issues, thereby helping students to easily see whether their reasoning about the program’s behavior was correct or not. 

The results suggest that the visualizations generated by Progvis have the potential to help students learn concurrent programming. A small pilot study showed that students who used Progvis were able to solve concurrency problems faster and arrived at better solutions compared to students who only used traditional tools. To evaluate long-term effects on learning, Progvis was also integrated into a course on concurrency and operating systems. Comparing the students’ performance on the final exam showed that the students who had used Progvis were more likely to correctly associate their synchronization with the associated data compared to students who had not used Progvis during the course. Even though no significant increase was observed in students’ overall performance, these results suggest that using Progvis does indeed have a positive impact on students’ learning. 

Students need the ability to reason about the behavior of programs when working with advanced concepts like concurrency and abstraction. To achieve this, students require core programming skills that allow them to trace and predict the outcome of a program. While previous research indicates that teachers cannot expect students to acquire all core programming skills after their introductory CS course, less is known of students’ progression in later years. In this study, we investigate 397 students’ ability to predict the outcome of short computer programs. The participants are from different programs and progressions in their studies. We find that students, regardless of program and year, struggle with predicting the outcome of short programs that require an accurate mental model of some less readily apparent concepts, such as references. Further, we discover that there is no significant improvement in the first three years. Finally, we propose further avenues of research to improve these learning outcomes.

Previous research has shown that even though many students are aware of overarching problems with concurrency, they are less successful in addressing any issues they have found. This implies that the students have not yet developed a mental model that describes the behavior of concurrent systems with enough accuracy. One way to help students explore the non-determinism of concurrent systems and thereby develop their mental model is through the use of visualization tools. One example of such a tool is Progvis, which provides students with a detailed visualization of the program state, and allows students to single-step individual threads to explore the program’s behavior in a concurrent environment. One problem with this type of tools is that they are not able to provide feedback on whether or not a proposed solution is correct, which limits their percieved usefulness. To increase the percieved usefulness of Progvis, we extended it with a system that utilizes model-checking and peer-grading to provide automated feedback to students. Our hopes were that this would encourage students to further use Progvis to practice concurrent programming. The system was used during two years in a course on concurrency and operating systems. This made it possible to utilize the experiences from the first year to further improve the system for the second year. Overall, the students expressed that they found our additions helpful. Additionally, we observed a slight increase in usage in the second year compared to the first year, which suggests that the improvements in the second year increased students’ motivation to some extent.

Previous research has shown that many students struggle with solving small concurrency problems after their first course on concurrency. A possible reason for this is that students do not have a suitable mental model of the semantics of the underlying programming language, and are therefore not able to properly reason about the program’s behavior. One way to help students learn concurrency and improve their mental model is through the use of visualization tools. Progvis is one such visualization tool that is not only aimed at concepts related to concurrency, but also provides an accurate visualization of more fundamental concepts to illustrate how they interact with concurrency. In previous work, the authors of Progvis performed a small-scale evaluation of the tool, and highlighted some areas of improvement. In this paper, we address these shortcomings by improving the memory model visualized by Progvis and implementing a model checker. We also evaluate Progvis on a larger scale by incorporating it into a course on concurrency and operating systems, which allows assessing whether using Progvis aids students in learning concurrency. The results indicate that Progvis (with our improvements) is successful in helping students realize how concurrency interacts with more fundamental concepts, and that students find it useful in helping them understand the content of the concurrency assignments.

In this full research paper we examine questionable collaboration from a student perspective. Collaborating while solving computer lab assignments is often considered an important part when learning computer science, as it allows students to discuss their work, while also practicing working together. However, it also introduces risks, such as students collaborating in ways negatively impacting their learning outcomes and leading to inaccurate grading. Hence it is important to work towards reducing the use of these poor collaborative practices. In order to ameliorate the problem with academic misconduct, we need to understand students’ justifications for deviating from acceptable practices. In this paper we therefore investigate how students justify their collaborative practices during computer lab assignments in situations they experience as questionable. The justifications were collected through 15 semi-structured interviews with students experienced in pair programming, majoring in computer science and other technical fields from two large well-known European universities.The justifications from the interviews were analysed using phenomenography resulting in seven categories: external pressure, lack of interest, spending time on the assignment, understanding the end product, contributing to the process, learning from the assignment and reflecting on the purpose of the learning. These describe in which situations students might deviate from the rules and can be used by institutions to prevent such behavior.

Concurrency and synchronization are two topics that are becomingincreasingly important for computer science students due to thehigh number of cores available in most modern devices. These aretopics that many students struggle with at first, perhaps partiallydue to the inherent nondeterminism and the difficulty to test forabsence of race conditions. Furthermore, previous research indicate that some common mistakes when working with concurrencymight be due students not connecting the concurrency concepts(such as synchronization) to the data that needs to be protected,especially when pointers and references are involved.To address these issues, we propose Progvis, which is a visualization tool aimed specifically at concurrency using the sharedmemory model. It provides a detailed visualization of objects inmemory and their relation to the running threads in order to helpstudents connect concurrency issues with the affected data. Wehave performed an initial, small scale evaluation on whether usingthe tool helps students solve synchronization problems during voluntary problem-solving sessions. The preliminary results indicatethat students who used the tool did indeed perform better.

Concurrency is often perceived as difficult by students. One reason for this may be due to the fact that abstractions used in concurrent programs leave more situations undefined compared to sequential programs (e.g., in what order statements are executed), which makes it harder to create a proper mental model of the execution environment. Students who aim to explore the abstractions through testing are further hindered by the non-determinism of concurrent programs since even incorrect programs may seem to work properly most of the time. In this paper we aim to explore how students understanding these abstractions by examining 137 solutions to two concurrency questions given on the final exam in two years of an introductory concurrency course. To highlight problematic areas of these abstractions, we present alternative abstractions under which each incorrect solution would be correct.

Controlling complexity through the use of abstractions is a critical part of problem solving in programming. Thus, becoming proficient with procedural and data abstraction through the use of user-defined functions is important. Properly using functions for abstraction involves a number of other core concepts, such as parameter passing, scope and references, which are known to be difficult. Therefore, this paper aims to study students proficiency with these core concepts, and students ability to apply procedural and data abstraction to solve problems. We collected data from two years of an introductory Python course, both from a questionnaire and from two lab assignments. The data shows that students had difficulties with the core concepts, and a number of issues solving problems with abstraction. We also investigate the impact of using a visualization tool when teaching the core concepts.

Computing learners may not master basic concepts, or forget them between courses or from infrequent use. Learners also often struggle with advanced computing courses, perhaps from weakness with prerequisite concepts. One underlying challenge for researchers and instructors is determining the reason why a learner gets an advanced question wrong. Was the wrong answer because the learner lacked prerequisite skills, has not mastered the advanced skill, or some combination of the two? We contribute a design investigation into how to create differentiated questions which diagnose prerequisite and advanced skills at the same time. We focused on tracing and related skills as prerequisites, and on advanced object-oriented programming, concurrency, algorithm and data structures as the advanced skills. We conducted an inductive qualitative analysis of existing assessment questions from instructors and from a concept inventory with a validity argument (the Basic Data Structures Inventory). We found dependencies on a variety of prerequisite knowledge and mixed potential for diagnosing difficulties with prerequisites. Inspired by this analysis, we developed examples of differentiated assessments and reflected on design principles for creating/modifying assessments to better assess both advanced and prerequisite skills. Our example differentiated assessment questions and methods help enable research into how prerequisites skills affect learning of advanced concepts. They also may help instructors better understand and help learners with varying prerequisite knowledge, which may improve equity of learning outcomes. Our work also raises theoretical questions about what assessments really assess and how separate advanced topics and prerequisite skills are.

This paper continues previous efforts in understanding the problemsstudents face when learning concurrency. In this paper, weexplore students’ understanding of the subject using phenomenographyin order to gain insights that can aid in explaining the underlyingcauses for common student mistakes in concurrency, whichhas been studied in depth previously. Students’ experience of concurrencyand critical sections were analyzed using a phenomenographicstudy based on interviews with students attending one oftwo courses on concurrency and operating systems. We present6 categories describing students’ experience of concurrency, and4 categories describing students’ experience of critical sections inthis paper. Furthermore, these categories are related to previousresults, both to explore how misconceptions in the categores relateto student mistakes and to estimate how common it is for eachcategory to be discerned.

This paper investigates common misconceptions held by students regarding concurrency in order to better understand how concurrency education can be improved in the future. As a part of the exam in two courses on concurrency and operating systems, students were asked to identify and eliminate any concurrency issues in a piece of code as a part of their final exam. Different types of mistakes were identified and the 216 answers were sorted into categories accordingly. The results presented in this paper show that while most students were able to identify the cause of an issue given its symptoms, only approximately half manage to successfully eliminate the concurrency issues. Many of the incorrect solutions fail to associate shared data with a synchronization primitive, e.g. using one lock to protect multiple instances of a data structure, or multiple locks to protect the same instance in different situations. This suggests that students may not only have trouble dealing with concepts related to concurrency, but also more fundamental concepts related to the underlying computational model. Finally, this paper proposes possible explanations for the students' mistakes in terms of improper mental models, and suggests types of problems that highlight the issues with these mental models to improve students' understanding of the subject.

This extended abstract describes our ongoing effort to support students learning and understanding of concurrency and synchronization. We have identified and quantified some of the areas that appear to be problematic to students, and are in the process of further examining underlying causes of these problematic areas. We then aim to utilize this knowledge to suggest interventions to existing approaches in order to better support students learning of the problematic areas in concurrency and evaluate the results of the interventions.

The ability to extend programming languages with domain-specific concepts is becoming an essential technology for developing complex software. However, many domain-specific languages are implemented in a way that interact poorly with the host language. There are a number of tools that aim to improve the situation by simplifying the creation of domain-specific languages, and allow easier interactions between the host language and the domain-specific language. However, many of these tools are limited to a single host language, and rarely allow extending the language used for language creation. To improve the situation, we created the language platform Storm, which aims to make the creation and usage of multiple extensible languages easy and seamless. This is accomplished by means of a shared, standardized namespace and in-process code generation, which gives Storm a high degree of extensibility, making it possible to extend or replace the built-in languages at will.