Just to recap a bit, for newcomers to this list, the choice I offer involves building "math objects" in a sort of hands-on shop class like setting. We see what makes things tick by constructing them, examining their guts.
Take, for example, the rational number type, consisting of two integers, p and q. These can be added, multiplied, subtracted and divided. Indeed, we have a Field, meaning closure, meaning none of these operations takes you outside the field of rationals. Plus you need some good basic numeracy concepts to work with 'em: GCD (greatest common divisor) to reduce to lowest terms and LCM (lowest common multiple) to add with common denominators. These have to be spelled out in code.
What's cool about some computer languages, e.g. Python, is you're allowed to define the methods that primitive symbols like + - / and * (multiply) invoke. So once you've defined these methods, you can write in such natural syntax as:
I'm using Rat for Rational, and instantiating two Rat "objects" by passing in the numerators and denominators as arguments. Because I've defined what + should do, I get the right answer, but only because my code computed the LCM for 3 and 4 (= 12) and did the proper algorithm.
Students had to build this rational number type. To do so, they had to start learning the terminology of object oriented programming as well, e.g. when I pass in those arguments, I invoke a "constructor" which initializes an object.
The object oriented stuff isn't irrelevant to mathematics. It's actually useful to look at math objects as part of an "extensible type system".
Just as rationals are built on having an integer type, so are real numbers historically built around the idea of having rationally-based algorithms that run indefinitely, converging ever closer to some value we symbolize with a greek letter like pi or e (or maybe we use a surd symbol).
The notion of limits, so important in calculus, starts early, with the study of sequences, and their convergent, divergent, oscillatory or chaotic behaviors.
Object oriented (OO) concepts also appear in simulations / modeling (e.g. 'Sim City' and 'Sims'). Indeed, this paradigm is central to business and industry. We need to give kids more exposure to these core ideas regardless of their applicability in math -- but (best of both worlds) it's not really and either/or choice as OO and math go together beautifully.
So, once we've built a rational number type, we'll want to do stuff like run a Fibonacci sequence and see how the corresponding rationals, expressed as decimals, approach the number phi (the most irrational rational), the ratio of a regular pentagon's diagonal to its edge (plus other geometric interpretations).
phi is easier to converge to than pi (algorithmically speaking) and has that "bridge from numbers to geometry" characteristic, and will therefore be quite important in this computer graphics intensive curriculum (we'll be seeing phi again when we get to the pentagonal dodecahedron and icosahedron for example).
Computers are good for these explorations (e.g. convergence studies) because you don't have to hand calculate the many terms you'll need to get the floating point to within 1e-8 or the target value or so. Calculators were good for this too, but weren't so adept in other ways.
Definitely it's high time to move beyond calculators, and beyond flatland. Plus if we use our rational number type to foray into continued fractions, we'll get some really neat results vis-a-vis the 2nd roots and phi.
The nuts and bolts of how to define a rational number type belong elsewhere, but rest assured this wouldn't be the very first thing a youngster would have to define.
In my current 8th grade class, we start with a Dog class, make it bark and eat. Then a Monkey class. Then I show how a Mammal class might incorporate some basic Mammal behaviors which the Dog and Monkey and Human types inherit, adding methods specific to their species.
There's not a lot of code, and my 8th graders enjoy the exercise.
Rational numbers come later, recycle a lot of the same concepts (plus operator overloading, which we just got to last week).
We don't stop with the rational number type of course. We build polynomials, vectors, polyhedra (using vectors). We also build integers that add and multiply modulo N, for our foray into group and number theory. This requires extending the whole numbers stuff a little more than is done today, getting into relative primality and Euler's totient concept. These are very easy ideas and reinforce some of the GCD stuff we've been doing all along (though not often enough with Euclid's Algorithm for some unknown reason).
Currently, the jump from wholes to rationals and decimals happens all too quickly, without enough reinforcement around primes versus composites and other fun topics. Kids don't learn anything about Fermat's Little Theorem, unless they're precocious and go out on the web, or read 'In Code' or whatever.
This is a gap in the pre-college curriculum that needs filling, which will be easy to do given our slant towards discrete math topics at the expense of so much Calculus Mountain stuff.