A retreat with STEM teachers

[kirby urner]

I've just been hanging out with a bunch of STEM teachers for a week.
This group traces rather directly to the University of Illinois, which
has a long history of pioneering new uses for computers, including in
the design and testing of "educational experiences".

The lead teacher in this school believes in "Making Math", i.e. uses
that as a front end. His group has served as a skunkworks for
developing a courseware delivery infrastructure focused around
Wolfram's Mathematica. Having a purely JavaScript front end with
Mathematica running in the back office, is now being developed more
commercially, given this successful initiative.

The company used to be called NetMath but was purchased and rebranded
by a new parent company based in Sebastopol (northern California).
I'm near there right now.

My role with this company is to teach the Python computer language.
The curriculum was written by one of our seniors, the outgoing
chairman of the Python Software Foundation, who happens also to be my
neighbor in Portland. Authors have their own special status and role
in our company, whereas Instructors, such as myself, have the front
lines responsibility for mentoring students through the skills
building.

In addition to teaching Steve's courseware (not using Mathematica on
this track), I do some curriculum writing for the live classroom gigs
I sometimes get involved with. My focus there has been andragogy of
late, though I also work with teenagers and sometimes younger. I have
background as a full time high school teacher, but that was when I was
in my 20s. Now I'm in my 50s.

In Python, we have what's called operator overloading, meaning a
student is able to take charge of what wheels to turn, what operations
to undertake, in response to such syntax as A + B or A / B. For
example, I might want A and B to serve as "math objects" that
"contain" string values where a "string" is a sequence of alphanumeric
characters encoded as bytes. When I write A + B, I mean for those
strings to splice together.

"Math objects" develop somewhat microbiological properties in the STEM
context, e.g. we want students to "poke and prod" with the sense that
these objects were designed precisely for this purpose. Then the
challenge is to look at the world and think in terms of what
attributes and behaviors things have, much as a naturalist would do.
Here where I'm staying, are many species of bird, with whales and sea
lions in the ocean. The birds have special meaning here thanks to a
particular movie that was set in these parts (wherein Sebastopol is
mentioned).

I found a geocaching site while out walking (with Steve the author,
also at this meeting). Sports like geocaching are another aspect of
the "off your duff math" I'm working on, now that we're naturalists.
You may have seen those Google Street View cars driving around, with
surveillance cameras poking up. People can wear gear like that on
their backs. Some of our best equipped facilities are / will be
reachable only if you hike and/or bike to them.

Active problem solving is another part of it, meaning STEM work
becomes community service (monitoring the environment and building up
data about it is a core responsibility of both students and faculty).

When you need to build your own Rational Number object, with separable
numerator and denominator, saved in lowest terms, you find yourself
working with 'greatest common denominator' a lot and that means
Euclid's Method, so commonly bleeped over in the legacy curricula.
When lecturing parents, I give them a sense of what to look for, if
wanting to see signs of what I look for in the future: look for
Euclid's Method, look for Polyhedrons, look for operator overloading.

Look for environmental monitoring and community service projects,
similar to home economics but less focused on role playing in a
nuclear family model. When you learn to cook, the recipe may be for
20 - 30, not 3 - 5.

OK, enough rambling. I was posting earlier about wanting to expand in
rural Oregon, around Fossil, where one of our Linus Pauling group has
property.** That's a separate ball of wax from this Sebastopol
enterprise, which does not operate a physical campus. All my student
interaction is on-line, when it comes to teaching Python.

My classroom gigs have been for Saturday Academy, Pycons, and for
meetings around town, for when my peers get together (we base
ourselves at Washington High School, symbolically at least -- that's
where Linus Pauling went as a kid, and he's one of our chief icons,
the STEM teacher par excellence (lots of polyhedrons in his
research)).

Kirby

** http://groups.google.com/group/mathfuture/msg/ef21df758d1cc25b

[David Chandler]

Hi Kirby,
I have been trying to achieve fluency at Python (main problem being I don't use it consistently week after week), but the part that hasn't come easily is working with OO, which also hinders my working with GUIs.  Do you have a smooth path into this topic?
--David Chandler

--
You received this message because you are subscribed to the Google Groups "MathFuture" group.
To post to this group, send email to mathf...@googlegroups.com.
To unsubscribe from this group, send email to mathfuture+...@googlegroups.com.
For more options, visit this group at http://groups.google.com/group/mathfuture?hl=en.

[kirby urner]

On Sat, May 12, 2012 at 5:11 PM, David Chandler <david...@gmail.com> wrote:
> Hi Kirby,
> I have been trying to achieve fluency at Python (main problem being I don't
> use it consistently week after week), but the part that hasn't come easily
> is working with OO, which also hinders my working with GUIs.  Do you have a
> smooth path into this topic?
> --David Chandler
>

I always think OO should just be a matter of looking around and seeing
objects, so like learning noun, verb, adjective, a familiar grammar
you already know.

The path is bumpy because it doesn't take a fresh enough view maybe.

Polyhedrons (polyhedra) as paradigm objects has shown lots of promise,
along with making "dot notation" more formally accepted as more math.

Kirby

[mok...@earthtreasury.org]

On Sat, May 12, 2012 8:11 pm, David Chandler wrote:
> Hi Kirby,
> I have been trying to achieve fluency at Python (main problem being I
> don't
> use it consistently week after week), but the part that hasn't come easily
> is working with OO, which also hinders my working with GUIs. Do you have
> a smooth path into this topic?

A Google search for

python object oriented programming

turned up a multitude of tutorials and book chapters, such as

http://www.voidspace.org.uk/python/articles/OOP.shtml

I am sure that you can find something that suits you. Is it the syntax or
the inheritance mechanism, or some other aspect, that is giving you
trouble?

> --David Chandler

--
Edward Mokurai
(&#40664;&#38647;/&#2344;&#2367;&#2358;&#2348;&#2381;&#2342;&#2327;&#2352;&#2381;&#2332;/&#1606;&#1588;&#1576;&#1583;&#1711;&#1585;&#1580;)
Cherlin
Silent Thunder is my name, and Children are my nation.
The Cosmos is my dwelling place, the Truth my destination.
http://wiki.sugarlabs.org/go/Replacing_Textbooks

[kirby urner]

The stuff I've been doing with Python, some of it, is here:

http://4dsolutions.net/ocn/cp4e.html

Hypertoons are especially interesting: key frames connected by smooth
transformations in a network.

Example:

http://www.youtube.com/watch?v=tp_ZycVtOKM

One look at a course:

http://4dsolutions.net/ocn/pymath.html

Then I've blogged with the field testing has been like:

http://worldgame.blogspot.com/2010/07/finish-line.html

http://controlroom.blogspot.com/2008/05/sa-classnotes-2008517.html

Martian Math was my most recent / ambitious live gig for teens:

http://4dsolutions.net/satacad/martianmath/index.html

Kirby

[David Chandler]

I find the syntax for OOP in Python not very intuitive.  When I sit down and reason carefully I see that a class has a self reference because it is going to be used to create perhaps multiple objects that are distinct from each other.

My other questions were perhaps more to do with event-driven programming.  There seems to be some kind of initial setup then a collection of classes that respond to events with no overall program flow that I'm used to.  When I sit down and work through it with a model program in front of me I can make sense of it, but it's hard to come up with code like this on my own, at this stage of my progress.

I was just wondering if any of you had a way of thinking about this kind of coding that makes it all seem more intuitive to you.

--David Chandler

On Tue, May 15, 2012 at 6:10 PM, <mok...@earthtreasury.org> wrote:

[kirby urner]

On Wed, May 16, 2012 at 12:23 PM, David Chandler <david...@gmail.com> wrote:
> I find the syntax for OOP in Python not very intuitive.  When I sit down and
> reason carefully I see that a class has a self reference because it is going
> to be used to create perhaps multiple objects that are distinct from each
> other.
>

I think of the great Dog, the Platonic ideal template, giving birth to
actual instances of dogs. The instance needs a self and the self has
its own personal / private namespace named self.__dict__.

C a r n e = meat in Latin. To instantiate is to incarnate. Sounds
religious. That's intended.

Aesthetically, I like Python for its mnemonic values. A class definition:

class Snake:
def __rib__(self):
pass
def __rib__(self):
pass
def __rib__(self):
pass
def __rib__(self):
pass
def __rib__(self):
pass
def __rib__(self):
pass
def __rib__(self):
pass

Looks like a Python! -- lots of ribs. Then change some of those to
familiar operations (behaviors) and you've got a Rational Number (Q):

class Q:
def __init__(self): # give birth
pass
def __add__(self, other): # add
pass
def __mul__(self, other): # multiply
pass
def __neg__(self): # additive inverse
pass
def __sub__(self, other): # subtract (add inverse)
pass
def __pow__(self, num): # power with exponent -1 = multiplicative inverse
pass
def __trudiv__(self, other): # divide (multiply by mult inverse)
pass

> My other questions were perhaps more to do with event-driven programming.
> There seems to be some kind of initial setup then a collection of classes
> that respond to events with no overall program flow that I'm used to.  When
> I sit down and work through it with a model program in front of me I can
> make sense of it, but it's hard to come up with code like this on my own, at
> this stage of my progress.
>

Event driven programming is complicated. You also don't need it to
get value from coding.

> I was just wondering if any of you had a way of thinking about this kind of
> coding that makes it all seem more intuitive to you.
>

Event objects, widgets that "listen" or "subscribe" to one another,
diagrams of various kinds...

The fun is to take away the computer and just think about objects (I'm
a polyhedron of a sort, bodily speaking, mind-wise too one might
posit).

How is a full sized city not "event driven" and "like objects"?

The tragedy of computer science is the wealth of metaphors that get
treated like literal dirt. They think OO is about how computers think
whereas we think about objects and their relationships all day long,
just riding the bus or fixing a meal.

Kirby