[Edu-sig] modelling objectoriented grapical user interface with and for beginners?

[L. Humbert]

Please,

let's try to put things together.
At first: as mentioned earlier, I'm a teacher in informatics 
-- not primary in mathematics (;-)

There is a little misunderstanding  in what to teach and how to teach 
elements in computer science, I think.

Many of us(?) believe that you have to know already "something" about
handling
a computer, before getting started Modelling in informatics.

But this is not quite right.
We should teach informatics to the beginner,
so - everyone gets a "right" mental model of working with a computer
(special with a GUI), 
(s|he) is teached to get a clear understanding of whats going on and
*how* this can be expressed 
*instead of* 
click here and click there and acitvate this button and scroll this area
and ...

I believe:
it should be possible to
build up the process of getting a clear imagination of GUIs capabilities
in
expressing and producing them with a little help from Python (or other 
languages)

Something like:

import ...
..
myDesktop=GUI(thisInformaticSytem, thisNetworkEnvironment, ..?)
myHomedirectory= myDesktop.showDirectory(thisNetworkEnvironment.home,
"collapsed")

while not thisInformaticSytem.shutdown():
    if thisInformaticSystem.getUserAction():
        myDesktop.broadcastAction(allElements_on_Desktop)



It should be possible to (re|construct) *simple* handling elements *and*
to
compare them with "the real" OS-functions. 
By this, a novice learner should get the power of *constructing* 
some functional elements of her own.
An example could be producing a very simple
 desktop manager within a couple of lessons, I hope.

This way, it should be possible to set up a clear understanding of what 
wents on behind the scene 
*and*
to empower the children in formulating principal understanding for
eventdriven applications not only by describing them, but with the power 
of an interpreted language.

Objectoriented Modelling [process] (most elements are done without 
programming)  for beginners (6. Graders) is teached in bavarian 
(a region in Germay) 
- you may take a look at
http://www-schulen.informatik.tu-muenchen.de/didaktik/material.html

But: it isn't done with support of a language, so only the primary
elements of 
modelling are discussed (and "learned") in this courses.

Another example:
pupils learn to handle presentation and represantion
of looking at
directories and their content

this can (and is) done "IRL" with whathowever GUI

I think, it could be done
by using a simple class to allow *them* "reconstructing" the 
functional behavior ...

another piece of an experimental GUI-element-handling system

class GUIdir(..):
    def __init__(...):
        ...

    def show(self, lookat="collapsed"):
        ...
        
    def sort(self, crit="name", modus="detail", ...):
        ...    

It should be possible to realize such rudiments without relying on a
special
GUI, so the main classes would be gui-independent.

The teacher/pupils/students (c|sh)ould decide, which concrete GUI to use
in a course, so
it could be
tkinter, pygame, swing (for using it with jython), wxpython, gtk, ... 

In trying to realize this project, a teacher is enabled to focus on
those elements,
which (s|he] wants the pupils/students 
- to understand and/or
- to use when later on projects are planed and realized.


    Ludger
    

PS: for the artists?
a)
on the adobe web site, there are filters which are realized in Python
http://opensource.adobe.com/
Python action plug-in for Adobe Photoshop. 
Allows a user to write Photoshop action plug-ins using Python. Has
Python interfaces to all the actions APIs. ...

b)
there are Python Filters for THE GIMP too:
http://www.daa.com.au/~james/pygimp/