[Edu-sig] K-16 CS/math hybrid

[Kirby Urner]

> Part of my hysteria here - for those who have been long-timers to the
> list and therefore to my hysterias - has been in sensing some effort
> on the part of the Python community as positioning Python as the
> tool to take the rigor out of a programming curricula.

I don't sense this, especially given Alex Martelli's influence (I wonder how
he's liking the new job at Google BTW).  And Guido is a very clear thinker,
meaning the level of metacognition behind Python's design is quite high.
Tim Peters.  What's to worry?

Beyond providing a strong/usable language to the world, I don't hold the
Python community responsible (as a community).  If I write some dumb
watered-down stuff, unworthy of the great CS tradition, that's just me.

> And wanting no part of it.
> 
> IMO:
> 
> a) it doesn't
> b) it shouldn't

Plus we're not always interested in "programming curricula" (for the sake of
programming).  If the goal is to get physics majors to ramp up in some
VPython context, to where they can explore mechanics/kinetics interactively,
within a day or two, who cares if they're not using classes/objects to their
maximum advantage, and don't write the tightest imperative code.  That's not
the point.  The point is to learn physics.  Python is good for that too.  

It's unfair to criticize quick and dirty code that pretends to be nothing
more.  There's room in this world for one-off scripts that get the job done.
We all write "code to throw away" or should.  Making everything you write
read like some CS text book example is a waste of precious time.

What I'm wondering is how many CS curricula emphasize team approaches, e.g.
teach extreme programming techniques, other ways to manage largish, scalable
projects.  This should come earlier rather than later, so some appreciation
for the conventions of teamwork start tickling in (e.g. why should I waste
time documenting, writing a lot of test? -- because *you* aren't the only
reader of this code, duh).

I think Python has the potential to give us *better* CS curricula than we've
had before, and these better curricula will do more to counter solipsistic
programming habits.

> But certainly it *can* redirect a rigorous approach into more
> productive channels than other alternatives:
> 
> IMO:
> 
> a) it can
> b) it should
> 
> Art

I big step towards "rigor" from just plain programming is knowing how to (a)
read and understand O-notation (that's the first step) and then (b) figure
out the efficiency of an algorithm and express it using O-notation.  CS
majors tend to know how to do that, while non-CS majors maybe don't, or are
only up to step (a).

At Knuth's web site, he wonders if O-notation should be phased in to regular
calculus more successfully.  Probably.  You can use it to express the margin
of uncertainty, e.g. the fuzz factor, after writing out some value as an
infinite sequence.

Kirby