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 university-based 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 Unix-like operating system to the desktop. Apple has followed suit, basing OS X on FreeBSD.

The pre-college curriculum was somewhat indirectly impacted by the universities-only 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, so-called 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 floppy-based 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 open-ended 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 full-blown computer science curriculum is migrating from the college level into K-12. 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 would-be 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 pre-existing code in user space is what brings many students into first contact with the so-called 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 client-server 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 know-how 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 dot-com 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 college-focused 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 K-12 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 K-12 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 pseudo-code 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 hodge-podge, a pseudo-random sprinkling of nodes on the curriculum neo-cortex (the topic of pseudo-random 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 pre-college 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 math-compsci 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 well-established 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 rule-driven (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 A-to-B and B-to-A 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 K-12 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 hand-held 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 3-letter 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 POV-Ray).

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 single-variable 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 multi-vector. 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 top-level 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 semi-protected 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.