From: jaschnel
Subject: LISP features
Date: 
Message-ID: <1993Jun28.103904.12329@newstand.syr.edu>
Here the list of responses that I recieved from the question:
	IF you could have any LISP features what wuld they be?

-------------------------------------------------------------------------------

Graphics, graphics, graphics, and if you can't do that, I'd like to be able to
at least move the cursor around the screen.  (XLISP has the former, but it's
only for PCs and doesn't compile.  CLISP has the latter, and I'm using the hell
out of it.  It's available for PC, UNIX, amiga...)

Trouble is, "impressive" graphics have to be fast, and someone decided that
Lisp isn't.  I don't think this is necessarily true, if you know how to abuse
the pointer structures with set, nconc, etc.  Anyway, I'm not going to write
an arcade game, but it was awfully nice to be able to make graphs with XLISP.

AWK type pattern matching.
Persistant obOAOAjects
Forward and Backward Chaining Rules
Smalltalk-like GUI builder.
A way to pushnew to end of list.
2 Aand 3 D graphics with animation.
Edit and Describe Object interface.

  I would to have some standard input/output routines that one would
find in either Pascal/C++/C or any other high level language.  This
is one of the reasons why I would use C over Lisp/Scheme.  

Anyway, I like to have some features as below to add into lisp

1) 3D geometrical solid modeler library,
2) intergrate with XLib, and PEXLib
3) Object-Oriented
4) math lib
5) intergrate with interface builder ex. tk/tcl 
6) fast DFS and data structure

  protocol-independent.  Symbolics Genera has a superb approach to
  this.  Somebody should take it, rewrite the lower levels so that
  they can be used at least with all CL's under Unix (using TLI or
  sockets).
OA
* a free API to Sun ("ONC") RPC (I have one but it only runs with
  Xerox Common Lisp).  If it can be ported to OSF/DCE RPC, just the
  better.

* a free CLOS-integrated API to a ToolTalk-like service (CORBA compliant)

* a thread library that is implemented on top of OS-threads so that it
  can make use of multiple processors.  (It should at least work under
  Solaris 2.2 because that's the only MP system we will have in the
A  short term :-)

* a free souped-up version of CLUE with an ugly OSF/Motif(TM) widget
  set that is equivalent in function to the "real" X Toolkit.
or
* a new CLOS window toolkit that borrows from the concepts of
  InterViews/Fresco and implements the ugly OSF/Motif(TM) look&feel.

Until these libraries are widely available, Common Lisp will not be
able to compete with C/C++ in many areas that are or will become
economically interesting.

Yes, I know that there is CLIM.  We even have it.  For my personal
taste, it is just a bit too expensive, too buggy and too heavyweight.

I would want above all explicit continuation operators (besides
 call-with-current-continuation a la Scheme) including 
(create-continuation proc)
which returns a new continuation executing the procedure proc.

I would like to have a kind of static syntax checker like 'lint' for C
 programs.

Many of my LISP functions and methods take clearly defined arguments, and I
would like these functions and the corresponding function calls to be checked,
as variant arglists are - in these cases - just programming errors.
(Of course, there are functions with variable arglists, and I consider this
a great feature of LISP, but more often than not I can exactly say "This
function needs exactly two arguments, the first one is a list, the second is
a symbol, now examine the source code and tell me where this function might
be called in the wrong way")


- The metaobject protocol.

- CLIM.
OAOA
- Lightweight processes/threads.

- Interface to foreign functions, classes, and methods.

- Networking (TCP, UDP, RPC, etc.).

- Persistence (i.e., interface to obOAOAject-oriented databases).

- Constraints and inferencing.


I would like to see high-performance floating point calculation and a
standardized vectorized library suitable for numerics and image processing.
Why not have the numerical recipes in LISP? 

1) A way to hook it to C without a lot of screaming
2) A way to interface it to DBMSs, e.g. Oracle
3) Prolog-like extensions, as detailed in Norvig's book