[Edu-sig] [edupython] Python in Education Advocacy Article

[Dethe Elza]

On 30-Mar-07, at 9:13 PM, Paul D. Fernhout wrote:

> Still, there are always tempting new projects like "Factor"
>   http://factorcode.org/
> which uses FORTH ideals to do amazing things (like with OpenGL) in
> fairly small footprints and with minimal external dependencies and  
> with
> fairly few core developer-years of work (though the developers are
> unusually bright. :-) From the web page: "Factor has an optimizing
> native compiler, automatic memory management with a generational  
> garbage
> collector, a powerful collections library, and various advanced  
> language
> features such as higher-order programming, continuations, and  
> extensible
> syntax. Factor development is done in an interactive environment  
> with a
> graphical user interface. There is a single-stepping debugger which  
> can
> travel backwards in time, and extensive documentation. An easy to  
> use C
> library interface allows one to call C libraries without writing any
> glue code in C. Bindings for OpenGL, FreeType, X11, Cocoa, and Windows
> APIs are provided."  (I can hope AK's FONC
>  http://vpri.org/mailman/listinfo/fonc
>   http://www.viewpointsresearch.org/html/writings.htm
> in a few years will produce something even beyond that, if it  
> succeeds).

Factor looks interesting.  You also might be interested in Io:

http://iolanguage.com/about/

<quote>Io is a small, prototype-based programming language. The ideas  
in Io are mostly inspired by Smalltalk (all values are objects), Self  
(prototype-based), NewtonScript (differential inheritance), Act1  
(actors and futures for concurrency), LISP (code is a runtime  
inspectable/modifiable tree) and Lua (small, embeddable).</quote>

Despite the fact that Python isn't listed as an influence on Io, I  
find it has a bit of a pythonic feel, with the difference that  
prototyping brings.  It has bindings to a rich set of external  
(mostly C) libraries (async sockets and dns, SQLite and SkipDB  
(embedded transactional databases), regular expressions (Perl 5  
compatible), xml/html/sgml parsing, md5, sha1, zlib, lzo, blowfish,  
curses (text interfaces), OpenGL/GLUT, PortAudio, FreeType (TrueType  
antialised font support),Objective-C bridge.  And, one of my favorite  
things, it has Erlang-like messaging and scalable (non-thread)  
concurrency.  Not quite ready for prime time yet, but very  
interesting to keep an eye on.

> The bottom line on "Edit and continue" is that making it work properly
> likely requires deep thinking and understanding about the entire  
> Python
> runtime system (as well as getting pickup of your changes by  
> various IDE
> developers), and Python as a system has moved so far along the
> development curve that coming from a standing start up to an
> understanding of Python's current internals necessarily beyond that of
> Guido (who says it is impossible :-) is likely a long hard effort.
> During which time Python will keep moving. It's not exactly a best  
> first
> choice of Python internals hacking. Guido is obviously the best person
> to tackle it, I think; just need to figure out how to motivate him to
> care about it instead of other cool and important things. Now if I  
> could
> just get hold of some "first herring" perhaps? :-)
>   http://travel.independent.co.uk/europe/article548699.ece
>   http://en.wikipedia.org/wiki/Herring

Well, the herring is probably the OLPC, which Guido is working to  
support by implementing edit and continue, according to his blog:

http://www.artima.com/weblogs/viewpost.jsp?thread=197203
<quote>
The software is far from finished. An early version of the GUI and  
window manager are available, and a few small demo applications:  
chat, video, two games, and a web browser, and that's about it! The  
plan is to write all applications in Python (except for the web  
browser), and a "view source" button should show the Python source  
for the currently running application. In the tradition of Smalltalk  
(Alan Kay is on the OLPC board, and has endorsed the project's use of  
Python) the user should be able to edit any part of a "live"  
aplication and see the effects of the change immediately in the  
application's behavior. (A versioned document store will make it  
possible to roll back disastrous changes.) This is where Krstic wants  
my help: he hopes I can work magic and implement this feature for  
Python. I got started right away during the conference, with a  
reimplementation of python's reload() function that can patch classes  
and functions in place. Even this small component still has a long  
way to go; a checkpoint of the work in progress is checked into  
subversion as part of the Py3k standard library. That's not where the  
rest of my OLPC work will show up; they use GIT for source control,  
so I will get to learn that.
</quote>

At least, that's what it looks to me like he's saying, and he said  
much of the same thing on this list when he posted an improved reload  
module that he said was a simpler version of the one he was working  
on.  Maybe it won't be as powerful as Smalltalk's edit-and-continue,  
but it might end up being the 80/20 solution to the same problem.

Now if I could just get him to take concurrency seriously (and the  
only serious approach to concurrency that seems to be workable is  
what Erlang does).

--Dethe

"...our universities, I suggest, are not half-way out of the fifteenth
century. [...] The three or four years' course of lectures, the bachelor
who knows some, the master who knows most, the doctor who knows all,  
are ideas that have come down unimpaired from the Middle Ages.   
Nowadays no one should end his learning while he lives and these  
university degrees are preposterous. [...] Educationally we are still  
for all practical purposes in the coach and horse and galley stage."  
H. G. Wells