[Edu-sig] the "minimalist vs. maximalist" spectrum

[kirby urner]

So I've been cavorting in J-world some (Jsoftware.com).  That's
another math-through-programming REPL, in the tradition of APL and
ISETL.  Been blogging as usual, plus watching the EuroPython thing
gel.

A local gig in the private sector led to a big Chicago-based firm
thinking highly of Python (some buzzcrawler app my friend Patrick
wrote, after attending my classes).  I get the impression that word is
still spreading, the buzz about Python still getting going.

Like this head hunter I talked recently with was just starting to
learn about Python.  I pointed her to O'Reilly's famous "history of
programming languages" time line (not up to date, but still highly
informative).  Follow-up meeting on Tuesday.

Our Portland User Group (PUG) list has been fun lately, with basic /
core Python advice (Jason sure knows those itertools).

I'm still working with TECC, an Alaska based charter still on the
drawing board, and a possible outlet for Pythonic Math products,
forged here in Bridge City aka Portland.  LEP High, off the drawing
board (in the sense of fully operational) already had me in for a test
drive.  Heavy emphasis on peer-to-peer learning, like with Kusasa.

TECC's founder, Anna Roys, walked away with my copy of John Zelle's
book (my gift to her youngest).  Her family already invests in C++, or
was it C#.  Anyway, there's definitely a talent pool around Anchorage
taking shape on my radar (I haven't managed to jet up there yet though
-- way busy in PDX).  More on the math-teach list (Math Forum @
Drexel).

So we'll probably do cellular automata, fractals, the kind of eye
candy stuff we've talked a whole lot about here over the years
(surprise surprise).Kevin's PythonCard demos also fit here, plus lead
into code samples around how to leverage wxPython (see below).
Portland is heavily into nanotech.  Seems like CA studies and nanotech
also wind up co-mingling.

I find it useful to distinguish between Python packages written by pro
programmers like Kevin, and helpful to students in various walks of
life (e.g. Alice, no longer in Python), versus more Pippy-like stuff,
where the assumption is that users want direct access to some
calculator-like REPL, will do their own coding, maybe with some
scaffolding (e.g. a vector class, or something to write povray or x3d
files (why reinvent the wheel?)).

My company's output has focused mostly on the Pippy-like angle, moving
to other APIs only recently.  Others here are into providing deeper
packages, stuff students might use without trying to poke around in
the source code too much, which code is way above the beginner level.
Doesn't mean they can't do that eventually of course.  Go back to that
turtle, figure out what made it tick.

In between, are self-teaching products, i.e. learning tools that also
teach how to write rather elaborate programs (way above the "sequences
and series" of OEIS vintage that I focus on -- using Python generators
more often than not (many examples already given, I'll spare you the
repetition, plus "next syntax" has changed with 3.x, so a lot of my
stuff needs a rewrite)).

PyGeo falls into this category (a self-teaching product), in that
Arthur was looking to new recruit bona fide "code warriors", not just
students of projective geometry (the knowledge domain for this
package).

Environments like Leo suggest themselves at this juncture, as if
you're taking students deep into a source code forest, a lot will
depend on friendly documentation, a sense that you have a clear guide.

The fact of a Unicode basis also means these heavily documented code
piles take internationalization for granted (not true when I was first
cutting teeth as a coder of text based, then GUI apps).

Python is such a fertile mixing ground because it attracts the
minimalist REPL people, coming from Iverson's APL/J pipeline, (I'd
count myself in this group), *and* maximalist writers of "big code"
such as Zope.  We don't exactly compete, just come from different ends
on the spectrum, meeting in some happy middle ground.

A lot of us wear more than one hat on this small-to-large spectrum,
e.g. write unit tested embellishments by day, as part of a team, churn
out reams of disposable hobby code by night ("programming just for the
fun of it").

IDLE itself is a good symbol of this middle ground, in that it's what
gives minimalists their 5-10 liners, tiny modules of 2-3 classes (4D
Solutions:  permutations, game of life on a hexapent, fractals, NKS
stuff, polyhedra...), yet is itself a substantial package, based
around Tkinter, and requiring a team of maintainers, continuing what
Guido started.

Along one path you might move to MathCad say, or some other terse
notation (generators first, sigma notation to follow).  Along another,
you could drill down into IDLE or Pygeo or Plone or whatever, and
start seeing what deep, complicated Python programs look like under
the hood.  Keep digging to the system layer and below, if that's your
calling (all the way to the chip in some cases).

In sum, what I like about Python is that you can introduce it without
too much bias, to both "minimalists" and "maximalists".  Students at
the intro level get to share the same basic curriculum, and yet divide
up at the next level, now having more to go on to make an informed
choice -- exactly what one wants in a CS0 (or in some exotic hybrid
"gnu math" sequence such as we're sourcing from Portland).

Kirby
4Dsolutions.net