RE: Functional Paradigm popularity and Maths (Was: XML as a transition to s-expr)

["David Simmons" <address@hidden>]

I suggest you contact Alan directly and ask for good references (also
query vivarium). He is pretty accessible, and this is a topic that has
historically been very near and dear to him. 

You can also peruse the web for current educational activities relating
to Smalltalk.

For Example:

    http://dmoz.org/Computers/History/Pioneers/Kay,_Alan/

    http://www.squeakland.org/learn/

    http://minnow.cc.gatech.edu/squeak/378

    http://www.squeakland.org/listarchive/squeakland/msg00029.html

    http://www.squeakland.org/learn/elementary.html

I would strongly suggest that what has "historically" made Smalltalk
applicable here is not the "language syntax", but rather the
language-semantics of objects and their presentation in the form of the
visual tools of an application (where Smalltalk evolved the
overlapping/windowing UI we all know and love today :-).

-- Dave S. [SmallScript LLC]

SmallScript for the AOS & .NET Platforms
David.Simmons@SmallScript.com | http://www.smallscript.org


> -----Original Message-----
> From: Tim Hickey [mailto:tim@cs.brandeis.edu]
> Sent: Wednesday, December 19, 2001 5:51 AM
> To: David Simmons
> Cc: 'Don Blaheta'; ll1-discuss@ai.mit.edu
> Subject: RE: Functional Paradigm popularity and Maths (Was: XML as a
> transition to s-expr)
> 
> On Wed, 19 Dec 2001, David Simmons wrote:
> > Well, ok. I have to jump in here a bit.
> >
> > Alan Kay's goals for Smalltalk were to invent a language that
"children"
> > could program. In that, it has been shown to be quite successful.
> > Children of ages 4 and up have been able to understand and write
> > programs and design objects in Smalltalk.
> 
> Could you pass along any references to this work on teaching four
> year olds how to program in Smalltalk?  It sounds interesting (like
> the Logo work). I'm actually more interested in teaching college
students
> than children however.
> 
> >
> > It takes just hours for most people to pick up Smalltalk and begin
to be
> > productive.
> >
> > Lisp requires one to think in terms of "lists" and "recursion". This
can
> 
> Not ncessarily. We spend about six weeks teaching web programming in
Lisp
> before getting into lists and recursion. Quite a bit of web
programming is
> in fact, reactive programming. Process a form by reading the form
inputs,
> reading some data from files, writing data to other files (or
databases),
> sending email, and generating a web page. None of which requires
recursion
> and all of which is useful and fun for novices. Likewise, there is a
> fairly large design space for interactive programs that are reactive
and
> do not deal with lists, e.g. creating windows with menus, buttons,
> textfields, etc. and adding actions that read from various components
and
> write to others. In this contest lists arise naturally (e.g. how do I
deal
> with a form where multiple checkboxes are checked ---> leads into uses
of
> "map" or list recursion).
> 
> > be a very difficult cognitive barrier that is limited by the persons
> > (mental development -- abstract thinking) "age" and the
corresponding
> > "educational" exposure (to abstract thinking) of the person
involved.
> >
> > For children, thinking in terms of conversations with "things" and
> > adding new "verbs" or "nouns" for those conversations is easier.
> 
> But Scheme can also express the idea of dealing with "things" and
> adding "actions", e.g., the following is a snippet of code using
> a GUI library written in Scheme (such libraries are clearly easy to
write)
> and that is a typical 20 minute "quiz" question.
> 
> ;;;; untested code, using the "JLIB" library of Jscheme
> 
> (define tx (textfield "" 10))
> (define ty (textfield "" 10))
> (define tz (textfield "" 10))
> (define ta (textfield "" 10))
> (define w
>   (window "test"
>     (menubar
>       (menu "File"
>         (menuitem "quit" (action (lambda(e) (.hide w)))))
>       (menu "Help"
>         (menuitem "about" (action (lambda(e) (.pack w) (.show w))))))
>     (col
>        (label "triangle area given three sides")
>        (table 3 2 (label "x") tx (label "y") ty (label "z") tz)
>        (button "compute area" (action (lambda(e)
>          (let* (
>             (x (readexpr tx))
>             (y (readexpr ty))
>             (z (readexpr tz))
>             (s (/ (+ x y z) 2.0))
>             (a (sqrt (* (- s x) (- s y) (- s z) s)))
>                )
>           (writeexpr ta a))))
>        (row (label "area") ta))))
> (.pack w)
> (.show w)
> 
> I would claim that this type of program allows students to
> think about objects and actions in a very simple and declarative
> way. It would be interesting to see how such a simple application
> looks in other languages (python, perl, smalltalk.
> 
> Also, as for the )))))) build up, (say at the end of menus).
> Students are generally able to "count" parens by naming the
> enclosing expression, e.g.
>   close-show, close-lambda, close-action close-menuitem close-menu
close-
> menubar
> as long as the expression fits on one page, this is easy to do without
any
> support. Once procedures get larger than a page, its often a good time
to
> refactor and abstract.
> 
> >
> > So just what are we saying...
> >
> 
> I guess I'm saying that the simplicity of the Scheme syntax and the
> simplicity of the functional model (as illustrated in the previous
> example) makes it easy to teach fairly
> sophisticated programming to students with no programming background.
> 
> What is it about smalltalk, python, etc. that would make it easy
> for novices to become productive?
> 
> ---Tim---
>