The research presented in this thesis aims at the development of a programming environment for primary schools that is focused on supporting students’ autonomous learning and independent troubleshooting. With the introduction of computer science as a new school subject, programming in primary school is currently experiencing a strong and promising rise in popularity. This creative form of learning can foster problem solving skills but it simultaneously requires a high level of precision. Making errors is inevitable and bugs show up in a variety of forms, from simple typos to highly complex misconceptions. Errors pose a significant problem for classroom implementation since students often struggle with troubleshooting and thus depend on external help.

Previous research has addressed this problem and presented various approaches that ease primary school programming. Suggestions reach from programming languages with specialized grammars to tangible application domains and block-based programming interfaces. While each of these approaches has its justification in easing the way into programming, still, primary school programmers eventually need to face their errors and acquire appropriate troubleshooting skills.

For more than fifty years, educational and professional programming languages have been treated as separate research fields which went through a distinct evolution in terms of error handling. Motivated by the enormous cost of a blunder in industry, numerous tools were developed for professionals to assist them in locating, analyzing, and fixing errors. Sophisticated tools reach from static program analysis all the way to post-mortem debuggers. In contrast, the educational community engaged with primary school programming focused during the last twenty years primarily on preventing errors. Yet, in order to become self-sufficient programmers, novices must be exposed to their own errors at some point. We developed a Logo learning environment with which primary school programmers aged 5 to 12 years can be introduced to programming and which provides novices with age-appropriate error recovery tools, e.g., an advanced syntax checker, static program analysis, type checking and inference, and a reverse debugger. All of these tools have been adapted to the use case in primary schools

We evaluated our approach using a set of more than 2 million structurally-erroneous Logo programs that were collected in over 80 000 user sessions. Using the tools presented in this thesis, 97% of all structural errors can be detected proactively (i.e., at compile time) and visualized using in-line error markers. In this way, the majority of structural programming errors can be fixed on-the-fly. The remaining 3% are runtime errors that can be analyzed and examined alongside all logical errors using our debugger.

The proposed research has promising implications for primary school programming. Through the direct feedback loop with thousands of users, we gained an insight into their learning including problems and misconceptions. The analysis of structural errors allowed us to target the needs of students more effectively by adapting our teaching materials. In the long run, this improves the quality of programming lessons in primary school and students learn to handle errors on their own.

Die vorgestellte Forschungsarbeit behandelt die Entwicklung einer Programmierumgebung für Primarschulen, welche auf autonomes Lernen und selbstständige Fehlerbehebung ausgerichtet ist. Durch die Einführung der Informatik als obligatorisches Schulfach erlebt das Programmieren an Primarschulen derzeit einen starken und vielversprechenden Aufschwung. Das Programmieren ist eine kreative Tätigkeit, welche konstruktive Problemlösefähigkeiten fördert, gleichzeitig jedoch auch ein hohes Level an Präzision voraussetzt. Fehler sind unumgänglich und deren Spektrum reicht von einfachen Tippfehlern bis hin zu komplexen Fehlvorstellungen. Für die Umsetzung des Programmierunterrichts im Klassenzimmer stellen Fehler ein signifikantes Problem dar, denn Programmieranfängerinnen und -anfänger können mit Fehlern oft nicht selbstständig umgehen und sind dadurch auf externe Hilfe angewiesen.

Frühere Forschungsarbeiten haben sich dieses Problems bereits angenommen und verschiedene Ansätze vorgestellt, die den Einstieg ins Programmieren vereinfachen. Die Vorschläge reichen von speziellen Programmiersprachen über altersgerechte Anwendungsbereiche bis hin zum blockbasierten Programmieren. Viele dieser Ansätze haben ihre Berechtigung und tragen zu einem einfacheren Einstieg ins Programmieren bei. Dennoch kommt irgendwann unweigerlich der Punkt, an welchem sich Novizen der vollen Bandbreite ihrer Fehler stellen müssen und lernen sollten diese selbstständig zu beheben.

In ihrer mehr als fünfzigjährigen Geschichte als separate Forschungsgegenstände haben sich Programmiersprachen aus dem frühschulischen Bildungsbereich immer mehr von professionellen Sprachen entfernt, besonders hinsichtlich der Handhabung von Fehlern. Motiviert durch die enormen Kosten eines Fehlers in der Industrie wurden in jahrzehntelangen Forschungsbemühungen zahlreiche Hilfsmittel entwickelt (z.B. statische Programmanalyse oder vielseitige Debugger), die professionelle Programmiererinnen und Programmierer darin unterstützen, Fehler einfacher zu lokalisieren, zu analysieren und zu beheben. Im Primarschulkontext besteht der Trend hingegen seit mehr als 20 Jahren darin, Programmieranfängerinnen und -anfänger vor Fehlern zu schützen, anstatt diese mithilfe von Diagnosetools proaktiv anzugehen. Wir haben eine Lernumgebung für Kinder im Alter von 5 bis 12 Jahren entwickelt, welche mehrere Fehlerdiagnosetools bereitstellt, von einem fortgeschrittenen Syntax-Checker, semantischer Verifikation, Type-Checking und -Inferenz, bis hin zu einem bidirektionalen Debugger. Diese Tools wurden speziell aufbereitet für den Einsatz in Primarschulen.

Der verwendete Ansatz wurde durch eine Sammlung von mehr als 2 Millionen strukturell fehlerhafter Logo-Programmen evaluiert, welche in mehr als 80 000 User-Sessions anfielen. Mit unserem Ansatz können rund 97% aller strukturellen Programmierfehler bereits zur Compilezeit detektiert und mit Fehlermarkierungen im Programmtext visualisiert werden. Auf diese Weise gelingt es, einen Grossteil aller strukturellen Fehler schnell und einfach on-the-fly zu beheben. Die restlichen 3% aller strukturellen Fehler zeigen sich zur Laufzeit und können gemeinsam mit logischen Fehlern dank bidirektionalem Debugger untersucht werden.

Die präsentierte Arbeit hat vielversprechende Implikationen für das Programmieren in der Primarschule. Durch die direkte Interaktion mit tausenden Benutzerinnen und Benutzern erhalten wir eine Einsicht in die Probleme und Fehlvorstellungen der Lernenden. Die Analyse struktureller Fehler erlaubt es, die verwendeten Unterrichtsmaterialien spezifisch auf die Bedürfnisse der Novizen auszurichten. Langfristig gewinnt der Programmierunterricht dadurch an Qualität und Schülerinnen und Schüler lernen ihre Fehler selbstständig zu beheben.