## Task Specific Programming will only matter if it solves a user’s problem (Precalculus TSP Part 4 of 5)

*September 30, 2019 at 7:00 am* *
7 comments *

This is the fourth in a five part series about Precalculus Task-Specific Programming. I presented two prototypes in Parts 1 and 2, and discussed what I’m exploring about programming in Part 3.

I’ve shown my prototypes to several teachers — some computer science (e.g., I presented the first prototype at the Work In Progress Workshop at ICER in Toronto) and a half-dozen math teachers. The computer science teachers have been pretty excited, and I have had several requests for the system to try out with various student groups.

Why am I looking at precalculus? Because it’s what leads to success in college calculus. I’m influenced by Sadler and Sonnert’s work showing that high school calculus isn’t the critical thing to support success in undergraduate calculus (see article here). It’s precalculus. Undergraduate calculus is a gatekeeper. Students don’t get STEM undergraduate degrees because they can’t get through calculus. So if we want more students to succeed in STEM undergraduate, we want high school precalculus to get better, in terms of more inclusive success.

Precalculus is a pretty abstract set of topics (see an example list here). For the most part, it’s foreword looking: “You’ll need this when you get to Calculus.” My idea is to teach precalculus with concrete contexts made possible by computing, like image filters. I want more students to find precalculus more engaging and more personally meaningful, leading to more learning.

So, might my prototypes help students learn precalculus?

Math teachers have generally been, “*Meh*.”

I’ve had four teachers tell me that it’s “interesting*.” One math teacher was blunt and honest — **neither of these tools solve a problem that students have**. Basic matrix notation and element-by-element matrix operations are the *easiest* parts of matrices. Precalculus students can already (typically) figure out how to plot a given wave equation.

What’s hard? Students struggle with forms of matrix multiplication and determinants. They struggle with what each of the terms in the wave function do, and what influences periodicity. Seeing the graphed points is good, but having the values display in symbolic form like `(3*pi)/2`

would be more powerful for making a connection to a unit circle. I’m learning these in a participatory design context, so I actually pushed more on what would be useful and what I need to do better — I have a much longer list of things to do better than just these points.

The math teachers have generally liked that I am paying attention to disciplinary literacy. I’m using their notations to communicate in the ways that things are represented in their math textbooks. I am trying to communicate in the way that they want to communicate.

Here’s the big insight that I learned from the mathematics teachers with whom I’ve spoken: **Teachers aren’t going to devote class time or their prep time to something that doesn’t solve their problems.** Some teachers are willing to put time into additional, enrichment activities — if the teacher needs more of those. As one teacher told me, “Most math classes are less about *more exploration*, and more about *less failure*.” The point of precalculus is to prepare students to pass calculus. If you want more diverse students to get into STEM careers, more diverse students have to get through calculus. Precalculus is important for that. The goal is *less failure, *more success, and more student understanding of mathematics.

This insight helps me understand why some computational tools just don’t get a foothold in schools. At the risk of critiquing a sacred cow, this helps to explain why Logo didn’t scale. Seymour Papert and crew developed turtle geometry, which Andrea diSessa and Hal Abelson showed was *really* deep. But did Logo actually solve a problem that students and teachers had? Turtle graphics is beautiful, and being body syntonic is great, but that’s not the students’ problem with math. Most of their real problems with mathematics had to do with the cartesian coordinate system, not with being able to play being a turtle. Every kid can walk a square and a triangle. Did students learn general problem-solving skills? Not really. So, why should teachers devote time to something that didn’t reduce student failure in mathematics?

It would be hard to be disciplinary literate when Logo and turtle geometry was invented. Logo was originally developed on teletype machines. (See Cynthia Solomon’s great keynote about this story.) The turtle was originally a robot. Even when they moved Logo to the Apple II, they could not match the representations in the kid’s textbooks, the representations that the teachers were most comfortable with. So instead, we asked student to think in terms of `fd 200 rt 90`

instead of `(x,y)`

. Basic usability principles tell us to use what the user is familiar with. Logo didn’t. It demanded more of the students and teachers, and maybe it was worthwhile in long run — but that tradeoff wasn’t obvious to the teachers.

I have a new goal:

*I want to provide a programming experience that can be used in five minutes which can be integrated into a precalculus class to improve on student learning.*

I want to use programming to solve a learning problem in another domain. Programming won’t enter the classroom if it doesn’t solve a teacher’s problem, which is what they perceive as the student’s problem. *Improving student learning is my users’ (teachers’) goals. Good UI design is about helping the user achieve their goals.*

I’ve started on designs for two more precalc prototypes based on the participatory design sessions I’ve had, and I’m working on improving the wave texture generator to better address real learning problems. The work I’m doing with social science educators is *completely* driven by teachers and student learning challenges. That’s one of the reasons why I don’t have working prototypes there yet — it’s harder to address *real* problems. My precalc prototypes were based on my read of literature on precalculus. That’s never going to be as informed as the teacher-in-the-classroom.

Now, there’s another way in which we might argue that these prototypes help with education — maybe they help with learning something about computer science? Here’s a slide from my SIGCSE 2019 keynote, referencing the learning trajectories work by Katie Rich, Carla Strickland, T. Andrew Binkowski, Cheryl Moran, and Diana Franklin (see this blog post).

You’re not going to learn anything about #1 from my prototypes — you can’t write imprecise or incomplete code in these task-specific programming environments. You can learn about #2 — different sets of transformation *can* produce the same outcomes. You definitely learn about #3 — programs are made by assembling instructions from a (*very*) limited set. If I were to go on and look at the Rich et al. debugging learning trajectories (see paper here), there’s a lot of that in my prototypes, e.g., “Outcome can be used to decide whether or not there are errors.”

So here’s the big research question: *Could students learn something about the nature of programming and programs from using task-specific programming? * I predict yes. Will it be transferable? To text or blocks language? Maybe…

Here’s the bigger research question that these prototypes have me thinking about. For the moment, imagine that we had tools like these which could be used reasonably in less than five minutes of tool-specific learning, and could be dropped into classes as part of a one hour activity. Imagine we could have one or two per class (e.g., algebra, geometry, trigonometry, biology, chemistry, and physics), throughout middle and high school. *Now*: Does it transfer? If you saw a dozen little languages before your first traditional, general-purpose programming language, would you have a deeper sense of what programs did (e.g., would you know that there is no Pea-esque “super-bug” homunculus)? Would you have a new sense for what the activity of programming is about, including debugging?

I don’t know, but I think it’s worth exploring task-specific programming more to see if it works.

**Request to the reader:** I plan to continue working on precalculus task-specific programming (as well as in social studies). If you know a precalculus teacher or mathematics education researcher who would be interested in collaborating with me (e.g., to be a design informant, to try out any of these tools, to collaborate on design or assessment or evaluation), please let me know. It’s been hard to find math ed people who are willing to work with me on something this weird. Thanks!

* In the South, if you hear “Bless your heart!” you should know that you’re likely being insulted. It sort of means, “You are so incompetent that you’re pitiful.” I’ve learned the equivalent from teachers now. It’s “That would make a nice *enhancement* activity” or “We might use that *after testing*.” In other words, “I’d never use this. It doesn’t solve any of my problems.”

Entry filed under: Uncategorized. Tags: mathematics education, precalculus, task-specific programming.

1.gasstationwithoutpumps | September 30, 2019 at 11:05 amMatrix operations are not the part of precalculus that I see students lacking (after they’ve had calculus). What I see missing are understanding of logarithms, trigonometry, and complex numbers. (Perhaps if my courses needed matrix operations, I’d see the lacks there also.)

I think that “programming-lite” tools might help with understanding complex numbers (particularly switching between Cartesian and polar views of the number). If combined with Euler’s formula, this could hep with trigonometry also.

I also think that it is very easy to get sucked into doing what computers do so well (computation), while missing the understanding and symbolic manipulation that is at the heart of the problem.

2.Mark Guzdial | September 30, 2019 at 11:16 amThanks, Kevin — that’s helpful. I completely agree that it’s too easy to get sucked into being computation-centric. That’s why we’re actively trying to keep it minimized (as I described in this blog post about our work in data visualization with history teachers). For the most part, the role of computation in both our history and precalculus prototypes is about managing scale in order to get to more meaningful outcomes. Anyone can plot a single point or a few points on a graph. Several hundred becomes data visualization, and it would be hard to do data visualization in history classes without computation. Similarly for these two prototypes, I’m trying to make matrix manipulations (which are easy to do by hand for 2×2 or 3×2 or other small n) more meaningful by scaling them to image transformations, and similarly scale a single wave function into a pattern of multiple. The trick is making sure that there is learning in precalculus and history.

3.gasstationwithoutpumps | September 30, 2019 at 11:51 amI think the biggest risk is having students see the matrix manipulation as a magic black box—you twiddle some knobs or type in some numbers and magically something changes. To get the desired result, you copy the magic numbers from someone else or randomly try things, with no understanding. I see that phenomenon in my electronics course far too often.

4.Task-specific programming for and about computing education (Precalculus TSP Part 5 of 5) | Computing Education Research Blog | October 4, 2019 at 7:00 am[…] and explored the implications of task-specific programming for research about programming, in education, and in relation to computing education research (this […]

5.Making the Case for Adaptive Parsons problems and Task-Specific Programming: Koli Calling 2019 Preview | Computing Education Research Blog | November 18, 2019 at 7:00 am[…] discuss my first prototype (see link here) and some of what math teachers are telling me (see link here). We also include a report on Bahare’s and my work with social studies educators A good bit of […]

6.What’s unique about CS education compared to other DBERs? | Computing Education Research Blog | December 23, 2019 at 7:00 am[…] to adopt. I’m working on task-specific programming with teachers informing the design (see post here), to create programming that they’ll actually adopt and integrate into their non-CS classes. […]

7.Computing Education Lessons Learned from the 2010’s: What I Got Wrong | Computing Education Research Blog | January 13, 2020 at 7:01 am[…] Constructionism in the Mindstorms sense only works for a small percentage of students, which is what Ames’ story tells us. Some students do want to understand the computer soup-to-nuts, and that’s great, and it’s worthwhile making that work for as many students as possible. But I believe that it still won’t be many students. Students care about lots of other things (from business to design, from history to geography) that don’t easily map to a focus on code and mathematics. I still believe in the value of having students program for learning lots of different things, but I’m no longer convinced that the “hard fun” of Logo is the most useful or productive path for using the power of computing for learning. I am less interested in making things for just a few precocious students, especially if teachers hate it. I believe in making things with teachers. […]