Mailman 3 May 2001 - Edu-sig

programming for artists
by bchang＠artic.edu 31 May '01

31 May '01

hello, i teach multimedia and web design at an art school as part of a curriculum that includes neon, kinetics, holography, microcontrollers, digital imaging and video, and pretty much anything else that involves technology. a lot of the problems our students run across require programming of one kind or another, and this trend seems to be increasing. my courses concentrate on programming a good deal, using javascript, flash/actionscript, or director/lingo for websites, cd-roms, gallery installations, etc. however, a good part of every semester is taken up with basic programming concepts before we can get to the "good stuff". i'd like to introduce a solid programming class at the foundation level, and python seems like an interesting possibility. i haven't learned it yet, but have been working in c++, java, perl, etc. for a while so hopefully i can get a handle on it by september <g>. the problem with the approach we've been using (javascript, lingo, or actionscript as an introduction) is that each of these languages has a lot of features and quirks which are very unique, which gets in the way of teaching general programming concepts. i'd like to use something that will let me teach core concepts quickly without getting stuck on too many language- specific details. at the same time, whatever i use will have to be something that students can use to produce interesting results quickly as well - since this is an art school, we're really interested in artistic applications of programming rather than, say, calculating compound interest or the traveling salesman problem. so, my question is - has anyone used python for teaching art students? does this sound like a reasonable thing to do? oh, one problem - it won't even be a full semester course, but just 5 weeks - the foundation class also spends 5 weeks on sound and 5 on electronics. not my choice, just the way the curriculum is structured. so what i'd want to be able to do is get students going with python, understand some basic programming concepts like variables, math, strings, functions, and hopefully events, and be able to make something simple but visually pleasing. does that sound possible? thanks, Ben Chang bchang(a)artic.edu Department of Art and Technology Studies School of the Art Institute Chicago, IL

2 1

Writing a web server
by Arthur_Siegel＠rsmi.com 30 May '01

30 May '01

Brent wrties - >How's this for a possible 9th/10th grade course: >* Web Programming with Python - Students will program a fully-functioning >website from scratch. Students will choose from building an interactive >storybook where the reader influences the outcome of the story, or a >web-community site with a message board and voting booth. No prior >programming experience necessary. > etc. I strongly agree that this kind of approach will have kids sitting up straight in their chairs.. Would have me sitting up straight in my chair. Wish I had more time to spend with the web based toolset provided with and by Python - not so much to do a site, but to get a decent peek under the hood of Internet technology. Months ago I talked about my niece showing off the radio she built from a kit - coiling wires around a tube etc. Kids curiosities are exactly what you expect them to be - how does the stuff around me work. Conways Game of Life is interesting enough, but does not speak to kids fundamental curiosity. The problem is that any discussion of Web and education seems to quickly become A Project - building some sophisticated web-based infra-structure/learning environment. And building a few reputations in the process. Taking something as simple as SimpleServer and making it, if anything, simpler - as you are suggesting - building ones own Web with coiled wires, is the truly revolutionary approach and where the gold is, IMO. ART,

1 0

programming for artists
by Arthur_Siegel＠rsmi.com 30 May '01

30 May '01

BEN WRITES - >oh, one problem - it won't even be a full semester course, but just 5 weeks - the >foundation class also spends 5 weeks on sound and 5 on electronics. not my >hoice, just the way the curriculum is structured. so what i'd want to be able >to do is get students going with python, understand some basic programming >concepts like variables, math, strings, functions, and hopefully events, and be >able to make something simple but visually pleasing. does that sound possible? Here in Pythonland all is possible. Seems to me Python with Numeric and VPython (see http://virtualphoton.pc.cc.cmu.edu/projects/visual/) is the best toolset you are apt to find to accomplish your mission. Have you looked at VPython and its demos yet? ART

1 0

Regular Expressions
by Brent Burley and Pat Erb 30 May '01

30 May '01

Does anyone teach regular expressions? I think it's one of the most powerful programming tools (and from my informal observations, one of the most overlooked). A rule of thumb I use in Python (and Perl) is that if you're accessing individual characters in a string, especially in a loop, there's a good chance it would be better done with a regular expression. Regular expressions can be intimidating to the uninitiated, and even the experienced often require several tries to get an expression right. Python's interactive nature helps, but it's fairly tedious to test a regular expression at a python console. I've written a tool called Recon , the Regular Expression Test Console. I use it for debugging regular expressions, but I also think it would be a great teaching tool since it provides a very simple, focused environment with detailed feedback. It's best described by the screen shot: http://erburley.home.netcom.com/recon.html If you want some exercises, try to write expressions for the following: - date (single or multiple formats) - currency - numbers, int/float/fraction/hex/e-notation/etc - words (consider line breaks and hyphens for a challenge!) - doubled words (as in "the the") - phone number, w/ international prefix - program identifiers - python comments (don't forget to skip # in a string) - C++ comments (hard to do right!) - python argument lists, including keyword args Brent Burley

2 1

Speaking of factorials...
by Kirby Urner 29 May '01

29 May '01

While we're on the subject, I just wanted to go over something about the combination function, defined as n! combo(n,k) = -------- k!(n-k)! You find this guy all over in math. You can use it to derive the kth term in row n of Pascal's [famous] Triangle for example. Citations: http://www.mathforum.com/epigone/math-learn/zulphingyee/ http://www.mathforum.com/epigone/math-learn/snoipumkhee/ But it's wasteful to implement this expression literally, without interpretation. Terms on the bottom inevitably cancel with terms on the top, so you end up "throwing away" some of the multiplications -- so why do 'em in the first place? For example, consider combo(10,4) = 1*2*3*4*5*6*7*8*9*10 -------------------- 1*2*3*4 * 1*2*3*4*5*6 You can use either the k! or the (n-k)! to cancel multiplications in the numerator. One should take one's pick and do so, rather than carry out all multiplications both above and below. Using Guido's little timer guy from his excellent essay at http://www.python.org/doc/essays/list2str.html (scroll down), we can test the relative efficacy if canceling (goodcombo), vis ignoring the opportunity (badcombo): >>> def goodcombo(n,k): return reduce(mul,range(n,n-k,-1))/reduce(mul,range(1,k+1)) >>> def badcombo(n,k): return (reduce(mul,range(1,n+1))/ (reduce(mul,range(1,k+1))*reduce(mul,range(1,n-k+1)))) >>> import time >>> def timing(f, n, a, b): print f.__name__, r = range(n) t1 = time.clock() for i in r: f(a,b); f(a,b); f(a,b); f(a,b); f(a,b); f(a,b) f(a,b); f(a,b); f(a,b); f(a,b) t2 = time.clock() print round(t2-t1, 3) >>> timing(goodcombo,500,10,6) goodcomb 0.275 >>> timing(badcombo,500,11,6) badcomb 0.453 I rest my case. You'll frequently find variants of badchoice in Python modules, e.g. here in in Robert Kern's totally awesome and way cool clifford.py at http://starship.python.net/crew/kernr/source/clifford.py def comb(n, k): """\ Returns /n\\ \\k/ comb(n, k) --> PyInt """ def fact(n): return Numeric.multiply.reduce(range(1, n+1)) return fact(n) / (fact(k) * fact(n-k)) Easier to read, maybe, but not faster to run. Speaking of Clifford Algebra, that's the next big thing in geometric algebra (GA) these days and finding a way to bring GA to secondary schools is a front lines curriculum writing challenge. Maybe Python can help, as per this post to a Community Colleges list (one of mine, of yesterday): http://www.mathforum.com/epigone/mathedcc/lorswinbleh Kirby

2 4

Re: [Edu-sig] Regular Expressions
by Alan Gauld 29 May '01

29 May '01

>Does anyone teach regular expressions? I included a chapter on RE in my beginners book. The bulk of the content can be found in an article on the infomIT web site (you need to register, but its free). > I think it's one of the most powerful programming > tools (and from my informal observations, one of > the most overlooked). I agree, hence the chapter. But I also acknowledge that REs can be very daunting to a novice - they can just look so incomprehensible. > I've written a tool called Recon , > the Regular Expression Test Console. If I'd known and its freely available I might have asked permission to put it on the CDROM! :-) >http://erburley.home.netcom.com/recon.html It certainly looks good... Alan G. http://www.crosswinds.net/~agauld

1 0

foundations,
by Matthias Felleisen 29 May '01

29 May '01

Kirby writes: I guess I'm feeling uneasy with a foundational approach that doesn't bring in the concept of objects closer to the beginning. The object concept is an important one. Just procedures and data, without objects, seems a rather scattered/cluttered approach. Shouldn't newcomers learn the object model right about where this rational numbers example is presented? Certainly building rational numbers as objects would be a standard exercise in a Python-focused curriculum (might be a math class -- if the distinction matters). You need to distinguish several things: - class-based programming & object-oriented computation - object-oriented programming & object-oriented computation - modules and representation hiding Functional programmers prefer modules over classes. In PLT Scheme we use both. The idea is simple. You write a module and you export just as much as you wish. For example, (define-signature Sequence^ ( build-sequence ; Element ... Element -> Sequence iterator ; Sequence (Element -> X) -> Void )) (define Sequence@ (unit/sig (Sequence^) (import ...) ; imports ; ------------------------------------------------------- ; body (define-struct hide (>sequence)) ; a structure for encapsulating stuff (define (build-sequence . x) (make-hide ... x ...)) (define (iterator sequence function) (let ([internal-representation (hide->sequence sequence)]) ...)))) defines a module that creates an opaque type sequence by exporting constructor and an iterator but no tools to get at the internal representation. In other words, it is a mechanism for coupling data and functions in an intimate manner (and units are first-class values on top). It looks even better if you write this with ML signatures: signature GROUP = sig type Element val plus : Element Element -> Element val id : Element val inv : Element -> Element end functor Group(type E) : GROUP = struct type Element = E; ... end and you can parameterize functors and units over imported mathematical structures: functor VectorSpace(structure Field) : VECTORSPACE = struct ... end and then you can use Real or Complex or some other field to build vector spaces. -- Matthias P.S. Someone asked whether I'd use ML first. No. Kids have enough trouble understanding computation. Type checking and proves are confusing them even more.

2 1

text compression as a learning tool
by Timothy Wilson 28 May '01

28 May '01

Hi everyone, I'm trying to come up with some more comprehensive projects to supplement my Python class for next fall. I'm definitely going to do a little "clubhouse crypto" (thanks Kirby and Neal Stephenson for picquing my interest). Before undertaking my own study of text/data compression, I'd like to get the opinions of the list members here about whether you think this could be an appropriate subject for beginning to intermediate Python programmers. Any particular references to compression algorithms or other background materials? Other thoughts? -Tim -- Tim Wilson | Visit Sibley online: | Check out: Henry Sibley HS | http://www.isd197.org | http://www.zope.org W. St. Paul, MN | | http://slashdot.org wilson(a)visi.com | <dtml-var pithy_quote> | http://linux.com

4 5

Re: Lisp vs Scheme vs Python
by Matthias Felleisen 28 May '01

28 May '01

Kirby, your teacher understood Lisp and Lisp vs Python very well. He didn't understand Scheme and why recursive programming matters. Scheme and S-expressions: your teacher was clueless in that regard. Scheme, macros and do: You don't need to teach about macros to use looping constructs. You can use the ones that every Scheme provides (do) and introduce new ones for your students, if you believe it's best. Of course it isn't :-). Recursion: Read up on data types and how to specify them. Mathematically speaking (and that's what you want to do), there are basic sets subsets unions products inductive definitions (co-inductive definitions). That's it. Your basic functions in a program should match the data defs. The only way to match induction is to use recursion. The kind of recursion that you know (e.g. quicksort, fractals) has little to do with data. It's an algorithmic technique beyond basic programming. Loops are short-hands for linear recursions. But because there is an infinite way of doing linear mutual recursions among data defs, you can't get away with a finite number of looping constructs -- if you want to match data defs and program defs. You need recursion. Read HtDP (http://www.htdp.org). -- Matthias

4 10

Re: Lisp vs Scheme vs Python
by Matthias Felleisen 28 May '01

28 May '01

"Tim Peters" <tim.one(a)home.com> writes: I'd add finite maps to the list, aka associative arrays ("dictionaries" in Python). Viewing a finite map as a subset of the product of the key and value sets isn't particularly illuminating, and especially not in a programming context. Yes, finite maps and functions should be added to the constructors of the data definition list. Omitted by accident. But, on recursion vs iteration you don't seem to know much about Scheme: Heartily agreed. Where Python parts company is in believing that *all* iteration is better expressed via recursion, and in particular iteration over lists. The notion that for element in list: do something with element 1. Here is why this match that I am talking about matters: datatype list = null | cons of int * list ^ | | | ------------------------------ I am using ML notation to spec a datatype, and the backpointer shows the self-reference in the data definition. Now compare this to the function definition: f(some_list) = (cond [(null? some_list) ...] [(cons? some_list) ... (first some_list) ... f(rest(some_list))]) ^ | | | -------------------------------------------------------------- Number of function clauses: 2, because there are 2 clauses in the data def Selectors in second clause: 2, because there are 2 fields in the data def Recursion in the second clause: yes, because there is self-ref in the data def Recursion on the second selector: yes, because ... Now show me how to explain this with a for-loop. Now show me how to tell kids that all this generalizes to dd's with 10 clauses and 22 self-refs? 2. Scheme abstracts uniformly with lambda (Python doesn't). So, of course we teach that the same pattern for list-processing comes up over and over again. And then we show how to abstract: using map and for-each. From then on students understand that (for-each (lambda (element) (display element) (newline)) list-of-elements) is perfectly okay. But, they also understand how to abstract for a data def with 22 clauses and 10 self-references. 3. You write more stuff on reductionist view of programming. I didn't advertise a reductionist view. I said that one teaches matching of data defs and functions first, and then one moves on to abstractions. The reason is that students understand the why and learn to do things on their own rather than copy patterns and play monkey at the keyboard. Having said all that one can teach some of these things in Python of course. (If Python had abstracted in a uniform fashion, that would be easier of course.) Having said all that, I must admit that I don't think of R5RS but my own Scheme. -- Matthias

2 1