[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Looking for Lisp techniques and tools

Sorry to interject Lisp/Scheme questions into this otherwise well-placed
discussion on C/Pascal/Ada/... but...

In article <9003020249.AA10901@LUBEC.MIT.EDU> mory@ATHENA.MIT.EDU writes:
>I would like a public domain c callable scheme interpreter for use as
>an extension language.  Any recommendations?
>							Mory

I'm just embarking on a similar trek.  I've got a substantial amount of 
experience with other programming languages, but I'm starting into Lisp
as a serious undertaking for the first time.  I've got some specific
questions and some general ones; I'll start with the general ones so
people uninterested in the specifics can bail out early.  I'm interested
to hear what tools and techniques people use for Lisp program development.
Post if you believe it's of general interest, e-mail to me will garner a
summary to the net (names will not be included in the summary).

Most of these questions probably seem simplistic; please let me know if
they are inappropriate to the level of these groups.  My purpose is to
find out about what people who've done substantial program development
in Lisp use for tools and methods.

At this point, I've got Elk 1.0 up and running (pretty much), so these
questions are slanted towards Elk and Scheme; however, it's not too late
to change my mind about choice of tools, so feel free to make any
suggestions you like.  PD or freely-distributed tools are preferred, but
descriptions about any tools and/or systems will be appreciated.

1. What types of tools are available for Lisp program and project
development?  Presumably there are Lisp-callable editors for Lisp
programs that know about Lisp syntax.  What about source-code
and project management tools?  What about simple things like pagers,
directory listing tools, shell escapes, and the like?  Any pointers
to where these can be found?

2. My intention is to develop an easily extended modelling language,
suitable for both interactive use for small jobs, but recognizing a
need for `batch' processing of larger ones.  The processes being
simulated involve potentially huge amounts of floating-point
computation.  A suitable simulation engine is already written in C.
My gut reaction is that the user interface for input to the simulator
and display of the results are probably best handled in Lisp, with a
system call invoking the simulation engine.  I propose to handle the
interface between the two with intermediate files.  For `batch' or
command-line driven mode, the model compiler/interpreter may optionally
need to be invoked, followed by the simulation engine; I feel that this
can be handled adequately by a suitable combination of command scripts
and possibly a C wrapper.  Any comments on this approach?  Does it
make more sense for the C program to invoke Lisp (which seems to be
a more commonly used technique)?

3. I've implemented a subset of the functionality I want in C, using
lex and yacc as required.  I find this approach cumbersome when dealing
with an extensible language and nested layers of encapsulation.  Am I
barking up the wrong tree taking a multilingual approach?  What about
using Lisp in this application?  It seems idealy suited to the task, but
not having tackled anything substantial in it, I may be missing something

So end the general questions.

4. I currently have Elk 1.0 running under UNIX System V r 3.2 on an
80386.  The xlib interface works, xt won't compile, but it looks like a
quick fix.  The only really tricky point (for me, at least) was an apparent
change in the format of externals in COFF files between the release of
Elk and release of SysVr3.2.  I still experience occassional core dumps
with segmentation violations and bus errors, esp. during autoloading and
garbage collection.  At this point, I'm a little suspicious of the alloca
implementation.  Before I start trying to track this down, are there any
official or unofficial patches known to fix this?

5. What's the current release level of Elk?  Are there any known bugs I
should be aware of?  Is it reasonable to consider increasing the amount
of memory allocated to the heap?

6. What are people's opinions of Elk?  Is it in wide distribution and being
used to implement substantial projects?  If not, why not?  Are there more
suitable systems for the kind of project described above?  Are there
Elk-specific tool kits, or Scheme tool kits known to be useful with Elk?

7. I have strived to make the existing source code for the simulation
engine portable between a number of systems, both UNIX and non-UNIX.
While not a pressing issue now, I would like to make the Lisp part of
the project similarly portable.  It seems that a common approach in a
number of Lisp implementations I've seen is to provide compatibility
functions for other popular Lisp dialects.  What are the issues I should
be aware of when trying to accomplish portability in Lisp, or is this
best not discussed in polite company?

That's it. Any and all responses will be greatly appreciated, especially
 from you Lisp afficionados out there.  If you've got other comments to
make, feel free.  I'll summarize any e-mail reponses I receive in the
next, oh say, 3 weeks to the net.  I promise to summarize, and I promise
not to name names.

mike borza.
Michael Borza              Antel Optronics Inc.
(416)335-5507              3325B Mainway, Burlington, Ont., Canada  L7M 1A6
work: mike@antel.UUCP  or  uunet!utai!utgpu!maccs!antel!mike
home: mike@boopsy.UUCP  or  uunet!utai!utgpu!maccs!boopsy!mike