Re: [Chicken-users] Noob question: (re)compile FFI-accessing code within REPL

[Martin Percossi]

Graham, many thanks for you reply; your pointers were very helpful.

First: another question. Then: a few comments regarding chicken based on 
my (limited) use.

Question: there seem to be several ways to load a scheme source file:
(use test)
(require 'test)
(require-extension test)
What are the differences, and which should I prefer?

Second: some comments on chicken:

Chicken on unix works very well. The integration with emacs via quack is 
quite good, although not quite as good as, say, SBCL with slime (since 
that has auto-completion in emacs; as mentioned in my previous email, I 
can get it in csi REPL, but not from within emacs).  chicken-setup works 
beautifully, with the caveat that it dumps what seems like 
implementation files in the directory from which the command was run. In 
order to keep things tidy, this requires me to always switch to a 
standard directory (I put mine in ~/programming/scheme/chicken/eggs). 
I've played around with a few eggs, such as csv, readline, man, openal, 
octave -- and I'm very impressed with the fact that they Just Work. This 
is probably attributable to chicken's multiple and excellent FFI 
interfaces. This really invites the programmer to reuse existing C 
libraries -- and is indeed one primary reason I'm interested in Chicken.

On windows, it's a whole different story. I didn't manage to get the 
setup that I wanted. I'm not sure if that's because what I wanted can't 
be done, or if I did the setup wrong, etc. What I wanted was to 
*program* in a "unix-like" environment -- like MSYS -- but *targetting* 
native windows applications -- no extra, special cygwin dlls or the 
like. So I tried, and actually succeeded (after several aborted 
attempts) to build using CMake with MSYS buildfiles, having installed 
MSYS and MinGW into C:\MSYS\1.0 and C:\mingw, respectively. I realized 
after searching more on google, that while csi works from a windows 
CMD.EXE, it doesn't work from an MSYS rxvt -- in order for it to work in 
MSYS, I need the command `csi -:c'. No big deal for either of these. But 
now the show-stopper: chicken-setup doesn't work properly from either 
CMD.EXE or the MSYS shell. On CMD.EXE, chicken-setup crashes because it 
attempts to execute a pipe: `gunzip <FILE> | tar xvf -'. Unfortunately 
gunzip doesn't exist, and as a result the command fails (even if it did 
succeed, I'm not sure that windows supports piping so that the command 
would fail at the next step anyway!). So I tried unarchiving the 
tarballs myself in MSYS. Unfortunately, this solution is pretty bad. 
Firstly, because it only seemed to lead to more problems: on CMD.EXE, 
more commands that required "unix-like" features, and on MSYS, I would 
get an error message complaining that I couldn't generate executables (I 
think the problem is trying to invoke the "standard" gcc windows/msdos 
executable from the "cygwin-like" environment that is MSYS). Secondly, 
even if I had gotten it to work, it would have been highly impractical 
because each egg can have multiple dependencies, and I would need to 
repeat the above steps for all the dependencies.

So after spending five hours on the windows installation, I just gave 
up. This is a real shame, because win32 should be an ideal platform for 
chicken, with its great integration with other languages. It would be 
lovely to have a nice win32 GUI wrapper. It would be cool to use 
direct-x. It would be cool to be able to use Microsoft Speech API, etc, 
etc. And I think the fixes in chicken-setup.scm wouldn't be all that 
hard. There should be a new "build-platform" -- msys (currently, there 
is only cygwin and windows) -- that does the right thing assuming that 
you want to build native windows applications within a MSYS environment. 
I've seen a open ticket which details the changes necessary: replacing 
the tar and gzip commands with scheme versions that come preinstalled 
with the distribution.

More ambitiously, there should be a simple .msi installer which would 
query the user for installation directories of MSYS, CMake, MinGW, and 
Chicken, and then just unpack everything and possibly build -- so that 
at the end of the install, the user is dropped into an MSYS terminal, 
with all the tools ready to use. Currently, however, I get the 
impression that Windows compatibility is at very best an afterthought.

All in all, I'm very satisfied with Chicken, and will continue to use 
chicken for my scheme programming on Unix. I will however, steer clear 
of windows, at least until I'm better at scheme programming and I can do 
better than just pepper chicken-setup.scm with (print "Got here!") 
statements...

Thanks
Martin