From kirby.urner at gmail.com  Mon Sep  1 19:53:09 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Mon, 1 Sep 2008 10:53:09 -0700
Subject: [Edu-sig] K12 Open Minds Reminder - Sessions announced!
In-Reply-To: <48B8D1AB.5070001@canterburyschool.org>
References: <48B8D1AB.5070001@canterburyschool.org>
Message-ID: <f604188c0809011053v311016a7ufd6fd580fbc0ed7f@mail.gmail.com>

I'm glad this is happening Vern, and I've been studying the website.

Your 'Open Source Options for Teaching Programming K-12' is probably
somewhat like my Python Briefing in part, the gig I cater to math
teachers in those schools with geek parents willing to kick up enough
fuss to cause a mini-revolution in math teaching practices (few and
far between so far nationally, these brewing tempests in teapots, but
then Portland is "special" (Church Lady allusion)).

If you find anyone pounding the podium about SQL pre-college, hooked
with Venn Diagrams etc., maybe put them in touch with me?  Even better
if they're using Python for hands-on, with SQLite or whatever.

It's a full scale offensive out here, getting more SQL in the high
schools, with some really nasty whispering campaigns both directions
(nothing new in math wars) plus nobody is sure what it'd mean for high
school students to be doing inner and outer joins with possibly
reckless abandon (we agree to safeguards, a sandbox, Polyhedra on
MySQL a good place to start, including with blobs?).

I'm not dragging edu-sig into it much though, as here we have the good
CS professors, not the rabid AlgebraFirsters I'm talking about (Robert
Moses et al), or students of Katrina Math program (cite Math Forum,
math-teach).  Colleges have a different set of problems, and besides,
SQL isn't Python.

Also, we don't like to over-politicize around here, I've learned from
past experience.

Kirby


On Fri, Aug 29, 2008 at 9:50 PM, Vern Ceder <vceder at canterburyschool.org> wrote:
> This is just a quick (and final) reminder that the K12 Open Minds
> conference is fast approaching. See http://www.k12openminds.org for more
> details - this is one of the few conferences devoted to Free and Open
> Source Software in K-12 education.
>
> There are two updates worth mentioning. First, the preliminary sessions
> list is now available at http://www.k12openminds.org/sessions - check it
> out and consider joining us. Both Andy Harrington and I will be talking
> about teaching Python, and Walter Bender from SugarLabs will also be
> presenting.
>
> Second, the deadline for rooms at the conference rate of $97 a night has
> been extended to Tuesday, Sept 2. After that, the room rate will
> increase dramatically. So if you are planning to attend, book a room now
> (see the "Hotels" link on k12openminds.org). You should be able to book
> online all through the weekend.
>
> I know that time is short, but we hope you will consider joining us in
> Indy for this event.
>
> Cheers,
> Vern Ceder, K12 Open Minds Planning Committee
> --
> This time for sure!
>   -Bullwinkle J. Moose
> -----------------------------
> Vern Ceder, Director of Technology
> Canterbury School, 3210 Smith Road, Ft Wayne, IN 46804
> vceder at canterburyschool.org; 260-436-0746; FAX: 260-436-5137
>
>
>
>
>
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig
>

From vceder at canterburyschool.org  Tue Sep  2 02:06:17 2008
From: vceder at canterburyschool.org (Vern Ceder)
Date: Mon, 01 Sep 2008 20:06:17 -0400
Subject: [Edu-sig] K12 Open Minds Reminder - Sessions announced!
In-Reply-To: <f604188c0809011053v311016a7ufd6fd580fbc0ed7f@mail.gmail.com>
References: <48B8D1AB.5070001@canterburyschool.org>
	<f604188c0809011053v311016a7ufd6fd580fbc0ed7f@mail.gmail.com>
Message-ID: <48BC8379.80703@canterburyschool.org>

Kirby,

>> If you find anyone pounding the podium about SQL pre-college, hooked
>> with Venn Diagrams etc., maybe put them in touch with me?  Even better
>> if they're using Python for hands-on, with SQLite or whatever.

Will do... I didn't have time to respond to your original post on SQL in 
  K12, but I like the idea. While I tend to use Python to explore the 
idea of "what is code and what can you do with it?", I can also see the 
power of using SQL to explore the area of "what is data and how can you 
manipulate it?" It seems to me that the two different paths could end up 
in similar places in the end.

>> Your 'Open Source Options for Teaching Programming K-12' is probably
>> somewhat like my Python Briefing in part

As to my talk, it will end with using Python (and other languages) in 
project based courses, preferably interacting with real OSS projects, 
but will begin in elementary with things like Scratch and Pico boards, 
which let very young kids write code that interacts with the real world, 
something pretty powerful at all ages.

Again, I wish we could have you there (and others on this list)... maybe 
next year.

Cheers,
Vern

kirby urner wrote:
> I'm glad this is happening Vern, and I've been studying the website.
> 
> Your 'Open Source Options for Teaching Programming K-12' is probably
> somewhat like my Python Briefing in part, the gig I cater to math
> teachers in those schools with geek parents willing to kick up enough
> fuss to cause a mini-revolution in math teaching practices (few and
> far between so far nationally, these brewing tempests in teapots, but
> then Portland is "special" (Church Lady allusion)).
> 
> If you find anyone pounding the podium about SQL pre-college, hooked
> with Venn Diagrams etc., maybe put them in touch with me?  Even better
> if they're using Python for hands-on, with SQLite or whatever.
> 
> It's a full scale offensive out here, getting more SQL in the high
> schools, with some really nasty whispering campaigns both directions
> (nothing new in math wars) plus nobody is sure what it'd mean for high
> school students to be doing inner and outer joins with possibly
> reckless abandon (we agree to safeguards, a sandbox, Polyhedra on
> MySQL a good place to start, including with blobs?).
> 
> I'm not dragging edu-sig into it much though, as here we have the good
> CS professors, not the rabid AlgebraFirsters I'm talking about (Robert
> Moses et al), or students of Katrina Math program (cite Math Forum,
> math-teach).  Colleges have a different set of problems, and besides,
> SQL isn't Python.
> 
> Also, we don't like to over-politicize around here, I've learned from
> past experience.
> 
> Kirby
> 
> 
> On Fri, Aug 29, 2008 at 9:50 PM, Vern Ceder <vceder at canterburyschool.org> wrote:
>> This is just a quick (and final) reminder that the K12 Open Minds
>> conference is fast approaching. See http://www.k12openminds.org for more
>> details - this is one of the few conferences devoted to Free and Open
>> Source Software in K-12 education.
>>
>> There are two updates worth mentioning. First, the preliminary sessions
>> list is now available at http://www.k12openminds.org/sessions - check it
>> out and consider joining us. Both Andy Harrington and I will be talking
>> about teaching Python, and Walter Bender from SugarLabs will also be
>> presenting.
>>
>> Second, the deadline for rooms at the conference rate of $97 a night has
>> been extended to Tuesday, Sept 2. After that, the room rate will
>> increase dramatically. So if you are planning to attend, book a room now
>> (see the "Hotels" link on k12openminds.org). You should be able to book
>> online all through the weekend.
>>
>> I know that time is short, but we hope you will consider joining us in
>> Indy for this event.
>>
>> Cheers,
>> Vern Ceder, K12 Open Minds Planning Committee
>> --
>> This time for sure!
>>   -Bullwinkle J. Moose
>> -----------------------------
>> Vern Ceder, Director of Technology
>> Canterbury School, 3210 Smith Road, Ft Wayne, IN 46804
>> vceder at canterburyschool.org; 260-436-0746; FAX: 260-436-5137
>>
>>
>>
>>
>>
>> _______________________________________________
>> Edu-sig mailing list
>> Edu-sig at python.org
>> http://mail.python.org/mailman/listinfo/edu-sig
>>
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig

-- 
This time for sure!
    -Bullwinkle J. Moose
-----------------------------
Vern Ceder, Director of Technology
Canterbury School, 3210 Smith Road, Ft Wayne, IN 46804
vceder at canterburyschool.org; 260-436-0746; FAX: 260-436-5137

From gintas at akl.lt  Tue Sep  2 19:41:35 2008
From: gintas at akl.lt (Gintautas Miliauskas)
Date: Tue, 02 Sep 2008 20:41:35 +0300
Subject: [Edu-sig] K12 Open Minds Reminder - Sessions announced!
In-Reply-To: <f604188c0809011053v311016a7ufd6fd580fbc0ed7f@mail.gmail.com>
References: <48B8D1AB.5070001@canterburyschool.org>
	<f604188c0809011053v311016a7ufd6fd580fbc0ed7f@mail.gmail.com>
Message-ID: <1220377295.24695.25.camel@satellite>

Hello,

> If you find anyone pounding the podium about SQL pre-college, hooked
> with Venn Diagrams etc., maybe put them in touch with me?  Even better
> if they're using Python for hands-on, with SQLite or whatever.

FWIW, I am planning a lesson or two on SQL (presented in contrast to
Python standard objects/lists/loops) for 12th grade pupils.  The
material probably will not be useful for anyone else though -- it's in
Lithuanian.

I would be very interested in a set of exercises, solutions to which
would preferably not be trivially findable on the web.  Any visual help
(diagrams, etc.) would save time too.  Those things do take some time to
prepare.

Best regards,
-- 
Gintautas Miliauskas
Vilnius Lyceum


From kirby.urner at gmail.com  Thu Sep  4 01:43:50 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Wed, 3 Sep 2008 16:43:50 -0700
Subject: [Edu-sig] K12 Open Minds Reminder - Sessions announced!
In-Reply-To: <1220377295.24695.25.camel@satellite>
References: <48B8D1AB.5070001@canterburyschool.org>
	<f604188c0809011053v311016a7ufd6fd580fbc0ed7f@mail.gmail.com>
	<1220377295.24695.25.camel@satellite>
Message-ID: <f604188c0809031643h5c9adb0ape750ee2844b74ea1@mail.gmail.com>

Thanks for writing Gintautas, and so wonderful to hear from Vilnius,
such a beautiful city...

I'm  making some headway with this Python Briefing component, here's
some cut and paste from the shell:

>>> from pysqlite2 import dbapi2 as sqlite
>>> con = sqlite.connect("gnugeom")
>>> cur = con.cursor()
>>> results  = cur.execute("select greekname, volume from Polyhedra")
>>> results.fetchall()
[(u'Tetrahedron', 1), (u'Hexahedron', 3), (u'Octahedron', 4),
(u'Rhombic Dodecahedron', 6), (u'Cuboctahedron', 20)]

The related Vectors and Facets tables contain the details for
populating Python string.Templates to give POV-Ray, X3D/VRML (and
other) output formats, per my talk in Vilnius last year:

http://www.4dsolutions.net/presentations/connectingthedots.pdf (3.2 MB
-- slides 24 - 27 especially).

My default volumes column may raise some eyebrows, as geometry
teachers aren't used to those wholesome whole volume numbers,
non-standard in K-12 textbooks -- but then they don't teach SQL
either, which is why this is called GnuMath i.e. it's not just the
usual stuff.

Here's my .sql for that Polyhedra table, pretty sparse at the moment
but sufficient for prototyping:

CREATE TABLE Polyhedra (
	greekname TEXT,
	shortname TEXT,
	vertices NUMERIC,
	edges NUMERIC,
	faces NUMERIC,
	volume NUMERIC);

INSERT INTO polyhedra VALUES ('Tetrahedron','tetra',4,6,4,1);
INSERT INTO polyhedra VALUES ('Hexahedron','cube',8,12,6,3);
INSERT INTO polyhedra VALUES ('Octahedron','octa',6,12,8,4);
INSERT INTO polyhedra VALUES ('Rhombic Dodecahedron','cell',14,24,12,6);
INSERT INTO polyhedra VALUES ('Cuboctahedron','cubocta',12,24,14,20);

A mini-course outline wherein this segment might fit, as a hands on activity:

Tetrahedron
24 A Modules
  angles and edges
  plane net
More Polyhedra
  vertices, edges, faces (OFF files)
  V + F = E + 2 (Euler)
A & B Modules

Just to translate a little:  an A module is 1/24th of a regular
tetrahedron as defined by its center of volume, a face center,
mid-edge, and vertex.  12 left handed and 12 right handed build the
shape.  As and Bs together build all the shapes in our table, plus 2
As and 1 B build the MITE, a minimum space-filling shape (irregular
tetrahedral).  Again, this is not especially familiar nomenclature in
today's high schools, which my company 4dsolutions exploits as a
marketing advantage (we're not just doing what everyone else is
doing).  http://www.grunch.net/synergetics/modules.html

Kirby


On Tue, Sep 2, 2008 at 10:41 AM, Gintautas Miliauskas <gintas at akl.lt> wrote:
> Hello,
>
>> If you find anyone pounding the podium about SQL pre-college, hooked
>> with Venn Diagrams etc., maybe put them in touch with me?  Even better
>> if they're using Python for hands-on, with SQLite or whatever.
>
> FWIW, I am planning a lesson or two on SQL (presented in contrast to
> Python standard objects/lists/loops) for 12th grade pupils.  The
> material probably will not be useful for anyone else though -- it's in
> Lithuanian.
>
> I would be very interested in a set of exercises, solutions to which
> would preferably not be trivially findable on the web.  Any visual help
> (diagrams, etc.) would save time too.  Those things do take some time to
> prepare.
>
> Best regards,
> --
> Gintautas Miliauskas
> Vilnius Lyceum
>
>

From MDiPierro at cs.depaul.edu  Thu Sep  4 07:16:35 2008
From: MDiPierro at cs.depaul.edu (Massimo Di Pierro)
Date: Thu, 4 Sep 2008 00:16:35 -0500
Subject: [Edu-sig] web2py book is out
Message-ID: <0ED391D4-05F7-4298-85A1-487C35E05E91@cs.depaul.edu>

In case you are interested. The web2py book is out:
http://he-cda.wiley.com/WileyCDA/Section/id-321954.html

Here is a sample:
http://mdp.cti.depaul.edu/examples/static/web2py_manual_cut.pdf

Here are some video:
http://www.vimeo.com/videos/search:web2py

Feel free to contact me if you have questions.

Massimo

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/edu-sig/attachments/20080904/31ef929d/attachment.htm>

From kirby.urner at gmail.com  Thu Sep  4 22:34:04 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Thu, 4 Sep 2008 13:34:04 -0700
Subject: [Edu-sig] More GnuMath stuff
Message-ID: <f604188c0809041334o52b4590fucd77526256851dfb@mail.gmail.com>

This code segment is a bit on the esoteric side but shows how a
generator, an iterable like a list comprehension, may be pressed into
service to populate an SQL table using pysqlite's executemany command.

import rbf

def pop(con):
    cur = con.cursor()
    gen = (
           (str(v), rbf.Vset[v].x, rbf.Vset[v].y, rbf.Vset[v].z)
           for v in rbf.Vset
           if v in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
           )
    cur.executemany("insert into Vectors(label, x, y, z) values (?, ?,
?, ?)", gen)
    con.commit()

Note we're not using %-operator dictionary substitution, but question
marks, with iterator as second parameter, playing the role of
tuple-generator (fill in the blanks).

What this looks like after running, in terms of raw data, is 26
"points of interest" used to anchor the aforementioned
whole-number-volumed polyhedra, tetrahedron as unit:

kirby at dell:~$ sqlite3 gnugeom
SQLite version 3.4.2
Enter ".help" for instructions
sqlite> select * from Vectors;
Z|0.707106781186547|0.707106781186547|0
A|0.353553390593274|0.353553390593274|0.353553390593274
C|-0.353553390593274|0.353553390593274|-0.353553390593274
B|-0.353553390593274|-0.353553390593274|0.353553390593274
E|-0.353553390593274|-0.353553390593274|-0.353553390593274
D|0.353553390593274|-0.353553390593274|-0.353553390593274
G|0.353553390593274|-0.353553390593274|0.353553390593274
F|0.353553390593274|0.353553390593274|-0.353553390593274
I|0|0|0.707106781186547
H|-0.353553390593274|0.353553390593274|0.353553390593274
K|0.707106781186547|0|0
J|0|0.707106781186547|0
M|0|-0.707106781186547|0
L|-0.707106781186547|0|0
O|0|0.707106781186547|0.707106781186547
N|0|0|-0.707106781186547
Q|-0.707106781186547|0|0.707106781186547
P|0.707106781186547|0|0.707106781186547
S|0|0.707106781186547|-0.707106781186547
R|0|-0.707106781186547|0.707106781186547
U|-0.707106781186547|0|-0.707106781186547
T|0.707106781186547|0|-0.707106781186547
W|-0.707106781186547|0.707106781186547|0
V|0|-0.707106781186547|-0.707106781186547
Y|0.707106781186547|-0.707106781186547|0
X|-0.707106781186547|-0.707106781186547|0
sqlite>

Here's a related graphic from:

Using Polyhedra to Teach OOP
and Coordinate Geometry Concepts
Chapter 7: Playing with Python
by Kirby Urner
First posted: August 28, 1999
Last modified: September 1, 1999
http://www.4dsolutions.net/ocn/oop7.html

A concept we're after here is primitive ORM (object-relational
mapping) in that we'll like have a Vector class, used to instantiate
each row of the Vectors table as a "vector object".  Vector objects
support __add__ and scalar multiplication (__mul__), plus may have a
self.draw() method for outputting to VPython, or some text file in
preparation for rendering.

Of course the whole Polyhedron might well be a class, probably is.
I'm not saying there's a one-size-fits-all solution here, would
encourage groups of students to cobble together their own databases in
most cases, at least smallish ones, as half the fun is using CREATE
TABLE, defining the relationships.

Note that Vectors are included in some secondary school level
curricula, though that's been increasingly pushed to remedial college
as the universal college expectation begets grade / degree inflation.

Our purpose here is to give high schoolers more opportunities as
job-ready entrepreneurs per the LEP High model (a charter school in
Portland).  Here's a paragraph I've shared with some of my
AlgebraFirst buddies:

"""
My angle is it's less the degree or credential that matters and more
the evidence of skills, something to brag about in a job interview,
that you know SQL, even though just fresh out of high school.  I'm
aiming towards a local economy in which a high school degree might be
sufficient again, for some entry level job, with college and company
life really a lot congruent in future, as work/study people farm
themselves out to this or that training, including history and
geography when traveling to that region... ends up being very like a
college degree, but measured more in promotions within the company (an
old template, no original thinking here, except it all sounds kinda
retro, now that we take quasi-universal college for granted).
"""

Those of you who've seen my Chicago talk (Pycon, on Showmedo), may
also remember TECC, another charter in the wannabe category, wondering
of all the spotlight on Wasilla with help Anna's cause at all.

So all the information you'd need to actually draw a Tetrahedron in
VPython could be garnered from some a SELECT statement such as the
following:

sqlite> select m.shortname, f.facet_id, f.vertex_id, v.x, v.y, v.z
from polyhedra m, facets f, vectors v where m.shortname = f.shortname
and f.label = v.label and m.shortname = "tetra";
tetra|0|0|0.353553390593274|0.353553390593274|0.353553390593274
tetra|0|1|-0.353553390593274|-0.353553390593274|0.353553390593274
tetra|0|2|-0.353553390593274|0.353553390593274|-0.353553390593274
tetra|1|0|0.353553390593274|0.353553390593274|0.353553390593274
tetra|1|1|-0.353553390593274|0.353553390593274|-0.353553390593274
tetra|1|2|0.353553390593274|-0.353553390593274|-0.353553390593274
tetra|2|0|0.353553390593274|0.353553390593274|0.353553390593274
tetra|2|1|0.353553390593274|-0.353553390593274|-0.353553390593274
tetra|2|2|-0.353553390593274|-0.353553390593274|0.353553390593274
tetra|3|0|-0.353553390593274|-0.353553390593274|0.353553390593274
tetra|3|1|-0.353553390593274|0.353553390593274|-0.353553390593274
tetra|3|2|0.353553390593274|-0.353553390593274|-0.353553390593274
sqlite>

For those less familiar with SQLite 3, it gives you a MySQL-like
administrative environment with Pysqlite2 the SQLite3 driver (yeah,
confusing).  You've got a pretty good implementation of SQL engine
syntax, so moving from this sandbox to something more robust is an
easy transition.  Some low volume websites never need to make the
transition.

Kirby

From wescpy at gmail.com  Fri Sep  5 10:19:38 2008
From: wescpy at gmail.com (wesley chun)
Date: Fri, 5 Sep 2008 01:19:38 -0700
Subject: [Edu-sig] [ANN] final 2008 Python courses, San Francisco
In-Reply-To: <78b3a9580809050116w2cfd7a98s10b7b9d201a979d8@mail.gmail.com>
References: <78b3a9580809050116w2cfd7a98s10b7b9d201a979d8@mail.gmail.com>
Message-ID: <78b3a9580809050119q46e5f004q7d7761950429fac4@mail.gmail.com>

*** will also X-post to CLP so apologies in advance for duplicates ***

Need to get up-to-speed with Python as quickly as possible? Come join
me, Wesley Chun, author of Prentice-Hall's bestseller "Core Python
Programming," for another comprehensive intro course plus a 1-day
Internet programming course coming up in November in beautiful
Northern California! I look forward to meeting you!

(Comprehensive) Introduction to Python
Mon-Wed, 2008 Nov 10-12, 9am-5pm

Internet Programming with Python
Sat, 2008 Nov 15, 9am-5pm

courses can be taken separately or combined for a discounted price.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(COMPREHENSIVE) INTRODUCTION TO PYTHON

Although this course may appear to those new to Python, it is also
perfect for those who have tinkered with it and want to "fill in the
gaps" and/or want to get more in-depth formal training.  It combines
the best of both an introduction to the language as well as a "Python
Internals" training course.

We will immerse you in the world of Python in only a few days, showing
you more than just its syntax (which you don't really need a book to
learn, right?). Knowing more about how Python works under the covers,
including the relationship between data objects and memory management,
will make you a much more effective Python programmer coming out of
the gate. 3 hands-on labs each day will help hammer the concepts home.

Come find out why Google, Yahoo!, Disney, ILM/LucasFilm, VMware, NASA,
Ubuntu, YouTube, and Red Hat all use Python. Users supporting or
jumping to Plone, Zope, TurboGears, Pylons, Django, Google App Engine,
Jython, IronPython, and Mailman will also benefit!

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
INTERNET PROGRAMMING WITH PYTHON

This is a one-day course with lecture and lab exposing attendees to
FOUR distinct areas of Internet programming:

* Network Programming using Sockets -- we introduce client/server
architecture and how to program sockets using Python.

* Internet Client Programming -- we learn how to use Python's standard
library to create FTP, NNTP, POP3, and SMTP clients

* Web Programming -- before you jump on all the web framework
bandwagons, it's a good idea to learn basics and the basis of how all
web servers deliver dynamic content back to the client browser to
prepare you better when jumping to a full-stack web framework

* Intro to Django -- a lightweight introduction to the Django web
framework including whipping up a very simple blog application in
20min!

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

WHERE: near the San Francisco Airport (SFO/San Bruno), CA, USA

WEB:   http://cyberwebconsulting.com (click "Python Training")

FLYER: http://starship.python.net/crew/wesc/flyerPP1combo.pdf

LOCALS: easy freeway (101/280/380) with lots of parking plus public
transit (BART and CalTrain) access via the San Bruno stations, easily
accessible from all parts of the Bay Area

VISITORS: free shuttle to/from the airport, free high-speed internet,
free breakfast and regular evening receptions; fully-equipped suites

See website for costs, venue info, and registration.  Discounts are
available for multiple registrations as well as for teachers/students.

Hope to see you there!
-- wesley

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
"Core Python Programming", Prentice Hall, (c)2007,2001
 http://corepython.com

"Python Web Development with Django", Addison Wesley, (c) 2008
http://withdjango.com

wesley.j.chun :: wescpy-at-gmail.com
python training and technical consulting
cyberweb.consulting : silicon valley, ca
http://cyberwebconsulting.com

From showell30 at yahoo.com  Fri Sep  5 21:00:29 2008
From: showell30 at yahoo.com (Steve Howell)
Date: Fri, 5 Sep 2008 12:00:29 -0700 (PDT)
Subject: [Edu-sig] webster van robot and tballsnake
Message-ID: <11858.98124.qm@web33502.mail.mud.yahoo.com>

Hey everybody,

I just wanted to introduce myself and a little project that I'm working on that might be of interest to this audience.

My name is Steve Howell, and I was one of the early project leaders for Guido van Robot, which was introduced to this mailing list a little under five years ago by Jeff Elkner:

  http://mail.python.org/pipermail/edu-sig/2003-October/003207.html

To paraphrase Jeff, Guido van Robot (aka GvR) brings "Pythonic" improvements to the teaching language Karel the Robot.  Since 2003, the program continued to evolve, mostly under the stewardship of a Dutch programmer named Stas Z, who has helped to internationalize it, clean up its user interface, and maintain ports on four major platforms (Linux, OLPC, Mac, and Windows).

  http://gvr.sourceforge.net/screen_shots/

Although I'm proud of the success of GvR, I've always been a little frustrated by its lack of adoption.  Although you never know for sure how many people use an Open Source project, I think GvR, like many other desktop applications, has a high barrier for experimentation.  Although the IDE and language itself are very simple, you have to have Python and PyGTK installed, and then you have to download the software itself.

I've always wanted to try out a Javascript port of GvR, post it on the web, and see if it got any more traction.  This week I finally got a little time to do just that:

  http://webstervanrobot.com/

Warning: the program has only been tested on Firefox 3 so far (IE is unfortunately broken).

Webster van Robot is currently is a programming language and free software application designed to introduce beginners to one of the most fundamental aspects of programming--looping.  It allows novice programmers to graphically manipulate an environment of streets, avenues, and walls using a simple programming language.  (BTW this blurb is mostly plagiarized from GvR.)

Here is a small Webster van Robot that uses all of its features:

  do 2:
    move
    turnleft
    build_wall_on_left
    turnright

Here's how to see it in action:

  go to http://webstervanrobot.com/
  edit the program to say "do 2:" instead of "do 1:"
  click on the run button
  (try out Demo #2 as well if you like)

How is Webster van Robot different than Guido van Robot:

  1) It runs directly out of the browser!  No installation required.
  2) It has only one programming construct now.  This is mostly a function of where I am in the development process, but you can always argue that simplicity is a feature!
  3) I have slightly different built-ins.  I decide to build in both "turnleft" and "turnright," as well as a new builtin for "build_wall_on_left."  I've always thought that Karel and Guido should start with a blank slate and build their own environment, without having to deal with "world" files.

When I've floated around the Webster idea before, people have suggested some kind of Python back end, but I found it was easy enough to implement the whole thing in Javascript.  Javascript has its quirks, but it's not a terrible language to work in, and one of my goals for the new project is to make it ridiculously easy for people to install/distribute the software.

Although I think of Webster van Robot mostly as a toy at this point, it got me thinking about the deeper problems of programming language literacy.  I really believe that most people should be able to learn Python in their lifetimes, but there needs to be a gentle progression to get there.  I've seen Guido van Robot used in only a couple classrooms, but that experience was enough to convince me that there's still a quantum leap from minimalistic languages to Python itself.

I'm also a huge believer that web apps will always meet with less friction than desktop apps.

So here's my pie-in-the-sky goal--I'd like to have a Javascript virtual machine that can execute progressively more complicated subset/variants of Python.  Or, to put it another way, I'd like a Javascript engine that allows easy, pluggable extensions of Webster van Robot as students gain more confidence.  Here are the places where I see extensibility:

  1) Plug in new model/views.  Streets, avenues, and walls aren't for everybody.

  2) Plug in new builtins.  Move, turnright, and build_wall_on_left aren't for everybody.

  3) Allow a gentle progression through flow constructs.  Start with "do," then introduce "if," "while," etc.

  4) Allow "def" fairly early in the process too.

  5) Allow gentle introduction of data structures and variables.  (This is the place where Karel the Robot and Guido van Robot don't have any ambition to fill a gap, and I think this is where the quantum leap comes into play.  I also think the lack of basic variables and expressions make it harder to write "fun" robot programs too.)

So, I'm thinking Javascript has enough horsepower to create this basic framework, although you could still mostly drive the code from a Python back end.  Although I haven't coded anything yet, Webster van Robot has some of the very basic pieces to get it started, and I've come up with a name--"tballsnake," which is an anagram of "blank slate."  "T-Ball" is a metaphor similar to "training wheels," and then the "snake" refers to the end goal--Python proficiency.

Anyway, hope some of this is food for thought.

Steve


From ajudkis at verizon.net  Sat Sep  6 16:29:46 2008
From: ajudkis at verizon.net (ajudkis at verizon.net)
Date: Sat, 06 Sep 2008 09:29:46 -0500 (CDT)
Subject: [Edu-sig] Webster Van Robot
Message-ID: <5752292.994621220711387018.JavaMail.root@vms070.mailsrvcs.net>

Steve,

Neat idea, nice implementation!
I want to call everyone's attention to RUR-PLE, another  Karel successor that the students control with actual Python.  I've used it quite successfully for 3 or 4 years now, it provides a great wading pool for trying out the basic concepts, and they get exposed to the real syntax from the first day.

Check it out at http://rur-ple.sourceforge.net/.

And Andre, if you're reading this, my students still have a soft spot for Reeborg, some of them were talking about him just yesterday.

Cheers,
Andy Judkis
Academy of Allied Health and Science
Neptune, NJ


From andre.roberge at gmail.com  Sat Sep  6 18:09:40 2008
From: andre.roberge at gmail.com (Andre Roberge)
Date: Sat, 6 Sep 2008 13:09:40 -0300
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <5752292.994621220711387018.JavaMail.root@vms070.mailsrvcs.net>
References: <5752292.994621220711387018.JavaMail.root@vms070.mailsrvcs.net>
Message-ID: <7528bcdd0809060909v511f3346n43e254e68aa206e2@mail.gmail.com>

On Sat, Sep 6, 2008 at 11:29 AM, <ajudkis at verizon.net> wrote:

> Steve,
>
> Neat idea, nice implementation!
> I want to call everyone's attention to RUR-PLE, another  Karel successor
> that the students control with actual Python.  I've used it quite
> successfully for 3 or 4 years now, it provides a great wading pool for
> trying out the basic concepts, and they get exposed to the real syntax from
> the first day.
>
> Check it out at http://rur-ple.sourceforge.net/.
>
> And Andre, if you're reading this, my students still have a soft spot for
> Reeborg, some of them were talking about him just yesterday.


:-)

Yes, I am still reading this. :-)

While rur-ple is very usable in its current state (1.0 release candidate 3),
there are still a few things left to clean up for the final 1.0 release.
"Unfortunately", I have not had the energy to spend any time on it for well
over a year.  I put "unfortunately" in quotation marks the lack of time
spent on rur-ple has been caused in large parts by working on Crunchy.  And
"one of these days", Crunchy will support an embedded world for Reeborg to
move in.    Perhaps it will make use of Steve's Webster...

Cheers,

Andr?


>
>
> Cheers,
> Andy Judkis
> Academy of Allied Health and Science
> Neptune, NJ
>
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/edu-sig/attachments/20080906/a3b2c95e/attachment.htm>

From jurgis at akl.lt  Mon Sep  8 11:20:27 2008
From: jurgis at akl.lt (Jurgis Pralgauskis)
Date: Mon, 8 Sep 2008 12:20:27 +0300
Subject: [Edu-sig] Webster Van Robot (and rur-ple)
Message-ID: <34f4097d0809080220p3be0f3d7p49fb53913b3b3e26@mail.gmail.com>

> I want to call everyone's attention to RUR-PLE, another  Karel successor that the students control with actual Python.  I've used it quite successfully for 3 or 4 years now, it provides a great wading pool for trying out the basic concepts, and they get exposed to the real syntax from the first day.
>
> Check it out at http://rur-ple.sourceforge.net/.

I also like it a lot, so with experienced friend prepaired .deb package
https://sourceforge.net/forum/message.php?msg_id=5132850
and also theres some intro stuff  http://en.wikipedia.org/wiki/RUR-PLE

ps.: http://webstervanrobot.com could someday be converted to be even
more visual
as http://scratch.mit.edu/about (which is top tool for programmin
introduction for all ages :)
html +js gives enough possibilities for drag and drop puzzle functionality

From andre.roberge at gmail.com  Mon Sep  8 12:30:11 2008
From: andre.roberge at gmail.com (Andre Roberge)
Date: Mon, 8 Sep 2008 07:30:11 -0300
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <7528bcdd0809060909v511f3346n43e254e68aa206e2@mail.gmail.com>
References: <5752292.994621220711387018.JavaMail.root@vms070.mailsrvcs.net>
	<7528bcdd0809060909v511f3346n43e254e68aa206e2@mail.gmail.com>
Message-ID: <7528bcdd0809080330l135b9eceid329553fe7cda1b9@mail.gmail.com>

On Sat, Sep 6, 2008 at 1:09 PM, Andre Roberge <andre.roberge at gmail.com> wrote:
> On Sat, Sep 6, 2008 at 11:29 AM, <ajudkis at verizon.net> wrote:
>>
>> Steve,
>>
>> Neat idea, nice implementation!
>> I want to call everyone's attention to RUR-PLE, another  Karel successor
>> that the students control with actual Python.  I've used it quite
>> successfully for 3 or 4 years now, it provides a great wading pool for
>> trying out the basic concepts, and they get exposed to the real syntax from
>> the first day.
>>
>> Check it out at http://rur-ple.sourceforge.net/.
>>
>> And Andre, if you're reading this, my students still have a soft spot for
>> Reeborg, some of them were talking about him just yesterday.
>
> :-)
>
> Yes, I am still reading this. :-)
>
> While rur-ple is very usable in its current state (1.0 release candidate 3),
> there are still a few things left to clean up for the final 1.0 release.
> "Unfortunately", I have not had the energy to spend any time on it for well
> over a year.  I put "unfortunately" in quotation marks the lack of time
> spent on rur-ple has been caused in large parts by working on Crunchy.  And
> "one of these days", Crunchy will support an embedded world for Reeborg to
> move in.    Perhaps it will make use of Steve's Webster...
>


Well, it turned out to be easier (to get started) than I thought.  For
those interested,
I have adapted Steve's Webster so that
1. it uses Reeborg's images  (which I did send to Steve as well)
2. it has a color scheme inspired by rur-ple
3. it uses a *small* subset of Python's syntax.

For example, the following is a valid program:
for some_variable in range(4):
    move()
    turn_left()
    move()
    build_wall_on_left()

If you want a copy to play with, please send me an email off-list.

Cheers,

Andr?



> Cheers,
>
> Andr?
>
>>
>> Cheers,
>> Andy Judkis
>> Academy of Allied Health and Science
>> Neptune, NJ
>>
>> _______________________________________________
>> Edu-sig mailing list
>> Edu-sig at python.org
>> http://mail.python.org/mailman/listinfo/edu-sig
>
>

From kirby.urner at gmail.com  Mon Sep  8 17:44:03 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Mon, 8 Sep 2008 08:44:03 -0700
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <7528bcdd0809080330l135b9eceid329553fe7cda1b9@mail.gmail.com>
References: <5752292.994621220711387018.JavaMail.root@vms070.mailsrvcs.net>
	<7528bcdd0809060909v511f3346n43e254e68aa206e2@mail.gmail.com>
	<7528bcdd0809080330l135b9eceid329553fe7cda1b9@mail.gmail.com>
Message-ID: <f604188c0809080844icc5ca07ka8a5dec1d7bbb441@mail.gmail.com>

> For example, the following is a valid program:
> for some_variable in range(4):
>    move()
>    turn_left()
>    move()
>    build_wall_on_left()
>

So no explicit target or receiver for the message, as the Smalltalk
people might say?  I.e. you don't say myturtle.move() but just move(),
more like Logo?

Kirby

From andre.roberge at gmail.com  Mon Sep  8 17:54:52 2008
From: andre.roberge at gmail.com (Andre Roberge)
Date: Mon, 8 Sep 2008 12:54:52 -0300
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <f604188c0809080844icc5ca07ka8a5dec1d7bbb441@mail.gmail.com>
References: <5752292.994621220711387018.JavaMail.root@vms070.mailsrvcs.net>
	<7528bcdd0809060909v511f3346n43e254e68aa206e2@mail.gmail.com>
	<7528bcdd0809080330l135b9eceid329553fe7cda1b9@mail.gmail.com>
	<f604188c0809080844icc5ca07ka8a5dec1d7bbb441@mail.gmail.com>
Message-ID: <7528bcdd0809080854x570e3cf2pa135d09254bea9d4@mail.gmail.com>

On Mon, Sep 8, 2008 at 12:44 PM, kirby urner <kirby.urner at gmail.com> wrote:
>> For example, the following is a valid program:
>> for some_variable in range(4):
>>    move()
>>    turn_left()
>>    move()
>>    build_wall_on_left()
>>
>
> So no explicit target or receiver for the message, as the Smalltalk
> people might say?  I.e. you don't say myturtle.move() but just move(),
> more like Logo?
>
That is correct.  This is how Guido van Robot is [although it uses
move and not move()], and how rur-ple is.

In rur-ple, one can later have
reeborg = Robot()
reeborg.move()
reeborg.turn_left()
etc.,
but it does start with simple functions and build from there.

One can see move() as equivalent to reeborg.move(), but where the
instantiation of the Robot class has happened behind the scene, i.e.

reeborg = Robot()
move = reeborg.move
turn_left = reeborg.turn_left
etc.

 My plans would be the same when integrated with Crunchy.   I think
(and Andy will be able to confirm/infirm based on his real life
experience) that it is better to use a more gradual approach like this
(i.e. hide the object-oriented construction at the beginning).

Andr?

> Kirby
>

From showell30 at yahoo.com  Mon Sep  8 18:08:17 2008
From: showell30 at yahoo.com (Steve Howell)
Date: Mon, 8 Sep 2008 09:08:17 -0700 (PDT)
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <f604188c0809080844icc5ca07ka8a5dec1d7bbb441@mail.gmail.com>
Message-ID: <248610.80130.qm@web33507.mail.mud.yahoo.com>




--- On Mon, 9/8/08, kirby urner <kirby.urner at gmail.com> wrote:

> From: kirby urner <kirby.urner at gmail.com>
> To: "Andre Roberge" <andre.roberge at gmail.com>
> 
> So no explicit target or receiver for the message, as the
> Smalltalk
> people might say?  I.e. you don't say myturtle.move()
> but just move(),
> more like Logo?
> 

Hi Kirby,

There are some object-oriented variants of Karel the Robot:

http://pclc.pace.edu/~bergin/karel.html

Guido van Robot and Webster van Robot are purely procedural, which has the following benefits:

  1) There's a lot less typing, which means more time for thinking, exploring, etc.
  2) You can master simple, but fundamental, concepts like creating methods and nesting loops without the conceptual overhead of object-oriented programming.

I would love to brainstorm ideas on creating a path from GvR and WvR to more object-oriented programming.  IMHO you need to make sure you do it in a non-superficial way.  For example, I would want your object space to be rich enough that you actually have objects that interface with each other.

Perhaps I'm biased by my own experiences.  I started off with procedural languages and learned a lot from them.  I had some time to understand their limitations, so when I was finally introduced to object-oriented programming (C++ in my case), I was highly motivated to appreciate its benefits.  Also, as Python programmers, I guess we can all appreciate that OO and procedural programming can live side by side.

To me one of the biggest advantages of object-oriented programming is the notion of data encapsulation.  Guido and Webster don't even deal with data.



From kirby.urner at gmail.com  Mon Sep  8 18:41:08 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Mon, 8 Sep 2008 09:41:08 -0700
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <248610.80130.qm@web33507.mail.mud.yahoo.com>
References: <f604188c0809080844icc5ca07ka8a5dec1d7bbb441@mail.gmail.com>
	<248610.80130.qm@web33507.mail.mud.yahoo.com>
Message-ID: <f604188c0809080941v44dbb6ebi84bbd8f1c50147b9@mail.gmail.com>

Thanks for the clarifications, good to know both options (receiver and
receiverless) are both in the mix.

Our use of 'procedural' may confuse some students as OO syntax is
eminently step-by-step with flow of control and all the rest of it,
very recognizably procedural the way I learned the term, with or
without the explicit dot notation (which is difficult to hide in real
Python).

I'm inclined to *not* see 'procedural' and 'object oriented' as
orthogonal concepts i.e. they mix together.  Where I do see a big
dichotomy is in whether one is expected to define new classes oneself,
or simply use the ones provided.

Apparently early versions of Visual Basic were "read only" in terms of
not having a class defining infrastructure, merely giving developers
access to canned OCX objects (instances) with canned APIs, but I could
be wrong, that's not a track I've ever followed, even to this very
day.

As I mention in my Chicago talk, I tell my students "I've never heard
of procedural programming, it gives me the creeps" but that's just a
rhetorical device to get the ball rolling, as I start with dot
notation immediately, within the first 10 minutes.  But that's because
I'm teaching core Python, not another language *implemented* in core
Python.  These aren't little children.

They may have done Logo or other 3rd person avatar controlling (ala
Sims) well before taking my class, so I presume this as background,
allude to Sims as "objects" and so on, project a YouTube or two if
they seem unclear what I'm talking about.

Kirby

From kirby.urner at gmail.com  Mon Sep  8 19:23:50 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Mon, 8 Sep 2008 10:23:50 -0700
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <f604188c0809080941v44dbb6ebi84bbd8f1c50147b9@mail.gmail.com>
References: <f604188c0809080844icc5ca07ka8a5dec1d7bbb441@mail.gmail.com>
	<248610.80130.qm@web33507.mail.mud.yahoo.com>
	<f604188c0809080941v44dbb6ebi84bbd8f1c50147b9@mail.gmail.com>
Message-ID: <f604188c0809081023j7e83cc35o25a805aca2ae93ef@mail.gmail.com>

Just to elaborate a bit, I do get around to telling longer stories,
sharing "geek lore" as I call it, and the story I tell goes something
like this:

In the early days of assembly language, it was all about conditional
jumping to get choices or forks in the road, which led to a first
generation of higher level coder to write "spaghetti code" even when
infrastructure for subprocedures was provided.

Djikstra went on the war path to rationalize coding around a main call
sequence with branching to subprocedures in a tree pattern, reusing
library utilities, but with much less reliance on global variables,
context, side effects, other subtle stuff (all that
"anti-encapsulation" infrastructure).  "Never use GOTO" was his advice
and many languages took it out.

*That* was the hallmark of the 'procedural programming' era (might've
been called 'subprocedural' but that's picking nits), to never use
GOTO, or at least not gratuitously (which is almost always is), to
always do a kind of top-down style with a main call sequence.

The OO revolution built on top of the procedural programming
resolution, by giving us encapsulation and inheritance infrastructure
that would more closely model the guts of a knowledge domain, i.e.
your job is to think in terms of cells, DNA, airports, train yards or
whatever but *not* in terms of some CPU with access to memory (way too
low level and irrelevant to the problems in scope).

OO was also of key importance given the evolution of GUIs and
non-menu-driven modes of interactivity, where users could (and still
do) fire off events from a mouse, keyboard, any number of screen
widgets, and the code had to be "ready" (i.e. "listening") -- much
more like interrupt-driven operating system design, with event queues
and so forth.

This is still a challenging kind of programming, goes into threading
and the rest of it, but we get our feet wet with such curricula as
John Zelle's, which relies on the cross-platform Tk widget set.

I prefer doing more with SQL first, introduce "multi-user" as an ACID
challenge (thinking about airline reservations systems), then turn to
the Web for widget programming, skip the whole "thick client" business
until a later course.  The old LAMP infrastructure really doesn't
require any specialized widget programming, just XHTML forms, buttons
and so on.

Python is a clean implementation of the OO style of thinking, and if
your knowledge domain is amendable to decomposition in terms of
objects, then chances are there'll be a way to express it in OO terms.
 Instances are a lot like subprocedures in some ways, in promoting
encapsulation, not willy-nilly sharing of globals, plus we still don't
need GOTO if we ever did (we did with assembler, still do).

I've notice high schoolers are able to follow all this, a kind of
storytime interlude, like when a teacher reads a story to the group,
although here I ad lib, might project a comic strip sometime.

I could also see doing this history in a more cartoon form, have been
urging O'Reilly to branch into the cartoon business more concertedly,
but that's a difficult transition for a wood pulp publishing giant
('Head First' a good first step).

There's lots more to this lore (some of which I get to, a lot of which
I'm still learning), but the mode is one of standing back, overview,
altitude viewing.  That's very important in introductory classes, in
literature, philosophy, art or mathematics.  We neglect it at our
significant peril in my view.  Leave out the historical dimension only
if you wish to consign your curriculum to the ash heap of history is
my motto.

These days, I'm less likely to work directly with high school aged
students, am more peddling my Python Briefing to their teachers, so
they're the ones getting this lore, perhaps to pass it back to their
math classes, along with a syllabus of optional viewing DVDs etc.,
plus Neal Stephenson's 'In the beginnning...' is still a classic.

Kirby



On Mon, Sep 8, 2008 at 9:41 AM, kirby urner <kirby.urner at gmail.com> wrote:
> Thanks for the clarifications, good to know both options (receiver and
> receiverless) are both in the mix.
>
> Our use of 'procedural' may confuse some students as OO syntax is
> eminently step-by-step with flow of control and all the rest of it,
> very recognizably procedural the way I learned the term, with or
> without the explicit dot notation (which is difficult to hide in real
> Python).
>
> I'm inclined to *not* see 'procedural' and 'object oriented' as
> orthogonal concepts i.e. they mix together.  Where I do see a big
> dichotomy is in whether one is expected to define new classes oneself,
> or simply use the ones provided.
>
> Apparently early versions of Visual Basic were "read only" in terms of
> not having a class defining infrastructure, merely giving developers
> access to canned OCX objects (instances) with canned APIs, but I could
> be wrong, that's not a track I've ever followed, even to this very
> day.
>
> As I mention in my Chicago talk, I tell my students "I've never heard
> of procedural programming, it gives me the creeps" but that's just a
> rhetorical device to get the ball rolling, as I start with dot
> notation immediately, within the first 10 minutes.  But that's because
> I'm teaching core Python, not another language *implemented* in core
> Python.  These aren't little children.
>
> They may have done Logo or other 3rd person avatar controlling (ala
> Sims) well before taking my class, so I presume this as background,
> allude to Sims as "objects" and so on, project a YouTube or two if
> they seem unclear what I'm talking about.
>
> Kirby
>

From echerlin at gmail.com  Mon Sep  8 21:41:39 2008
From: echerlin at gmail.com (Edward Cherlin)
Date: Mon, 8 Sep 2008 12:41:39 -0700
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <f604188c0809081023j7e83cc35o25a805aca2ae93ef@mail.gmail.com>
References: <f604188c0809080844icc5ca07ka8a5dec1d7bbb441@mail.gmail.com>
	<248610.80130.qm@web33507.mail.mud.yahoo.com>
	<f604188c0809080941v44dbb6ebi84bbd8f1c50147b9@mail.gmail.com>
	<f604188c0809081023j7e83cc35o25a805aca2ae93ef@mail.gmail.com>
Message-ID: <e574f6eb0809081241n65cbccb8p78c61d309997f708@mail.gmail.com>

This sounds like something we should hear about at PyCon 2009 in
Chicago. Can you do it either as a presentation or a tutorial? If you
can, we can organize a coding sprint for you.

Also, please consider any such educational Python projects for
inclusion in Sugar on the OLPC XO. http://www.sugarlabs.org/.

On Mon, Sep 8, 2008 at 10:23 AM, kirby urner <kirby.urner at gmail.com> wrote:
> Just to elaborate a bit, I do get around to telling longer stories,
> sharing "geek lore" as I call it, and the story I tell goes something
> like this:
>
> In the early days of assembly language, it was all about conditional
> jumping to get choices or forks in the road, which led to a first
> generation of higher level coder to write "spaghetti code" even when
> infrastructure for subprocedures was provided.
>
> Djikstra went on the war path to rationalize coding around a main call
> sequence with branching to subprocedures in a tree pattern, reusing
> library utilities, but with much less reliance on global variables,
> context, side effects, other subtle stuff (all that
> "anti-encapsulation" infrastructure).  "Never use GOTO" was his advice
> and many languages took it out.
>
> *That* was the hallmark of the 'procedural programming' era (might've
> been called 'subprocedural' but that's picking nits), to never use
> GOTO, or at least not gratuitously (which is almost always is), to
> always do a kind of top-down style with a main call sequence.
>
> The OO revolution built on top of the procedural programming
> resolution, by giving us encapsulation and inheritance infrastructure
> that would more closely model the guts of a knowledge domain, i.e.
> your job is to think in terms of cells, DNA, airports, train yards or
> whatever but *not* in terms of some CPU with access to memory (way too
> low level and irrelevant to the problems in scope).
>
> OO was also of key importance given the evolution of GUIs and
> non-menu-driven modes of interactivity, where users could (and still
> do) fire off events from a mouse, keyboard, any number of screen
> widgets, and the code had to be "ready" (i.e. "listening") -- much
> more like interrupt-driven operating system design, with event queues
> and so forth.
>
> This is still a challenging kind of programming, goes into threading
> and the rest of it, but we get our feet wet with such curricula as
> John Zelle's, which relies on the cross-platform Tk widget set.
>
> I prefer doing more with SQL first, introduce "multi-user" as an ACID
> challenge (thinking about airline reservations systems), then turn to
> the Web for widget programming, skip the whole "thick client" business
> until a later course.  The old LAMP infrastructure really doesn't
> require any specialized widget programming, just XHTML forms, buttons
> and so on.
>
> Python is a clean implementation of the OO style of thinking, and if
> your knowledge domain is amendable to decomposition in terms of
> objects, then chances are there'll be a way to express it in OO terms.
>  Instances are a lot like subprocedures in some ways, in promoting
> encapsulation, not willy-nilly sharing of globals, plus we still don't
> need GOTO if we ever did (we did with assembler, still do).
>
> I've notice high schoolers are able to follow all this, a kind of
> storytime interlude, like when a teacher reads a story to the group,
> although here I ad lib, might project a comic strip sometime.
>
> I could also see doing this history in a more cartoon form, have been
> urging O'Reilly to branch into the cartoon business more concertedly,
> but that's a difficult transition for a wood pulp publishing giant
> ('Head First' a good first step).
>
> There's lots more to this lore (some of which I get to, a lot of which
> I'm still learning), but the mode is one of standing back, overview,
> altitude viewing.  That's very important in introductory classes, in
> literature, philosophy, art or mathematics.  We neglect it at our
> significant peril in my view.  Leave out the historical dimension only
> if you wish to consign your curriculum to the ash heap of history is
> my motto.
>
> These days, I'm less likely to work directly with high school aged
> students, am more peddling my Python Briefing to their teachers, so
> they're the ones getting this lore, perhaps to pass it back to their
> math classes, along with a syllabus of optional viewing DVDs etc.,
> plus Neal Stephenson's 'In the beginnning...' is still a classic.
>
> Kirby
>
>
>
> On Mon, Sep 8, 2008 at 9:41 AM, kirby urner <kirby.urner at gmail.com> wrote:
>> Thanks for the clarifications, good to know both options (receiver and
>> receiverless) are both in the mix.
>>
>> Our use of 'procedural' may confuse some students as OO syntax is
>> eminently step-by-step with flow of control and all the rest of it,
>> very recognizably procedural the way I learned the term, with or
>> without the explicit dot notation (which is difficult to hide in real
>> Python).
>>
>> I'm inclined to *not* see 'procedural' and 'object oriented' as
>> orthogonal concepts i.e. they mix together.  Where I do see a big
>> dichotomy is in whether one is expected to define new classes oneself,
>> or simply use the ones provided.
>>
>> Apparently early versions of Visual Basic were "read only" in terms of
>> not having a class defining infrastructure, merely giving developers
>> access to canned OCX objects (instances) with canned APIs, but I could
>> be wrong, that's not a track I've ever followed, even to this very
>> day.
>>
>> As I mention in my Chicago talk, I tell my students "I've never heard
>> of procedural programming, it gives me the creeps" but that's just a
>> rhetorical device to get the ball rolling, as I start with dot
>> notation immediately, within the first 10 minutes.  But that's because
>> I'm teaching core Python, not another language *implemented* in core
>> Python.  These aren't little children.
>>
>> They may have done Logo or other 3rd person avatar controlling (ala
>> Sims) well before taking my class, so I presume this as background,
>> allude to Sims as "objects" and so on, project a YouTube or two if
>> they seem unclear what I'm talking about.
>>
>> Kirby
>>
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig
>



-- 
Silent Thunder [ ?? / ???????? / ????? ? ] is my name,
And Children are my nation.
The Six Worlds are my dwelling place,
And Truth my destination.

From kirby.urner at gmail.com  Mon Sep  8 22:10:30 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Mon, 8 Sep 2008 13:10:30 -0700
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <e574f6eb0809081241n65cbccb8p78c61d309997f708@mail.gmail.com>
References: <f604188c0809080844icc5ca07ka8a5dec1d7bbb441@mail.gmail.com>
	<248610.80130.qm@web33507.mail.mud.yahoo.com>
	<f604188c0809080941v44dbb6ebi84bbd8f1c50147b9@mail.gmail.com>
	<f604188c0809081023j7e83cc35o25a805aca2ae93ef@mail.gmail.com>
	<e574f6eb0809081241n65cbccb8p78c61d309997f708@mail.gmail.com>
Message-ID: <f604188c0809081310n7351c334s1c0a21bfaa60e995@mail.gmail.com>

On Mon, Sep 8, 2008 at 12:41 PM, Edward Cherlin <echerlin at gmail.com> wrote:
> This sounds like something we should hear about at PyCon 2009 in
> Chicago. Can you do it either as a presentation or a tutorial? If you
> can, we can organize a coding sprint for you.

Yeah, I'd like to do that again, had a great time last year, meeting
old and new people (to me), striking up some collaborations.  Budget
permitting, I'll be there again with or without a prepared speech or
presentation, again connecting with my two daughters, maybe bringing a
partner (Patrick Barton came last year, a Linus Pauling House regular,
but through his own Chicago based company, not on my ticket).

> Also, please consider any such educational Python projects for
> inclusion in Sugar on the OLPC XO. http://www.sugarlabs.org/.
>

My Python Briefing is about helping math teachers get their feet wet
in what's become an important set of tools in any mathematician's tool
kit (talking about "executable math notations" per Iverson (APL) not
Python specifically here), with all the necessary source code examples
already at my Oregon Curriculum Network web site, enough to inspire
plenty of imitators I think (that's my goal).  And it's not like I'm
the only source, plus took liberal helpings from other sites to get
going (what open source is all about, plus giving credit where credit
is due).

So I don't see any need for a coding sprint.  This isn't about
uploading some new version of Sage or anything close.
http://www.sagemath.org/  That's not to say I don't include Sage in my
Briefing -- I flip through lots of slides at high speed, saying I only
have 30-45 (minus Q&A) minutes and if they want me to slow down
that'll cost 'em. :)

I have lots of postings on file, in this archive and my blog, re OLPC
& XO, mainly explaining that P4E (Programming for Everyone, inheriting
from Guido's CP4E) is rather hardware agnostic, although of course we
care about specific APIs associate with this or that MIDI card or
whatever it might be (phidgets are "in" these days -- literal
embodiments of what might have been screen widgets, USB connected).
http://en.wikipedia.org/wiki/Phidgets (hi Nat!).

Kirby

PS:  for those of you who didn't catch my talk last year, and in case
I'm unable to make Pycon next year, here's the entire talk with a
replaced video track (the cameras didn't follow the action very
closely, plus source code is unreadable at that distance):
http://showmedo.com/videos/video?name=1010050&fromSeriesID=101 (the
TECC academy I mention, show in a newspaper clipping from Alaska
paper, is actually based in Wasilla, which is entertaining for us,
maybe will get to do a Briefing there someday, though so far I'm
sticking closer to home (check blogs for my whereabouts)).

From showell30 at yahoo.com  Tue Sep  9 04:07:56 2008
From: showell30 at yahoo.com (Steve Howell)
Date: Mon, 8 Sep 2008 19:07:56 -0700 (PDT)
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <f604188c0809080941v44dbb6ebi84bbd8f1c50147b9@mail.gmail.com>
Message-ID: <900888.56377.qm@web33501.mail.mud.yahoo.com>

Hi Kirby,

Thanks for this response, and the follow up as well.  See my comments and questions inline.

Thanks,

Steve

--- On Mon, 9/8/08, kirby urner <kirby.urner at gmail.com> wrote:

> From: kirby urner <kirby.urner at gmail.com>
> 
> Our use of 'procedural' may confuse some students
> as OO syntax is
> eminently step-by-step with flow of control and all the
> rest of it,
> very recognizably procedural the way I learned the term,
> with or
> without the explicit dot notation (which is difficult to
> hide in real
> Python).
>

Agreed that 'procedural' and 'OO' have a lot more common than different.  I didn't mean to suggest in any way that the concepts were orthogonal.

Python does have plenty of builtins, where the target is either implicit or supplied as a parameter:

http://docs.python.org/lib/built-in-funcs.html

Perhaps the "print" statement would be the best example in Python of conciseness winning out over explicitness.  Java is perhaps the other extreme, with its "system.out.println" idiom.
 
> I'm inclined to *not* see 'procedural' and
> 'object oriented' as
> orthogonal concepts i.e. they mix together.  Where I do see
> a big
> dichotomy is in whether one is expected to define new
> classes oneself,
> or simply use the ones provided.
> 

I agree with the dichotomy.  There's some middle ground too, where students can alter or extend existing classes before they write their own.

> Apparently early versions of Visual Basic were "read
> only" in terms of
> not having a class defining infrastructure, merely giving
> developers
> access to canned OCX objects (instances) with canned APIs,
> but I could
> be wrong, that's not a track I've ever followed,
> even to this very
> day.
>

Most of us learn to read before we write, so I'm not so sure it's necessarily a bad thing to introduce OO to students as consumers before they become producers.  On the other hand, I totally understand your desire to have students write their own objects from the beginning.

What's an example of a small Python program that your students have written that uses objects that they built?  Do they start with model/view/controller objects or otherwise?

 
> As I mention in my Chicago talk, I tell my students
> "I've never heard
> of procedural programming, it gives me the creeps" but
> that's just a
> rhetorical device to get the ball rolling, as I start with
> dot
> notation immediately, within the first 10 minutes.  

Do students ever get confused by the dot notation, or at least frustrated with the wordiness?

> But
> that's because
> I'm teaching core Python, not another language
> *implemented* in core
> Python.  These aren't little children.
> 

I think it's great that you have students who are ready to jump right into core Python, but I don't think you have to be a little child to benefit from small languages like Karel, Logo, and various cousins.   When I was in college, lots of non-CS students got exposed to programming through Karel and got a lot out of it.  That was nearly 20 years ago, so I'm sure today's generation comes in with a little more sophistication, but I still see the benefit of starting with a language with very limited syntax.

Even if you have a bit of programming background coming into a small language, it can still be a really refreshing exercise to work within its limitations.  One of the funnest programs I ever wrote was to have Karel determine whether his beeper world was palindromic.  Try to do that without variables!

Getting back to little children, though, I do think there will come a day where smaller children learn to program as easily as they learn reading, writing, arithmetic, music, etc.





From kirby.urner at gmail.com  Tue Sep  9 06:50:50 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Mon, 8 Sep 2008 21:50:50 -0700
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <900888.56377.qm@web33501.mail.mud.yahoo.com>
References: <f604188c0809080941v44dbb6ebi84bbd8f1c50147b9@mail.gmail.com>
	<900888.56377.qm@web33501.mail.mud.yahoo.com>
Message-ID: <f604188c0809082150g3b6b61a2lbaa4332e2aa01967@mail.gmail.com>

On Mon, Sep 8, 2008 at 7:07 PM, Steve Howell <showell30 at yahoo.com> wrote:

...

> Most of us learn to read before we write, so I'm not so sure it's necessarily a bad thing to introduce OO to students as consumers before they become producers.  On the other hand, I totally understand your desire to have students write their own objects from the beginning.
>

Yes agreed, big difference between "recall" and "recognition" when
learning a language, including a human one like Spanish or English,
and it's important to eyeball mature code long before it's important
to write such code to a blank canvas, a much more daunting
proposition.

So yes, I believe in "scaffolding", by which I mean canned or
pre-written code, designed to get students comfortable with the look
and feel of this language, which may seem quite alien (worse than
Klingon) to start with.

But it's still easier than J, I would contend (another language we
might look at, as I believe in at least glancing at mind-expanding
examples from outside whatever core language, if we agree that there
is one -- could be projected content, nothing installed on each
student computer).

> What's an example of a small Python program that your students have written that uses objects that they built?  Do they start with model/view/controller objects or otherwise?
>

I've experimented with different techniques but one of my current
favorites is to define a Snake class with a stomach, a method for
birth (__init__), eating, and maybe elimination in a second (more
complicated) example.  __repr__ also defined and explained.

You may not be aware of my tendency to call special names __ribs__
inside an "everything is a Snake in Python" by which I mean some kind
of object, like an animal (special names look like ribs).  Per many
posts to this list, I take a zoomorphic approach to OO, as I'm
assuming your average student likes thinking in terms of animals.

Another rhetorical ploy is to make the first class definition Biotum,
again with an eat method, the idea being that primitive objects like
lists and dictionaries are more like "proteins" (building blocks),
whereas the Biotum marks the first time we need a "self" concept
(something to anchor "this instance" versus "that instance").
Functions are in between, more like organs or organelles, turning into
methods when absorbed into this higher life form.

I'll go through all this quickly on the first day (presuming a class),
then go over it again much more slowly, spending a lot of time with
functions especially.  I'm somewhat inclined to do generators early as
well, as I find them a small step from functions, just replace return
with yield and make it a loop of some kind.

When working with math teachers, it's all about functions as well,
including figurate and polyhedral number sequences per AT&T's On-Line
Encyclopedia of Integer Sequences, e.g. a first function might be def
cubocta( f ):  return 10 * f * f + 2, which has to do with one of the
more important lattices in the sciences:
http://www.research.att.com/~njas/sequences/A005901 (you'll find my
name in the links section).

>
>> As I mention in my Chicago talk, I tell my students
>> "I've never heard
>> of procedural programming, it gives me the creeps" but
>> that's just a
>> rhetorical device to get the ball rolling, as I start with
>> dot
>> notation immediately, within the first 10 minutes.
>
> Do students ever get confused by the dot notation, or at least frustrated with the wordiness?

I'm sure that they do, but a higher priority is to decipher the
mysteries of this weird grammar, with all these __ribs__ and dots and
whatever.  One of our first exercises is to go dir( 1 ), just to show
that even primitive numbers "know a lot" i.e. have internalized
structure as objects (are like snakes in that sense).

My pitch to the math teachers is it's time to recognize "dot notation"
as part of our basic math notation, now that these several languages
have implemented it somewhat consistently (Javascript included).  This
prejudice against executable notations being "not mathematical" is
what I'd call a prejudice, or superstition.

>
>> But
>> that's because
>> I'm teaching core Python, not another language
>> *implemented* in core
>> Python.  These aren't little children.
>>
>
> I think it's great that you have students who are ready to jump right into core Python, but I don't think you have to be a little child to benefit from small languages like Karel, Logo, and various cousins.   When I was in college, lots of non-CS students got exposed to programming through Karel and got a lot out of it.  That was nearly 20 years ago, so I'm sure today's generation comes in with a little more sophistication, but I still see the benefit of starting with a language with very limited syntax.
>

Yes, agreed.  Also since the last OSCON I've developed new respect for
Scratch from MIT.
http://scratch.mit.edu/

Nat Torkington was talking this up during his keynote (different from
the Nat I said hi to recently re phidgets (above)).

> Even if you have a bit of programming background coming into a small language, it can still be a really refreshing exercise to work within its limitations.  One of the funnest programs I ever wrote was to have Karel determine whether his beeper world was palindromic.  Try to do that without variables!
>

Yes, no reason we have to start with Python, or even if we do, no
reason we can't move to these others in addition.

> Getting back to little children, though, I do think there will come a day where smaller children learn to program as easily as they learn reading, writing, arithmetic, music, etc.
>

Maybe.  I'm thinking it's more like piano, where some will feel drawn,
some will be prodigies, others will have burdensome geek parents who
insist that Sally or Johnny start writing Perl at age 6, come hell or
high water.  I can't prevent these abuses, just go on record with my
view that there's no huge rush to get into it, take your time -- but
if you love it, you love it.

Kirby

From ianb at colorstudy.com  Tue Sep  9 18:21:59 2008
From: ianb at colorstudy.com (Ian Bicking)
Date: Tue, 09 Sep 2008 11:21:59 -0500
Subject: [Edu-sig] Webster Van Robot
In-Reply-To: <248610.80130.qm@web33507.mail.mud.yahoo.com>
References: <248610.80130.qm@web33507.mail.mud.yahoo.com>
Message-ID: <48C6A2A7.5080207@colorstudy.com>

Steve Howell wrote:
> There are some object-oriented variants of Karel the Robot:
> 
> http://pclc.pace.edu/~bergin/karel.html
> 
> Guido van Robot and Webster van Robot are purely procedural, which
> has the following benefits:
> 
> 1) There's a lot less typing, which means more time for thinking,
> exploring, etc. 2) You can master simple, but fundamental, concepts
> like creating methods and nesting loops without the conceptual
> overhead of object-oriented programming.
> 
> I would love to brainstorm ideas on creating a path from GvR and WvR
> to more object-oriented programming.  IMHO you need to make sure you
> do it in a non-superficial way.  For example, I would want your
> object space to be rich enough that you actually have objects that
> interface with each other.

The way it usually is presented in Logo is like:

   TELL :robot [FD 10]

That is, you have some actors (activated with TELL), and you have 
commands, and the commands are passed to the actors.  There's a default 
actor.  Like everything else in logo, it is dynamically scoped, not 
lexically, which makes methods and functions less distinct.  That is, if 
you do:

   TO SQUARE :size
     REPEAT 4 [FD :size RT 90]
   END
   TELL :robot [SQUARE 100]

then even though SQUARE is a procedure, it uses FD, and FD is a method. 
  Or, something like a method.

Anyway, it's not exactly applicable to Python, though it could be. 
Here's a factoring of turtles:

class active_method(object):
     def __init__(self, func):
         self.func = func
     def __get__(self, obj, type=None):
         if obj is None:
             # Maybe with some default too, like the turtle module lazily
             # creates an instance
             obj = type.active_turtles[-1]
         return new.instancemethod(self.func, obj, type)

class Pen(turtle.Pen):
     active_objects = []
     def __enter__(self):
         self.__class__.active_objects.append(self)
         return self
     def __exit__(self):
         active = self.__class__.active_objects
         assert active[-1] is self
         active.pop()
     @active_method
     def fd(self):
         whatever fd does...
     ... and so one, with more @active_method...

fd = Pen.fd
... and again, for every method ...

def square(size):
     for i in range(4):
         fd(size)
         rt(90)

with Pen():
     setxy(100, 10)
     square()

-- 
Ian Bicking : ianb at colorstudy.com : http://blog.ianbicking.org

From kirby.urner at gmail.com  Tue Sep  9 21:12:54 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Tue, 9 Sep 2008 12:12:54 -0700
Subject: [Edu-sig] Integrated Studies (long)
Message-ID: <f604188c0809091212l17331407mc6c2816695f0031e@mail.gmail.com>

Polyhedra, Python, and SQL

I'm archiving all the data and source code sufficient to start
outputting colorful polyhedra to screen, using the aforementioned 26
"points of interest" A-Z, and a Facets table giving each polyhedron's
faces by going around in sequence, in terms of these 26 labels, the
x,y,z coordinates supplied in a Vectors table.

For example, a Tetrahedron ABCD has facets [(A,B,C), (A,C,D), (A,D,B),
(B,C,D)].  Ordering matters within a facet (we're hopping around a
face, like a fenced yard with fence posts), so the Facets table has a
vertex_id column to keep them in order, within facet_id.  You'll find
an ORDER BY vertex_id in the source code below.

The code below takes the name of a shape and uses the newgeom database to:
(a) pull up the facets, given the short name of a polyhedron
(b) distill unique edges from those facets and
(c) draw those edges to a VPython window.

Why "distill unique edges"?  Because going around each face
effectively gives each edge twice.  For example, our Tetrahedron
(above) has edges (A,B), (B,C), (C,A) per the first face (A,B,C).
Those edges will come up again as we distill (A,C), (C,D) and (D,A)
from the next face and so on.

By keeping all edge-tuples internally alphabetical, we keep (C,A) and
(A,C) from appearing unique, and therefore might use the 'set' data
structure to weed out the duplicates (trying to add (A,C) a second
time has no effect).

One way to distill edges from say face (A,B,C) is to zip ((A,B,C) ,
(B,C,A)) i.e. put the first vertex last in a second copy of the face,
to get pairs (A,B), (B,C) and (C,A) as above, but sorting
alphabetically, turning (C,A) into (A,C).

You'll see a list comprehension in getedges that does precisely this.
f[1:]+[f[0]] is the syntax for turning a list into a rotated version
of itself i.e. if f = [A, B, C] then the result is [B, C, A] (see
below).

The idea here is enterprising GnuMath teachers using this as tweakable
scaffolding.

Even a beginning student can start changing the color, reloading the
module, and redrawing a polyhedron, all interactively via the shell
(remember to restart after closing the VPython window, automatic in
IDLE, but not in Wing 101, which I'm currently using).

There's a lot going on here, i.e. this is a dense packing of a lot of
ideas, meaning student should find it rewarding and relevant, plus the
eye candy is pretty fun (even better with enhancements).

Kirby


#===============

from pysqlite2 import dbapi2 as sqlite
from visual import cylinder, color, vector

conn = sqlite.connect("newgeom")
curr = conn.cursor()


def drawpoly(shape):

    edges = getedges(shape)
    for a, b in edges:
        SELECT = """
        select x,y,z from vectors where label = ?
        """
        x,y,z = curr.execute(SELECT, (a,)).fetchone()
        v0 = vector(x,y,z)

        x,y,z = curr.execute(SELECT, (b,)).fetchone()
        v1 = vector(x,y,z)

        cyl=cylinder(pos=v0, axis=v1-v0,
                     radius= 0.01, color = color.red)

def getedges(shape):

    edgeset = set()  # need to weed out dupes

    SELECT = """
    select faces from polyhedra
    where shortname = ?
    """
    result = curr.execute(SELECT, (shape,))
    num_faces = result.fetchone()[0]

    for i in range(num_faces):
        f = list(getfaces(shape, i))
        edges = [tuple( sorted((i[1],j[1])))
                  for i,j in zip(f, f[1:]+[f[0]]) ]
        for e in edges:
            edgeset.add(e) # tuples hashable

    return edgeset


def getfaces(shape, facet_id):

    SELECT = """
    select vertex_id, label
    from facets
    where facet_id = ? and shortname = ?
    order by vertex_id"""

    return curr.execute(SELECT, (facet_id, shape))

#===============


Here are the three table schemas, amenable to tweaking (per type, keys etc.):

sqlite> .schema Polyhedra
CREATE TABLE Polyhedra (
	greekname CHAR PRIMARY KEY,
	shortname CHAR NOT NULL,
	vertices NUMERIC NOT NULL,
	edges NUMERIC NOT NULL,
	faces NUMERIC NOT NULL,
	volume NUMERIC NOT NULL);

sqlite> .schema Vectors
CREATE TABLE Vectors (
	label CHAR,
	x NUMERIC,
	y NUMERIC,
	z NUMERIC);

sqlite> .schema Facets
CREATE TABLE Facets (
	shortname CHAR,
	facet_id NUMERIC,
	vertex_id NUMERIC,
	label CHAR);


Here's the raw contents of the three tables, suitable for importing:

sqlite> select * from polyhedra;
Tetrahedron,tetra,4,6,4,1
Hexahedron,cube,8,12,6,3
Octahedron,octa,6,12,8,4
"Rhombic Dodecahedron",cell,14,24,12,6
Cuboctahedron,cubocta,12,24,14,20

sqlite> select * from vectors;
Z,0.707106781186547,0.707106781186547,0
A,0.353553390593274,0.353553390593274,0.353553390593274
C,-0.353553390593274,0.353553390593274,-0.353553390593274
B,-0.353553390593274,-0.353553390593274,0.353553390593274
E,-0.353553390593274,-0.353553390593274,-0.353553390593274
D,0.353553390593274,-0.353553390593274,-0.353553390593274
G,0.353553390593274,-0.353553390593274,0.353553390593274
F,0.353553390593274,0.353553390593274,-0.353553390593274
I,0,0,0.707106781186547
H,-0.353553390593274,0.353553390593274,0.353553390593274
K,0.707106781186547,0,0
J,0,0.707106781186547,0
M,0,-0.707106781186547,0
L,-0.707106781186547,0,0
O,0,0.707106781186547,0.707106781186547
N,0,0,-0.707106781186547
Q,-0.707106781186547,0,0.707106781186547
P,0.707106781186547,0,0.707106781186547
S,0,0.707106781186547,-0.707106781186547
R,0,-0.707106781186547,0.707106781186547
U,-0.707106781186547,0,-0.707106781186547
T,0.707106781186547,0,-0.707106781186547
W,-0.707106781186547,0.707106781186547,0
V,0,-0.707106781186547,-0.707106781186547
Y,0.707106781186547,-0.707106781186547,0
X,-0.707106781186547,-0.707106781186547,0

sqlite> select * from facets;
tetra,0,0,A
tetra,0,1,B
tetra,0,2,C
tetra,1,0,A
tetra,1,1,C
tetra,1,2,D
tetra,2,0,A
tetra,2,1,D
tetra,2,2,B
tetra,3,0,B
tetra,3,1,C
tetra,3,2,D
cube,0,0,A
cube,0,1,H
cube,0,2,C
cube,0,3,F
cube,1,0,A
cube,1,1,H
cube,1,2,B
cube,1,3,G
cube,2,0,B
cube,2,1,E
cube,2,2,C
cube,2,3,H
cube,3,0,B
cube,3,1,E
cube,3,2,D
cube,3,3,G
cube,4,0,D
cube,4,1,G
cube,4,2,A
cube,4,3,F
cube,5,0,C
cube,5,1,E
cube,5,2,D
cube,5,3,F
octa,0,0,I
octa,0,1,J
octa,0,2,K
octa,1,0,I
octa,1,1,L
octa,1,2,M
octa,2,0,I
octa,2,1,J
octa,2,2,L
octa,3,0,I
octa,3,1,M
octa,3,2,K
octa,4,0,N
octa,4,1,J
octa,4,2,K
octa,5,0,N
octa,5,1,K
octa,5,2,M
octa,6,0,N
octa,6,1,M
octa,6,2,L
octa,7,0,N
octa,7,1,L
octa,7,2,J
cell,0,0,N
cell,0,1,F
cell,0,2,J
cell,0,3,C
cell,1,0,N
cell,1,1,F
cell,1,2,K
cell,1,3,D
cell,2,0,N
cell,2,1,D
cell,2,2,M
cell,2,3,E
cell,3,0,N
cell,3,1,C
cell,3,2,L
cell,3,3,E
cell,4,0,I
cell,4,1,A
cell,4,2,J
cell,4,3,H
cell,5,0,I
cell,5,1,H
cell,5,2,L
cell,5,3,B
cell,6,0,I
cell,6,1,B
cell,6,2,M
cell,6,3,G
cell,7,0,I
cell,7,1,G
cell,7,2,K
cell,7,3,A
cell,8,0,K
cell,8,1,F
cell,8,2,J
cell,8,3,A
cell,9,0,K
cell,9,1,D
cell,9,2,M
cell,9,3,G
cell,10,0,M
cell,10,1,B
cell,10,2,L
cell,10,3,E
cell,11,0,L
cell,11,1,C
cell,11,2,J
cell,11,3,H
cubocta,0,0,O
cubocta,0,1,Q
cubocta,0,2,W
cubocta,1,0,O
cubocta,1,1,Z
cubocta,1,2,P
cubocta,2,0,P
cubocta,2,1,R
cubocta,2,2,Y
cubocta,3,0,R
cubocta,3,1,Q
cubocta,3,2,X
cubocta,4,0,W
cubocta,4,1,S
cubocta,4,2,U
cubocta,5,0,U
cubocta,5,1,X
cubocta,5,2,V
cubocta,6,0,Y
cubocta,6,1,T
cubocta,6,2,V
cubocta,7,0,Z
cubocta,7,1,T
cubocta,7,2,S
cubocta,8,0,O
cubocta,8,1,P
cubocta,8,2,R
cubocta,8,3,Q
cubocta,9,0,O
cubocta,9,1,W
cubocta,9,2,S
cubocta,9,3,Z
cubocta,10,0,Q
cubocta,10,1,W
cubocta,10,2,U
cubocta,10,3,X
cubocta,11,0,P
cubocta,11,1,Z
cubocta,11,2,T
cubocta,11,3,Y
cubocta,12,0,R
cubocta,12,1,X
cubocta,12,2,V
cubocta,12,3,Y
cubocta,13,0,T
cubocta,13,1,S
cubocta,13,2,U
cubocta,13,3,V
sqlite>

From kirby.urner at gmail.com  Wed Sep 10 00:05:07 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Tue, 9 Sep 2008 15:05:07 -0700
Subject: [Edu-sig] Integrated Studies (long)
In-Reply-To: <f604188c0809091212l17331407mc6c2816695f0031e@mail.gmail.com>
References: <f604188c0809091212l17331407mc6c2816695f0031e@mail.gmail.com>
Message-ID: <f604188c0809091505u1980493ckb04a9328199be9ce@mail.gmail.com>

Teacher Notes:

On Tue, Sep 9, 2008 at 12:12 PM, kirby urner <kirby.urner at gmail.com> wrote:

<< SNIP >>

> For example, a Tetrahedron ABCD has facets [(A,B,C), (A,C,D), (A,D,B),
> (B,C,D)].  Ordering matters within a facet (we're hopping around a
> face, like a fenced yard with fence posts), so the Facets table has a
> vertex_id column to keep them in order, within facet_id.  You'll find
> an ORDER BY vertex_id in the source code below.

If you're doing the Oregon Curriculum group theory segments, then
you'll recognize a link here to "cyclic notation", a way to encode
permutations, e.g. letters A-Z to some other sort thereof.  Many
textbooks use numbers.

So like if I write ((1, 4, 3), (2)), that means 1 -> 4, 2 -> 2, 3 ->
1, 4 -> 3 where -> is an "ascii arrow" meaning "maps to".

The J language has a primitive verb for doing cyclic notation:

http://jsoftware.com/help/dictionary/dccapdot.htm

> You'll see a list comprehension in getedges that does precisely this.
> f[1:]+[f[0]] is the syntax for turning a list into a rotated version
> of itself i.e. if f = [A, B, C] then the result is [B, C, A] (see
> below).

This is where exercises with "little lambda" might be fun, Python's
light-weight "anonymous function", a tip of the hat to the LISP &
Scheme family, which make lambda an animal worthy of worship, i.e. a
much bigger deal (but then we have snakes to be proud of).

>>> func = lambda thelist: thelist[1:] + [thelist[0]]
>>>
>>> func(['A','B','C','D'])
['B', 'C', 'D', 'A']

Of course naming it func somewhat defeats the whole purpose of keeping
it anonymous, not that lambda isn't itself a name, for a greek letter.

>
> The idea here is enterprising GnuMath teachers using this as tweakable
> scaffolding.
>
> Even a beginning student can start changing the color, reloading the
> module, and redrawing a polyhedron, all interactively via the shell
> (remember to restart after closing the VPython window, automatic in
> IDLE, but not in Wing 101, which I'm currently using).

VPython lets you build colors with RGB values, so this would be a good
time for a segment on that, if students seem clueless.

But you've also got the built-in colors to start, so if really
beginners, maybe don't bore them with yet more details before letting
them dive in, getting their hands "dirty".  You could also assign each
Polyhedron a default color in the master table, or a separate face,
vertex and edge color.  Go wild.

>>> from visual import color
>>> dir ( color )
['__builtins__', '__doc__', '__file__', '__name__', 'black', 'blue',
'colorsys', 'cyan', 'green', 'hsv_to_rgb', 'magenta', 'orange', 'red',
'rgb_to_hsv', 'white', 'yellow']

You'd think someone would add to this list in the original package, or
maybe I just have an old version.  I agree with Arthur that VPython is
an important asset, an inspiration for future packages and/or newer
versions of itself.

Note that in Python 3.0 we have to unpack reload from the imp "suitcase":

>>> from imp import reload

But as of this writing in late 2008, there wasn't a pysqlite driver
for Python 3.0.

>>> import sqlpolys
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    import sqlpolys
  File "/home/kirby/sqlpolys.py", line 1, in <module>
    from pysqlite2 import dbapi2 as sqlite
ImportError: No module named pysqlite2

However, there was APSW (Another Python Sqlite Wrapper) that did have
3.0 capability:
http://code.google.com/p/apsw/

> There's a lot going on here, i.e. this is a dense packing of a lot of
> ideas, meaning student should find it rewarding and relevant, plus the
> eye candy is pretty fun (even better with enhancements).
>
> Kirby

If you get through all this and they're hungry for more, consider
using a string.Template approach to building a POV-Ray file, start
adding facets as polygons, do more with vertices etc.

You'll find lots in the Oregon Curriculum to help you down this road,
if that's the road you choose.

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

Or reimplement in APSW as an exercise?

Kirby

From gef at ceid.upatras.gr  Wed Sep 10 14:41:35 2008
From: gef at ceid.upatras.gr (Fotis Georgatos)
Date: Wed, 10 Sep 2008 15:41:35 +0300
Subject: [Edu-sig] fyi. a published thesis, use of Python in class
Message-ID: <bf7bdf9f0809100541k6c7b4a30l18f37c82d948ab08@mail.gmail.com>

Hello *,

since I occasionaly get people interested in my MSc thesis
that was written long ago (2002) - people even reference it but,
it's rather hard to get the original being somewhere in Amsterdam -
I hereby inform you of its electronic presence at arxiv.org:

arXiv:0809.1437 [pdf]
    Title: How applicable is Python as first computer language for
teaching programming in a pre-university educational environment, from
a teacher's point of view?
    Authors: Fotis Georgatos
    Comments: 135 pages, 20 tables, 10 figures (incl. evolution of
computer languages)
    Subjects: Programming Languages (cs.PL); Computers and Society (cs.CY)

Abstract:
This project report attempts to evaluate the educational properties of
the Python computer language, in practice. This is done by examining
computer language evolution history, related scientific background
work, the existing educational research on computer languages and
Python's experimental application in higher secondary education in
Greece, during first half of year 2002. This Thesis Report was
delivered in advance of a thesis defense for a Masters/Doctorandus
(MSc/Drs) title with the Amstel Institute/Universiteit van Amsterdam,
during the same year.



I hope it might help some of you, because I've found that material of
documented application
of the Python language in class still appears a bit scarce...

ps.
Some people might just enjoy the (anecdotal) information on other languages.

cheers,
Fotis

From kirby.urner at gmail.com  Wed Sep 10 16:48:34 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Wed, 10 Sep 2008 07:48:34 -0700
Subject: [Edu-sig] Fwd:  fyi. a published thesis, use of Python in class
In-Reply-To: <f604188c0809100746r4e27b720r4fee3e95ab08c6fc@mail.gmail.com>
References: <bf7bdf9f0809100541k6c7b4a30l18f37c82d948ab08@mail.gmail.com>
	<f604188c0809100746r4e27b720r4fee3e95ab08c6fc@mail.gmail.com>
Message-ID: <f604188c0809100748v4f5a5638q1d6ea0ba9b278148@mail.gmail.com>

I don't manage the edu-sig web page any more, for python.org, but
could see where a link to this thesis would look handsome right next
to bullet 5:  "John Miller's PhD dissertation, Promoting Computer
Literacy Through Programming Python (1.37 MB), looks at the issues
around teaching with Python, and explores some of the threads taken up
on edu-sig."

Kirby



---------- Forwarded message ----------
From: kirby urner <kirby.urner at gmail.com>
Date: Wed, Sep 10, 2008 at 7:46 AM
Subject: Re: [Edu-sig] fyi. a published thesis, use of Python in class
To: Fotis Georgatos <gef at ceid.upatras.gr>


On Wed, Sep 10, 2008 at 5:41 AM, Fotis Georgatos <gef at ceid.upatras.gr> wrote:

<< SNIP >>

> I hope it might help some of you, because I've found that material of
> documented application
> of the Python language in class still appears a bit scarce...

Thank you Fotis, I have been reading this all morning, had not seen it
before.  Thank you for bringing it to my attention.

I've mostly documented by classroom work in my blogs, but usually in
connection with Saturday Academy, which doesn't compete to offer
transferable credits, only skills and its own credential, which does
count for something.  This is not the same as having an established
state school recognize Python as a good learning language.  I salute
the Pedagogical Institute for having some vision.

Kirby

>
> ps.
> Some people might just enjoy the (anecdotal) information on other languages.
>
> cheers,
> Fotis
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig
>

From macquigg at ece.arizona.edu  Wed Sep 10 17:43:41 2008
From: macquigg at ece.arizona.edu (David MacQuigg)
Date: Wed, 10 Sep 2008 08:43:41 -0700
Subject: [Edu-sig] Network Simulations using Python
Message-ID: <5.2.1.1.0.20080910081205.02c757a8@plus.pop.mail.yahoo.com>

I'm putting together some problems for students in ECE 578, Computer Networks.  The simulator being used in the class is truly awful, one of these expensive commercial programs, dumbed down for academic use, but still loaded with the non-essential complexity typical of programs written for full-time professionals. 

It occurs to me that Python would be a much better tool for what we are doing.  The objects in a network are easily modeled as Python objects, and students gain a much better understanding when they see what is inside the objects, rather than just picking them off a menu, and using them as black boxes.

Take a look at http://ece.arizona.edu/~edatools/ece578/Ethernet/   The Python program is still in its early stages.  Next step is to "refactor" it, making the main program a Network object, so we can run it in a loop.

Comments and suggestions are welcome, especially for more clarity in the Python code.  Python is still not used in any class at U of A, and this could be one of our shining examples to get it started.



From vceder at canterburyschool.org  Wed Sep 10 17:51:00 2008
From: vceder at canterburyschool.org (Vern Ceder)
Date: Wed, 10 Sep 2008 11:51:00 -0400
Subject: [Edu-sig] Fwd:  fyi. a published thesis, use of Python in class
In-Reply-To: <f604188c0809100748v4f5a5638q1d6ea0ba9b278148@mail.gmail.com>
References: <bf7bdf9f0809100541k6c7b4a30l18f37c82d948ab08@mail.gmail.com>	<f604188c0809100746r4e27b720r4fee3e95ab08c6fc@mail.gmail.com>
	<f604188c0809100748v4f5a5638q1d6ea0ba9b278148@mail.gmail.com>
Message-ID: <48C7ECE4.9070601@canterburyschool.org>

kirby urner wrote:
> I don't manage the edu-sig web page any more, for python.org, but
> could see where a link to this thesis would look handsome right next
> to bullet 5:  "John Miller's PhD dissertation, Promoting Computer
> Literacy Through Programming Python (1.37 MB), looks at the issues
> around teaching with Python, and explores some of the threads taken up
> on edu-sig."
> 
> Kirby

+1

Vern



> ---------- Forwarded message ----------
> From: kirby urner <kirby.urner at gmail.com>
> Date: Wed, Sep 10, 2008 at 7:46 AM
> Subject: Re: [Edu-sig] fyi. a published thesis, use of Python in class
> To: Fotis Georgatos <gef at ceid.upatras.gr>
> 
> 
> On Wed, Sep 10, 2008 at 5:41 AM, Fotis Georgatos <gef at ceid.upatras.gr> wrote:
> 
> << SNIP >>
> 
>> I hope it might help some of you, because I've found that material of
>> documented application
>> of the Python language in class still appears a bit scarce...
> 
> Thank you Fotis, I have been reading this all morning, had not seen it
> before.  Thank you for bringing it to my attention.
> 
> I've mostly documented by classroom work in my blogs, but usually in
> connection with Saturday Academy, which doesn't compete to offer
> transferable credits, only skills and its own credential, which does
> count for something.  This is not the same as having an established
> state school recognize Python as a good learning language.  I salute
> the Pedagogical Institute for having some vision.
> 
> Kirby
> 
>> ps.
>> Some people might just enjoy the (anecdotal) information on other languages.
>>
>> cheers,
>> Fotis
>> _______________________________________________
>> Edu-sig mailing list
>> Edu-sig at python.org
>> http://mail.python.org/mailman/listinfo/edu-sig
>>
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig

-- 
This time for sure!
    -Bullwinkle J. Moose
-----------------------------
Vern Ceder, Director of Technology
Canterbury School, 3210 Smith Road, Ft Wayne, IN 46804
vceder at canterburyschool.org; 260-436-0746; FAX: 260-436-5137

From andre.roberge at gmail.com  Wed Sep 10 18:00:17 2008
From: andre.roberge at gmail.com (Andre Roberge)
Date: Wed, 10 Sep 2008 13:00:17 -0300
Subject: [Edu-sig] Network Simulations using Python
In-Reply-To: <5.2.1.1.0.20080910081205.02c757a8@plus.pop.mail.yahoo.com>
References: <5.2.1.1.0.20080910081205.02c757a8@plus.pop.mail.yahoo.com>
Message-ID: <7528bcdd0809100900l56f119a6occ10d9fc17c28b18@mail.gmail.com>

On Wed, Sep 10, 2008 at 12:43 PM, David MacQuigg
<macquigg at ece.arizona.edu> wrote:
> I'm putting together some problems for students in ECE 578, Computer Networks.  The simulator being used in the class is truly awful, one of these expensive commercial programs, dumbed down for academic use, but still loaded with the non-essential complexity typical of programs written for full-time professionals.
>
> It occurs to me that Python would be a much better tool for what we are doing.  The objects in a network are easily modeled as Python objects, and students gain a much better understanding when they see what is inside the objects, rather than just picking them off a menu, and using them as black boxes.
>
> Take a look at http://ece.arizona.edu/~edatools/ece578/Ethernet/   The Python program is still in its early stages.  Next step is to "refactor" it, making the main program a Network object, so we can run it in a loop.
>
> Comments and suggestions are welcome, especially for more clarity in the Python code.  Python is still not used in any class at U of A, and this could be one of our shining examples to get it started.
>

Sorry no comment about the code (yet...).  Perhaps it would also be
suitable to send this to the python tutor list.  They tend to provide
a lot more feedback of the type you're asking than one typically gets
here.

And I don't mean this in a negative way about discussions on this
list; just pointing out the different focus...

Andr?

>
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig
>

From goldwamh at slu.edu  Wed Sep 10 18:13:47 2008
From: goldwamh at slu.edu (Michael H. Goldwasser)
Date: Wed, 10 Sep 2008 11:13:47 -0500
Subject: [Edu-sig]  Network Simulations using Python
In-Reply-To: <5.2.1.1.0.20080910081205.02c757a8@plus.pop.mail.yahoo.com>
References: <5.2.1.1.0.20080910081205.02c757a8@plus.pop.mail.yahoo.com>
Message-ID: <18631.62011.296274.126325@gargle.gargle.HOWL>


On Wednesday September 10, 2008, David MacQuigg wrote: 

>    It occurs to me that Python would be a much better tool for what we are doing.  The objects in a network are easily modeled as Python objects, and students gain a much better understanding when they see what is inside the objects, rather than just picking them off a menu, and using them as black boxes.

Dave brings up this great idea about using Python to develop network
simulators.  A related issue is that it is possible to use Python in a
networks course for manipulating the actual network components
(e.g. sockets, pipes, clients, servers).   It certainly is easier to
do that type of programming with Python's libraries when compared to
the traditional approach done in C.

At first glance I see a couple of nice tutorials to this end in
academia targeting upper-level networks courses:

    http://ilab.cs.byu.edu/python
    http://heather.cs.ucdavis.edu/~matloff/Python/PyNet.pdf

In fact network programming in Python is so easy we've done units on
it at the CS1 level. A discussion of our approach appeared at ITICSE
2007 in a paper titled "Introducing Network Programming into a CS1
Course." 

That paper can be downloaded at  http://cs.slu.edu/~goldwasser/publications
and more complete teaching materials from that unit appear in Chapter 14
of our text.

With regard,
Michael



       +-----------------------------------------------
       | Michael Goldwasser
       | Associate Professor
       | Dept. Mathematics and Computer Science
       | Saint Louis University
       | 220 North Grand Blvd.
       | St. Louis, MO 63103-2007
       |
       | Office: Ritter Hall 6
       | Email:  goldwamh at slu.edu
       | URL:    http://cs.slu.edu/~goldwasser
       | Phone:  (314) 977-7039
       | Fax:    (314) 977-1452


From gef at ceid.upatras.gr  Wed Sep 10 18:59:36 2008
From: gef at ceid.upatras.gr (Fotis Georgatos)
Date: Wed, 10 Sep 2008 19:59:36 +0300
Subject: [Edu-sig] fyi. a published thesis, use of Python in class
In-Reply-To: <f604188c0809100746r4e27b720r4fee3e95ab08c6fc@mail.gmail.com>
References: <bf7bdf9f0809100541k6c7b4a30l18f37c82d948ab08@mail.gmail.com>
	<f604188c0809100746r4e27b720r4fee3e95ab08c6fc@mail.gmail.com>
Message-ID: <bf7bdf9f0809100959heb73b74w84e1bef6a466f4ad@mail.gmail.com>

Hello Kirby et al,

On Wed, Sep 10, 2008 at 5:46 PM, kirby urner <kirby.urner at gmail.com> wrote:
> Thank you Fotis, I have been reading this all morning, had not seen it
> before.  Thank you for bringing it to my attention.

My pleasure :)

I just figured I haven't provided a URL for the .pdf document, too;
so, here it is:
http://arxiv.org/pdf/0809.1437v1

> I've mostly documented by classroom work in my blogs, but usually in
> connection with Saturday Academy, which doesn't compete to offer
> transferable credits, only skills and its own credential, which does
> count for something.  This is not the same as having an established
> state school recognize Python as a good learning language.  I salute
> the Pedagogical Institute for having some vision.

In the name of accuracy, I'd like to point out that the Pedagogical Institute
hasn't given a blessing -or contempt- about using the language at large scale.
To their tribute though, they did grant license early on to conduct the research
in the real environment, and there are sharp individuals there that understood
the benefits very quickly; as well as the few colleagues that went all along.
So, what happened under their auspices and guidance was the experiment.
But, having people willing to experiment in an area that is new and unknown,
and even do that in a fearless yet considerating way, yes, that was vision.

I hope now that the OLPC is a standard topic in the educational community
and Python has got much extra publicity and popularity because of it,
people here and elsewhere will be more willing to consider it as a
learning vehicle.
I'm not claiming that a transition to Python is going to happen quickly but,
if I saw educators having it as a bold item in their mind, that would
be progress!

I wonder which country/ies would dare put the language as a recommendation
in their country-wide curriculum, do we have any firsts in this area?

cheers,
Fotis

From kirby.urner at gmail.com  Fri Sep 12 05:49:04 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Thu, 11 Sep 2008 20:49:04 -0700
Subject: [Edu-sig] Repositioning SQL within K-16
In-Reply-To: <f604188c0808170910q48b1cf03i3d8939a41efa16be@mail.gmail.com>
References: <f604188c0808170910q48b1cf03i3d8939a41efa16be@mail.gmail.com>
Message-ID: <f604188c0809112049x365c295dw44bef58265362caa@mail.gmail.com>

On Sun, Aug 17, 2008 at 9:10 AM, kirby urner <kirby.urner at gmail.com> wrote:

<< SNIP >>

> So in math class we're maybe more interested in the duals table
> (relates each poly to its unique dual) and the XYZ coordinates, if
> that's how they're stored...
>

K-16 features many gentle on-ramps, which individual students will
sample, staying on some, getting off others.

SQL starts out with simple SELECTs against pre-existing tables.

In our 10th grade geometry class, we learn the "dual" of a polyhedra
is obtained by turning faces into corners (vertices), vertices into
faces, leaving the number of edges alone (V + F = E + 2).

So if we wanted to list duals in our Polyhedra table as a saved view,
we could do something like:

#===

from pysqlite2 import dbapi2 as sqlite

conn = sqlite.connect("newgeom")
curr = conn.cursor()

curr.execute("DROP VIEW duals;")

VIEW = """create view duals as
select a.shortname, b.shortname
from polyhedra a, polyhedra b
where a.faces = b.vertices
and a.vertices = b.faces
and a.edges = b.edges;
"""

curr.execute(VIEW)
conn.commit()

for row in curr.execute("select * from duals").fetchall():
    print row[0], "is the dual of", row[1]

#===

To get:

>>>
tetra is the dual of tetra
cube is the dual of octa
octa is the dual of cube
cell is the dual of cubocta
cubocta is the dual of cell

Note that "cell" is my short name for the rhombic dodecahedron, a
space-filling shape fascinating to Kepler.

Note also that sqlite3 has native html tabular output, something to
play with (cut and paste while projecting, view in browser
perhaps?)...

Of course there's this prejudice that XML is not a math topic, but
pre-college we're less strict about the difference between bread and
butter numeracy and "pure math", want to show semi-structure data in
tree format.

Poet Gene Fowler, author of eWriter, always maintained that XHTML
should be studied under the heading of punctuation, i.e. while you're
learning about colons, commas and semi-colons, learn pointy bracket
markup as well.  As such, we might push HTML over to grammar teachers,
but then computer languages have grammar, so they might push right
back.

The bottom line is if teachers feel these are hot potato topics, then
they become no one's responsibility, whereas if they're seen as
excitingly relevant, as injecting new life into tired material, then
we're looking at a bonanza, with plenty to go around.

All we need is that army of curriculum writers ready to tackle the
content in an open source manner -- what I see happening on the Web,
slowly but surely, including on Youtube, fun:
http://www.youtube.com/watch?v=40Lnoyv-sXg
sqlite> .schema polyhedra
CREATE TABLE Polyhedra (
	greekname CHAR PRIMARY KEY,
	shortname CHAR NOT NULL,
	vertices NUMERIC NOT NULL,
	edges NUMERIC NOT NULL,
	faces NUMERIC NOT NULL,
	volume NUMERIC NOT NULL);

sqlite> .mode html

sqlite> select * from polyhedra;
<TR><TD>Tetrahedron</TD>
<TD>tetra</TD>
<TD>4</TD>
<TD>6</TD>
<TD>4</TD>
<TD>1</TD>
</TR>
<TR><TD>Hexahedron</TD>
<TD>cube</TD>
<TD>8</TD>
<TD>12</TD>
<TD>6</TD>
<TD>3</TD>
</TR>
<TR><TD>Octahedron</TD>
<TD>octa</TD>
<TD>6</TD>
<TD>12</TD>
<TD>8</TD>
<TD>4</TD>
</TR>
<TR><TD>Rhombic Dodecahedron</TD>
<TD>cell</TD>
<TD>14</TD>
<TD>24</TD>
<TD>12</TD>
<TD>6</TD>
</TR>
<TR><TD>Cuboctahedron</TD>
<TD>cubocta</TD>
<TD>12</TD>
<TD>24</TD>
<TD>14</TD>
<TD>20</TD>
</TR>

Kirby

From kirby.urner at gmail.com  Sat Sep 13 00:49:38 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Fri, 12 Sep 2008 15:49:38 -0700
Subject: [Edu-sig] fyi. a published thesis, use of Python in class
In-Reply-To: <bf7bdf9f0809100959heb73b74w84e1bef6a466f4ad@mail.gmail.com>
References: <bf7bdf9f0809100541k6c7b4a30l18f37c82d948ab08@mail.gmail.com>
	<f604188c0809100746r4e27b720r4fee3e95ab08c6fc@mail.gmail.com>
	<bf7bdf9f0809100959heb73b74w84e1bef6a466f4ad@mail.gmail.com>
Message-ID: <f604188c0809121549ybf29ae8k8e3deead5929ccc2@mail.gmail.com>

On Wed, Sep 10, 2008 at 9:59 AM, Fotis Georgatos <gef at ceid.upatras.gr> wrote:
> Hello Kirby et al,
>
> On Wed, Sep 10, 2008 at 5:46 PM, kirby urner <kirby.urner at gmail.com> wrote:
>> Thank you Fotis, I have been reading this all morning, had not seen it
>> before.  Thank you for bringing it to my attention.
>
> My pleasure :)
>
> I just figured I haven't provided a URL for the .pdf document, too;
> so, here it is:
> http://arxiv.org/pdf/0809.1437v1
>
>> I've mostly documented by classroom work in my blogs, but usually in
>> connection with Saturday Academy, which doesn't compete to offer
>> transferable credits, only skills and its own credential, which does
>> count for something.  This is not the same as having an established
>> state school recognize Python as a good learning language.  I salute
>> the Pedagogical Institute for having some vision.
>
> In the name of accuracy, I'd like to point out that the Pedagogical Institute
> hasn't given a blessing -or contempt- about using the language at large scale.
> To their tribute though, they did grant license early on to conduct the research
> in the real environment, and there are sharp individuals there that understood
> the benefits very quickly; as well as the few colleagues that went all along.
> So, what happened under their auspices and guidance was the experiment.
> But, having people willing to experiment in an area that is new and unknown,
> and even do that in a fearless yet considerating way, yes, that was vision.

Kudos again.

< short_story >

In Oregon State we have this network of open source think tanks that
showcases through various venues, including the Hillsboro Police
Department, which set up a Linux Lab at West Precinct (Redhat based),
and invited in high school aged students for free training.

A motive for doing this:  police found themselves always "playing the
heavy" even with kids who maybe had done nothing wrong, asked into
classrooms to hammer home various lessons (entire curricula even)
focused on the illegality of copying, the dangers of chat rooms.

In the meantime, they saw all these young adults in open source having
gobs of fun, legally and safely, and not criminalizing the free
sharing of work.

How do we get kids from here to there?  Shouldn't the schools be doing
it?  But are they?

Given police have a big investment in living in a wholesome community
(anything else gets to be nightmarish, including for cops) they took
it upon themselves to do what schools mostly do not (or did not, it's
all changing pretty fast at this time).

As it turned out, the experiment was mostly a failure because
teenagers have a healthy fear of police stations and don't voluntarily
go there for schooling.  But their heart was in the right place, I
still believe.

My role in all this was as co-teacher subcontracted through Saturday
Academy (saturdayacademy.org), which gets some of its funding from the
Paul Allen group is my understanding (a Microsoft guy).

I tell this story about the police as a part of my informal
presentation to the London Knowledge Lab, that time Guido and I were
meeting with the Shuttleworth Foundation about stuff (Alan Kay also
present, although this summit was not about OLPC per se, was more
hardware agnostic, nor just about Python either, other communities
represented e.g. Scheme's).

http://www.lkl.ac.uk/cms/index.php?option=com_content&task=view&id=72&Itemid=48

< /short_story >

>
> I hope now that the OLPC is a standard topic in the educational community
> and Python has got much extra publicity and popularity because of it,
> people here and elsewhere will be more willing to consider it as a
> learning vehicle.

I think Jython and the Google AppEngine, so many up to date libraries,
are what most excite some people about Python and its prospects.

Others think PyPy is the bees knees (lots discussion about PyPy at
Green Dragon after last PPUG meeting, which focused on Django on
Jython:  http://worldgame.blogspot.com/2008/09/ppug-200899.html

We all have our reasons to love the snake.

Sugar certainly shows Python's potential as a robust and rapid
development environment, although given I hang around Intel people
(near Hillsboro) I'm somewhat am used to hearing it dissed (this was
awhile ago by now -- haven't heard anything lately).

My focus has been Py3K and its ability to use Greek characters (for
example) as top-level names, for functions and classes (I've been
using Chinese in my examples) e.g.:
http://mybizmo.blogspot.com/2008/05/chinese-names-in-python.html

> I'm not claiming that a transition to Python is going to happen quickly but,
> if I saw educators having it as a bold item in their mind, that would
> be progress!
>
> I wonder which country/ies would dare put the language as a recommendation
> in their country-wide curriculum, do we have any firsts in this area?
>
> cheers,
> Fotis

Here in the USA it's a political hot potato to speak in terms of any
"national curriculum" as we're too ethnically diverse to admit of such
a thing, but in each state there's some effort to come up with
"standards" (lots of cutting and pasting as bureaucrats employ open
source techniques to pad their websites).

Since Portland is considered an open source capital by some, it's a
congenial place in which to work with other parents in starting new
charter public schools not beholden to pre-existing curricula.  For
example our local LEP High runs on Edubuntu thanks to tech support
from Open Sourcery:  http://www.lephigh.org/
http://opensourcery.com/node/57

My own approach is to suggest that math teachers at the secondary
school level stop focusing on calculators as a rather antiquated idea
of "technology in the classroom" and get going on a curriculum more
suited to the needs of our local Silicon Forest employers.  We find
many teachers quite receptive to this thinking, so long as they get on
the job training.

Kirby

PS:  Vern, saw your +1 but looks like I'll need to take my proposal to
web site management, another list outside edu-sig (I used to be on
that list back when I set up the edu-sig page using cvs, pre the
reskinning and bright new look, switch to svn, and it was a terrible
spam storm of mostly bots politely rejecting one another's spam
rejection notices, oy!).

From lavendula6654 at yahoo.com  Sat Sep 13 01:10:31 2008
From: lavendula6654 at yahoo.com (Elaine)
Date: Fri, 12 Sep 2008 16:10:31 -0700 (PDT)
Subject: [Edu-sig] Python course at Foothill College
Message-ID: <248735.83890.qm@web31304.mail.mud.yahoo.com>

If you would like to learn Python, Foothill College is offering a course in Palo Alto starting Wednesday evening, 24 Sept, at 6 pm. This 12-week course is designed for students who are already familiar with another structured programming language. Here is more detailed information:

CIS 68K  "INTRODUCTION TO PYTHON PROGRAMMING"  5 Units
Meets Wednesday evenings, 6 -9:40 pm, from 24 Sept. until 10 Dec. at Middlefield campus room J3.

If you would like to sign up for the class, please register beforehand by going to:
http://www.foothill.fhda.edu/reg/index.php

If you have questions, you can contact the instructor at:
haightElaine at foothill.edu




      

From mpaul213 at gmail.com  Sat Sep 13 07:29:56 2008
From: mpaul213 at gmail.com (michel paul)
Date: Fri, 12 Sep 2008 22:29:56 -0700
Subject: [Edu-sig] some success
Message-ID: <40ea4eb00809122229i451dcf79u46bf2ff3af21a57c@mail.gmail.com>

The first homework assignment in my math classes this year was to download
and install Python.  I've been using it most extensively in my FST
(Functions Statistics Trig) class.  The curriculum starts with sigma
notation, so I showed them list comprehension syntax.  All it requires is
knowing how to create an algebraic expression, some understanding of
range(), and some understanding of 'for' and 'in'.  Really quite
reasonable.  The reactions have been mixed.  Some kids were really
apprehensive and complained to the principal.  He emailed me, and I
responded saying they should come see me.  I figured that they were
mistakenly assuming that they were responsible for understanding everything
I had been showing them on the first couple of days, and I was right.  That
stuff was just to present an overview.  Some kids really were intrigued by
Python, and they asked questions like 'how many digits of pi can it show?'
I was anticipating that, so I had a spigot algorithm on hand, and we
generated thousands of digits of pi!  It was great, but some of these
over-achievers think they're supposed to regurgitate everything they see
happen in class.  After all, their only real concern is their GPA.  This
kind of attitude has ruined education.  Anyway, having a few one-on-one
sessions cleared things up.  I showed them that all they really had to know
was very little.  The other stuff was just for fun.  So they were OK with
that.  Some of the kids are still apprehensive, but others are
enthusiastic.

One day a new kid signed in, and during class I had volunteers come up to
the computer to enter their expressions in Python.  After class I asked the
kid if what we were doing made any sense, and he was beaming.  He said yes,
and he couldn't wait to get home to download Python.  That was very
encouraging.

What I want the kids and colleagues and administration to understand is that
this is not something on top of the algebra, this IS algebra!  It's algebra
that RUNS.  It's 21st century algebra.

Some are getting it, and I'm glad to see that.  But many still don't.
Unfortunately, these others aren't just students.

It's a weird balance.  It splits in weird ways through the groups of
students, colleagues, administrators.

- Michel
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/edu-sig/attachments/20080912/388afe5a/attachment.htm>

From macquigg at ece.arizona.edu  Sat Sep 13 12:00:45 2008
From: macquigg at ece.arizona.edu (David MacQuigg)
Date: Sat, 13 Sep 2008 03:00:45 -0700
Subject: [Edu-sig] Network Simulations using Python
In-Reply-To: <fc87cd880809100914u705e356bl92cb32e3a82c33e9@mail.gmail.co
 m>
References: <5.2.1.1.0.20080910081205.02c757a8@plus.pop.mail.yahoo.com>
	<5.2.1.1.0.20080910081205.02c757a8@plus.pop.mail.yahoo.com>
Message-ID: <5.2.1.1.0.20080912185600.016c3660@mail.ece.arizona.edu>

At 11:14 AM 9/10/2008 -0500, Andrew Harrington wrote:

>Doing this in Python sounds good.  keep us posted on the updates.

I'll keep my updates at http://ece.arizona.edu/~edatools/ece578/Ethernet/

>I am most interested in a module to use with Cs0 or CS1 types to 
>illustrate network issues, not something a *user* would need more
>than a few weeks of Python for.

I can do some fairly sophisticated models with simple Python programs.  Class definitions are essential, however, so it may take a little more Python than is covered in the first few weeks of CS1.  Maybe there is some synergy here.  The network models can help students learn Python by motivating the need to define your own classes.

At 11:05 AM 9/10/2008 -0500, Michael Goldwasser wrote:

> Thats a great start and I agree that it might be easier to develop
> your own Python simulation versus using the existing simulators.  I
> don't teach our upper level networks course but have tried to do some
> very simple networks materials as part of a "cs 0" breadth course and
> again I run into the same problem in that I want a very basic network
> simulation that demonstrates the basic idea of packet switching
> without overwhelming beginning students.

We're using Computer Networks by Peterson and Davie, and packet switching is Chapter 3, starting a week from now.  Suggestions for simulation problems are welcome.  I appreciate the earlier suggestion to do some network programming (using a network rather than simulating it), and I know Python is very good at this.  There is not much in this text on programming.

For CS0 you might want animations, rather than simulations.  See http://net-seal.net  They have one on packet switching.

I've gone the next step with my Ethernet simulation (sim1.py), and encapsulated all the functionality into a few classes.  This adds some complexity (sim2.py), but now you can easily change the variable to be swept, even re-use the objects in a different network configuration.

One difficulty that I am running into is that many of our students haven't even heard of Python.  They have had plenty of Java, however, so I've written an annotated version of sim1.py to explain the differences from Java (sim1PythonNotes.py).  Michael's Appendix B is excellent on comparing Java and Python.

I thought about just doing the whole thing in Java, but then we lose the most important advantage of Python as a network simulation toolkit - interactive development of the models.

-- Dave


>On Wed, Sep 10, 2008 at 10:43 AM, David MacQuigg <<mailto:macquigg at ece.arizona.edu>macquigg at ece.arizona.edu> wrote:
>>I'm putting together some problems for students in ECE 578, Computer Networks.  The simulator being used in the class is truly awful, one of these expensive commercial programs, dumbed down for academic use, but still loaded with the non-essential complexity typical of programs written for full-time professionals.
>>
>>It occurs to me that Python would be a much better tool for what we are doing.  The objects in a network are easily modeled as Python objects, and students gain a much better understanding when they see what is inside the objects, rather than just picking them off a menu, and using them as black boxes.
>>
>>Take a look at <http://ece.arizona.edu/%7Eedatools/ece578/Ethernet/>http://ece.arizona.edu/~edatools/ece578/Ethernet/   The Python program is still in its early stages.  Next step is to "refactor" it, making the main program a Network object, so we can run it in a loop.
>>
>>Comments and suggestions are welcome, especially for more clarity in the Python code.  Python is still not used in any class at U of A, and this could be one of our shining examples to get it started.



From kirby.urner at gmail.com  Sat Sep 13 15:44:55 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Sat, 13 Sep 2008 06:44:55 -0700
Subject: [Edu-sig] some success
In-Reply-To: <40ea4eb00809122229i451dcf79u46bf2ff3af21a57c@mail.gmail.com>
References: <40ea4eb00809122229i451dcf79u46bf2ff3af21a57c@mail.gmail.com>
Message-ID: <f604188c0809130644k221ded7dld6e4c1f03cc674d1@mail.gmail.com>

2008/9/12 michel paul <mpaul213 at gmail.com>:

<< SNIP >>

> What I want the kids and colleagues and administration to understand is that
> this is not something on top of the algebra, this IS algebra!  It's algebra
> that RUNS.  It's 21st century algebra.
>
> Some are getting it, and I'm glad to see that.  But many still don't.
> Unfortunately, these others aren't just students.
>
> It's a weird balance.  It splits in weird ways through the groups of
> students, colleagues, administrators.
>
> - Michel

Great work Michel, you're definitely on the frontier.

Future shock may be shocking sometimes, however these students will
have more opportunities than their peers down the road.

Also, some students are apprehensive no matter what, even with only
traditional pre-computer stuff happening i.e. there's always
performance anxiety (in my experience anyway), goes with the territory
(or learning new things).

I look forward to more reports from the field.

Kirby

From macquigg at ece.arizona.edu  Sat Sep 13 20:04:36 2008
From: macquigg at ece.arizona.edu (David MacQuigg)
Date: Sat, 13 Sep 2008 11:04:36 -0700
Subject: [Edu-sig] some success
In-Reply-To: <40ea4eb00809122229i451dcf79u46bf2ff3af21a57c@mail.gmail.co
 m>
Message-ID: <5.2.1.1.0.20080913100345.02b09a40@mail.ece.arizona.edu>

At 10:29 PM 9/12/2008 -0700, michel paul wrote:

>The first homework assignment in my math classes this year was to download and install Python.  I've been using it most extensively in my FST (Functions Statistics Trig) class.

Sounds like the same class I took as a high school Junior in 1963.  It was all pretty new at the time, right after a major revision in the curriculum.  We need another Sputnik!!!

>After class I asked the kid if what we were doing made any sense, and he was beaming.  He said yes, and he couldn't wait to get home to download Python.  That was very encouraging.

I remember laboriously making a plot of sin(x) on a large sheet of graph paper, using values from tables in a big book.  This wasn't an assignment.  I just enjoyed doing it.  I remember thinking - where do sine waves come from?  Do generators really make sine waves?  Seems like parabolas would be simpler.

If only I could have applied that energy and enthusiasm to learning the fundamentals of computing ...  Instead my introduction to computing a few years later was truly awful.  It wasn't considered a subject worthy of study at Caltech.  Now after a long career in engineering, I'm learning some basic computer science by helping with classes at U of A.

>What I want the kids and colleagues and administration to understand is that this is not something on top of the algebra, this IS algebra!  It's algebra that RUNS.  It's 21st century algebra.

I like your presentation of list comprehensions as set notation.  It helped me see the utility of the syntax, and appreciate its compactness.  I was thinking of list comprehensions as just another twist I had to learn to read other people's programs.  Now when I see one, I don't have to parse it in my mind to understand it, and I use them all the time.

This also seems like a good way to squeeze some computing into an otherwise orthodox curriculum.  It's just a tool for doing algebra, not a frontal assault on the status quo.  If Python gets a foothold at U of A, it will likely be just a tool to do some simulations in an advanced networking class.  Learning Python is easier than learning OPNET.  Oh, and by the way, it's not just a network simulation language.  It's useful in just about everything you will do involving computation!

Keep up the good work!



From kirby.urner at gmail.com  Sat Sep 13 21:52:59 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Sat, 13 Sep 2008 12:52:59 -0700
Subject: [Edu-sig] Network Simulations using Python
In-Reply-To: <5.2.1.1.0.20080912185600.016c3660@mail.ece.arizona.edu>
References: <5.2.1.1.0.20080910081205.02c757a8@plus.pop.mail.yahoo.com>
	<5.2.1.1.0.20080912185600.016c3660@mail.ece.arizona.edu>
Message-ID: <f604188c0809131252w5d4374c6t9cde2a1d041d35b6@mail.gmail.com>

Someone should say something about Twisted in this "networking through
Python" thread, but I'm not sure what.

I come at Twisted through Medusa in Zope and readings about asyncore,
think of Twisted somewhat in those terms.

Later I jumped from Zope into Plone, hung out with Alan and those guys
for a sprint in Canada.

At this last OSCON, I hung out with Steve Holden (holdenweb.com) and
Duncan McGreggor (a Twisted guy) most of the time.

Kirby
4dsolutions.net

http://twistedmatrix.com/trac/wiki

http://www.nightmare.com/medusa/

http://docs.python.org/lib/module-asyncore.html

http://plone.org/

From gregor.lingl at aon.at  Sat Sep 13 23:51:13 2008
From: gregor.lingl at aon.at (Gregor Lingl)
Date: Sat, 13 Sep 2008 23:51:13 +0200
Subject: [Edu-sig] Network Simulations using Python
In-Reply-To: <f604188c0809131252w5d4374c6t9cde2a1d041d35b6@mail.gmail.com>
References: <5.2.1.1.0.20080910081205.02c757a8@plus.pop.mail.yahoo.com>	<5.2.1.1.0.20080912185600.016c3660@mail.ece.arizona.edu>
	<f604188c0809131252w5d4374c6t9cde2a1d041d35b6@mail.gmail.com>
Message-ID: <48CC35D1.1020000@aon.at>



kirby urner schrieb:
> Someone should say something about Twisted in this "networking through
> Python" thread, but I'm not sure what.
>   
I'd just like to point you to Shandy Brown's "Writing Games Tutorial", which
uses Twisted in it's network section:

http://ezide.com/games/writing-games.html

BTW this tutorial also deservers attention because of its explanations on
how to use the MVC pattern with pygame.

Regards,
Gregor


> I come at Twisted through Medusa in Zope and readings about asyncore,
> think of Twisted somewhat in those terms.
>
> Later I jumped from Zope into Plone, hung out with Alan and those guys
> for a sprint in Canada.
>
> At this last OSCON, I hung out with Steve Holden (holdenweb.com) and
> Duncan McGreggor (a Twisted guy) most of the time.
>
> Kirby
> 4dsolutions.net
>
> http://twistedmatrix.com/trac/wiki
>
> http://www.nightmare.com/medusa/
>
> http://docs.python.org/lib/module-asyncore.html
>
> http://plone.org/
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig
>
>
>   

From andre.roberge at gmail.com  Sun Sep 14 20:10:36 2008
From: andre.roberge at gmail.com (Andre Roberge)
Date: Sun, 14 Sep 2008 15:10:36 -0300
Subject: [Edu-sig] Reeborg's world!
Message-ID: <7528bcdd0809141110s53ba5f04v4b31c3c813c057de@mail.gmail.com>

Hi everyone,

You can see a more Python-like implementation of Steve Howell's
Webster van Robot at

http://reeborg.world.googlepages.com/reeborg.html.

It is essentially a draft web-based version of rur-ple (for those that
are familiar with it).

The actual home page, where Steve is given credit is
http://reeborg.world.googlepages.com/home

This is very much work in progress (that I will try to update on the
web ...), which
will eventually be integrated in Crunchy.

At this time, instructions are not included but "should be" somewhat intuitive.
[just click at random ;-) ... alternatively, go to the home page, find
the link to the
images, which should help a bit.]

As usual, comments and suggestions are welcome!

Andr?

From MDiPierro at cs.depaul.edu  Sun Sep 14 22:14:39 2008
From: MDiPierro at cs.depaul.edu (DiPierro, Massimo)
Date: Sun, 14 Sep 2008 15:14:39 -0500
Subject: [Edu-sig] Algorithms Animator Open Sourced
Message-ID: <C1AA20CAC1E41647BFF1D41215EDD475807EC28E21@wagner.cti.depaul.edu>

I open sourced this. In the hope it is useful to some of you.

Algorithms Animator

https://launchpad.net/algorithms-animator

Python application that implements and animates interactively those algorithms that are normally covered in an undergraduate course on the topic. It includes Insertion Sort, Quicksort, Mergesort, AVL Tree Search/Insert/Rebalance, Depth First Search, Breadth First Search, Topological Sort, Prim, Kruskal, Dijkstra, LCS, Huffman-Fano, and more. It is extensible. All the API are exposed. It includes a ready-to-run Windows executable (bin/AlgorithmsAnimator.exe), some documentation and a short tutorial about running time analysis (doc/csc321notes.pdf). This program was originally designed in 2003 for teaching "Design and Analysis of Algorithms" at DePaul University. All the algorithms in the source code (src/csc321algorithms.py) are equivalent line-by-line to the pseudo-code in the MIT CLRS "Introduction to Algorithms" book.

Massimo

From echerlin at gmail.com  Sun Sep 14 23:19:40 2008
From: echerlin at gmail.com (Edward Cherlin)
Date: Sun, 14 Sep 2008 14:19:40 -0700
Subject: [Edu-sig] Algorithms Animator Open Sourced
In-Reply-To: <C1AA20CAC1E41647BFF1D41215EDD475807EC28E21@wagner.cti.depaul.edu>
References: <C1AA20CAC1E41647BFF1D41215EDD475807EC28E21@wagner.cti.depaul.edu>
Message-ID: <e574f6eb0809141419s4e8e694ei9d473adac0c7cdb5@mail.gmail.com>

Thank you. Presumably we could apply the same approach to teaching
elementary-school arithmetic algorithms, maze traversal algorithms,
and the like for One Laptop Per Child. I have suggested this to their
Education mailing list.

On Sun, Sep 14, 2008 at 1:14 PM, DiPierro, Massimo
<MDiPierro at cs.depaul.edu> wrote:
> I open sourced this. In the hope it is useful to some of you.
>
> Algorithms Animator
>
> https://launchpad.net/algorithms-animator
>
> Python application that implements and animates interactively those algorithms that are normally covered in an undergraduate course on the topic. It includes Insertion Sort, Quicksort, Mergesort, AVL Tree Search/Insert/Rebalance, Depth First Search, Breadth First Search, Topological Sort, Prim, Kruskal, Dijkstra, LCS, Huffman-Fano, and more. It is extensible. All the API are exposed. It includes a ready-to-run Windows executable (bin/AlgorithmsAnimator.exe), some documentation and a short tutorial about running time analysis (doc/csc321notes.pdf). This program was originally designed in 2003 for teaching "Design and Analysis of Algorithms" at DePaul University. All the algorithms in the source code (src/csc321algorithms.py) are equivalent line-by-line to the pseudo-code in the MIT CLRS "Introduction to Algorithms" book.
>
> Massimo
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig
>



-- 
Don't panic.--HHGTTG, Douglas Adams
fivethirtyeight.com, 3bluedudes.com Obama by 70 in EC!
http://www.obamapedia.org/ Join us!
http://wiki.sugarlabs.org/go/User:Mokurai For the children

From MDiPierro at cs.depaul.edu  Mon Sep 15 07:10:59 2008
From: MDiPierro at cs.depaul.edu (DiPierro, Massimo)
Date: Mon, 15 Sep 2008 00:10:59 -0500
Subject: [Edu-sig] Algorithms Animator Open Sourced
In-Reply-To: <e574f6eb0809141419s4e8e694ei9d473adac0c7cdb5@mail.gmail.com>
References: <C1AA20CAC1E41647BFF1D41215EDD475807EC28E21@wagner.cti.depaul.edu>,
	<e574f6eb0809141419s4e8e694ei9d473adac0c7cdb5@mail.gmail.com>
Message-ID: <C1AA20CAC1E41647BFF1D41215EDD475807EC28E23@wagner.cti.depaul.edu>

I agree.

Anyway, I made another page about the animator and I am posting a video there in 1hour.

http://mdp.cti.depaul.edu/Teaching/Algorithms

Massimo

________________________________________
From: Edward Cherlin [echerlin at gmail.com]
Sent: Sunday, September 14, 2008 4:19 PM
To: DiPierro, Massimo
Cc: edu-sig at python.org
Subject: Re: [Edu-sig] Algorithms Animator Open Sourced

Thank you. Presumably we could apply the same approach to teaching
elementary-school arithmetic algorithms, maze traversal algorithms,
and the like for One Laptop Per Child. I have suggested this to their
Education mailing list.

On Sun, Sep 14, 2008 at 1:14 PM, DiPierro, Massimo
<MDiPierro at cs.depaul.edu> wrote:
> I open sourced this. In the hope it is useful to some of you.
>
> Algorithms Animator
>
> https://launchpad.net/algorithms-animator
>
> Python application that implements and animates interactively those algorithms that are normally covered in an undergraduate course on the topic. It includes Insertion Sort, Quicksort, Mergesort, AVL Tree Search/Insert/Rebalance, Depth First Search, Breadth First Search, Topological Sort, Prim, Kruskal, Dijkstra, LCS, Huffman-Fano, and more. It is extensible. All the API are exposed. It includes a ready-to-run Windows executable (bin/AlgorithmsAnimator.exe), some documentation and a short tutorial about running time analysis (doc/csc321notes.pdf). This program was originally designed in 2003 for teaching "Design and Analysis of Algorithms" at DePaul University. All the algorithms in the source code (src/csc321algorithms.py) are equivalent line-by-line to the pseudo-code in the MIT CLRS "Introduction to Algorithms" book.
>
> Massimo
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig
>



--
Don't panic.--HHGTTG, Douglas Adams
fivethirtyeight.com, 3bluedudes.com Obama by 70 in EC!
http://www.obamapedia.org/ Join us!
http://wiki.sugarlabs.org/go/User:Mokurai For the children

From davelist at mac.com  Mon Sep 15 18:21:12 2008
From: davelist at mac.com (davelist at mac.com)
Date: Mon, 15 Sep 2008 12:21:12 -0400
Subject: [Edu-sig] Algorithms Animator Open Sourced
In-Reply-To: <C1AA20CAC1E41647BFF1D41215EDD475807EC28E23@wagner.cti.depaul.edu>
References: <C1AA20CAC1E41647BFF1D41215EDD475807EC28E21@wagner.cti.depaul.edu>
	<e574f6eb0809141419s4e8e694ei9d473adac0c7cdb5@mail.gmail.com>
	<C1AA20CAC1E41647BFF1D41215EDD475807EC28E23@wagner.cti.depaul.edu>
Message-ID: <AEE6D5E1-271A-416A-AAE6-03FA2D88B3CE@mac.com>


This looks interesting - thanks for making it available. I'm not  
familiar with launchpad - is there an easy way to download the source  
using svn or is there a .tar.gz file somewhere?

Thanks,
Dave

On Sep 15, 2008, at 1:10 AM, DiPierro, Massimo wrote:

> I agree.
>
> Anyway, I made another page about the animator and I am posting a  
> video there in 1hour.
>
> http://mdp.cti.depaul.edu/Teaching/Algorithms
>
> Massimo
>
> ________________________________________
> From: Edward Cherlin [echerlin at gmail.com]
> Sent: Sunday, September 14, 2008 4:19 PM
> To: DiPierro, Massimo
> Cc: edu-sig at python.org
> Subject: Re: [Edu-sig] Algorithms Animator Open Sourced
>
> Thank you. Presumably we could apply the same approach to teaching
> elementary-school arithmetic algorithms, maze traversal algorithms,
> and the like for One Laptop Per Child. I have suggested this to their
> Education mailing list.
>
> On Sun, Sep 14, 2008 at 1:14 PM, DiPierro, Massimo
> <MDiPierro at cs.depaul.edu> wrote:
>> I open sourced this. In the hope it is useful to some of you.
>>
>> Algorithms Animator
>>
>> https://launchpad.net/algorithms-animator
>>
>> Python application that implements and animates interactively those  
>> algorithms that are normally covered in an undergraduate course on  
>> the topic. It includes Insertion Sort, Quicksort, Mergesort, AVL  
>> Tree Search/Insert/Rebalance, Depth First Search, Breadth First  
>> Search, Topological Sort, Prim, Kruskal, Dijkstra, LCS, Huffman- 
>> Fano, and more. It is extensible. All the API are exposed. It  
>> includes a ready-to-run Windows executable (bin/ 
>> AlgorithmsAnimator.exe), some documentation and a short tutorial  
>> about running time analysis (doc/csc321notes.pdf). This program was  
>> originally designed in 2003 for teaching "Design and Analysis of  
>> Algorithms" at DePaul University. All the algorithms in the source  
>> code (src/csc321algorithms.py) are equivalent line-by-line to the  
>> pseudo-code in the MIT CLRS "Introduction to Algorithms" book.
>>
>> Massimo
>> _______________________________________________
>> Edu-sig mailing list
>> Edu-sig at python.org
>> http://mail.python.org/mailman/listinfo/edu-sig
>>
>
>
>
> --
> Don't panic.--HHGTTG, Douglas Adams
> fivethirtyeight.com, 3bluedudes.com Obama by 70 in EC!
> http://www.obamapedia.org/ Join us!
> http://wiki.sugarlabs.org/go/User:Mokurai For the children
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig


From jjposner at snet.net  Tue Sep 16 01:19:26 2008
From: jjposner at snet.net (John Posner)
Date: Mon, 15 Sep 2008 19:19:26 -0400
Subject: [Edu-sig] Edu-sig Digest, Vol 62, Issue 15
In-Reply-To: <mailman.7.1221472803.18128.edu-sig@python.org>
References: <mailman.7.1221472803.18128.edu-sig@python.org>
Message-ID: <005e01c91789$802cd530$80867f90$@net>

> ... Presumably we could apply the same approach to teaching
> elementary-school arithmetic algorithms, maze traversal algorithms,
> and the like for One Laptop Per Child. I have suggested this to their
> Education mailing list.

Here's a video of a tool I wrote to help elementary-school kids learn
carrying/borrowing in the addition/subtraction of whole numbers.

     http://showmedo.com/videos/video?name=2010000&fromSeriesID=201


To get this tool, and a similar one for adding/subtracting fractions, go to:

     http://www.geocities.com/jjphoogrp

-John Posner



From kirby.urner at gmail.com  Tue Sep 16 01:35:19 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Mon, 15 Sep 2008 16:35:19 -0700
Subject: [Edu-sig] Edu-sig Digest, Vol 62, Issue 15
In-Reply-To: <005e01c91789$802cd530$80867f90$@net>
References: <mailman.7.1221472803.18128.edu-sig@python.org>
	<005e01c91789$802cd530$80867f90$@net>
Message-ID: <f604188c0809151635q7176469fr1afce946e448212@mail.gmail.com>

Hi John --

I like that your 2nd example doesn't go strictly left to right *or*
right to left -- columns resolve (by carrying) in various orders,
always to the same end.

I could see boosting the frame rate at showing many more examples
really quickly -- another meaning of "mental arithmetic".  2nd roots
anyone?

Kirby


On Mon, Sep 15, 2008 at 4:19 PM, John Posner <jjposner at snet.net> wrote:
>> ... Presumably we could apply the same approach to teaching
>> elementary-school arithmetic algorithms, maze traversal algorithms,
>> and the like for One Laptop Per Child. I have suggested this to their
>> Education mailing list.
>
> Here's a video of a tool I wrote to help elementary-school kids learn
> carrying/borrowing in the addition/subtraction of whole numbers.
>
>     http://showmedo.com/videos/video?name=2010000&fromSeriesID=201
>
>
> To get this tool, and a similar one for adding/subtracting fractions, go to:
>
>     http://www.geocities.com/jjphoogrp
>
> -John Posner
>
>
> _______________________________________________
> Edu-sig mailing list
> Edu-sig at python.org
> http://mail.python.org/mailman/listinfo/edu-sig
>

From kirby.urner at gmail.com  Wed Sep 17 22:54:24 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Wed, 17 Sep 2008 13:54:24 -0700
Subject: [Edu-sig] Orienting newcomers...
Message-ID: <f604188c0809171354v20f5f54ak459061a2d82dab98@mail.gmail.com>

We know from feedback that having an interactive shell makes a huge
difference, in terms of what's to like about Python.  As I'm
delivering to skeptics a lot of the time, who think I'm maybe back
stabbing other languages that deserve more respect, I'm sure to
mention that Python isn't the only interactive interpreter based
language reducing to bytecodes for virtual machine execution under the
hood.  There's Jython as well.  Joke.

Given we're in 2.x -> 3.x migration phase, I tell a short story in
which "most language designers" never thought of putting in a
deliberate break point, a pit stop for correcting low level design
flaws that are sure to be there (we all make mistakes), making some
cool tweaks, but Guido is smarter than the average bear (cartoon
allusion **).

Plus we like making fun of Y2K (a "retro apocalypse"), Py3K or Python
3000 being a takeoff on that, also on Windows 2000 maybe.  We can
afford to get "mock apocalyptic" about all the breaking code, because
we actually have no reason to panic.  The older engines aren't going
anywhere, we have time to take a relaxed not-crisis-driven approach
for a change.

Anyway there's history to tell, also about the VM based approach
(managed code), versus pedal to the metal chip assembly code hot off
the compiler, as that's our entry point for discussing Mono/.NET (CLR)
and the Java class hierarchy and runtime, which are sort of like
"core" and "standard library" all rolled into one (for those coming
from CPython or just C itself).

When it comes to core, standard library, 3rd party, I'm quick to point
out we ourselves are 3rd party the moment we save that first .py file
in /site-packages i.e. all additional code is in some sense 3rd party.

The question of how the interpreter and source code co-exist is too
convoluted to get into that much, but we don't always do it the same
way.

Most trivially, in shell mode we're real time interactive, whereas in
running a script, we're walking away from REPL (read, evaluate, print,
loop).  GUI applications have their characteristic main loop event
polling, and so on.

I don't think I should hype Python Nation's PiPy as "the equivalent of
CPAN" in the Republic of Perl as it's not, although the idea is
similar.  On the Java side, eggs are like jars.

What I'm trying to do in my allotted 30-45 minutes is "speak geek" in
a fluent enough way to give listeners, also watching projected
content, a sense of what's what in this rather ephemeral realm of open
source software (how come we get to look at the source is because it's
open).

This is useful for adults thinking about retraining in IT, not just
for math faculties looking for new topics that integrate well with the
sciences ala SciPy or whatever.

Kirby

** http://www.youtube.com/watch?v=zEZJ_mLUNPc

From da.ajoy at gmail.com  Fri Sep 19 07:50:48 2008
From: da.ajoy at gmail.com (Daniel Ajoy)
Date: Fri, 19 Sep 2008 00:50:48 -0500
Subject: [Edu-sig] light-bot another one like Karel
Message-ID: <op.uhpruylm0gup8g@daniel-pc>

In flash:
http://www.gameroo.nl/games/light-bot

Daniel



From mpaul213 at gmail.com  Sat Sep 20 17:11:39 2008
From: mpaul213 at gmail.com (michel paul)
Date: Sat, 20 Sep 2008 08:11:39 -0700
Subject: [Edu-sig] further exploration
Message-ID: <40ea4eb00809200811q126857c7wf66ae898d64e9e4d@mail.gmail.com>

I took the kids to the lab yesterday.  I had our tech guy install VPython.
It's great finally having a tech guy who has done some programming!  Again,
this is a Functions, Statistics, Trig class, although the curriculum is
actually organized as Statistics, Functions, Trig.  I'm going to suggest
reversing that next time, but in a weird way it actually worked starting off
with statistics and using list comprehension for sigma.  I just told them
don't freak out, this is meant as an introduction, so relax and notice how
you can read the code almost like a natural language, that's all you need to
see right now.  Regarding standard deviation, I said don't memorize
formulas.  Just learn these concepts:  1.  Standard deviation is the square
root of variance.  2.  Variance is the mean of the squared deviations.  3.
Deviation is difference from the mean.  Using list comprehension you can
express each of these thoughts in a set of one liners.  All we need are
functions for mean(L), deviations(L), and squares(L).  Then we're all set to
define the variance(L) as the mean of the squared deviations of L.  That
last sentence right there easily translates into def variance(L): return
mean(squares(deviations(L))).  I know that some of them appreciated the
elegance of that.  There definitely were some who got it.  I think seeing
the ideas spelled out like that is way better than using a statistical
software package.  This way they can own their thinking.  Its just a matter
of getting them to buy into it.  So I took them to the lab and had them use
these functions  and then create histograms using VPython.  I embedded the
VPython syntax for them into simpler functions like histogram(L, intervals),
so all they had to do was supply some data and their preferred categories.
Toward the end of class I clued them in on the 'examples' folder in VPython
and had them explore random blocks and stonehenge.  They loved it.  They
oohed and ahhed when I had them use the mouse buttons to dive in.  And then
I just let them explore.  It was great.  There has still been some
resistance or disinterest on the part of some students, but I think this
impressed even them.  There's still the factor of kids who might remain
resistant because it seems overwhelming and they feel intimidated by it all,
and the 3D stuff might have scared them some more.  I don't know how many
might still be in that category, but that's what I have to find out next.

- Michel
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/edu-sig/attachments/20080920/79845981/attachment.htm>

From kirby.urner at gmail.com  Fri Sep 26 01:20:16 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Thu, 25 Sep 2008 16:20:16 -0700
Subject: [Edu-sig] More news from Oregon
Message-ID: <f604188c0809251620g4aece38al121891ea2358030a@mail.gmail.com>

Reviewing some of the history from my angle:  we did some pilots with Python
in Portland Public Schools at the geek flagship, Winterhaven, both before my
family joined, and afterward, me picking up McCarty's 8th grade one day a
week for some field testing of new ideas, including projecting Google Earth,
xml-rpc, etc. (Python + DOM might be a better name for it, would change the
mix more in favor of JavaScript if doing it again).  Then I switched over to
older students via Saturday Academy, publishing write-ups to edu-sig and to
my blog.  Now we (my partnership) is hammering out this Python Briefing and
promoting it to such as the Software Association of Oregon and the Center
for Advanced Learning, places like that, with the idea being to help with
inservice training of already embedded faculty.

The situation in Oregon has been:  Java for AP compsci (high school level),
but the state institutions of higher ed not being that keen on accepting ETS
certification, meaning many bothering with AP compsci have been aiming at
higher ed in neighboring states, Utah especially, where I understand the
Java curriculum gets college credits.  Python has made inroads in this or
that classroom (I don't pretend to having a lot of overview data on this,
don't sit in State offices set up to monitor such things, if they even
exist) based on anecdotal evidence collected at SAO planning meetings at
Willamette University (attended with a team from Free Geek, a few years ago
now).

My approach has always been different (though not original with me, Kenneth
Iverson an inspiration):  to challenge the standard mathematics curriculum
to update or die, meaning if you stick with those calculators, you'll get
creamed by the new charters we're floating.  That's a polemical way of
stating it though, need to be more diplomatic on the ground, plus it's
usually not the teacher that's the bottleneck, but the subservient attitude
of curriculum writers towards big publishing houses and their paper-wasting
ways.  Computer programming languages are "disruptive technology" pure and
simple, and there's no easy way to phase them in to high school mathematics
classes without breaking backward compatibility in some ways, duh.

Internationally, it's a somewhat different picture, with some schools
systems realizing they have nothing to lose, and so more willing to
experiment with the new tools.  And of course homeschoolers are all over the
map with this stuff, often regular school students by day, i.e. they
homeschool after hours, when having access to YouTube, other essentials.  So
I've found a lot of international collaborators willing to leverage what
we're able to develop for our Oregon and Washington region (Silicon Forest),
Gerald de Jong for example (a Java guy more than Python).

Anyway, the long and short of it is I'm still working with that charter in
Alaska I mentioned in my Chicago talk, hammering on ASCII - to - Unicode as
a "major story of our time" don't care what class it's taught in
(sociology?  anthropology?).  Basically, if it's taught nowhere in the high
school, it's not up to standard.  Of course that doesn't mean "state
standard" in all cases, which is where we might say something not entirely
charitable about this or that slow poke of a state, doesn't even teach kids
the very basics.  But then, who said state legislatures should be in the
curriculum writing business in the first place, is a legitimate question.
In Oregon, private industry still has a say too (and why not, we know what a
lot of the jobs are like).

I'm also continuing to collaborate with Ian Benson on some of this SQL stuff
(need to be teaching SQL in algebra, or what good is it?), other
professional mathematicians.  Not everyone wants to get out in front in the
"math wars" understandably.  Especially this Bucky stuff is controversial,
lots of media stirrings thanks to Whitney Museum in New York, on to Chicago
next.  Plus there's a play opening in Portland soon **, which only helps me
with the geometry teachers, as they see a way to connect more to these
extra-curricular events.  As for how "Bucky stuff" ties to Python in my
little world, that's too big a topic for here.  Hypertoons and rbf.py are
two points of contact, or check these Focal Points in my blog:
http://mybizmo.blogspot.com/2006/09/focal-points.html

Kirby Urner
4Dsolutions.net

** http://www.pcs.org/bucky/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/edu-sig/attachments/20080925/4e4b8798/attachment.htm>

From krstic at solarsail.hcs.harvard.edu  Fri Sep 26 02:13:48 2008
From: krstic at solarsail.hcs.harvard.edu (=?UTF-8?Q?Ivan_Krsti=C4=87?=)
Date: Thu, 25 Sep 2008 20:13:48 -0400
Subject: [Edu-sig] PyCon 2009 - Call for proposals
Message-ID: <76D08F88-CE50-4B71-8145-8C6AE0396999@solarsail.hcs.harvard.edu>

Hi folks,

PyCon '09 will be opening for talk proposals shortly; see below. We'd  
love to have some great talks on Python in education, so please don't  
be shy!

Cheers,

Ivan Krsti?
Chair, PyCon 2009 Program Committee




Call for proposals -- PyCon 2009 -- <http://us.pycon.org/2009/>
===============================================================

Want to share your experience and expertise? PyCon 2009 is looking for
proposals to fill the formal presentation tracks. The PyCon conference
days will be March 27-29, 2009 in Chicago, Illinois, preceded by the
tutorial days (March 25-26), and followed by four days of development
sprints (March 30-April 2).

Previous PyCon conferences have had a broad range of presentations,
from reports on academic and commercial projects to tutorials and case
studies. We hope to continue that tradition this year.

Online proposal submission will open on September 29, 2008. Proposals
will be accepted through November 03, with acceptance notifications
coming out on December 15. For the detailed call for proposals,
please see:

   <http://us.pycon.org/2009/conference/proposals/>

We look forward to seeing you in Chicago!



--
Ivan Krsti? <krstic at solarsail.hcs.harvard.edu> | http://radian.org


From showell30 at yahoo.com  Fri Sep 26 05:37:42 2008
From: showell30 at yahoo.com (Steve Howell)
Date: Thu, 25 Sep 2008 20:37:42 -0700 (PDT)
Subject: [Edu-sig] More news from Oregon
In-Reply-To: <f604188c0809251620g4aece38al121891ea2358030a@mail.gmail.com>
Message-ID: <135740.11561.qm@web33501.mail.mud.yahoo.com>

Kirby, thanks for the updates.  Below are the statements that were most throught-provoking to me.  See my reactions.


--- On Thu, 9/25/08, kirby urner <kirby.urner at gmail.com> wrote:

> Computer programming languages are "disruptive
> technology" pure and
> simple, and there's no easy way to phase them in to
> high school mathematics
> classes without breaking backward compatibility in some
> ways, duh.

I totally agree with that.  I also wonder how there can be convergences between how we teach computer languages (Python, Javascript, etc.) and natural languages (French, Spanish, etc.).


> Anyway, the long and short of it is I'm still working
> with that charter in
> Alaska I mentioned in my Chicago talk, hammering on ASCII -
> to - Unicode as
> a "major story of our time" don't care what
> class it's taught in
> (sociology?  anthropology?). [...]

I agree with you that Unicode's a big story.  I just wonder if fifty years from now, we'll all be wondering how people ever survived without a single small alphabet that we can all agree on.  In fact, I'm wondering how many people will be left in the world that can't read and write (a somewhat evolved version of) English (in addition to their native languages).


From kirby.urner at gmail.com  Fri Sep 26 17:34:59 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Fri, 26 Sep 2008 08:34:59 -0700
Subject: [Edu-sig] More news from Oregon
In-Reply-To: <135740.11561.qm@web33501.mail.mud.yahoo.com>
References: <f604188c0809251620g4aece38al121891ea2358030a@mail.gmail.com>
	<135740.11561.qm@web33501.mail.mud.yahoo.com>
Message-ID: <f604188c0809260834x3381a338v5e72cef05af8e386@mail.gmail.com>

On Thu, Sep 25, 2008 at 8:37 PM, Steve Howell <showell30 at yahoo.com> wrote:

> Kirby, thanks for the updates.  Below are the statements that were most
> throught-provoking to me.  See my reactions.
>
>
> --- On Thu, 9/25/08, kirby urner <kirby.urner at gmail.com> wrote:
>
> > Computer programming languages are "disruptive
> > technology" pure and
> > simple, and there's no easy way to phase them in to
> > high school mathematics
> > classes without breaking backward compatibility in some
> > ways, duh.
>
> I totally agree with that.  I also wonder how there can be convergences
> between how we teach computer languages (Python, Javascript, etc.) and
> natural languages (French, Spanish, etc.).


Yes.  I typically bring up J (the language) and the LEX Institute at this
point, the former because the documentation consciously adopts "grammar" and
"parts of speech" as the dominant paradigm, the latter because here you have
human language learners (pioneers in techniques) tackling Fourier
Transformations as a topic.  O'Reilly's 'Head First' titles reminds me of
LEX, per this blog post:


>
>
>
> > Anyway, the long and short of it is I'm still working
> > with that charter in
> > Alaska I mentioned in my Chicago talk, hammering on ASCII -
> > to - Unicode as
> > a "major story of our time" don't care what
> > class it's taught in
> > (sociology?  anthropology?). [...]
>
> I agree with you that Unicode's a big story.  I just wonder if fifty years
> from now, we'll all be wondering how people ever survived without a single
> small alphabet that we can all agree on.  In fact, I'm wondering how many
> people will be left in the world that can't read and write (a somewhat
> evolved version of) English (in addition to their native languages).
>
>
Having lived in the Philippines, I recognize the importance of a lingua
franca, be that English or whatever and expect we'll continue to see "glue
language" sinews keeping us globalizing productively.  Romanji or Latin-1
definitely did us a big favor in being small and compact, running in < 1K
one might say.  Mnemonics like JMP and CMD, short words like "hex", are
likely to stick around for the foreseeable future.  But yeah, reams of
source code in Cyrillic and Greek are already happening at higher levels
than assembler, would be my educated guess, and our open source repositories
will be reflecting those freedoms.

Kirby
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/edu-sig/attachments/20080926/6f839efc/attachment.htm>

From kirby.urner at gmail.com  Fri Sep 26 17:40:30 2008
From: kirby.urner at gmail.com (kirby urner)
Date: Fri, 26 Sep 2008 08:40:30 -0700
Subject: [Edu-sig] More news from Oregon
In-Reply-To: <f604188c0809260834x3381a338v5e72cef05af8e386@mail.gmail.com>
References: <f604188c0809251620g4aece38al121891ea2358030a@mail.gmail.com>
	<135740.11561.qm@web33501.mail.mud.yahoo.com>
	<f604188c0809260834x3381a338v5e72cef05af8e386@mail.gmail.com>
Message-ID: <f604188c0809260840p50b59285ha67da332b29acd0f@mail.gmail.com>

>
> Yes.  I typically bring up J (the language) and the LEX Institute at this
> point, the former because the documentation consciously adopts "grammar" and
> "parts of speech" as the dominant paradigm, the latter because here you have
> human language learners (pioneers in techniques) tackling Fourier
> Transformations as a topic.  O'Reilly's 'Head First' titles reminds me of
> LEX, per this blog post:
>


http://worldgame.blogspot.com/2005/01/brainstorming-about-pedagogy.html

Everything is a moving target of course, i.e. innovations in computer
technology will revolutionize how we teach human languages, in terms of
using YouTube like clips and so on.

Another important teaching from pedagogy:  we don't all like learning the
same way, or, put another way, have these personalized optimal ways of
learning that, if catered to, will multiply learning effectiveness by orders
of magnitude.

So to talk about "evolving" or "evolution" should not get us thinking
"convergence" as if it's all narrowing to some Borg-like mono-culture.  My
sense of technology is it facilitates precisely the opposite:  an explosion
of possibilities and a consequent multiplicity of lifestyles (and learning
styles).

Kirby
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/edu-sig/attachments/20080926/0fb8b4e9/attachment.htm>

From andre.roberge at gmail.com  Sat Sep 27 15:45:21 2008
From: andre.roberge at gmail.com (Andre Roberge)
Date: Sat, 27 Sep 2008 10:45:21 -0300
Subject: [Edu-sig] Fwd:  PyCon 2009 - Call for proposals
In-Reply-To: <7528bcdd0809261644s63adddadve3f23aee66c3bacf@mail.gmail.com>
References: <76D08F88-CE50-4B71-8145-8C6AE0396999@solarsail.hcs.harvard.edu>
	<7528bcdd0809261644s63adddadve3f23aee66c3bacf@mail.gmail.com>
Message-ID: <7528bcdd0809270645m24b25788t889b596afc26fd3a@mail.gmail.com>

(Apologies to Ivan for sending him a message directly rather than to
the list which I meant to do.  Andr?)


---------- Forwarded message ----------
From: Andre Roberge <andre.roberge at gmail.com>
Date: 2008/9/26
Subject: Re: [Edu-sig] PyCon 2009 - Call for proposals
To: Ivan Krsti? <krstic at solarsail.hcs.harvard.edu>


On Thu, Sep 25, 2008 at 9:13 PM, Ivan Krsti?
<krstic at solarsail.hcs.harvard.edu> wrote:
> Hi folks,
>
> PyCon '09 will be opening for talk proposals shortly; see below. We'd love
> to have some great talks on Python in education, so please don't be shy!
>
> Cheers,
>
> Ivan Krsti?
> Chair, PyCon 2009 Program Committee
>
>

Rising up to Ivan's challenge...   After missing last year's Pycon, I
have been hoping of going this year, and talk about Crunchy.  There
are many aspects I could cover and was wondering what people would be
most interested in.  For example:

1. using Crunchy's doctest feature as a teaching tool.  (including an
experimental "exam mode" soon to be incorporated in Crunchy's trunk).
2. using Crunchy's unittest feature as a teaching tool.  (unittest
mode was implemented this summer as part of Google SoC)
3. using the "code analyzer" feature to provide feedback to students.
(again from this summer's SoC; using pylint or pyflakes or pychecker).
4. using the simple interface to pdb  (soon to be incorporated in the trunk)
5. using a mini-language environment  (Karel the robot/rur-ple)
6. using the Croquant (a MoinMoin extension) and Crunchy in
combination to create educational resources.
etc.

I could give a talk that would be a survey of all that's available in
Crunchy (version 1.0 should be out before the new year) or go in depth
on a couple of topics.

Alternatively, I could go and give an in-depth look as how to write a
simple (and a not-so-simple) plugin for Crunchy, extending its
capabilities...

Any comment/suggestions/things you'd like to see?

Andr?

P.S.  For those that understand French, Florian Bir?e gave a
presentation that included many of the new features of Crunchy (some
of which where mentioned above) at Toulouse France; this presentation
(55 minutes) has been recorded on video and is available at
http://toulibre.org/Videos   (2nd from the bottom).