Hello from a new user interested in shipping applications

[Paul Fernhout <pdfernhout@kurtz-fernhout.com>]

Hi Schemers.

My name is Paul Fernhout and I am part of a husband-wife team that makes
education software (among other things). Some of the software is under
the GPL, some is under the MIT/X license, and some of it is shareware.

Since we're a tiny two-person company and both of us also do consulting,
we really need an "edge" over just slogging away in C++ (perhaps with
wxWindows) if we are going to be able to make neat products in the time
we have. In the past, Delphi has been something of that edge. Also, if
the work isn't somewhat fun, progress is not as easily sustainable.
(Unfortunately, Delphi isn't that fun.) So, I am wondering if MzScheme
could be that edge and be fun too.

I'm currently evaluating MzScheme for use in making a cross-platform
version of our shareware PlantStudio application and possibly some other
applications. Our PlantStudio product is now in Delphi and there is a
demand for a Mac version.
Right now I'm estimating support and development pros and cons with
MzScheme versus other open source alternatives (mostly beefing up Squeak
Smalltalk or using Python/wxWindows). I am also considering several
commercial products (including some Lisps (MCL & Franz) and VisualWorks
Smalltalk) but the desire of making an open system for end users (i.e.
including a compiler) is somewhat at odds with most commercial licensing
structures and costs. 

The cross-platform nature of MzScheme, well thought out modular core,
and relatively small disk footprint and manageable complexity all look
good. My major concerns are related to numerical speed and GUI
stability, with some secondary ones related to issues like full
debugging support, typical limited browsing tools in Lisp, and breadth
of built-in cross-platform library support (i.e. sound I/O, 3D graphics,
truncating/flushing files etc.). I am also concerned that if I decide to
do Lisp, maybe I should just go with Common Lisp (although I don't see a
current one out there doing GUIs on both Mac and PC).

I've been trying out MzScheme and MrEd and I must say I am quite
impressed with the excellent system and the quality of the
documentation. My wife has not used Lisp and MzScheme's training
materials would be a big plus. I have also reviewed some of the email
archive and its obvious the responsiveness of the core team is quite
good. It looks like a pleasent enough community, although perhaps not
yet with quite the volume of say the Squeak list or the Python newsgroup
(which is both good and bad).

I've most recently been using mostly Delphi, Squeak and Python for my
own OO work, doing mostly C++, Java, and VisualWorks for clients. I
haven't done any serious Lisping for many, many years. However, I
originally learned hands-on OO on a Symbolics using ZetaLisp and
Flavors. I always liked the ability to have both the OO and non-OO
worlds in Lisp. Putting up a GUI in MzScheme really gives me that warm
fuzzy feeling of being home, almost leaving me wondering where I made a
wrong turn in my programming career (back during the AI winter). :-)

I see MrEd uses wxWindows for the cross-platform support. I've used that
with Python and it does work nicely. (A few memory leaks under wxPython
though -- probably Python related.) 

I like the MzScheme networking support -- I just used the pop3 example
to check my email and it works nicely.
 
One big thing that appeals to me about MzScheme is the educational
emphasis. We are interested in shipping open versions of educational
simulations (like our Garden Simulator now in Delphi and available under
the GPL). It would seem MzScheme and MrEd might do this nicely, and with
only a minimal performance penalty using the right sort of compiler. We
could code models in MzScheme, include the compiler (at least the
built-in byte-code one) in the application, and let the end user modify
the models as much as desired, with a pointer to the excellent MzScheme
documentation as their reference. This would all have a reasonable
footprint compared to installing a typical C++ or Delphi compiler.

The combination of  MzScheme + Flux as a standalone system also sounds
really cool, as I have some interest in embedded systems and systems
that are open from the ground up. 

I also have an interest in Open Hyperdocument Systems / Dynamic
Knowledge Repositories such as envisioned by Doug Engelbart at his
Bootstrap Institute.        http://www.bootstrap.org/  
It seems MzScheme might be a nice platform for that sort of work,
especially since one could include the entire compiler, documentation,
etc. in an open ended package.

A few questions:

Are people (students, educators, developers) having fun with MzScheme?

Can anyone comment in general on the numerical performance of MzScheme
compared to C or other Lisps? I am concerned by some references to speed
of 1/30 - 1/100 that of C in some cases. For example, if I am
multiplying matrixes of floats, how much of a hit do I take if I do it
all in MzScheme? I would think in theory this could be minimal with some
tricks and a good compiler (some Lisp compilers get quite close to C
speed). And of course, one might translate a subset of Scheme to C using
mzc (as Squeak currently translates a subset of Smalltalk to C),
although on casual perusal it appears this process is not designed for
maximum numerical processing speed from type hinting. Has anyone
actually done a major numerical simulation in MzScheme who can comment
on the experience? Is it "close enough"? Are there any specialized array
math libraries for MzScheme? Python for example has a "numPy" extension
that lets you do array math (FFTs etc.) at near C speeds.

I was wondering if anyone can point me at any applications anyone has
shipped with MzScheme in any form (whether shrinkwrapped EXEs or simply
bundling MrEd with the libraries). Any other success stories would be
appreciated. It does look like MzScheme is used succesfully at over 200
educational institutions.

Also, are there any obvious "gotchas" one could point out in using
MzScheme (or workarounds) to deliver an application to end users? It
doesn't matter whether they are technical or licensing related.  It
appears to me MzScheme is under the LGPL, which allows the use in
otherwise proprietary applications if dynamic linking is used (and a
more complex license interpretation is required for static linking
making shipping using a single EXE less likely -- but I could probably
live with generating a launcher). Are there any parts not under the LGPL
that have a license I should be concerned about for redistribution?

Mac support is really important to me, even though I develop under
Windows NT. Can one really make cross-platforms apps under Windows that
then run well on a wide variety of Macintoshes, or are there lots of
issues with support for various OS versions, Mac models, etc? It seems
the wxWindows version used in MrEd is still 1.X, and even the 2.X
wxWindows Mac version lags behind the other platforms. Basically, how
stable are MzScheme and MrEd on the Mac? They don't have to be perfect,
but are they stable enough that I can put up some windows, mess with
files, create and display some bitmaps, and do some number crunching and
expect the end user won't see crashes or bizarre behavior?

Whatever platform I pick, I will most likely spend much of the next six
months working with it. I am not adverse to putting some of that time
into polishing or extending the base system. So, I am not looking for a
promise of substantial technical support or bug fixes. I have been
considering putting two or more months into getting Squeak to where it
needs to be for these sorts of efforts (though it would likely take much
more in the Squeak case, because containing the core complexity hasn't
been high on the Squeak priority list; against that Squeak's elegant
cross-platform approach has some advantages over wxWindows and Smalltalk
has generally better OO browsing/debugging tools).  

The problem I face is that while I can patch things at the
cross-platform level, the process of testing, isolating and fixing
problems across specific platforms at a VM or windowing system
interaction level most likely requires equipment and tools I am not
current with. For example, our Macs are pre-PPC and our Mac MetroWorks
CW compiler is five years old or so. We also don't have Windows 98 or
2000 installed, and we only intermittently run RH 6.1 Linux. Obviously
we could address any specific platform issue, but they each take money
and time. So we really want a cross-platform base that is stable, even
if some other work above that base might be involved. 

It is my assumption that because MzScheme is used at universities (which
often have a mix of equipment including Macs and PCs) that it has
implicitly undergone a lot of cross-platform testing and most of the
rough edges have probably been smoothed off. Is this actually the case?

I am just trying to get a sense of how close MzScheme is to a reliable
core product I can build on top of. It looks really close, but I have
only used in under NT 4.0. The only minor problem I've had with it so
far is some turtle examples locking out other Scheme user interaction
(necessitating killing the entire MzScheme application out of
impatience), but presumably that is just a cooperative coding issue (I
hope, but it really did surprise me given that I thought MzScheme had
internal multi-threading support). 

In any case, thanks to the MzScheme team for making such a wonderful and
educational product.

-Paul Fernhout
Kurtz-Fernhout Software 
=========================================================
Developers of custom software and educational simulations
Creators of the GPL'd Garden with Insight(TM) garden simulator
http://www.kurtz-fernhout.com