Today’s STEM classrooms have expanded the domain of computer
science education from a basic two-toned terminal screen to now
include helpful Integrated Development Environments(IDE) (BlueJ,
Eclipse), block-based programming (MIT Scratch, Greenfoot), and
even physical computing with embedded systems (Arduino, LEGO
Mindstorm). But no matter which environment a student starts
programming in, all students will eventually need help in finding
and fixing bugs in their code. While the helpful IDE’s have debugger
tools built in (breakpoints for pausing your program, ways to
view/modify variable values, and "stepping" through code execution),
in many of the other programming environments, students
are limited to using print statements to try and "see" what is happening
inside their program.
Most students who learn to write code for Arduino microcontrollers
will start within the Arduino IDE, but the official Arduino
IDE does not currently provide any debugging tools. Instead, a student
would have to move on to a professional IDE such as Atmel Studio
or acquire a hardware debugger in order to add breakpoints or
view their program’s variables. But each of these options has a steep
learning curve, additional costs, and can require complex configurations.
Based on research of student debugging practices[3, 7] and
our own classroom observations, we have developed an Arduino
software library, called Arduino Debugger, which provides some
of these debugging tools (ex. breakpoints) while staying within
the official Arduino IDE. This work continues a previous library,
(redacted), which focused on features specific to e-textiles development
boards. The Arduino Debugger library has been modified to
support not only e-textile boards (Lilypad, Adafruit Circuit Playground)
but most AVR and ARM based Arduino boards.We are also
in the process of testing a set of Debugging Code Templates to see
how they might increase student adoption of debugging tools.
more »
« less
Pair debugging of electronic textiles projects: Analyzing think-aloud protocols for high school students’ strategies and practices while problem solving.
Much attention has focused on student learning while making physical computational artifacts such as robots or electronic textiles, but little is known about how students engage with the hardware and software debugging issues that often arise. In order to better understand students’ debugging strategies and practices, we conducted and video-recorded eight think- aloud sessions (~45 minutes each) of high school student pairs debugging electronic textiles projects with researcher-designed programming and circuitry/crafting bugs. We analyzed each video to understand pairs’ debugging strategies and practices in navigating the multi- representational problem space. Our findings reveal the importance of employing system-level strategies while debugging physical computing systems, and of coordinating between various components of physical computing systems, for instance between the physical artifact, representations on paper, and the onscreen programming environment. We discuss the implications of our findings for future research and designing instruction and tools for learning with and debugging physical computing systems.
more »
« less
- Award ID(s):
- 1742140
- NSF-PAR ID:
- 10309411
- Editor(s):
- Gresalfi, M.; Horn, I.
- Date Published:
- Journal Name:
- The Interdisciplinarity of the Learning Sciences, 14th International Conference of the Learning Sciences (ICLS) 2020
- Volume:
- 2
- Format(s):
- Medium: X
- Sponsoring Org:
- National Science Foundation
More Like this
-
-
de Vries, E. ; Hod, Y. ; Ahn, J. (Ed.)While making physical computational artifacts such as robots or electronic textiles is growing in popularity in CS education, little is known about student informal conceptions of these systems. To study this, we video-recorded think-aloud sessions (~10 minutes each) of 22 novice CS high school students explaining their understanding of everyday physical computing systems and qualitatively analyzed transcripts and student drawings for their structural, behavioral, and functional understanding of these systems. Most students identified the presence of programs in making these systems functional but struggled to account them structurally and behaviorally. A few students pointed out probable programming constructs in shaping underlying mechanisms, drawing from their prior programming experiences. To integrate these systems in computing education, we call for pedagogical designs to address the invisibility of computation—both of structural interconnections and of program execution.more » « less
-
more » « less
Abstract Much attention in constructionism has focused on designing tools and activities that support learners in designing fully finished and functional applications and artefacts to be shared with others. But helping students learn to debug their applications often takes on a surprisingly more instructionist stance by giving them checklists, teaching them strategies or providing them with test programmes. The idea of designing bugs for learning—or
debugging by design —makes learners agents of their own learning and, more importantly, of making and solving mistakes. In this paper, we report on our implementation of ‘Debugging by Design’ activities in a high school classroom over a period of 8 hours as part of an electronic textiles unit. Students were tasked to craft the electronic textile artefacts with problems or bugs for their peers to solve. Drawing on observations and interviews, we answer the following research questions: (1) How did students participate in making bugs for others? (2) What did students gain from designing and solving bugs for others? In the discussion, we address the opportunities and challenges that designing personally and socially meaningful failure artefacts provides for becoming objects‐to‐think‐with and objects‐to‐share‐with in student learning and promoting new directions in constructionism.Practitioner notes What is already known about this topic
There is substantial evidence for the benefits of learning programming and debugging in the context of constructing personally relevant and complex artefacts, including electronic textiles.
Related, work on productive failure has demonstrated that providing learners with strategically difficult problems (in which they ‘fail’) equips them to better handle subsequent challenges.
What this paper adds
In this paper, we argue that designing bugs or ‘failure artefacts’ is as much a constructionist approach to learning as is designing fully functional artefacts.
We consider how ‘failure artefacts’ can be both objects‐to‐learn‐with and objects‐to‐share‐with.
We introduce the concept of ‘Debugging by Design’ (DbD) as a means to expand application of constructionism to the context of developing ‘failure artifacts’.
Implications for practice and/or policy
We conceptualise a new way to enable and empower students in debugging—by designing creative, multimodal buggy projects for others to solve.
The DbD approach may support students in near‐transfer of debugging and the beginning of a more systematic approach to debugging in later projects and should be explored in other domains beyond e‐textiles.
New studies should explore learning, design and teaching that empower students to design bugs in projects in mischievous and creative ways.
-
Debugging, a recurrent practice while programming, can reveal significant information about student learning. Making electronic textile (e-textile) artifacts entails numerous opportunities for students to debug across circuitry, coding, crafting and designing domains. In this study, 69 high school students worked on a series of four different e-textiles projects over eight weeks as a part of their introductory computer science course. We analyzed debugging challenges and resolutions reported by students in their portfolios and interviews and found not only a wide range of computational concepts but also the development of specific computational practices such as being iterative and incremental in students’ debugging e-textiles projects. In the discussion, we address the need for more studies to recognize other computational practices such as abstraction and modularization, the potential of hybrid contexts for debugging, and the social aspects of debugging.more » « less
-
Debugging, a recurrent practice while programming, can reveal significant information about student learning. Making electronic textile (e-textile) artifacts entails numerous opportunities for students to debug across circuitry, coding, crafting and designing domains. In this study, 69 high school students worked on a series of four different e-textiles projects over eight weeks as a part of their introductory computer science course. We analyzed debugging challenges and resolutions reported by students in their portfolios and interviews and found not only a wide range of computational concepts but also the development of specific computational practices such as being iterative and incremental in students’ debugging e-textiles projects. In the discussion, we address the need for more studies to recognize other computational practices such as abstraction and modularization, the potential of hybrid contexts for debugging, and the social aspects of debugging.more » « less
- Free Publicly Accessible Full Text
-
Accepted Manuscript1.0
- Conference Paper:
- The DOI is not currently available.
