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. 

Datorers prestanda ökar stadigt. Historiskt sett har denna ökning huvudsakligen berott på en ökad hastighet hos processorn, och hur effektivt den har kunnat köra kod. På senare tid har prestandautvecklingen hos enskilda processorer inte varit möjlig i lika stor utsträckning. Därmed kommer prestandaökningen numera främst från ökad parallellism genom att inkludera fler kärnor i processorerna. Dessa kärnor fungerar i princip som oberoende processorer. De kan alltså köra olika kod oberoende av varandra. En dubblering i antalet kärnor kan därmed teoretiskt sett leda till en dubblering i prestandan. För att kunna utnyttja denna extra prestanda måste programmen anpassas för att köras på denna typ av system. Detta är i allmänhet inte en enkel uppgift, då parallellprogrammering ofta anses vara svårt. I och med att system med flera kärnor blir allt vanligare, inte bara i högpresterande datorer, utan också i mindre kraftfulla system som mobiltelefoner och integrerade system, kommer allt fler programmerare att träffa på denna typ av system. Det är därför alltmer viktigt att programmerare har åtminstone en grundläggande förståelse för hur parallellprogrammering fungerar.

I och med att parallellprogrammering är viktigt att kunna som programmerare behöver vi kunna undervisa ämnet på ett bra sätt. Både tidigare forskning och mina erfarenheter som lärare visar dock att parallellprogrammering ofta upplevs som svårt av studenter, och att fler än hälften misslyckas med att lösa små programmeringsproblem i slutet av sin parallellprogrammeringskurs. Målet med denna avhandling är därför att förbättra undervisningen av parallellprogrammeringen, och därmed öka kompetensen hos de programmerare vi utbildar.

För att veta mer exakt varför studenter finner parallellprogrammering svårt ägnas första delen av avhandlingen åt att undersöka detta mer i detalj. Resultaten visar att det inte nödvändigtvis är de nya koncepten som är relaterade till parallellprogrammering som utgör de största problemen. Snarare är en stor del av problematiken för studenter att den icke-determinism som introduceras i parallella system kräver mer formella resonemang kring programs beteende jämfört med sekvensiella program. Detta är ofta något som studenter finner svårt i sig, då det i tidigare kurser ofta går relativt enkelt att testa om ett visst pro-gram fungerar eller ej. I och med att mer formella resonemang krävs, blir det också viktigare att ha en tillräcklig förståelse av grundläggande koncept, såsom hur referenser, pekare, och parameteröverföring fungerar. I och med att det tidigare har gått att testa sig fram i större utsträckning är det inte ovanligt att delar av problemen med parallellprogrammering beror på att studenterna inte har den detaljnivå som krävs i sin förståelse av dessa grundläggande koncept.

Ett sätt att illustrera dessa koncept är genom att använda visualiseringsverktyg. I denna avhandling beskrivs verktyget Progvis, som till skillnad från andra verktyg fokuserar både på problematiken som uppstår när parallellism introduceras och på hur detta interagerar med de grundläggande koncepten som studenter finner svåra. Detta gör att Progvis kan illustrera hur enkla program i språket C exekeveras i stor detalj. Som en positiv bieffekt av denna detaljrikedom kan Progvis också användas i andra sammanhang, exempelvis för att introducera pekararitmetik i C i nybörjarkurser. Utöver möjligheten att visualisera program inkluderar Progvis också möjligheten att automatiskt hitta fel i program, vilket hjälper studenter att verifiera sina resonemang.

Progvis har också testats i praktiken i kurser vid Linköpings universitet. Dessa studier visar att Progvis på kort sikt hjälper studenter att felsöka sina program. Med hjälp av Progvis lyckades de inte bara komma fram till bättre lösningar än studenter som enbart använde vanliga programmeringsverktyg, utan de var även snabbare. Detta kortsiktiga resultat har dock inte nödvändigtvis någon inverkan på studenters lärande. För att utvärdera långsiktig påverkan på studenternas resultat och lärande integrerades användningen av Progvis i en kurs på universitetet. En jämförelse av studenternas prestationer på kursens tentamen visade att de studenter som använt Progvis var bättre på att korrekt associera den synkronisering som behövdes med motsvarande problematiska data jämfört med tidigare år. Sammantaget tyder dessa resultat på att Progvis har en positiv inverkan på studenters lärande av parallellprogrammering.