Purpose Much remains unknown about how young children orient to computational objects and how we as learning scientists can orient to young children as computational thinkers. While some research exists on how children learn programming, very little has been written about how they learn the technical skills needed to operate technologies or to fix breakdowns that occur in the code or the machine. The purpose of this study is to explore how children perform technical knowledge in tangible programming environments. Design/methodology/approach The current study examines the organization of young children’s technical knowledge in the context of a design-based study of Kindergarteners learning to code using robot coding toys, where groups of children collaboratively debugged programs. The authors conducted iterative rounds of qualitative coding of video recordings in kindergarten classrooms and interaction analysis of children using coding robots. Findings The authors found that as children repaired bugs at the level of the program and at the level of the physical apparatus, they were performing essential technical knowledge; the authors focus on how demonstrating technical knowledge was organized pedagogically and collectively achieved. Originality/value Drawing broadly from studies of the social organization of technical work in professional settings, we argue that technical knowledge is easy to overlook but essential for learning to repair programs. The authors suggest how tangible programming environments represent pedagogically important contexts for dis-embedding young children’s essential technical knowledge from the more abstract knowledge of programming.
more »
« less
Objects to debug with: How young children resolve errors with tangible coding toys
Debugging is an important skill all programmers must learn, including preliterate children who are learning to code in early childhood settings. Despite the fact that early learning environments increasingly incorporate coding curricula, we know little about debugging knowledge in early childhood. One reason is that the tangible programming environments designed for young children entail a layer of material complexity that we have yet to account for in terms of learning to debug. In our study of young children learning to program, we found that in the midst of solving programming tasks and learning to debug, tangible toys presented bugs of their own. This paper analyzes video of Kindergarteners learning to debug errors in the program and errors in the physical materials. We argue that concurrent physical and programming bugs present opportunities for young children to learn about the broader computational system in which they are learning to code.
more »
« less
- Award ID(s):
- 1842116
- NSF-PAR ID:
- 10288749
- Date Published:
- Journal Name:
- Proceedings of the International Society of the Learning Sciences (ISLS) Annual Meeting
- Format(s):
- Medium: X
- Sponsoring Org:
- National Science Foundation
More Like this
-
-
more » « less
Abstract It is critical to teach all learners to program and think through programming. But to do so requires that early childhood teacher candidates learn to teach computer science. This in turn requires novel pedagogy that can both help such teachers learn the needed skills, but also provide a model for their future teaching. In this study, we examined how early childhood teacher candidates learned to program and debug block-based code with and without scaffolding. We aimed to see how approaches to debugging vary between early childhood teacher candidates who were provided debugging scaffolds during block-based programming and those who were not. This qualitative case study focused on 13 undergraduates majoring in early childhood education. Data sources included video recording during debugging, semi-structured interviews, and (in the case of those who used scaffolding) scaffold responses. Research team members coded data independently and then came to consensus. With hypothesis-driven scaffolds, participants persisted longer. Use of scaffolds enabled the instructor to allow struggle without immediate help for participants. Collaborative reasoning was observed among the scaffolded participants whereas the participants without scaffolds often debugged alone. Regardless of scaffolds, participants often engaged in embodied debugging and also used trial and error. This study provides evidence that one can find success debugging even when engaging in trial and error. This implies that attempting to prevent trial and error may be counterproductive in some contexts. Rather, computer science educators may be advised to promote productive struggle.
-
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
-
more » « less
Abstract Computational thinking (CT) is an important twenty-first century skill that begins developing early. Recent interest in incorporating early CT experiences in early childhood education (i.e., preschool) has increased. In fact, the early years mark an important time during which initial competencies are acquired, interest and motivation begins to form, and in which children may develop a sense of belonging in STEM fields. As a result, providing children with access to robotics and computer science experiences to support CT that are also developmentally appropriate and culturally relevant is key. This paper uses the “powerful ideas” of computer science, seven developmentally appropriate CT concepts that children can learn, as a framework and explores the experiences of two (composite) teachers who participated in and co-developed a culturally relevant robotics program and the processes they undertake to support children’s CT development and learning. This paper considers practices that support the seven key powerful ideals while leveraging existing instructional routines and contexts that are already occurring in most classrooms, such as centers, small group activities, classroom environments, and read-alouds. Of note, this paper prioritizes approaches that acknowledge, center, and feature the ethnic, cultural, and linguistic backgrounds of young children and their families. Identifying affordable and accessible practices, this paper provides educators with tangible, integrated, and authentic practices to support children’s computational thinking, STEM learning, and sense of belonging.
-
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.
- Free Publicly Accessible Full Text
-
Accepted Manuscript1.0
- Conference Paper:
- The DOI is not currently available.
