Static analysis tools can be used to help programmers identify problems in their code. However, these tools often assume that developers have some programming background knowledge, so they can be hard to use in an educational context. We investigated the most common FindBugs errors from student code submissions and determined those errors that were related to incorrect solutions to problems and potential struggling for students. FindBugs is a static analysis tool that looks for incorrect patterns in Java bytecode analysis to identify potential coding flaws. For the common errors, we rewrote some of the original FindBugs messages to help students more easily understand the problems with their code. We found that students with at least one FindBugs warning in their final submission to an assignment had more submissions, longer work times, and lower correctness scores than students who did not have a FindBugs warning in their final submission. Adding modified FindBugs feedback to the automated grader resulted in students making fewer submissions and decreasing the length of time required to complete assignments. / Master of Science / Professional software developers use automated tools when they code to help them catch potential coding problems. These tools are difficult for novice student programmers because they do not have the same level of background as professionals. In this work, we attempted to change the feedback given by these tools so that students could understand it and use it to fix their code. We found that, across all of the undergraduate courses in this study, FindBugs warnings were associated with students having more trouble with assignments. When students could see FindBugs warnings, their time to complete assignments and the number of attempts they made both went down.

Thesis (Ph. D.)--University of California, Riverside, 2009. / Includes abstract. Title from first page of PDF file (viewed March 11, 2010). Available via ProQuest Digital Dissertations. Includes bibliographical references (p. 223-234). Also issued in print.

Thesis (Ph. D.)--University of Texas at El Paso, 2007. / Title from title screen. Vita. CD-ROM. Includes bibliographical references. Also available online.

abstract: Assemblers and compilers provide feedback to a programmer in the form of error messages. These error messages become input to the debugging model of the programmer. For the programmer to fix an error, they should first locate the error in the program, understand what is causing that error, and finally resolve that error. Error messages play an important role in all three stages of fixing of errors. This thesis studies the effects of error messages in the context of teaching programming. Given an error message, this work investigates how it effects student’s way of 1) understanding the error, and 2) fixing the error. As part of the study, three error message types were developed – Default, Link and Example, to better understand the effects of error messages. The Default type provides an assembler-centric single line error message, the Link type provides a program-centric detailed error description with a hyperlink for more information, and the Example type provides a program centric detailed error description with a relevant example. All these error message types were developed for assembly language programming. A think aloud programming exercise was conducted as part of the study to capture the student programmer’s knowledge model. Different codes were developed to analyze the data collected as part of think aloud exercise. After transcribing, coding, and analyzing the data, it was found that the Link type of error message helped to fix the error in less time and with fewer steps. Among the three types, the Link type of error message also resulted in a significantly higher ratio of correct to incorrect steps taken by the programmer to fix the error. / Dissertation/Thesis / Masters Thesis Software Engineering 2017

Error messages in compilers is a topic that is often overlooked. The quality of the messages can have a big impact on development time and ease oflearning. Another method used to speed up development is to build a domainspecific language (DSL). This thesis migrates an existing framework to use TypeScript in order to speed up development time with compile-time error handling. Alternative methods for implementing a DSL are evaluated based onhow they affect the ability to generate good error messages. This is done usinga proposed list of six usability heuristics for error messages. They are also usedto perform heuristic evaluation on the error messages in the TypeScript compiler. This showed that it struggled with syntax errors but had semantic errormessages with low amount of usability problems. Finally, a method for implementing a DSL and presenting its error messages is suggested. The evaluationof said method showed promise despite the existence of usability problems. / Felmeddelanden i kompilatorer är ett ämne som ofta förbises. Kvaliténpå felmeddelanden kan ha stor påverkan på utvecklingstid och lätthetatt lära. En annan metod för att sänka utvecklingstid är att bygga ettdomänspecifikt programmeringspråk. Detta examensarbete migrerar ettexisterande ramverk till TypeScript för att snabba på utvecklingstidmed felhantering i kompileringsstadiet. Alternativa metoder för attimplementera ett DSL evalueras baserat på hur de påverkar möjlighetenatt generera bra felmeddelanden. Detta görs med en föreslagen lista avsex heuristiker för felmeddelanden. De används också för att utföra enheuristik utvärdering på felmeddelandena i TypeScriptkompilatorn. Detta visade att den har svårt för syntaxfel men hademeddelanden för semantiska fel med låg mängdanvändbarhetsproblem. Till sist föreslås en metod för att implementeraett DSL och presentera dess felmeddelanden. Evalueringen av den nämndametoden visade lovande resultat trots förekomsten av användbarhetsproblem.

Programmers compose programs in multiple languages to combine the advantages of innovations in new high-level programming languages with decades of engineering effort in legacy libraries and systems. For language inter-operation, language designers provide two classes of multilingual programming interfaces: (1) foreign function interfaces and (2) code generation interfaces. These interfaces embody the semantic mismatch for developers and multilingual systems builders. Their programming rules are difficult or impossible to verify. As a direct consequence, multilingual programs are full of bugs at interface boundaries, and debuggers cannot assist developers across these lines. This dissertation shows how to use composition of single language systems and interposition to improve the safety of multilingual programs. Our compositional approach is scalable by construction because it does not require any changes to single-language systems, and it leverages their engineering efforts. We show it is effective by composing a variety of multilingual tools that help programmers eliminate bugs. We present the first concise taxonomy and formal description of multilingual programming interfaces and their programming rules. We next compose three classes of multilingual tools: (1) Dynamic bug checkers for foreign function interfaces. We demonstrate a new approach for automatically generating a dynamic bug checker by interposing on foreign function interfaces, and we show that it finds bugs in real-world applications including Eclipse, Subversion, and Java Gnome. (2) Multilingual debuggers for foreign function interfaces. We introduce an intermediate agent that wraps all the methods and functions at language boundaries. This intermediate agent is sufficient to build all the essential debugging features used in single-language debuggers. (3) Safe macros for code generation interfaces. We design a safe macro language, called Marco, that generates programs in any language and demonstrate it by implementing checkers for SQL and C++ generators. To check the correctness of the generated programs, Marco queries single-language compilers and interpreters through code generation interfaces. Using their error messages, Marco points out the errors in program generators. In summary, this dissertation presents the first concise taxonomy and formal specification of multilingual interfaces and, based on this taxonomy, shows how to compose multilingual tools to improve safety in multilingual programs. Our results show that our compositional approach is scalable and effective for improving safety in real-world multilingual programs. / text

Submitted by Milena Rubi (milenarubi@ufscar.br) on 2016-10-18T13:50:17Z No. of bitstreams: 1 FERREIRA_Maria_2015.pdf: 44702801 bytes, checksum: d58773cbbac5f088372d16f186805b06 (MD5) / Approved for entry into archive by Milena Rubi (milenarubi@ufscar.br) on 2016-10-18T13:50:31Z (GMT) No. of bitstreams: 1 FERREIRA_Maria_2015.pdf: 44702801 bytes, checksum: d58773cbbac5f088372d16f186805b06 (MD5) / Approved for entry into archive by Milena Rubi (milenarubi@ufscar.br) on 2016-10-18T13:50:43Z (GMT) No. of bitstreams: 1 FERREIRA_Maria_2015.pdf: 44702801 bytes, checksum: d58773cbbac5f088372d16f186805b06 (MD5) / Made available in DSpace on 2016-10-18T13:51:11Z (GMT). No. of bitstreams: 1 FERREIRA_Maria_2015.pdf: 44702801 bytes, checksum: d58773cbbac5f088372d16f186805b06 (MD5) Previous issue date: 2015-12-18 / Coordenação de Aperfeiçoamento de Pessoal de Nível Superior (CAPES) / Compiler error messages should allow programmers to understand and solve quickly problems found during the compilation process. However, compilers usually issue short contextless messages with little information and with terms that are difficult to understand. This work introduces the plug-in Error Message System (EMS) that allows the presentation of easy-to-understand and more meaningful error messages. EMS is a plug-in to the Eclipse IDE. It is highly configurable through Domain Specific Languages (DSLs). The DSLs allow that regular users build their own error messages and share them. Beginner programmers can use a set of error messages adapted to them thus reducing the time of understanding and correction of compilation errors. / As mensagens de erro dos compiladores devem permitir que os programadores compreendam e solucionem os problemas encontrados durante o processo de compilação rapidamente. Entretanto, os compiladores usualmente emitem mensagens curtas, sem contexto, pouco informativas e com termos de difícil compreensão. Este trabalho apresenta o plug-in Error Message System (EMS) que permite a apresentação das mensagens de erro mais fáceis de entender e mais informativas. EMS é um plugin para a IDE Eclipe e é altamente configurável através de linguagens específicas de domínio(LED). As LEDs permitem que usuários comuns façam suas próprias mensagens de erro e as compartilhem. Programadores iniciantes podem utilizar um conjunto de mensagens adaptadas a eles, reduzindo o tempo de compreensão e correção dos erros de compilação.

Den snabba digitaliseringen har inte bara lett till stora förändringar i samhället utan också utbildningssystemet i vilket kunskaper om tillämpningar och funktion av olika tekniska system och digitala verktyg har blivit en nödvändighet. Programmering har blivit en naturlig del av processen att förstå dagens digitala system men också ett verktyg för problemlösning och design av digitala lösningar. Processen att lära sig programmering kan för många elever bli utmanande och omges av en mängd svårigheter på vägen. En känd problematik för nybörjare har sedan länge varit felsökning som är en nödvändig kunskap både för att kunna förhindra olika typer av fel men också för att kunna lösa fel som uppstår i ett program. Detta är också ett av lärandemålen i kursen Programmering 1. I detta examensarbete utvecklades och testades en prototyp till en elevhandledning vars syfte är att stödja elever i att lära sig felsökning som en del av undervisningen i kursen Programmering 1 på gymnasiet. Vidare var syftet med studien att identifiera de felsökningsstrategier som elever använder för att åtgärda olika typer av fel i sina program. Examensarbetet genomfördes som en del av projektet K-ULF som bedriver praktiknära forskning genom ett samarbete mellan skolor och universitet i Stockholm. Studien genomfördes i huvudsak i fyra delar där den första var en förstudie bestående av observationer under vilken felsökning identifierades som ett problemområde. Under denna del av studien kunde flera teman identifieras kopplade till problemlösningsstrategier som eleverna använder sig av. Därefter påbörjades utvecklingsarbetet av en prototyp till elevhandledningen. Designen av elevhandledningen utgick från data som samlats in under förstudien i kombination med resultat från tidigare forskning om nybörjares svårigheter med felsökning. Prototypen testades sedan på en elevgrupp bestående av andra- och tredjeårselever som läser ett naturvetenskapligt gymnasieprogram. Elevmaterialet utvärderades sedan ur ett elev- och lärarperspektiv genom en enkät respektive en intervju. Därefter bearbetades den tidigare versionen av prototypen utifrån det som framkommit under den utvärderande fasen av arbetet. Att behovet av ett elevmaterial som stödjer elever i felsökning finns, blev tydligt under arbetets gång och bekräftades sedan i den senare delen av arbetet. Resultatet av studien visar att det finns fyra huvudteman kopplade till elevers felsökningsstrategier. Dessa är Lärarstöd, Självständig lösning, Stöd från klasskamrat och Google. Vidare framkom att elevmaterialet visat sig ha en positiv effekt på elevers lärande genom att bidra till en ökad förståelse om felens orsak och uppkomst vilket ledde till att fler elever kunde lösa problem i sin kod självständigt. / The rapid digitalization has not only led to major changes in society but also in the education system in which knowledge of the applications and functions of various technical systems and digital tools has become a necessity. Programming has become a natural part of the process of understanding today's digital systems, but also a tool for problem solving and designing digital solutions. The process of learning programming can be challenging for many students and beset with many difficulties along the way. A known problem for beginners has long been troubleshooting, which is a necessary knowledge both to be able to prevent various types of errors but also to be able to solve errors that occur in a program, which is also one of the learning objectives in the course Programming 1. In this thesis a prototype for a student guide was developed and tested whose purpose is to support students in learning debugging as part of the teaching in the course Programming 1 in upper secondary school. Furthermore, the purpose of the study was to identify the debugging strategies that students use to fix different types of errors in their programs. The thesis was carried out as part of the K-ULF project, which conducts practical research through a collaboration between schools and universities in Stockholm. The study was mainly carried out in four parts where the first was a pilot study consisting of observations during which troubleshooting was identified as a problem area. During this part of the study, several themes could be identified linked to problem-solving strategies that the students use. Then the development work of a prototype for the student guide began. The design of the student guide was based on data collected during the pilot study combined with results from previous research on beginners' difficulties with troubleshooting. The prototype was then tested on a student group consisting of second- and third-year students studying a high school science program. The student material was thereafter evaluated from a student and teacher perspective through a questionnaire and an interview respectively. The initial version of the prototype was then revised based on what emerged during the evaluation phase of the work. The need for a student material that supports students in troubleshooting became clear during the course of the work and was then confirmed in the latter part of the work. The results of the study show that there are four main themes linked to students' troubleshooting strategies. These are Teacher Support, Independent Solution, Classmate Support and Google. Furthermore, it emerged that the student material proved to have a positive effect on students' learning by contributing to an increased understanding of the cause and origin of the errors which resulted in more students being able to solve issues in their code independently.