The idea of a De-Construction Kit™ arose from my work as a software engineer and computer science teacher. In 2002-2012 I taught computer science at Penn Engineering. Early-on, several of us* created an auto-grading system to grade students’ Java and C programs. It was a way to force ourselves to give clear instructions, and to standardized grading.
Starting in 2005 I worked on a software development team (with Fernando Pereira, Mark Fickett, and others)** to create an educational technology called BotWorld, a micro-world with seven projects, inspired by Pac-Man and Karel the Robot, to help students learn Java. Each project comes with skeleton code (incomplete code) and specifications. Our auto-grading system graded the students’ projects. Over the years over 1,000 students have completed BotWorld projects. We wrote a white paper and gave a SIGCSE workshop (Griffin, Menezes, Chen, & Palsetia, 2010).
Aside from BotWorld, I created hundreds of interactive practice problems for learning Java with DrJava , an interpreter that’s great for hands-on learning with immediate feedback. As many CS teachers do, I sometimes gave students code to debug, usually “find the bug and fix it” problems. Unlike some teachers, I use well-written (vs. obfuscated code) with a small number of bugs (vs. many). I also created some typical explore activities: e.g. to trace code and predict outcomes, or to change/remix code to see what happens.
As you can see, the kinds of things people do with De-Construction Kits (e.g. exploring, debugging, completing) are common in CS education. But we tend to lump them with a lot of other things into one big bucket called “problem solving.” Instead, we can think of them as learning-by-taking-apart, or de-constructionist activities. This conceptualization can help us with the instructional design process, with the goal of providing scaffolded learning with fading support.
In 2008 I was introduced to constructionism at a Scratch workshop (at SIGCSE) taught by one of the Scratch designer/developers, John Maloney. I loved the approach. It emphasizes creative computing, making things that are personally meaningful, and sharing your creations with others. I started playing with Scratch on my own and decided to use it in my classes. Within a few years I learned about other cool educational technologies that also use a constructionist approach, such as MIT App Inventor for Android and Snap!. Seymour Papert’s constructionism made a splash back in the early 1980s. Now it’s enjoying a second wave.
In 2009 I met qualitative researchers from Penn’s school of education who knew Scratch well. Quinn Burke (advised by Yasmin Kafai) and I co-taught a Scratch workshop for my summer students. It was fun and the students liked it. The creative part was great, but some learning opportunities were missed because students often chose to use the easiest constructs. I had the idea to create Scratch animations with bugs (errors) in them, carefully designed to make students interact with key computing concepts. (Some people had done similar things before, but in a different way and for different purposes, e.g.(G. C. Lee & Wu, 1999).) I asked Eliot Kaplan, a teaching assistant, to create some of these buggy animations, and he did. Over the years I created quite a few, as did several other TAs. (Anand’s clock and Ameya’s basketball game come to mind.) I decided to give a name to the buggy Scratch projects. I asked Eliot which name he preferred – DebugIt or Debug’em. He liked Debug’em so we went with that (though we originally spelled it Debugem).
Also in 2009 (if I recall the date correctly), I invited Michael Moore (also advised by Yasmin) to give an e-textile workshop to my summer students. Our students sewed 
electronics with conductive thread on to fabric to make cool light-up hats and bags. The kids generally liked it, but one downside was the amount of sewing it required. I will admit that I am not good at sewing and I found that part quite frustrating! I wondered if there was a way to learn about electronics from e-textiles without so much sewing. I realized we could make something like a Debug’em with the e-textiles, so students could focus on troubleshooting the electronics. I asked Eliot to make some “physical debuggers” with the same philosophy. He did, and we videotaped students using the very first ones. One day I realized that these “physical debuggers” were similar enough to the Scratch Debug’ems to be called Debug’ems too. (I guess this seems obvious now but it didn’t at the time.)
In 2010 several us started working on an NSF-funded project about mentoring. We started using the Scratch and e-textile Debug’ems in grant-related activities like camps and workshops. That fall I suggested that we submit a pair of similar posters to SIGCSE, one for the Scratch Debug’ems and the other for the e-textile Debug’ems. It had occurred to me that both kinds of Debug’ems complemented the constructionist pedagogy and could be viewed as deconstruction kits – like construction kits in reverse. Our posters were accepted (Griffin, Kaplan, Burke, & Kafai, 2011; Kaplan, Griffin, Kafai, & Burke, 2011).
Around 2010 I was inspired by two things to create different kinds of exploring activities. When I worked with Harvey Scribner’s students at University City Hi
gh School (now gone), my time in the classroom was short and the kids didn’t have enough time to create their own Scratch animations. Nor did they know enough about Scratch yet to debug Debug’ems. So I created a complete Scratch animation about Harvey’s Random Acts of Literacy project for Harvey’s students to explore. I gave the students a treasure hunt to find things in the code. I also started going to workshops about teaching with the POGIL approach. It uses guided inquiry. With PO
GIL, exploring a model is always the first step.
In 2011, post-doc Deborah Fields and graduate student Kristin Searle joined Yasmin’s group. They continued the work I started on debugging with e-textiles and presented a poster at SIGCSE (Fields, D. A., Kafai, Y. B., Searle, K. A. & Min, Hannah S., 2012).
In 2012 I wrote a paper that expanded the idea of a De-Construction Kit beyond debugging. It outlines design principles for three kinds of kits – for exploring (like Harvey’s animation), debugging (like Debug’ems), and for completing (like BotWorld). It discusses their applicability to a range of topics including coding and physical systems (with music boxes and e-textiles as examples). It also introduces deconstructionism as a theory complementary to constructionism (Griffin, Kaplan, & Burke, 2012).
In 2013 I created Debug’ems for MIT App Inventor for Android using Ralph Morelli’s cloud-based quizly system. I also created De-Construction Kits for learning Python, using paper worksheets, when I co-taught with J.D. Dougherty at Haverford College. (Our students had the option to do a constructionist project too; a gallery of their work can be found here.)
Yasmin’s group and others continued to explore debugging and de-constructing with physical objects (Kafai et al., 2014; Kafai & Vasudevan, 2015; Murer, 2015; Murer, Jacobsson, Skillgate, & Sundström, 2014).
In 2016 I started using the Runestone Interactive e-book authoring system to make De-Construction Kits for learning Python. I love all the interactive components it has, for learning to code or for any number of other topics. I am now experimenting with learning progressions that use series of De-Construction Kits and I am continuing to develop deconstructionism as an instructional theory (Griffin, Kaplan, & Burke, 2012; Griffin, 2016; Griffin, 2017).
If you would like to describe your work as being similar to or inspired by a de-constructionist approach, please reference (Griffin, Kaplan, & Burke, 2012) or (Griffin, 2016). If you would like to call something you’ve created a Debug’em® or a De-Construction Kit™ please contact us using the Contact page.
* Grading Software Dev Team: concept: Jean Griffin and Fernando Pereira; project mgmt: Griffin; software dev: Owen Gunden, Will Lovas, Bertan Aygun, Ari Gilder, Zach Goldberg, Luciano Cheng
** BotWorld Team: concept: Griffin and Pereira; project mgmt: Griffin; software dev: Mark Fickett, Ryan Menezes, Lu Chen; grading software: Ari Gilder & crew; project authoring: Gilder, Kevin Lehrman, Chen, Menezes, (who else?); web: Chen, Menezes; artwork: Chen.
References in Chronological Order
Lee, G. C., & Wu, J. C. (1999). Debug It: A debugging practicing system. Computers & Education, 32(2), 165–179.
Griffin, J., Menezes, R., Chen, L., & Palsetia, D. (2010). BotWorld, an “Objects-First, Algorithms Early” Java Microworld. In Workshop presented at the 41st ACM Technical Symposium on Computer Science Education (SIGCSE ’10).
Griffin, J., Kaplan, E., Burke, W. Q., & Kafai, Y. B. (2011). Deconstruction Kits in Scratch: Designing Scratch Debugems for Learning Core Programming Concepts. Proceedings of the 42nd ACM Technical Symposium on Computer Science Education (SIGCSE ’11).
Kaplan, E., Griffin, J., Kafai, Y., & Burke, W. (2011). A Deconstruction Kit for the LilyPad Arduino: Designing Debugging Sets for Computing and Electronics Concepts. In Proceedings of the 42nd SIGCSE Technical Symposium on Computer.
Fields, D. A., Kafai, Y. B., Searle, K. A. & Min, Hannah S. (2012, March). Debuggems to assess student learning in e-textiles. Poster presented at the annual meeting of the ACM Special Interest Group on Computer Science Education (SIGCSE).
Griffin, J., Kaplan, E., & Burke, Q. (2012). Debug’ems and Other Deconstruction Kits for STEM Learning. In Proceedings of the Integrated STEM Education Conference (ISEC), IEEE 2nd (pp. 1–4). IEEE.
Murer, M., Jacobsson, M., Skillgate, S., & Sundström, P. (2014). Taking Things Apart: Reaching Common Ground and Shared Material Understanding. Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, 469–472.
Kafai, Y. B., Lee, E., Searle, K., Fields, D., Kaplan, E., & Lui, D. (2014). A crafts-oriented approach to computing in high school: Introducing computational concepts, practices, and perspectives with electronic textiles. ACM Transactions on Computing Education, 14(1), 1–20.
Murer, M. (2015). Un-Crafting : Exploring Tangible Practices for Deconstruction in Interactive System Design, 469–472.
Kafai, Y., & Vasudevan, V. (2015). Hi-Lo tech games: Crafting, Coding and Collaboration of Augmented Board Games by High School Youth. In Proceedings of the 14th International Conference on Interaction Design and Children – IDC ’15 (pp. 130–139).
Griffin, J. M. (2016). Learning by Taking Apart: Deconstructing Code by Reading, Tracing, and Debugging. In Proceedings of the 17th Annual Conference on Information Technology Education (SIGITE ’16) (pp. 148–153). ACM.
Griffin, J. M., (2017, January). Learning the Python Programming Language With Interactive Deconstruction Kits. Poster presented at the 15th Annual Faculty Conference on Teaching Excellence, Temple University, Philadelphia PA.
This website is Copyright © Jean Griffin. DEBUG’EM is a registered trademark and Deconstruction Kit is an unregistered mark of Jean Griffin. All rights reserved.-
De-Construction Kit 