Status

[Havoc Pennington <rhpennin midway uchicago edu>]

Hi,

This list has been silent for a while, especially with respect to Guppi
itself, though the underlying Goose library is moving right along. So
here's a note about what's going on, and how we intend to move past the
vapor stage. We actually have a lot of code ready to go in gtk--plot and
goose, but Guppi itself doesn't do much.

Due to massive Gtk-- changes and other stuff I needed to do, Guppi was put
on hold for a while. In this time several things have happened:

 - The Gnome Canvas has evolved a good bit and is now in its final 
   "1.0" form, ready to be used
 - Gnome 1.0 / Gtk 1.2 have stabilized 
 - (less good) Guppi has become totally uncompilable due to Gtk-- 
   breakage; I estimate that it would take days just to make it
   build again; Goose caused some breakage too but less extensive
 - Goose has matured quite a bit and has quite a few nice features
 - Gtk--Plot has been moved to Gtk+ rather than Gtk--, and some 
   new things have been added to it
 - Jon and I have learned the wonders of Guile (I know some people
   will make I told you so noises :-) and there are the beginnings 
   of Guile bindings for Goose objects

I'm currently planning to move Guppi away from Gtk-- entirely. For a
couple of reasons; first, Gtk-- is not stable enough yet, so it's a pain
for me to code to; second, it will be a lot easier for people to compile
things and help with the Guppi coding effort. We might move back toward
Gtk-- later if it seems appropriate; Gtk-- interoperates nicely with Gtk+,
so it can be gradual. But for now, gnome-libs and goose will be the 
only dependencies.

Looking at all the accumulated cruft in the totally uncompilable Guppi
source tree, I decided it would be easier to start on a clean slate,
learning from past mistakes. I won't be rewriting everything; plenty of
cut-and-paste will go on, but I have created a new source tree, which is
in CVS under "guppi2."  This is easier than trying to fix 4000 lines of 
code in-place.

Here are the goals of the Guppi project:

 - A plotting program that is purely graphical and easy-to-use;
   scripting will not be required
 - Embedability in other Gnome applications; this is a long-term 
   goal, after gnome-libs 1.0 Miguel and others are hoping to 
   resume Baboon development to enable it.
 - A "data browser" with import/export capabilities; this is 
   used in the standalone Guppi, while the embedded Guppi will 
   get its data from the enclosing application
 - GUI interface to the statistical functions of Goose; various 
   data transformations, etc.

In addition, I want to add a nice Guile scripting feature; this will be 
a sort of "advanced" mode. It will let you access the Guile bindings for
Goose.

A big advantage of Guile: you'll be able to load other Guile modules, such
as Gnudl perhaps (I'm not sure how Gnudl is set up), and use them too. We
can implement translations between various foreign objects and Goose
objects. There's a lot of potential power here.

I don't know how many people are actually on this list, but here are some
things I could use help on:

 - Pointers to example GUI applications that do plotting and/or 
   data browsing. They can be proprietary applications. If I can
   find good examples, I will clone shamelessly. May even buy 
   a license in order to clone. (I am looking for examples that do not use
   scripting as the main interface. I have plenty of shell-like tools that
   can pop up a plot.)

 - Goose's Guile bindings could use some work; this is pretty easy to 
   hack on. The key doc to read is "Data Representation in Guile,"
   see http:/www.red-bean.com/guile/ under documentation. Goose 
   has a couple of examples already.
   
 - I want a "Guile terminal" feature; I've tried implementing this in 
   various ways, and decided that basically the following is necessary:

    - A child process (eventually running in a ZvtTerm, but for now 
      it can just be on the console) which does the readline() thing - 
      prompts for lines, gets them.
    - Whenever the child gets a line, it should send it to Guppi for
      evaluation in Guppi's interpreter. Guppi will use 
      gtk_input_add() to detect data on the child pipe.
    - The parent should send the output to the child, and the 
      child should display it. 
    
    Pretty much need to re-implement Guile's (top-repl), but 
    using gtk_input_add() and a child process. This should not 
    be that hard for someone that knows Guile... just doing it 
    sans Gtk with a select() in the parent would save me a lot
    of time.


Well, comments and suggestions appreciated. We'll see how this goes on
attempt #2, older and wiser.

Thanks,
Havoc