
NSF Org: |
DRL Division of Research on Learning in Formal and Informal Settings (DRL) |
Recipient: |
|
Initial Amendment Date: | August 15, 2017 |
Latest Amendment Date: | August 5, 2019 |
Award Number: | 1742081 |
Award Instrument: | Standard Grant |
Program Manager: |
Chia Shen
cshen@nsf.gov (703)292-8447 DRL Division of Research on Learning in Formal and Informal Settings (DRL) EDU Directorate for STEM Education |
Start Date: | September 1, 2017 |
End Date: | August 31, 2022 (Estimated) |
Total Intended Award Amount: | $357,754.00 |
Total Awarded Amount to Date: | $376,454.00 |
Funds Obligated to Date: |
FY 2019 = $18,700.00 |
History of Investigator: |
|
Recipient Sponsored Research Office: |
3100 MARINE ST Boulder CO US 80309-0001 (303)492-6221 |
Sponsor Congressional District: |
|
Primary Place of Performance: |
3100 Marine Street, Room 479 Boulder CO US 80303-1058 |
Primary Place of
Performance Congressional District: |
|
Unique Entity Identifier (UEI): |
|
Parent UEI: |
|
NSF Program(s): | STEM + Computing (STEM+C) Part |
Primary Program Source: |
04001920DB NSF Education & Human Resource |
Program Reference Code(s): |
|
Program Element Code(s): |
|
Award Agency Code: | 4900 |
Fund Agency Code: | 4900 |
Assistance Listing Number(s): | 47.076 |
ABSTRACT
Debugging is pervasive in both computing education and more generally in problem-solving across many disciplines. Project "Debugging by Design" focuses on the development of debugging for engineering electronic textiles as a central computational thinking practice by putting engineering into high school computer science (CS) classrooms. Unlike traditional approaches that teach debugging strategies, the goal of this project is to investigate a new instructional approach called "debugging by design" where the researchers turn the tables by having students and teachers themselves design debugging activities and materials supported by debugging tools. The hypothesis of the approach is that debugging by design will strengthen teachers' and students' learning of computational and engineering thinking while fostering a growth mindset around computational competencies. Electronic textile construction kits include sewable microcontrollers, sensors, and actuators combining computing, crafting, and engineering thus spanning both the physical and the computational. This particular hybrid medium is ideal for a study on the pedagogical value of debugging in fostering computational thinking in engineering. Bugs can exist in either or both of the media at the same time. Debugging such multi-faceted systems lends itself not only to the practice of computational thinking and programming as a technical skill, but it is also invaluable as a developmental skill leading to a growth mindset and the concept of "productive failure". The project is funded by the STEM+Computing program, which seeks to address emerging challenges in computational STEM areas through the applied integration of computational thinking and computing activities within disciplinary STEM teaching and learning in early childhood education through high school (preK-12).
This project includes interconnected research and materials-design components. The instructional materials developed will be integrated into Exploring Computer Science (ECS) classrooms. The research questions that the project aims to answer include how debugging furthers computational thinking, how debugging encourages a growth mindset, how teachers embed project materials into ECS, and what teachers learn from designing debugging activities. Research will be carried out with ECS classrooms in the Los Angeles Unified School District and School District of Philadelphia. Researchers will work with 2 classrooms (35 students each) in each of the first two years and eight classrooms in the third year. Two "Debuggathons" (debugging design activities) will also be conducted in year 2, with both teachers and students jointly participating. The deliverables of the project include (a) debugging tool support that can help teachers and students debug the code and circuit designs in their advanced electronic textiles; (b) designs and implementations of instructional debugging activities that can be created and used by students and their teachers in Exploring Computer Science high school classrooms; and (c) student and teacher data and analysis that provide evidence on how doing and designing debugging activities can further students' computational thinking and foster a growth mindset.
PUBLICATIONS PRODUCED AS A RESULT OF THIS RESEARCH
Note:
When clicking on a Digital Object Identifier (DOI) number, you will be taken to an external
site maintained by the publisher. Some full text articles may not yet be available without a
charge during the embargo (administrative interval).
Some links on this page may take you to non-federal websites. Their policies may differ from
this site.
PROJECT OUTCOMES REPORT
Disclaimer
This Project Outcomes Report for the General Public is displayed verbatim as submitted by the Principal Investigator (PI) for this award. Any opinions, findings, and conclusions or recommendations expressed in this Report are those of the PI and do not necessarily reflect the views of the National Science Foundation; NSF has not approved or endorsed its content.
This research project, carried out in collaboration with Dr. Yasmin Kafai's group at University of Pennsylvania, designed and developed tools to aid novice designers, in particular middle- and high school students, in troubleshooting problems in electronic textile projects.
Electronic textiles, and more generally craft projects with embedded microcontrollers, have proven to be a vehicle to attract learners to STEM topics -- particularly electronics engineering and software engineering (programming) -- who would otherwise be unlikely to find these topics engaging.
Inevitably students designing and constructing microcontroller projects encounter bugs: the project does not behave the way they intended or expected. Whereas students often see bugs as mistakes to be avoided, bugs are also opportunities for students to learn, and sometimes the student may actually prefer the unintended "buggy" behavior, leading to the oft-heard phrase, "It's not a bug, it's a feature."
Microcontroller projects have two major components: hardware and software. The hardware component is an electronic circuit with sensors such as switches and light and proximity sensors, actuators such as LEDs and motors, all connected to a microcontroller "brain". The software component is code that prescribes the behavior of the microcontroller, for example lighting LEDs or running motors when certain external conditions are sensed. Whereas conventional microcontroller projects use wires and a solderless breadboard or printed-circuit board to connect components, electronic textile projects use conductive thread in place of wires, and typically use a special type of microcontroller that is designed for embedding in fabrics, such as the LilyPad Arduino.
Debugging is the process of finding the source of the unexpected behavior and making a change to the circuit or the program to make the project behave as originally intended. The source of a bug may be in the circuit (such as a broken wire) or the program (such as a misplaced instruction), or it may result from the interaction of the circuit and the program.
Finding and fixing bugs can be frustrating, especially to young and inexperienced learners whose understanding of the underlying principles of electronics and software is incomplete or incorrect. And, unlike physical systems such as plumbing, the electricity flowing through the circuit and the execution of the program is invisible. For this reason, students need tools to help them locate and understand the behavior of their projects. Unfortunately, tools and test equipment to troubleshoot microcontroller projects, and especially e-textile projects, are scarce and not designed for inexperienced learners such as middle school students.
This project addressed this problem: designing and developing tools to support inexperienced learners to troubleshoot and debug e-textile projects. The main tangible project outcomes are a suite of tools that a novice e-textile designer can use to locate the cause of unexpected behavior in an e-textile project (figure 1).
The tools developed are:
- Low-Floor Multimeter, a simple multimeter that provides a continuity tester and a voltage meter.
- The Logic Probe aka Power Check (figure 2) tests whether a thread in an e-textile circuit is powered or grounded, allowing students to easily test circuits.
- The Wrist-Meter (figure 3) combines a voltage meter and a continuity tester that can identify errors while sewing with conductive thread. It measures the voltage through the needle, and if the voltage drops below a threshold, beeps to prompt the user to immediately locate and fix the error.
- The Wearable Mini Voltage Meter is another simplified multimeter, incorporating two alligator clip probes and a large numerical readout. It can be worn while testing a wearable e-textile project.
- The Logic Injector (figure 4) "injects" a high logic state into a circuit. This tool simulates a digital write high to test circuitry for shorts, loose connections, and polarity.
- The Circuit Playground Extension is a microcontroller holder sewn into an e-textile project, making it possible to easily swap microcontrollers when replacing faulty hardware or testing different programs. It is useful in classrooms where students might exchange programs or the teacher might hand out pre-programmed microcontrollers.
- The ThreadBoard (figure 5) is a version of the solderless breadboard specifically for e-textiles. Before sewing a circuit into fabric, students can configure the circuit, using stainless steel conductive thread and electronic components that adhere magnetically to the ThreadBoard. This enables students to experiment with circuit design before sewing the circuit into their fabric.
- Circuit Check (figure 6) is a browser-based program for directly observing a microcontroller project, providing support for investigating hardware or software bugs. Circuit Check displays live sensor readings (such as temperature and light) and supports different actuator states (e.g. turning an LED on). Circuit Check runs alongside the student's program, enabling them to observe their system's internal states while their code is running and allows them to pause the program to isolate and test hardware components.
Last Modified: 01/17/2023
Modified by: Ann N Eisenberg
Please report errors in award information by writing to: awardsearch@nsf.gov.