Python in the Mathematics Curriculum
a talk prepared by
Kirby Urner
for
Pycon '04
March 2426, 2004
Preamble
I thought it would be useful, at least in the written version of this
talk, to attempt more overview and context. I've already posted a lot
of example code and
curriculum, in conjunction with others, to the web. Rather than include
too much of that here, I'd like to take this opportunity to provide a
snap shot of my current thinking, something to look back on later, partly
to gauge how accurately I was reading the signs  or how misled. Those
mostly interested in reading source code should follow the links or run
some searches.
Setting the Stage Computer science used to be an exclusively universitybased discipline,
as universities were the only institutions, outside the government and
big business, who could afford big iron. Then came the PC revolution, spearheaded
by Apple and IBM, the latter in partnership with Microsoft. A generation
of IT workers trained up on this equipment, while a separate and still
university based cadre continued in the Unix tradition. These last two
trajectories converged thanks largely to the GNU and Linux projects, which
brought a Unixlike operating system to the desktop. Apple has followed
suit, basing OS X on FreeBSD.
The precollege curriculum was somewhat indirectly impacted by the universitiesonly
phase of the computer revolution in the 1960s, with the advent of the
new mathematics in the United States. This included a hefty helping of
boolean algebra, socalled truth tables, which have remained in most curricula
to this day. "Computer programmer" entered the lexicon of school kids,
as a new career possibility. Computers invaded science fiction and popularizations.
The dream of a chess playing computer, first triggered by The
Turk in Napoleon's day, was finally being realized.
With the PC revolution, Apple 2es and IBM PCs (and clones thereof) began
infiltrating the classroom. MIT's
Media Lab was a galvanizing influence, in the form of Logo
spurred Seymour Papert's evangelism.
BASIC was embedded in the ROM chip of the earliest PCs, with floppybased
versions to follow. But probably more than programming, education software
began to exert its influence in the schools, based on the computer game
model. Some were little more than electronic page turners. Others, such
as Rocky's Boots,
encouraged more openended discovery and play. In either case, the model
was two or three computers in the classroom, and a library of software
titles designed to guide students with a minimum of teacher supervision.
The computer was a workstation on the sidelines, a way to keep a few kids
occupied, while others did something else. This pattern remains popular
to this day.
The PC revolution made it possible to set up computer labs, somewhat
on the model of the typing classes of the preceding two or three generations,
still included). Business applications, especially spreadsheets and wordprocessors,
were given the most attention. Topics such as programming, computer architecture,
database design, and system administration, were largely untouched.
The advent of the open source revolution and its migration to the most
affordable computers, including ones too underpowered to run the latest
Windows, is driving the curriculum in new directions which we're still
working out.
Either as a product of this revolution, or as a simultaneous development,
a more mature and fullblown computer science curriculum is migrating
from the college level into K12. A new track is being set up, leading
towards in AP computer science test in many, but not all, cases. The emphasis
is now shifting more towards actual programming, versus education software
and business applications. In this regard, the Logo and BASIC threads
of the late 1970s and early 1980s are being continued. Adding to this
mix is web development, with initial emphasis on HTML and JavaScript,
but likely with more CGI and web application development to follow. Of course this historic progression of computing from larger to smaller
does not mean that the impact of the larger, more expensive systems has
gone away even as the smaller ones have become more affordable. Kids now
grow up knowing that cartoons and special effects, both central to media
culture, have everything to do with computers, in part thanks to the "making
of" featurettes added to most DVDs. TV and film are also edited using
software. So kids are getting the message that many creative fields, from
architecture to zoology, involve digital media, and that usually means
computers in some way or another, and often computers that are still too
expensive for the average home user. All this helps drive both student
and parent demand for more relevant exposure to the technology  and
not just calculators.
The Impact of Open Source From the standpoint of a computer science curriculum, learning on an
open source platform simply makes sense from a pedagogical point of view,
economic considerations aside. Students are allowed to poke around inside
the guts of a sophisticated operating system, to get a sense of how it
works. The details are only thinly concealed, and yield to concerted digging,
especially if supplemented with expert guidance.
The cultural message embedded in the open source process is clear: we
see you as equals, we trust you to understand us and join us, even if
we've never met you. On a closed source platform, the message is more:
you are just the end user, we make life easy for you, and we hide the
inner workings, which aren't your business. Except in computer science,
what's happening behind the scenes is our business.
But it's not only the operating system which is open source, and the
kernel is not where the majority of wouldbe programmers would even want
to start. Of greater interest are the applications, the MP3
players and arcade games, or the web application servers. And so many
come to Python by way of Zope, Pygame etc. The exploration of preexisting code in user space is what brings many
students into first contact with the socalled scripting languages. They
find out about Perl, Python and PHP when wrapping their heads around some
LAMP installation (Linux Apache MySQL and any of the above). But this
pattern is still quite atypical in high school, especially with respect
to the formal curriculum. Open source is only beginning to make inroads,
and clientserver setups such as LAMP do not yet appear on the average
high schooler's radar. However, this status quo is unlikely to persist.
Additionally, I think a key cultural phenomenon is the evolving perception
of geek culture as a whole. What many students discover is a global network
of loosely organized, yet talented individuals, including many free spirits.
The network is cosmopolitan and guided by some newly articulated principles
regarding how some forms of intellectual assets should remain freely accessible
and reusable. While these values might seem another ideological pipe dream,
were they expressed in merely political terms, in this case the lingua
franca of the movement is source code, and licensing agreements designed
to protect it against leaking off into the proprietary sector. Even though
Python may be used in proprietary ways, Python itself remains free. Despite SCO's attempts to paint this as an "us versus them" conflict
between the original pioneers of Unix, and an unauthorized band of software
pirates who merely exploit what has come before, people in the know realize
that "they are us" i.e. the core developers consciously adopted an open
source route, because it makes the most sense from an engineering standpoint.
Every developer needs an operating system  so why not develop one together
and keep it open?
The Linux and FreeBSD developers are continuing a venerable tradition,
not hijacking it. Techies rule, while those mainly looking for a quick
buck are finding themselves marginalized. Those with a longer term strategy
have hopped aboard the open source bandwagon, even if, as is the case
with IBM, proprietary software remains a core source of revenue. Given
how many chip sets are covered by Linux, maintenance on top of a common
OS leads to great savings, fewer headaches, and an improved customer experience.
This arising of a global culture, typified by ethical values, connects
to the hopes of the third world to develop high tech economies around
indigenous talent, without suffering so much of a brain drain and colonization
by outsider corporations. Governments are eyeing open source partly out
of an inate sense of nationalism, which in more economic terms means keeping
relevant knowhow local and indigenous. How exactly the new policies pan
out remains to be seen, but the fact remains that geekdom has become a
place to channel one's nationalism, altruism and idealism, somewhat outside
the scope of traditional politics.
From the standpoint of a Buckminster Fuller enthusiast such as myself,
the open source movement has many of the hallmarks of what he projected
as a "design science revolution," which would be global and focused on
actual artifacts over political rhetoric.
Meanwhile, Back in the Classroom
So how are all of these social trends and pressures likely to play out
in the school, in some ways a microcosm of society? To some extent, we
see a rise in geekdom,
a shedding of some of the negative stereotypes and memes. The glamour
of high tech has not worn off, despite the dotcom crash. New, useful
gadgets keep coming to market (many of them first appearing in Japan)
and technology skills remain relevant in the market. The pressure to continually
update one's skills has not slackened.
Increasingly, there's also the sense that knowing about computers is
an essential aspect of knowing "how things work" in general, just as having
some knowledge of the internal combustion engine was (and still is) a
standard aspect of general literacy.
On the curriculum front, new synapses are being formed as we speak. The
AP computer science test is driving schools to scrounge up new faculties,
likely not math teachers, as math teachers are still in short supply and
need to stick to their traditional role. Shop teachers, who might have done
things around machine tools and electronics before, are moving to computers
by way of robotics. Even some music and art teachers are being pressed into
learning Java, as their job descriptions radically change in accordance with tight budgets. The more recent graduates,
usually younger teachers, are coming to teaching with more of the formal
training and background already in place. More teachers actually majoring
in computer science will soon be lining up to teach it at the high school
level.
Meanwhile, computer science text books aimed at high schoolers are hitting
the market, in many cases derived from collegefocused counterparts. Many
of these focus on Java because this language has recently displaced C++
as the language
of the AP test. But not all schools are focused on the AP test (it
is still not recognized by state schools in some states  Oregon for
example), and even many that are building towards Java do not start with
it, but keep some earlier language in the picture, such as Visual Basic
or Pascal. At this time, few are using Python, and many high school faculty
members haven't yet heard about it. The idea of starting with Python and
transitioning to Java through Jython
is not even on the radar screen of most high school faculties at this
point.
Python's relative obscurity has partly to do with the fact that open source
culture is still at the beginning stages of making inroads, in the form
of computer labs with diskless workstations and such. Based on my own
informal polls and research, teachers already using open source are much
more likely to already know about Python, even though Python is quite
happy running on Windows (it's not part of the Windows "distro," except
from a few vendors such as HP, who don't advertise its presence to end
users  which fact leads to a lot of emails to the webmaster@python.org,
and hence the FAQ).
In the short term, I see this rewriting of college level text books for the high
school context as the core response of publishers. Having worked in a publishing
company in the 1980s, I know that the most profitable way to go is to recycle what's
already in inventory, changing it in various ways, but not rewriting from scratch.
In the longer term, what I wonder about is the unavoidable duplication this
approach entails, between what's going on in introductory computer science,
and what's being taught within the traditional mathematics curriculum.
And to a somewhat lesser extent, I wonder about the impact of computer
science on how we teach the humanities, such as grammar and writing.
A poet friend of mine, Gene Fowler, is adamant that XML should be viewed
as an extension of our system of punctuation, and become the purview of
all literati. He takes this design goal that XML be "human readable" very
literally in other words, and I can well imagine a kind of poetry which
combined words with markup. We shall see. Plus I think the Document Object
Model (DOM) might relevantly be studied in language class, right along
with outlines, tables of contents, indexes and other literary infrastructure.
Should regular expressions be taught in language class as well?
My more limited focus here is more on dovetailing computer science with
traditional mathematics at the high school level. I see it as inevitable
that computer science will be making deeper inroads, based on the trends
and pressures narrated above. And I also think this cannot help but impact
our approach to mathematics teaching, which is currently making do with
calculators (albeit of increasing sophistication), and focusing on the
AP calculus test, and not the AP computer science test, as its guiding
objective.
Transforming K12 Mathematics into a Math/CompSci Hybrid
Hybridization would be one way to go, and I think something along these
lines is likely to evolve. Computer science is going to drive high school mathematics
to reform. This will be a new pressure, somewhat different from the NCTM's
vague lip service in favor of "technology in the classroom," a phrase
referring to calculators, or applications such as Geometer's
Sketchpad  but not real programming. The math teaching community, here in the USA and to some extent in the
UK, is already in the throws of "math wars" pitting more traditional pedagogues
against those experimenting with new content and techniques (was it ever
any different?). What's noticably absent from the math wars debates is
any serious attempt to grapple with the advance of computer science into
the K12 curriculum.
Math teachers I encounter via internet discussion lists and newsgroups
are still mostly debating about calculators, their use and abuse. Computers
tend to be viewed in the way that many mathematicians view them, as platforms
for Mathematica or MathCad. As high end calculators become more able to
evaluate integrals or differentiate in symbolic terms, the distinction
between calculators and computers begins to fade  and the content
of computer science is again not discussed. So let's look at computer science. What does it entail. Some computer language
is chosen, for illustrative purposes, be that MMX pseudocode or something
higher level, like Pascal or, these days, Java (or, I would of course
suggest, Python).
Some of the topics typically investigated would then include: data
structures (array, tree, queue, stack), sets,
functions
and relations, combinatorics, algorithms, recursion, sequences and
series, sets, unary and binary operations, closure, graphs (as in networks),
plotting, bytes and words, classes and objects, tuples and relations (in
the database sense), hardware architecture, protocols, bases 2, 8 and
16. The above paragraph is a "bag" i.e. an unordered list or hodgepodge,
a pseudorandom sprinkling of nodes on the curriculum neocortex (the
topic of pseudorandom numbers should be added to the bag). It's easy
to come up with such lists by looking at such titles as Concrete
Mathematics (Graham, Knuth, Patashnik), The
Art of Computer Programming (Knuth), or any other computer science
text book (Mathematical
Structures for Computer Science by Gersting is another good example)
 not that any of these are directed specifically towards high schoolers.
But just throwing out these topics is sufficient to make my point, which
is that computer science does not intersect with the math curriculum
simply in terms of shared hardware, but rather the intersection is at the level of
core content. To put it differently: computer science is already
exemplary of a kind of mathematics curriculum in which computers are incorporated.
So in this sense we're not waiting to find out how mathematics will absorb
computers  we're already seeing how this is done, in the form of computer
science.
And so I see the encroachment of computer science into the high schools
as at least initially somewhat competetive with the traditional curriculum.
For the first time in a very long time, the precollege mathematics curriculum
is getting a makeover from a neighboring discipline. The ecology is being
disrupted. For example, there's potential here for computer science to be
cast as an underdog, recruiting students (and teachers) who are dissatisfied
with a mathematics track that seems to lack immediate relevance. Whereas
the calculus will remain important, it's somewhat debatable whether a
high degree of proficiency in integration by parts by the end of high
school, is any more worthy a goal than mastery of regular expressions
(both technical skills), especially if a conceptual grasp of the calculus
is an element in both scenarios. Mathematics is a huge body of literature, and technical proficiency is
possible only with regard to a smattering of topics by the end of high
school. What should these proficiencies be? Of course one might aim for
high marks on both the AP calculus and AP computer science tests.
However, my view is that we will be forming a kind of Y (a fork), with
arithmetic as the common stem, a technology focused math branching up
one prong of the Y, and a more traditional and somewhat more technophobic
prong heading off towards AP calculus. So where's the hybridization in this picture? I think the technology
focused math will have to shoulder more of the burden of teaching mathematics
itself, as a larger pool of students (including many talented and gifted),
choose this path over the more traditional one. Given high school
doesn't presume foreknowledge of the basic mathematics (as a college course
might), but provides initial exposure, the hybrid track will need to simultaneously
impart the basics, and apply it in a computer science context.
Which brings me to Python. I think this language, above just about all others at
the time of this writing, is accessible enough to not get in the way, not consume
too many brain cycles, even as we're trying to get through quite a lot of
material. It will become the student's friend, less his frustrating foe, helping
her or him to gain insights into the material, versus obfuscating it with a lot
of clutter and extraneous syntax.
Math Through Programming
Let me wipe the slate clean for the moment and take the wild liberty of sketching in
some of the elements I would think would make for a viable and vital mathcompsci
hybrid, suitable for high schoolers.
First, I think it's obvious that geometry segues into computer graphics.
The analytic geometry we already teach will be transposed to the screen,
as happened to some extent with Logo. As I believe Arthur Siegel will
demonstrate in the next presentation, this transposition does not necessarily
mean losing touch with Euclidean roots, in the sense of deriving theorems
from axioms. Euclid's
Elements has traditionally entered the curriculum as the prime
example of a mathematical system, and that's certainly still one of its
useful roles.
However, as a student of R. Buckminster Fuller, I have to say that I've
been impressed with the early accessibility and relevance of spatial geometry
if taught in conjunction with alternative concepts, by which I mean his
concentric hierarchy
of polyhedra and closest sphere
packing arrangements.
For those who find Fuller's writings too obscure, I point then to The
Book of Numbers by Conway and Guy, both wellestablished mathematicians.
In this book, as in Fuller's magnum opus, Synergetics,
polyhedra are built up by packing spherical elements together, with counts
taken at each step. This is akin to the figurate
numbers in the plane, most obviously the triangular and square numbers,
but here moving into volume to examine octahedral, icosahedral and cuboctahedral
numbers.
What I like about this approach is the connection between ruledriven
(program driven) number sequences, such as 1, 3, 6, 10.., or 1,
13, 55, 147 and the corresponding, visually appealing shapes. This
forges connections between algebra and visualizations, but in a way more
basic than by means of Cartesian coordinates (or any coordinates). Moreover
such sequences provide an ideal beginning for learning to program. For
example, take the triangular numbers in Python:
def tri(n): return n*(n+1)/2 # return the nth triangular number
It would be harder to think of a much simpler program, and yet this sequence
is already packed with relevance. It represents the number of ways a n+1
things might interconnect, i.e. to n other objects, dividing by two because
we want to count AtoB and BtoA as the same edge.
When dealing the spatial shapes, we have the surface counts versus the
cumulative volumetric counts, and will be able to find second and third
powering relationships in the respective sequences. Understanding that
radial, areal and volumetric growth correspond to 1st, 2nd and 3rd power
sequences is a key curriculum goal (according to the current California
standard, to be achieved by the 8th grade).
def cubocta(n):
"Shell counts  a growing cuboctahedron"
if n==1: return 1
else: return 10 * n**2  20*n + 12
>>> [cubocta(i) for i in range(1,10)] [1, 12, 42, 92, 162, 252, 362, 492, 642]
def cumcubocta(n):
"Cumulative count (all shells + nucleus),
of a cuboctahedral packing"
return int((10/3)*n**3  5*n**2 + (11/3)*n  1)
And on this topic of volume, Fuller stands out for providing an elegant
streamlining of relationships between polyhedra, which he develops by
connecting centers of tightly packed spheres in a CCP matrix. His tetrahedron,
cube, octahedron, rhombic dodecahedron, cuboctahedron progression comes
down to volume numbers of 1,3,4,6 and 20 respectively.
Computer graphics makes this easy to visualize, and the simple integers
make it easy to memorize. In going with spatial figures, we're using computers
for what they're good at  high quality spatial renderings, as seen in
the movies.
On this topic of sequences, I do not consider it necessary to leave the
idea of "generators" for an advanced lesson. Python makes generators easy
to think about, with the yield behaving like a print statement
 providing a result without actually returning, and therefore remaining
ready for a next cycle. The fact that Python is bringing generators into
the foreground with a variant of list comprehension syntax further argues
on the side of making "lazy evaluation" or "just in time evaluation" part
of the everyday conceptual apparatus of your average Python user.
def pascal():
"Generate rows of Pascals Triangle"
row = [1]
while True:
yield row
row = [i+j for (i,j) in zip(row + [0], [0] + row)]
>>> for i in range(10): print k.next()
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
And on this topic of functions, Python makes it very easy to consider
their composition, as functions may be passed to other functions as arguments.
Furthermore, functions may be returned as results. With operator overloading,
we might make the multiplication symbol do the work of composing
two functions to return a function. This is a powerful mathematical
idea, which segues directly into permutations in a group
theory context (which in turn links to cryptography).
The traditional K12 mathematics curriculum is, I would argue, less able
to drive the abstractions because it doesn't have anything so concrete
to stand on as the interactive Python shell and operator overloading constructs.
The concept of addressing should be approached with coordinate systems
as particular examples of addressing schemes. In addition, we have labeling,
a way of associating points with letters. Python makes it easy to associate
letters with tuples, using dictionary syntax. Triangle ABC may be represented
as a dictionary of three letter keys associated with 3 xy pairs, or points.
Or we might number the points if we don't want to use letters (many geometric
file formats take this approach). Or we might name our points New York,
Calcutta and Tokyo  because we have many ways of addressing spatial
locations, including geographic names, which key to latitude and longitude
coordinates (another addressing scheme, perhaps read off some handheld
GPS device).
A general idea here is to relate graph theory, networks, to geography.
In looking at polyhedra as wireframes, we're setting up an easy transition
to the vocabulary of edges and nodes as applied to global infrastructure,
such as the internet itself, or transportation systems in general. How
do we uniquely identify all the airports in this world? A system of 3letter
codes. Again, the theme here is addressing  which will later join
us to the topic of computer memory and the addressing thereof. Addressing
schemes (e.g. URLs) and coordinate systems  these two topics belong
in close proximity.
In a second pass through coordinate geometry, we'll swap out tuples and
substutite vectors, which internalize the tuples as data, but also supply
a host of vector methods, such as addition, subtraction, scaling, dot
product and cross product. From vectors we'll move to matrices, rotation
matrices in particular, again using Python, but writing to some API for
the resulting graphics (such as VPython,
VRML
or POVRay).
However, before we get to vectors, with operator overloading, we need previous
experience building other more familiar math objects. And so I move from my
geometry track back to the algebra track, where we were learning the basics by
programming simple sequences.
A next type we might build is the rational number type. For this, we
will need to review the concepts of gcd and lcm. One hallmark of a computer
science curriculum, versus the traditional math curriculum, is inclusion
of the Euclidean Algorithm for the gcd. Python expresses Euclid's Algorithm
every simply:
def gcd(a,b):
while b:
a,b = b, a % b
return a
And the lcm:
def lcm(a,b): return (a*b)/gcd(a,b)
But now I would swerve from the traditional curriculum and more in the
direction of abstract algebra, with its focus on groups, rings and fields.
This is considered college level stuff, but the Algebra II text books
try to hint at it, I think usually ineffectively. With Python's operator
overloading, these topics are just too good to pass up, by means of integers
modulo N. Another hallmark of a computer science math, versus a more traditional
one, is the importance of modulo arithmetic early on (in part because
registers tend to wrap around to 0, if you keep adding 1 to them).
In addition to integers modulo N, Python may be easily used to introduce the
concept of permutations and their multiplication in finite groups. The expression
of a permutation in cyclic notation becomes a useful programming exercise.
This topics will again connect us to the gcd and the concepts of totative,
totient and relative primality. This delving into group and number
theory, in the context of learning to program, will provide students
in this curriculum with a deeper theoretical understanding of algebraic
systems than their counterparts currently pursuing the traditional sequence.
High school computer science, as envisioned here, does not leave students
poorly prepared to go further in mathematics.
def totatives(n):
return [i for i in range(1,n) if gcd(i,n)==1]
def totient(n): return len(totatives(n))
>>> [totient(i) for i in (45,64,75,100)]
[24, 32, 40, 40]
Another object we'll want to build is the Polynomial. Having covered groups,
rings and fields to some extent, we'll be ready for the idea that polynomials
form a ring, meaning they form a group under addition, but not under multiplication.
Multiplication of singlevariable polynomials by algorithm has the advantage
of getting us away from FOIL to a more comprehensive approach:
class Poly (object):
def __init__ (self,coeffs):
self.coeffs = coeffs
def __call__ (self,x):
return sum([b*x**i for i,b in enumerate(self.coeffs)])
def __repr__ (self):
r = ' + '.join(["(%s * x**%s)" % (b,i)
for i,b in enumerate(self.coeffs) if b<>0])
return r.replace(' * x**0','')
def __mul__ (self, other):
outerp = [(e1+e2, c1*c2) for e1,c1 in enumerate(self.coeffs)
for e2,c2 in enumerate(other.coeffs)]
sums = {} # add like terms in dictionary
for t in outerp:
sums[t[0]] = sums.get(t[0],0) + t[1]
return Poly([sums[i] for i in range(len(sums))])
>>> p = Poly([1,2,3,4,0,5])
>>> p
(1) + (2 * x**1) + (3 * x**2) + (4 * x**3) + (5 * x**5)
>>> q = Poly([0,3,0,0,1])
>>> q
(3 * x**1) + (1 * x**4)
>>> p*q
(3 * x**1) + (6 * x**2) + (9 * x**3) + (13 * x**4) +
(2 * x**5) + (18 * x**6) + (4 * x**7) + (5 * x**9)
From polynomials, we might move on to Vectors. By this time, if not
before, it will be seeming natural to think of "math objects" as extending
a kind of type system. The newer, often more complicated types, incorporate
the older ones. For example, the "vector field" recycles the reals (or
floats), by incorporating them into a new kind of object. If Clifford
Algebra eventually catches on at the high school level, as some anticipate,
then the vector type will be subsumed within another yet more elaborate
kind of object, the multivector. Or, we might simply make do with quaternions.
Calculus will also get some treatment in Python. We can add symbolic differentiation
to our Polynomial object without much effort. The generic concepts of derivative
and integral may be communicated using the fact that Python functions are toplevel
objects, passable as arguments to other functions. What many high school calculus
students have trouble getting, because in point of fact the notation isn't always
clear about this, is that the derivative operator works on functions to return
functions. Python will help make this clear.
A theme running
through all this is the emergence of "dot notation" in the context of
mathematics.
Summary of Main Points Probably the more controversial aspect of my thesis here is that computer
science is likely to compete with traditional mathematics at the high
school level. The more common view is that mathematics will chug along
as is, making do with chalk boards and calculators, and computer science
will have a relatively marginal existence on the side, more of a vocational
track, like shop.
However, I think the more common analysis overlooks the content of a
bona fide computer science curriculum, what's needed to make sense of
the higher level languages now appearing on the AP computer science test
 first C++ and, most recently, Java. I also think the more common view
does not accurately weigh student demand, including dissatisfaction with
the mathematics of postponed gratification, a sense that "relevance" is
deferred year after year. Computer skills, on the other hand, offer more
immediate payoff, if only in the form of some JavaScript on a personal
web page. The emphasis, and notation (if we consider a computer
language as notation, albeit an interactive one) is different enough
along this new track, that it cannot be easily blended in to the traditional
mathematics track as another thread, much as some early math texts attempted
to do with BASIC or Logo. The field has grown too much in the mean time,
commensurate with its accessibility, affordability and relevance to youth.
And so rather than solving the problem with new threads within the traditional
math curriculum, I see that we're headed for a fork. The computer science
track will branch off from the precalc/calc track, and carry enough math
threads along with it to compete as an alternative math track, but with
more technology in the picture, and a different sequence and mix of topics.
It's in this sense that I speak of hybridization: the new track will incorporate
quite a bit of basic math content, because especially at the high school
level, it needs to be introduced, not presumed.
This competing technological track, increasingly centered around open source
tools, will take many important math concepts further and deeper than
has been traditionally accomplished pre college. In other words, it need
not be typecast as a pale imitation of a math curriculum with only shallow
samplings. We could think of it as "math from Mars," to register its somewhat
alien, and I think surprising invasion of what, hitherto, has been a semiprotected
sanctuary.
It is in this context (among many) that I think Python is well positioned
to move forward, as both the general purpose programming language it already
is, and as an expressive notation well suited to capturing the imaginations
of young people, ready to embark on new adventures.
