I've been thinking about education lately, much of it inspired by the book Mindstorms.

**Here's a hypothesis:**

We'd have better outcomes in math if programming were used to teach math.

After people learn to count, add, multiply, divide, and some basic geometry like the area squares and rectangles, they should be taught basic programming. After basic programming use programming to teach pre-algebra, algebra, and then everything that follows (also taught with programming).

It’s silly to teach something as abstract as algebra without teaching the reason why abstractions emerge from procedures. Programming is the perfect place to teach procedures and then why abstractions emerge from procedures. Once you have that you’re ready for algebra. Since you know programming you have a playground to learn algebra in as well.

### Procedures Are the Foundation

Procedures come first. Counting is a procedure. So are adding, multiplying, finding the perimeter of a rectangle, etc... It makes sense to teach the most basic procedures first. And more or less that's what happens today.

But then things go off the rails. Rather than teaching procedures as a first-class idea, we move to abstract formulas. Many don't make the jump from concrete procedures to abstract formulas.

What if, instead, procedures themselves became the focus. Understanding why a procedure works, debugging procedures, comparing procedures. One could argue this is too much meta-thinking. But is it? Procedures are more concrete than formulas. Debugging and constructing procedures might be more natural for children than it seems at first blush.

A simple programming environment is the best way to teach procedures. The code does not have to be abstract at all. Many of the concepts are relatable if the syntax is simple and understood. A `for`

loop maps perfectly to the idea of counting.

Once people are wanting to do more complex things with code abstraction emerges out of necessity. There's a reason to generalize and reuse. Powerful tools go into the toolbox.

Next, present math symbols and formulas as next level abstraction. Not things to memorize. Things that are useful.

Programming bridges the concrete world of procedures and the abstract mathematical world. Doesn't that seem clear? Why torture children with abstract symbols when they don't have metacognitive tools for procedures?

### Experimenting

I'm experimenting with this on myself. I'm trying to write math things I know and make procedural programming the bridge. Jupyter Notebooks seem like a possible medium for this. At least it's one I don't have to build.

Here's an experimental try at a notebook that explains Gauss's Formula with code and procedures. It's not aimed at children but for adults who know programming who might struggle with abstract math.