HDTenEightyP/NetNews huggingface dataset:
From: dnd@ee.man.ac.uk (Darryl Davis (RA))
Newsgroups: comp.lang.lisp
Subject: change-class in CLOS
Keywords: CLOS, classes
Date: 7 Oct 92 18:19:46 GMT
Reply-To: dnd@spec0.ee.man.ac.uk (Darryl Davis (RA))
Organization: Dept Electrical and Electronic Eng, Manchester University, UK

While i have used Common lisp for a while now, i am new to CLOS and have a few problems with
objects, changing classes and DEFMETHOD

The objects
i have a set of objects, most of which are specilaisations of a basic object.
Some are specialisations of more than one object
eg
(DEFCLASS class1 ()
        ( (input :initarg :input      :type string    :reader class1-input))
   (:documentation "The foundation Object"))

(DEFCLASS class2 ()
	( (table :intform NIL         :accessor class2-table))
   (:documentation "A secondary foundation Object"))

(DEFCLASS class3 ( class1 )
        ( (symbolist :intform NIL         :accessor class3-symbolist))
   (:documentation "A secondary level Object"))

(DEFCLASS class4 ( class3 class2 )
        ( (complexarg :intform NIL         :accessor class4-complexarg))
   (:documentation "A third level Object"))

The foundation object (ie objects of class1) is created in response to user input,
It becomes a different class of object on the basis of the parsed input.
 What i have problems with are these two situations:

1. 
where i have SomeOBJECT of class class3 and require it to become a class4 class object.
and i want it to inherit the current slot values of two objects.
the standard way of changing class goes like this:

(change-class SomeOBJECT 'class4)
and then set appropriate slot values according to the two objects i previously had
(of course it (by default) inherits the slot values of SomeOBJECT where they exist in the new object)

what i want is something like this:

(SETF NewOBJECT (change-class-special SomeOBJECT SomeFurtherObject 'class4))h

2.
The second problem is using DEFMETHOD with Multiple objects
eg

(DEFMETHOD some-special-process ((obj1 class1) (obj2 class2))
	......)

(DEFMETHOD some-special-process ((obj1 class1) (obj2 class4))
        ......)


Any ideas on these thorns would be appreciated

dr doom the optimist
--
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
   Dr. Darryl Davis                	>
   Multi-Media Laboratory		>
   Department of Electrical Engineering >   E-mail    	: dnd@spec0.man.ac.uk
   The University of Manchester     	>             
   Brunswick St                      	>   Phone     	: (+44)-61-275-4561
   Manchester M13 9PL               	>   FAX 	: (+44)-61-275-4512
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Newsgroups: comp.lang.lisp
From: morley@aaii.oz.AU (David Morley)
Subject: Static Type Analysis Tools
Keywords: type checking
Organization: Australian AI Institute
Date: Wed, 14 Oct 1992 06:53:19 GMT


Hi folks!

Does anyone know of any static type analysis tools for (preferably
Common) Lisp?  The sort of thing I am after would warn me if I were to
define:

(defun FOO (x)
  (declare (type integer x))
  (* x x))
(defun BAR (y)
  (declare (type symbol y)
  (foo (foo y))))


	David
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: Printing to Standard Error
Date: 7 Oct 1992 15:59:47 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com

In article <Bvr99t.Lnr@acsu.buffalo.edu> ccurtis@acsu.buffalo.edu (Chris Curtis) writes:
>  Does anyone know of a way to print to standard error within 
>lisp?  

This is implementation dependent.  In Lucid CL you can make
a stream that goes to stderr with (make-lisp-stream :output-handle 2).  I
don't know how to do it in other Lisps.

>	I'm using common lisp and have tried writing to the 
>*error-output* stream, but it seems that this prints to standard
>output by default.

CLtL1 required *ERROR-OUTPUT* to be a synonym stream for *TERMINAL-IO*,
which is usually connected to stdin and stdout on Unix.  X3J13 relaxed this
requirement; the new requirements are described on p.499 of CLtL2 and
p.21-55..57 of dpANS CL.  The new rules would permit *ERROR-OUTPUT* to be
connected to stderr, but I don't think many implementations have yet made
this change.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: mip@ai-gate.cs.uni-sb.de (Michael Paul)
Newsgroups: comp.lang.lisp
Subject: Linear Programming
Date: 13 Oct 92 08:14:34 GMT
Organization: /WW/ai-gate/home/mip/.organization


Hi Lisp-Hackers !

I am looking for a Linear-Programming Tool, implemented in Common Lisp.
Does anyone know, where I can find it ??

Thanks in advance,

   					   Michael

  /|/>     /          /   /^^>         /             email: mip@cs.uni-sb.de
 /  / o _ /_  __  _  /   /__/ __      /      ,,,     phone: +49-681-302-4136
/  /_(_(_/ (_(_(_('_/_  /   _(_(_(_(_/_     (o o)    fax:   +49-681-302-4421
----------------------------------------oOO--(_)--OOo-----------------------
FB14-Informatik ; Universitaet des Saarlandes ; D-6600 Saarbruecken 11



--


				Tschuess
   					   Michael

  /|/>     /          /   /^^>         /             email: mip@cs.uni-sb.de
 /  / o _ /_  __  _  /   /__/ __      /      ,,,     phone: +49-681-302-4136
/  /_(_(_/ (_(_(_('_/_  /   _(_(_(_(_/_     (o o)    fax:   +49-681-302-4421
----------------------------------------oOO--(_)--OOo-----------------------
FB14-Informatik ; Universitaet des Saarlandes ; D-6600 Saarbruecken 11
Newsgroups: comp.lang.lisp,comp.lang.clos,comp.object
From: cer@Franz.COM (Chris Richardson)
Subject: CLOS BOF at OOPSLA
Organization: Franz Inc., Berkeley, CA
Distribution: comp
Date: Thu, 15 Oct 1992 18:52:55 GMT


I would like to organize a CLOS BOF at OOPSLA. If you are interested in
participating then please check the BOF notice board or see me at the Franz
booth to find out the (as yet undetermined) details.
--
-----
Chris Richardson, Franz Inc.	1995 University Avenue, Suite 275         
cer@Franz.COM (internet)	Berkeley, CA  94704                       
uunet!franz!cer (uucp)		Phone: (510) 548-3600; FAX: (510) 548-8253
Newsgroups: comp.lang.lisp
From: markt@dgp.toronto.edu (Mark A. Tapia)
Subject: Re: #'reduce
Organization: CSRI, University of Toronto
Date: 8 Oct 92 20:34:05 GMT

In article <danny-061092112735@danny.farallon.com> danny@farallon.com 
(Danny Brewster) writes in response to  <OLI.92Oct6124657@milan.ims.
uni-stuttgart.de>, (Oliver Christ) about the program fragment:
>>  (reduce #'max '("This" "is" "a" "test" ".") :key #'length)
>> 
>
>Reduce doesn't accept :KEY according to CLtL2.  In fact, if you
>look at REDUCE more closely, you'll see that :KEY wouldn't make sense.
>
>Instead of REDUCE, try the following:
>
>(APPLY #'MAX (MAPCAR #'LENGTH '("This" "is" "a" "test" ".")))
>
>Even more efficient would be:
>
>(LET ((max 0))
>  (DOLIST (elt '("This" "is" "a" "test" "."))
>    (SETF max (MAX max (LENGTH elt))))
>  max)
>

Macintosh Common Lisp (MCL) accepts the :key keyword parameter:
? (reduce #'max '("This" "is" "a" "test" ".") :key #'length)
4

You can also use loop to make it clearer:
? (loop for el in '("This" "is" "a" "test" ".")
	maximizing (length el))
4
From: ccurtis@acsu.buffalo.edu (Chris Curtis)
Newsgroups: comp.lang.lisp
Subject: Printing to Standard Error
Date: 7 Oct 92 14:22:40 GMT
Organization: State University of New York at Buffalo / CEDAR Research Group


  Does anyone know of a way to print to standard error within 
lisp?  I'm using common lisp and have tried writing to the 
*error-output* stream, but it seems that this prints to standard
output by default.


Thanks in advance,

Chris Curtis (e-mail: ccurtis@cs.buffalo.edu)
Newsgroups: comp.lang.lisp
From: nik@scs.leeds.ac.uk (Nik Silver)
Subject: Re: Is lisp easy to learn?
Organization: The University of Leeds, School of Computer Studies
Date: Thu, 15 Oct 1992 11:44:49 GMT

In article <1992Oct15.061332.14982@eng.umd.edu>, clin@eng.umd.edu (Charles Lin) writes:
>    I think it's the interpreter that makes LISP easy to learn.  You
>get immediate feedback without having to wait for the compilation
>procedure.   But, as with any programming, when you get bugs it
>can be bothersome, but I find it easier to debug in LISP than
>other languages.
>
> [...]
>    My question is then: If Lisp is so easy, why is it easy?  What
>prevents someone from using, say, ML?

I don't know about ML, but surely Lisp is the closest language to pure
mathematics: obvious parallels lie with lambda calculus and the work of
Kurt Godel. While neither of these two areas are simple in themselves, they
both share the same philosophy of good pure maths --- a minimum of intial
axioms.

These axioms are not arbitrarily chosen, and are knitted closely together.
As a result, simple programs/theorems can be written almost immediately,
but more complex ones (self-referencing programs/incompleteness) can still
be elegantly constructed.

After taking two degrees in pure mathematics and moving to computer science
I find Lisp a very attractive language. Although, as with the huge numbers
behind Godel's Incompleteness Theorem, I'd be lost without a lisp-oriented
editor.

-- 
Nik ``nik@scs.leeds.ac.uk'' Silver
Newsgroups: comp.lang.lisp,comp.lang.clos
From: zwsd06@trc.amoco.com (Bill Davis)
Subject: Need advice from anyone using CLOS & CLIM on Mac
Keywords: macintosh, clos, clim
Organization: Amoco Production Company, Tulsa Research
X-Checksum-Snefru: 73b00587 63d32357 18a1e0b6 54b0bbbe
Distribution: na
Date: Mon, 12 Oct 1992 18:13:30 GMT

I'd appreciate advice from anyone with experience on any of the following:

1) Does MCL include both CLOS and CLIM?  I have a price quote of $495 for
   MCL & would like to know if that is inclusive.

2) How does the development environment in MCL compare with either 
   Genera (Symbolics) or Franz Allegro Composer?

3) How does the performance for MCL compare with the Symbolics or Sun-based
   environments (on whatever Mac you happen to use)?

4) How tightly related are MCL and Allegro CL?

5) Is there some type of file versioning facility on MCL as in the Genera
   environment?


Many thanks in advance.  Please email replies.


----------
Bill Davis                      bdavis@trc.amoco.com
Amoco Production Research       (918) 660-4129
P.O. Box 3385, Room 1A10         fax  660-4163
Tulsa, OK 74102

-- 
Bill Davis                      bdavis@trc.amoco.com
Amoco Production Research       (918) 660-4129
P.O. Box 3385, Room 1A10         fax  660-4163
Tulsa, OK 74102
From: boyer@cs.utexas.edu (Robert Boyer)
Newsgroups: comp.lang.lisp
Subject: Re: Is lisp easy to learn?
Date: 14 Oct 1992 19:27:01 -0500
Organization: U Texas Dept of Computer Sciences, Austin TX
NNTP-Posting-Host: ai.cs.utexas.edu

In article <92288.145030REGHC@CUNYVM.BITNET> <REGHC@CUNYVM.BITNET> writes:
>I just purchased a book for Lisp programming, but have never used this before.
>Is this easy to learn by myself by reading the manual and practicing on the
>computer?

Bill Henneman told me in 1971 that Marvin Minsky had remarked that
anyone could learn Lisp in 1 day, except that if they already knew
Fortran, it would take 3 days.
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: A question...
Date: 16 Oct 1992 22:02:41 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com

In article <ldu1krINNfsg@utkcs2.cs.utk.edu> ensor@cs.utk.edu (Neal Ensor) writes:
>Another question on the same vein... How can I extend this array to
>become an array of linked lists?  i.e.

By default, Lisp arrays can contain objects of any type.  Just use (setf
(aref <array> <index>) <object>) to set it.  Unlike C, Lisp arrays don't
actually "contain" objects of any specific type, they just contain
references to objects, just like conses, variables, structure slots, etc.

>Is this similar to a lisp vector?  (BTW, can't seem to find Steele's book
>*GASP* anywhere around...  I assume it covers this sort of thing... I'll
>grab it when I can find it!)

CLtL is more of a references than a tutorial, so if you're having trouble
understanding this, it may not clear things up too much.  Take a look at
some of the books mentioned in section 1-1 of the FAQ.

-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: osoelgaultier+@CMU.EDU (Stefan Monnier)
Newsgroups: comp.lang.lisp
Subject: Re: Is lisp easy to learn?
Date: 15 Oct 92 11:42:45 GMT
Article-I.D.: andrew.UerQapK00VoqM5L1YZ
	<1992Oct15.114449.9425@news.nd.edu>
Organization: Junior, Math/Computer Science, Carnegie Mellon, Pittsburgh, PA

Excerpts from netnews.comp.lang.lisp: 15-Oct-92 Re: Is lisp easy to
learn? Nik Silver@scs.leeds.ac. (1315)

> In article <1992Oct15.061332.14982@eng.umd.edu>, clin@eng.umd.edu
> (Charles Lin) writes:
> >    I think it's the interpreter that makes LISP easy to learn.  You
> >get immediate feedback without having to wait for the compilation
> >procedure.   But, as with any programming, when you get bugs it
> >can be bothersome, but I find it easier to debug in LISP than
> >other languages.
> >
> > [...]
> >    My question is then: If Lisp is so easy, why is it easy?  What
> >prevents someone from using, say, ML?

> I don't know about ML, but surely Lisp is the closest language to pure
mathematics.

The EASIEST is not lisp but SCHEME.
Lisp style is simpler than ML cause its syntax is 'inexistant' !

Scheme is easier to learn cause it is more consistent and smaller !

Anyway, I've been told that Prolog is also VERY easy to learn as
a first language. As it was not my first language, I can't tell you exactly, 
but I must admit that it is simple although not as simple as Scheme.

	Stefan

-----------------------------------------------------
-- On the average, people seem to be acting normal --
-----------------------------------------------------
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp
Subject: Re: Static Type Analysis Tools
Date: 14 Oct 1992 18:37:05 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: telecaster.think.com
Keywords: type checking

In article <1992Oct14.065319.24756@yarra-glen.aaii.oz.au> morley@aaii.oz.AU (David Morley) writes:
>Does anyone know of any static type analysis tools for (preferably
>Common) Lisp?  The sort of thing I am after would warn me if I were to
>define:
>
>(defun FOO (x)
>  (declare (type integer x))
>  (* x x))
>(defun BAR (y)
>  (declare (type symbol y)
>  (foo (foo y))))

The CMU Common Lisp compiler performs type analysis, as part of its type
propogation optimization.  Here's what I got when I compiled your example
(after I fixed the parenthesis error in BAR):

* (compile-file "/users/systems1/barmar/test.lisp")

Python version 1.0, VM version SPARCstation/Sun 4 on 14 OCT 92 02:33:06 pm.
Compiling: /tmp_mnt/users/systems1/barmar/test.lisp 14 OCT 92 02:33:03 pm

Converted FOO.
Compiling DEFUN FOO: 
Converted BAR.
Compiling DEFUN BAR: 

File: /tmp_mnt/users/systems1/barmar/test.lisp

In: DEFUN BAR
  (FOO Y)
==>
  Y
Warning: Result is a SYMBOL, not a INTEGER.

Compiling Top-Level Form: 

Compilation unit finished.
  1 warning


/users/systems1/barmar/test.sparcf written.
Compilation finished in 0:00:02.

#p"/tmp_mnt/users/systems1/barmar/test.sparcf"
T
T

-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
Xref: sparky comp.lang.lisp:2616 comp.lang.clos:874
From: barmar@think.com (Barry Margolin)
Newsgroups: comp.lang.lisp,comp.lang.clos
Subject: Re: change-class in CLOS
Followup-To: comp.lang.clos
Date: 8 Oct 1992 03:39:05 GMT
Organization: Thinking Machines Corporation, Cambridge MA, USA
NNTP-Posting-Host: gandalf.think.com
Keywords: CLOS, classes

In article <6381@m1.cs.man.ac.uk> dnd@spec0.ee.man.ac.uk (Darryl Davis (RA)) writes:
>While i have used Common lisp for a while now, i am new to CLOS and have a few problems with
>objects, changing classes and DEFMETHOD

CLOS questions are more appropriately posted to comp.lang.clos.  I've
redirected the discussion there.

>1. 
>where i have SomeOBJECT of class class3 and require it to become a class4 class object.
>and i want it to inherit the current slot values of two objects.
>the standard way of changing class goes like this:
>
>(change-class SomeOBJECT 'class4)
>and then set appropriate slot values according to the two objects i previously had
>(of course it (by default) inherits the slot values of SomeOBJECT where they exist in the new object)
>
>what i want is something like this:
>
>(SETF NewOBJECT (change-class-special SomeOBJECT SomeFurtherObject 'class4))h

(defun change-class-special (original-object other-object new-class)
  (let ((new-object (change-class original-object new-class)))
    (copy-other-slots new-object other-object)))

Then write appropriate COPY-OTHER-SLOTS methods.

>2.
>The second problem is using DEFMETHOD with Multiple objects
>eg
>(DEFMETHOD some-special-process ((obj1 class1) (obj2 class2))
>	......)
>(DEFMETHOD some-special-process ((obj1 class1) (obj2 class4))
>        ......)

I think you left something out of this part: your problem/question.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

barmar@think.com          {uunet,harvard}!think!barmar
From: charest@Aig.Jpl.Nasa.Gov (Len Charest)
Subject: Re: #'reduce
Reply-To: charest@aig.jpl.nasa.gov
Organization: NASA/Jet Propulsion Laboratory
Date: Wed, 7 Oct 1992 18:45:03 GMT

In article <OLI.92Oct6124657@milan.ims.uni-stuttgart.de>, oli@milan.ims.uni-stuttgart.de (Oliver Christ) writes:
|> ... why does
|>  (reduce #'max '("This" "is" "a" "test" ".") :key #'length)
|> result in a 'unknown keyword: :key' error both with Allegro CL 4.1 and
|> Lucid 4.0 on a Sparc? 

|> Any help? In X3J13's CL draft #'reduce accepts :key arguments.

The :KEY argument to REDUCE was added by X3J13. The Lisp implementations you
mention were released prior to the proposed ANSI standard.
..................................................
                                  Len Charest, Jr.
                 JPL Artificial Intelligence Group
                          charest@aig.jpl.nasa.gov
From: tim@hpfcbig.SDE.HP.COM (Tim Mikkelsen)
Date: Tue, 13 Oct 1992 19:00:56 GMT
Subject: Re: Xlisp built in editor?
Organization: HP SESD, Fort Collins, CO
Newsgroups: comp.lang.lisp.x


In case you don't have it, here is the file "EDIT.LSP": 

;;;
;;; file: EDIT.LSP
;;;

;;;(setq *breakenable* t)
;;;(setq *tracenable* t)

;;;
;;; This variable is the default file to edit
;;;

(defvar edit-file 'nil)

(defvar editor "emacs")

;;;
;;; edit a file using the specified editor
;;; if the file editted was a lisp file (.lsp) load it
;;;

(defun edit (&optional file)
    (read-char) ; get rid of newline sitting in input stream
    (and (not file)
         (null edit-file)
         (setq file (get-filename)))
    (if (not (stringp file))
	(setq file edit-file))
    (if (not (stringp editor))
	(setq editor (get-editor)))
    (system (strcat editor " " file))
    (setq edit-file file)
    (let ((len (length edit-file)))
	(if (string= (string-downcase (subseq edit-file (- len 4))) ".lsp")
	    (load edit-file))))

(defun get-filename ()
	(princ "File: ")
	(read-line))

(defun get-editor ()
	(princ "Editor: ")
	(read-line))
From: toma@sail.LABS.TEK.COM (Tom Almy)
Newsgroups: comp.lang.lisp.x
Subject: Re: Xlisp built in editor?
Date: 7 Oct 92 14:51:42 GMT
Article-I.D.: sail.12682
Reply-To: toma@sail.labs.tek.com
Organization: Tektronix, Inc., Beaverton,  OR.

In article <1992Oct6.061516.8215@mv.mv.com> kgg@mv.mv.com (Kenn Goutal) writes:

>at least was, a function (DOS <cmd>), which you could presumably could
>use to call your favourite editor on the source file of a function, and
>then you could (LOAD ...) it again.  Not terrifically fast or elegant.

Xlisp comes with a small LSP file, EDIT, that automates this.

>Also, I have XLISP-PLUS -- dunno how it differs from the original
>in this regard.

The EDIT.LSP in XLISP-PLUS has some additional features.

>>Perhaps an IDE even.
>Amen to that, brother.  Hmmm...  Care to write a spec for such a beast?

With XLISP-PLUS you can use REPAIR.LSP, SAVE, RESTORE, and PP.LSP and avoid
using an external editor altogether. The problem is that REPAIR.LSP is a
LIST oriented editor which in most respects is more dificult to use than
a typical screen oriented editor, although it does have the advantage that
you parenthesis are ALWAYS matched!


-- 
Tom Almy
toma@sail.labs.tek.com
Standard Disclaimers Apply
From: hardy@golem.ps.uci.edu (Meinhard E. Mayer (Hardy))
Subject: Re: Xlisp built in editor?
In-reply-to: cyberman@exucom.com's message of 5 Oct 92 02:03:18 GMT
Newsgroups: comp.lang.lisp.x
Organization: Department of Physics, UC Irvine, CA 92717-4575, USA
Date: 8 Oct 92 18:24:07 GMT

In article <1992Oct5.020318.25900@exucom.com> cyberman@exucom.com (Stephen R. Phillips) writes:

???   Are thier any editors for Xlisp?
???   IE like EMACS? 
???   This would make making lisp programs a lot easier for me.

With gnu-emacs you can run xlisp as a subprocess (in the same manner
as scheme, or winterp, for example). 
It requires some customization of your .emacs file, or putting
together an xlisp.el file, if no one has done this yet. 

--
Hardy 
-----
Meinhard E. Mayer,  Department of Physics, UC Irvine 
e-mail: hardy@golem.ps.uci.edu (preferred) or MMAYER@UCI.BITNET

Newsgroups: comp.lang.lisp.x
From: jbehrens@aardvark.ucs.uoknor.edu (BEHRENS,JOHN T)
Subject: Action! for Xlisp
Originator: news@midway.ecn.uoknor.edu
Date: Thu, 8 Oct 1992 16:44:00 GMT
News-Software: VAX/VMS VNEWS 1.41    
Organization: University of Oklahoma - University Computing Services


Action! is claimed to be able to make Common Lisp or Xlisp run ten times faster
Is this claim true? Any idea or info will be greatly appreicated.
J. T. Behrens
U. of Oklahoma 
Newsgroups: comp.lang.lisp
From: jclose@chesapeake.ads.com (Jeff Close)
Subject: Is there a PACKAGE PROBLEM in Allegro?
Organization: Advanced Decision Systems division of Booz, Allen & Hamilton
Distribution: usa
Date: Thu, 8 Oct 1992 19:45:35 GMT

Hi.  I'm using Allegro CL on a Sparc 1.1 and am getting strange behavior in
some code regarding package redefinition.  At least, it's strange compared to 
what I would expect.  Specifically, it doesn't seem to have an effect when I
try to redefine a package.  The package itself is a problem because it doesn't
seem to "see" many common symbols from CLOS, including defclass and others, 
even though it uses CL-USER.

Thanks much for any suggestions...

jeff
-- 
-----------------------------------------------------------------------------
jclose@ads.com: ADS BA&H/2111 Wilson Bd #800/Arlington, VA 22201 703-243-1611

Anarchists don't believe in rules.  Surrealists make up their own.
Newsgroups: comp.lang.lisp
From: ralex@tigger.cs.Colorado.EDU (Repenning Alexander)
Subject: Re: Is lisp easy to learn?
Organization: University of Colorado, Boulder
Date: Thu, 15 Oct 1992 21:07:04 GMT


What do yall mean by "one can learn lisp in one day"? Sure, it's no
big deal to understand the basics of Lisp (e.g., adding some numbers,
defining simple functions, doing simple list manipulation). 

We got many new people in our group that were familiar with other
programming languages. They really did grasp the essentials in a day.
However, to become fully functional members of our group took them
about a year.  Of course, it took them some time to understand our
existing code, and our philosophy of lisp programming etc. But to a
large degree they had to fight with some of the intrinsic complexities
of lisp like eval-whens, read macros, destructive functions, macros,
packages, declarations, defsystems, loop macros, etc.  

The nice thing about lisp is that you can do simple things right away.
However, to become a power user you have to look into many of the 1029
pages of "Common Lisp the Language". To get some intuition on how easy
it is to learn lisp try to follow one of the numerous
if-you-show-me-your-macroexpansion-of-your-LOOP-I-will-tell-you-what-it-actually-does
discussions.

Don't get me wrong. Lisp IS the language of my choice, but I just don't know 
how much useful lisp knowledge one really gets in a short period like
one day.

  Alex
Newsgroups: comp.lang.lisp