{"id":{"repo_id":"aalto","oai_identifier":"oai:aaltodoc.aalto.fi:123456789/5149"},"canonical_url":"https://search.dev.ndltd.org/etd/aalto/oai:aaltodoc.aalto.fi:123456789/5149","repository":{"repo_id":"aalto","name":"Aalto University","base_url":"https://aaltodoc.aalto.fi/server/oai/request"},"display":{"title":"Understanding and debugging concurrent programs through visualisation","abstract":"In this thesis, the development and evaluation of a visualisation system intended to support students in understanding and debugging concurrent programs is presented. The first phase of development consisted of examining how students understand and develop concurrent programs through phenomenographic research. The resulting outcome spaces included the students' understandings of tuple spaces, the purpose of a programming assignment and what developing, debugging and testing a concurrent program involves. The outcome spaces included categories ranging from simple understandings containing only what is necessary to complete the assignments to understandings that placed the program in a larger context beyond the assignment. These outcome spaces were used in a classification of defects in students' concurrent programs. The defects found in the students' programs were classified by the underlying human error and by the type of program failure the defect causes. This analysis of defects was used to determine appropriate measures to support students in avoiding such defects. Many of the students' defects were related to misunderstanding the goals of the assignment, so they were rewritten to clarify the goals. To give the students a more concrete demonstration of the situations their programs had to deal with, test packages were provided to them. Many of the students' defects were related to incorrect use of concurrency. To help students understand and correct these defects and learn from their mistakes, the visualisation system Atropos was developed. Atropos is intended to help students understand concurrent program behaviour in Java. Atropos supports backward debugging of concurrent Java programs through interactive exploration of a dynamic dependence graph. A solution for replay and dynamic dependence analysis of concurrent Java programs that may include data races was devised. Atropos was evaluated through a mixed-methods analysis of the behaviour of pairs of students using Atropos to debug concurrent programs. The results include a description of the ways in which students successfully made use of Atropos and suggestions for how it could be improved to better support their debugging approaches. While students appear to understand the dependence graph representation and how to apply it in debugging, they need more support from Atropos for eliding the implementation of data structures in order to examine their use.","abstract_html":"In this thesis, the development and evaluation of a visualisation system intended to support students in understanding and debugging concurrent programs is presented. The first phase of development consisted of examining how students understand and develop concurrent programs through phenomenographic research. The resulting outcome spaces included the students' understandings of tuple spaces, the purpose of a programming assignment and what developing, debugging and testing a concurrent program involves. The outcome spaces included categories ranging from simple understandings containing only what is necessary to complete the assignments to understandings that placed the program in a larger context beyond the assignment. These outcome spaces were used in a classification of defects in students' concurrent programs. The defects found in the students' programs were classified by the underlying human error and by the type of program failure the defect causes. This analysis of defects was used to determine appropriate measures to support students in avoiding such defects. Many of the students' defects were related to misunderstanding the goals of the assignment, so they were rewritten to clarify the goals. To give the students a more concrete demonstration of the situations their programs had to deal with, test packages were provided to them. Many of the students' defects were related to incorrect use of concurrency. To help students understand and correct these defects and learn from their mistakes, the visualisation system Atropos was developed. Atropos is intended to help students understand concurrent program behaviour in Java. Atropos supports backward debugging of concurrent Java programs through interactive exploration of a dynamic dependence graph. A solution for replay and dynamic dependence analysis of concurrent Java programs that may include data races was devised. Atropos was evaluated through a mixed-methods analysis of the behaviour of pairs of students using Atropos to debug concurrent programs. The results include a description of the ways in which students successfully made use of Atropos and suggestions for how it could be improved to better support their debugging approaches. While students appear to understand the dependence graph representation and how to apply it in debugging, they need more support from Atropos for eliding the implementation of data structures in order to examine their use.","abstract_has_math":false,"creators":["Lönnberg, Jan"],"institution":"Aalto University","degree_name":null,"degree_level":null,"degree_discipline":null,"degree_department":"Tietotekniikan laitos","school":null,"contributors":["Aalto-yliopisto","Aalto University"],"advisors":["Ben-Ari, Mordechai, Associate Professor","Malmi, Lauri, Professor"],"committee_chairs":[],"committee_members":[],"year":2012,"date_issued":"2012","date_published":"2012","updated_at":"2026-08-21T22:21:56Z","subjects":[],"languages":["en"],"rights":[],"rights_urls":[],"identifier_entries":[]},"links":{"outbound_url":"https://aaltodoc.aalto.fi/handle/123456789/5149","outbound_label":"Repository record","outbound_source":"dc:identifier.uri"},"source_record":{"url":"https://aaltodoc.aalto.fi/server/oai/request?verb=GetRecord&metadataPrefix=dim&identifier=oai%3Aaaltodoc.aalto.fi%3A123456789%2F5149","prefix":"dim"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor","label":"Contributor","values":["Aalto-yliopisto","Aalto University"]},{"key":"dc:contributor.advisor","label":"Advisor","values":["Ben-Ari, Mordechai, Associate Professor"]},{"key":"dc:contributor.department","label":"Department","values":["Tietotekniikan laitos","Department of Computer Science and Engineering"]},{"key":"dc:contributor.supervisor","label":"Supervisor","values":["Malmi, Lauri, Professor"]},{"key":"dc:creator","label":"Author","values":["Lönnberg, Jan"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date.accessioned","label":"Dc Date Accessioned","values":["2012-09-11T08:02:55Z"]},{"key":"dc:date.available","label":"Dc Date Available","values":["2012-09-11T08:02:55Z"]},{"key":"dc:date.issued","label":"Date","values":["2012"]},{"key":"dc:publisher","label":"Institution","values":["Aalto University","Aalto-yliopisto"]},{"key":"dc:type","label":"Dc Type","values":["G5 Artikkeliväitöskirja"]},{"key":"dc:type.dcmitype","label":"Dc Type Dcmitype","values":["text"]}]},{"id":"language_rights","label":"Language and Rights","entries":[{"key":"dc:language.iso","label":"Language (ISO)","values":["en"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier.uri","label":"Identifier URI","values":["https://aaltodoc.aalto.fi/handle/123456789/5149"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description.abstract","label":"Abstract","values":["In this thesis, the development and evaluation of a visualisation system intended to support students in understanding and debugging concurrent programs is presented. The first phase of development consisted of examining how students understand and develop concurrent programs through phenomenographic research. The resulting outcome spaces included the students' understandings of tuple spaces, the purpose of a programming assignment and what developing, debugging and testing a concurrent program involves. The outcome spaces included categories ranging from simple understandings containing only what is necessary to complete the assignments to understandings that placed the program in a larger context beyond the assignment. These outcome spaces were used in a classification of defects in students' concurrent programs. The defects found in the students' programs were classified by the underlying human error and by the type of program failure the defect causes. This analysis of defects was used to determine appropriate measures to support students in avoiding such defects. Many of the students' defects were related to misunderstanding the goals of the assignment, so they were rewritten to clarify the goals. To give the students a more concrete demonstration of the situations their programs had to deal with, test packages were provided to them. Many of the students' defects were related to incorrect use of concurrency. To help students understand and correct these defects and learn from their mistakes, the visualisation system Atropos was developed. Atropos is intended to help students understand concurrent program behaviour in Java. Atropos supports backward debugging of concurrent Java programs through interactive exploration of a dynamic dependence graph. A solution for replay and dynamic dependence analysis of concurrent Java programs that may include data races was devised. Atropos was evaluated through a mixed-methods analysis of the behaviour of pairs of students using Atropos to debug concurrent programs. The results include a description of the ways in which students successfully made use of Atropos and suggestions for how it could be improved to better support their debugging approaches. While students appear to understand the dependence graph representation and how to apply it in debugging, they need more support from Atropos for eliding the implementation of data structures in order to examine their use.","I denna avhandling presenteras utvecklingen och utvärderingen av ett visualiseringssystem som skapats för att hjälpa studenter förstå och avlusa jämlöpande program. I den första utvecklingsfasen undersöktes genom en fenomenografisk undersökning hur studenter uppfattar och utvecklar jämlöpande program. Utfallsrummen från denna undersökning handlade om hur studenter uppfattar tupelrymder, avsikten med ett övningsarbete i programmering och vad som ingår i utvecklandet, avlusandet och testandet av ett jämlöpande program. Utfallsrummen innehöll beskrivningskategorier från enkla uppfattningar som bara omfattar det som krävs för att utföra övningarna till uppfattningar som satt programmet i ett sammanhang som sträcker sig bortom övningen. Utfallsrummen användes för att klassificera buggarna i studenternas jämlöpande program. Buggarna klassificerades enligt det bakomliggande mänskliga felet och enligt det felaktiga uppförandet i programmet buggen ger upphov till. Denna analys av buggarna användes för att finna lämpliga medel för att hjälpa studenter undvika att skapa dylika buggar. Många av buggarna kom från att studenterna missförstått övningsarbetenas mål, så de skrevs om för att förtydliga målen. Studenterna gavs testpaket som gav dem en mer konkret demonstration av övningsarbetenas mål. Många av studenternas buggar var kopplade till felaktigheter i samverkan mellan exekveringstrådar. För att hjälpa studenter förstå och korrigera dessa buggar och lära sig från sina misstag utvecklades visualiseringssystemet Atropos. Atropos är tänkt att hjälpa studenter förstå hur jämlöpande program i Java uppför sig. Atropos stöder baklänges avlusning av jämlöpande Java-program genom interaktiv utforskning av en dynamisk beroendegraf. En lösning skapades för återuppspelning och dynamisk beroendeanalys av jämlöpande Java-program som kan innehålla datatävlingssituationer. Atropos utvärderades genom en analys av hur par av studenter använde Atropos för att avlusa jämlöpande program. Analysen gjordes med kvalitativa och kvantitativa metoder. Utvärderingens resultat omfattar bland annat en beskrivning av hur studenterna utnyttjade Atropos och förslag för hur Atropos bättre kunde stöda deras sätt att avlusa. Fastän studenterna verkar förstå beroendegrafsrepresentationen och hur den kan utnyttjas i avlusning, borde Atropos ha bättre stöd för att dölja implementationen av datastrukturer då användningen av dem undersöks."]},{"key":"dc:format.mimetype","label":"Dc Format Mimetype","values":["application/pdf"]},{"key":"dc:title","label":"Title","values":["Understanding and debugging concurrent programs through visualisation","Programvisualisering för att hjälpa studenter förstå och avlusa jämlöpande program"]}]}],"canonical_facts":{"dc:contributor":["Aalto-yliopisto","Aalto University"],"dc:contributor.advisor":["Ben-Ari, Mordechai, Associate Professor"],"dc:contributor.department":["Tietotekniikan laitos","Department of Computer Science and Engineering"],"dc:contributor.supervisor":["Malmi, Lauri, Professor"],"dc:creator":["Lönnberg, Jan"],"dc:date.accessioned":["2012-09-11T08:02:55Z"],"dc:date.available":["2012-09-11T08:02:55Z"],"dc:date.issued":["2012"],"dc:description.abstract":["In this thesis, the development and evaluation of a visualisation system intended to support students in understanding and debugging concurrent programs is presented. The first phase of development consisted of examining how students understand and develop concurrent programs through phenomenographic research. The resulting outcome spaces included the students' understandings of tuple spaces, the purpose of a programming assignment and what developing, debugging and testing a concurrent program involves. The outcome spaces included categories ranging from simple understandings containing only what is necessary to complete the assignments to understandings that placed the program in a larger context beyond the assignment. These outcome spaces were used in a classification of defects in students' concurrent programs. The defects found in the students' programs were classified by the underlying human error and by the type of program failure the defect causes. This analysis of defects was used to determine appropriate measures to support students in avoiding such defects. Many of the students' defects were related to misunderstanding the goals of the assignment, so they were rewritten to clarify the goals. To give the students a more concrete demonstration of the situations their programs had to deal with, test packages were provided to them. Many of the students' defects were related to incorrect use of concurrency. To help students understand and correct these defects and learn from their mistakes, the visualisation system Atropos was developed. Atropos is intended to help students understand concurrent program behaviour in Java. Atropos supports backward debugging of concurrent Java programs through interactive exploration of a dynamic dependence graph. A solution for replay and dynamic dependence analysis of concurrent Java programs that may include data races was devised. Atropos was evaluated through a mixed-methods analysis of the behaviour of pairs of students using Atropos to debug concurrent programs. The results include a description of the ways in which students successfully made use of Atropos and suggestions for how it could be improved to better support their debugging approaches. While students appear to understand the dependence graph representation and how to apply it in debugging, they need more support from Atropos for eliding the implementation of data structures in order to examine their use.","I denna avhandling presenteras utvecklingen och utvärderingen av ett visualiseringssystem som skapats för att hjälpa studenter förstå och avlusa jämlöpande program. I den första utvecklingsfasen undersöktes genom en fenomenografisk undersökning hur studenter uppfattar och utvecklar jämlöpande program. Utfallsrummen från denna undersökning handlade om hur studenter uppfattar tupelrymder, avsikten med ett övningsarbete i programmering och vad som ingår i utvecklandet, avlusandet och testandet av ett jämlöpande program. Utfallsrummen innehöll beskrivningskategorier från enkla uppfattningar som bara omfattar det som krävs för att utföra övningarna till uppfattningar som satt programmet i ett sammanhang som sträcker sig bortom övningen. Utfallsrummen användes för att klassificera buggarna i studenternas jämlöpande program. Buggarna klassificerades enligt det bakomliggande mänskliga felet och enligt det felaktiga uppförandet i programmet buggen ger upphov till. Denna analys av buggarna användes för att finna lämpliga medel för att hjälpa studenter undvika att skapa dylika buggar. Många av buggarna kom från att studenterna missförstått övningsarbetenas mål, så de skrevs om för att förtydliga målen. Studenterna gavs testpaket som gav dem en mer konkret demonstration av övningsarbetenas mål. Många av studenternas buggar var kopplade till felaktigheter i samverkan mellan exekveringstrådar. För att hjälpa studenter förstå och korrigera dessa buggar och lära sig från sina misstag utvecklades visualiseringssystemet Atropos. Atropos är tänkt att hjälpa studenter förstå hur jämlöpande program i Java uppför sig. Atropos stöder baklänges avlusning av jämlöpande Java-program genom interaktiv utforskning av en dynamisk beroendegraf. En lösning skapades för återuppspelning och dynamisk beroendeanalys av jämlöpande Java-program som kan innehålla datatävlingssituationer. Atropos utvärderades genom en analys av hur par av studenter använde Atropos för att avlusa jämlöpande program. Analysen gjordes med kvalitativa och kvantitativa metoder. Utvärderingens resultat omfattar bland annat en beskrivning av hur studenterna utnyttjade Atropos och förslag för hur Atropos bättre kunde stöda deras sätt att avlusa. Fastän studenterna verkar förstå beroendegrafsrepresentationen och hur den kan utnyttjas i avlusning, borde Atropos ha bättre stöd för att dölja implementationen av datastrukturer då användningen av dem undersöks."],"dc:format.mimetype":["application/pdf"],"dc:identifier.uri":["https://aaltodoc.aalto.fi/handle/123456789/5149"],"dc:language.iso":["en"],"dc:publisher":["Aalto University","Aalto-yliopisto"],"dc:title":["Understanding and debugging concurrent programs through visualisation","Programvisualisering för att hjälpa studenter förstå och avlusa jämlöpande program"],"dc:type":["G5 Artikkeliväitöskirja"],"dc:type.dcmitype":["text"]},"updated_at":"2026-08-21T22:21:56Z"}