From: Courageous
Subject: Deep copy in lisp: how?
Date: 
Message-ID: <38F0B90A.8FC4B502@san.rr.com>
I have a CLOS object which may contain an arbitrary graph of
other objects. This graph may be cyclic. I'm looking for an
easy way to deep copy the object. I've been told that
generic deep copy might be implementing by writing the
object to a stream, and then reading back from that stream.
Is this the best way of doing it? Is there another way?


Thank you,



Joe Kraska
San Diego
CA

From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164291289641126@naggum.no>
* Courageous <········@san.rr.com>
| I have a CLOS object which may contain an arbitrary graph of other
| objects.  This graph may be cyclic.  I'm looking for an easy way to deep
| copy the object.

  the only easy way out is to write a copier that knows what it's doing.
  any easier way out would violate "as simple as possible, but no simpler".

| I've been told that generic deep copy might be implementing by writing
| the object to a stream, and then reading back from that stream.

  you've been told that?  what a joker that must have been!  how do you
  think you would proceed to implement readers and writers for the objects?
  do you think _they_ come in generic versions that do everything right?

  (for the languages where you may use a generic version that does it wrong
  most of the time, which you usuallyq observe if you try, there _is_ the
  merit to this language design that most "modern programmers" (= dummies)
  are a lot happier when they something out and see it fail, then do it
  "right" (= less _obviously_ wrong), than to know it would fail and know
  they had to do it right from the start.)

  implementing a mechanism that avoids descending into cyclic structures is
  amazingly easy.  detection is easy with the rabbit and the hare algorithm.
  a hash table of copied objects avoids all possible problems to begin with.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F0D50B.8F4EE798@san.rr.com>
>   implementing a mechanism that avoids descending into cyclic structures is
>   amazingly easy.  detection is easy with the rabbit and the hare algorithm.
>   a hash table of copied objects avoids all possible problems to begin with.

In essence, I'm looking for an implementation of this that uses introspection
on the objects; I require a generic implementation that knows nothing in
specific a-priori about the objects it will deep copy; however, stipulating
certain rules on the structure of the objects may be within reason. I know
this is possible one way or the other, for I have seen automatic deep copy
implemented via code generation in C++. I'm pretty new at lisp; however, so
I'm not sure what language-specific pitfalls I will encounter yet.

Thanks for your tip,

C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164297272958870@naggum.no>
* Courageous <········@san.rr.com>
| I know this is possible one way or the other, for I have seen automatic
| deep copy implemented via code generation in C++.

  I'm sorry, but you have been tricked.  just because it exists for C++ is
  not in any way, shape, or form an argument for the _correctness_ of the
  implementation or the algorithm or even the concept to begin with.

| I'm pretty new at lisp; however, so I'm not sure what language-specific
| pitfalls I will encounter yet.

  you encountered a language-specific pitfall and fell headlong into it
  when you believed that C++ had an automatic solution.  you will get out
  of this sorry state of affairs when you realize that such automated tools
  are not able to do their job.  the key to understand this is that even in
  a class for which "deep copy" makes non-zero sense, you don't _always_
  want to deep copy _everything_, and if you fail to implement it right,
  you will in fact destroy valuable information in the copying process.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F11CBD.CF70B8F8@san.rr.com>
>   you encountered a language-specific pitfall and fell headlong into it
>   when you believed that C++ had an automatic solution.

I don't believe that C++ has a an automatic solution, rather, I've
seen a code generator (for C++) which correctly copies graphs of
the objects while keeping referential integrity intact.

> and if you fail to implement it right,
>   you will in fact destroy valuable information in the copying process.

Never had that happen is all of 3 years using the code generator
that I had, which would, in fact, copy wildly crazy and cyclic
graphs of objects perfectly correctly. Furthermore, if you look
into the world of object oriented databases, you'll find that
various oodbs also do this perfectly well.

Perhaps we're having a definition of terms problem?

I can't write a specific graph copier, because I don't have a-
priori knowledge of the structure of the objects that I will be
copying.





C/
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3r9cezo55.fsf@cley.com>
* Courageous  wrote:

> I can't write a specific graph copier, because I don't have a-
> priori knowledge of the structure of the objects that I will be
> copying.

Look, you can't write a general copier, get over it.  Whatever your
C++ framework is doing it *isn't* doing general copy.  You need to
know enough about the objects you want to copy to know what can occur
in these objects, how to copy them, what bits should be copied, what
is not copiable, what equality means when detecting cycles, and so
forth.

If this isn't obvious, think for a few seconds about how a general
copier should behave when it comes across a package object, say.

--tim
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F14F3F.D6A54A70@san.rr.com>
> > I can't write a specific graph copier, because I don't have a-
> > priori knowledge of the structure of the objects that I will be
> > copying.
> 
> Look, you can't write a general copier, get over it.

Well, actually you *can* write a "general" graph copier if the
graph of objects is composed of objects made from a restricted
set of primitives.

A tip for some of you folks: one of the keys to successful
communication is not to assume that the other person is wrong,
but rather to figure out what they're right *for*.

Bye now,

C/
From: Andrew K. Wolven
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F16584.CE7BC28A@redfernlane.org>
wrong. ignorance rules. this is c.l.l.

Courageous wrote:

> > > I can't write a specific graph copier, because I don't have a-
> > > priori knowledge of the structure of the objects that I will be
> > > copying.
> >
> > Look, you can't write a general copier, get over it.
>
> Well, actually you *can* write a "general" graph copier if the
> graph of objects is composed of objects made from a restricted
> set of primitives.
>
> A tip for some of you folks: one of the keys to successful
> communication is not to assume that the other person is wrong,
> but rather to figure out what they're right *for*.
>
> Bye now,
>
> C/
From: Rahul Jain
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8cron7$f2e$1@joe.rice.edu>
In article <·················@san.rr.com> posted on Sunday,
April  9, 2000 10:47 PM, Courageous <········@san.rr.com> wrote:
> 
>> > I can't write a specific graph copier, because I don't have a-
>> > priori knowledge of the structure of the objects that I will be
>> > copying.
>> 
>> Look, you can't write a general copier, get over it.
> 
> Well, actually you *can* write a "general" graph copier if the
> graph of objects is composed of objects made from a restricted
> set of primitives.
> 

A general copier that working in specific situations, then :)

-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3zor2w9dm.fsf@cley.com>
* Courageous  wrote:

> Well, actually you *can* write a "general" graph copier if the
> graph of objects is composed of objects made from a restricted
> set of primitives.

Perhaps you should be clear about what you mean by `general'.  Earlier
you said:

	I require a generic implementation that knows nothing in
	specific a-priori about the objects it will deep copy

which people have interpreted to mean something like, given an object
O, return a copy of O when you do not know anything about what O is.
But actually, what you really seem to want is something that is very
specific, and works on some small set of classes.  That is easy to
write -- so easy to write that I'm kind of confused why you are asking
for it.  You just need a notion of equality, and way of telling if you
have seen an object equal to the one you are looking at before (if
your notion of equality is EQL or something, then Lisp provides this
functionality in hash tables, if it is some user-defined predicate you
may have to write a small hashtable implementation based on it), and
some basic recursive programming.

> A tip for some of you folks: one of the keys to successful
> communication is not to assume that the other person is wrong,
> but rather to figure out what they're right *for*.

One of the keys to successful communication on this newsgroup is to
ask for what you want in reasonably specific terms rather than
extremely vague ones.

--tim
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F29C72.97673019@san.rr.com>
> > Well, actually you *can* write a "general" graph copier if the
> > graph of objects is composed of objects made from a restricted
> > set of primitives.
> 
> Perhaps you should be clear about what you mean by `general'.  Earlier
> you said:

Oh. Okay. Well then, looking at the *very same message* that you
quoted, but taking a slow gander at the part you deliberately
cut out in order to score points, I see:

"however, stipulating certain rules on the structure of the objects
may be within reason."

Bye now,


C/
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3bt3hw2xn.fsf@cley.com>
* Courageous  wrote:
> Oh. Okay. Well then, looking at the *very same message* that you
> quoted, but taking a slow gander at the part you deliberately
> cut out in order to score points, I see:

Believe me, I'm not trying to score points off you, or anyone.  I
should obviously have quoted the original article as the one that
caused people to assume you wanted a truly general copier, but I
didn't hit ^ enough times & just picked a bit that looked like it
meant the same thing, which was stupid I realise.  I won't quote the
original now as you'll probably think I'm trying to win some stupid
argument.

I'll repeat once more the things you need to write a copier (actually
I notice I forgot to give one of them):

	a notion of equality of objects

	a method of saying if you've seen an object equal in the above
	sense to the one you are looking at now

	a method of knowing which slots of an object you need to
	descend into to copy it.  This depends on the semantics of the
	slots as well as their content (this is the one I failed to
	mention).

If your notion of equality is EQL or something similar, then the first
two things are done very well by a hashtable, if it is more general
then you need to write some hashtable-type thing.

`Knowing which slots' is application-dependent, but you can do stuff
with the MOP to find them.  I'd tend to do it with something like a
map-interesting-slots generic function with progn method combination
which I'd use to define the new interesting slots when I defined a new
class.

--tim
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F2DFD5.225516FE@san.rr.com>
> `Knowing which slots' is application-dependent, but you can do stuff
> with the MOP to find them.  I'd tend to do it with something like a
> map-interesting-slots generic function with progn method combination
> which I'd use to define the new interesting slots when I defined a new
> class.

Yes. With the mop, you can traverse the slot definitions of
a class, and with the right kind of code, you can iterate
over each of these, recursively if need be. I have something
similar (without the graph copying) implemented for non
cyclic graphs. It was interesting to learn how to do this;
I figured it out with _The Art of the Metaobject Protocol_.

Most of the reason I posted my question to the group was
to make sure I wasn't reinventing the wheel. That, and my
"copier" was originally intended to produce a plain text
rendition of the object that followed certain formatting
rules. Therein, I supported a set of basic primitives
(boolean, integer, float, string), sequences (array,
list, vector), and finally any standard-object. To
understand how to correctly serialize boolean as "false"
on my plain text serialization, I ended up having to
have a look-aside table of metadata, which turned out
to be necessary in any case (I forget why, but something
to do with the types of sequence elements upon internal
ization).

If this is just a case of doing what I did before, but
with adding an objref and then using some kind of
hashtable or something, I'm fine with that. I was
hoping there was an implementation already out there...

C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164355492179483@naggum.no>
* Courageous <········@san.rr.com>
| A tip for some of you folks: one of the keys to successful
| communication is not to assume that the other person is wrong,
| but rather to figure out what they're right *for*.
 
  do you follow this tip yourself?  if so, how come you don't listen?
  it seems to me you're telling us we're wrong because you have "seen"
  something you believe is sufficient when it isn't.

  a tip for tippers: follow them yourself first, to _show_ how they work
  well for you.  if not, just shut up about the tips.

#:Erik
From: Bernhard Pfahringer
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <gyu3dottxmc.fsf@borg.i-did-not-set--mail-host-address--so-shoot-me>
Courageous <········@san.rr.com> writes:

> > > I can't write a specific graph copier, because I don't have a-
> > > priori knowledge of the structure of the objects that I will be
> > > copying.
> > 
> > Look, you can't write a general copier, get over it.
> 
> Well, actually you *can* write a "general" graph copier if the
> graph of objects is composed of objects made from a restricted
> set of primitives.
> 

ACL comes with a specific deep copier, if you abuse their
fasl-file facilities (kind of what was hinted at for the Java solution):

USER(2): (arglist 'excl:fasl-write)
(COMPILER::DATA STREAM &OPTIONAL COMPILER::*FASL-CIRCLE* *COMPILE-VERBOSE*)
T
USER(3): (setq l '(1 2 3))
(1 2 3)
USER(4): (nconc l l)
(1 2 3 1 2 3 1 2 3 1 ...)
USER(5): (excl:fasl-write l "x.fasl" t t)
;;; Writing fasl file x.fasl
;;; Fasl write complete
T
USER(6): #'excl:fasl-read
#<Function FASL-READ>
USER(7): (arglist 'excl:fasl-read
)
(COMPILER::FILE)
T
USER(8): (excl:fasl-read "x.fasl")
((1 2 3 1 2 3 1 2 3 1 ...))
USER(9): (first *)
(1 2 3 1 2 3 1 2 3 1 ...)
USER(10): (eql * l)
NIL
USER(11): (list-length **)
NIL

Maybe thats sufficient for your problem?

--------------------------------------------------------------------------
Bernhard Pfahringer 
Dept. of Computer Science, University of Waikato
G1.25, phone: +64-7-838-4041
········@cs.waikato.ac.nz
--------------------------------------------------------------------------
From: Robert Monfera
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F27188.20708366@fisec.com>
Bernhard Pfahringer wrote:

> ACL comes with a specific deep copier, if you abuse their
> fasl-file facilities (kind of what was hinted at for the Java solution):
>
> USER(2): (arglist 'excl:fasl-write)

The documentation says FASL-WRITE does not work for CLOS classes other
than the built-in ones.  MAKE-LOAD-FORM has to be used, requiring
specialized methods.

Robert
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164355240918791@naggum.no>
* Courageous <········@san.rr.com>
| Never had that happen is all of 3 years using the code generator that I
| had, which would, in fact, copy wildly crazy and cyclic graphs of objects
| perfectly correctly.

  that's a ridiculously bold statement.  how do you _know_?  would you even
  have _seen_ an error if it occurred?

| Furthermore, if you look into the world of object oriented databases,
| you'll find that various oodbs also do this perfectly well.

  they do it by restricting the domain to fit what they implement, but it
  fits the C++ mind-set to think this way and take it for granted that
  others will understand that "of _course_ we don't do the hard stuff".  in
  this newsgroup and in Lisp, the trivial problems are uninspiring, and so
  we tend to think in broader terms.  this means that arbitrary limits are
  regarded as cheating, unless yo present the limited domain up front as
  inherent engineering decisions.  did you do that?  no.  foo on you for
  that.

| Perhaps we're having a definition of terms problem?

  yes, you come from the C++ world.  C++ people are extremely arrogant the
  way they think they invented object-orientedness.  they didn't, OK?  C++
  doesn't even touch upon the really hard areas.  you have to face this
  fact, or you'll make more ridiculously bold statements that reflect very
  badly on your ability to deal with complexity.

| I can't write a specific graph copier, because I don't have a- priori
| knowledge of the structure of the objects that I will be copying.

  at issue is knowing the _intent_ of the slots, not which they are.  in
  Common Lisp we have the MOP to ask for the structure of the objects.
  piece of cake, really.  just like databases can report on such things.
  it doesn't help one bit in deciding whether to make a shallow or deep
  copy, though.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F29F89.2E1ED0EC@san.rr.com>
>    unless yo present the limited domain up front as
>   inherent engineering decisions.  did you do that?  no.  foo on you for
>   that.

I mentioned the possibility of restrictions in my second message
in this very thread. Did you read it? No. Foo on you for that.

>   C++ people are extremely arrogant the
>   way they think they invented object-orientedness.

????

Non sequitur. This doesn't follow from anything, nor does
anything follow from this. Please keep your crazy rants to
yourself.




C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164446697303504@naggum.no>
* Courageous <········@san.rr.com>
| I mentioned the possibility of restrictions in my second message
| in this very thread. Did you read it? No. Foo on you for that.

  this is just great.  of course I did that, and that's _why_ I criticize
  you for not doing it UP FRONT.  perhaps you do ont know what "UP FRONT"
  means?  well, it means you do it at the very start of your request for
  help.  sort of like "I use XLISP, and have this problem" instead of just
  asking people to guess based on the lack of intelligibility of the
  problem as stated in the environments smart people use.

  please go back to C++, both communities would benefit from that.

#:Erik
From: Rob Warnock
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8cr9tm$1scu2$1@fido.engr.sgi.com>
Erik Naggum  <····@naggum.no> wrote:
+---------------
| * Courageous <········@san.rr.com>
| | I know this is possible one way or the other, for I have seen automatic
| | deep copy implemented via code generation in C++.
| 
|   I'm sorry, but you have been tricked.  just because it exists for C++ is
|   not in any way, shape, or form an argument for the _correctness_ of the
|   implementation or the algorithm or even the concept to begin with.
+---------------

Indeed. Perhaps it's time once again to drag out Kent Pitman's classic
"Parenthetically Speaking" article on the subject:

	<URL:http://world.std.com/~pitman/PS/EQUAL.html>
	The Best of Intentions: EQUAL Rights--and Wrongs--in Lisp

which addresses the question "Why is there no generic COPY function?"
[in Common Lisp], and explains why any so-called "automatic" deep copy
is inherently *wrong*.


-Rob

-----
Rob Warnock, 41L-955		····@sgi.com
Applied Networking		http://reality.sgi.com/rpw3/
Silicon Graphics, Inc.		Phone: 650-933-1673
1600 Amphitheatre Pkwy.		PP-ASEL-IA
Mountain View, CA  94043
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3ln2nqd6k.fsf@cley.com>
* Courageous  wrote:
> I know this is possible one way or the other, for I have seen
> automatic deep copy implemented via code generation in C++.

I seriously doubt it!

--tim
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F13A90.73CAA68E@san.rr.com>
> I seriously doubt it!

As I said in one of my posts, I'd be willing to accept certain
structural rules of organization. With this particular code generator,
it used the well-defined CORBA IDL (which simply cannot express a
function pointer and the like). Likewise, with the ODMG DDL, you
have a fairly restricted language of expression.

If you think about it, it's strictly impossible to implement utterly
generic graph copy, reflectivity or not (imagine a simple C array of
int; how long is it? Dunno).

My second post hinted at this. In C/C++, we use a vector type, and only
support that. For objects to persist or be relocatable, they have to
be defined using a set of very specific primitives. The arrangement of
these primitives will not be known in advance. Cycles may be present
and must be (and can be) accounted for.

I'm just looking for a simple way to do this with Lisp. Given Lisp's
flexibility, I doubt very highly it would require a code generator,
but I've been wrong before.

(BTW, as Franz has a CORBA binding, and presumably this binding does
Objects By Value, this would suggest that at least one commercial
implementation of what I'm looking for already exists).

...

C/
From: Philip Lijnzaad
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <u766tqpam2.fsf@o2-3.ebi.ac.uk>
On 09 Apr 2000 17:48:09 +0000, 
"Erik" == Erik Naggum <····@naggum.no> writes:

Erik> implementing a mechanism that avoids descending into cyclic structures is
Erik> amazingly easy.  

if slightly non-obvious at first. For those confused, you have two parts of
your function step through the elements of a list, one going in single steps,
the other in steps of two. If they ever end up in the same element, the list
must have been circular.

Erik> detection is easy with the rabbit and the hare algorithm.

Is this an optimized version of the tortoise and the hare algorithm? 

Erik> a hash table of copied objects avoids all possible problems to begin with.

but may not scale. 
                                                                      Philip

-- 
Not getting what you want is sometimes a wonderful stroke of luck.
-----------------------------------------------------------------------------
Philip Lijnzaad, ········@ebi.ac.uk | European Bioinformatics Institute,rm A2-24
+44 (0)1223 49 4639                 | Wellcome Trust Genome Campus, Hinxton
+44 (0)1223 49 4468 (fax)           | Cambridgeshire CB10 1SD,  GREAT BRITAIN
PGP fingerprint: E1 03 BF 80 94 61 B6 FC  50 3D 1F 64 40 75 FB 53
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164356890914970@naggum.no>
* Philip Lijnzaad <········@ebi.ac.uk>
| On 09 Apr 2000 17:48:09 +0000, 
| "Erik" == Erik Naggum <····@naggum.no> writes:
| 
| Erik> implementing a mechanism that avoids descending into cyclic structures is
| Erik> amazingly easy.  
| 
| if slightly non-obvious at first. For those confused, you have two parts of
| your function step through the elements of a list, one going in single steps,
| the other in steps of two. If they ever end up in the same element, the list
| must have been circular.
| 
| Erik> detection is easy with the rabbit and the hare algorithm.
| 
| Is this an optimized version of the tortoise and the hare algorithm? 

  yes (my silly mistake).  you just described it in the above paragraph, so
  you must know it under a different name, but the key is to realize that
  it only _detects_ a circularity, after it has happened -- there is no
  guarantee that you find the first such element.

#;Erik
From: Tom Breton
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m3n1n1q3bb.fsf@world.std.com>
Philip Lijnzaad <········@ebi.ac.uk> writes:

> On 09 Apr 2000 17:48:09 +0000, 
> "Erik" == Erik Naggum <····@naggum.no> writes:
> 
> Erik> implementing a mechanism that avoids descending into cyclic structures is
> Erik> amazingly easy.  
> 
> if slightly non-obvious at first. For those confused, you have two parts of
> your function step through the elements of a list, one going in single steps,
> the other in steps of two. If they ever end up in the same element, the list
> must have been circular.

No, hare&tortoise is nice, but it only does detection, which allows
you to *stop* examining a circular graph, but doesn't allow you to
immediately detect when you've completely traversed a graph that has
one loop, nor to successfully traverse a graph with cross-loops.

To avoid descending more than once, you simply need to remember what
you've already explored and not explore it again.  Basically what a GC
does.

> Erik> detection is easy with the rabbit and the hare algorithm.
> 
> Is this an optimized version of the tortoise and the hare algorithm? 

Heh!  

-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3og7jqdd6.fsf@cley.com>
* Courageous  wrote:
> I have a CLOS object which may contain an arbitrary graph of
> other objects. This graph may be cyclic. I'm looking for an
> easy way to deep copy the object. I've been told that
> generic deep copy might be implementing by writing the
> object to a stream, and then reading back from that stream.
> Is this the best way of doing it? Is there another way?

What you want is something more than deep copying -- something I call
`graph copying' although it may have a proper name.  It copies while
keeping track of every object it has copied, and avoiding copying it
again in that case.  Graph copying is unavoidably expensive because it
needs an occurs check.

Common Lisp does not have a generic object copying function because
the notion of `copying' is something that is typically
application-dependent.  Languages that provide one typically provide
one that doesn't work most of the time (C++ is a good example) so you
end up overriding it most of the time.

For objects that CL knows how to print & read, than it is often
possible do a graph copy by printing them to a stream & reading back,
but it's almost always better to write an application-specific
copier.

Here's a (badly written I think) example of dealing with circularities
& sharing for cons trees (only!):

    (defun copy-cons-graph (x)
      (let ((octab (make-hash-table)))
	(labels ((cp (y)
		   (typecase y
		     (cons
		      (or (gethash y octab)
			  (let ((c (cons nil nil)))
		            ;; the new cons needs to be in OCTAB
		            ;; before we try and descend into it.
		            ;; This seems a pretty clunky way of doing
		            ;; this, but it's sunday night.
			    (setf (gethash y octab) c)
			    (setf (car c) (cp (car y)))
			    (setf (cdr c) (cp (cdr y)))
			    c)))
		     (t y))))
	  (cp x))))

Finally: I gave a paper on stuff related to this at last year's lugm,
I don't know if it's on the web anywhere, but franz's web site would
be a good place to look (I will put up a descendent of it at some
point, when I have some time).

--tim
1
From: Paolo Amoroso
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <K+3xON74ou2Pc7CbeYNKIe+GsNUu@4ax.com>
On 09 Apr 2000 20:32:37 +0100, Tim Bradshaw <···@cley.com> wrote:

> Finally: I gave a paper on stuff related to this at last year's lugm,
> I don't know if it's on the web anywhere, but franz's web site would
> be a good place to look (I will put up a descendent of it at some
> point, when I have some time).

Which paper do you refer to? I have the ELUGM '99 and LUGM '99 proceedings,
but they don't include your papers. So I guess the Franz site doesn't have
them either.

The ELUGM '99 proceedings' index refers to a talk by you titled "One Step
Beyond" without the corresponding paper (but someone in this group said
that you had problems attending the event). The LUGM '99 proceedings' index
lists another talk without paper titled "Creeping features".


Paolo
-- 
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3em8dwrgi.fsf@cley.com>
* Paolo Amoroso wrote:

> The ELUGM '99 proceedings' index refers to a talk by you titled "One Step
> Beyond" without the corresponding paper (but someone in this group said
> that you had problems attending the event). The LUGM '99 proceedings' index
> lists another talk without paper titled "Creeping features".

Creeping features & one step beyond are the same thing, and yes I
didn't make it to elugm.  I'm not sure why it's not in the lugm-99
proceedings, it should have been!

I'll put it up on our web site asap.

--tim
From: Arthur Lemmens
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F37E52.1DC5AEA9@simplex.nl>
Tim Bradshaw wrote:
> 
> * Paolo Amoroso wrote:
> 
> > The ELUGM '99 proceedings' index refers to a talk by you titled "One Step
> > Beyond" without the corresponding paper (but someone in this group said
> > that you had problems attending the event). The LUGM '99 proceedings' index
> > lists another talk without paper titled "Creeping features".
> 
> Creeping features & one step beyond are the same thing, and yes I
> didn't make it to elugm.  I'm not sure why it's not in the lugm-99
> proceedings, it should have been!

In my copy of the LUGM-99 proceedings, it is: "One step beyond, or Creeping 
metafeaturism" by Tim Bradshaw (10 pages). I enjoyed reading it.

Arthur Lemmens
From: Paolo Amoroso
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <wZ=0OMR80MzucZzHc8ZxzvxPNvGq@4ax.com>
On Tue, 11 Apr 2000 21:34:42 +0200, Arthur Lemmens <·······@simplex.nl>
wrote:

> In my copy of the LUGM-99 proceedings, it is: "One step beyond, or Creeping 
> metafeaturism" by Tim Bradshaw (10 pages). I enjoyed reading it.

Huh... That paper is missing from my copy of the LUGM '99 proceedings...
Does yours also include the paper by Chuck Fry listed as "Lisp in Space" in
the index (i.e. the list of talks printed on a green sheet), and the one by
Fred Gilham listed as "Dist. Transactions"?


Paolo
-- 
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/
From: Arthur Lemmens
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F4D89A.B515A4EB@simplex.nl>
Paolo Amoroso wrote:

> Huh... That paper is missing from my copy of the LUGM '99 proceedings...
> Does yours also include the paper by Chuck Fry listed as "Lisp in Space"

No, I can't find that one.

> and the one by Fred Gilham listed as "Dist. Transactions"?

Yes: "SDTP - A Multilevel-Secure Distributed Transaction Processing System" 
by Fred Gilham and David Shih (12 pages).

Arthur Lemmens
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey31z4cwaf9.fsf@cley.com>
* I wrote:

> I'll put it up on our web site asap.

OK, it is now at http://www.cley.com/articles/one-step-beyond.pdf.
This is the original paper, I had hoped to do an HTML version which
more closely corresponds to the talk I actually gave, but this is all
there is for now.

--tim
From: Gareth Rees
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <uvh1qw62i.fsf@pobox.com>
Courageous wrote:
> I have a CLOS object which may contain an arbitrary graph of other
> objects. This graph may be cyclic. I'm looking for an easy way to deep
> copy the object.

A generic deep copy function is impossible because in order to copy an
object, you must know the meaning of the object and how it will be used.

There's an information essay by Kent Pitman on this very subject -- see
http://world.std.com/~pitman/PS/EQUAL.html

Here's are extracts:

  ``Why is there no generic COPY function?'' Common Lisp programmers
  often ask this question. [...]

  Programmers want a generic COPY function that somehow ``does the right
  thing,'' but relying solely on the representation type is insufficient
  to resolve intentional distinctions between conses, lists, alists, and
  trees, so we wouldn't know whether to call COPY-CONS (if there were
  such a thing), COPY-LIST, COPY-ALIST, or COPY-TREE.

  Of course, we could just define that COPY-LIST is what's used, but
  that could (and probably would) give the misleading impression that
  such a choice was ``uniquely determined'' or even ``morally correct,''
  instead of just arbitrarily chosen. Also, an arbitrary choice would
  leave users feeling funny about the presence of an operator that can
  copy many--but not all--kinds of objects.

-- 
Gareth Rees
From: Gareth Rees
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <uog7iw56g.fsf@pobox.com>
Courageous wrote:
> I have a CLOS object which may contain an arbitrary graph of other
> objects. This graph may be cyclic. I'm looking for an easy way to deep
> copy the object.

A generic deep copy function is impossible because in order to copy an
object, you must know the meaning of the object and how it will be used.

There's an informative essay by Kent Pitman on this very subject -- see
http://world.std.com/~pitman/PS/EQUAL.html

Here are some extracts:

  ``Why is there no generic COPY function?'' Common Lisp programmers
  often ask this question. [...]

  Programmers want a generic COPY function that somehow ``does the right
  thing,'' but relying solely on the representation type is insufficient
  to resolve intentional distinctions between conses, lists, alists, and
  trees, so we wouldn't know whether to call COPY-CONS (if there were
  such a thing), COPY-LIST, COPY-ALIST, or COPY-TREE.

  Of course, we could just define that COPY-LIST is what's used, but
  that could (and probably would) give the misleading impression that
  such a choice was ``uniquely determined'' or even ``morally correct,''
  instead of just arbitrarily chosen. Also, an arbitrary choice would
  leave users feeling funny about the presence of an operator that can
  copy many--but not all--kinds of objects.

-- 
Gareth Rees
From: Fernando D. Mato Mira
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F1E49B.8489BB7D@acm.org>
Gareth Rees wrote:

> A generic deep copy function is impossible because in order to copy an
> object, you must know the meaning of the object and how it will be used.

I just remembered several years ago, quite fresh from spending a couple
years
`Eiffelling' I wanted a generic copy operation. I think I had even started
writing the obvious trivial proposal for:

(defgeneric copy (context type source)
    (:documentation "Make a /type/ copy of /source/ according to
/context/"))

and where all the standard predefined copy operations would be already
hooked up, eg:

(defmethod copy ((context NULL) (type (eql :shallow)) (source list))
   (copy-list source))

(defmethod copy ((context NULL) (type (eql :deep)) (source list))
   (copy-tree source))

--
Fernando D. Mato Mira
Real-Time SW Eng & Networking
Advanced Systems Engineering Division
CSEM
Jaquet-Droz 1                   email: matomira AT acm DOT org
CH-2007 Neuchatel                 tel:       +41 (32) 720-5157
Switzerland                       FAX:       +41 (32) 720-5720

www.csem.ch      www.vrai.com     ligwww.epfl.ch/matomira.html
From: Fernando D. Mato Mira
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F1E8BB.DDD86A5A@acm.org>
Sketetons would also be provided, eg:

(defmethod copy (context type (source list))
  (mapcar #'(lambda (x) (copy context type x)) source))

--
Fernando D. Mato Mira
Real-Time SW Eng & Networking
Advanced Systems Engineering Division
CSEM
Jaquet-Droz 1                   email: matomira AT acm DOT org
CH-2007 Neuchatel                 tel:       +41 (32) 720-5157
Switzerland                       FAX:       +41 (32) 720-5720

www.csem.ch      www.vrai.com     ligwww.epfl.ch/matomira.html
From: Fernando D. Mato Mira
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FACA84.D329ED49@acm.org>
"Fernando D. Mato Mira" wrote:

> Skeletons would also be provided, eg:
>
> (defmethod copy (context type (source list))
>   (mapcar #'(lambda (x) (copy context type x)) source))

Let's emphasize the `eg'. ie, the Right Way would be to provide
something
a little more elaborate not making a linear proper list assumption, with
the protocol
becoming:

(defgeneric copy (context type source &optional map))

where /map/ should conform to a generic hashtable interface (eg,
hash-get, hash-put, hash-remove, hash-replace, hash-try-put)

--
Fernando D. Mato Mira
Real-Time SW Eng & Networking
Advanced Systems Engineering Division
CSEM
Jaquet-Droz 1                   email: matomira AT acm DOT org
CH-2007 Neuchatel                 tel:       +41 (32) 720-5157
Switzerland                       FAX:       +41 (32) 720-5720

www.csem.ch      www.vrai.com     ligwww.epfl.ch/matomira.html
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F29E54.78D832EF@san.rr.com>
> A generic deep copy function is impossible because in order to copy an
> object, you must know the meaning of the object and how it will be used.

I understand this. I guess I'm wondering what specific constraints
have to be held to if you reasonably expect a graph-copy to work.
I'm willing to build my objects out of specific primitives, but
being new to lisp, don't know where I'm likely to make mistakes.

If there are many different data structures which cannot be deep
copied, I'm okay with that. I can stipulate that these objects
contain no such structures (checking that they indeed don't is
another issue).



C/
From: Jon S Anthony
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F37055.3004@synquiry.com>
Courageous wrote:
> 
> > A generic deep copy function is impossible because in order to copy an
> > object, you must know the meaning of the object and how it will be used.
> 
> I understand this. I guess I'm wondering what specific constraints
> have to be held to if you reasonably expect a graph-copy to work.
> I'm willing to build my objects out of specific primitives, but
> being new to lisp, don't know where I'm likely to make mistakes.

The very things you are saying here show that you don't understand.
You're still completely missing the point.  Any such constraints are
_context_ specific, i.e., specific to the problem space, the various
representations that you have chosen to to encode it, and what those
representations _mean in the given context_.  It should be completely
clear that no general solution this is _possible_ no matter what set
of "primitive" representations you are willing to restrict yourself
to.


> If there are many different data structures which cannot be deep
> copied, I'm okay with that. I can stipulate that these objects
> contain no such structures (checking that they indeed don't is
> another issue).

Datastructures are _completely irrelevant_.  Of course you can copy
_any_ datastructures (and vastly simpler, more easily correct, and
cleaner in CL than you could even dream of doing in your wildest
fantasies in C++), but that's the _easy_ part.  Knowing which parts to
copy, when to copy, and how to copy, is the important part and the
part which is context specific and thus impossible to generalize in
the sense you seem to want.


If you know what you are doing (see above) writing a completely
general graph copier is pretty straightforward.  For example, one of
the aspects of our application is that graphs are first class objects
- any kind of graph can be defined (with edge semantics specified and
enforced, information propagation provided, etc., etc., etc.) and they
can be freely manipulated.  I wrote a completely general graph copier
in about a page of code.


/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F3D7F1.BEDE0612@san.rr.com>
> ......................................... Knowing which parts to
> copy, when to copy, and how to copy, is the important part and the
> part which is context specific and thus impossible to generalize in
> the sense you seem to want.
 
> If you know what you are doing (see above) writing a completely
> general graph copier is pretty straightforward. ... I wrote a
> completely general graph copier in about a page of code.


However it is that you're reconciling these two paragraphs
is what I'm interested in. You say that it's not structure,
but semantics that indicates the meaning of a copy, and I'm
fine with that, too. It doesn't matter. I have a practical
problem to solve, here.

I'm not quite sure why in the part I cut out you felt a
need to describe the wonders of lisp to me. Do you get a
lot of hostile-to-lisp posters here? I am someone who is
voluntarily learning to use lisp, and as is I suspect
of many first time users, I've found it so flexible and
useful that most of my questions involve where its
limitations lie.

When I say that something can be done in some other language
with some particular mechanism, this isn't some sort of
snide comment on the capabilities of lisp, but rather me
pointing out that if an approach works in one language,
there ought to be a way, no matter how labyrinthine, to
achieve it in another.





C/
From: Jon S Anthony
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F3E494.68FE@synquiry.com>
Courageous wrote:
> 
> > ......................................... Knowing which parts to
> > copy, when to copy, and how to copy, is the important part and the
> > part which is context specific and thus impossible to generalize in
> > the sense you seem to want.
> 
> > If you know what you are doing (see above) writing a completely
> > general graph copier is pretty straightforward. ... I wrote a
> > completely general graph copier in about a page of code.
> 
> However it is that you're reconciling these two paragraphs
> is what I'm interested in. You say that it's not structure,
> but semantics that indicates the meaning of a copy, and I'm
> fine with that, too. It doesn't matter. I have a practical
> problem to solve, here.

Well, then just go and write the silly thing.  You are the only one
(at least around here) that knows the specifics of your application
context and thus the only one who can answer the semantic questions
poised above and thus the only one who can write your specific graph
copier.  It should be a "yawner exercise".


> I'm not quite sure why in the part I cut out you felt a

Why not?


/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164522187493376@naggum.no>
* Courageous <········@san.rr.com>
| It doesn't matter.  I have a practical problem to solve, here.

  thank you.  I think this sums up your position admirably.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F4AC3B.EC3AB8FA@san.rr.com>
Erik Naggum wrote:
> 
> * Courageous <········@san.rr.com>
> | It doesn't matter.  I have a practical problem to solve, here.
> 
>   thank you.  I think this sums up your position admirably.

Yes, it does. Some of us do, in fact, work on real problems
which need solving. Theoretical constraints are interesting
and valuable to know, but the project moves on.

I suspect that you need to look inward and not outward to
solve the problem that you need to work on. Usenet won't
offer your ego what it's looking for, no matter how hard
you look for it.

Good luck to you,



C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164550783316675@naggum.no>
* Courageous <········@san.rr.com>
| Yes, it does.  Some of us do, in fact, work on real problems which need
| solving.  Theoretical constraints are interesting and valuable to know,
| but the project moves on.

  just because you cannot fathom the theoretical implications of your
  questions does not mean that those who do don't solve practical problems.
  think about this.  please.

  and, incidentally, if I have "made" you feel like an idiot, why not just
  do something that would put such impressions to _shame_ instead of going
  out of your way to _prove_ that you really _are_ hopelessly lost?

| I suspect that you need to look inward and not outward to solve the
| problem that you need to work on. Usenet won't offer your ego what it's
| looking for, no matter how hard you look for it.

  I'm sure you and your shrink have worked something out that works for you
  (although by the looks of it, you have some ways to go), but just like he
  or she should have told you that you shouldn't give other people your
  medication, you also shouldn't believe that your personal problems apply
  to other people.

  but I'll give you this: you are indeed courageous.  I know of few other
  people who would expose themselves the way you do.  here's a hint: you
  really don't need to -- nobody cares about _you_, personally, and it's an
  affront to your audience, _any_ audience, to think they do.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F5336F.26EDD837@san.rr.com>
>   I'm sure you and your shrink have worked something out that...

You just can't stop, can you Erik?



C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164603059346977@naggum.no>
* Courageous <········@san.rr.com>
| You just can't stop, can you Erik?

  if I can stop you, that's good enough for me, because I don't start the
  kind of insane drivel you seem to enjoy starting.  but have you asked
  yourself your own question, lately?  I don't appreciate your line of
  psychologizing crap, but now that you get it back in your face, I see
  that you are a lot more sensitive to the matter than I am, which is good,
  because you may realize that if you plan to win any games that way, you
  won't do it here, and you're clearly the kind of moron who needs to be
  hurt to stop to think.  will _that_ make you stick to your issues,
  whatever they may be, or will you smear more of your personality all over
  the place with yet more moronic psychologizing and irrelevant personal
  attacks?  it's your call, "Courageous".

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F592D1.3E5C6AA6@san.rr.com>
> insane drivel... crap... in your face... you won't do it here...
> and you're clearly the kind of moron... who needs to be
> hurt to stop to think... moronic...

"Needs to be hurt". I especially like that one.
With messages like this, the only person who's
getting hurt is you. How embarrassing for you.

Take a step back.


C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164610602078761@naggum.no>
* Courageous <········@san.rr.com>
| Take a step back.

  let me know when your advice has worked for you.  make an effort to show
  that you can listen to anything but your own voice while you're at it.

#:Erik
From: Tim Moore
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8d4ugf$o4v$0@216.39.145.192>
On 13 Apr 2000, Erik Naggum wrote:

> * Courageous <········@san.rr.com>
> | Take a step back.
> 
>   let me know when your advice has worked for you.  make an effort to show
>   that you can listen to anything but your own voice while you're at it.
> 
> #:Erik
> 
It's good advice for both of you.

Speaking as a one-time Lisper wandering in the the C++ wilderness for
years, I think some more slack could be shown to users of other languages
who stumble into comp.lang.lisp, either because they've just gotten into
Lisp or for whatever reason.  Topics such as "How do I do a deep copy
in Lisp?" cause blood pressures to rise because Lispers know it's
impossible, but that's because the language is much richer and exposes one
to situations where deep copy is in fact quite hard if not impossible.
Deep copy is hard in C++ too, but other factors (such as primitive memory
management) may discourage the use of data structures that are hard to
deep copy, or classes may do a reasonable job of deep copying in limited
domains (vis. the distributed object database example), so C++ers become
confused and hurt when they are told that their apparently reasonable
request is intractable and, by the way, silly on the face of it.

Apropos of nothing, C++ hasn't stood still and isn't quite as cretinous as
it was 10 years ago.  I use a C++ garbage collector (Boehm) in my work and
home projects  for example, and the things that are being done with
templates and partial evaluation are extremely cool.  I'm glad to be
returning to Lisp, if only as an amateur, but the C++/Perl world doesn't
totally suck.

Tim
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164643995219305@naggum.no>
* Tim Moore <·····@herschel.bricoworks.com>
| Topics such as "How do I do a deep copy in Lisp?" cause blood pressures
| to rise because Lispers know it's impossible, but that's because the
| language is much richer and exposes one to situations where deep copy is
| in fact quite hard if not impossible.

  you're missing the point, as one would expect from a bystander.  it isn't
  the _topic_ that cause any problems.  it's the dimwits who come here and
  ask for advice, and resoundingly _reject_ the advice they get from
  well-meaning, highly educated people who try to teach pigs to sing, which
  we know wastes your time and annoys the pig (witness the "practical" line
  that just _had_ to come our way) only they don't know the dimwits they
  try to help _are_ pigs until after a while, and then they get annoyed
  when the pig turns out to be severely limited in learning _ability_, too.

#:Erik
From: Tim Moore
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8d5cjv$ilv$0@216.39.145.192>
On 13 Apr 2000, Erik Naggum wrote:

> * Tim Moore <·····@herschel.bricoworks.com>
> | Topics such as "How do I do a deep copy in Lisp?" cause blood pressures
> | to rise because Lispers know it's impossible, but that's because the
> | language is much richer and exposes one to situations where deep copy is
> | in fact quite hard if not impossible.
> 
>   you're missing the point, as one would expect from a bystander.  it isn't
>   the _topic_ that cause any problems.  it's the dimwits who come here and
>   ask for advice, and resoundingly _reject_ the advice they get from
>   well-meaning, highly educated people who try to teach pigs to sing, which
>   we know wastes your time and annoys the pig (witness the "practical" line
>   that just _had_ to come our way) only they don't know the dimwits they
>   try to help _are_ pigs until after a while, and then they get annoyed
>   when the pig turns out to be severely limited in learning _ability_, too.

Pigs are highly intelligent.  Sometimes pigs turn out to be humans under a
spell.  In any event, who cares if the recipient isn't receptive?  Posting
on Usenet is not a zero-sum game between you and someone who asks a
question; you don't give up your precious bodily essence everytime you
answer a question.  You're educating thousands of silent readers (maybe
that's a bit optimistic for comp.lang.lisp :) who may be confused about
the same topic, and often as not you're educating and enriching yourself.

OK, this has nothing to do with Lisp at all anymore, so I promise not to
follow up.

Tim
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164649925932789@naggum.no>
* Tim Moore <·····@herschel.bricoworks.com>
| Pigs are highly intelligent.

  pardon me for elaborating on a saying.  speaking of which, this must be a
  regional thing -- in some parts of the English-speaking world, people
  tend to use idioms almost constantly, but do not reflect on them at all,
  which makes them into a mere set of ersatz vocabulary, while in other
  parts of the English-speaking world, puns and elaborations and mixing and
  matching idioms and expressions to travel between many layers of meaning
  is considered natural.  I tend to be puzzled when I meet people who don't
  reflect on their language, because it's hard to tell which part of the
  many meanings they got and which they completely missed out on.

| In any event, who cares if the recipient isn't receptive?

  you do, when you take the role of a bystander and raise the discussion to
  a meta-level.  others do, when they are in middle of the discussion that
  started it all.  many find it very annoying to see recurring dimwits fail
  to get over a personal hangup or their desperately trying to recover
  something they are the only ones to remember they lost.

  newsgroup volume is a measure of discontent.

#:Erik
From: William Deakin
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F6F303.22EB3281@pindar.com>
Erik Naggum wrote:

> ....in some parts of the English-speaking world, people tend to use idioms
> almost constantly, but do not reflect on them at all...

This is very true.

As an example of this, when a machine is running is slow it is described as
`running like a pig' or `a dog.' If you have ever tried racing either of these
animals you would realise that the idiom is foolish and a more appropriate one
would be `running like an IT professional'.

;) will
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey33doovofi.fsf@cley.com>
* William Deakin wrote:

> As an example of this, when a machine is running is slow it is described as
> `running like a pig' or `a dog.' If you have ever tried racing either of these
> animals you would realise that the idiom is foolish and a more appropriate one
> would be `running like an IT professional'.

One of the most frightening experiences I've ever had was coming
across a wild boar while resting from cycling half way up a hill in
Germany.  It moved *really fast*.  Fortunately it wasn't out to get me
I think, and adrenaline can make you climb even quite steep hills at a
great rate for a few hundred yards.

--tim
From: thi
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m2rvh1kpfwg.fsf@netcom9.netcom.com>
William Deakin <·····@pindar.com> writes:

> As an example of this, when a machine is running is slow it is
> described as `running like a pig' or `a dog.' If you have ever tried
> racing either of these animals you would realise that the idiom is
> foolish and a more appropriate one would be `running like an IT
> professional'.

all professionals run quickly when the boss is around.

thi
From: Arne Knut Roev
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <Ft0zxv.FF7@online.no>
thi <···@netcom.com> wrote:
> all professionals run quickly when the boss is around.

For all such cases, at least one of the following statements apply:

    1. There is something wrong with said professional.

    2. There is something wrong with said boss.

    3. You are watching a theatre play.

[note absence of smiley]

-- 
Arne Knut Roev <······@online.no> Snail: N-6141 ROVDE, Norway
=
The Gates of Hell shall not prevail:
Darkness now; then Light!
From: Will Deakin
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8d9sv5$hha$1@barcode.tesco.net>
thi wrote:
>all professionals run quickly when the boss is around.

And yet more slowly than an elephant. The top speed of the worlds fastest
sprinter ~21mph. Speed of an irate charging elephant ~24mph.

;) will
From: thi
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m2ru2h36yf1.fsf@netcom9.netcom.com>
"Will Deakin" <···········@hotmail.com> writes:

> thi wrote:
> >all professionals run quickly when the boss is around.
> 
> And yet more slowly than an elephant. The top speed of the worlds fastest
> sprinter ~21mph. Speed of an irate charging elephant ~24mph.

so when looking for elephants, put a boss at the end of africa!

thi
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F64457.CE095E32@san.rr.com>
> Pigs are highly intelligent.  Sometimes pigs turn out to be humans under a
> spell.  In any event, who cares if the recipient isn't receptive?

The more interesting question to ask is: if the recipient doesn't
attach the import to your angle on a problem that you do, does
it justify crumbling into hurling insult after insult like a
spoiled child? Merely a rhetorical question, of course.

I've been called worse things than a pig. :)


C/
From: Fernando
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <n8kdfsot39avhk8mmj7kpv8a1mhcftt758@4ax.com>
On 13 Apr 2000 17:01:03 GMT, Tim Moore <·····@herschel.bricoworks.com>
wrote:


>years, I think some more slack could be shown to users of other languages
>who stumble into comp.lang.lisp, either because they've just gotten into
>Lisp or for whatever reason.  
[...]
>domains (vis. the distributed object database example), so C++ers become
>confused and hurt when they are told that their apparently reasonable
>request is intractable and, by the way, silly on the face of it.

	I don't think you are being very fair: _onlY_ Erik behaves
like that, everybody else in the newsgroup is normal...

	Just like the proliferation of parens, he may be a minor
annoyance to newbies, but fortunately, parens stop annoying you in a
week, and as soon as you plonk him, he'll stop annoying you. ;-)

>Apropos of nothing, C++ hasn't stood still and isn't quite as cretinous as
>it was 10 years ago.  I use a C++ garbage collector (Boehm) in my work and

	Interesting...  Any links to this gc? O:-)

>home projects  for example, and the things that are being done with
>templates and partial evaluation are extremely cool.  I'm glad to be
>returning to Lisp, if only as an amateur, but the C++/Perl world doesn't
>totally suck.

	Agreed for C++, but Perl does totally suck... };-)




//-----------------------------------------------
//	Fernando Rodriguez Romero
//
//	frr at mindless dot com
//------------------------------------------------
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164713468970761@naggum.no>
* Fernando <·······@must.die>
| Just like the proliferation of parens, he may be a minor annoyance to
| newbies, but fortunately, parens stop annoying you in a week, and as soon
| as you plonk him, he'll stop annoying you. ;-)

  but how long before the obsessed stalkers stop annoying the newsgroup?

#:Erik
From: Arne Knut Roev
Subject: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <Ft0rMx.F7G@online.no>
Erik Naggum <····@naggum.no> wrote:
> * Fernando <·······@must.die>
> | Just like the proliferation of parens, he may be a minor annoyance to
> | newbies, but fortunately, parens stop annoying you in a week, and as soon
> | as you plonk him, he'll stop annoying you. ;-)
> 
>   but how long before the obsessed stalkers stop annoying the newsgroup?

My sentiments entirely.

I read this newsgroup for technical contents, not "social graces".

Which is why I have no intention of "plonking" Mr Naggum: His technical
comments seem to be among the most reliable here.

-akr

PS: 
   A short comment may be in order, for those of narrow mind: In this
   posting, I am not, repeat _not_, repeat _NOT_, trying to "kiss Mr
   Naggum's arse": I mean every word of what I wrote above!
DS.

-- 
Arne Knut Roev <······@online.no> Snail: N-6141 ROVDE, Norway
=
The Gates of Hell shall not prevail:
Darkness now; then Light!
From: Tom Breton
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m3ya6gutqd.fsf@world.std.com>
Arne Knut Roev <······@online.no> writes:

> Which is why I have no intention of "plonking" Mr Naggum: His technical
> comments seem to be among the most reliable here.

Look, I won't belabor how absurd that is, but to make this group
usable for myself, I'll be plonking you along with him.  No hard
feelings, but I really have no use for his nonsense, reflected or
otherwise.  Don't take it personally; you made your choice, I just
respond.

-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
From: Ian Upright
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ng9ifsse746mdksfp15ujllgh006k2td0d@4ax.com>
Arne Knut Roev <······@online.no> wrote:

>Erik Naggum <····@naggum.no> wrote:
>> * Fernando <·······@must.die>
>> | Just like the proliferation of parens, he may be a minor annoyance to
>> | newbies, but fortunately, parens stop annoying you in a week, and as soon
>> | as you plonk him, he'll stop annoying you. ;-)
>> 
>>   but how long before the obsessed stalkers stop annoying the newsgroup?
>
>My sentiments entirely.
>
>I read this newsgroup for technical contents, not "social graces".

As a Smalltalker who doesn't read this newsgroup very often, I was quite
irritated by Mr. Naggum's absurd and highly inflamitory opinions.  It seemed
to be a perfectly reasonable question to ask, not warranting even a *hint*
of inflammatory comments.

Are all Lisper's f***ing belligerent ass*****?  ;-)

I still don't understand what the problem is.  If you consider a completey
generic one-size fits all deepCopy to be useless, I'd have to strongly
disagree.  In Smalltalk I do what I consider "true" deep copies all the
time, and I get a lot of use out of them.  There even exists this tool
called a DeepCopyArbiter that generically traverses any arbitrary graph of
objects, and allows you to add rulesets to define at what point the deep
copy should end, based on a specific instance, type of object, or other
criteria.  I'm baffled as to why you can't do this sort of thing easily in
CLOS.  Maybe I'm just not familiar enough with CLOS yet, or maybe this sort
of pattern doesn't fit in well with the language?

Ian

----------------------------------------------------------------------------
 One Accord Technologies                              ···@oneaccordinc.com
----------------------------------------------------------------------------
From: Arne Knut Roev
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <Ft40Bt.HM9@online.no>
Ian Upright <···@oneaccordinc.com> wrote:
> I still don't understand what the problem is.  If you consider a completey
> generic one-size fits all deepCopy to be useless, I'd have to strongly
> disagree.  

Well, there are two problems:

1. Is a completely generic/general "Deep copier" _possible_ ? (Which, if you
   can recall, was at the heart of the original topic.)

2. A guy asks one question, gets a few answers, then asks a different
   question, and claims that he has asked the same question both times.
   Not a very good way of assuring us that he is interested in a sensible 
   answer, is it ?

Mr Upright also wrote:
> There even exists this tool called a DeepCopyArbiter that generically 
> traverses any arbitrary graph of objects, and allows you to add rulesets 
> to define at what point the deep copy should end, based on a specific 
> instance, type of object, or other criteria. 

"and allows you to add..." - but does it _require_ you to give it such
rulesets before using it, or can you just hand it an instance of 
"something" and have it return a complete, deep copy, where it has walked
through all the substructures correctly, without destroying any 
information or doing anything inappropriate with the things it 
encountered on its way ? Because that is what the original question was
about, before all the manoeuvring began... (Yes, I _really_ want to know the
answer to this question...)

-- 
Arne Knut Roev <······@online.no> Snail: N-6141 ROVDE, Norway
=
The Gates of Hell shall not prevail:
Darkness now; then Light!
From: Harley Davis
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38fa5766$0$234@newsreader.alink.net>
Ian Upright <···@oneaccordinc.com> wrote in message
·······································@4ax.com...
> I still don't understand what the problem is.  If you consider a completey
> generic one-size fits all deepCopy to be useless, I'd have to strongly
> disagree.  In Smalltalk I do what I consider "true" deep copies all the
> time, and I get a lot of use out of them.  There even exists this tool
> called a DeepCopyArbiter that generically traverses any arbitrary graph of
> objects, and allows you to add rulesets to define at what point the deep
> copy should end, based on a specific instance, type of object, or other
> criteria.  I'm baffled as to why you can't do this sort of thing easily in
> CLOS.  Maybe I'm just not familiar enough with CLOS yet, or maybe this
sort
> of pattern doesn't fit in well with the language?

Naturally, you *could* write such a system in Lisp - and many have.  The
point being made (apparently with great difficulty) is that the proposed
system is just wrong, in Lisp, SmallTalk, or any other language, except in
somewhat limited circumstances.  The correct semantics for deep copy depends
not only on the type and state of the objects being copied, but on the
*purpose* of the copy - information which cannot in general be stored in the
objects but depends on the application context.

I suspect that the rules in the proposed rules system would need to do some
sort of local network examination if you descend into generic system objects
such as lists or vectors.  If the do spend time trying to guess the purpose
of the copy from the state of the local network around the current object in
the copy, the system is probably inefficient, heuristic, and
unmaintainable - it would be easier just to have several versions of deep
copy.  Of course, in languages without closures and generic functions it can
be a pain to write recursive descent algorithms of arbitrary data
structures, so the programmer is discouraged from doing so and encouraged to
use generic facilities, even if they are inefficient and potentially
incorrect.

-- Harley
From: Ian Upright
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <68aifsgfg7180knounmcdd6gtsb8kdqglo@4ax.com>
Ian Upright <···@oneaccordinc.com> wrote:

>I still don't understand what the problem is.  If you consider a completey
>generic one-size fits all deepCopy to be useless, I'd have to strongly
>disagree.  In Smalltalk I do what I consider "true" deep copies all the
>time, and I get a lot of use out of them.

BTW, Smalltalk does have closures and streams and similar concepts to CLOS
so I'm still baffled as to why that causes a problem in CLOS but not in
Smalltalk.  (A common way in Smalltalk is to simply not deepCopy closures
and streams, etc., or don't deepCopy objects that contain them)  :-)

Ian

----------------------------------------------------------------------------
 One Accord Technologies                              ···@oneaccordinc.com
----------------------------------------------------------------------------
From: Jon S Anthony
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FBB1BB.5BA7@synquiry.com>
Ian Upright wrote:

> BTW, Smalltalk does have closures and streams and similar concepts
> to CLOS so I'm still baffled as to why that causes a problem in CLOS
> but not in Smalltalk.

It doesn't cause a problem in CLOS, and I don't understand why you
think the points made here about the problems of general deep copy
indicate in any way whatsoever that it does.

>  (A common way in Smalltalk is to simply not deepCopy closures and
> streams, etc., or don't deepCopy objects that contain them) :-)

As I mentioned in another message, I've copied closures just fine
(given the "right" circumstances).  _If_ you have a compatible
definition of what a deep copy would be for your specific context,
doing this is a shoulder shrug.  Frankly, the same is true of streams
as well.  Again, this sort of thing is _not_ the issue at all.

Can this be done in the general case, i.e., irrespective of contextual
concerns?  No.  _That's_ the point.  The amazing thing about this
whole discussion is that this should be even a remotely interesting
point, let alone one capable of generating all this irrelevant heat.


/Jon
-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Tim Bradshaw
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3r9c4cf64.fsf@cley.com>
* Jon S Anthony wrote:

> Can this be done in the general case, i.e., irrespective of contextual
> concerns?  No.  _That's_ the point.  The amazing thing about this
> whole discussion is that this should be even a remotely interesting
> point, let alone one capable of generating all this irrelevant heat.

Oh, I think that's easy.  The problem is that people come along with
this concept of `deep copy'.  They think that it refers to a real
thing out there in the world, but us horrid lisp people are trying to
make this nasty point that this notion exists *only inside their
heads* -- the concept is in fact an illusion.  This is very hard for
people to accept because it's somehow fouling up their idea of
reality, so it's just much easier for them to assume that we are wrong
or silly or something.

These issues with equality and copying are a kind of smaller version
of the kinds of problems people have with quantum mechanics.  QM is
full of places where things you think are `out there in the world'
actually turn out to be mostly in your head.  It even has some rather
similar issues with copying and identity (you don't want to think too
hard about whether two electrons are the same or different particles
for instance).  And really smart people (like Einstein) have just
crashed into a wall with this stuff and refused to accept it.

Though in some sense the issues here are even worse than QM -- at
least for QM you can just say that the world is just weird, whereas
with this stuff it's all boring little switches and wire down there,
and somehow this weird issue has arisen out of all that dull
electronics.

--tim
From: Erik Naggum
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165044910752775@naggum.no>
* Jon S Anthony <···@synquiry.com>
| The amazing thing about this whole discussion is that this should be even
| a remotely interesting point, let alone one capable of generating all
| this irrelevant heat.

  not at all.  some people will forever refuse to listen to the truth, if a
  notion they have is from a source regarded as somehow "superior" to those
  they would have to listen to to hear the truth.  these are non-technical
  people, incapable of dealing with technical issues without dealing with
  people, in the shape of trusting other people's conclusions before they
  think on their own.  what other people say to such people is immensely
  important to them, but you have to be the right person to say the right
  thing before they will accept it.  refusing to think in this particular
  way is always a source of heat, because to the people who do not want to
  listen to the truth, it's a people issue, not a technical issue at all,
  and to those who want to explain the truth, it never could be a people
  issue to begin with.

#:Erik
From: Courageous
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FC96F6.E4CC83DD@san.rr.com>
>  refusing to think in this particular way...

Life's not like that, Erik.




C/
From: Erik Naggum
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165123882306994@naggum.no>
* Courageous <········@san.rr.com>
| Life's not like that, Erik.

  we're not talking about your _life_ here.  grow a clue, now.

#:Erik
From: Courageous
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FDE81E.7489FE7D@san.rr.com>
> | Life's not like that, Erik.
> 
>   we're not talking about your _life_ here.

No, Erik. It's life in general.


C/
From: Erik Naggum
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165302603471097@naggum.no>
* Courageous <········@san.rr.com>
| No, Erik. It's life in general.

  a loser victim explains "life in general"...

  why should I take _your_ word for it, of all the people I could listen to?

  feel free to live your loser victim life, Joe Kraska.  keep me out of it.

#:Erik
From: Courageous
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F92A15.A4B3F69D@san.rr.com>
> time, and I get a lot of use out of them.  There even exists this tool
> called a DeepCopyArbiter that generically traverses any arbitrary graph of
> objects, and allows you to add rulesets to define at what point the deep
> copy should end, based on a specific instance, type of object, or other
> criteria.  I'm baffled as to why you can't do this sort of thing easily in
> CLOS.  Maybe I'm just not familiar enough with CLOS yet, or maybe this sort
> of pattern doesn't fit in well with the language?

Actually, with the MOP, you *could* do it. It took me a reread to see
what you were saying, and I just think that's wicked cool. Several
years ago we developed for C++ a similar product that would terminate
a deep copy based on depth or classes of interest. You could, for
example, express something like "deep copy for me this graph of
objects, but terminate recursion if any node you encounter is not
inherited from MyClass". Needless to say, the code generation for this
was a bitch. I have a feeling that as a Smalltalker, you're probably
just plain spoiled (I've been explaining to my boss lately that it
was a mistake making me learn Lisp, because he'll never be able
to persuade me to leave). :)

If found the book _The Art of the Metaobject Protocol_ to be very
useful for learning what you need to know about what's under the
hood of CLOS.



C/
From: Tom Breton
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m3bt3a92c0.fsf@world.std.com>
Ian Upright <···@oneaccordinc.com> writes:

> 
> As a Smalltalker who doesn't read this newsgroup very often, I was quite
> irritated by Mr. Naggum's absurd and highly inflamitory opinions.  It seemed
> to be a perfectly reasonable question to ask, not warranting even a *hint*
> of inflammatory comments.
> 
> Are all Lisper's f***ing belligerent ass*****?  ;-)

I can certainly understand why you mite think so!

But I promise you, there are a good number of less vocal posters who
frequent cll who are both knowledgeable and civil.

-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
Suggestion:  Use your killfile liberally in cll
From: Tom Breton
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m33dom91qn.fsf@world.std.com>
Ian Upright <···@oneaccordinc.com> writes:

Let me answer the technical question separately:

> I still don't understand what the problem is.  If you consider a completey
> generic one-size fits all deepCopy to be useless, I'd have to strongly
> disagree.  In Smalltalk I do what I consider "true" deep copies all the
> time, and I get a lot of use out of them.  There even exists this tool
> called a DeepCopyArbiter that generically traverses any arbitrary graph of
> objects, and allows you to add rulesets to define at what point the deep
> copy should end, based on a specific instance, type of object, or other
> criteria.  I'm baffled as to why you can't do this sort of thing easily in
> CLOS.  Maybe I'm just not familiar enough with CLOS yet, or maybe this sort
> of pattern doesn't fit in well with the language?

In Lisp, some important structures haven't got that sort of type
information.  IIUC this is not true in Smalltalk, which is strongly
typed.

For instance, alists ("dictionaries" to you) can't be distinguished
from ordinary lists without outside help.  But they need to be copied
in a special way.  So a deep copy in Lisp that found a list wouldn't
know whether to copy it as a regular list or an alist, and if it
guessed wrong it would make a mess.

As you suggest, it's all about how deep to copy; where to stop
descending.

FWIW, I wouldn't give up the ease with which Lisp operates on general,
untyped graphs just to have a deep copy.

-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
Suggestion:  Use your killfile liberally in cll
From: Tim Bradshaw
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3g0sm44xs.fsf@cley.com>
* Ian Upright wrote:

> I still don't understand what the problem is.  If you consider a completey
> generic one-size fits all deepCopy to be useless, I'd have to strongly
> disagree.  In Smalltalk I do what I consider "true" deep copies all the
> time, and I get a lot of use out of them.  There even exists this tool
> called a DeepCopyArbiter that generically traverses any arbitrary graph of
> objects, and allows you to add rulesets to define at what point the deep
> copy should end, based on a specific instance, type of object, or other
> criteria.  

Can you copy a queue correctly with this tool -- more generally does
it preserve arbitrary structure sharing?  Can you use it to do several
different sorts of copies of an object depending on what kind of copy
you want?  Does it have a user-definable version of equality and can
you have several different notions of equality for the same object?

--tim
From: Tim Bradshaw
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3aeitefxh.fsf@cley.com>
* I wrote:

> Can you copy a queue correctly with this tool -- more generally does
> it preserve arbitrary structure sharing?  Can you use it to do several
> different sorts of copies of an object depending on what kind of copy
> you want?  Does it have a user-definable version of equality and can
> you have several different notions of equality for the same object?

I think this sounds a bit glib, so I'll try and be a bit clearer.  I
hope this will be the last thing I write about this, because I've said
everything I have to I think, and probably more than I should have.

What I was mostly getting at was something that I kind of touched on
in the metafeatures paper, but I don't think I quite said it
explicitly, so here it is.

	Programs, especially programs in a language like Lisp where
	memory-management issues don't make complex data structures a
	nightmare to deal with, can have objects which have shared
	structure, and typically do.

	This can be incidental -- without free() to kill you, it's OK
	to share bits of other people's objects so long as you are
	careful about modifying them.

	Or it can be intentional, where the sharing is an important
	part of the nature of the object.  This is actually really
	common in Lisp both in user code and also in things like
	closures sharing environments.

	A good example of this is a very obvious Lisp implementation
	of a queue, or fifo object.  This can be made in Lisp by an
	object with two slots, one of which is a list, from which
	things are peeled off one by one, and one of which is the last
	cons of that same list.  To add something to the queue you
	destructively modify the last cons of the list something
	like this:

		(setf (cdr lastcons) (cons new nil)
	              lastcons (cdr lastcons))

	(of course, there are boundary conditions to deal with when
	the queue empties and so on, but those don't matter here).

	It's absolutely crucial that a copier for this object do the
	right thing:

		a shallow copy will create something which is kind of
		the same as the old queue, except that strange things
		will happen if either queue empties;

		a deep copy which does not preserve sharing will
		create something which is just not a queue at all --
		new objects added to the `queue' don't actually get
		added.

	There are two approaches to copying such an object which will
	work.

	You could write a special queue-copier, which would be
	efficient.  This is, I think, the right solution.

	You could make a general-purpose copier which preserves
	structure sharing (I call this graph-copying).  This requires
	an occurs check, and that is just inherently expensive I
	believe[*], as such a general copier needs to check *every*
	object in the thing being copied, whereas a special one can
	know that only certain bits of sharing matter.  Even then it
	is questionable as to whether such a general copier is really
	plausible.

	It seems to me that there are two kinds of `general deep
	copier' out there -- ones that don't preserve sharing and can
	thus cause mysterious bugs, and ones that do and thus are much
	more expensive than you would like.  Java for instance (which
	seems to have done mostly the right thing by defining an
	interface for copying but no actual implementation), seems to
	have a sharing-preserving copier in its serialisation
	protocol: I wonder how many people realise this, and realise
	the potential costs.

	I would be interested in knowing what the SmallTalk and CORBA
	copiers do.

--tim

[*] I'd also be interested in knowing if this can be made cheap.  I
don't think it can because I think it's basically a theorem that's
known in places like the logic programming community (prolog has no
occurs check).  There is a neat special case that *can* be made cheap,
which is when you're allowed to destroy the graph you are copying.
That's what copying GCs do.  This is kind of reminiscent of Henry
Baker's Linear Lisp stuff, and in fact it might be the same case in
some way deeper than I can see.
From: Courageous
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FB3BE1.F635FBFF@san.rr.com>
>         It seems to me that there are two kinds of `general deep
>         copier' out there -- ones that don't preserve sharing and can
>         thus cause mysterious bugs, and ones that do and thus are much
>         more expensive than you would like.  Java for instance (which
>         seems to have done mostly the right thing by defining an
>         interface for copying but no actual implementation), seems to
>         have a sharing-preserving copier in its serialisation
>         protocol: I wonder how many people realise this, and realise
>         the potential costs.

In my experience, CORBA and JAVA both make network programming
accessible to a class of programmers who are really completely
unaware of the costs of certain kinds of network operations.
While I realize that this isn't what you were talking about,
I've seen *so* many programs that were written using bad
CORBA designs and therefor were so slow it could scarcely
be believed.

>         I would be interested in knowing what the SmallTalk and CORBA
>         copiers do.

I actually haven't read the ObjectsByValue standard myself, but
I wouldn't be the least bit surprised if it was nearly identical
to Java's... it was the people behind Java which lobbied so hard
for it, in order to make RMI and CORBA compatible, IIRC.



C/
From: Jon S Anthony
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FBB3FC.43D3@synquiry.com>
Courageous wrote:

> >         I would be interested in knowing what the SmallTalk and CORBA
> >         copiers do.
> 
> I actually haven't read the ObjectsByValue standard myself, but
> I wouldn't be the least bit surprised if it was nearly identical

the object by value thing in CORBA goes back before Jave even existed
(or at least before it meant anything to anybody).  I know it was
being discussed (and there were even various incompatible
implementations of this sort of thing) 6-7 years ago.

As someone else pointed out already, this is a particularly stupid
idea for CORBA or any "distributed object" paradigm, and what's more,
the simple minded definition of "copy" here could already be done with
struct.  Which is to say, that CORBA object by value, in no way copies
the _object_ in any reasonable sense, since only simple state and none
of the methods are copied...

/Jon


-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Courageous
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FBB756.DD4193C5@san.rr.com>
> the object by value thing in CORBA goes back before Jave even existed
> (or at least before it meant anything to anybody).  I know it was
> being discussed (and there were even various incompatible
> implementations of this sort of thing) 6-7 years ago.

A friend of mine who's fairly heavily into the whole CORBA
thing (he was our head link up with the Visibroker
folks) says that Sun was behind OBV very strongly, lobbying in
particular for an implementation compatible with the way RMI
does things.

Which isn't to say that Sun was instrumental in introducing
OBV, but rather that they weighed in heavily on its final
form...



C/
From: Jon S Anthony
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FCDC24.2994@synquiry.com>
Courageous wrote:
> 
> > the object by value thing in CORBA goes back before Jave even existed
> > (or at least before it meant anything to anybody).  I know it was
> > being discussed (and there were even various incompatible
> > implementations of this sort of thing) 6-7 years ago.
> 

> A friend of mine who's fairly heavily into the whole CORBA thing (he
> was our head link up with the Visibroker folks) says that Sun was
> behind OBV very strongly, lobbying in particular for an
> implementation compatible with the way RMI does things.

The problem is that with Sun, the evidence available strongly suggests
that the right hand doesn't even know the left hand exists, let alone
knows what it may be doing.  Back there in '93 or so, the Sun folk (at
the OMG meetings and elsewhere) made all sorts of noise about how they
were going to be a C++ only shop.  The ORB folk at Sun went blithely
on their way with this view.  Along came the Java folk and RMI (yet
another incompatible distributed method invocation scheme).  The two
sides finally noticed one another.  There was much heat.  One thing
that came out of this was that RMI was supposed to become layered on
CORBA (or at least IIOP).


Of course, there was yet another group that decided to do another ORB
altogether, just for JDK.  This ORB sucked, was not part of 1.1, but
at least it was free. OTOH RMI was available in 1.1 and, since the
industry is rife with incompetence and the browser folk could never
agree on any sort of "standard ORB" to include, and, for unknown(able)
"reasons" have never included Java 1.2 in their offerings or any
current ORB, it (RMI) is still there in its original form and, in the
"web world", the only game in town.

Go figure.


/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Fernando
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <hi5mfs81dl8brff2ho90u64kkgqro5urev@4ax.com>
On Sun, 16 Apr 2000 02:24:49 GMT, Ian Upright <···@oneaccordinc.com>
wrote:


>Are all Lisper's f***ing belligerent ass*****?  ;-)

	Nope.  Just a few (one?) of us specializes in Lots of
Insignificant Silly Posts... ;-)

>
>I still don't understand what the problem is.  If you consider a completey
>generic one-size fits all deepCopy to be useless, I'd have to strongly
>disagree.  In Smalltalk I do what I consider "true" deep copies all the

	That's because Smalltalk has a stronger typing and your deep
copier may know what an object is, just "by looking at it".  In CL,
this is not always the case....






//-----------------------------------------------
//	Fernando Rodriguez Romero
//
//	frr at mindless dot com
//------------------------------------------------
From: Jon S Anthony
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FBB5AB.A17@synquiry.com>
Fernando wrote:
>
>         That's because Smalltalk has a stronger typing and your deep
> copier may know what an object is, just "by looking at it".  In CL,
> this is not always the case....

It's not the case in any language.  Even in something like Ada where you
have very strong and static typing, this sort of magical deep copier
that always does the correct thing for any application using any
representation (intensional and implementation) cannot be done.


/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Harley Davis
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38fbbbf1$0$231@newsreader.alink.net>
Fernando <·······@must.die> wrote in message
·······································@4ax.com...
> On Sun, 16 Apr 2000 02:24:49 GMT, Ian Upright <···@oneaccordinc.com>
> wrote:
> >I still don't understand what the problem is.  If you consider a
completey
> >generic one-size fits all deepCopy to be useless, I'd have to strongly
> >disagree.  In Smalltalk I do what I consider "true" deep copies all the
>
> That's because Smalltalk has a stronger typing and your deep
> copier may know what an object is, just "by looking at it".  In CL,
> this is not always the case....

In what way does Smalltalk have stronger typing than Lisp?

-- Harley
From: Courageous
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FBB2CB.B72BE34@san.rr.com>
>         That's because Smalltalk has a stronger typing and your deep
> copier may know what an object is, just "by looking at it".  In CL,
> this is not always the case....

Well, you never know how much someone has screwed with the MOP,
but disregarding that, isn't it possible to check to see if the
object is 'standard-object? Perhaps I don't know what you mean
by "what an object is", unless of course you're referring to the
fact that it's quite possible to build objects with the MOP that
*don't* derive from 'standard-object.

I wonder how frequently this degenerate case ever really occurs?




C/
From: Robert Monfera
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FD0AF7.583E21D3@fisec.com>
Courageous wrote:

> Well, you never know how much someone has screwed with the MOP,
> but disregarding that, isn't it possible to check to see if the
> object is 'standard-object? Perhaps I don't know what you mean
> by "what an object is", unless of course you're referring to the
> fact that it's quite possible to build objects with the MOP that
> *don't* derive from 'standard-object.
>
> I wonder how frequently this degenerate case ever really occurs?

You still have not read the paper by Tim Bradshaw?  His queue class is
neither a non-standard metaobject nor something that a "default" deep
copier can properly duplicate.  It is impolite to pursue a thread
without investing at least as much time understanding responses as
responding.

Robert
From: Courageous
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FD0FC2.7DB08E2B@san.rr.com>
> You still have not read the paper by Tim Bradshaw?  His queue class is
> neither a non-standard metaobject nor something that a "default" deep
> copier can properly duplicate.  It is impolite to pursue a thread
> without investing at least as much time understanding responses as
> responding.

I completely understand that you can't just deep copy every
type of object blithely.



C/
From: Rob Warnock
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8dmrgp$1oh03$1@fido.engr.sgi.com>
Courageous  <········@san.rr.com> wrote:
+---------------
| > You still have not read the paper by Tim Bradshaw?  His queue class is
| > neither a non-standard metaobject nor something that a "default" deep
| > copier can properly duplicate.  It is impolite to pursue a thread
| > without investing at least as much time understanding responses as
| > responding.
| 
| I completely understand that you can't just deep copy every
| type of object blithely.
+---------------

It's worse than that. The issue has nothing to do with "objects" per se.
Tim's queue "class" can trivially be [and frequently *was*, before CLOS!]
implemented as a single cons cell [sometimes called a "queue header"], and
*none* of the standard copiers for cons cells will "do the right thing" w.r.t.
preserving the required invariant (eq (last (car header)) (cdr header)).

If this isn't clear, observe the following:

	> (defun valid-queue-p (header)
	    (eq (last (car header)) (cdr header)))
	VALID-QUEUE-P
	> (defvar foo '((a b c d e . #1=(f)) . #1#))
	FOO
	> foo
	((A B C D E F) F)
	> (valid-queue-p foo)
	T
	> (defvar tree-copied-foo (copy-tree foo))  
	TREE-FOO
	> tree-copied-foo
	((A B C D E F) F)
	> (valid-queue-p tree-copied-foo) 
	NIL
	> (defvar list-copied-foo (copy-list foo))
	LIST-FOO
	> list-copied-foo
	((A B C D E F) F)
	> (valid-queue-p list-copied-foo)
	NIL
	> (defvar seq-copied-foo (copy-seq foo))  
	SEQ-FOO
	> seq-copied-foo
	((A B C D E F) F)
	> (valid-queue-p seq-copied-foo) 
	NIL
	>

In fact, the *only* way to copy such a queue "correctly" is with an
*application-aware* (or "intention-aware") copy routine, such as:

	> (defun copy-queue (header)
	    (let ((copy (copy-list (car header))))
	      (cons copy (last copy))))
	COPY-QUEUE
	> (defvar queue-copied-foo (copy-queue foo))
	QUEUE-COPIED-FOO
	> (defvar queue-copied-foo (copy-queue foo))
	QUEUE-COPIED-FOO
	> queue-copied-foo
	((A B C D E F) F)
	> (valid-queue-p queue-copied-foo)
	T
	>


-Rob

-----
Rob Warnock, 41L-955		····@sgi.com
Applied Networking		http://reality.sgi.com/rpw3/
Silicon Graphics, Inc.		Phone: 650-933-1673
1600 Amphitheatre Pkwy.		PP-ASEL-IA
Mountain View, CA  94043
From: Tim Bradshaw
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3aeip9bl0.fsf@cley.com>
* Rob Warnock wrote:

> In fact, the *only* way to copy such a queue "correctly" is with an
> *application-aware* (or "intention-aware") copy routine, such as:

I don't think so.  Graph copy (the thing I talk about tat the end of
my paper) will copy it, but at appalling cost.  an application-aware
copier is obviously much better.

--tim
From: Rahul Jain
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8dh0i8$hnr$1@joe.rice.edu>
In article <················@san.rr.com> posted on Monday, April 17,
2000  7:53 PM, Courageous <········@san.rr.com> wrote:
> Well, you never know how much someone has screwed with the MOP,
> but disregarding that, isn't it possible to check to see if the
> object is 'standard-object? Perhaps I don't know what you mean
> by "what an object is", unless of course you're referring to the
> fact that it's quite possible to build objects with the MOP that
> *don't* derive from 'standard-object.
> 
> I wonder how frequently this degenerate case ever really occurs?

What he means is that it's often impossible to tell the actual purpose
of a data structure from just it's contents. An alist looks just like a
normal list, or maybe a tree. Therefore you really can't tell what to
copy since you don't know if you're copying a list, tree, or alist.


-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Tim Bradshaw
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3wvlwcgby.fsf@cley.com>
* Fernando  wrote:

> 	That's because Smalltalk has a stronger typing and your deep
> copier may know what an object is, just "by looking at it".  In CL,
> this is not always the case....

It doesn't have stronger typing.  It may be that smalltalk people tend
to use distinct classes where CL people would overload a single
class. I think in smalltalk you can subclass things like string and
array classas, so you could probably get more information about what
sort-of-thing is meant.  Whether people actually *do* this kind of
subclassing for in smalltalk I don't know.

(This will now degenerate into a futile argument about whether or not
you should have distinct classes for every intensional type, or wrap
every non-subclassable type in some object you can subclass (like Java
with all its weird explicit boxing stuff for numbers and so on).  In
this discussion somehow both C++ people and SmallTalk people will gang
up on the Lisp people despite having completely opposite views on
almost everything.

Somewhere in one of these threads is the c.l.l version of Godwin's law
-- I wish I knew exactly what the magic phrase is for c.l.l.)

--tim
From: Courageous
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FBDEAA.936932C8@san.rr.com>
> It doesn't have stronger typing.  It may be that smalltalk people tend
> to use distinct classes where CL people would overload a single
> class.

Well, from the C++ view, you can't really add a method to a
pre-existing object type that you don't have source for. Hence,
if all you want to do is add a method to a third-party class,
you have to subclass it. Pretty sucky, really.

Lots of little inconveniences like that, but frankly I don't
think they ever really made for better programs the way they
were promised to do.

> like Java with all its weird explicit boxing stuff for numbers and so on

Ah, not sure what you mean by "boxing stuff," but if your talking
about int versus Integer and the like, these simply exist so that
in certain contexts the performance costs for using the full-object
versions can be avoided. The "High Performance Computing Movement"
for Java has some requests to add even more primitive types to
Java, although I can't recall what at the moment. Something about
a way to create a non reference counted object, I think. I
doubt it'll ever fly, but with creeping featurism, one can never
tell.

I already know that there is a version of RMI serialization
which makes a bunch of assumptions about the exchanging architectures
and excludes object metadata that is a full order of magnitude
faster than the reference implementation (bug of course, you can
only use this protocol under very specific circumstances).

>  In
> this discussion somehow both C++ people and SmallTalk people will gang
> up on the Lisp people despite having completely opposite views on
> almost everything.

Hitler! Hitler! Hitler!

*looks around*

Did it work? :)



C/
From: Tim Bradshaw
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3og78ca72.fsf@cley.com>
* Courageous  wrote:

> Ah, not sure what you mean by "boxing stuff," but if your talking
> about int versus Integer and the like, these simply exist so that
> in certain contexts the performance costs for using the full-object
> versions can be avoided. 

But the way to get that is a decent compiler, not smashing the
language which you then have to live with for ever.  CL has real
objects for its numbers (you can define methods, though not subclass
them, which seems like a good middle ground to me), and some very good
numerical compilers.  Given the amount that I'm sure is being spent on
Java compilers by people like Sun, which probably dwarfs the total
expenditure on Lisp compilers throughout history, and the fact that
Java has Lisp people working on it, this is pretty tragic.

Perhaps they crippled themselves by defining the JVM in such a way
that you can never unbox things.  Sounds like a sad design mistake to
me...


--tim
From: Courageous
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FBF6C7.B3C2EC41@san.rr.com>
> > Ah, not sure what you mean by "boxing stuff," but if your talking
> > about int versus Integer and the like, these simply exist so that
> > in certain contexts the performance costs for using the full-object
> > versions can be avoided.
> 
> But the way to get that is a decent compiler, not smashing the
> language which you then have to live with for ever.  CL has real
> objects for its numbers (you can define methods, though not subclass
> them, which seems like a good middle ground to me), and some very good
> numerical compilers.  Given the amount that I'm sure is being spent on
> Java compilers by people like Sun, which probably dwarfs the total
> expenditure on Lisp compilers throughout history, and the fact that
> Java has Lisp people working on it, this is pretty tragic.
> 
> Perhaps they crippled themselves by defining the JVM in such a way
> that you can never unbox things.  Sounds like a sad design mistake to
> me...

Possibly. I suspect there is some (small) benefit to be
had from having elements of objects which themselves
aren't referenceable; possibly removing the reference
traversing overhead as well as the necessity of
checking for dynamic dispatch. However, I'm not expert
at what compilers can or cannot optimize away in this
regard. I checked up on my previous reference to requests
to change Java, and finally found what I was looking for:
Java Grande. It's a high performance computing movement
related to java. They have a website at:

http://www.javagrande.org

They have some interesting publications in .pdf format.

BTW, some of Java's inability to be optimized past a
certain point may have something to do with the virtual
machine? (disregarding the possibility of native
compiling for the moment, of course)

C/
From: Tim Bradshaw
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3ln2bd8kn.fsf@cley.com>
* Courageous  wrote:

> Possibly. I suspect there is some (small) benefit to be
> had from having elements of objects which themselves
> aren't referenceable; possibly removing the reference
> traversing overhead as well as the necessity of
> checking for dynamic dispatch. However, I'm not expert
> at what compilers can or cannot optimize away in this
> regard. 

I think the answer to this is that they can optimize everything.
Certainly good Lisp compilers are capable of doing an extremely good
job, with relatively small effort expended on them.

--tim
From: Harley Davis
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38fe33ee$0$236@newsreader.alink.net>
Tim Bradshaw <···@cley.com> wrote in message
····················@cley.com...
> * Courageous  wrote:
>
> > Possibly. I suspect there is some (small) benefit to be
> > had from having elements of objects which themselves
> > aren't referenceable; possibly removing the reference
> > traversing overhead as well as the necessity of
> > checking for dynamic dispatch. However, I'm not expert
> > at what compilers can or cannot optimize away in this
> > regard.
>
> I think the answer to this is that they can optimize everything.
> Certainly good Lisp compilers are capable of doing an extremely good
> job, with relatively small effort expended on them.

I'm pretty sure they just wanted to have real 32 and 64 bit ints instead of
having to use either boxing or type dispatch bits, and this overrode the
programmer-friendliness consideration of making all types equal citizens.

-- Harley
From: Daniel Barlow
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <87og774jyg.fsf@tninkpad.telent.net>
Courageous <········@san.rr.com> writes:

> Hitler! Hitler! Hitler!
> 
> *looks around*
> 
> Did it work? :)

According to the traditional reading of Godwin's Law, the person who
made the comparison is deemed to have lost.

Hey ho.

-dan
From: Jon S Anthony
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FBAFC1.63D0@synquiry.com>
Ian Upright wrote:
> 
> I still don't understand what the problem is.  If you consider a
> completey generic one-size fits all deepCopy to be useless, I'd have
> to strongly disagree.

It's not considered "useless" it's being correctly considered
impossible.  Go back and look at the responses to this issue.


>  In Smalltalk I do what I consider "true" deep copies all the time,
> and I get a lot of use out of them.

Which again is the point.  You have _some_ definition in mind for what
this is and you do it with that definition in mind and are happy about
the results.  Everyone here would nod their head in agreement.  For
another space, your definition may be not just useless, but outright
wrong.


>  There even exists this tool called a DeepCopyArbiter that
> generically traverses any arbitrary graph of objects, and allows you
> to add rulesets to define at what point the deep copy should end,
> based on a specific instance, type of object, or other criteria.

That's irrelevant.


> I'm baffled as to why you can't do this sort of thing easily in
> CLOS.  Maybe I'm just not familiar enough with CLOS yet, or maybe
> this sort of pattern doesn't fit in well with the language?

You can, which is why the point at the level you are making it is
irrelevant.


/Jon


-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Gareth Rees
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <u7ldxvv3i.fsf@pobox.com>
Ian Upright wrote:
> I still don't understand what the problem is.  If you consider a
> completely generic one-size fits all deepCopy to be useless, I'd have
> to strongly disagree.  In Smalltalk I do what I consider "true" deep
> copies all the time, and I get a lot of use out of them.

The issue is one of deciding when to copy and when not to copy.
Sometimes structure must be copied, sometimes it must be shared (for
example, it's almost never right to descend into the symbol table when
copying a structure -- symbols should be shared between the original and
the copy).

To decide when to copy you have to look at the intensional type of the
object (that is, the programmer's notion of the type of the object and
how it is to be used).  The representation type of the object is not
enough because the same representation type may be used to represent
many different intensional types.  This is particularly common in Lisp,
where for example a cons cell may be used to represent pairs, lists,
binary trees, n-ary trees, association lists and other datatypes.

If you adopt a discipline whereby each intensional type is represented
by one representational type -- for example by defining a class for each
intensional type -- then you can write a "generic" deep copy that works
for that discipline.  It can use the representational type to decide
when to copy and when to share.

Maybe it is usual in Smalltalk to work under such a discipline.  But it
is not common in Lisp.  In Lisp it is convenient and commonplace to put
data into generic lists or vectors (as opposed to using `defstruct' or
`defclass' to make a new representational type for each new type).

(Note that such a "generic" deep copier isn't truly generic because it
only works if the programmer respects the discipline.  This is the issue
that people have been talking about.)

-- 
Gareth Rees
From: Erik Naggum
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164963670328673@naggum.no>
* Ian Upright <···@oneaccordinc.com>
| As a Smalltalker who doesn't read this newsgroup very often, I was quite
| irritated by Mr. Naggum's absurd and highly inflamitory opinions.

  I'm glad you agree that being quite irritated at other people's absurd
  and highly inflammatory opinions is perfectly acceptable.

| Are all Lisper's f***ing belligerent ass*****?  ;-)

  no, but all visiting smalltalkers might perhaps be, based on the usual
  sample of one to support generalizations.  smiley or no smiley, such
  flaws in methodology or complete lack of methodological thinking is at
  the core of my criticism.  people who lack the ability, or who have never
  been trained, to think methodologically, make mistakes that nothing short
  of fixing their methodology can change.  most intelligent people pick up
  on this relatively fast when required to.  morons think they have a right
  to make even less methodolically sound claims when criticized.

| I still don't understand what the problem is.

  well, that's odd, since you illustrated it well when you took it for
  granted that certain object types in Smalltalk are simply not copied.

#:Erik
From: David Thornley
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <Oy5L4.2782$9L.92052@ptah.visi.com>
In article <··································@4ax.com>,
Ian Upright  <···@oneaccordinc.com> wrote:
>Arne Knut Roev <······@online.no> wrote:
>
>Are all Lisper's f***ing belligerent ass*****?  ;-)
>
At least one is.  (Of course, I read the perl newsgroups for a while.  I
found it easier to live with Erik afterwards.) 

>I still don't understand what the problem is.  If you consider a completey
>generic one-size fits all deepCopy to be useless, I'd have to strongly
>disagree.

Obviously not useless, although not as useful as a reliable infinite loop
detector.  The question is whether it's more possible.

  In Smalltalk I do what I consider "true" deep copies all the
>time, and I get a lot of use out of them.

I do them too, in Lisp.  Generally, I write a method saying what the
particular copy I'm writing should do for each applicable class.
This doesn't mean that a general solution exists.

  There even exists this tool
>called a DeepCopyArbiter that generically traverses any arbitrary graph of
>objects, and allows you to add rulesets to define at what point the deep

Stop right there.

How is this different from what I do, except that all the copying rules
are in one place?  I don't think it would be difficult to write a
deep-copy-arbiter macro that would write methods to do deep copies while
stopping at specified classes.  (OK, it would need a bit of the MOP to
find out what the members of classes are.)

If this sort of macro doesn't exist, it's because nobody's bothered to
write it.

--
David H. Thornley                        | If you want my opinion, ask.
·····@thornley.net                       | If you don't, flee.
http://www.thornley.net/~thornley/david/ | O-
From: Arne Knut Roev
Subject: Re: On the quality of this newsgroup, was: Re: Deep copy in lisp: how?
Date: 
Message-ID: <Ft9L3v.xt@online.no>
David Thornley <········@visi.com> wrote:
> In article <··································@4ax.com>,
> Ian Upright  <···@oneaccordinc.com> wrote:
>>Arne Knut Roev <······@online.no> wrote:
[snip!]

For the record: None of the text fragments Mr Thornley quotes, were written
by me.

Apart from this, I have no comments to his posting.

-- 
Arne Knut Roev <······@online.no> Snail: N-6141 ROVDE, Norway
=
The Gates of Hell shall not prevail:
Darkness now; then Light!
From: Tim Moore
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8d7ko7$2lk$0@216.39.145.192>
On Fri, 14 Apr 2000, Fernando wrote:

> On 13 Apr 2000 17:01:03 GMT, Tim Moore <·····@herschel.bricoworks.com>
> wrote:
> >Apropos of nothing, C++ hasn't stood still and isn't quite as cretinous as
> >it was 10 years ago.  I use a C++ garbage collector (Boehm) in my work and
> 
> 	Interesting...  Any links to this gc? O:-)
http://www.hpl.hp.com/personal/Hans_Boehm/gc/
Tim
From: Fernando
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <49kgfs0j1vh847qbdtffsv390au282pk8r@4ax.com>
On 14 Apr 2000 17:32:55 GMT, Tim Moore <·····@herschel.bricoworks.com>
wrote:

>On Fri, 14 Apr 2000, Fernando wrote:
>
>> On 13 Apr 2000 17:01:03 GMT, Tim Moore <·····@herschel.bricoworks.com>
>> wrote:
>> >Apropos of nothing, C++ hasn't stood still and isn't quite as cretinous as
>> >it was 10 years ago.  I use a C++ garbage collector (Boehm) in my work and
>> 
>> 	Interesting...  Any links to this gc? O:-)
>http://www.hpl.hp.com/personal/Hans_Boehm/gc/

Thanks. :-)





//-----------------------------------------------
//	Fernando Rodriguez Romero
//
//	frr at mindless dot com
//------------------------------------------------
From: Tom Breton
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m3hfd5975h.fsf@world.std.com>
Courageous <········@san.rr.com> writes:

> >   I'm sure you and your shrink have worked something out that...
> 
> You just can't stop, can you Erik?

Apparently he can't.

-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164646548558686@naggum.no>
* Tom Breton <···@world.std.com>
| Apparently he can't.

  Microsoft hired Ralph Reed of Christian Coalition fame as their lobbyist
  in Washington to get George Dubya to be favorable to their antitrust
  lawsuit.  this was widely considered a serious mistake, especially after
  the New York Times uncovered it.

  I haven't hired Tom Breton as my spokesman or lobbyist, but it would be
  the same kind of mistake if I had.

  so, can _you_ stop, Tom?  but we know the answer: "apparently he can't".

#:Erik
From: ·······@my-deja.com
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8d430e$rea$1@nnrp1.deja.com>
In article <·············@synquiry.com>,
  Jon S Anthony <···@synquiry.com> wrote:
> Any such constraints are
> _context_ specific, i.e., specific to the problem space, the various
> representations that you have chosen to to encode it, and what those
> representations _mean in the given context_.  It should be completely
> clear that no general solution this is _possible_ no matter what set
> of "primitive" representations you are willing to restrict yourself
> to.

Well, it depends on what you mean by "deep copy".  The obvious
meaning is that after a deep copy, you have two references
that behave identically, but updates through one won't affect
the behavior of the other (that idea can be formalized).
Most languages can't implement this, but it's still well-defined.

> Of course you can copy
> _any_ datastructures (and vastly simpler, more easily correct, and
> cleaner in CL than you could even dream of doing in your wildest
> fantasies in C++), but that's the _easy_ part.

No, in fact, some very common data structures in CommonLisp
cannot be copied because they are opaque, among them closures
and streams.

> Knowing which parts to
> copy, when to copy, and how to copy, is the important part and the
> part which is context specific and thus impossible to generalize in
> the sense you seem to want.

Unlike equality, where it matters if you compare too much,
for the semantics of a deep copy, it doesn't matter if you
copy too much--it will simply be inefficient.

Automatic deep copy is actually a pretty common operation in
dynamic distributed object systems and persistent object stores,
and a number of systems do a very good job implementing it
almost completely automatically.  Even CL compilers end up
having to be able to perform some pretty general deep copies.

Tom.


Sent via Deja.com http://www.deja.com/
Before you buy.
From: Jon S Anthony
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F66318.333A@synquiry.com>
·······@my-deja.com wrote:
> 
> In article <·············@synquiry.com>,
>   Jon S Anthony <···@synquiry.com> wrote:
> > Any such constraints are
> > _context_ specific, i.e., specific to the problem space, the various
> > representations that you have chosen to to encode it, and what those
> > representations _mean in the given context_.  It should be completely
> > clear that no general solution this is _possible_ no matter what set
> > of "primitive" representations you are willing to restrict yourself
> > to.
> 
> Well, it depends on what you mean by "deep copy".  The obvious

Which is one thing that many here have been trying to point out.


> meaning is that after a deep copy, you have two references
> that behave identically, but updates through one won't affect
> the behavior of the other (that idea can be formalized).

That's one meaning.


> > Of course you can copy
> > _any_ datastructures (and vastly simpler, more easily correct, and
> > cleaner in CL than you could even dream of doing in your wildest
> > fantasies in C++), but that's the _easy_ part.
> 
> No, in fact, some very common data structures in CommonLisp
> cannot be copied because they are opaque, among them closures
> and streams.

I'm not sure about streams, but I've actually copied closures in
(effectively) your sense.  Of course, it requires having the proper
source around to do it.


/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Jon S Anthony
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F6644D.2611@synquiry.com>
·······@my-deja.com wrote:
> 

> No, in fact, some very common data structures in CommonLisp
> cannot be copied because they are opaque, among them closures
> and streams.

On second thought, you're right - the kind of copy that I did for
closures would not (in general) fit your definition.

/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F5927A.B8CE9601@san.rr.com>
> Automatic deep copy is actually a pretty common operation in
> dynamic distributed object systems and persistent object stores,
> and a number of systems do a very good job implementing it
> almost completely automatically.

Having worked with distributed systems and object databases
for 8 years now, I've noticed the same thing. Said systems
do a lot of bending over backwards to fit a square peg into
a round hole, but they get the job done.

C/
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3d7nuuhzj.fsf@cley.com>
* tom 98 wrote:

> Unlike equality, where it matters if you compare too much,
> for the semantics of a deep copy, it doesn't matter if you
> copy too much--it will simply be inefficient.

Actually, it does matter, especially if you copy things that should be
equal so they stop being equal.  If you copy things that not DAGs then
this can not only fail to preserve the semantics of your data
structure but fail to terminate, which is bad.  Making things that are
only incidentally equal remain equal is only bad for efficiency.

--tim
From: ·······@my-deja.com
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8d5d2a$b28$1@nnrp1.deja.com>
> > Unlike equality, where it matters if you compare too much,
> > for the semantics of a deep copy, it doesn't matter if you
> > copy too much--it will simply be inefficient.
>
> Actually, it does matter, especially if you copy things that should be
> equal so they stop being equal.  If you copy things that not DAGs then
> this can not only fail to preserve the semantics of your data
> structure but fail to terminate, which is bad.

It depends on the definition of "deep copy" you choose.  My
definition is based on mutability, not any form of equality.
I think that's what most people really mean by "deep copy", and that's
what most systems that have it actually provide.

Conceptually, you can implement deep copy by simply copying the
complete object graph of the system and returning a reference to the
copy of the object referenced by the original reference.  This is
guaranteed to terminate and will have the semantics I describe.

Note that that doesn't mean everything is smooth sailing.
For example, code that uses references into the old data
data structure as, say, iteration guards will simply fail
when used with the copy.  And if you have objects in the Lisp data
structure, like an integer file descriptor, that refer to some external
state, then that external state will obviously not get copied
(nor should it).

> Making things that are
> only incidentally equal remain equal is only bad for efficiency.

The problem with defining equality is not things that are
incidentally equal, it's that many common data structures
(hash tables, splay trees, association lists, etc.) are semantically
equal even though they are structurally different; mutable structures
are also ambiguous from the point of view of equality.

It is possible to define general deep structural equality predicates and
many languages do.  They usually don't map onto semantic equality,
but they are still quite useful, and generally quite
conservative (e.g., mutable structures are not equal, regardless of
content).

Many recent languages also have some simple conventions about what
should
participate in deep copies and deep equality by default, simple means
for
overriding that, and a standard way of communicating programmer intent
to the runtime.  This allows them to implement distributed object
systems,
object persistence, and a lot of other facilities, almost completely
automatically.

In general, I think there are consistent definitions of
"deep copy" and "deep structural equality" possible in Lisp,
just like they are in most other languages.  But these operations
are probably not going to be all that useful in Lisp due to
the semantics of the language: Lisp has a very general set of
types, most of them are mutable, and Lisp has almost no
conventions for how to define deep copy and deep equality.
In languages with less mutability (ML, Haskell, ...), restricted
sets of data structures (APL, Matlab4, ...), or very uniform
conventions on how to define new data structures (Java, ...),
notions of deep copy and deep structural equality are actually
useful.

Tom.


Tom.


Sent via Deja.com http://www.deja.com/
Before you buy.
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3snwou269.fsf@cley.com>
* tom 98 wrote:

> It depends on the definition of "deep copy" you choose.  My
> definition is based on mutability, not any form of equality.
> I think that's what most people really mean by "deep copy", and that's
> what most systems that have it actually provide.

I'm not quite sure what you mean by this.  Copying immutable objects
is something that I think Lisp people would find extremely
uninteresting except in some special cases (like copying an object
into another lisp image).  But there pretty much are no immutable
objects in Lisp (numbers are the only case I can think of off the top
of my head, and there are special exceptions in the definition of EQ
to allow the system to copy numbers secretly anyway).  I'm
deliberately not counting any object with components, since even if it
is itself immutable, you have to know all its components are too.
Obviously you could have objects which were immutable *in an
application*, but that's application-dependent.

> Conceptually, you can implement deep copy by simply copying the
> complete object graph of the system and returning a reference to the
> copy of the object referenced by the original reference.  This is
> guaranteed to terminate and will have the semantics I describe.

Yes, this I think is what I called `graph copy' in my paper.  But I
think it's painful because you need an occurs check, unless you can
rely on either being able to smash the object you are copying (as a
copying GC would) or you can do a very efficient occurs check (for
instance if you can get at the address of objects and rely on it not
changing during the copy -- neither of which is true for Lisp -- then
you can use a bitmap to check if you've seen the object before which
will be 1/32nd or 1/64th the size of the address space you are
interested in -- this may be prohibitive if the graph is scattered
through the address space of course).

Perhaps there is some trick I don't know to doing this.

> It is possible to define general deep structural equality predicates and
> many languages do.  They usually don't map onto semantic equality,
> but they are still quite useful, and generally quite
> conservative (e.g., mutable structures are not equal, regardless of
> content).

Right, so they're useless for our purposes if everything is mutable...


> In general, I think there are consistent definitions of
> "deep copy" and "deep structural equality" possible in Lisp,
> just like they are in most other languages.  

The whole point is that there are not *useful* definitions of these
things -- ((a . b) (c . d)) is equal to ((c . d) (a . b) (c . e)) as
an alist, but it would be hard to define a structural equality
predicate which gave you this, because it has to know that you are
comparing these things *as an alist*.

I don't think we have any actual substantive difference on any of
these issues in fact -- although I may have misunderstood you. I'm
just trying to draw the conclusion that typically copying is extremely
application-dependent and that the language cannot provide copy or
equality operation which are useful in more than very restricted
applications, and Lisp has done the right thing in not doing this.
The implication then is that the approach Lisp should take is to
provide tools which let you write copiers and equality tests, such as
more MOP stuff.

--tim
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164632179269337@naggum.no>
* ·······@my-deja.com
| Unlike equality, where it matters if you compare too much, for the
| semantics of a deep copy, it doesn't matter if you copy too much--it will
| simply be inefficient.

  when object identity matters, copying too much is destroying information.
  such destruction can lead to very serious errors that are impossible to
  trace after the fact.  if you don't get it right, you're hosed.  if you
  don't even recognize that you can get this wrong, you're hosed a priori.
  such is the tragic case for that hack we've been trying to teach there's
  more to life than his C++ wonderworld.

  (do we really _need_ to educate people at this level in this newsgroup?)

#:Erik
From: Tom Breton
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m3ln2h97js.fsf@world.std.com>
·······@my-deja.com writes:

> In article <·············@synquiry.com>,
>   Jon S Anthony <···@synquiry.com> wrote:
> > Any such constraints are
> > _context_ specific, i.e., specific to the problem space, the various
> > representations that you have chosen to to encode it, and what those
> > representations _mean in the given context_.  It should be completely
> > clear that no general solution this is _possible_ no matter what set
> > of "primitive" representations you are willing to restrict yourself
> > to.
> 
> Well, it depends on what you mean by "deep copy".  The obvious
> meaning is that after a deep copy, you have two references
> that behave identically, but updates through one won't affect
> the behavior of the other (that idea can be formalized).

And that no longer match under shallow equality.


(defconstant my-obj (cons 1 2) "" )
(defconstant alist-0 (list (cons my-obj "its value")) "" )
(defconstant alist-1 (copy-tree alist-0) "" )

(assoc my-obj alist-0 :test #'eq)

(assoc my-obj alist-1 :test #'eq)



> > Of course you can copy
> > _any_ datastructures (and vastly simpler, more easily correct, and
> > cleaner in CL than you could even dream of doing in your wildest
> > fantasies in C++), but that's the _easy_ part.
> 
> No, in fact, some very common data structures in CommonLisp
> cannot be copied because they are opaque, among them closures
> and streams.

Good point.

> > Knowing which parts to
> > copy, when to copy, and how to copy, is the important part and the
> > part which is context specific and thus impossible to generalize in
> > the sense you seem to want.
> 
> Unlike equality, where it matters if you compare too much,
> for the semantics of a deep copy, it doesn't matter if you
> copy too much--it will simply be inefficient.

It also matters for shallow equality.


-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
From: Joerg-Cyril Hoehle
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <qkpog7c6aa5.fsf@tzd.dont.telekom.spam.de.me>
Hi,

original message (for reference):

Courageous <········@san.rr.com> writes:
> I have a CLOS object which may contain an arbitrary graph of
> other objects. This graph may be cyclic. I'm looking for an
> easy way to deep copy the object. I've been told that
> generic deep copy might be implementing by writing the
> object to a stream, and then reading back from that stream.
> Is this the best way of doing it? Is there another way?
> 
> 
> Thank you,
> Joe Kraska
> San Diego
> CA

Later:
> A tip for some of you folks: one of the keys to successful
> communication is not to assume that the other person is wrong,
> but rather to figure out what they're right *for*.

I believe there's also tips and netiquette about reading the FAQ and
the newsgroup for some time. Maybe you would have come across a
reference to Kent M. Pitman article
http://world.std.com/~pitman/PS/EQUAL.html about why there can't be an
all general copy, so you'd have known not to ask the question - but
maybe there aren't bad questions, just bad answers.

I sincerely hope that by now, you read both this and Tim Bradshaw's
article at http://www.cley.com/articles/one-step-beyond.pdf

Also, it was an extremely bad move in your second posting to talk
about c++, especially about deep copying. And later about databases,
since there are some strong opinions here about "the worse is better",
90% working solutions, unfinished APIs and the like.

Later:
> pointing out that if an approach works in one language,
> there ought to be a way, no matter how labyrinthine, to
> achieve it in another.

Here again, you aren't going to make friends here, since the way you
phrase it people will believe you implicitly said that the language
requiring labyrinthine or byzanthine solutions would be Lisp, whereas
it's shared opinion here that it's just the other way round.

I believe you weren't specific enough about your needs, trying to be
too abstract. But with all that was pointed at you by now
(esp. Bradshaw) , I also believe you should now be able to write a
one-page deep graph copy that'll fit your application (more precisely
the specific restrictions on data that your application
manipulates). It seems to me you need at least some hashtable for
detection of redundancy and some declarative interface (not
necessarily MOP or even CLOS) to tell how specific limited objects and
their slots must be copied.

Regards
	Jorg Hohle
Telekom Research Center -- SW-Reliability
From: Rob Warnock
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8d8e2b$17i6$1@fido.engr.sgi.com>
Joerg-Cyril Hoehle <············@tzd.dont.telekom.spam.de.me> wrote:
+---------------
| Kent M. Pitman article http://world.std.com/~pitman/PS/EQUAL.html
| about why there can't be an all general copy...
| I sincerely hope that by now, you read both this and Tim Bradshaw's
| article at http://www.cley.com/articles/one-step-beyond.pdf
+---------------

One of the examples in Tim's paper was very telling -- a "queue" object
which contains pointers to *shared* sub-structure. If one had *any*
lingering doubts about the impossibility of a "universal" or "generic"
copy doing the right thing, that example would surely blow them away.

Objects may have *application*-defined internal consistency invariants
which are destroyed by copying, and a general copy operator *can't* know
(in general) how to preserve (or at least, restore) those invariants
through the copying process.


-Rob

-----
Rob Warnock, 41L-955		····@sgi.com
Applied Networking		http://reality.sgi.com/rpw3/
Silicon Graphics, Inc.		Phone: 650-933-1673
1600 Amphitheatre Pkwy.		PP-ASEL-IA
Mountain View, CA  94043
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F7C9D1.EB9DC92D@san.rr.com>
> I believe you weren't specific enough about your needs, trying to be
> too abstract.

True. However, it's funny. At my place of work, I'm the one all
the newbies come to for answers, because I understand that sometimes
the question is wrong, and instead attempt to answer their question
from the point of view of helping them achieve the solution to
the problem they are facing. I also understand that they are
beginners, and so I take special care to guide them through their
learning process. There's more than one way of looking at things,
if you get my drift.

"Can't" isn't in my vocabularly.

> But with all that was pointed at you by now
> (esp. Bradshaw) , I also believe you should now be able to write a
> one-page deep graph copy that'll fit your application (more precisely
> the specific restrictions on data that your application
> manipulates). It seems to me you need at least some hashtable for
> detection of redundancy and some declarative interface (not
> necessarily MOP or even CLOS) to tell how specific limited objects and
> their slots must be copied.

As it so happens, I already happen to have some externalization
software I wrote to handle translation of graphs of objects that
don't have any internal references. My only reason for asking
the question at all was that I was hoping there was some built
in feature in lisp that would attempt to deep copy objects
irrespective of the obvious errors that this could introduce.

No big deal, though.

More rhetorically, I wonder if the people over at Franz will
be "morons" if they attempt to implement the Objects By
Value section of the CORBA standard in their ORBLink product?






C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164777262564002@naggum.no>
* Courageous <········@san.rr.com>
| However, it's funny. At my place of work, I'm the one all the newbies
| come to for answers, because I understand ...

  I'm sure you think you're the hero of your work-place, but it doesn't
  help just to _tell_ people when you have done so much damage to your
  public impression as you have, and as a line of self-defense, it's so
  pathetic it stinks.  _anyone_ could write a self-serving self-appraisal.
  that's why people _don't_ write such personal defenses on the Net -- it's
  self-defeating and on top of it, it's embarrassing when those "newbies"
  who came to you for answers ask you something you don't know and search
  for the answer on the Net, only to find that you don't have a clue in
  some very important areas and are incredibly self-defensive and personal
  about it.  to really top it off, you haven't understood _any_ of the many
  very good explanations you have received to your question.  such arrogant
  ignorance is a very questionable quality in an employee who doles out
  answers to helpless "newbies" in an organization.  so you should start to
  worry about yourself, and much less about others: if you can't take care
  of yourself, you certainly are in no position to give advice to others.

| More rhetorically, I wonder if the people over at Franz will be "morons"
| if they attempt to implement the Objects By Value section of the CORBA
| standard in their ORBLink product?

  why do you want to hurt yourself so much?  you didn't have to _prove_
  that you still have not understood the difference between implementing a
  carefully constrained specification of a protocol and _general_ deep
  copier, did you?  normal people don't insist on making the same mistake
  over and over just because they don't like being called morons when they
  do and continue with it until they are no longer called morons (it works
  the other way around, in case you wonder).  the people over at Franz have
  understood this difference long ago (like at _least_ 15 years ago), and
  are in no danger at all of being called morons.  and in case you wonder
  about more things, smart people who don't defend themselves can disagree
  violently without even the hint of a danger of getting personal, so even
  if implementing CORBA _were_ a really moronic thing to do, that itself
  doesn't mean someone who does it is a moron.  it's the getting _personal_
  that is the first hint of someone being a moron.  you have never quit
  giving that hint, on the contrary: you have reinforced it over and over,
  and this is a pretty strong argument that it is a correct assessment of
  your mental acuity and childish, retarded stubbornness.  you can change
  this by snapping out of your "personal" mental state and realize that
  your ego is not under attack from anyone other than your own imagination.
  most everyone here will utter a sigh of relief if you get the idea, and
  nobody will ever "remind" you of your past mistake when you have learned
  -- that's what makes possibly heated technical discussions _impersonal_
  to people who aren't morons.

  I'm _expecting_ another knee-jerk moronic response.  surprise me.  (of
  course, now that I said that, your childish stubbornness prohibits you
  from showing any trace of adult, smart behavior, but try, anyway.)

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F83EB8.A21C0EB7@san.rr.com>
>   are in no danger at all of being called morons.  and in case you wonder
>   about more things, smart people who don't defend themselves can disagree
>   violently without even the hint of a danger of getting personal, 

You're complaining about *me* making matters personal.
Oh, that's rich. Between the two of us, who's posting
page-long diatribes sometimes filled with profanity?

>   you can change
>   this by snapping out of your "personal" mental state and realize that
>   your ego is not under attack from anyone other than your own imagination.

Says he who fills up pages with insults & profanity...




C/
From: Coby Beck
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <rhdK4.559$9B.78318@news.bc.tac.net>
Courageous <········@san.rr.com> wrote in message
······················@san.rr.com...
>
> >   are in no danger at all of being called morons.  and in case you
wonder
> >   about more things, smart people who don't defend themselves can
disagree
> >   violently without even the hint of a danger of getting personal,
>
> You're complaining about *me* making matters personal.
> Oh, that's rich. Between the two of us, who's posting
> page-long diatribes sometimes filled with profanity?
>
> >   you can change
> >   this by snapping out of your "personal" mental state and realize that
> >   your ego is not under attack from anyone other than your own
imagination.
>
> Says he who fills up pages with insults & profanity...

The technical part of this thread was quite interesting, but it has really
degenerated.  You both should give it a rest.  (and i really doubt Eric will
let you have the last word.  You can only "win" but quitting).

Thank you for bringing up the topic, by the way.

Coby
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164898799599994@naggum.no>
* Courageous <········@san.rr.com>
| You're complaining about *me* making matters personal.
| Oh, that's rich. Between the two of us, who's posting
| page-long diatribes sometimes filled with profanity?

  well, here's the clue: _you_ take it personally.  _you_ cannot even
  imagine that it _isn't_ personal, but that's _your_ choice.  you don't
  have to make this choice.  so make another choice if you aren't satisfied
  with it.  if you _are_ satisfied with your choice, and still complain,
  you do in fact merit the personal insults and the label "moron" and much,
  much more and much, much worse assessments of your mental state.

| Says he who fills up pages with insults & profanity...

  obviously, _you_ have a personal problem with what _you_ think is insults
  and profanity because your wiener brain makes you see _nothing_ else if
  this trigger is fired within you.  this is not somebody else's problem.
  so just _deal_ with it if you don't like its consequences for you.

  I take it that you are happy with your choice to take negative comments
  personally and as destructively for yourself as possible, and so want
  others to stop making negative comments that you could take personally.
  face that facts, moron: that's not going to happen when you post as much
  evidence of stupidity as you do.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FA576C.46C56ECA@san.rr.com>
> | Says he who fills up pages with insults & profanity...
> 
>   obviously, _you_ have a personal problem with what _you_ think is insults
>   and profanity because your wiener brain makes you see _nothing_ else if...

You mean like when you say things like "fucking retarded" and
moronic and ah "wiener brain", and so on?

*mocking laughter*



C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164940726622243@naggum.no>
* Courageous <········@san.rr.com>
| You mean like when you say things like "fucking retarded" and
| moronic and ah "wiener brain", and so on?

  for once a personal comment: I pity you.  such insecurity as you suffer
  from should have been protected from public exposure and treated with
  love and professional care.  a clue: you won't get that here.

  here's a another clue: you care what I think about you, but I don't think
  about you -- only your moronic actions bother me.  how could I possibly
  respond to anything else?  oh, forget that, I'm asking the one person
  here who is unable to distinguish the actions from the person acting.
  
#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FB3A73.E3F7F3FB@san.rr.com>
> | You mean like when you say things like "fucking retarded" and
> | moronic and ah "wiener brain", and so on?
> 
>   I pity you... such insecurity as you suffer from... 
>   ....your moronic...

More insults spew forth like bile from Erik Naggum's
mouth. You just can't stop, can you, Erik?




C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3164984947664175@naggum.no>
* Courageous <········@san.rr.com>
| You just can't stop, can you, Erik?

  interestingly, this started with a general deep copier and the first
  thing I told you about was detection of circularities.  I detect with
  some satisfaction that you walk around in very small circles and ask the
  same moronic questions over and over.  when will you realize it?

  but now is the time we will learn whether you stop or prove again that
  you are obsessing like the other morons who have visited this newsgroup.

  since day 1, I have told you this: try some non-moronic behavior if you
  want people to think differently about you.  this is obviously impossible
  for you to fathom, and instead keep acting the moron because you want
  others to stop calling you a moron before you change your moronic ways.

  but sure, I can stop _calling_ you a moron, but that won't change you.
  after all is said and done, I have said "moron", and you _are_ a moron.
  is this really going to help you, you pitiful "Courageous" moron?

  now, repeat another question for you own amusement.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FBB3BE.D8755C6@san.rr.com>
> moronic... obsessing... moron... try some non-moronic... moron...
> moron.... moronic... moron, ... "moron" ... moron.

This isn't going to compensate for it, you know.



C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165044217260009@naggum.no>
* Courageous <········@san.rr.com>
| This isn't going to compensate for it, you know.

  I said I was going to stop calling you a "moron".  YOUR WISH HAS BEEN
  GRANTED!  so why do you continue with the same behavior that caused the
  label you do not want attached yourself?  we have already established
  that the best you think you can do in a debate is to count words, for
  instance.  do as you were told to in the very beginning: try something
  better, or face the consequences: people will _know_ you can't do better.

  this is not going to stop until you start to behave smart.  this may take
  a while, but the only goal I have with someone like you in this newsgroup
  is to make them stop acting in certain ways.  if you are impervious to
  any sort of outside signal to improve your behavior, it doesn't help what
  I say or not -- it may in fact hurt you that I don't state my conclusion.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FC9461.2769CBC5@san.rr.com>
>  the best you think you can do in a debate...

You think this is a debate?

>   this is not going to stop until...

When you finally do look inward, you might realize that
one does not issue an ultimatum in order to cease abuse.
One simply ceases.




C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165123380936230@naggum.no>
* Courageous <········@san.rr.com>
| One simply ceases.

  I'm waiting for you to stop behaving in a way that needs correction.

  as you have so succinctly stated, "you can't stop, can you, Joe Kraska"?
  I think we have all the proof we need.  it's up to you.  in fact, it has
  been up to you for a very long time, but your insistence on proving your
  case has been a barrier to progress.  I draw my conclusions, but I have
  promised to stop stating them, so won't.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FDE838.313FD9CE@san.rr.com>
>   I'm waiting for you to stop behaving in a way that needs correction.

One of the hallmark signs of an abuser is blaming the victim.



C/
From: Rahul Jain
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8dlkt7$2q3$1@joe.rice.edu>
In article <·················@san.rr.com> posted on Wednesday,
April 19, 2000 12:06 PM, Courageous <········@san.rr.com> wrote:
> 
>>   I'm waiting for you to stop behaving in a way that needs correction.
> 
> One of the hallmark signs of an abuser is blaming the victim.

So who's blaming whom here?
STOP IT ALREADY!
If you simply accepted that the perceptions you got from C++'s
"auto-copy" were completely wrong, NONE of this nonsense would
have happened. In fact, the whole issue of whether deep copy is
possible has NOTHING to do with C++, Smalltalk, or Lisp. I
understood the problem when the only languages I knew were BASIC,
C, and HyperTalk. So save yourself what little pride you might
have left and move on. We all make mistakes, it's the smart ones
who can learn from them and benefit from the knowledge they've
gained.

-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Coby Beck
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <pOxL4.1399$9B.173125@news.bc.tac.net>
Rahul Jain <·····@rice.edu> wrote in message
·················@joe.rice.edu...
> In article <·················@san.rr.com> posted on Wednesday,
> April 19, 2000 12:06 PM, Courageous <········@san.rr.com> wrote:
> >
> >>   I'm waiting for you to stop behaving in a way that needs correction.
> >
> > One of the hallmark signs of an abuser is blaming the victim.
>
> So who's blaming whom here?
> STOP IT ALREADY!
> If you simply accepted that the perceptions you got from C++'s
> "auto-copy" were completely wrong, NONE of this nonsense would
> have happened. In fact, the whole issue of whether deep copy is
> possible has NOTHING to do with C++, Smalltalk, or Lisp. I
> understood the problem when the only languages I knew were BASIC,
> C, and HyperTalk. So save yourself what little pride you might
> have left and move on. We all make mistakes, it's the smart ones
> who can learn from them and benefit from the knowledge they've
> gained.
>

I think that part of the thread ended quite some time ago.

If people would act in a mature and civil manner, none of this would happen.

Coby
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FE5C10.43021B38@san.rr.com>
> If you simply accepted that the perceptions you got from C++'s
> "auto-copy" were completely wrong, NONE of this nonsense would
> have happened.

C++ doesn't have an auto copy that I know of.

I've never thought that such a deep copier would work in all
circumstances, only that it's useful to use it when you know
it will work.

A general purpose deep copier is useful for those cases in
which you deep copy will function properly. These number of
cases are, in fact, quite large.

I never asked for advice on whether or not such a deep copier
would work in all cases, and don't care to hear any. I'm sorry
that bothers you, but all I wanted to know is if there was
some built in feature that I could make use of. Hearing
the rationale for why it doesn't exist as a built in feature
is interesting, but not relevant to what I'm trying to
achieve in my software project.

If this last bothers you, well... tough.



C/
From: Rahul Jain
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8dlqo6$9ac$1@joe.rice.edu>
In article <·················@san.rr.com> posted on Wednesday,
April 19, 2000  8:20 PM, Courageous <········@san.rr.com> wrote:
> 
>> If you simply accepted that the perceptions you got from C++'s
>> "auto-copy" were completely wrong, NONE of this nonsense would
>> have happened.
> 
> C++ doesn't have an auto copy that I know of.

It automatically makes some sort of copy constructor that I've
never dared to use, since I know that it's most likely wrong.

> I've never thought that such a deep copier would work in all
> circumstances, only that it's useful to use it when you know
> it will work.
>
> A general purpose deep copier is useful for those cases in
> which you deep copy will function properly. These number of
> cases are, in fact, quite large.

What exactly would a "general purpose" deep copier DO? Where would
it stop?

> I never asked for advice on whether or not such a deep copier
> would work in all cases, and don't care to hear any. I'm sorry
> that bothers you, but all I wanted to know is if there was
> some built in feature that I could make use of. Hearing
> the rationale for why it doesn't exist as a built in feature
> is interesting, but not relevant to what I'm trying to
> achieve in my software project.

Languages don't provide situation-specific tools. They are the tools
you USE to make situation-specifc tools from generic ones. If reality
isn't relevant to your project, I suggest you find something to do
that's somewhat practical. In theory, if we had perfect AI, we could
just sit around and let computers take over the planet. It's not
something I'd plan a project to depend on, however.

> If this last bothers you, well... tough.

No, it's just stupid and wasteful. I suggest you stop and get on with
your life.

-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FE7520.F9B91420@san.rr.com>
> > C++ doesn't have an auto copy that I know of.
> 
> It automatically makes some sort of copy constructor that I've
> never dared to use, since I know that it's most likely wrong.

It's shallow copy. If you want deep copy, you have to
go to a code generator which implements what you want
in terms of specific primitives designed so that they
even *can* be deep copied. Which isn't to say that some-
one using said system couldn't shoot themselves in the
foot. Because they could, of course.

> > I've never thought that such a deep copier would work in all
> > circumstances, only that it's useful to use it when you know
> > it will work.
> >
> > A general purpose deep copier is useful for those cases in
> > which you deep copy will function properly. These number of
> > cases are, in fact, quite large.
> 
> What exactly would a "general purpose" deep copier DO?

In the wrong situations, the wrong thing, no doubt.

> > I never asked for advice on whether or not such a deep copier
> > would work in all cases...

> Languages don't provide situation-specific tools.

They do sometimes, however, provide general purpose tools which
are only useful in specific situations.

> They are the tools
> you USE to make situation-specifc tools from generic ones. If reality
> isn't relevant to your project, I suggest you find something to do
> that's somewhat practical.

Well, I already have.



C/
From: David Thornley
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <PF0M4.431$wJ1.14926@ptah.visi.com>
In article <············@joe.rice.edu>, Rahul Jain  <·····@rice.edu> wrote:
>In article <·················@san.rr.com> posted on Wednesday,
>April 19, 2000  8:20 PM, Courageous <········@san.rr.com> wrote:
>> 
>>> If you simply accepted that the perceptions you got from C++'s
>>> "auto-copy" were completely wrong, NONE of this nonsense would
>> 
>> C++ doesn't have an auto copy that I know of.
>
>It automatically makes some sort of copy constructor that I've
>never dared to use, since I know that it's most likely wrong.
>
It does a member-by-member copy.  How deep that is depends on the
copy constructors of the members; if the members are built-in
data types, it does the equivalent of a bitwise copy.  This
can be overridden, although it means implementing all the copying
that would otherwise be done, not just some of it; it can be
explicitly prevented from happening.

It's pretty useful, and an excellent hiding place for a couple of
classes of bugs.

>> A general purpose deep copier is useful for those cases in
>> which you deep copy will function properly. These number of
>> cases are, in fact, quite large.
>
>What exactly would a "general purpose" deep copier DO? Where would
>it stop?
>
Hmmm.  Actually, CL has at least one version of a deep copier:
copy-tree.  It only descends conses, which is just what you want
in enough cases to be useful.

I think the lack of "deep copiers" is similar to the plethora of
equality operators.  There's a whole lot of variation on what
you may want in both cases, and the approach was to implement lots
of different equality operators and few deep copiers.

If you know what sort of copy you want to do, it's usually fairly
easy to write methods to do it.  That's my experience, anyway.

--
David H. Thornley                        | If you want my opinion, ask.
·····@thornley.net                       | If you don't, flee.
http://www.thornley.net/~thornley/david/ | O-
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FE5FEE.C6505244@san.rr.com>
> > One of the hallmark signs of an abuser is blaming the victim.
> 
> So who's blaming whom here?

Do you feel I'm being "abusive" to Erik? Do tell.



C/
From: Rahul Jain
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8dlpno$83e$1@joe.rice.edu>
In article <·················@san.rr.com> posted on Wednesday,
April 19, 2000  8:37 PM, Courageous <········@san.rr.com> wrote:
> 
>> > One of the hallmark signs of an abuser is blaming the victim.
>> 
>> So who's blaming whom here?
> 
> Do you feel I'm being "abusive" to Erik? Do tell.

No, I'm just pointing out that you're BOTH participaring in the
argument, and that you BOTH should stop. Erik is a very smart
guy, and if you get over his vehmence and try to UNDERSTAND
what he's saying, you'll end up GAINING from communicating with
him, instead of LOSING, like you are now.

-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Coby Beck
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <dTxL4.1401$9B.173068@news.bc.tac.net>
Rahul Jain <·····@rice.edu> wrote in message
·················@joe.rice.edu...
> In article <·················@san.rr.com> posted on Wednesday,
> April 19, 2000  8:37 PM, Courageous <········@san.rr.com> wrote:
> >
> >> > One of the hallmark signs of an abuser is blaming the victim.
> >>
> >> So who's blaming whom here?
> >
> > Do you feel I'm being "abusive" to Erik? Do tell.
>
> No, I'm just pointing out that you're BOTH participaring in the
> argument, and that you BOTH should stop.

 hear hear.

> Erik is a very smart
> guy, and if you get over his vehmence and try to UNDERSTAND
> what he's saying, you'll end up GAINING from communicating with
> him, instead of LOSING, like you are now.
>
Erik's useful contribution to this thread ended ages ago.  And it is a sad
fact that his intelligent technical information is so often drowned in a
soup of childish abuse.

Coby
From: Rahul Jain
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8dlqvr$9bu$1@joe.rice.edu>
In article <·················@san.rr.com> posted on Wednesday,
April 19, 2000  8:37 PM, Courageous <········@san.rr.com> wrote:
> 
>> > One of the hallmark signs of an abuser is blaming the victim.
>> 
>> So who's blaming whom here?
> 
> Do you feel I'm being "abusive" to Erik? Do tell.

No, you're the one who blamed Erik for being an abuser. Ironically,
that makes him the victim and you the abuser by your OWN twisted
logic.

You're ARE, however being abusive to the concept I have in my brain
that people are smart. But don't feel you're alone, there are plenty
of others who contribute to that abuse, too. I just figured that I
wouldn't see too much of it here.

Oh well. The internet is free and open, and I'll have to deal with it.

-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FE782F.3BAC4B6F@san.rr.com>
> No, you're the one who blamed Erik for being an abuser. Ironically,
> that makes him the victim and you the abuser by your OWN twisted
> logic.

Truly? So, by my "twisted logic," if I refer to what's written
below as "abuse," I am an abuser? Please go on...

... you're a village idiot who.. behave like a fucking moron...
... with a moronic nick... you walk around in very small circles...
... like the other morons...  try some non-moronic behavior 
... obviously impossible for you to fathom... keep acting the moron
... your moronic ways... I have said "moron", and you _are_ a moron
....you can't run your own miserable life... you pitiful "Courageous"
....moron

Oh, and let's not forget my favorite:

... who deserves to be hurt.

Very revealing that one, especially.

You say I am an abuser? Say again?



C/
From: Rahul Jain
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8dm96t$nue$1@joe.rice.edu>
In article <·················@san.rr.com> posted on Wednesday,
April 19, 2000 10:20 PM, Courageous <········@san.rr.com> wrote:

> You say I am an abuser? Say again?

No, YOU said that you are an abuser, since I assume that your rules
for others apply to yourself. That may be wrong of course.

Anyway, I'm not going to be dragged into your nonsense like Erik
and so many others were.

EOT

-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FEAA7F.F38881B7@san.rr.com>
> > You say I am an abuser? Say again?
> 
> No, YOU said that you are an abuser, since I assume that your rules
> for others apply to yourself. That may be wrong of course.

So are you saying then, that Erik is a victim?



C/
From: Pierre R. Mai
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <87itxdduqu.fsf@orion.dent.isdn.cs.tu-berlin.de>
Courageous <········@san.rr.com> writes:

> > > You say I am an abuser? Say again?
> > 
> > No, YOU said that you are an abuser, since I assume that your rules
> > for others apply to yourself. That may be wrong of course.
> 
> So are you saying then, that Erik is a victim?

It would help to stop thinking in terms of "abuser" and "victim",
since todays "victim" might be tomorrows or yesterdays "abuser", or
might indeed be "victim" and "abuser" at the same time, towards
different or even the same person(s).

BTW, I believe that this might be yet another facet of Erik's advice
of focussing on deeds and not on people.

Regs, Pierre.

-- 
Pierre Mai <····@acm.org>         PGP and GPG keys at your nearest Keyserver
  "One smaller motivation which, in part, stems from altruism is Microsoft-
   bashing." [Microsoft memo, see http://www.opensource.org/halloween1.html]
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165321443490104@naggum.no>
* Courageous <········@san.rr.com>
| Oh, and let's not forget my favorite:
| 
| ... who deserves to be hurt.
| 
| Very revealing that one, especially.
| 
| You say I am an abuser? Say again?

  since this one is so important to you and so important not to _forget_,
  could you be bothered to actually locate it among what I have said to
  you?  a message-ID will be very helpful.  a URL at deja.com will work.

  if you find that I have NOT actually said that, you will admit to be a
  moron, a liar, and a disgusting creep who is out to misrepresent others
  in such a way as to make others look bad when in fact you are a piece of
  reeking, self-victimizing crap yourself.

  if you do find that I HAVE actually said that, I'll admit to being a
  psychopathic abuser who has actually been out to destroy your sterling
  reputation as a genius within BBN for no good reason.

  do we have a deal, Joe "Courageous" Kraska?

  I believe "very revealing" are extremely interesting words from our
  supposed "victim".  the psychology of most victims is that the world
  consists of abusers and victims, and if you aren't a victim, you are an
  abuser.  the _fact_, however, is that every abuser is a victim and every
  victim is an abuser.  the question is towards and with whom they have
  their respective roles.  those who do not subscribe to this set of roles,
  are actually neither abusers _nor_ victims.

  so, what will your search _reveal_, Joe "Victim" Kraska?

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3900DE87.DDA7303F@san.rr.com>
>   so, what will your search _reveal_, Joe "Victim" Kraska?
> #:Erik

It revealed this, Erik Naggum. I took the liberty of capitalizing
your words for you to help out your deteriorating memory, which
has obviously been corrupted by the bile you spew.

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

Path: 
                  
typhoon1.san.rr.com!newsf2.san.rr.com!cyclone-west.rr.com!news.rr.com|news-west.rr.com!cyclone-east.rr.com!news.rr.com!news-east.rr.com!europa.netcrusader.net!194.176.220.129!newsfeed.icl.net!newsfeed.icl.net!news.algonet.se!algonet!uninett.no!Norway.EU.net!127.0.0.1!nobody
              From: 
                   Erik Naggum <····@naggum.no>
        Newsgroups: 
                   comp.lang.lisp
            Subject: 
                   Re: Deep copy in lisp: how?
              Date: 
                   13 Apr 2000 08:24:19 +0000
       Organization: 
                   Naggum Software; vox: +47 8800 8879; fax: +47 8800 8601; http://www.naggum.no
             Lines: 
                   16
       Message-ID: 
                   <················@naggum.no>
        References: 
                   <·················@san.rr.com> <·············@pobox.com>
<·················@san.rr.com> <·············@synquiry.com> <·················@san.rr.com>
<················@naggum.no> <·················@san.rr.com>
                   <················@naggum.no> <·················@san.rr.com>
                   gate.dn.nhst.no
      Mime-Version: 
                   1.0
      Content-Type: 
                   text/plain; charset=us-ascii
           X-Trace: 
                   oslo-nntp.eunet.no 955614450 3982 195.0.192.66 (13 Apr 2000 08:27:30 GMT)
    X-Complaints-To: 
                   ··········@eunet.no
 NNTP-Posting-Date: 
                   13 Apr 2000 08:27:30 GMT
      mail-copies-to: 
                   never
        User-Agent: 
                   Gnus/5.0803 (Gnus v5.8.3) Emacs/20.5
              Xref: 
                   newsf2.san.rr.com comp.lang.lisp:30100




* Courageous <········@san.rr.com>
| You just can't stop, can you Erik?

  if I can stop you, that's good enough for me, because I don't start the
  kind of insane drivel you seem to enjoy starting.  but have you asked
  yourself your own question, lately?  I don't appreciate your line of
  psychologizing crap, but now that you get it back in your face, I see
  that you are a lot more sensitive to the matter than I am, which is good,
  because you may realize that if you plan to win any games that way, you
  won't do it here, and you're clearly the kind of moron who NEEDS TO
  BE HURT to stop to think.  will _that_ make you stick to your issues,
  whatever they may be, or will you smear more of your personality all over
  the place with yet more moronic psychologizing and irrelevant personal
  attacks?  it's your call, "Courageous".

#:Erik
From: Coby Beck
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <9a8M4.1770$9B.206267@news.bc.tac.net>
Courageous <········@san.rr.com> wrote in message
······················@san.rr.com...
>
> >   so, what will your search _reveal_, Joe "Victim" Kraska?
> > #:Erik
>
> It revealed this, Erik Naggum. I took the liberty of capitalizing
> your words for you to help out your deteriorating memory, which
> has obviously been corrupted by the bile you spew.
>

Now this is why you should have quit a week ago.  Erik said "needs to be
hurt" you misquoted him saying "deserves to be hurt".  Unfortunately this is
a significant distinction.

So now Erik, in his mind, has defeated you.  Everything he has spewed is now
validated (in his mind).  You have fed him what he craves and we will all
suffer the sight of yet more intense and vicious diatribes.  And those
stretching for reasons to excuse him have what they need...

Coby
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <39011157.DDBFCE64@san.rr.com>
> > >   so, what will your search _reveal_, Joe "Victim" Kraska?
> > > #:Erik
> >
> > It revealed this, Erik Naggum. I took the liberty of capitalizing
> > your words for you to help out your deteriorating memory, which
> > has obviously been corrupted by the bile you spew.
> >
> 
> Now this is why you should have quit a week ago.  Erik said "needs to be
> hurt" you misquoted him saying "deserves to be hurt".  Unfortunately this is
> a significant distinction.

Is there any semantic distinction whatsoever in the sentiment?
Not to me. To wit: "She deserves to be raped." "She needs to be
raped." Nope, not a difference at all.

People do not escape vile sentiments over small differences in
wording. Sorry.

C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165384323882383@naggum.no>
* Courageous <········@san.rr.com>
| People do not escape vile sentiments over small differences in
| wording. Sorry.

  indeed, you feel free to _introduce_ vile sentiments by disregarding the
  actual wording in other people's writing, preferring your own rewrites.

  your attributed wording: "you deserve to be hurt".

  my actual wording: "you're clearly the kind of moron who needs to be hurt
  to stop to think".

  to Joe Kraska, this is a "small difference in wording".

  I'll repeat this in words this retarded creep may understand: Joe Kraska
  is clearly the kind of moron who needs to be _punished_ to stop to think
  about his actions.

  for something that was so important to him, it was his favorite that he
  would not forget, one would have thought he had the decency to get it
  right, but we know all that needs to be known about Joe Kraska, now -- he
  feels entirely free to attribute malice to other people with no regard
  whatsoever to whether it exists outside his own mind.  we know what his
  mind is like, now: it's boiling with hatred for people who prove to him
  that he is a moron, and yet he insists on proving it over and over.

  he does, however, _deserve_ to be hurt, now, for what he does to others
  with blatant disregard for facts, honesty, and justice.  this is what our
  society has decided is the right reaction to people like him: punishment
  for crimes committed, restitution for damages done, etc.  he is indeed an
  abuser, and one who defends his attempted abuse with nothing short of his
  own sick, demented imagination.  he is such a pathetic abuser, however,
  that it reflects only himself, his employer, his family, and his friends,
  if any, and not on those he tries to abuse.

  nothing more needs ever be said about Joe Kraska of BBN.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3901DF32.D49B84F3@san.rr.com>
Erik Naggum wrote:
> 
> * Courageous <········@san.rr.com>
> | People do not escape vile sentiments over small differences in
> | wording. Sorry.
> 
>   indeed, you feel free to _introduce_ vile sentiments by disregarding the
>   actual wording in other people's writing, preferring your own rewrites.

Very well, I'll correct myself:
---------------
... you're a village idiot who.. behave like a fucking moron...
... with a moronic nick... you walk around in very small circles...
... like the other morons...  try some non-moronic behavior 
... obviously impossible for you to fathom... keep acting the moron
... your moronic ways... I have said "moron", and you _are_ a moron
....you can't run your own miserable life... you pitiful "Courageous"
....moron

Oh, and let's not forget my favorite:

... who NEEDS to be hurt.

Very revealing that one, especially.

You say I am an abuser? Say again?
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165414841017864@naggum.no>
* Courageous <········@san.rr.com>
| Oh, and let's not forget my favorite:
| 
| ... who NEEDS to be hurt.
| 
| Very revealing that one, especially.
| 
| You say I am an abuser? Say again?

  others have pointed out that you're the abuser.  I'm gleefully picking up
  on that, of course, as they are in fact right, but you would never listen
  to them if I said it first.  I'm happy you're defensive about it, though.

  incidentally, but mostly for the search engines: the full quote is "you
  are the kind of moron who needs to be hurt to stop to think", Joe Kraska.
  our society punishes destructive morons who have no respect for others.
  if you are so retarded that you _still_ cannot fathom that this is very
  different from your nightmarish imagination of what it is, you're also
  clinically psychotic and probably _unable_ to distinguish reality from
  your sick imagination.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3901FE90.849ED785@san.rr.com>
>   others have pointed out that you're the abuser. 

And yet, looking towards myself, I haven't found that I've
used insults and epithets like these:

... you're a village idiot who.. behave like a fucking moron...
... with a moronic nick... you walk around in very small circles...
... like the other morons...  try some non-moronic behavior 
... obviously impossible for you to fathom... keep acting the moron
... your moronic ways... I have said "moron", and you _are_ a moron
....you can't run your own miserable life... you pitiful "Courageous"
....moron

The part that drives you that finds behavior like what's
written above rewarding is a character flaw that you could
do without.



C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165473473610042@naggum.no>
* Courageous <········@san.rr.com>
| The part that drives you that finds behavior like what's
| written above rewarding is a character flaw that you could
| do without.

  stop attributing your own mental problems to other people.
  such constitutes your abuse of this forum.

#:Erik
From: Coby Beck
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <%QvM4.1928$9B.225564@news.bc.tac.net>
Erik Naggum <····@naggum.no> wrote in message
·····················@naggum.no...
>   incidentally, but mostly for the search engines: the full quote is "you
>   are the kind of moron who needs to be hurt to stop to think", Joe
Kraska.
>   our society punishes destructive morons who have no respect for others.

Sadly, this is not true.  As evidenced by the fact that Erik Naggum, the
author of the most despicable and hateful writing i have ever seen posted to
a public forum, still enjoys the respect and admiration of otherwise
intelligent people.

>   if you are so retarded that you _still_ cannot fathom that this is very
>   different from your nightmarish imagination of what it is, you're also
>   clinically psychotic and probably _unable_ to distinguish reality from
>   your sick imagination.

This latest thread suggests that these words better describe their author
than any of his numerous targets.

Coby
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165473232010087@naggum.no>
* "Coby Beck" <·····@mercury.bc.ca>
| Sadly, this is not true.

  perhaps you confuse respect for people with respect for all their
  actions.  I don't.  it still amazes me that it is possible for some
  people to think in terms of their severely extrapolated conceptions of
  "people" when all they could possibly interact with is their actions,
  reactions, and responses in certain clearly delimited contexts.

#:Erik
From: Kragen Sitaker
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <cYsM4.820$RM6.877765@news-east.usenetserver.com>
In article <················@naggum.no>, Erik Naggum  <····@naggum.no> wrote:
>  are the kind of moron who needs to be hurt to stop to think", Joe Kraska.
>  our society punishes destructive morons who have no respect for others.

I wish.  There would be no spam.

Still, it does punish *some* destructive morons who have no respect for
others --- as well as some destructive intelligent people who have no
respect for others.

You appear to be the latter, although I can't see that you've been
punished yet.
-- 
<······@pobox.com>       Kragen Sitaker     <http://www.pobox.com/~kragen/>
The Internet stock bubble didn't burst on 1999-11-08.  Hurrah!
<URL:http://www.pobox.com/~kragen/bubble.html>
The power didn't go out on 2000-01-01 either.  :)
From: Christopher Browne
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <slrn8g4kqb.67k.cbbrowne@knuth.brownes.org>
Centuries ago, Nostradamus foresaw a time when Kragen Sitaker would say:
>In article <················@naggum.no>, Erik Naggum  <····@naggum.no> wrote:
>>  are the kind of moron who needs to be hurt to stop to think", Joe Kraska.
>>  our society punishes destructive morons who have no respect for others.
>
>I wish.  There would be no spam.
>
>Still, it does punish *some* destructive morons who have no respect for
>others --- as well as some destructive intelligent people who have no
>respect for others.
>
>You appear to be the latter, although I can't see that you've been
>punished yet.

#erik is definitely _unkind_ on occasion.

When he stays with speaking to _actual_ technical issues, he seems
to have tremendous insights to offer, even at those times when he
is basically saying, "Here's what's _true_; you're being a *moron,*
which makes this technical point _no less true_."

To _some_ extent, the abuse may chase off those that are being
morons, and that _may_ be of value to the quality of discussion.
When "morons" get "run out of town," and this is accompanied 
by some discussion that has valuable quality, this is arguably
a good thing.

Unfortunately, sometimes the "moron" may be:
a) Not as moronic as #eric suggests, and
b) Persistent enough to _not_ get run out of town.

That seems to be the case here; "Courageous" is "courageously" standing
up against the abusive comments, to which #erik has been reacting via
_more abusive_ comments.

Which strikes me as a mistake on _both_ sides.

#erik _should_ restrict himself to speaking to the technical issues,
namely that of "How low can you go," when dealing with the depth of
copying objects.

"Courageous" is clearly off-topic, as discussion of #erik's personality
is not appropriate to comp.lang.lisp.
-- 
"I  doubt this language  difference would  confuse anybody  unless you
were providing instructions on the insertion of a caffeine enema."
-- On alt.coffee
········@ntlug.org - - <http://www.hex.net/~cbbrowne/lsf.html>
From: Coby Beck
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8mwM4.1931$9B.225904@news.bc.tac.net>
Christopher Browne <········@knuth.brownes.org> wrote in message
····························@knuth.brownes.org...
> Centuries ago, Nostradamus foresaw a time when Kragen Sitaker would say:
> >In article <················@naggum.no>, Erik Naggum  <····@naggum.no>
wrote:
> >>  are the kind of moron who needs to be hurt to stop to think", Joe
Kraska.
> >>  our society punishes destructive morons who have no respect for
others.
> >
> >I wish.  There would be no spam.
> >
> >Still, it does punish *some* destructive morons who have no respect for
> >others --- as well as some destructive intelligent people who have no
> >respect for others.
> >
> >You appear to be the latter, although I can't see that you've been
> >punished yet.
>
> #erik is definitely _unkind_ on occasion.

This is extreme understatement.  If this man had the courage to behave this
way in person at any meeting, public hearing, debate, question/answer
session or whatever non-virtual type of discussion that is analagous to a
usenet forum, he would be physically removed and perhaps arrested.

*Why* should he be excused here?


>
> When he stays with speaking to _actual_ technical issues, he seems
> to have tremendous insights to offer, even at those times when he
> is basically saying, "Here's what's _true_; you're being a *moron,*
> which makes this technical point _no less true_."
>
> To _some_ extent, the abuse may chase off those that are being
> morons, and that _may_ be of value to the quality of discussion.
> When "morons" get "run out of town," and this is accompanied
> by some discussion that has valuable quality, this is arguably
> a good thing.

This is not a good thing at all.  "Stupid" questions often start productive
threads and *most* "stupid" people learn, and then we see it was not
stupidity but ignorance, _very different_.  Erik has *no* right whatsoever
to decide for me whose posts i can and cannot read by haranguing ordinary
people like they are the scum of the earth until they leave the group and
maybe LISP for good.

I know *personally* many people, young budding programmers, who are
intimidated so much by this "expert" that they stop reading and never post
their questions.  He does the entire lisp community a grave diservice with
this behavior.  I learned lisp in a class of twenty, i'm not saying that he
is the reason there are not twenty new people participating in this group,
but i know what i am talking about.

And furthermore, if no one in the group objects, the impression is the the
whole group supports this attitude.


>
> Unfortunately, sometimes the "moron" may be:
> a) Not as moronic as #eric suggests, and
> b) Persistent enough to _not_ get run out of town.
>
> That seems to be the case here; "Courageous" is "courageously" standing
> up against the abusive comments, to which #erik has been reacting via
> _more abusive_ comments.
>
> Which strikes me as a mistake on _both_ sides.

Agreed.

But really, it may be my mistake to park my car unlocked with the keys in
it, but the jerk who steals it is the only criminal.

>
> #erik _should_ restrict himself to speaking to the technical issues,
> namely that of "How low can you go," when dealing with the depth of
> copying objects.
>
> "Courageous" is clearly off-topic, as discussion of #erik's personality
> is not appropriate to comp.lang.lisp.

His behavior is a *very* big part of this groups culture.  He makes a
spectacle of himself publically.  Therefore it is not inappropriate to
comment on it, in fact it is important to do so.

Coby
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165473415738608@naggum.no>
* "Coby Beck" <·····@mercury.bc.ca>
| This is extreme understatement.  If this man had the courage to behave this
| way in person at any meeting, public hearing, debate, question/answer
| session or whatever non-virtual type of discussion that is analagous to a
| usenet forum, he would be physically removed and perhaps arrested.

  your imagination is playing tricks on you.  confine it accordingly.

| *Why* should he be excused here?

  I'm glad _your_ actions constitute an excuse of my actions.  or don't you
  include yourself in what you speak about?  perhaps it's time you do?

#:Erik
From: Stig Hemmer
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ekvitx8ac68.fsf@epoksy.pvv.ntnu.no>
"Coby Beck" <·····@mercury.bc.ca> writes:
> > #erik is definitely _unkind_ on occasion.
> 
> This is extreme understatement.  If this man had the courage to behave this
> way in person at any meeting, public hearing, debate, question/answer
> session or whatever non-virtual type of discussion that is analagous to a
> usenet forum, he would be physically removed and perhaps arrested.
> 
> *Why* should he be excused here?

He is excused here because we allow it.  Each and every one of us
allows Erik Naggum to continue his abuse.  This includes me.

Have a nice day.

Stig Hemmer,
Jack of a Few Trades.
From: Coby Beck
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <xHLM4.2167$9B.238510@news.bc.tac.net>
Stig Hemmer <····@pvv.ntnu.no> wrote in message
····················@epoksy.pvv.ntnu.no...
> "Coby Beck" <·····@mercury.bc.ca> writes:
> > > #erik is definitely _unkind_ on occasion.
> >
> > This is extreme understatement.  If this man had the courage to behave
this
> > way in person at any meeting, public hearing, debate, question/answer
> > session or whatever non-virtual type of discussion that is analagous to
a
> > usenet forum, he would be physically removed and perhaps arrested.
> >
> > *Why* should he be excused here?
>
> He is excused here because we allow it.  Each and every one of us
> allows Erik Naggum to continue his abuse.  This includes me.
>

This does not answer the question at all and would seem to indicate
approval.  I have stated as clearly as i know how why i think this is not
right.  I have yet to see one coherent justification for supporting Erik's
abuse.

Coby
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165558802528023@naggum.no>
* "Coby Beck" <·····@mercury.bc.ca>
| I have yet to see one coherent justification for supporting Erik's abuse.

  I have yet to see one coherent justification for the abusive behavior I'm
  _criticizing_.  in fact, the reason for your "allowing" me this is that
  none of you would tolerate what I'm criticizing.  that's why you don't
  even _start_ pestering me until you're very safe that whatever nuisance
  I'm trying to get rid of is about to be gotten rid of for good.  just
  admit it: _you_ don't want Joe "Courageous" Kraska here, _either_.  I'm
  doing the dirty work you don't want to do, and when I succeed, you think
  I overdid it, but think back, carefully: why was so much force necessary?

  consider whether you understand the alternatives: do you really _want_ a
  newsgroup full of morons who post false information, idiotic guesswork,
  homework exercises and (stupid or severely misguided) "solutions"?  which
  other newsgroups have I frequented and which have maintained a supremely
  high technical level in the past?  which other newsgroups have seen their
  technical level _raised_ because of what the fools call "abuse" of the
  mindless pestilence that invades USENET from time to time?  which other
  newsgroups have deteriorated shortly after I stopped caring about the
  false information, the blathering idiots, and the destruction of the
  ability to discuss technical matters that only a small portion of the
  audience can follow?  maybe you should start thinking about such things?

  previously, your imagination had run amuck and conjured up the sick image
  of this going on in real life.  I'm amazed that this is possible, because
  it indicates a complete and utter lack of contact with reality:  a person
  such as Joe "Courageous" Kraska is a nuisance in real life, too, and will
  get reprimanded whenever he disturbs a group of people.  go back and read
  the _start_ of this thread.  _who_ would have been thrown out of a public
  meeting?  now, use your imgination _productively_ and think long and hard
  about why it doesn't work to throw some people out of _virtual_ meetings.
  what do those people do?  in brief, to what do I _respond_?  if you don't
  even _see_ that, you have no business criticizing anyone for anything.

  and... taking sides after the war is over is pretty damn stupid.  if you
  want this to end, just shut up about it, and it'll go away.  if you want
  this not to start again, help avoid _recurrences_.  it's just incredibly
  stupid to want something to end in the middle if you don't help it not to
  _start_ and even more stupid if you help fuel the flames.  however, such
  is the moronic blathering of my _critics_.  they have no concept of what
  they want or don't want until _long_ after they could have any _possible_
  effect on anything.  it's the annoyingly mindless "can't we all just get
  along?" all over again.  if we could, Joe Kraska would have gotten the
  idea the first time around.  if we could, anyone who wanted some moron to
  stop needed post only _one_ message to get results.  clearly, this is not
  the case _anywhere_.  so quit dreaming.  deal with reality -- a reality
  that has a certain percentage of morons.  help get rid of them _before_
  they do their damage.  and _don't_ support them afterwards.

  can I trust that you'll help me avoid recurrences of any future invasion
  of morons, Coby?  or can I trust that you will instead stand up for each
  and every blathering moron and proclaim your support at the _earliest_
  possible convenience and then stand by them through _all_ their actions
  and ensuing stupidity so that you can actually _fall_ with the guys you
  support?  you see, Joe "Courageous" Kraska now actually believes that you
  _support_ him and condone _his_ behavior, from his question and first
  moronic article in response to the first rejection to his moronic "Dear
  Erik" message.

  if you will neither help avoid recurrences _or_ support the morons the
  next time around, please be smart and don't jump into the middle of the
  fray only when it looks like the moron could _finally_ go away, because
  the moron will stay _much_ longer when you do that, and thus you help
  _perpetuate_ what you pretend you don't like to see happen.  _think_
  about this.  please.  and if your anger blinds you, shut up, instead.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3904746D.CA4B393B@san.rr.com>
>   previously, your imagination had run amuck and conjured up the sick image
>   of this going on in real life.  I'm amazed that this is possible, because
>   it indicates a complete and utter lack of contact with reality:  a person
>   such as Joe "Courageous" Kraska is a nuisance in real life, too, and will
>   get reprimanded whenever he disturbs a group of people.

I thought you wanted this thread to end, Erik?
(I indeed suggest that everyone reread this
thread from the very beginning).


C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165609117697311@naggum.no>
* Courageous <········@san.rr.com>
| I thought you wanted this thread to end, Erik?

  just cease and desist, Joe Kraska.  that will end it.  nothing else will.

#:Erik
From: Christopher Browne
Subject: Absolutely Nothing to do with Deep Copies
Date: 
Message-ID: <g56N4.15971$VR.393203@news5.giganews.com>
Centuries ago, Nostradamus foresaw a time when Courageous would say:
>>   previously, your imagination had run amuck and conjured up the sick image
>>   of this going on in real life.  I'm amazed that this is possible, because
>>   it indicates a complete and utter lack of contact with reality:  a person
>>   such as Joe "Courageous" Kraska is a nuisance in real life, too, and will
>>   get reprimanded whenever he disturbs a group of people.
>
>I thought you wanted this thread to end, Erik?
>(I indeed suggest that everyone reread this
>thread from the very beginning).

Both of you need to _SHUT UP._

If you each decided to take a potshot or two at each other in public,
and leave it at that, nobody would complain very much.

The size of this thread of _non-Lisp-related_ material has grown to a
veritable dozen or more articles.

Frankly, that is _still_ well and fine; you guys can take as many
potshots at each other as you like, and nobody here will complain, _IF
YOU TAKE THE FIGHTING SOMEWHERE ELSE._  alt.flame would probably be a
good place to take it.  Or possibly alt.abuse.

The point is that none of this belongs on comp.lang.lisp, and it
hasn't belonged on comp.lang.lisp for quite some time.

_IT DOESN'T MATTER WHO'S IN THE WRONG._ When you each follow up in
comp.lang.lisp, and don't change to either email or a more appropriate
newsgroup, you perpetuate the wrong.

[Note: Followup redirected to alt.flame.]

If you at least had an "ObLisp" reference to ensure that the
discussion was, even if only ever so tenuously, related to Lisp, that
might be one thing.  Analyzing each other's "abusiveness" is in no way
relevant.  Don't think that because the "other guy" is being abusive,
that the exchange is somehow "benign" to you, and negative to the
other.  The abusive exchange makes _BOTH_ of you look bad.   

A relevant comparison here is of two monkeys flinging dung at each
other.  There is no "winning" such a fight; all parties involved in
the fight wind up smelling really bad.

> (apply #'flinging-dung '(courageous erik))
DIRTY-COURAGEOUS
DIRTY-ERIK

ObLisp:

Has anyone built an Email filtering scheme in Lisp?  Wouldn't mind
seeing some sample code, whether in CL or Scheme...
-- 
"never post anything you don't want to see on your resume..."
-- Martin Minow <·····@pobox.com>
········@hex.net- <http://www.ntlug.org/~cbbrowne/lsf.html>
From: Russell Senior
Subject: Filtering in lisp (was Re: Absolutely Nothing to do with Deep Copies)
Date: 
Message-ID: <86u2grorth.fsf_-_@coulee.tdb.com>
>>>>> "cbb" == Christopher Browne <········@news.hex.net> writes:

cbb> Has anyone built an Email filtering scheme in Lisp?  Wouldn't
cbb> mind seeing some sample code, whether in CL or Scheme... 

Yes, in elisp.  See Emacs/Gnus (emacs-20.6 comes with Gnus-5.7),
particularly cool since it works on both email and netnews.  In
particular you might want to look at the section of the Gnus
documentation titled `Advanced Scoring'.

-- 
Russell Senior         ``The two chiefs turned to each other.        
·······@aracnet.com      Bellison uncorked a flood of horrible       
                         profanity, which, translated meant, `This is
                         extremely unusual.' ''                      
From: Pierre R. Mai
Subject: Re: Absolutely Nothing to do with Deep Copies
Date: 
Message-ID: <87itx644we.fsf@orion.dent.isdn.cs.tu-berlin.de>
········@news.hex.net (Christopher Browne) writes:

> Has anyone built an Email filtering scheme in Lisp?  Wouldn't mind
> seeing some sample code, whether in CL or Scheme...

Gnus, the news reader preferred by leading Emacsen, has an extensive
assortment of rule-based and adaptive scoring, filtering, splitting
and supression/highlighting mechanisms, is written entirely in Emacs
Lisp, and can be further adapted by the user in Emacs Lisp, as usual.
With this arsenal at ones disposal, it should present no problem
whatsoever to ignore that which one doesn't want to be bothered with,
and to focus on whatever one wants, if one is inclined to do so.
Making use of such tools will usually be much more effective than
complaining to newsgroups about the noise they generate.

Regs, Pierre.

-- 
Pierre Mai <····@acm.org>         PGP and GPG keys at your nearest Keyserver
  "One smaller motivation which, in part, stems from altruism is Microsoft-
   bashing." [Microsoft memo, see http://www.opensource.org/halloween1.html]
From: Rob Warnock
Subject: mail filters [was: {nothing related to Lisp} ]
Date: 
Message-ID: <8e3ris$3kbbe$1@fido.engr.sgi.com>
Christopher Browne <········@hex.net> wrote:
+---------------
| Has anyone built an Email filtering scheme in Lisp?  Wouldn't
| mind seeing some sample code, whether in CL or Scheme...
+---------------

By weird coincidence, I've been hacking on one lately, in Scheme.
If there's interest, I'll post something here when it's vaguely
usable. (I wasn't going to bother the Lisp folks with it, but...)

By the way, the "filtering" (at least, not the kind I'm interested in)
wasn't the hard part. Most of the messiness has had to do with interacting
with the rest of the mail environment, especially playing the same style
of locking as the other programs which append to, alter, or truncate
mailbox files.


-Rob

-----
Rob Warnock, 41L-955		····@sgi.com
Applied Networking		http://reality.sgi.com/rpw3/
Silicon Graphics, Inc.		Phone: 650-933-1673
1600 Amphitheatre Pkwy.		PP-ASEL-IA
Mountain View, CA  94043
From: Christopher Browne
Subject: Absolutely Nothing to do with Deep Copies
Date: 
Message-ID: <xUqN4.10743$Hc7.279013@news4.giganews.com>
Centuries ago, Nostradamus foresaw a time when Courageous would say:
>>   previously, your imagination had run amuck and conjured up the sick image
>>   of this going on in real life.  I'm amazed that this is possible, because
>>   it indicates a complete and utter lack of contact with reality:  a person
>>   such as Joe "Courageous" Kraska is a nuisance in real life, too, and will
>>   get reprimanded whenever he disturbs a group of people.
>
>I thought you wanted this thread to end, Erik?
>(I indeed suggest that everyone reread this
>thread from the very beginning).

Both of you need to _SHUT UP._

If you each decided to take a potshot or two at each other in public,
and leave it at that, nobody would complain very much.

The size of this thread of _non-Lisp-related_ material has grown to a
veritable dozen or more articles.

Frankly, that is _still_ well and fine; you guys can take as many
potshots at each other as you like, and nobody here will complain, _IF
YOU TAKE THE FIGHTING SOMEWHERE ELSE._  alt.flame would probably be a
good place to take it.  Or possibly alt.abuse.

The point is that none of this belongs on comp.lang.lisp, and it
hasn't belonged on comp.lang.lisp for quite some time.

_IT DOESN'T MATTER WHO'S IN THE WRONG._ When you each follow up in
comp.lang.lisp, and don't change to either email or a more appropriate
newsgroup, you perpetuate the wrong.

[Note: Followup redirected to alt.flame.]

If you at least had an "ObLisp" reference to ensure that the
discussion was, even if only ever so tenuously, related to Lisp, that
might be one thing.  Analyzing each other's "abusiveness" is in no way
relevant.  Don't think that because the "other guy" is being abusive,
that the exchange is somehow "benign" to you, and negative to the
other.  The abusive exchange makes _BOTH_ of you look bad.   

A relevant comparison here is of two monkeys flinging dung at each
other.  There is no "winning" such a fight; all parties involved in
the fight wind up smelling really bad.

> (apply #'flinging-dung '(courageous erik))
DIRTY-COURAGEOUS
DIRTY-ERIK

ObLisp:

Has anyone built an Email filtering scheme in Lisp?  Wouldn't mind
seeing some sample code, whether in CL or Scheme...
-- 
"never post anything you don't want to see on your resume..."
-- Martin Minow <·····@pobox.com>
········@hex.net- <http://www.ntlug.org/~cbbrowne/lsf.html>
From: Coby Beck
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <956605398343@NewsSIEVE.cs.bonn.edu>
Erik Naggum <····@naggum.no> wrote in message ·····················@naggum.no...
| * "Coby Beck" <·····@mercury.bc.ca>
| | I have yet to see one coherent justification for supporting Erik's abuse.
|
|   I have yet to see one coherent justification for the abusive behavior I'm
|   _criticizing_.  in fact, the reason for your "allowing" me this is that
|   none of you would tolerate what I'm criticizing.  that's why you don't
|   even _start_ pestering me until you're very safe that whatever nuisance
|   I'm trying to get rid of is about to be gotten rid of for good.  just
|   admit it: _you_ don't want Joe "Courageous" Kraska here, _either_.  I'm
|   doing the dirty work you don't want to do,

Please don't do me any more of these favors.

|   consider whether you understand the alternatives: do you really _want_ a
|   newsgroup full of morons who post false information, idiotic guesswork,
|   homework exercises and (stupid or severely misguided) "solutions"?

I want a newsgroup where people of all levels of experience feel free to post their
questions and thoughts about lisp without the fear of being humiliated and harangued.
I want a newsgroup where questions asked in good faith are answered in good faith
*stupid or not*  I want a newsgroup where people of intermediate skill level can post
their answers for the beginners and the experts might then offer _constructive_
criticism and better solutions where appropriate.

The irony is that we have both just described exactly the same thing.  It is only the
way of looking at it that differs.

|   [snip]
|   _think_ about this.  please.  and if your anger blinds you, shut up, instead.
|

I *am* shutting up about all the rest of your post but not because of anger.  There is
so little common ground in our perceptions and so many assumptions i disagree with that
i don't foresee any useful discussion.

Coby
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165609076098916@naggum.no>
* "Coby Beck" <·····@mercury.bc.ca>
| I want a newsgroup where people of all levels of experience feel free to
| post their questions and thoughts about lisp without the fear of being
| humiliated and harangued.

  you're not reading what I write, but rather what you want to read.  if
  you had read what I wrote, instead of what you want to read, you'd have
  realized about an eon ago that "questions and thoughts" are not at all
  what I react or respond to.  try again.  by opening your mouth in the
  express interest of justice, you owe it to yourself more than to me.

| The irony is that we have both just described exactly the same thing.

  don't flatter yourself.

| I *am* shutting up about all the rest of your post but not because of
| anger.  There is so little common ground in our perceptions and so many
| assumptions i disagree with that i don't foresee any useful discussion.

  that's becase you don't perceive, yet, you judge only, and not what you
  see, but what you want to see.  this happens only to people who have no
  interest in being fair, only in passing judgment.  you're hereby ignored.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3901E003.97201D98@san.rr.com>
>   nothing more needs ever be said about Joe Kraska of BBN.

I might also point out to the group how he's attempting
to be intimidating by bringing my employer into this.
Another sign of an abuser.


C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165414539555821@naggum.no>
* Courageous <········@san.rr.com>
| Another sign of an abuser.

  oh, shut UP, already!  absolutely _anything_ would be a sign of an abuser
  to you.  that's _part_ of the problem you need to solve for yourself.
  you have already demonstrated that the problem here is that you can't
  separate reality from your nightmarish imagination.  this is yet more of
  the same.  spare comp.lang.lisp your therapy sessions!  please!

  let me ask rhetorically: what kind of _victim_ runs after his purported
  abuser with "taunt me!  taunt me!" (except in Monty Python sketches)?

  shutting up may be a very good thing for you to consider, Joe Kraska.  as
  for your employer, present or future, they _will_ search for your name on
  the Net when they evaluate you, soon or on your next "career move".  in
  order to make you understand what you're doing to other people, I include
  your full name and affiliation when you hide it behind an incredibly
  childish nickname so people who look for your name will find your "work".
  anonymity is a privilege you have violated the right to expect others to
  honor, especially when you pretend that others say harmful things they do
  not in fact say, so suffer the consequences of your actions.

#:Erik
From: Tom Breton
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m3r9c0vb0a.fsf@world.std.com>
Rahul Jain <·····@rice.edu> writes:

> In article <·················@san.rr.com> posted on Wednesday,
> April 19, 2000  8:37 PM, Courageous <········@san.rr.com> wrote:
> > 
> >> > One of the hallmark signs of an abuser is blaming the victim.
> >> 
> >> So who's blaming whom here?
> > 
> > Do you feel I'm being "abusive" to Erik? Do tell.
> 
> No, I'm just pointing out that you're BOTH participaring in the
> argument, and that you BOTH should stop. 

Yes, it has gone on for some time.  I can't help noticing that you're
not telling this to *Erik*, who has been posting the long, personally
abusive haragues in response to a sentence or 2, and who has a long
pattern of starting the abuse.

Are you saying that because Erik acts childishly, we will lower our
standards for him and blame others for his actions?  

> Erik is a very smart
> guy, and if you get over his vehmence and try to UNDERSTAND
> what he's saying, you'll end up GAINING from communicating with
> him, instead of LOSING, like you are now.

Actually, for all his bluster, I wouldn't call Erik smart or
knowledgeable.


-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
Suggestion:  Use your killfile liberally in cll
From: Rahul Jain
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8dnv0a$l5p$1@joe.rice.edu>
In article <··············@world.std.com> posted on Thursday,
April 20, 2000  2:16 PM, Tom Breton <···@world.std.com> wrote:
> Rahul Jain <·····@rice.edu> writes:
>> No, I'm just pointing out that you're BOTH participaring in the
>> argument, and that you BOTH should stop. 
> 
> Yes, it has gone on for some time.  I can't help noticing that you're
> not telling this to *Erik*, who has been posting the long, personally
> abusive haragues in response to a sentence or 2, and who has a long
> pattern of starting the abuse.

starting or not, I agree that he is always involved, from what
I've seen....

> Are you saying that because Erik acts childishly, we will lower our
> standards for him and blame others for his actions?  
> 

what part of BOTH did you not get?

>> Erik is a very smart
>> guy, and if you get over his vehmence and try to UNDERSTAND
>> what he's saying, you'll end up GAINING from communicating with
>> him, instead of LOSING, like you are now.
> 
> Actually, for all his bluster, I wouldn't call Erik smart or
> knowledgeable.

Then maybe you should take ideas for their value as ideas and
not prejudice them based on your own personal hangups against
the person whose idea it was. You might realize that you agree
with that person after all.

-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Jon S Anthony
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3900D743.45C7@synquiry.com>
Courageous wrote:
> 
> > Then maybe you should take ideas for their value as ideas and
> > not prejudice them based on your own personal hangups against
> > the person whose idea it was. You might realize that you agree
> > with that person after all.
> 
> For what it's worth, I've never had any doubt that Erik
> was right. I understood in the beginning exactly what was
> meant, it's just that's neither the question I asked, nor
> something I was particularly concerned with. In the object
> models I am working with (which are simulation objects),
> the vast majority of objects are based on simple inheritance,
> have basic primitive type attributes, or contain/reference
> similar objects, or have sequences of the same...
> 
> In such context, a graph copy is quite useful, I assure
> you.

Also sounds pretty trivial.  So why not spend some small fraction
of the enormous amount of energy you've wasted here, and just write
it?  You'd simply be done and that would be that.


/Jon


-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3900DEBC.77F466B@san.rr.com>
> Also sounds pretty trivial.  So why not spend some small fraction
> of the enormous amount of energy you've wasted here, and just write
> it?  You'd simply be done and that would be that.

I have what I need already, thanks.



C/
From: Jon S Anthony
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3900D665.45D2@synquiry.com>
Tom Breton wrote:
> 
<...>
> 
> Actually, for all his bluster, I wouldn't call Erik smart or
> knowledgeable.

That's sounds like a "political agenda" position if there ever
was one.  If you can't see that Erik has a _lot_ of knowledge
to offer (and _does_ provide it regularly), that says more about
you than him.

/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Tom Breton
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m3d7njqajy.fsf@world.std.com>
Jon S Anthony <···@synquiry.com> writes:

> Tom Breton wrote:
> > 
> <...>
> > 
> > Actually, for all his bluster, I wouldn't call Erik smart or
> > knowledgeable.
> 
> That's sounds like a "political agenda" position if there ever
> was one.  If you can't see that Erik has a _lot_ of knowledge
> to offer (and _does_ provide it regularly), that says more about
> you than him.

Wrong on every single count.

Don't try to tell me I haven't given him a fair chance.  I've given
him much more than that.  My conclusion is that his technical
reputation in cll is undeserved.  I had to tell him very basic stuff
about optimization.  He still thinks like an Assembly language
programmer and openly refuses to learn better ways.

So now when I see someone on cll credit him with smarts, sometimes I
feel I should correct them.

-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
Suggestion:  Use your killfile liberally in cll
From: Jon S Anthony
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <390227B4.15FA@synquiry.com>
Tom Breton wrote:
> 
> Jon S Anthony <···@synquiry.com> writes:
> 
> > Tom Breton wrote:
> > >
> > <...>
> > >
> > > Actually, for all his bluster, I wouldn't call Erik smart or
> > > knowledgeable.
> >
> > That's sounds like a "political agenda" position if there ever
> > was one.  If you can't see that Erik has a _lot_ of knowledge
> > to offer (and _does_ provide it regularly), that says more about
> > you than him.
> 
> Wrong on every single count.

You offer no evidence for your claim.  Evidence against it is all over
the place.  So, I guess there is no reason for me to believe you.


> Don't try to tell me I haven't given him a fair chance.  I've given

I don't know or care if you have "given him a fair chance" as whether
you have or not is completely irrelevant to the factual point being
made.


> about optimization.  He still thinks like an Assembly language
> programmer and openly refuses to learn better ways.

Says you.  Not particularly good evidence.  I've read both "sides"
on this point.


> So now when I see someone on cll credit him with smarts, sometimes I
> feel I should correct them.

I don't think I particularly need any correction from you.


/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165384579368198@naggum.no>
* Tom Breton <···@world.std.com>
| I had to tell him very basic stuff about optimization.

  you still haven't read what I have written about optimization, and you
  repeat the same idiotic comments that were proven wrong by others, but
  pretend that I'm the only one who doesn't "agree" with you.  the fact is,
  however, that _nobody_ agrees with you, but you, like any moron deserving
  the label, decided in your own sick, demented mind, that I'm to blame for
  your lack of brains.  this is just as brilliant as your incredibly stupid
  ideas about optimization.

#:Erik
From: Tom Breton
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m3hfcvqapr.fsf@world.std.com>
Rahul Jain <·····@rice.edu> writes:

> In article <··············@world.std.com> posted on Thursday,
> April 20, 2000  2:16 PM, Tom Breton <···@world.std.com> wrote:
> 
> > Are you saying that because Erik acts childishly, we will lower our
> > standards for him and blame others for his actions?  
> > 
> 
> what part of BOTH did you not get?

The part where you addressed just one side.  Actions speak louder than
words.

> >> Erik is a very smart
> >> guy, and if you get over his vehmence and try to UNDERSTAND
> >> what he's saying, you'll end up GAINING from communicating with
> >> him, instead of LOSING, like you are now.
> > 
> > Actually, for all his bluster, I wouldn't call Erik smart or
> > knowledgeable.
> 
> Then maybe you should take ideas for their value as ideas and
> not prejudice them based on your own personal hangups against
> the person whose idea it was. 

Tsk, tsk.  You totally made that up about me, and it was completely
uncalled for.  And geez, to make that up about me just to defend
Naggum, I'm appalled.

Don't try to tell me I haven't given him a fair chance.  I've given
him much more than that.  My conclusion is that his technical
reputation in cll is undeserved.  I had to tell him very basic stuff
about optimization.  He still thinks like an Assembly language
programmer and openly refuses to learn better ways.

So now when I see someone on cll credit him with smarts, sometimes I
feel I should correct them.

-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
Suggestion:  Use your killfile liberally in cll
From: Rahul Jain
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8dssir$700$1@joe.rice.edu>
In article <··············@world.std.com> posted on Friday, April 21, 2000
 6:46 PM, Tom Breton <···@world.std.com> wrote:
> Rahul Jain <·····@rice.edu> writes:
>> what part of BOTH did you not get?
> 
> The part where you addressed just one side.  Actions speak louder than
> words.

The message was "addressed" to c.l.l

>> Then maybe you should take ideas for their value as ideas and
>> not prejudice them based on your own personal hangups against
>> the person whose idea it was. 
> 
> Tsk, tsk.  You totally made that up about me, and it was completely
> uncalled for.  And geez, to make that up about me just to defend
> Naggum, I'm appalled.

Keep thinking that.

> Don't try to tell me I haven't given him a fair chance.  I've given
> him much more than that.  My conclusion is that his technical
> reputation in cll is undeserved.  I had to tell him very basic stuff
> about optimization.  He still thinks like an Assembly language
> programmer and openly refuses to learn better ways.

Thanks for proving my point.
 
> So now when I see someone on cll credit him with smarts, sometimes I
> feel I should correct them.

And again.
Personally, I've seen little wisdom coming from your posts, and a much
larger amount coming from Erik's. I don't think that it excuses his
vehmence, but on technical matters, I'd believe him over you, considering
how you've proven that you can't see yourself when you look in the mirror.

-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165302496305278@naggum.no>
* Courageous <········@san.rr.com>
| One of the hallmark signs of an abuser is blaming the victim.

  the hallmark of a loser is one who has thoughts of "blame" and "victim"
  and "abuser" and all that shit and who seems himself in one particular
  role relative to others.  snap out of it!

  no one is blaming you for anything.  you are simply being told that your
  actions have certain consequences.  you seem to subscribe to this view,
  yet refuse to apply it to yourself.  I find this highly indicative of
  what I have concluded about you.  you have been told that if you don't
  want the consequences, you should change the actions.  you refuse to
  change your pattern of being a hapless victim and go on and on and on
  about everything bad happening to you being my fault.  you victimize
  _yourself_ and work very hard to _remove_ responsibility from yourself.
  such is the hallmark of a loser without hope of recovery, but I think
  that has been the fairly well established pattern from you already.

  the problem with you is you can't stop feeling the victim, even when it's
  clear that you're running after _me_ with your unceasing desire to blame
  me for your _personal_ problems.  I'm not responsible for your reactions.
  you have to accept responsibility for your own _part_ in everything that
  happens to you and not try to shift it to somebody else.  doing so is,
  indeed, highly indicative of what I have already concluded about you.

  the big test is whether you get over this.  so far, you have not, and
  neither has Tom Breton and a few other "victims".  they have another
  thing in common: all been very seriously mistaken in some particular
  area.  I find it very interesting that being persistently wrong about
  something causes _some_ people to fall into the "victim" trap (in their
  own mind) and never get out of it, while those who want to understand
  accept technical counter-information the first time it is presented and
  _learn_ from it.  people who refuse to learn, however, fall into another
  category which is unlikely to be respected for much, and even less when
  they start to blame others and use "I'm a victim!" language.

  I now understand why you need to _call_ yourself "Courageous".

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3900E027.24FE5B2D@san.rr.com>
>   you are simply being told that your
>   actions have certain consequences.

"Stop, or I'll kill the hostage and it'll be YOUR fault."




C/
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <39007925.C37D3E6F@san.rr.com>
> | One of the hallmark signs of an abuser is blaming the victim.
> 
>   the hallmark of a loser is...

[snip.

Another one page ego diatribe says it all, Erik.
As usual, you outdo yourself.


C/
From: Erik Naggum
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3165322206168072@naggum.no>
* Courageous <········@san.rr.com>

  while you continue your abuse, I'm waiting for your message-ID with the
  favorite quoted text of yours which you attribute to me.

#:Erik
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <3900DEFC.B8F23CAE@san.rr.com>
Erik Naggum wrote:
> 
> * Courageous <········@san.rr.com>
> 
>   while you continue your abuse, I'm waiting for your message-ID with the
>   favorite quoted text of yours which you attribute to me.

A done deal, as it were.



C/
From: Tom Breton
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m37ldy9267.fsf@world.std.com>
Courageous <········@san.rr.com> writes:
[Erik Naggum wrote]
> >   are in no danger at all of being called morons.  and in case you wonder
> >   about more things, smart people who don't defend themselves can disagree
> >   violently without even the hint of a danger of getting personal, 
> 
> You're complaining about *me* making matters personal.
> Oh, that's rich. Between the two of us, who's posting
> page-long diatribes sometimes filled with profanity?

Heh.  I understand from second-hand quotes that he called me an
"obsessed stalker", a very strange name to call me when he is in my
killfile.

-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
Suggestion:  Use your killfile liberally in cll
From: Tim Bradshaw
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ey3vh1j4nch.fsf@cley.com>
* Courageous  wrote:

> More rhetorically, I wonder if the people over at Franz will
> be "morons" if they attempt to implement the Objects By
> Value section of the CORBA standard in their ORBLink product?

It's not stupid to implement a design that may broken if you need to
do that to be able to say that you conform to a standard and therefore
get sales.  But it doesn't tell you anything about the brokenness of
the design either -- being a popular standard does not correlate
particularly well with being a good design, as Lisp people have found
by bitter experience.

--tim
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38F8B3DF.B1091C5@san.rr.com>
> > More rhetorically, I wonder if the people over at Franz will
> > be "morons" if they attempt to implement the Objects By
> > Value section of the CORBA standard in their ORBLink product?
> 
> It's not stupid to implement a design that may broken if you need to
> do that to be able to say that you conform to a standard and therefore
> get sales.  But it doesn't tell you anything about the brokenness of
> the design either -- being a popular standard does not correlate
> particularly well with being a good design, as Lisp people have found
> by bitter experience.


Well, that's a fair criticism.

I suppose I have a different attitude about these things than you
do. I was thinking back to a message where I said that I used a
C++ deep copier from generated code for several years, and that it
always worked perfectly. I realized in retrospect that there were
a number of occasions where when I used it, things were screwed up.
But then upon analysis, I always ended up blaming myself and not
the code; it did, from my perspective, always only do exactly what
I told it to do. It never so much as occured to me to blame the
copier.

That inspires the question: "Should programmers be protected from
themselves?". Obviously, I don't think so. Such is fairly typical
of my C background, I suppose.



C/
From: thi
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m2r3doln3ei.fsf@netcom9.netcom.com>
Courageous <········@san.rr.com> writes:

> That inspires the question: "Should programmers be protected from
> themselves?". Obviously, I don't think so. Such is fairly typical
> of my C background, I suppose.

programmers should be protected from each other.

thi
From: Rahul Jain
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <8ddc10$o80$1@joe.rice.edu>
In article <···············@netcom9.netcom.com> posted on
Sunday, April 16, 2000  4:26 PM, thi <···@netcom.com> wrote:
> Courageous <········@san.rr.com> writes:
> 
>> That inspires the question: "Should programmers be protected from
>> themselves?". Obviously, I don't think so. Such is fairly typical
>> of my C background, I suppose.
> 
> programmers should be protected from each other.
> 
> thi

Only if one of them is a blatant troll

-- 
-> -\-=-=-=-=-=-=-=-=-=-/^\-=-=-=<*><*>=-=-=-/^\-=-=-=-=-=-=-=-=-=-/- <-
-> -/-=-=-=-=-=-=-=-=-=/ {  Rahul -<>- Jain   } \=-=-=-=-=-=-=-=-=-\- <-
-> -\- "I never could get the hang of Thursdays." - HHGTTG by DNA -/- <-
-> -/- http://photino.sid.rice.edu/ -=- ·················@usa.net -\- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
   Version 11.423.999.210020101.23.50110101.042
   (c)1996-2000, All rights reserved. Disclaimer available upon request.
From: Stig Hemmer
Subject: Should programmers be protected from themselves?
Date: 
Message-ID: <ekvg0scaayg.fsf_-_@epoksy.pvv.ntnu.no>
Courageous <········@san.rr.com> writes:
> That inspires the question: "Should programmers be protected from
> themselves?". Obviously, I don't think so. Such is fairly typical
> of my C background, I suppose.

Most programmers think that we should be protected from ourselves ON
SOME LEVEL.

However, there are wild disagreements as to which level is the right
one.  Most people favor what they are used to... and C people are used
to very little protection.

For example: Consider a language where you could, by an easy mistake,
make the compiler treat a bit pattern that was supposed to be a
floating point value instead be interpreted as an integer value.
(This does not mean _truncated_ to an integer, but bit-wise
reinterpreted as an integer.  This gives totally wild results)

This would be a bad idea, wouldn't it?

Computers used to work like that...  and people made that sort of
mistakes all the time.

Then type checking was introduced, and most people saw that it was a
good thing.  But some people had been using the old "feature" to do
real fast floating point arithmetic, e.g. multiplying by REAL 2.0 by
adding INTEGER 1.  They didn't like type checking.  (Never mind that
the "real fast" way of doing things occationally gave the wrong
answer...)

And so it goes.

My answer to your question would be that programmers should be
protected from themselves in any way reasonable, _but_ that the
protections should be easy to overrule when needed.

Stig Hemmer,
Jack of a Few Trades.
From: Philip Lijnzaad
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <u7n1mtxc7r.fsf@o2-3.ebi.ac.uk>
Tim> * Courageous  wrote:
>> More rhetorically, I wonder if the people over at Franz will
>> be "morons" if they attempt to implement the Objects By
>> Value section of the CORBA standard in their ORBLink product?

Tim> It's not stupid to implement a design that may broken if you need to
Tim> do that to be able to say that you conform to a standard and therefore
Tim> get sales.  

Actually, CORBA valuetypes (which are partly useful but mostly monstrous)
don't seem to be that popular anyways. They seem to have invaded the tidy
world of pre-2.3 CORBA at the insistence of Java acolytes. The single thing
they _are_ useful for (extendability) would probably be better done using
struct { string xml; string dtd; }. Ah well,

                                                                      Philip

-- 
Not getting what you want is sometimes a wonderful stroke of luck.
-----------------------------------------------------------------------------
Philip Lijnzaad, ········@ebi.ac.uk | European Bioinformatics Institute,rm A2-24
+44 (0)1223 49 4639                 | Wellcome Trust Genome Campus, Hinxton
+44 (0)1223 49 4468 (fax)           | Cambridgeshire CB10 1SD,  GREAT BRITAIN
PGP fingerprint: E1 03 BF 80 94 61 B6 FC  50 3D 1F 64 40 75 FB 53
From: Courageous
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <38FB3AC7.7DC30E24@san.rr.com>
> Tim> It's not stupid to implement a design that may broken if you need to
> Tim> do that to be able to say that you conform to a standard and therefore
> Tim> get sales.
> 
> Actually, CORBA valuetypes (which are partly useful but mostly monstrous)
> don't seem to be that popular anyways.


Which CORBA vendors actually have implementations at this point?
It's still pretty early, all the way around, I think.


C/
From: Philip Lijnzaad
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <u7hfd0y9o6.fsf@o2-3.ebi.ac.uk>
On Mon, 17 Apr 2000 16:21:58 GMT, 
"Courageous" == Courageous  <········@san.rr.com> writes:

Tim> It's not stupid to implement a design that may broken if you need to
Tim> do that to be able to say that you conform to a standard and therefore
Tim> get sales.
>> 
>> Actually, CORBA valuetypes (which are partly useful but mostly monstrous)
>> don't seem to be that popular anyways.


Courageous> Which CORBA vendors actually have implementations at this point?
Courageous> It's still pretty early, all the way around, I think.

I know IONA (Orbix) and OOC (ORBacus) do (even if only as beta), as does DOG
(JavaORB) and Mico. Inprise^WBorland^WCorel (Visibroker) can't be far behind.

Follow-ups set to comp.object.corba. 


                                                                      Philip
-- 
Not getting what you want is sometimes a wonderful stroke of luck.
-----------------------------------------------------------------------------
Philip Lijnzaad, ········@ebi.ac.uk | European Bioinformatics Institute,rm A2-24
+44 (0)1223 49 4639                 | Wellcome Trust Genome Campus, Hinxton
+44 (0)1223 49 4468 (fax)           | Cambridgeshire CB10 1SD,  GREAT BRITAIN
PGP fingerprint: E1 03 BF 80 94 61 B6 FC  50 3D 1F 64 40 75 FB 53
From: Tom Breton
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <m38zygulrl.fsf@world.std.com>
············@tzd.dont.telekom.spam.de.me (Joerg-Cyril Hoehle) writes:

> 
> Later:
> > A tip for some of you folks: one of the keys to successful
> > communication is not to assume that the other person is wrong,
> > but rather to figure out what they're right *for*.
> 
> I believe there's also tips and netiquette about reading the FAQ and
> the newsgroup for some time. Maybe you would have come across a
> reference to Kent M. Pitman article
> http://world.std.com/~pitman/PS/EQUAL.html about why there can't be an
> all general copy, so you'd have known not to ask the question - but
> maybe there aren't bad questions, just bad answers.
> 
> I sincerely hope that by now, you read both this and Tim Bradshaw's
> article at http://www.cley.com/articles/one-step-beyond.pdf

Thanks for the reference.  It's a good article, and not primarily for
his comments on deep copying.

-- 
Tom Breton, http://world.std.com/~tob
Not using "gh" since 1997. http://world.std.com/~tob/ugh-free.html
Rethink some Lisp features, http://world.std.com/~tob/rethink-lisp/index.html
From: Paolo Amoroso
Subject: Re: Deep copy in lisp: how?
Date: 
Message-ID: <ZZP4OPjeHOGtZgITfBLzmnAC5+Vu@4ax.com>
On 14 Apr 2000 18:13:06 +0200, ············@tzd.dont.telekom.spam.de.me
(Joerg-Cyril Hoehle) wrote:

> since there are some strong opinions here about "the worse is better",
> 90% working solutions, unfinished APIs and the like.

For those unfamiliar with "worse is better":

  "Lisp: Good News, Bad News, How to Win Big" By Richard Gabriel
  http://www.naggum.no/worse-is-better.html


Paolo
-- 
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/