[rgui-user] Jumping Right In

[Tom Sawyer]

first let me welcome you to the GUtopia Developer's Mailing List. your
participation in this project is greatly appreciated! and i hope, at the
very least, that you all gain something from our discussions here.

QUICK NOTE: i am cc'ing this to the gutopia-user list "just in case". if
you are subscribed to that list but wish to participate in this dialog,
please subscribe to the gutopia-dev list instead. doing so does not
mandate you to actually "develop" anything. -tom

okay, lets get to it...

i had thought about giving some sort of overview here, pointing out the
goals of GUtopIa, etc. but i decided otherwise. i think all of you
understand the overall drive behind GUTopIa. further, i am interested in
hearing what you forsee GUTopIa accomplishing --without further casting
my own opinions beyond what i have already sketched in the wiki. so this
then is a "pre-topic" of discussion.

the main topic of discussion, with which we shall kickstart this list,
derives from a small but thought provoking ruby-talk post by
Massimiliano Mirra.

  "It seems that quite a few of us have been experimenting with
interface abstraction by using standard tools only. I wonder if there is
merit in the idea of joining minds and creating a proof-of-concept
application that uses the best of what we've learnt. In the worst case a
fine tuned skeleton could be produced that people would be able to use
as a guideline; in the best case a design pattern could be isolated and
then required at will, like observer.rb or forwardable.rb."

so here we are, asking this question in earnest: is there a design
pattern that can be isolated out of gui interface abstraction? it is an
ambitious question. to facilitate it's dialog i have created a wiki page
devoted to it called GUtopIa Design Patterns. there i will place
information related to the ideas distilled from this conversation.
currently i have placed some rough considerations of my own on the page
simply to get it started. take a look. 

  http://www.rubygui.org/cgi-bin/wiki.pl?GUtopIa_Design_Patterns

as you will gather from that wiki page, i suspect that much of this
design pattern question relates directly to the developers perspective
of coding with a gui api. what are the full range of aspects this
question considers? ... so here then is our primary topic of discussion.

lastly, i'm going to jump straight into the middle of our primary topic,
with a concern i have about gui abstractions using ruby. i have
contemplated the folowing difficulty for some time and have yet to see
any complete solution. it is the question of "automagical" bindings.
just in case this terminology isn't known by all, an automagical binding
is a set relationship between variables and/or methods such that when
one is changed or called the related variables and/or methods are
changed or called AUTOMATICALLY. with appreciated input from a few
developers, i have all but worked out a solution for the typical cases:
trapping on #x= methods for variable changes and trapping on methods in
general. you can see the code for this in gutopia.rb in the savannah
cvs; it is achieved with the first method called #bind. unfortunately
this doesn't quite go far enough. for what if you have an array you wish
to bind to? there a number of way in which to manipulate the contents of
an array, sucha as #<< and #sort!. how can all of those possibilities be
reasonably trapped?

i hope this serves as a good start to our discussions. please, if anyone
has anyhting they'd like to add to the above, do not hesitate to do so.

okay guys, have at it :-)

-- 
~transami