---

(bright music)

So with all that kind of out of the way, as people are coming in and sitting, I do want to take a moment to introduce our next speaker, Dr. David Weintrop from the University of Maryland. I've been reading David's work for a lot of years now. David wrote his dissertation on transitioning students from block-based coding to text-based coding. We are currently developing some software to facilitate that process now.

Jimmy, raise your hand, Jimmy. If you want to know anything about that, you can come and talk to Jimmy about that. It's our VEXcode VR Switch. He'll be out tomorrow doing some talks on that with the teachers that are out there. But you can also come to our booth, and Jimmy can actually give you a demo on that, some more information on that.

Beyond that, David's expertise lies in things like computational thinking and block-based coding paradigms. I think we've had a lot of talk about implementation here today so far. Teachers and administrators have been discussing what they're implementing and how they're implementing it. We often talk about things like computational thinking, but if you go and talk to folks, you're going to get nine different definitions of what computational thinking is, which isn't really helpful from a pedagogical standpoint in trying to teach it.

David is a foremost scholar in computational thinking. His work has influenced what we do at VEX when we make our curriculum around both computer science and STEM. Teachers often have a love-hate relationship with research—most of the time it's hate, not love—but I think you're going to find David to be very accessible. You're going to have a lot of takeaways from what he's talking about that you can then put into your classroom. Beyond all that, I consider him a good friend. So, it's my pleasure and honor to introduce to you right now Dr. David Weintrop.

(everyone applauding)

Hello, sir. Thank you, thank you. Hi, everyone. How are you guys all doing? Wonderful. So, yeah, Jason invited me to come and share some of my work at the Scaled Up Educators Conferences. "Jason, thanks so much. I really appreciate it. I would love to, under one condition. Please don't make me come up on stage right after a bunch of super impressive high schoolers come up and give their talk, because there's no way I can win over an audience trying to follow up a presentation like that." So Jason, of course, helped me out, so here we are.

Okay, so I want to spend a little time today talking about some work that I've done around computer science education in K-12 classrooms, and also around thinking about ways to integrate computational thinking across the curriculum. Very briefly, the focus of my work is on creating effective, engaging, and equitable computational learning experiences for all students. I've done this in a bunch of different ways.

I've done research looking at block-based programming, and I'm going to spend most of today talking about that. I've done some work looking at ways to integrate robotics into STEM contexts, and I'll, time permitting, share a bit of this Robo.Math project that we did. This is a fourth-grade math plus computational thinking mediated by robotics curriculum. We have the Scratch Encore, a middle school culturally responsive computer science curriculum. Mostly, I just want to put this on people's radar, because if this is something that you're interested in, I will very happily talk with you about it. You can also just google Scratch Encore, a fully featured middle school computer science curriculum. It has everything that you want and has teacher materials, assessments, auto graders, all that good stuff.

We're now working on this project I'm super excited about called API Can Code. This is a high school data science curriculum grounded in API.

It's having high schoolers be introduced to the computational foundations of data science by exploring the data that they create and consume every day through publicly accessible APIs. And then the last bit is this project we have called IMPACT Libraries. IMPACT being an acronym for Improving the Assessment of Computational Thinking in Libraries. This is a whole suite of ways to assess whether or not kids are learning computational thinking skills in informal settings, which can be really productive, thinking about more, less structured kind of robotics in the classroom, robotics after-school projects.

A lot of this is thinking about ways like, are we succeeding in getting kids more interested and excited about computing and robotics? Are we shifting the ways that they're thinking about kind of what they might wanna do after they graduate? Is this having any impact in terms of equity and accessibility? So this is kind of an unconventional approach to assessment that I think is well suited for robotics contexts.

Okay, but all that aside, so this is mostly just some things that I can talk about. So if any of that piques your interest, please come find me. I'd love to hear your thoughts and share what I'm working on.

But what I wanna mostly talk about today is block-based programming in K-12 classrooms. So one of the things that I think is super interesting about block-based programming... I'm kind of assuming that everyone here is familiar with block-based programming. Here we have the VEX VR interface. The origins of where block-based programming came from is that it was an approach to programming explicitly designed for informal contexts. And one of the central goals of the designers of the block-based approach was how can we support kids to learn how to program in a context where they might not have an adult or a teacher present to help them should they get stuck. So they were trying really hard to figure out ways to make these interfaces and approaches to programming accessible for these informal contexts.

They were so successful that increasingly we're seeing block-based programming show up in formal computer science classrooms. And we can see this in middle school, the Scratch Encore curriculum I mentioned a minute ago uses block-based programming. Code.org has all sorts of different curricula. VEX has its suite of CSS curricula, much of which relies on block-based programming. And so the question that I was interested in asking was trying to figure out whether or not bringing block-based programming into formal classrooms is a productive idea.

I mean, my intuition was that, yeah, this is probably a good idea, but again, most of the research that had been done on the question was all about is this fun? Is this engaging? Is it supporting kids in these informal contexts? And we didn't really know very much about does this make sense to do in an eighth grade classroom? Does this make sense to do in a 12th grade classroom? How do 12th graders feel about these kind of playful, colorful blocks, again, designed for middle school students?

So I spent a couple years in a few different high schools in the Chicago Public School District to try and answer this question in a bunch of different ways. The first thing I did is I spent time trying to understand, like there's an assumption that it makes sense to bring block-based programming into classrooms because it's easier, or kids will think it was easier. So the first thing that we did was try and verify this intuition. It's like, do high school students think block-based programming is easier? Kind of here we see that, sure enough, a majority of students think that block-based programming is easier. And in interviews kids would say things like, "Oh yeah, learning Java is way more complicated than blocks." Or they'd say, "Well, in Java there are no blocks to help out."

Thank you for your attention and interest in this topic. If you have any questions or would like to discuss further, please feel free to reach out.

"Like you have to do it all from scratch." And I'm sure there's no pun intended, but the idea is right, this intuition that block-based programming is easier. Panned out the data. And then we went one step further, and we're trying to figure out like, okay, so then what about it makes it easier?

We analyzed a bunch of interviews with students from across the city, and they identified a bunch of what we call perceived affordances. On the right are the aspects of block-based programming that high school students cited as helping make it easier. On the left are quotes that are examples of each one. For example, blocks are easier to read. A student said, "Well, Java's not in English. It's in the Java language. Blocks are in English, so it's easier to understand."

This idea, there's natural language capabilities, and you can have a block that says "Blocks are easier to read," and you can just drop that into a program in a way that you couldn't with text-based. They talked about how the shape and visual layout is a really productive aspect of blocks, that the blocks are kind of rounded diagonal. It's kind of like a puzzle. Things fit together.

As a background, the inspiration for blocks as they're being designed in the 90s, actually came from Lego blocks where it's like, yeah, you think about Legos and how they feel fit together. The other thing that's so brilliant about Lego is you can't really have a, there's no way to make a Lego structure that doesn't compile, you know what I mean? Like there's no syntax error in Lego. Either it snaps together or it doesn't. And so that was the inspiration here. So we see that follow through. Students talking about it's easier to compose. This is both dragging and dropping, being easier than typing, and also not needing to worry about curly braces, semicolons.

They have this neat idea called, that we ended up calling browsability. The idea here is, this comes from the cognitive science literature, and human-computer interaction design, this idea that recognition is easier than recall. Like if you ask someone a question, it's much easier for them to pick the right answer from a list than it is to come up with it on their own. And so what you can do is in a block-based environment you have all these blocks presented in front of you. And so the ability to pick out the thing that you want is much easier than students having to do it from scratch.

And actually, if you can get really clever in the design of the blocks, and say, create a set of blocks tailored to a particular, say, robotics environment, or a particular challenge, you can actually further bridge and support learners in having success. They also talked about this kind of tinkerability, that blocks make it easier to try things, and if it doesn't work, undo it. That might come back to the idea that snapping things is really quick and easy. Prefabricated commands, the idea that one block can do a whole lot of things. Whereas, in text-based program we're kinda building piece by piece.

And then this last bit, this idea of visual outcomes, is the idea that block-based environments, things like, certainly, VEXcode VR, as well as Scratch and Snap, things like that, there's always a visual environment next to it. So you can kind of have the executing, and it's either a robot moving or a sprite dancing, or something like that. Those all live side by side. So a whole bunch of reasons that students think block-based programming is easier.

We also heard from students that there are some ways that students thought that block-based programming was either there were drawbacks to it, counterproductive. So for example, some students would talk about how they thought block-based programming was less powerful, saying things like, "Blocks are limiting."

Thank you for your attention and interest in this topic. We hope this insight into block-based programming has been informative and helpful.

There's not a block for everything. We talked about potentially slower authoring and the idea that as you get more proficient, snapping these together could take a long time. Finally, and potentially most troubling, is the idea that block-based programming is inauthentic. A quote from a student saying, "If we actually wanted to program something, we wouldn't have blocks." Depending on the context, this may or may not be true. However, when considering high school students, some of whom might want to pursue computer science after graduation, the perception of block-based learning as inauthentic could negatively impact their learning experience.

Prefacing this whole question was whether blocks are a productive way to introduce students to block-based programming. We conducted interviews, and it seems like students find it easier, which is a good sign. This suggests that we might want to move forward with it. We designed a study to empirically compare block-based and text-based programming to determine which is more productive and helps students learn better in high school classrooms.

I'm going to take a couple of minutes to describe how we did the study, and then we'll have the big reveal. I spent time developing three programming environments: one fully block-based, one fully text-based, and an in-between implementation. The idea was to hold everything as constant as possible—same programming language, same runtime environment—and only change the way students program.

In the block-based environment, like most block-based environments, you have the blocks pad on the left. You can click around, drag something in, and it snaps into place. You can edit the arguments, and when you run it, you get a lovely spiral. This is a conventional, out-of-the-box block-based interface.

The text-based interface is character by character identical to the block-based interface. We don't have the palette or the dragging and dropping, but character by character, it's the exact same language and program, resulting in the same outcome.

For the hybrid blocks text implementation, we took the same text editor and put the pad on the other side. You can take a block, drag it, drop it, and edit it. Across all three environments, character by character, the program is the exact same, and our lovely little turtle draws the exact same spiral.

I worked with a big public high school in Chicago that had three intro programming classes. We started our study on the first day of school. Period four used block-based, period seven used hybrid, and period eight used text-based programming. The study lasted five weeks. All three classes followed the exact same curriculum, taught by the same teacher in the same classroom. We aimed to test the role of representation in supporting students' learning, controlling for teacher, class, and school effects.

We designed a pre- and post-assessment, and I can provide more details if people are interested.

Thank you for your attention and interest in this study. We hope our findings will contribute to better educational practices in programming education.

But so on the, I think it was the third day of school, we did a pre-assessment. The idea here is we gave... We were asking students about, it was essentially a short test on programming concepts. And so on the third day of school, we have our three dots. And this is exactly what we wanna see. This is some statistics that say there's no difference between these three classes. All three classes have roughly, or statistically have the same kind of incoming knowledge. So this is good, so that means we're starting the same place.

And then five weeks later, each of the classes went through the curriculum using either block-based, text-based, or hybrid. We ran the same assessment again as a post-test. How do you think it went? So as I've learned from observing master teachers, if you guys think students in the block-based condition did the best, hold up a one. If you think students in the... So we'll say blocks is one, hybrid is two, text is three, and then there's a fourth option, which is there's actually no difference. It doesn't matter, hold up a four. So I want you guys to vote about which condition you think did the best? Seeing some ones, some twos, a couple threes. No fours. Oh, we got a four upfront. That all my work, it doesn't matter. All right, so-

(audience laughing)

Love the faith. So, okay, so here's what we found. The first and most important thing is that all three, all three classes learned. The difference between pre and post is a significantly positive slope for all three. So this is good. So in some ways, it doesn't matter, 'cause everyone's learning, but critically we see a significant difference between how students in the blocks condition scored compared to the text condition, which means according to the study, over the course of the first five weeks, students scored significantly higher on a computer science assessment after learning in block-based compared to text-based. Same teacher, same school, same curriculum, same runtime environment, same programming language, again, all that was different between the two was it being block-based or text-based. Pretty neat.

So I wanna do a quick aside, just 'cause I think this is really fascinating. I realize not everyone here is U.S.-based, but many of you guys are. As some of you guys know, in high school, there's this new AP Computer Science Principles exam. One of the fascinating things about AP Computer Science Principles is it does not require a specific curriculum, as a result, there's lots of different curricula that have been designed for AP Computer Science. Interestingly, because it has many different curricula, it also has these different programming languages, which means some students will take an AP Computer Science Principles course and learn to program in, it might be Java, it might be JavaScript in multiple languages. It might be altogether block-based.

But the challenge faced by the college board who creates this test is, who creates this course at the end of the year, students take a pen and paper written exam. And so the question becomes how do you assess students on their programming ability when you don't know what language that they learned or even what kind of programming interface that they've seen. So what the college board came up with was, well, I know what to do, I will just invent my own programming language. So they created their own programming language. This is examples of the programming language. There's Assignment, there's Output, there's Robot Commands, Procedures, all this good stuff. And so this would be a sample question from the pen and paper test might look something like this, but there's a problem, because, well, this is all text-based, so how do we solve this problem? Well, college board once again says, "Ah, this is no problem, I know what to do. "I will just draw circles around these things.

(audience laughing)

And now we have our block-based program.

And this is what they actually did. This is what students they gave computer science to. So that means, so I just did this little song and dance about how I did this study to show that block-based is better than text-based. But the question that the AP Computer Science Principles assessments is actually asking, it's not Snap! and JavaScript. Now we're looking at this. Now it's like, here's the difference. And so, again, character by character, we're holding things constant. But really, the difference between these environments, what it really boils down to is like replacing curly braces with sometimes ovals or sometimes rounded rectangles, sometimes ovals, even got some actual rectangles here. So very sophisticated.

And so the question becomes which of these is better? And so again, going back to we did all this work, it's like, here are all the things that students think make block-based programming easier. But if we think about what the AP college, or the college board did for the AP Computer Science Principles thing is pretty much like, so this is kind of different, but everything else here... I mean they're not browsing commands, they're not composing anything. The character by character is the same. So they've really just isolated the visual layout and kind of replaced curly braces with ovals.

Okay, if you think that students did better on the... Sorry, to take a step back. Did a collaboration with code.org who designed a high school computer science, or AP CS Principles course, taught nationally. So we were able to design and insert an assessment into the code.org materials. That was actually the same assessment that I used for the previous study. We just made a computer science principles version of it. So we just made a version where all the questions were represented either in text-based or block-based AP Computer Science Principle pseudo code.

And so, if you think students perform better on the text-based version, put up a one. If you think students did better on the block-based version of questions, put up a two. If you think there's no difference, put up a three. Okay, so one, if you think... Here, let me pull up this slide again. So if you think this is... One if you think this is better, students perform better this way; two if they perform better this way; three, it doesn't matter. Ones, twos, a couple fives. I dunno what that means.

(audience laughing)

So what these three stars mean in academic literature, these three stars mean that there's a statistically significant difference between these things. What we found is overall, across all students, they did statistically significantly better on the block-based questions than the text-based, which is very exciting for me, because based on my expert opinion, I was pretty sure there was gonna be no difference. I was team three, but wasn't incorrect.

And what's really important to highlight from here is, okay, so, one, all students perform better on questions presented in the block-based form. Again, like block-based is like this goofy AP Computer Science Principle thing. But critically, students from historically excluded populations in computing, this is and women and underrepresented minorities, saw the greatest gains between block-based and text-based. So it's not just that all students perform better, but the students who historically have been the least welcomed and the most excluded from formal conventional computer science contexts saw the greatest gains.

And we've explored a bunch of different potential explanations, including things like cognitive load theory, as explanations about just kind of like a sense of familiarity with things. The idea that things like curly braces and semicolons are just signifiers that students, to show students who don't feel comfortable or confident in computing signifies that this isn't for them.

That this is hard, that this is calling to mind all this, like, oh, I know that I'm not supposed to be good at, or I know that I don't like programming, and therefore it's calling all those kind of emotions or biases forward.

So, what we've learned, kind of getting back to this, and so we did a bunch of different studies looking at the comparison of block-based and text-based, both kind of authentic and these inauthentic environments, and found for the most part that block-based programming students perform better in block-based than text-based. This is good. In some ways what I'm trying to do is marshal a bunch of data to convince you, slash give you the ammunition to convince peers, and especially computer science teachers and old school computer science teachers who are all about text-based programming that in fact not only does block-based programming, not only should it have a role in formal computer science education, but the data is showing that it is productive for learners, especially learners who have historically been excluded from the field.

But there's also this question of, at some point, should students want to kind of move forward in computer science? At some point this transition from blocks to text is gonna need to happen. For example, in the United States, again, not that I'm the biggest fan of the AP system, but it's a useful, it's like as close to a national curriculum as we have, the AP Computer Science A exam is a text-based language. It's based in text-based languages, so it's for students who are, say, sophomores or juniors and really excited about computer science and wanna explore more, they're eventually gonna have to make this transition. And so the question becomes how can we do this?

So, Jason alluded to this, but there's an emerging set of environments and approaches to trying to blend and smooth this transition from block-based to text-based. And so one that VEX has been developing, this is where my student Jimmy's been spending a lot of his time thinking, is this environment called switch mode, where you can write a block-based program the way that you always would, but now we have this cool switch block feature, where you can take a block, switch it to a switch mode, and essentially what the switch mode blocks are are they give you the look and shape of block-based commands, but the inside of it is a mini text editor. So the idea is you can blend block-based and text-based code within one program. And also as we just saw here, you can start with one and you can convert it from one to the other.

And so across these switch mode blocks, you have all the different shapes necessary. You have these hat blocks to define new procedures. You have kind of vanilla inline commands. You have these C shape blocks, where instead of curly braces you have nested things. But now each of the places where there are commands are now text, which is one way that we're looking at scaffolding learners who have become proficient in programming in block-based as they move on to more sophisticated kind of professionally, conventionally professionally forms of block-based programming.

So this is work that we are actively doing. Jimmy will be spending next fall in some classrooms kind of trying to do a similar study to what I just shared, but now looking at if and how this type of environment scaffolds learners and kind of excelling and moving from block-based to text-based.

And so one of the takeaways from this work, and one of the things that I think is so neat and exciting about VEX, and this is something that in talking with Jason and Tim and others I know that the company has been very intentional about, is this idea of designing learning environments that are, one, developmentally appropriate for students, but critically, two, can provide a way to move from one environment to another, so that it's not reinventing the wheel.

This is actually a challenge that we face in the computer science education community more broadly: students moving from fourth grade to fifth, sixth, seventh, eighth, ninth, 10th, and hopping from one language to another language, just kind of feeling like they needed to relearn things. Whereas with VEX, we have VEX 123. We can start with really young, even pre-literate learners, with these press-and-go robots. So kindergarten, first grade students who aren't yet proficient readers.

From there, they can move on to their coder encoder cards, which is starting to be this kind of tangible, highly scaffolded way to start to think about, write programs that feels a little more like conventional programming where you're defining a series of steps one command at a time, you're assembling them kind of one on top of each other. In some ways, it has a lot of the flavor, a lot of the feel of what VEXcode looks like, and with VEXcode we now move from kind of like a physical version of block-based to a more conventional version of block-based.

And then we just saw once learners are working in block-based, now we have this switch mode as a mechanism to further scaffold them along. Once they're more proficient with switch mode, we now have this scaffolded text-based environment where we still have, I talked before about browsability and how productive and important things like just being able to browse available commands to recognize what's available, both in terms of knowing what to do and knowing the syntax associated with it.

So we now have an environment that provides some of these scaffolds of block-based, not in the language itself, but in larger part of the editor. Finally, as students get proficient there, they can move on to things that start to look like, well this is what... Not that they start to look like, it's just like, all right, here we have a fully featured kind of professional integrated development environment for learners to code in.

And so we have this way to kind of move students from... I mean it's kinda wild to think about, but it's one ecosystem that moves students from pre-literate, press-and-go, all the way up through kind of professional programming, professional IDEs, which I think is pretty unique in the space and pretty exciting. Lots of research to be done, and thinking about how to move students from across this trajectory. But I'm really impressed that VEX has covered the whole K-12 trajectory.

---

Okay, so I wanna shift... If it's okay with you guys, I wanna shift gears a little bit to talk about another project that I've worked on called Robo.Math. This is a project funded by the Spencer Foundation, in collaboration with the District of Columbia Public Schools. I worked on it with a colleague of mine, Janet Walkoe at University of Maryland, who studies early algebraic reasoning.

The explicit goal of Robo.Math was to investigate this idea of mutual supportiveness, that students can learn computational thinking and mathematics in a way that they mutually inform each other, and they're mutually beneficial. Mathematics provides a context to apply computational thinking skills. Computational thinking provides a mechanism to explore mathematical concepts. And we're doing all this mediated by robotics.

So, some of you might've picked up, I made this clever shift from talking about computer science to talking about computational thinking. As Jason pointed out, computational thinking as a term is a bit fraught where everyone uses it, but no one's talking about the same thing. I'm assuming this is something that people have experienced to some level. They maybe had like an administrator show up and be like, "Oh, we should do computational thinking." And then you're like, "Okay, great." And then off you go.

So, computational thinking, the contemporary conversation started from this short, three-page kind of think piece by a prominent computer scientist named Jeannette Wing, who wrote, among other things, "To reading, writing, and arithmetic, we should add computational thinking to every child's analytic ability." Great, totally on board. One thing that Jeannette Wing failed to do in this article was provide a useful, meaningful, actionable definition of what computational thinking meant. She left that to us.

In the years since, and so this, as you are experiencing, this idea of computational thinking really caught on, people got really excited about it, a lot of momentum, a lot of investment made behind it. So a bunch of different people have proposed different definitions of computational thinking. This is an overly complicated Venn diagram of different definitions. Like me being a responsible academic, I threw my definition in here, and so I get to be this purple. I didn't actually make this, so I can't take credit. I took this purple sliver. But what we see is common across all of them are these essentially these ideas, abstraction and problem decomposition. And then we're also seeing things like data and information modeling, systems thinking, computational artifacts, which is just a fancy way to say (indistinct) programs, pattern recognition, algorithms design, parallel thinking, conditional logic. So lots of different ingredients.

The way that I think about computational thinking is it essentially just boils down to concepts and skills associated with using computational tools to help solve problems, which to me is a very intuitive accessible definition. And then going back to this kind of mess of here's 75 different definitions, the definition you should use is the definition that's useful and productive for the context that you're in, assuming it aligns with this general goal of concepts and skills associated with computational tools to solve problems. Which means if you're operating in a more data-intensive space, then computational thinking probably is gonna have more to do with data information, maybe modeling and simulation. There's still gonna be algorithms and pattern recognition, but that might look different than if you're working in a space that's, I don't know about physical robotics, or if it's about something more like a creative, expressive context. But again, it all comes back to this idea of concepts and skills associated with using computational tools to help solve problems.

So there's been a push, and again, I kind of assume I'm preaching to the choir a little bit here, where we all collectively agree that computational thinking is this important, useful skillset for all students to have. And so there's a lot of different ways we can think about integrating computational thinking, or introducing learners to computational thinking. So one approach that I'm gonna talk a little bit about now is this idea of integrating computational thinking across the curriculum. What does computational thinking look like in math class, in a science class, English language arts? So having it live across the curriculum. We can also think about given its type close relationship with computer science, we can think about formal computer science classrooms as a context to learn computational thinking.

Thank you for your attention and engagement. I hope this discussion has provided some clarity and inspiration for how we can all incorporate computational thinking into our educational practices.

And then there's this growing suite of ways that students can engage with computational thinking outside the classroom. This might include robotics at home, computational thinking video games, or a museum exhibit currently at the Computer History Museum in Palo Alto, where students write little programs and play with frogs on lily pads. We also have tools like the Makey Makey and Makerspaces as contexts to engage with computational thinking.

I want to spend a little time talking about what computational thinking can look like when it's integrated across the curriculum, particularly in math classes. Integrating computational thinking into math classes is a good idea because all schools have math classes, all schools have math teachers, and critically, all students take math. I was having a conversation earlier today about the challenges of creating these really cool, accessible, fun robotics learning environments, which are currently offered as electives. This means a whole swath of students, for various reasons, are either selecting into or out of these learning opportunities. For instance, if students have to choose between robotics, photography, art, or creative writing, you'll naturally end up with a different set of students in robotics.

The story I heard this morning was about a student who ended up taking robotics not because she was excited about it, but because she thought it would be the easiest option. Now, she loves robotics. The teacher shared that this student, who was just an average student, said the robotics class was the first time she felt like she was really good at something. She only took it because she thought it would be easier than other classes. So, integrating things like robotics and computational thinking into a math class means all students will have an opportunity, whether they like it or not.

The curriculum I mentioned is called Robo.Math, a collaboration with the DC Public School System. A couple of key ingredients informed how and why it took the shape it did. We worked closely with the district to create the curriculum and ensure it aligned with the district's priorities. They were particularly interested in creating memorable, fun, hands-on activities with fourth-grade students in math class. It utilized district resources, using a robotics platform that is not VEX—don't tell anyone—it was actually with Sphero. This wasn't my decision, but a lot of this will translate, don't worry. It aligned with initiatives they were running and, importantly, with critical math standards.

This is another reasonable and common pushback to the idea of integrating computational thinking into a math class. A math teacher might say, "Well, that's great, but I've got every lesson planned from here through the end of the year. Not only that, I have these high-stakes tests happening, I have these standards, and I'm really constrained. I don't have weeks to just play around and do whatever I want." What we can do, and what I'll show you, is create mutually supportive experiences where students learn mathematics by employing computational thinking skills and engaging with robotics as a way to learn math more deeply.

Thank you for your attention and interest in this important topic. I hope this discussion has provided valuable insights into the integration of computational thinking into education.

And so we created a set of activities actually aligned with, in DC we used Common Core Standards, so a set of activities that both aligned with Common Core and we mapped it onto the Eureka curriculum, which is the curriculum that they use. We could say like, "Oh, well on like unit seven, lesson four, just do this other thing, because it's gonna cover the same content, and it'll fit into the like larger sequencing, and it'll be way cooler and better in every possible way." And the teacher's like, "Cool, we'll do it."

Okay, so what did this look like in practice? I don't have that much time left, so I just wanna give you a flavor of what this looks like to show that it's possible. And again, I'm very happy to... We've written about this, we can talk a lot more about it. So what we have here is a DC Public classroom's implementation of a VEX field. DIY VEX field. And so this is a carpet that they have on the floor of their classroom. Each of the rectangles are the same. They're not squares, rectangles. They're each the same size. And so together with the teacher, we put together this obstacle course.

And then what we did was the challenge, as you could maybe guess, is for students to have the robot navigate the course, but what we did was instead of letting students operate directly on the carpet itself to figure everything out, we gave them this to-scale legend that says each carpet square is 24 inches by 21 inches. And then the path, like this is the first leg of the path, the first leg of the path is three and a half squares. So the idea is that the path in the physical space maps onto the path in this kind of representation. And so now the challenge for students became how do we, given this, where we can like figure out the different lengths of all these things, how do we write a program to navigate from the beginning to end?

I'm very quickly gonna show just the start of a video to give you a sense of what this looked like. So for those of you who aren't familiar with Sphero, Sphero, for better or worse, instead of just saying move forward a fixed amount, it uses a direction by an angle, and then it has speed and time. So this is distance equals rate times time. And so for example... So when you're trying to figure out how far to go, you essentially are putting in a speed and putting in a duration.

So to collect data, we have kids wearing these head cams. And so here what they're doing is they figured out that they want to run the length of one square on the carpet, which is 24 inches. And so here what they're doing is this trial and error exercise of trying to decide what the argument should be. So here rolling straight at speed 50 for 0.3 seconds. Well, it's not gonna go very far. They set it back. Now they change it to 0.5 seconds, and it goes a little bit further. And so they're going through this iterative trial and error process to work their way towards one command that will run 24 inches. And spoiler alert, they get to 0.57 and it's really close, you can see you get a super close up. It's like really close, but not quite there. And then finally they land on 0.573 as the distance for how far it's gonna last.

The reason that they were so focused on, the reason they're so focused on getting to 24 inches... So, again, this is our map that they're working on, and that they're thinking about how do we, how are we gonna navigate this math? Thinking about these computational thinking skills of pattern recognition and decomposition, they recognized, oh well we can, if we write a program that runs just one square, example, roll 50 for 0.573 seconds, we can just use it over and over again. And now all of a sudden we have our, we're building up our algorithm incrementally, like we've decomposed the problem into these steps, and now we're building it up incrementally, which is this really nice example of a core computational thinking skill.

And then we have this really... This is where some of the math comes in. We have this neat interaction where now we only have to go half. And so one of the students says, and it was in the video, and I didn't put a video on 'cause it, or I didn't put the audio on, but one of the students says, "Oh, and then we need to go half as far, so we can just cut the speed in half." And sure enough, it turns out if you roll 25 for the same duration, it'll go half as far, which on the one hand is intuitive. But at the same time, for a fourth grader, this is actually pretty sophisticated proportional reasoning about, given that the distance equals rate times time, how changing one factor will influence the other, instead of cutting them both in half, which also could be reasonable. And also knowing kinda the role that these two factors play in terms of producing the outcome.

One other example of something interesting we saw is so the students were trying to get the robot to roll 24 inches. And so they tried 0.7 seconds, and that's too far. 0.03 is not far enough. 0.5 is closer. 0.57 is super close, but not quite there. And then they land on this 0.573, and that ends up working. What's important about this instance here is that precision and place value are Common Core Standards for fourth grade mathematics. And here we see students going from 0.5 to 0.57 to 0.573. Knowing that 0.573 is just a little further than 0.57, despite the fact that, without the decimal, it's comparing 57 to 573. So without the decimal, that's a huge difference. But here we have this really tangible, concrete, visual way to understand what place value means.

And then the last example I'll give from this, and then I'll wrap up with two quick things, is there's another quote, and I think this is just fabulous. So they get to 0.57, and in typical fourth grader fashion, he's like... He says, "We're close enough. I think she would give us that." It's like, oh, you know, the teacher, like whatever, it's fine. He's probably not wrong. But then his partner says, "No, no, no, it's like an inch less. So if it keeps going like that." So it's like, oh, if we're a little off here, we're a little more off here, and we're a little more off here, and we're a little more off here, and it's pretty sophisticated knowing that as part of building our algorithm, we're gonna repeatedly use the same command, and this idea of compounding error as you go. Again, these are fourth graders. Just kind of... And, again, preaching to the choir, fourth graders, here were just doing kind of like in situ, very natively doing all these cool fun robotics things, but at the same time doing this really powerful mathematical reasoning, and mathematical reasoning that aligns to fourth grade math standards, which is wonderful.

Okay, one last thing I wanna very briefly put on people's radar, because I feel anytime I have the opportunity to talk to a room full of classroom teachers and educators, I always like to talk about this, because I think it's really important, and was designed with teachers for teachers. So we created a rubric called, a document called The Teacher Accessibility, Equity, and Content Rubric for Evaluating Computing Curricula. The challenge that we were facing, the problem we were trying to solve here is teachers, educators, administrators are often being asked to make very important consequential decisions about what robotics platform am I gonna use? What curriculum am I gonna teach? What afterschool programs am I gonna run? These are important questions, and we often don't have the tools to answer them in a way that we can feel good and confident about. So in response to that, we created this rubric that has three dimensions.

Thank you for your attention and for the incredible work you do every day. Your dedication to education and to your students is truly inspiring.

The idea is we worked with a bunch of teachers and came up concretely with a list of things that will help make it easier for teachers to adopt. Teacher support, four check boxes; supplemental materials, four check boxes.

The second dimension is called equity. So again, concrete check boxes. How does it attend to culture or community level? Does it provide students opportunities to draw on their identities and interests? Are there ways to support students with exceptionalities, English language learners, special ed? All these are very concrete, right? You can go through and look at a curriculum, just check boxes of what fits and what doesn't.

And the final one is content. Looking at how does it align to, what computer science content is present? Does it align to standards? What instructional and pedagogical practices are present? What instructional design strategies are used? And again, the goal is to be very concrete, so that if you're trying to make a decision between two different curricula, two different robotics toolkits, two different afterschool activities, that you can just kind of run through and look at.

If you go to this, if you search TEC rubric I think you'll find it, but the URL's at the bottom. But the idea is we have some scaffolds to help show you how to use it. But the idea is that this is intended to be a quick and easy way for you to think about whether or not to adopt a curriculum, and critically, especially in the case where you're not the decision maker, are there any gaps in the curriculum? Are there opportunities for me to improve the curriculum? Particularly with respect to things like equity.

If you go through and evaluate your materials with respect to equity and be like, oh, it turns out they don't actually have anything here to support students who have difficulty with reading. Or, oh, there's very few opportunities for students to draw on their own at-home interests to express them as part of what it means to explore this curriculum. And so that would be an opportunity for customization for kinda teachers to supplement what's already there.

Okay, I've thrown a lot at you. I was trying to talk for 45 minutes. I spoke for 26, so apologies for the extra minute. But with that, I would love to get questions, and I'll be around all day as well, so come find me. But yeah, I'd love, love to hear from you, and questions and ideas you guys have.

First of all, thank you, David, very much.

(audience applauding)

Any questions for David? Laura has a question. Can you go to the mic for me, Laura, please? And I'll be quick. Oh, you're fine, yeah. We noticed in our schools that when (indistinct) Robo.Math, and we noticed that in our schools that were high poverty, low SES, the schools that implemented (indistinct) robotics and computational thinking and stuff like that, their scores became number one in our district. And it was not through, we didn't research it. Found that compared to our other titled schools, they started having rigor like that. And my other schools would be like, "Our kids can't do that." But this school was like, "No, they can." And they didn't hold 'em back because they thought they couldn't. They just assumed they could. So, did you run into that with your research? I sort of feel like you sort of stumbled onto something with that.

Yeah, so in case people missed, Laura was sharing experiences of working in, particularly under-resourced schools that historically have not had access to things like robotics curriculum and for students who might not be able to go home and kind of play with their iPad and this other robotics kit that a parent or guardian bought for them. And what she found was that bringing robotics into those classes, students not only thrived, but excelled and actually surpassed some schools that were kind of better resourced, and which first of all the most important thing is like snaps to that.

(snapping fingers)

Hearing those stories... The more people that can hear stories like that more often, the better off we'll all be. That experience definitely resonates with the work we're doing in DC public schools, particularly targeting schools in low socioeconomic or economically depressed areas, bringing robotics into contexts where it historically hasn't been. We very much had that experience working with students.

It has been a significant challenge for teachers, and part of that comes from a space of asking them to do things that might be a bit beyond their comfort zone. Another part of it comes from the challenges of what it means to be a teacher in that type of classroom with students who are not necessarily getting all the supports, as they are growing, complicated humans. It ends up just being the challenge of being in those classrooms.

But one of the things that's so wonderful about VEX Robotics in general is this was... And we had some wonderful quotes from kids who were talking about how this is the first time they've ever really enjoyed math, because seeing things blink, seeing things roll around is just more fun, engaging, cool, and exciting. It can provide a level of insight, engagement, and enthusiasm that you can then bootstrap to do some of the more content learning, shifting attitudes, perceptions, and confidence development.

Jimmy and I have a paper on VEXcode 123 as a mechanism to try and support social-emotional learning and storytelling with robotics. That was a long-winded way of saying, snaps and thank you for sharing, and yeah. Excellent.

All right, other questions, comments? Yes, please.

Thank you. First, I want to say I appreciate the work you do in this area. I particularly love your computational thinking framework that looks at integration between science and math. I've used that to help frame afterschool programs. I think that's a powerful tool as well because it breaks down and gives educators ways to really think about building students' computational thinking throughout.

There's some other work you've done also where you, and I may be misrepresenting it, but you talk about computational literacy and computing, and the importance of describing those components and showing where there is a nexus or a meet between them. If you were looking at building competencies from K-5, middle to high, is it practices to behaviors? Or am I... I think I'm missing something.

No, that sounds great. I hope I said something like that. (audience members laughing)

But just thank you for the work, because it really informs the Praxis components, and I'm super excited you're here. I want to exchange my contact information with you because there's work I'm doing with Virginia Tech that I feel your work will still support in those realms. So thank you.

Wonderful. Thank you for saying that. I should also say, these are a bunch of different projects. All of these resources are freely available. You can get to all of them from my website, and for all of them except for IMPACT Libraries, we worked closely with teachers. This is a conversation I was having earlier today about how important it is to get teacher, administrator, and parent voices and values present in the work that we're doing.

For the IMPACT Libraries, we didn't work with teachers. We worked with librarians, but again, it's the same idea of hearing your voices and bringing together research and practice in ways that make what we find more accessible, easily adoptable, and better aligned. So we're not showing up with Jeannette Wing's not useful definition of computational thinking. Like, oh no, no, no, here's a concrete...

Here are six things you could do in your classroom that we discussed with a group of teachers. These are strategies they are already implementing, and you can bring them into your classroom as well.

By incorporating computational thinking, you can supercharge these strategies. Computational thinking might have been present in your classroom already, but perhaps it was hidden in one way or another.

That's good? Great. I'll be around for the rest of the day, so please don't be shy about coming over. I'm happy to talk about any of this stuff.

Thank you.

(audience applauding)

Wonderful, thank you everyone.

(bright music)