Re: [Chicken-users] inventory of community skills

[Shawn Rutledge]

> > What kind of network-transparent GUI ideas are you talking about?
> >
>
> Yes, I wanna know about that, too!

It's hard to sum up, and some of it will nowadays begin to sound
familiar because others are working in similar directions (people have
told me oh that's just XUL or NanoX or X (hey, it works across the
network) or AJAX etc...).  Maybe the shortest explanation is that I
want a way to specify a portable GUI as succinctly as possible.  The
code for the application describes what it does, and how to spread the
work across multiple processors, but specifies (ideally) nothing at
all about the rendering of the GUI.  Then there are middleware pieces
that translate the specification to run on various kinds of front-ends
- everything from an embedded device that has only one button and one
LED, to a PDA or phone, to a web browser, to a cluster of touchscreens
(where you can put toolbars on one screen and the objects being
manipulated on another, and the global overview of the system being
manipulated on another, and so on).  Some apps will scale better than
others obviously, but they will all be written in the same language.
The middleware will try to push as much computation as possible onto
the client(s) so that they can be very responsive, hopefully not need
to use the network for every significant model change (like most of
today's web applications do), work offline some of the time and
re-sync model state later.  But this end goal may be out of reach
right now.  To start I just want to write a client-server system in
which all the code is in Scheme and the GUI specifications (in Scheme)
are fairly abstract, and then to use it for a bunch of real-world
applications I have in mind.  I have already written applications like
the ones I want to write in my career, so they don't worry me, but I
want them to be free for me to continue to develop and use, and avoid
having to rewrite or replace them every time a new technology comes
along.  Lisp has stood the test of time (although it morphed
somewhat).  It was based on a mathematical idealism, and then as the
story goes McCarthy was surprised when a grad student actually
implemented it.  It dates from the very beginning of computer science
yet is still in use today and has features other languages are still
just getting.  So I think Scheme applications written to a
sufficiently abstract GUI standard could have very long lives, too.
But my project will be a very long one; I'm resigned to writing a lot
of stuff bottom-up.  I want to be able to invent new widgets as I need
them, not be stuck with the existing set.  And it needs to run at
maximum efficiency at every scale of device.  But reproducing the
existing set of widgets (with some enhancements) is my first priority.
Then I can start going round-robin between writing the apps that I
have the most use for at the moment, being able to use those apps to
store my own notes and documentation, improving the level of
abstraction that I use when writing the apps, porting the GUI stuff to
more platforms, figuring out how to build the "distributed system"
aspects, and so on.