[geeks] hehe

[Joshua D Boyd]

On Sat, Dec 01, 2001 at 02:58:07AM -0500, Greg A. Woods wrote:
> [ On Saturday, December 1, 2001 at 01:53:02 (-0500), Joshua D Boyd wrote: ]
> > Subject: [geeks] hehe
> >
> > Sigh.  I keep looking for new lisps or schemes to try, but the only thing I can
> > find with decent GUI support for linux seems to be GUILE, and that doesn't 
> > really strike me as a serious development environment.  I like scheme48, but
> > it seems that I would have to modify the VM to add X and GLX support.  clisp
> > also seems nice, but again, you have to jump through some major hoops that 
> > seem to effectively come out to making a custom VM.
> 
> How about STk?  DrScheme?  RScheme?  Mzcheme?

Hmm.  I'm looking at STk.  It might be OK.  The development environment looks
nice.  I'm not finding docs on adding extensions though.  

BTW, I did find something called cl-gtk.  It is mainly aimed at common lisp, 
but if I read the documentation correctly, they wrote it to use a named pipe
for the CL programs to drive the GTK display, meaning that it should be pretty
easy to get it to work with and Scheme (or other language) that supports pipe 
and other posix calls.  However, what I really want is opengl support.  On the
up side, gl is so simple, and it doesn't use things like callbacks, and it 
hardly uses pointers (textures and vertex arrays), so bindings should be 
pretty easy, although performance via pipes probably isn't so hot.

Anyway, back to the schemes you mentioned.  DrScheme had some nice development
features, but it didn't have great gui support (it had good gui development 
tools, but under windows at least, it didn't have very good support for writing
scheme programs that created windows and buttons, etc).  It seemed a bit too
educationally oriented.

RScheme.  I have that installed on my lintel workstation at home.  It's blurb
in dselect was very attractive.  It has support for pipes and such.  It has 
native threading (so does Scheme48, I think).  I have yet to be able to find
out how to bind c libraries to it.  This doesn't seem to be covered by the 
documentation.  Until I found scheme48, this is what I used on Linux.

MzScheme.  I haven't looked at this as hard as I should have.  Apparently a 
simple scheme OS was created in less than a day by modifying the VM to bind it
to the OSKit.  DrScheme is built on it.  For professional Win32 development,
MzScheme appears that it would be the way to go.  It supports COM, ActiveX, and
it's own cross platform GUI toolkit.  I would assume that this means that doing
a proper Windows GUI in MzScheme is possible, but if not, it still means that 
it would be good for server side programming.  It supports pipes and other
system calls, so it should be easy enough to make it work with cl-gtk.  I just
haven't gotten around to trying in under linux.

Now, what really get me pissed off about languages under linux is something 
that qbasic (and QuickBASIC) did.  qbasic made it easy to make calls to any
C library, as long as you didn't need callbacks or pointers to do so.  Under
early versions of VisualBasic, they added the ability to easily call and C 
DLLs, as long as it didn't require callbacks (pointer were OK though).  
Under more recent versions of VisualBasic, even callbacks are easy to deal 
with.  (Calling C++ objects is impossible currently, unfortunately).  If 
Microsoft can make BASIC deal with the outside world in such a convienient
manor, why can't superior systems like all the different Schemes do the same 
thing?  GTK is specifically written in C to make it easy for other languages
to bind with it, and yet all the other languages make external bindings sooo
difficult.
 
> Of course if you're having this much fun with lisp & scheme, and if you
> want to do GTK stuff for UI too, then you should get along even better
> with ruby and ruby-gtk!  ;-)

I've seen ruby around.  My impression of it was that it was very capable.  I 
didn't find a compelling reason to use it instead of Python, and I really like
the emacs Python support.  

However, I really like that scheme and lisp consider themselves to be data 
that can and should be manipulated.  I also find having to use recursion for 
everything to be rather an interesting challenge (OK,
common lisp doesn't force this, but I try to do it this way, since at this 
point, if I don't I would have code that I can't yet easily port to scheme, and
I haven't yet been able to settle down to one or the other).

At this point, I still do a fair amount of Python and C/C++ development.  I'm 
not good enough to be able to do everything in scheme or lisp, and I have large
amounts of code written in other languages as well.

-- 
Joshua D. Boyd