Task-specific programming for and about computing education (Precalculus TSP Part 5 of 5)

October 4, 2019 at 7:00 am 2 comments

I am exploring task-specific programming as a direct outgrowth of my work on GaComputes, ECEP, and ebooks. I’ve worked hard at helping computing education to grow in the US, but it’s not growing much (see my September Blog@CACM post for stats on that). There are too few people learning with the power of computing. It’s because we make programming so hard. We need to make programming more accessible, and one way to do that is to make it easier.

Why do we need to make it more accessible? My answer is: in order for people to use computer science for learning everything else. In 2009, when Matthias and Shriram wrote “Why computer science doesn’t matter” (see paper here), I hated it. Of course, computer science matters! Now I realize that they’re right. Nobody gets turned away from college admissions because they didn’t have high school CS. MANY students get turned away because they can’t pass Algebra 1. Other students don’t finish their degrees because they can’t get past Calculus. This other stuff really matters. I believe that we can use programming to help learn the stuff that really matters.

A key insight for me is that what students really use in Bootstrap:Algebra or even in Scratch is a small piece of programming. (I talked about this a good bit in my SIGCSE keynote.) We can reduce how much of programming we teach and still get huge benefits. Essentially, the students in Scratch and Bootstrap:Algebra are doing task-specific programming. I’m just going one step further to strip away even the trappings of a more general programming language. I’m making it as small as I can (but large enough to cover a learner’s task), so that we can increase usability, and thus increase the probability that we can apply programming to improve learning outcomes in other disciplines.

But it’s still programming, so the insights and theories of computing education research (CER) deeply influence this work on task-specific programming. In turn, task-specific programming offers the opportunity to ask some of our CER questions in new contexts. Here are two examples.

Notional Machines

At the Dagstuhl Seminar on Notional Machines (see post by Ben Shapiro), there was a key moment for me. Someone said something there about “Part of the notional machine for algebra.” I stopped and went all academic on them. “Wait a minute — if that’s a real rule used for evaluating algebra, then it’s not a notional machine. Notional machines are simplifications. That’s real algebra, not a notional machine.” There was a bit of a fight after that. It’s kind of a blur now.

In my two prototypes, I want the mathematics to be the notional machine. The notional machine for the image filter builder is matrix arithmetic and scalar multiplication. Underneath, it’s doing something more complicated, but I want students to completely understand what’s going on in terms of matrices.

The notional machine for the texture wave builder is a bit more complicated. My goal is for the notional machine to be just the wave function, but it’s a bit more than that. It’s also how the wave function maps to RGB values in a picture, and I’m actually not sure I have it right yet. If you have a wave where you just manipulate red here, and a wave that manipulates gray there (where red=green=blue at all pixels), then how do I combine the red component with the gray component in some reasonable way? I’ve tried a few ways already. I’ve thought about adding another task-specific language, just to let the students specify the mapping.

Of course, these are really simple programming models (no variables, no user-defined functions), so the notional machines are really simple, too. As much as possible, the notional machine is the context itself — math, or math+graphics. When does learning this notional machine help you learn other notional machines later?

And what have you learned if you learn those? Does task-specific programming help you learn more within the task domain? I hope that learning the matrix notional machine for image filters helps you with matrix manipulation later. Do students really learn precalculus from these prototypes?

If you learn the notional machine for task-specific programming, does that help you learn other notional machines later? There still is a computational notional machine embedded in there, e.g., about controlling the computational agent, about order of execution, and so on. Does that knowledge transfer to other computational contexts?

Structure-behavior-function models

My student Katie Cunningham is studying the use of structure-behavior-function (SBF) models for understanding how students come to understand programs. (I defined SBF models here). In short, this theoretical framing helps us understand the relationships between students learning to read code, to write code, to trace code, and to explain code in plain English.

Task-specific programming doesn’t fit the same way in that model. There is no writing of code. There is structure to the programs, but more of it is embedded in the environment than in the textual language. One of the insights from the participatory design sessions that we’ve had with teachers is that the environment is so much more powerful than the language. Consider the statement in my wave texture generator Set Gray to 4sin(5(x-3))+0. That does completely define the structure and transformation. However, the below picture is is so much more powerful and is what students really see — multiple, linked representations that explain that one line of code:

Behavior is complicated. As I said above, I want the behavior to be the notional machine of the mathematics. To trace the operation above, a student might plug in values for X to see what Y is generated, and check the plot and the wave to see if it makes sense. But it’s not like variable tracing.

But the explain in plain English task of figuring out the function is still there. Check out this image filter program:

Readers who know Media Computation or graphics will likely recognize that as the program to compute the negation of an image. How do we help students to do that? How do we help students to see the program and figure out what it does at a macroscopic level? I built tools into the wave texture builder to make it possible to see the role of each wave in the overall texture, but if you were to describe a texture as a “tightly-woven red and green plaid,” I’m not sure how you’d get that purpose/function from the definition of the waves The problem of figuring out the function is pretty much the same in task-specific programming.

Where to go from here

So this is the end of the series. I’ve described two prototypes for task-specific programming in precalculus (matrix transformations and wave functions), and explored the implications of task-specific programming for research about programming, in education, and in relation to computing education research (this post).

I did these as blog posts, in part, because I’m not yet sure where I might publish and fund this work.

  • Most learning sciences work focuses on students. I’m focusing on teachers first.
  • Most CS education work focuses on learning about CS, especially programming. I’m focusing on using CS programming for learning something else.
  • Most programming languages work focuses, well…on languages. I’m focusing on programming where languages are a second-class citizen.
  • Most work on CS in K-12 is focused on either computational thinking or teaching standalone CS classes. I’m focusing on integrating computing into classes with a goal of reducing computational thinking as much as possible.
  • Most NSF funding in CS Education is tied to work with schools and districts (RPP), and is about CS integration in elementary school and CS-specific classes in high school (STEM+C).  I’m doing design work with teachers for CS integration at the high school level.
  • There is funding (like NSF DRK12 and Cyberlearning) for developing interesting technology for learning, but I’m at the design stage. DRK12 has exploratory grants, but the funding level is too low to pay for my collaborators and my students. How do you get something like this started?

I’m seeing more clearly the point that Greg Nelson and Amy Ko talked about at ICER last year (see paper here). This is design-first work. It’s hard to find a home for that.

I’d appreciate your advice. Where is there a research community that’s concerned about these kinds of things? Where should I be publishing this work? Where should I be looking for funding?


Entry filed under: Uncategorized. Tags: , , , .

Task Specific Programming will only matter if it solves a user’s problem (Precalculus TSP Part 4 of 5) An Analysis of Supports and Barriers to Offering Computer Science in Georgia Public High Schools: Miranda Parker’s Defense

2 Comments Add your own

  • 1. Michael Mannix  |  October 4, 2019 at 9:17 pm

    Hello Mark,
    I follow you on Twitter. Your tweets and blog posts give me some solace that my personal mission in my high school physics classroom is a worthy pursuit as well as some insight into the issues I experience. I am evolving means to teach 9th grade intro physics at a public high school in which Snap! visual block programming is a prominent feature. I have a blog at http://www.physicswithsnap.com. My personal experience convinces me that coding to simulate physical phenomena can provide exceptional insight and a modest thrill to learners. I chose a visual block platform because I know it to be more accessible to my students than text-based code. I am glad to have the term “task-specific-programming” to categorize what I am doing. I appreciate your work and analysis. I will continue to follow and I wish you the best in this work.

  • […] Task-Specific Programming languages, which I’ve blogged about here (here’s a thread of examples here and here’s an announcement of funding for the work in social studies). We now refer to the […]


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Trackback this post  |  Subscribe to the comments via RSS Feed

Enter your email address to follow this blog and receive notifications of new posts by email.

Join 10,185 other subscribers


Recent Posts

Blog Stats

  • 2,039,880 hits
October 2019

CS Teaching Tips

%d bloggers like this: