HDTenEightyP/NetNews huggingface dataset:
From: terry@zoe.network23.com
Newsgroups: comp.lang.smalltalk
Date: 18 Jul 92 01:36 MDT
Subject: Re: Blocks are BAD!!!
Nf-ID: #R:1992Jul17.212748.22672@zoe.netwo:2033232404:1992Jul17.213649.22730@zoe.netwo:-1403121470:001:962
Nf-From: zoe.network23.com!terry    Jul 18 01:36:00 1992


From article <1992Jul16.155259.24874@slc.com>, by davidm@slc.com (David Monnie):
> In article <1992Jul13.155759.16282@zoe.network23.com> terry@zoe.network23.com (Terry) writes:
>>Problem:
>>Blocks cause considerable difficulty when attempting to make objects
>>persistent and these objects refer to blocks.
> 
>>Comments please.
> 
> If you were using a pure OO database to store the blocks -- one
> which stores behavior, including blocks -- then this shouldn't be
> terribly difficult.  Just because your persistence mechanism limits
> you doesn't mean blocks are bad.

In general you are correct, but I am saving a complex visual object
where one of its subcomponents contains a block.  These are normal
Smalltalk objects.  If your OODB can make 'any' Smalltalk object
persistent please send me a description.

> David Monnie
> Servio Corporation
> Beaverton, OR
> davidm@slc.com

Terry
-- 
terry@zoe.network23.com
{rayssd,xanth,mirror,att}!galaxia!zoe!terry
From: khaw@parcplace.com (Mike Khaw)
Newsgroups: comp.lang.smalltalk
Subject: Re: Objectworks\Smalltalk for OS/2
Date: 29 Jul 92 22:54:00 GMT

In <1992Jul29.145359.28804@heeg.de> support@heeg.de (Support) writes:

>There have been several requests for Objectworks\Smalltalk for OS/2. So here's
>the official info:

>Objectworks\Smalltalk Rel. 4.0 for OS/2 _is_ _available_.

>It is fully compatible with all other Objectworks\Smalltalk Rel. 4.0 versions
>and includes a FREE upgrade to Rel. 4.1 for OS/2 as soon as it is available.

>Contact info@parcplace.com for orders/information. If they can't help you,
>contact support@heeg.de for information. (We ported the software.)


Firma Georg Heeg's implementation of Smalltalk Release 4.0 for OS/2 is
not available from ParcPlace Systems. The geographical regions which
Firma Georg Heeg serves for Objectworks\Smalltalk are Germany,
Switzerland, Austria and the Benelux countries.

I have no additional information on Objectworks\Smalltalk regarding
OS/2, so please do not contact me.

For product information on ParcPlace Systems products, contact your
ParcPlace sales rep at:

	voice: 1-800-759-PARC
	email: info@parcplace.com
--
Michael Khaw	Domain=khaw@parcplace.com, UUCP=...!uunet!parcplace!khaw
ParcPlace Systems, Sunnyvale, CA	PRODUCT INFO: info@parcplace.com
Newsgroups: comp.lang.smalltalk
From: ac690@cleveland.Freenet.Edu (Edward Klimas)
Subject: Re: Smalltalk/V DLL call for char**
Reply-To: ac690@cleveland.Freenet.Edu (Edward Klimas)
Organization: Case Western Reserve University, Cleveland, OH (USA)
Date: Fri, 24 Jul 92 03:15:29 GMT


In a previous article, jon@iti.gov.sg (Jonathan Priddey) says:

>I'm trying to wrap a commercial DLL from Smalltalk/V 1.1 for MS Windows.
>Most calls convert ok using the <api ...> syntax, but whereas struct
>works for char*, ie String, I need an array of pointers to Strings for char**.
>How can I get addresses of a String to be stored in a ByteArray? I can't find
>any address methods.
>
>Has anyone done this?
	I beleive all that you have to do to make this work on the V side is 
	to create enough ByteArray elements to hold your data.  This can 
	usually be easily done by using concatination or ByteArray:with:with: etc..    
	As for the api call a uShort is usually the data structure required to 
	accept the address but you really should look at a system programmers 
	reference manual that describes the specific api in detail.  If you 
	don't allocate enough elements for the ByteArray, your application will 
	probably hang as Win overwrites something.  Allocating extra 
	ByteArrays that are not used only wastes memory so you may want to
	allocate larger ByteArrays if you are not absolutely comfortable
	with the data structures.

	Ed Klimas
	Linea Engineering
From: ghazi@caip.rutgers.edu (Kaveh R. Ghazi)
Newsgroups: comp.lang.smalltalk
Subject: encapsulated postscript from st80 4.1 ?
Date: 28 Jul 92 16:11:18 GMT
Organization: Rutgers Univ., New Brunswick, N.J.


	Does anyone know how to get encapsulated postscript pictures out of
the Printing.st fileIn code that comes with st80 v4.1?  I asked PP support
and they responded along the lines of, we tried and couldn't get it to work.
I need to include smalltalk pictures in other documents.  Any help would be
appreciated.
		Thanks,
		--Kaveh
-- 
Kaveh R. Ghazi			CAIP Center, Rutgers University.
ghazi@caip.rutgers.edu		rutgers!caip.rutgers.edu!ghazi
Newsgroups: comp.lang.lisp
From: dfs@doe.carleton.ca (David F. Skoll)
Subject: Re: Why name your objects? (was Re: creating LISP ...)
Organization: Dept. of Electronics, Carleton University
Date: Mon, 27 Jul 1992 16:22:49 GMT

In <GUMBY.92Jul27051811@Cygnus.COM> gumby@Cygnus.COM (David V.
Henkel-Wallace) writes:

[I wrote that naming objects makes it easy to read/write databases to disk.]

>unless you have a very small database, or need to be able to read it
>into many lisps, you probably won't want the time it takes to go
>through the reader and the printer.  Instead you want to make a
>compiled file.

Right.  But we wanted the database to be human-readable and
human-editable with a text editor.  Also, we wanted to be able to
translate to and from several other (non-Lisp) formats to our database
format, and found that C/awk/sed tools were better than Lisp for doing
the translation.  That virtually mandated an ASCII database.

--
David F. Skoll
From: simon@lia.di.epfl.ch (Simon Leinen)
Newsgroups: comp.lang.lisp
Subject: Re: Advice on recursion?
Date: 24 Jul 92 10:29:11 GMT
Organization: DI-LIA -- Ecole Polytechnique Federale de Lausanne
In-reply-to: vachon@chicoutimi.gel.ulaval.ca's message of 23 Jul 92 19:27:49 GMT
X-Md4-Signature: b93cb3623b02d0860da2c86c88916b7e

In article <1992Jul23.192749.129@cerberus.ulaval.ca>
vachon@chicoutimi.gel.ulaval.ca (Pierre Vachon) writes:

     Are there disadvantages to using 'labels' like this:

      (defun foo (arg)
	(let ((...))

	  (labels ((recursive (arg1 arg2)
			    (body)))
	    (recursive 'foo 'bar))))

This is exactly what I use most often.  The main drawback I see is
that you typically cannot trace the internal function if it
misbehaves.  Maybe some Lisps have an extension that permits (TRACE
(LABELS FOO RECURSIVE)) or something, but I don't know any.

Decent Lisp compilers of course optimize a tail recursion to a loop.
Good compilers also integrate the internal function into the caller,
in which case the LABELS version is always as efficient as an explicit
loop construct (at least Lucid and CMU CL can claim this, I believe).

So in the cases where the recursive version seems more natural (which
depends a lot on the observer), there is no reason to sacrifice
clarity for speed anymore, if you assume a state-of-the-art compiler.
-- 
Simon.
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: dynamic-extent control transfers
Date: 22 Jul 1992 21:22:28 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
Distribution: comp
NNTP-Posting-Host: telecaster.think.com

In article <JBA.92Jul22143439@kix.ai.mit.edu> jba@ai.mit.edu (Jonathan Amsterdam) writes:
>2. Associate a unique tag with each block and invalidate the tag on return
>   from the block.
>
>(2) is cheap but requires consing, which seems counter
>to the whole point of giving control transfers dynamic extent.

I think I'd go with (2).  I don't think the whole point of making exit
points dynamic extent was to save on consing, at least not to this extent.
It's to save the need to cons a representation of the entire control state.

>  (The unique
>tag could start out being a fixnum, eliminating consing for the first
>couple of billion occurrences, but eventually you'd have to either cons
>bignums or wrap around, risking tag duplication.)

The tag only has to be unique for a particular exit point.  So they won't
have to increment as often as if there was a single, global ID generator.

If you're worried about using generic arithmetic for this, you could simply
have a two-fixnum tag field, and roll your own double-precision integer
arithmetic routine using fixnum arithmetic.  Given typical fixnum sizes,
this should be enough to re-enter a block every microsecond for several to
several thousand years.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: haitham@Chemeng.Ed.Ac.Uk (Haitham Lababidi)
Newsgroups: comp.lang.lisp
Subject: Re: converting from strings to ___
Date: 23 Jul 92 09:04:03 GMT
Reply-To: haitham@Chemeng.Ed.Ac.Uk
Organization: Edinburgh University Chemical Engineering Department.
Originator: haitham@stow

In article 10131@cs.brown.edu, map@cs.brown.edu (Mike Perkowitz) writes:
>
>i'm working on a system where i'm getting user input through Motif widgets
>(using CLM). in one part, the user can specify values for certain parameters
>through a text widget. the problem is that the value held by the text widget
>will always be a string. i need to be able to treat that string as a number or
>even as any arbitrary value (t/nil, for example). what it really seems like i
>need to be able to do is just "remove the quotes" from the string and turn it
>into a symbol or something. does anybody have any ideas? is this doable? to
>what extent? any assistance would be greatly appreciated...
>
>thanks,

Try the following function:

(defun my-read-string (string)
  (let (val errorp error-string)
    (handler-case
     (setf val (read-from-string string nil :empty-string))
     (condition (error-condition)
                (setf error-string error-condition
                      errorp :read-error val nil)))
     (when (eq val :empty-string) (setf val nil errorp :empty-string))
     (when (and errorp (eq errorp :read-error))
       (format t "Error: read-from-string:~%~%~A" error-string))
     (values val errorp error-string)))

You can then easily direct the error (if any) to a "notice-prompt" originated from
the widget you are reading from.


+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    Dr. Haitham Lababidi                       Tel  +44 31 650 4862
    Department of Chemical Engineering         Email haitham@uk.ac.ed
    Edinburgh University                                              
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
From: paulmac@stdb.jhuapl.edu (Paul McNamee)
Newsgroups: comp.lang.lisp
Subject: Portable way to prevent underflow errors
Date: 21 Jul 92 17:48:46 GMT
Reply-To: @mailer.jhuapl.edu:paulmac@stdb.jhuapl.edu (Paul McNamee)
Organization: The Johns Hopkins University Applied Physics Laboratory


I'm looking for a way to prevent errors caused by exponentiation where I'm
raising a number between [0-1] to an integer [0-infinity) power.  This
would be simple if my underflow were due to division by zero but with
exponentiation
	(expt .9 500) ==> 1.32 e-23    but
	(expt .1 500) ==> Error.       and
Thus it seems hard to predict and prevent the later case (by not calling it).
In my case the obvious solution of returning zero is quite acceptable.
Symbolics supports this with a without-floating-underflow-traps macro.
Does Lucid provide a utility for this?  

Perhaps there is a mathematical way to do this using long-float-epsilon and
least-positive-double-float, but my horribly deficient mathematical mind
hasn't thought up one.

Thanks for any assistance,

  Paul McNamee
  paulmac@stdb.jhuapl.edu
Newsgroups: comp.lang.lisp
From: oruiz@uxa.cso.uiuc.edu (ruiz oscar eduardo)
Subject: LISP and Objects
Organization: University of Illinois at Urbana
Date: Tue, 21 Jul 1992 18:58:11 GMT
Keywords: LISP, Objects, C++



I have been writing C++ code for geometric objects as part of a geometric
reasoning package. Now I need to use Lisp capabilities to dynamically
define predicates about geometric properties of objects. These predicates
should use as support the functions and routines I have written in C++.
My questions:
  
  1. Is there a way to force Lisp to hande lists of Objects?
     For example, can I handle lists of records?
  2. Is there anywhere a source code (commented if possible) of a lisp
     interpreter?
  

Please address replys to any of these  :
	oscar@meibm4.cen.uiuc.edu
	oruiz@uxa.cso.uiuc.edu
	oruiz@lebesgue.me.uiuc.edu

or, reply to this article.
			Thanks.	Oscar E. RUiz S.

Newsgroups: comp.lang.lisp
From: map@cs.brown.edu (Mike Perkowitz)
Subject: Re: converting from strings to ___
Organization: Brown Computer Science Dept.
Date: Thu, 23 Jul 1992 15:05:14 GMT


read-from-string is my friend too. very handy. thanks to 
everyone who offered help.

mike

----------------------------------------------------------------
     No statement made in a signature file is ever correct.
          Mike Perkowitz              map@cs.brown.edu
----------------------------------------------------------------
Newsgroups: comp.lang.lisp
From: phil@Xenon.Stanford.EDU (Phil Stubblefield)
Subject: Help with EVAL-WHEN
Summary: How to conditionally DEFGENERIC, etc.?
Originator: phil@Xenon.Stanford.EDU
Organization: Computer Science Department, Stanford University.
Date: Tue, 28 Jul 1992 03:37:44 GMT

I'm working on some software intended to run in several different
implementations.  In some of the implementations, a useful function FOO is
defined.  In the others, FOO is undefined, and so I've provided my own
definition.  What I'd like to be able to do is to execute my definition if
and only if the implementation doesn't already provide its own.

My code is isomorphic to the following:

(eval-when (:compile-toplevel :load-toplevel :execute)
  (unless (fboundp 'foo)
    (eval-when (:compile-toplevel :load-toplevel :execute)

      (defconstant +used-to-compute-foo+ ...)

      (defgeneric foo (object))

      (defmethod foo ((object t))
        <code that uses the previously defined constant>)

      <more method definitions...>

      )))


At compile time under Franz Allegro CL 4.1 running on a SparcStation, I am
warned that the symbol +used-to-compute-foo+ is being declare special.  At
load time, I get the following error (reformatted):

Error: No methods applicable for generic function
       #<STANDARD-GENERIC-FUNCTION FIND-METHOD @ #x862e0e> with
       args (#<Function FOO @ #xb1f72e> NIL
       (#<BUILT-IN-CLASS SEQUENCE @ #x78b356>) NIL)
       of classes (FUNCTION NULL CONS NULL)
  [condition type: PROGRAM-ERROR]

Clearly, I have a incomplete and/or flawed model of EVAL-WHEN.  Can someone
enlighten me?

(For those who care, the actual instantiation of this problem uses the
function CLIM:PRESENTATION-TYPE-OF, which is defined in CLIM 1.1 but not in
CLIM 1.0.  Unfortunately, I know of no easy way to discriminate between the
two releases.)

-- 

Phil Stubblefield                                        (415) 325-7165
Rockwell Palo Alto Laboratory                    phil@rpal.rockwell.com
From: schaefer@disco-sol.dfki.uni-sb.de (Ulrich Schaefer)
Newsgroups: comp.lang.lisp
Subject: Re: Simplification
Date: 27 Jul 92 10:43:39 GMT
Organization: DFKI Saarbruecken GmbH, D-W 6600 Saarbruecken
In-reply-to: ppc1@cec1.wustl.edu's message of 25 Jul 92 11:54:10 GMT

In article <1992Jul25.115410.27207@wuecl.wustl.edu> ppc1@cec1.wustl.edu (Peter Pui Tak Chiu) writes:

	   how to do symbolic simplification using scheme, lisp or anything...?

   what i mean is symbolic simplification like MATHEMATICA.
[...]
   can anyone tell me how to do it or refer me to some books that talk about it?

I guess the following book will be very useful.

%A Peter Norvig
%T Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp
%I San Mateo: California: Morgan Kaufmann
%D 1991
%O ISBN 1-55860-191-0

--
   __o     /  / /        /     __    /        /       schaefer@dfki.uni-sb.de
 _ \<,_   /  / / __ o _ /_    (   _ /_  o_o _/_ _  _  Phone ++49-681-3025303
(_)/ (_) /__/_/_/(_(_(_/ (   __)_(_/ (_(_/__/__(/_/(  Home  ++49-681-54921
-------------------------------------------/---------------------------------
Ulrich Schaefer, Deutschherrnstrasse 27, D-6600 Saarbruecken 1, Germany
"Ich, Fahrradfahren? Bei *dem* Verkehr?"
Xref: sparky comp.lang.lisp:2067 comp.lang.clos:584
From: mlg@siemens.com. (Michael Greenberg)
Newsgroups: comp.lang.lisp,comp.lang.clos
Subject: Beware of print-object methods when debugging
Date: 21 Jul 92 17:55:57 GMT
Followup-To: comp.lang.lisp


A coworker came into my office this morning to ask for help debugging
his program.  The bug seemed to be in a part of the program that did
processing nodes in a graph. The code seemed to work correctly for all
objects (about 1000 of them) except for one.

Somewhere in the code there was a statement like:

(setf (node-a node) (make-instance 'foo ...))

We would do something like

(dolist (node (all-objects-in-tree))
  (print (node-a node)))

and see the expected results except for one object where 'NIL' was
printed.   The code was pretty complex and there were all sorts of
dependencies between the various objects in the system, so it wasn't
surprising that that was an error somewhere.  

I beat on this for a while trying to figure out what was
going on.  30 minutes later he said "By the way, I also have a
question about print-object...".

It turns out the problem was that his print-object method for the
class 'foo' sometimes printed 'NIL'.



--
Michael Greenberg                      email: mgreenberg@siemens.com
Siemens Corporate Research             phone: 609-734-3347
755 College Road East
Princeton, NJ 08540
From: pl140048@academ01.mty.itesm.mx (Leonardo Garrido)
Newsgroups: comp.lang.lisp
Subject: Re: ftp site for XLISP
Date: 29 Jul 1992 20:02:25 GMT

sb6932560@v9000 (PAN WEI) writes:

>Can anybody point me to an ftp site for xlisp
>on the IBM-PC. Thanks

I am interested too!. 
Please if someone kynows about it let us know.
Thanks a lot in advance.

Leonardo.
Newsgroups: comp.lang.lisp
From: gregor@parc.xerox.com (Gregor Kiczales)
Subject: Re: Beware of print-object methods when debugging
Followup-To: comp.lang.lisp
Organization: Xerox Palo Alto Research Center
Date: 21 Jul 92 21:10:18


Yes, this is one of many ways to lose with print-object methods.  I
sometimes think it would be nice if implementations provided some sort
of switch, whereby you could disable the call to PRINT-OBJECT or
something.  Of course, you can do this on an application specific basis,
by writing all your methods in the form:

(defmethod print-object ((o foo) str)
  (if *use-default-printer*
      (call-next-method)
      (print-unreadable... )))

In fact, in an application we have here, I have set it up so that, when
running on a particular kind of machine, something very much like this
is controlled by whether the mode lock key is held down.

Gregor
Newsgroups: comp.lang.lisp
From: map@cs.brown.edu (Mike Perkowitz)
Subject: converting from strings to ___
Organization: Brown Computer Science Dept.
Date: Wed, 22 Jul 1992 19:46:39 GMT


i'm working on a system where i'm getting user input through Motif widgets
(using CLM). in one part, the user can specify values for certain parameters
through a text widget. the problem is that the value held by the text widget
will always be a string. i need to be able to treat that string as a number or
even as any arbitrary value (t/nil, for example). what it really seems like i
need to be able to do is just "remove the quotes" from the string and turn it
into a symbol or something. does anybody have any ideas? is this doable? to
what extent? any assistance would be greatly appreciated...

thanks,

mike perkowitz

----------------------------------------------------------------
     No statement made in a signature file is ever correct.
          Mike Perkowitz              map@cs.brown.edu
----------------------------------------------------------------
Newsgroups: comp.lang.lisp
From: jmrg9881@uxa.cso.uiuc.edu (Jon Reid)
Subject: Re: Want macro to produce 3 function calls
Organization: University of Illinois at Urbana
Date: Mon, 27 Jul 1992 18:51:15 GMT

Thanks to everyone who responded.  It seems "progn" is the way to go.

Jon

Xref: sparky comp.lang.lisp:2094 comp.lang.clos:589 comp.lang.scheme:1973
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp,comp.lang.clos,comp.lang.scheme
Subject: LUV-92 reminder
Date: 24 Jul 92 16:25:41 GMT
Article-I.D.: early-bi.14pau5INNei2
Distribution: world
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com


This is just a short reminder that the Second International Lisp Users and
Vendors Conference (LUV-92) will be taking in just a few weeks, August
10-14, at the U.S.Grant Hotel in San Diego, CA.  The theme of the
conference will be "Delivering Business Success with Lisp".  The keynote
address will be by Michael Stock, President and CEO of Artificial
Intelligence Technologies, and the closing address will be given by Richard
P. Gabriel, Chief Technical Officer of Lucid, Inc.  Patrick Kerpan of Swiss
Bank O'Connor and Skip Egdorf of Los Alamos National Laboratories will also
be speaking.  Mr.  Kerpan will speak on his experiences delivering Lisp
based systems that support the financial industry.  Mr. Egdorf will speak
on delivering a portable discrete event simulation system using Common
Lisp, CLOS and CLIM that is used in the nuclear power industry.

The first two days (August 10-11) of the conference will be tutorials
offered by outstanding instructors:

	New Features of ANSI Standard Common Lisp (Lois Wolf, Franz, Inc.)
	CLOS I&II (Allan Wechsler, Symbolics, Inc.)
	Porting Lisp Applications to Stock Hardware (Jim Veitch, Franz, Inc., John Aspinall, Symbolics, Inc.)
	Interfacing Lisp with Other Languages (Charlie Cox, Franz, Inc.)
	Developing Applications for Business (Dean Scharnhorst, Symbolics, Inc.)
	Macrology (Robert Kerns, Digital Equipment Corp.)
	Advanced CLOS (Jon L. White, Lucid, Inc.)
	Instroduction to CLIM (Lois Wolf, Franz, Inc.)
	Advanced CLIM (John Aspinall and Scott McKay, Symbolics, Inc.)
	Interfacing Lisp to SQL Databases (Cris Kobryn, Harlequin, Ltd.)
	Elements of Good Lisp Programming Style (Peter Norvig, Sun Microsystems, Inc.)

The tutorials cost $150 apiece, $50 for students.  The Wed-Fri conference
costs $500, $100 for students.  For detailed schedules and registration
information, contact Laura Lotz of An Event to Remember at +1 (215)
651-2990, Fax +1 (215) 651-0936.

-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: tar@ISI.EDU (Thomas A. Russ)
Newsgroups: comp.lang.lisp
Subject: Re: Portable way to prevent underflow errors
Date: 21 Jul 92 21:23:45 GMT
Reply-To: tar@isi.edu
Organization: USC-ISI
In-reply-to: paulmac@stdb.jhuapl.edu's message of 21 Jul 92 17:48:46 GMT



You should take a look at the condition handling section in the 2nd
edition of the CommonLisp reference.

A simple solution to the immediate problem at hand (which I just tried
under lucid 4.??) Transform

	(expt .9 500) ==> 1.32 e-23    but
	(expt .1 500) ==> Error.       and

into:

(handler-case (expt .9 500)
   (floating-point-underflow nil 0))   ==> 1.32...e-23


(handler-case (expt .1 500)
   (floating-point-underflow nil 0))   ==> 0

--

Thomas A. Russ                                             tar@isi.edu    
USC/ISI, 4676 Admiralty Way, Marina del Rey, CA 90292      (310) 822-1511
Newsgroups: comp.lang.lisp
From: sybalsky@parc.xerox.com (John Sybalsky)
Subject: Looking for C users who've returned to Lisp
Organization: Xerox Palo Alto Research Center
Date: Thu, 23 Jul 1992 08:14:36 GMT


I've been asked to write an article about former Lisp users who
moved to C -- and have come back to Lisp.  The idea is to look
at what caused their return to Lisp, as a springboard for comparing
the two languages' areas of applicability.

I'd appreciate receiving (by email) references to folks I might
contact, with the intention of describing them and the projects-
that-brought-them-back explicitly in the article.  I expect to use
3 to 5 vignettes as the core of the article.

Obviously, I'm happy to mention WHOSE lisp it was they came back to....


Thanks!
-- 
--John
Venue
I OWN the company.  Of COURSE they're official opinions!
Newsgroups: comp.lang.lisp.x