Newbie - 2 Small problems
Dr. Edmund Weitz
> I'm not sure if this is the right place to ask, but since it is a lisp
> forum I thought it couldn't hurt ;)
>
> 1) Is there any way to test for option arguments in a function? For
> example, if I do:
>
> (defun test (list1 list2 &key k)
>
> is there a way to test in the body of that function whether or not k
> exists? If k doesn't exist, the value is NIL, but I don't know how to
> compare if something's value is NIL. I know I should know, but I
> don't. I would use an if statement, but k is either NIL or the key
> value....
* (defun bar (&key (foo nil supplied-foo-p))
(format t "~%foo is ~A" foo)
(format t "~%foo was ~Aprovided" (if supplied-foo-p "" "not ")))
BAR
* (bar)
foo is NIL
foo was not provided
NIL
* (bar :foo nil)
foo is NIL
foo was provided
NIL
* (bar :foo 'baz)
foo is BAZ
foo was provided
NIL
See 3.4.1 of the CLHS for details.
> 2) is there an easy way to swap items in a list? For example, I
> want to swap the 2nd and 4th items in the list '(1 4 3 2 5).... is
> there an easy way to do it? I can't explicitly set the value of an
> element in a list, can I?
* (defparameter *my-list* '(1 2 3 4 5))
*MY-LIST*
* (rotatef (second *my-list*) (fourth *my-list*))
NIL
* *my-list*
(1 4 3 2 5)
* (setf (third *my-list*) 42)
42
* *my-list*
(1 4 42 2 5)
HTH,
Edi.
--
Dr. Edmund Weitz
Hamburg
Germany
The Common Lisp Cookbook
<http://cl-cookbook.sourceforge.net/>
Michael Parker
>
> I'm not sure if this is the right place to ask, but since it is a lisp
> forum I thought it couldn't hurt ;)
>
> 1) Is there any way to test for option arguments in a function? For
> example, if I do:
>
> (defun test (list1 list2 &key k)
>
> is there a way to test in the body of that function whether or not k
> exists? If k doesn't exist, the value is NIL, but I don't know how to
> compare if something's value is NIL. I know I should know, but I
> don't. I would use an if statement, but k is either NIL or the key
> value....
(defun test (list1 list2 &key (k nil k-supplied-p))
...)
>
> 2) is there an easy way to swap items in a list? For example, I want
> to swap the 2nd and 4th items in the list '(1 4 3 2 5).... is there
> an easy way to do it? I can't explicitly set the value of an element
> in a list, can I?
Sure. Both elt and nth are setf forms. As are first, second, third,
etc.
Keep in mind that unlike in Python these functions are linear-time, not
constant-time operations.
1> (setq *foo* (list 'a 'b 'c))
(A B C)
2> (setf (nth 1 *foo*) 'd)
D
3> *foo*
(A D C)
4> (setf (elt *foo* 2) 'e)
E
5> *foo*
(A D E)
>
> Sorry for the wierd questions. I've been trying to figure them out
> for hours but can't =(
>
> Thanks!
The CLHS is your friend.
Kent M Pitman
> > 2) is there an easy way to swap items in a list? For example, I
> > want to swap the 2nd and 4th items in the list '(1 4 3 2 5).... is
> > there an easy way to do it? I can't explicitly set the value of an
> > element in a list, can I?
>
> * (defparameter *my-list* '(1 2 3 4 5))
> *MY-LIST*
> * (rotatef (second *my-list*) (fourth *my-list*))
> NIL
> * *my-list*
> (1 4 3 2 5)
> * (setf (third *my-list*) 42)
> 42
> * *my-list*
> (1 4 42 2 5)
However, note that it will traverse the list twice to do this. lists
elements are directly accessed, they are obtained by cdr'ing down the
chain of conses each time.
Usually, if you are going to be swapping arbitrary elements, it's a
hint that you do not want a list as your basic data structure. This
is a basic issue of algorithmic design and would be true in any
language, except languages that lie to you and tell you that they have
a list data structure when really they are using an array.
Steve Long
TejimaNoHimitsu wrote:
> I'm not sure if this is the right place to ask, but since it is a lisp
> forum I thought it couldn't hurt ;)
>
> 1) Is there any way to test for option arguments in a function? For
> example, if I do:
>
> (defun test (list1 list2 &key k)
>
> is there a way to test in the body of that function whether or not k
> exists? If k doesn't exist, the value is NIL, but I don't know how to
> compare if something's value is NIL. I know I should know, but I
> don't. I would use an if statement, but k is either NIL or the key
> value....
>
By exists, you mean (boundp k) is non-nil? I believe an arg always has to
have something bound to it.
>
> 2) is there an easy way to swap items in a list? For example, I want
> to swap the 2nd and 4th items in the list '(1 4 3 2 5).... is there
> an easy way to do it? I can't explicitly set the value of an element
> in a list, can I?
>
Yes. One non-destructive technique (function) might be
(defun swap-elt (seq n1 n2)
(let ((new-seq (copy-seq seq)))
(setf (elt new-seq n1) (elt seq n2))
(setf (elt new-seq n2) (elt seq n1))
new-seq))
swap-elt
(setf x '(1 2 3 4 5))
(1 2 3 4 5)
(swap-elt x 1 2)
(1 3 2 4 5)
x
(1 2 3 4 5)
(swap-elt x 0 4)
(5 2 3 4 1)
x
(1 2 3 4 5)
(setf x "god")
god
(swap-elt x 0 2)
dog
Many ways to skin this cat.
Erik Naggum
| Thanks guys! I really appreciate your help. I never knew about the
| CLHS.... I'll have to look over this! =)
What are you using to learn to program in Common Lisp now? I really hope
you have found a textbook, and are not _only_ using documentation that
comes with your Common Lisp environment. Both a tutorial on the language
and the reference will come in very handy very quickly. There is no
nutshell handbook on Common Lisp yet, for instance, because the standard
(CLHS among friends) is sufficient, but it is not pedagogical in nature.
www.lisp.org is a good start.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Rahul Jain
> Both elt and nth are setf forms. ...
> Keep in mind that unlike in Python these functions are linear-time, not
> constant-time operations.
ELT is neither constant- nor linear-time. (in the big theta sense,
which is what I assume you mean)
ELT is a generic sequence accessor, and so, takes the appropriate
amount of time for the sequence being acessed. If it is a list, it
takes linear time. If it is an array it takes constant-time. Note that
the Real Python (CMUCL's and SBCL's compiler) has the list-accessors
take linear-time. It's just that Fake Python that has the Fake Lambda
and Fake List where accesses take constant-time, and lists can't share
structure. :)
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- mailto:rj...@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Erik Naggum
| The above function is supposed to take a predicate, a number, and a
| sorted list of numbers and insert elm into lis at the proper spot
| based on the boolean predicate p. For example, if you call:
|
| (insert-n-sort #'< 3 '(2 4 6 8))
|
| You should get
|
| (2 3 4 6 8) back.
Not to spoil your fun here, but either of these will produce the correct
result with very little overhead:
(merge 'list (list 3) (list 2 4 6 8) #'<)
(sort (list* 3 (list 2 4 6 8) #'<))
Please note that sort is destructive, so do not use a quoted argument.
| 1) How can I change all the setf crap to let statements? I know it's
| bad form to use setf
setf is not bad form. It is bad karma to teach that it is. Your
professor may return as a Scheme programmer if he keeps this up. (Or he
may done something terrible in his previous life and actually be a Scheme
programmer.)
It _is_ bad form to setf a component of a quoted constant, however.
| I can never get the syntax for let working properly...
It is really quite simple: (let (<binding>*) <declaration>* <form>*).
A <binding> has the form (<variable> <value>), or just <variable> if you
plan to set it before you use it.
| 2) Is there an easy way to sort the list produced by the mapcar? By
| easy, I don't mean calling (sort timp #'<) because we aren't allowed to
| use the sorting function. In fact, we shouldn't even need to sort the
| list... but that's the only way I can get it to work. Program is a piece
| of cake in Java, C++, C#, etc.... but I don't know lisp well enough to do
| something like a minsort (hence why I asked how to swap elements) ;)
I am so strongly opposed to the pointless exercises in re-inventing the
wheel using idiotic restrictions in order to learn what a wheel is that I
think teachers who do this to their students should be terminated.
Having to reimplement basic functionality is not as illuminating as
reading and understanding a professional programmer's implementation of
it -- "learn by doing" is good for muscular training. Programming is a
process of thinking, so you learn by thinking, not by unthinkingly
replicating the mere results of other people's thinking. I also think
every writer learns to write by reading observantly, taking notes, using
a very large dictionary to discover nuances and details in meaning, and
paying attention to details everywhere. I think this is what studying is
all about -- learning merely to repeat what others have done before you
is not study.
| I know I asked for help once already so I understand if people are
| reluctant to provide more aid....
As long as they keep learning and ask intelligent questions and work on
your own, it is actually a joy to help people.
Thomas Bushnell, BSG
> | 1) How can I change all the setf crap to let statements? I know it's
> | bad form to use setf
>
> setf is not bad form. It is bad karma to teach that it is. Your
> professor may return as a Scheme programmer if he keeps this up. (Or he
> may done something terrible in his previous life and actually be a Scheme
> programmer.)
I consider it bad form to introduce needless side-effects; when a setf
could be done in let, I always prefer let. Then again, I don't use
any languages that have setf; I use set!. :)
Thomas
Erik Naggum
| I consider it bad form to introduce needless side-effects; when a setf
| could be done in let, I always prefer let. Then again, I don't use
| any languages that have setf; I use set!. :)
set! is bad form. setf is not. Just another one of those differences
between real Lisps like Common Lisp and toy lisps like Scheme.
Kenny Tilton
TejimaNoHimitsu wrote:
> The above function is supposed to take a predicate, a number, and a
> sorted list of numbers and insert elm into lis at the proper spot
> based on the boolean predicate p.
the exciting thing to me is that the spec does not say the sorted list
is sorted by the same predicate as the argument, which could make for
great fun. But I will assume the two are the same.
> for let working properly..... (let (gimp (list elm x)) (if.....))
(let ((gimp (list elm x))) (if ...))
btw, i think you want (list* elm x) or (cons elm x)
> we aren't allowed
> to use the sorting function.
can you use rotatef? rplaca?
--
kenny tilton
clinisys, inc
---------------------------------------------------------------
"Be the ball...be the ball...you're not being the ball, Danny."
- Ty, Caddy Shack
Thomas Bushnell, BSG
> * tb+u...@becket.net (Thomas Bushnell, BSG)
> | I consider it bad form to introduce needless side-effects; when a setf
> | could be done in let, I always prefer let. Then again, I don't use
> | any languages that have setf; I use set!. :)
>
> set! is bad form. setf is not. Just another one of those differences
> between real Lisps like Common Lisp and toy lisps like Scheme.
Ah, so this is an insult battle. Not interested here.
Thomas
Kent M Pitman
> Erik Naggum <er...@naggum.net> writes:
>
> > | 1) How can I change all the setf crap to let statements? I know it's
> > | bad form to use setf
> >
> > setf is not bad form. It is bad karma to teach that it is. Your
> > professor may return as a Scheme programmer if he keeps this up. (Or he
> > may done something terrible in his previous life and actually be a Scheme
> > programmer.)
>
> I consider it bad form to introduce needless side-effects;
An assignment is not a side-effect.
It is a notational gesture.
(let ((x 3))
(let ((x (+ x 1)))
x))
and
(let ((x 3))
(setq x (+ x 1))
x)
do the same thing. It is purely a notational choice which you use.
> when a setf could be done in let, I always prefer let.
Sometimes (e.g., in iterations) it is very hard to construct the
former style syntactically without introducing an apparent recursion.
Personally, I think recursions make things harder to read and would
prefer a SETQ. But others disagree. It is again just a personal
choice issue how much you're going to want to perturb the written
structure of the program in order to accomodate a style choice. SETQ
facilitates incremental change by not forcing a whole program to be
restructured just to accomodate a small conceptual change.
Erik Naggum
| Ah, so this is an insult battle.
No. Try some other explanation.
Thomas Bushnell, BSG
> * Thomas Bushnell, BSG
> | Ah, so this is an insult battle.
>
> No. Try some other explanation.
When you call Scheme a "toy Lisp", you are trolling, much like those
who call Lisp a toy language. Maybe it seems that way if you haven't
done much really serious programming in it, of real sophisticated
systems.
Any language without call/cc looks totally like a toy to me, actually.
Thomas
Thomas Bushnell, BSG
> An assignment is not a side-effect.
Um, sometimes an assignment is equivalent to side-effect free form,
tis true--such is the case with your examples.
But in general, assignments introduce side-effects. In general, the
following two are *not* equivalent:
(begin
(set! x 3)
...)
(let ((x 3))
...)
The latter is side-effect free; the former is not. Functions which
only include side-effect free forms have values which depend purely on
their arguments; this is not (in general) true if you use set!.
I belabor this only because in the Scheme world, at least, this is
exactly the normal definition of a side-effect.
Right--some uses of set! are side-effect free. But all uses of let
are always side-effect free.
> > when a setf could be done in let, I always prefer let.
>
> Sometimes (e.g., in iterations) it is very hard to construct the
> former style syntactically without introducing an apparent recursion.
Um, in the Scheme world, we always call these "apparent recursions" by
the name "iteration". The avoidance of syntactic recursion in Lisp
dates back to the days before proper tail recursion was de rigeur.
> Personally, I think recursions make things harder to read and would
> prefer a SETQ. But others disagree.
I think this is just a matter of what you are most used to reading.
Erik Naggum is certainly right that use of setf (and friends) is very
prevalent in the Lisp world, but in the Scheme world, it's regarded as
bad form--and once, the same was in fact true in the Lisp world.
> It is again just a personal
> choice issue how much you're going to want to perturb the written
> structure of the program in order to accomodate a style choice. SETQ
> facilitates incremental change by not forcing a whole program to be
> restructured just to accomodate a small conceptual change.
Oh, quite the contrary, actually. Side-effects, as a rule,
incorporate lots of non-local dependencies, which must be very
carefully managed. (Not that this is hard to do; it's just one extra
thing to think about, and one extra source of bugs.) Side effect free
programming, on the other hand, saves an awful lot of that work.
Surely side effects are often necessary to express a computation
cleanly, but as SICP points out, such cases really occur when you have
things like state-maintaining objects of some sort.
I fully agree that this is an issue of taste, culture, and style. I
only entered the discussion to point out that people who's style
includes the maxim "avoid unnecessary set! and friends" have a
legitimate and useful style, and that the original poster was probably
coming from that background.
Incidentally, this is not really a Scheme v. Lisp issue. Side effects
are looked down on by a huge number of older Lisp texts and
implementations and programmers. Modern Common Lisp looks more like
PL/I to me, so I guess all kinds of weird things are now normal
there. :)
Thomas
Erik Naggum
| When you call Scheme a "toy Lisp", you are trolling, much like those
| who call Lisp a toy language. Maybe it seems that way if you haven't
| done much really serious programming in it, of real sophisticated
| systems.
|
| Any language without call/cc looks totally like a toy to me, actually.
The key was the difference between the communities. Scheme is a toy seen
from Common Lisp. This is a Common Lisp forum. Whatever Scheme freaks
need to disparage in order to feel good about Perl, no, wait, Scheme, is
trolling in comp.lang.lisp. I find it odd that you did not recognize
that you were trolling to begin with, and only got "insulted" when you
got a response in kind. Scheme freaks go nuts about set! and call upon
various deities to ensure that people who use it do not get a second
chance, while Kent Pitman has offered us a reasonable distinction between
intra-scope assignment and extra-scope side-effects. So Scheme's silly
knee-jerk reaction to set! is the same as the knee-jerk reaction to goto
-- failure to understand when it has its uses causes a religious response
to its presence. I also wonder why you keep trolling if you think it is
in any way inappropriate. Me, I think poking fun at Scheme is one of the
few available pleasures that nobody could _possibly_ be hurt by, since it
is such a toy language. Now, if I posted that in comp.lang.scheme, it
would be trolling and insulting. Much like it would have been if I had
posted any of my acidic comments on that XML failure to comp.text.xml.
And considering all the venomous crap that Scheme freaks pour over the
real Lisp, I think we should stay away from Northern Ireland-like ways to
deal with our feeling "insulted" by what other people say. Including,
but not limited to people who now are "insulted" by my reference to the
bellicose cultures of Northern Ireland. Trust me, if I had used Israel
and Palestine as the canonical example of, no, wait, let's not do that.
Thomas Bushnell, BSG
> The key was the difference between the communities. Scheme is a toy seen
> from Common Lisp. This is a Common Lisp forum. Whatever Scheme freaks
> need to disparage in order to feel good about Perl, no, wait, Scheme, is
> trolling in comp.lang.lisp. I find it odd that you did not recognize
> that you were trolling to begin with, and only got "insulted" when you
> got a response in kind.
Scheme is usually represented as one dialect of Lisp. comp.lang.lisp
*predates* Common Lisp, however. It seems to me that comp.lang.lisp
should therefore be for all Lisps (and principally for those in
current use, of course).
> Scheme freaks go nuts about set! and call upon
> various deities to ensure that people who use it do not get a second
> chance, while Kent Pitman has offered us a reasonable distinction between
> intra-scope assignment and extra-scope side-effects.
Yes, and that's a reasonable case. Like I said, I think it's also an
issue of style, and the two programming communities have legitimate
differences of style.
> So Scheme's silly
> knee-jerk reaction to set! is the same as the knee-jerk reaction to goto
> -- failure to understand when it has its uses causes a religious response
> to its presence.
Depends on the context. set! is often exactly the right thing; Scheme
programmers who exert weird contortions to avoid it are certainly
making a mistake. goto is perfectly reasonable in C code too.
I would never say something like "never use set!"; I'd say (in accord
with usual Scheme style) "you get clearer Scheme programs if you only
use set! where it's really necessary--which is usually when you are
implementing some kind of state-preserving object".
> And considering all the venomous crap that Scheme freaks pour over the
> real Lisp, I think we should stay away from Northern Ireland-like ways to
> deal with our feeling "insulted" by what other people say.
Well, I wasn't insulted, I just said it seemed like you wanted an
argument--which seems true indeed.
You seem to have a common pattern here: you post something really
provocative, you accuse someone else of trolling when you were the
first really provocative poster, etc, etc.
It may be the only option for me here is to just skip your posts
entirely, but I'd hate to do that, because amidst the 10% of venom is
90% of very interesting elucidating stuff.
I haven't said any "venomous crap" against "the real Lisp" (which is,
of course, Maclisp) :). I haven't said anything venomous against that
other PL/I Lisp (you know, Common Lisp). Actually, the first edition
of Common Lisp was a really nifty achievement, but the later stuff is
baffling to me. It's an issue of style though, unlike many, I don't
have any particular zealoutry to convince everyone that my way is the
only true way.
Thomas
Erik Naggum
| Scheme is usually represented as one dialect of Lisp. comp.lang.lisp
| *predates* Common Lisp, however. It seems to me that comp.lang.lisp
| should therefore be for all Lisps (and principally for those in
| current use, of course).
The nature and process of newsgroup splits dictates that if you get a
forum for yourself, you do _not_ bother the general community.
comp.lang.scheme decided to make have own community, and they should be
happy there instead of wanting _two_: One for your own little pet
language, and for the the general "Lisp" that you refuse to recognize
that you are no longer a member of by virtue of your own forum.
The same goes for Dylan, but we have _thankfully_ been relieved of D*lan
propaganda, lately.
| Well, I wasn't insulted, I just said it seemed like you wanted an
| argument--which seems true indeed.
I respond to your accusation that I want an insult battle. Do not use a
rejection of your position as proof that it was true. Such dishonesty is
usually reserved for extreme and ultra-conservative politicians, not
people who have honest intentions with what they do.
Some people I have argued against in the past have a very serious problem
seeing a difference between my arguing against what they argue for and my
arguing for what they argue against. I suggest you think this over and
make sure you know what people are actually arguing for and against. If
you have a philosoophy background, this difference should be _really_
easy to see.
| You seem to have a common pattern here: you post something really
| provocative, you accuse someone else of trolling when you were the first
| really provocative poster, etc, etc.
Really? I wrote:
> set! is bad form. setf is not. Just another one of those differences
> between real Lisps like Common Lisp and toy lisps like Scheme.
after _you_ had opened up for a comparison between Common Lisp and Scheme
with a goddamn smiley, but when I joke back, you find it "really
provocative", and _you_ insult me with something so stupid as this:
| Ah, so this is an insult battle. Not interested here.
Could it _possibly_ be that you were the first to go hostile here, and
that you are so blind to your own actions that you are _never_ at fault?
There are a lot of people out there who have deep psychological barriers
to accepting that they behave badly in some way and who defend themselves
by accusing the other party of everything that could possibly apply to
themselves, and who even play the stupid mirror game, but the refusal to
consider that the other party is at fault is _not_ the moronic argument
that one is not. You have to think in such terms to even arrive at the
idea that that is what other people do. If you are only used to such
people, I pity you, but a _little_ room for a balanced view of things
_should_ be available even in the most prejudiced who really need to
regard themselves as "good guys" _all_ the time.
The biggest, if not the _only_, problem on USENET is that people need to
defend themselves, usually because someone thinks that they defend
themselves best by accusing somebody of something completely outlandish
that they never expressed, implied, or opened up to be inferred.
| I haven't said any "venomous crap" against "the real Lisp" (which is, of
| course, Maclisp) :). I haven't said anything venomous against that other
| PL/I Lisp (you know, Common Lisp).
Why is _this_ not "really provocative"? You are in a forum where people
are interested in Common Lisp in particular, yet you go on and on with
your stupid insults towards Common Lisp, but as soon as I have a little
fun with your toy lanauge, you find it "really provocative" and go nuts?
Are you for real?
| Actually, the first edition of Common Lisp was a really nifty
| achievement, but the later stuff is baffling to me. It's an issue of
| style though, unlike many, I don't have any particular zealoutry to
| convince everyone that my way is the only true way.
"Actually" is usually reserved for facts, not biased opinions.
Regardless of what you _feel_, it is probably smart to avoid provoking
people in the forum where people expressly congegrate to enjoy what you
do not. This is why I poke fun at Scheme and XML and Perl and C++ _here_
-- not in their newsgroups. Do you grasp this difference? Can you
_quit_ being so sensitive about your stupid toy language when you are not
in _its_ particular forum and community? Of _course_ people have a right
to think Scheme sucks here -- you guys got your own newsgroup so you
could discuss Scheme without fighting with real Lispers.
Thomas Bushnell, BSG
> The biggest, if not the _only_, problem on USENET is that people need to
> defend themselves, usually because someone thinks that they defend
> themselves best by accusing somebody of something completely outlandish
> that they never expressed, implied, or opened up to be inferred.
I'm happy with a rule that nobody ever needs to defend themselves.
It goes along with a rule against thin skins and so forth.
Bruce Hoult
wrote:
> The nature and process of newsgroup splits dictates that if you get a
> forum for yourself, you do _not_ bother the general community.
>
> comp.lang.scheme decided to make have own community, and they should be
> happy there instead of wanting _two_: One for your own little pet
> language, and for the the general "Lisp" that you refuse to recognize
> that you are no longer a member of by virtue of your own forum.
>
> The same goes for Dylan, but we have _thankfully_ been relieved of D*lan
> propaganda, lately.
>
> [...]
>
> Of _course_ people have a right
> to think Scheme sucks here -- you guys got your own newsgroup so you
> could discuss Scheme without fighting with real Lispers.
So, by logical extension, I take it that you feel users of Franz Lisp
and Macintosh Common Lisp do not belong here and should not discuss
things with real Lispers?
Or, conversely, that if the groups comp.lang.lisp.scheme and
comp.lang.lisp.dylan had been proposed and passed, that discussion of
those would then be welcome here?
-- Bruce
Kenny Tilton
Twice in as many days! No one not interested makes this post.
We need a design pattern for this, and I have to credit Woodward &
Bernstein for the original "non-denial denial". But it seems the NG
equivalent arrow goes the other way, we've had a continuing
con-continuation and an interested lack of interest.
Needless to say, I'm not going to say anything about this.
Paul Foley
> Erik Naggum <er...@naggum.net> writes:
>> The key was the difference between the communities. Scheme is a toy seen
>> from Common Lisp. This is a Common Lisp forum. Whatever Scheme freaks
>> need to disparage in order to feel good about Perl, no, wait, Scheme, is
>> trolling in comp.lang.lisp. I find it odd that you did not recognize
>> that you were trolling to begin with, and only got "insulted" when you
>> got a response in kind.
> Scheme is usually represented as one dialect of Lisp. comp.lang.lisp
> *predates* Common Lisp, however.
No it doesn't.
The first post to comp.lang.lisp was in November of 1986; _Common
Lisp, The Language_ was published in 1984.
> It seems to me that comp.lang.lisp
> should therefore be for all Lisps (and principally for those in
> current use, of course).
It is. Common Lisp is the only one in current common use, except for
specialized implementations in Emacs and AutoCAD, etc., which have
their own groups. [Scheme, of course, without regard to how it's
"usually represented" (i.e., by Schemers), isn't a Lisp]
--
Oh dear god. In case you weren't aware, "ad hominem" is not latin for
"the user of this technique is a fine debater."
-- Thomas F. Burdick
(setq reply-to
(concatenate 'string "Paul Foley " "<mycroft" '(#\@) "actrix.gen.nz>"))
Thomas Bushnell, BSG
> > Scheme is usually represented as one dialect of Lisp. comp.lang.lisp
> > *predates* Common Lisp, however.
>
> No it doesn't.
>
> The first post to comp.lang.lisp was in November of 1986; _Common
> Lisp, The Language_ was published in 1984.
Oh, that's just an artifact of the Great Renaming, which was 1986-7.
comp.lang.lisp is the new name of the old net.lang.lisp. The first
message was there can be found at
http://groups.google.com/groups?hl=en&group=net.lang.lisp&scoring=d&as_drrb=b&as_mind=1&as_minm=1&as_miny=1981&as_maxd=10&as_maxm=6&as_maxy=1982&selm=anews.Aucbarpa.997
And is dated 1982-03-27 23:56:29 PST.
It's by John Foderaro. The first sentence is:
"The net.lang.lisp newsgroup is for the discussion of any and all lisp
dialects."
> It is. Common Lisp is the only one in current common use, except for
> specialized implementations in Emacs and AutoCAD, etc., which have
> their own groups. [Scheme, of course, without regard to how it's
> "usually represented" (i.e., by Schemers), isn't a Lisp]
Well, I typed "lisp faq" into google. The very first hit was a faq at
cs.cmu.edu, and question 1-1 says "What is the difference between
Scheme and Common Lisp". The answer begins "Scheme is a dialect of
Lisp that stresses...." The same faq occurs many places on the web as
it happens, and is sometimes cited as the "old comp.lang.lisp faq".
I also found http://www-jcsu.jesus.cam.ac.uk/~csr21/lispfaq.html. It
has the more cagey "Scheme is a member of the greater family of Lisp
languages", and suggest that conversations like the present one are
pointless. (Before Erik Naggum gets upset, it was he, not me, that
insisted that there must be some rigid demarcation between Scheme and
"true lisp", whatever that is.)
Kenny Tilton
(mapcar #'(lambda (x)
(setf gimp (list elm x))
(if (apply p gimp)...
;
; ok, i see now: you are really just testing (<predicate> elm x), so
; you could just say (when (funcall p elm x)...notice i used WHEN for a
minor
; clarity boost over (if <test> <only-the-true-branch>)
;
; so now...
(defun insert-n-sort (p elm lis)
(mapcar #'(lambda (x)
(when (funcall p elm x)
(setf...
;
; the spec said LIS was already sorted (I am guessing by P) so
; there is no need for a SETF, you just have to return whatever you whip
up to
; insert elm in the list, using RETURN-FROM insert-n-sort
;
(defun insert-n-sort (p elm lis)
(mapcar #'(lambda (x)
(when (funcall p elm x)
(return-from insert-n-sort
(append
(append
;
; no big deal, but append takes multiple (&rest) args, so one will do:
;
(defun insert-n-sort (p elm lis)
(mapcar #'(lambda (x)
(when (funcall p elm x)
(return-from insert-n-sort
(append
(subseq lis 0 (position x lis))
(list elm)
;
; no big deal again, but you may as well just say (cons elm <the
rest>)...
; not sure even which is clearer. anyway, i'd save a cons cell and code
up...
;
(defun insert-n-sort (p elm lis)
(mapcar #'(lambda (x)
(when (funcall p elm x)
(return-from insert-n-sort
(append
(subseq lis 0 (position x lis))
(cons elm (subseq lis (position x lis)
(length lis)))))))
lis))
;
; we are forced into the needless effort of position and subseq calls
because mapcar
; hands just the car of a cons cell to the mapping function, so when you
find the
; insertion point you do not know where you are. maplist passes each
cons
; cell to the mapping function
;
(defun insert-n-sort (p elm lis)
(maplist #'(lambda (lis-remaining)
(when (funcall p elm (car lis-remaining))
;
; the bad news is we only know what comes after (not
before) the insertion point,
; but if we understand cons cells (the point of this
exercise?) we
; can splice in place:
;
(setf (cdr lis-remaining)
(cons (car lis-remaining) (cdr lis-remaining)))
(setf (car lis-remaining) elm)
;
; we be jammin
;
(return-from insert-n-sort lis)))
lis)
;
; predicate was never satisfied if we get here, so elm "loses" and
goes to end
;
(nconc lis (list elm)))
Two things: the above is destructive; it changes the list received.
So does SORT, so maybe that is OK.
Second, if the point of this was for you to master cons cells (which I
suspect since you were
told not to use SORT) then forget you ever saw the splicing bit and try
to work
it out for yourself. I recommend drawing pictures of cons cells at first
to make this much
easier.
Paul Foley
> Paul Foley <myc...@actrix.gen.nz> writes:
>> > Scheme is usually represented as one dialect of Lisp. comp.lang.lisp
>> > *predates* Common Lisp, however.
>>
>> No it doesn't.
>>
>> The first post to comp.lang.lisp was in November of 1986; _Common
>> Lisp, The Language_ was published in 1984.
> Oh, that's just an artifact of the Great Renaming, which was 1986-7.
> comp.lang.lisp is the new name of the old net.lang.lisp.
I know that; you didn't say "net.lang.lisp predates Common Lisp",
though.
--
Qui beneficium dedit, taceat; narret qui accepit -- Seneca
Wade Humeniuk
"TejimaNoHimitsu" <bl...@test.com> wrote in message
news:0fbn8us36rts6j6oc...@4ax.com...
>
> (defun insert-n-sort (p elm lis)
> (mapcar #'(lambda (x)
> (setf gimp (list elm x))
> (if (apply p gimp)
> (subseq lis 0 (position x lis))
> (subseq lis (position x lis)
> (length lis))
> )))
>
> )
> timp)
>
>
> The above function is supposed to take a predicate, a number, and a
> sorted list of numbers and insert elm into lis at the proper spot
>
> (insert-n-sort #'< 3 '(2 4 6 8))
>
> You should get
>
> (2 3 4 6 8) back.
If recursion is acceptable you might try something like,
(defun insert-n-sort (predicate element list)
(cond
((null list) (cons element list))
((and (funcall predicate element (car list))
(not (funcall predicate (car list) element)))
(cons element list))
(t
(cons (car list) (insert-n-sort predicate element (cdr list))))))
However this solution is not complete. I am not sure line 18 is something
you want the function to be capable of doing unless the numbers are sorted
in descending order..
CL-USER 17 > (insert-n-sort '< 7 '(2 4 5 6 8 10))
(2 4 5 6 7 8 10)
CL-USER 18 > (insert-n-sort '> 7 '(2 4 5 6 8 10)) ;; wrong answer
(7 2 4 5 6 8 10)
CL-USER 19 >
Wade
Erik Naggum
| So, by logical extension, I take it that you feel users of Franz Lisp
| and Macintosh Common Lisp do not belong here and should not discuss
| things with real Lispers?
Well, Franz Lisp is extinct, and the newsgroup is basically dead. Stuff
that is clearly about Macintosh Common Lisp should definitely go in their
own newsgroup.
Incidentally, have you seen Sam Steingold answer _every_ question about
CLISP with a suggestion to use the CLISP mailing list? This is OK with
you, but keeping your D*lan propaganda to comp.lang.dylan is not. Why?
| Or, conversely, that if the groups comp.lang.lisp.scheme and
| comp.lang.lisp.dylan had been proposed and passed, that discussion of
| those would then be welcome here?
I think you are nuts.
Kenny Tilton
TejimaNoHimitsu wrote:
>
> In all actuality, I don't think the point of this problem was the
> master cons cells.
Hmmm, then maybe your position/subseq stuff was what the prof will be
expecting. re-splicing conses will raise some eyebrows. but hey,
sometimes a student gets into their subject and wants to dig a little
deeper, and fer sher a Lisper often needs to think closely about conses.
BTW, it occurred to me that the maplist/return-from thing was in effect
doing this:
1) find the cons insertion point
2) splice in the new value
and that the MEMBER family returns conses, so... I also ducked a progn
in the splice by using a multiple-pair SETF, and punched up the data
names a little:
(defun insert-n-sort (p elm presorted-lis)
(let ((ip-cons (member-if (lambda (ps-elm)
(funcall p elm ps-elm))
presorted-lis)))
(if ip-cons
(setf
(cdr ip-cons) (cons (car ip-cons)
(cdr ip-cons))
(car ip-cons) elm)
(nconc presorted-lis (list elm))))
presorted-lis)
did you ever work out why your algorithm did not work? i forgot all
about that myself. hint: i have not confirmed this, but it looks as if
one of the enhancements i made last time just happened to fix the bug.
You might want to just fix your algorithm and turn that in, nothing
wrong with it, just classic coming-up-to-speed code.
--
Thomas Bushnell, BSG
> I know that; you didn't say "net.lang.lisp predates Common Lisp",
> though.
net.lang.lisp *is* comp.lang.lisp; only the name has changed.
Bruce Hoult
wrote:
> * Bruce Hoult <br...@hoult.org>
> | So, by logical extension, I take it that you feel users of Franz Lisp
> | and Macintosh Common Lisp do not belong here and should not discuss
> | things with real Lispers?
>
> Well, Franz Lisp is extinct, and the newsgroup is basically dead. Stuff
> that is clearly about Macintosh Common Lisp should definitely go in their
> own newsgroup.
>
> Incidentally, have you seen Sam Steingold answer _every_ question about
> CLISP with a suggestion to use the CLISP mailing list? This is OK with
> you, but keeping your D*lan propaganda to comp.lang.dylan is not. Why?
Why? Because I happen to think that there are topics of interest to all
people using Lisp-family languages, including Common Lisp, Emacs Lisp,
Dylan, Scheme, and Arc. So there should be somewhere where these topics
can be discussed. comp.lang.lisp is the obvious place for that. If you
disagree with this place, I invite you to name another.
Perhaps you'd like a place for the discussion of Common Lisp only. Then
create one. Call it comp.lang.common-lisp or whatever.
I'll note that comp.lang.clos already exists. That's clearly a Common
Lisp only place, though perhaps the name suggests a more restrictive
range of topics are welcome than the *whole* of Common Lisp. On the
other hand, it gets far less traffic than any of the other groups
discussed -- I see 36 posts in the last four months, of which five were
not spam or cross posted -- so I doubt that anyone would be too upset
with more general CL discussion there.
> | Or, conversely, that if the groups comp.lang.lisp.scheme and
> | comp.lang.lisp.dylan had been proposed and passed, that discussion of
> | those would then be welcome here?
>
> I think you are nuts.
I like you too.
-- Bruce
Thomas A. Russ
> > 1) Is there any way to test for option arguments in a function? For
> > example, if I do:
> >
> > (defun test (list1 list2 &key k)
> >
> > is there a way to test in the body of that function whether or not k
> > exists? If k doesn't exist, the value is NIL, but I don't know how to
> > compare if something's value is NIL. I know I should know, but I
> > don't. I would use an if statement, but k is either NIL or the key
> > value....
> >
Hmm, I seem to be missing some articles in this thread from my
newsreader, but I didn't see this particular one answered.
The answer is that one may specify more complicated patterns for keyword
(and optional) parameters. In particular, the pattern
(<name> <default-value> <value-supplied-p>)
solves exactly your problem:
(defun test (list1 list2 &key (k nil k-supplied-p))
...)
will have k-supplied-p bound to T if a value was supplied in the call
and it will be bound to NIL if no value was supplied (and the default
value was used instead).
--
Thomas A. Russ, USC/Information Sciences Institute t...@isi.edu
Coby Beck
"Thomas A. Russ" <t...@sevak.isi.edu> wrote in message
news:ymiofhu...@sevak.isi.edu...
I think every answer to this used the same k-supplied-p variable name. Just
in case the OP reads too much into that coincidence I will point out you can
call it whatever you wish.
--
Coby Beck
(remove #\Space "coby 101 @ bigpond . com")
Erik Naggum
| Why? Because I happen to think that there are topics of interest to all
| people using Lisp-family languages, including Common Lisp, Emacs Lisp,
| Dylan, Scheme, and Arc. So there should be somewhere where these topics
| can be discussed. comp.lang.lisp is the obvious place for that. If you
| disagree with this place, I invite you to name another.
I disagree with this, but not on your premises. People who come here to
preach about "how things are done in D*lan" or "Scheme is elegant and
does it right" are expressly _not_ trying to aim for that "common ground"
between all Lisp members, but are idiotic trolls you abuse the ability to
post anything to any newsgroup even though they have their own playpens
where such opinionated huffing and puffing is accepted. comp.lang.lisp
is not a union of comp.lang.dylan.advocacy or comp.lang.scheme.advocacy.
| Perhaps you'd like a place for the discussion of Common Lisp only. Then
| create one. Call it comp.lang.common-lisp or whatever.
I am sure such a proposal would get your vote. Would you promise to keep
your D*lan propaganda out of comp.lang.common-lisp? And could we kick
every single Scheme freak in the groin if they invaded the newsgroup with
their stupid Lisp-1 and "functional" and "elegance" rhetoric? Then
comp.lang.lisp could be that "common ground" between D*lan and Scheme.
However, the last time I tried to figure out if such a commonality even
could exist, it looked so much like a black hole I expected a baby
universe to pop out.
The notion that the "Lisp family" would enjoy a family reunion is sick.
Much like people who have gone their separate ways and denouncing their
heritage when making things "better" in their own particular view, D*lan
and Scheme have _departed_ from the Lisp family and have made their own
small families, instead. This is healthy. You don't see Java and C++
and C# folks fill up comp.lang.c because of their "heritage", do you?
What _is_ it about "Lisp" that makes D*lan and Scheme freaks still want
to be a member of the family? All you guys do is denounce Common Lisp.
You certainly do _not_ discuss issues that are common to the Lisp family.
Brian P Templeton
> Kent M Pitman <pit...@world.std.com> writes:
>
>> An assignment is not a side-effect.
>
> Um, sometimes an assignment is equivalent to side-effect free form,
> tis true--such is the case with your examples.
>
> But in general, assignments introduce side-effects. In general, the
> following two are *not* equivalent:
>
> (begin
> (set! x 3)
> ...)
>
> (let ((x 3))
> ...)
>
> The latter is side-effect free; the former is not. Functions which
> only include side-effect free forms have values which depend purely on
> their arguments; this is not (in general) true if you use set!.
>
> I belabor this only because in the Scheme world, at least, this is
> exactly the normal definition of a side-effect.
>
> Right--some uses of set! are side-effect free. But all uses of let
> are always side-effect free.
>
What about
(let ((x (set! y 3)))
...)
? That's not side-effect free :)
--
BPT <b...@tunes.org> /"\ ASCII Ribbon Campaign
backronym for Linux: \ / No HTML or RTF in mail
Linux Is Not Unix X No MS-Word in mail
Meme plague ;) ---------> / \ Respect Open Standards
Thomas Bushnell, BSG
> I disagree with this, but not on your premises. People who come here to
> preach about "how things are done in D*lan" or "Scheme is elegant and
> does it right" are expressly _not_ trying to aim for that "common ground"
> between all Lisp members, but are idiotic trolls you abuse the ability to
> post anything to any newsgroup even though they have their own playpens
> where such opinionated huffing and puffing is accepted. comp.lang.lisp
> is not a union of comp.lang.dylan.advocacy or comp.lang.scheme.advocacy.
Agreed. comp.lang.lisp is not the place to troll for the superiority
of one Lisp dialect over another. But that's true whichever dialect
you choose.
I'm sorry some past people have posted nasty things "in the name of
Scheme". Such things are bad.
But it's just as bad to post trolls about "why Common Lisp is the best
thing ever".
> What _is_ it about "Lisp" that makes D*lan and Scheme freaks still want
> to be a member of the family? All you guys do is denounce Common Lisp.
> You certainly do _not_ discuss issues that are common to the Lisp family.
Huh?
Let's see. Common Lisp people on comp.lang.lisp spend lots of energy
denegrating Scheme.
I've never seen *any* posts on comp.lang.scheme that are concerned to
denegrate Common Lisp.
Thomas
Thomas Bushnell, BSG
> What about
> (let ((x (set! y 3)))
> ...)
> ? That's not side-effect free :)
I think you know what the answer to that question is, right?
Bruce Hoult
wrote:
> * Bruce Hoult <br...@hoult.org>
> | Why? Because I happen to think that there are topics of interest to all
> | people using Lisp-family languages, including Common Lisp, Emacs Lisp,
> | Dylan, Scheme, and Arc. So there should be somewhere where these topics
> | can be discussed. comp.lang.lisp is the obvious place for that. If you
> | disagree with this place, I invite you to name another.
>
> I disagree with this, but not on your premises. People who come here to
> preach about "how things are done in D*lan" or "Scheme is elegant and
> does it right" are expressly _not_ trying to aim for that "common ground"
> between all Lisp members, but are idiotic trolls you abuse the ability to
^^^
How very Freudian.
> post anything to any newsgroup even though they have their own playpens
> where such opinionated huffing and puffing is accepted. comp.lang.lisp
> is not a union of comp.lang.dylan.advocacy or comp.lang.scheme.advocacy.
You confuse information and comparison with unthinking advocacy.
Do I think there are things done better in Dylan than in CL? Sure.
Being designed later and with hindsight it would be astouding if there
weren't. Do I think there are things done better in CL than in Dylan?
That's one reason I'm here: to find out. I've already taken one thing
that I think CL does better and implemented it in Gwydion Dylan -- that
is the ability to have a loop control clause that abbreviates "foo = bar
then baz" to just "foo = bar" where bar and baz happen to be the same
expression.
I have no doubt there will be more in future.
> | Perhaps you'd like a place for the discussion of Common Lisp only. Then
> | create one. Call it comp.lang.common-lisp or whatever.
>
> I am sure such a proposal would get your vote.
Yes, it would.
> Would you promise to keep
> your D*lan propaganda out of comp.lang.common-lisp? And could we kick
> every single Scheme freak in the groin if they invaded the newsgroup with
> their stupid Lisp-1 and "functional" and "elegance" rhetoric? Then
> comp.lang.lisp could be that "common ground" between D*lan and Scheme.
> However, the last time I tried to figure out if such a commonality even
> could exist, it looked so much like a black hole I expected a baby
> universe to pop out.
>
> The notion that the "Lisp family" would enjoy a family reunion is sick.
> Much like people who have gone their separate ways and denouncing their
> heritage when making things "better" in their own particular view, D*lan
> and Scheme have _departed_ from the Lisp family and have made their own
> small families, instead.
Erik, you very often talk about this great gulf between CL people on the
one side and Scheme and Dylan people on the other, and how Scheme and
Dylan people hate CL (and, presumably, each other). I've looked for it
but in fact you are the *only* person I've ever seen who has expressed
such hostility.
Quite the contrary, there are a number of obvious examples of people who
are or have been active in multiple languages. The creator of Scheme
had a hand in the definition of Common Lisp. Kent Pitman has done work
with both. Many Dylan people have been prominent in Common Lisp and I
can think of several who post here fairly regularly.
If there are in fact people involved around the time of the creation of
Dylan who denounced Common Lisp then they are either keeping very quiet
about it, or else are no longer active in the Dylan community.
Perhaps you have better information, but the oldest information I have
is the 1992 Dylan book which Apple sent for free to anyone who asked for
it. Allow me to quote from the preface:
Apple already has one OODL product: Macintosh Common Lisp. Dylan
is intended to complement Common Lisp, not to replace it. Common
Lisp is a rich environment defined by a standard and available in
compatible implementations on a broad range of platforms. Dylan
is lean and stripped down to a minimum feature set. At present
Dylan is not available on any platform (outside Apple), but is
intended to run on a wide variety of machines, including very small
machines that don't have the horsepower to support a modern Common
Lisp. Common Lisp is aimed primarily at the Lisp community, while
Dylan is accessible to application developers unfamiliar with Lisp.
Common Lisp is oriented more towards exploratory programming with
delivery capability, while Dylan is oriented more towards delivery
with exploratory capability.
Some things in the world have changed since then -- primarily that all
machines have gotten bigger and faster, and that CL compilers such as
CMUCL have gotten much better -- but I think the last sentence still
applies even today.
I don't see any hostility towards Common Lisp. There was a decision --
not taken lightly -- that differeing goals were best met by creating a
new language with much in common with CL.
There does, on the other hand, seem to be a lot of lingering hostility
from those in the CL community who think that the effort would have been
better spent on developing CL itself, rather than dividing efforts.
This is very visible even today, with the recent denouncement from
several quarters of a Common Lisp stalwart such as Paul Graham.
> What _is_ it about "Lisp" that makes D*lan and Scheme freaks still want
> to be a member of the family?
It's not a question of *want*. These languages *are* closely related
members of the same family -- far more closely related to each other
than any of them is to any other language.
What is it that makes you *want* to deny that?
> All you guys do is denounce Common Lisp.
> You certainly do _not_ discuss issues that are common to the Lisp family.
You're welcome to your opinion, but I believe it to be false.
-- Bruce
Thomas Bushnell, BSG
> What about
> (let ((x (set! y 3)))
> ...)
> ? That's not side-effect free :)
It also fails to give X any determinate value.
Erik Naggum
| But it's just as bad to post trolls about "why Common Lisp is the best
| thing ever".
I disagree. Among the remaining Lisps, it is the best thing ever. Those
who have thought otherwise, have left for other pastures, like D*lan and
Scheme and Arc. There are not "better" than Common Lisp by a long shot.
| Let's see. Common Lisp people on comp.lang.lisp spend lots of energy
| denegrating Scheme.
No, they don't. They spend some time rejecting the Scheme propaganda. I
think you need to pay attention to who is arguing for and against things.
| I've never seen *any* posts on comp.lang.scheme that are concerned to
| denegrate Common Lisp.
That is because they post it here! Christ, are you trolling or what?
Thomas Bushnell, BSG
> * tb+u...@becket.net (Thomas Bushnell, BSG)
> | But it's just as bad to post trolls about "why Common Lisp is the best
> | thing ever".
>
> I disagree. Among the remaining Lisps, it is the best thing ever. Those
> who have thought otherwise, have left for other pastures, like D*lan and
> Scheme and Arc. There are not "better" than Common Lisp by a long shot.
You know, I haven't seen anybody but you arguing why one must be
better than the others. *ONLY* *YOU*. Nobody else is saying any such
thing.
You seem concerned that there are lots of Scheme people saying "Scheme
is the only thing worth considering", but I can't see any of them.
Nary a one. But what I *do* is you arguing, every chance you get,
that Common Lisp is the One True Lisp Dialect.
> | Let's see. Common Lisp people on comp.lang.lisp spend lots of energy
> | denegrating Scheme.
>
> No, they don't. They spend some time rejecting the Scheme propaganda. I
> think you need to pay attention to who is arguing for and against things.
I haven't seen any Scheme propaganda.
> That is because they post it here! Christ, are you trolling or what?
Who is this "they"? Can we see names or Message-ID's or something?
Thomas
Erik Naggum
| You confuse information and comparison with unthinking advocacy.
I wish I did. If I want to learn about D*lan, I read comp.lang.dylan.
If I wish to learn about Scheme, I read comp.lang.scheme. If I do not
wish to learn about either, I do not read these newsgroup, but thanks to
people who have no concept of what other people would like to discuss
where, I have to wade through one "comparison" after another and much
more "information" about Scheme freaks and their preferences than I would
like to suffer.
| I've looked for it but in fact you are the *only* person I've ever seen
| who has expressed such hostility.
This is sheer nonsense.
| Quite the contrary, there are a number of obvious examples of people who
| are or have been active in multiple languages.
You cannot portray a city as "safe" by pointing to how many nice people
live in it, and it is quite amazing that you have to go on such a stupid
propaganda trip.
| The creator of Scheme had a hand in the definition of Common Lisp. Kent
| Pitman has done work with both. Many D*lan people have been prominent in
| Common Lisp and I can think of several who post here fairly regularly.
This proves exactly nothing.
| There does, on the other hand, seem to be a lot of lingering hostility
| from those in the CL community who think that the effort would have been
| better spent on developing CL itself, rather than dividing efforts.
Perhaps you would arrive at a less self-serving conclusion if you could
try to remember how D*lan dropped its sensible syntax?
| This is very visible even today, with the recent denouncement from
| several quarters of a Common Lisp stalwart such as Paul Graham.
Paul Graham is a Common Lisp _stalwart_? He has spent lots of time and
effort telling the world he does _not_ like Common Lisp, why loop is bad
and wrong, and done a remarkable job of re-creating Scheme in Common Lisp.
| It's not a question of *want*. These languages *are* closely related
| members of the same family -- far more closely related to each other
| than any of them is to any other language.
|
| What is it that makes you *want* to deny that?
Their remarkably important differences.
| You're welcome to your opinion, but I believe it to be false.
Of course you do.
Erik Naggum
| You know, I haven't seen anybody but you arguing why one must be better
| than the others. *ONLY* *YOU*. Nobody else is saying any such thing.
Nonsense. You keep arguing for why Scheme is better than Common Lisp.
| You seem concerned that there are lots of Scheme people saying "Scheme is
| the only thing worth considering", but I can't see any of them. Nary a
| one. But what I *do* is you arguing, every chance you get, that Common
| Lisp is the One True Lisp Dialect.
Really? Where? Perhaps you can quote me on this?
If you cannot find me actually saying that, perhaps you need to think a
little about how you arrived at this ludicrous conclusion? Perhaps you
can think a litle about how the annoying Scheme propagandists keep
arguing that Scheme is, precisely, better than Common Lisp by virtue of
some individual feature, like, _your_ preference for call/cc, for
instance.
I thought you said you had some training in philosophy, yet you keep
making trivial mistakes, like not being able to distinguish arguments
against what you are for from arguments for what you are against, and now
this amazing lack of intellectual honesty in differentiating between what
you see and what you conclude must have been. People who impute intent
to other people and think they have _seen_ this intent are hopelessly
lost in their own view of the world -- because they first have to realize
that they do _not_ observe anybody's intent, they have concluded it from
what they have seen and what _they_ have brought to the conclusions.
I want a place where we can discuss Common Lisp issues without having to
wade through tons of negative commentary about Common Lisp. You
obviously fail to understand how your _own_ comments are negative and
could use and sometimes _require_ a rejection of your arguments. What is
this obnoxious nonsense about comparing Common Lisp to PL/1, for instance?
You, of all people, who get incensed when I ridicule Scheme a little,
do in fact spend a lot of your time denigrating Common Lisp in this forum.
| Who is this "they"? Can we see names or Message-ID's or something?
You, Thomas Bushnell.
Thomas Bushnell, BSG
> * Thomas Bushnell, BSG
> | You know, I haven't seen anybody but you arguing why one must be better
> | than the others. *ONLY* *YOU*. Nobody else is saying any such thing.
>
> Nonsense. You keep arguing for why Scheme is better than Common Lisp.
Um, no, I think I once mentioned that I "require" call/cc to count as
a non-toy language as a jibe in response to your frequent claim that
Scheme is a toy.
I think both Scheme and Common Lisp are good things; I have no clue
what would ever be gained if one were "proven" better than the other.
> | You seem concerned that there are lots of Scheme people saying "Scheme is
> | the only thing worth considering", but I can't see any of them. Nary a
> | one. But what I *do* is you arguing, every chance you get, that Common
> | Lisp is the One True Lisp Dialect.
>
> Really? Where? Perhaps you can quote me on this?
Um, perhaps because of your insistence that the only proper topic for
comp.lang.lisp is Common Lisp?
> If you cannot find me actually saying that, perhaps you need to think a
> little about how you arrived at this ludicrous conclusion? Perhaps you
> can think a litle about how the annoying Scheme propagandists keep
> arguing that Scheme is, precisely, better than Common Lisp by virtue of
> some individual feature, like, _your_ preference for call/cc, for
> instance.
Um, no, I didn't say Scheme was "better" in the abstract. Scheme has
a nifty feature that Common Lisp lacks. Whether that makes Scheme
"better" or not is a foolish question, since both Scheme and Common
Lisp have strengths and weaknesses, and I don't have any particular
interest in which is "better".
> You
> obviously fail to understand how your _own_ comments are negative and
> could use and sometimes _require_ a rejection of your arguments. What is
> this obnoxious nonsense about comparing Common Lisp to PL/1, for instance?
Ah, no, I only compare Common Lisp to PL/I when Scheme is called a
toy. Part of that is because calling languages "toys" way predates
you; indeed, IIRC, the first people to adopt that charming little term
were PL/I users who thought Algol-like languages were mere toys, not
useful for any serious programming.
I'm entirely happy to institute a new rule: nobody insults any other
language at all; I'll drop the PL/I reference, and you can drop the
toy reference. That would please me no end.
> | Who is this "they"? Can we see names or Message-ID's or something?
>
> You, Thomas Bushnell.
Let's see the Message-IDs now. Put up or shut up.
Kent M Pitman
> Ah, no, I only compare Common Lisp to PL/I when Scheme is called a toy.
Am I the only one who remembers PL/1 fondly?
Maybe it's again an issue like Lisp : Common Lisp :: PL/1 : Multics
PL/1 since I happen to have used Multics PL/1 and have found it quite
powerful. I liked Lisp better, of course, but I didn't see anything
particularly wrong with PL/1. Somewhere along the way, it has come to
be a metaphor for things bad. Seems a pity. My memory of it is a lot
more favorable than my more recent memories of C.
Erik Naggum
| Um, no, I think I once mentioned that I "require" call/cc to count as
| a non-toy language as a jibe in response to your frequent claim that
| Scheme is a toy.
Yet you were insulted by and found my "jibe" strongly provocative.
Something is clearly amiss here.
| I think both Scheme and Common Lisp are good things; I have no clue
| what would ever be gained if one were "proven" better than the other.
The point is not which is better, which where people are allowed to
believe so. Scheme freaks have comp.lnag.scheme as their haven of belief
in Scheme's superiority, Common Lisp programmers have comp.lang.lisp, and
D*lan users have comp.lnag.dylan. In _this_ newsgroup and _this_
community, we have a _right_ to think that what we use is the best of all
possible things around, It is that right that is continually challenged
by naysayers and fault-finders who come from D*lan and Scheme camps in
particular.
| > | You seem concerned that there are lots of Scheme people saying
| > | "Scheme is the only thing worth considering", but I can't see any of
| > | them. Nary a one. But what I *do* is you arguing, every chance you
| > | get, that Common Lisp is the One True Lisp Dialect.
| >
| > Really? Where? Perhaps you can quote me on this?
|
| Um, perhaps because of your insistence that the only proper topic for
| comp.lang.lisp is Common Lisp?
So you admit that I have never actually said anything _like_ what you
_lie_ about that I have done. You are intellectually dishonest, Thomas
Bushnell.
Your ability to draw conclusions does not give you any right to make
claims about what _others_ have argued or said or meant or intended.
Keep these apart, will you? Where is your philosophical training if you
cannot even manage to distinguish your observations from your conclusions?
| Um, no, I didn't say Scheme was "better" in the abstract. Scheme has
| a nifty feature that Common Lisp lacks. Whether that makes Scheme
| "better" or not is a foolish question, since both Scheme and Common
| Lisp have strengths and weaknesses, and I don't have any particular
| interest in which is "better".
Why, then, do you keep posting about stuff that you know that people in
this community have expressly rejected as less valuable or even as abject
misfeatures? You are _trolling_, Thomas Bushnell.
| Ah, no, I only compare Common Lisp to PL/I when Scheme is called a toy.
Liar.
| Part of that is because calling languages "toys" way predates you;
| indeed, IIRC, the first people to adopt that charming little term were
| PL/I users who thought Algol-like languages were mere toys, not useful
| for any serious programming.
Memory of past ills is _such_ a boon for responding to what is at hand.
| I'm entirely happy to institute a new rule: nobody insults any other
| language at all; I'll drop the PL/I reference, and you can drop the toy
| reference. That would please me no end.
Once again, we see how one person needs to try to control another person
in order to behave wisely in his own terms. This is such a pattern with
you losers who do something bad and refuse to accept responsiblity for it.
I have no gripes with Scheme at all until and unless some Scheme freaks
fires up his propaganda engine. I do not read comp.lang.scheme because I
think Scheme really sucks as a language. I do not read comp.lang.perl
because I thin perl is the suckiest language on the planet. I do not
read comp.text.xml because those who work with XML are such uninspiring
dorks. There is sufficient room here to vent frustration with loser
languages like Perl and XML that nobody keeps telling anyone that both
are "really" Lisps -- Perl has a lot of Lisp nature, and XML is basically
only a highly elaborate s-expression syntax --
| > | Who is this "they"? Can we see names or Message-ID's or something?
| >
| > You, Thomas Bushnell.
|
| Let's see the Message-IDs now. Put up or shut up.
This, after you have lied and misrepsented me to no end, and you could
not even cough up a reference to your own claims about what I have said?
Such gall! Such chutzpah! Get lost, troll.
Bruce Hoult
wrote:
> * Bruce Hoult <br...@hoult.org>
> | You confuse information and comparison with unthinking advocacy.
>
> I wish I did. If I want to learn about D*lan, I read comp.lang.dylan.
> If I wish to learn about Scheme, I read comp.lang.scheme. If I do not
> wish to learn about either, I do not read these newsgroup, but thanks to
> people who have no concept of what other people would like to discuss
> where
You don't have to guess what people would like to discuss where.
Newsgroups have charters and FAQs which give this information.
> | I've looked for it but in fact you are the *only* person I've ever seen
> | who has expressed such hostility.
>
> This is sheer nonsense.
Denial is not refutation. And I'm not the only person who has noticed
this.
> | Quite the contrary, there are a number of obvious examples of people who
> | are or have been active in multiple languages.
>
> You cannot portray a city as "safe" by pointing to how many nice people
> live in it, and it is quite amazing that you have to go on such a stupid
> propaganda trip.
In fact nice people are precisely what makes a city safe. All cities
have some bad people. The difference between safe and unsafe cities
lies in how nice or otherwise the rest of the people are.
> | There does, on the other hand, seem to be a lot of lingering hostility
> | from those in the CL community who think that the effort would have been
> | better spent on developing CL itself, rather than dividing efforts.
>
> Perhaps you would arrive at a less self-serving conclusion if you could
> try to remember how D*lan dropped its sensible syntax?
That's a matter on which reasonable people can disagree. And if you're
not interested in Dylan then why do you care, anyway?
What is your objection to Dylan's syntax?
> | This is very visible even today, with the recent denouncement from
> | several quarters of a Common Lisp stalwart such as Paul Graham.
>
> Paul Graham is a Common Lisp _stalwart_? He has spent lots of time and
> effort telling the world he does _not_ like Common Lisp, why loop is bad
> and wrong, and done a remarkable job of re-creating Scheme in Common Lisp.
I guess I'm imagining books such as "ANSI Common Lisp" and "On Lisp",
and the fact that he made a fortune using Lisp.
Until the last year or so I never saw a bad word said about him.
> | It's not a question of *want*. These languages *are* closely related
> | members of the same family -- far more closely related to each other
> | than any of them is to any other language.
> |
> | What is it that makes you *want* to deny that?
>
> Their remarkably important differences.
Which are far fewer than their similarities.
-- Bruce
Carl Shapiro
> In article <32248909...@naggum.net>, Erik Naggum <er...@naggum.net>
> wrote:
> > Paul Graham is a Common Lisp _stalwart_? He has spent lots of time and
> > effort telling the world he does _not_ like Common Lisp, why loop is bad
> > and wrong, and done a remarkable job of re-creating Scheme in Common Lisp.
>
> I guess I'm imagining books such as "ANSI Common Lisp" and "On Lisp",
> and the fact that he made a fortune using Lisp.
Well, it seems that you haven't been paying attention.
"The good news is, it's not Lisp that sucks, but Common Lisp."
Anonymous
On Tue, 12 Mar 2002 04:23:57 GMT, Kent M Pitman <pit...@world.std.com>
wrote:
These endless battles ... seeing the comments regarding
net.lang.lisp, I just dug up this little piece from that ng - Stanley
Shebs responding to a remark by Olin Shivers, 1986-07-03:
" Hmmm, he sounds like a Schemer! Actually, the most ultimate and
purest Lisp dialect I know of is 3-Lisp, which is so clean and regular
that it makes any Scheme look like a kludge. Brian Smith pointed out
that (for instance) conses are used in a multitude of ways in most
Lisps, while in 3-Lisp conses are only used for function applications;
the "rail" data structure is used for lists/sequences. Quotes don't
"fall off" as a result of evaluation; as a result, one doesn't get the
Lisp oddity (+ 2 '3) => 5. Closures are ordinary data structures with
4 slots. Reflection gives one great power, in fact it hasn't really
been exploited yet. 3-Lisp is the way to go for true language purists.
stan"
Anyone for 3-Lisp?
Lars
-----= Posted via Newsgroups.Com, Uncensored Usenet News =-----
http://www.newsgroups.com - The #1 Newsgroup Service in the World!
-----== 90,000 Groups! - 19 Servers! - Unlimited Download! =-----
lars_lundback
does give a funny impression. If this one doesn't behave ...
Erik Naggum
| You don't have to guess what people would like to discuss where.
| Newsgroups have charters and FAQs which give this information.
What is keeping you from understanding that D*lan has its own newsgroup,
chartered and FAQ'ed to be the "home forum" for D*lan users? Why do you
have to keep posting here about how D*lan does its things? Do you not
trust those who would be interested in D*lan to find it on their own
accord so you have to constantly remind them of it, like some spamming
advertiser? What is it that you cannot understand about newsgroup
dynamics that makes you _fight_ for a right to annoy people who expressly
direct you to go back to your D*lan newsgroup? Why is this something you
feel you have a _right_ to do? How would someone be received over in
comp.lang.dylan if they answered every question with a Common Lisp
solution to a D*lan problem? The same goes for Scheme, for exactly the
same reason.
> This is sheer nonsense.
| Denial is not refutation.
This is rich. Nonsense cannot be refuted, you illiterate gnome.
| That's a matter on which reasonable people can disagree.
Yes, and those who think Nicklaus Wirth did it right are generally in
comp.lang.dylan and those who think John McCarth was right are generally
in comp.lang.lisp.
| What is your objection to Dylan's syntax?
Duh. That you dropped the fully parenthesized prefix syntax.
| I guess I'm imagining books such as "ANSI Common Lisp" and "On Lisp",
| and the fact that he made a fortune using Lisp.
Quit the moron act and THINK, goddamnit!
| Until the last year or so I never saw a bad word said about him.
Could be that he tilted only last year, or you that power of observation
leave a lot to be desired. The latter seem fairly obviously a problem.
| Which are far fewer than their similarities.
That is a matter upon which reasonable men can and do disagree.
In particular, why is it so important to you to _dismiss_ what I think,
and to try to _force_ me to accept your gospel as truth? I _reject_ what
you tell me about D*lan's "lispness". _Why_ do you have the facts and I
am wrong about this? I am not alone in this regard at all, either, as if
that mattered to anyone who can think, but numbers appear to matter to
you. D*lan is not a big winner in _any_ sense. So get used to the
rejection and find consolation among those who agree with you and accept
your choices. Over here in comp.lang.lisp we are in fact so tolerant of
you negative, disrespectful, rejecting miscreants that we even have to
fight you off because you seem to use each other as rationale for the
acceptance of your trolling and abuse of this forum for your ill-
conceived propaganda, completely disregarding the will of residents, and
the more they object to your behavior, the more you seek vindication for
your bad behavior and your counter-productive ways, and the more you seek
to blame those who do not want you to engage in inflammatory nonsense.
Of all the language newsgroups I read, comp.lang.lisp is the _only_ one
to suffer obnoxious bastards from other language camps who claim to have
a "right" to post their trolling and language wars (a.k.a. "information
and comparison") in another language's newsgroup. Most people know that
this is bad, but not D*lan and Scheme freaks. They must fight for their
right to troll and incense comp.lang.lisp. One has to wonder what kind
of inferiority complex has resulted in this desire to annoy people in a
hope to be recognized even after they have expressly distanced themselves
from those from whom they seek acceptance and recognition.
Thomas F. Burdick
Indeed, "On Lisp" is a great exercise in being a Lisp fan, but also a
great piece of CL-haterism.
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
Erik Naggum
| Am I the only one who remembers PL/1 fondly?
No. And I only used Subset G on PrimOS. (Some say it was even less than
Subset G. I never acquired the skills to tell any difference.)
| Somewhere along the way, it has come to be a metaphor for things bad.
The whole language was _huge_. I wasted a whole month's pay on the
language documentation, but it had many wonderful features. It was also
extremely hard to get an overview over and hard to learn to use properly.
I think it has gained its reputation from being so difficult from its
"reverse pointer" concept, which had a particular name I forget. It was
a true systems software language, however, and PrimOS was written in lots
of languages that interoperated very elegantly.
It is pretty pathetic that people need to ridicule both PL/1 and Common
Lisp at the same time. It appears that large language throw some people
off at an early stage and are considered bad by virtue of their size. I
have seen people become frightend of English because of the Oxford
English Dictionary in its full size, when they have only been exposed to
some simple English Learner's Dictionary or something equally trivial.
Perhaps it is some "fear of not mastering".
Thomas Bushnell, BSG
> | Which are far fewer than their similarities.
>
> That is a matter upon which reasonable men can and do disagree.
However, it's on one which you don't think disagreement is allowed.
Rather, you insist (loudly, rudely, continuously) that yours is the
only reasonable opinion, and that anyone who disagrees not only should
shut up, but should certainly not dare to broach their disagreement on
your personal stomping ground.
There is a newsgroup reserved for Scheme. There is *not* a newsgroup
reserved for Common Lisp. Perhaps there should be one; feel free to
start up the usual Usenet mechanism to create one.
The existing newsgroup for comp.lang.lisp is for all dialects of Lisp,
and I have never seen (in print) anyone claim that Scheme is not a
dialect of Lisp. You are the *only* person I've ever heard say such a
thing, actually.
Thomas
Thomas Bushnell, BSG
> You don't have to guess what people would like to discuss where.
> Newsgroups have charters and FAQs which give this information.
I gave a reference to the comp.lang.lisp "charter", actually, which
was the first message posted to net.lang.lisp back in 1982.
Thomas
Erik Naggum
Could you please stop lying about what I think?
| Rather, you insist (loudly, rudely, continuously) that yours is the
| only reasonable opinion, and that anyone who disagrees not only should
| shut up, but should certainly not dare to broach their disagreement on
| your personal stomping ground.
Could you please engage your brain long enough to understand that just
because I reject _one_ opinion, I make no such idiotic implication for
any other opinion? Yours is a classical case of "you can extrapolate in
any direction from a single data point". Dishonest, disrespectful, even
hateful, this is. Fuck you for being so unable to distinguish your own
feelings from what others think.
Your personal need to portray me as some kind of monster is a clear
indication of a psychotic break when you are under stress. Consult a
physician about this problem and get a grip on yourself and start dealing
with reality, not your twisted, deluded mental imagery.
Just because I loudly, rudely, continuously refute a claim that astrology
is just a dialect of astronomy or that behaviorism is "scientific" does
not mean that I have allowed only one opinion of what astronomy is or
what should be considered scientific. Why do you have a problem with
such a fanstastically simple and logical argument? Why do you have to
portray others like utter fools because _you_ lack the clear thinking
that keeps you out of trouble? I find this extremely provocative and
annoying. Nobody can be so mind-numbingly ignorant of the laws of logic
as to _believe_ that opposing one opinion means that one does not
tolerate "disagreement" or that one has the only answer. It is possible
to argue, strongly, that the moon is not made of cheese without any clue
as to the specific makeup of the moon. Likewise, the earth is not the
center of the universe, regardless of what is the center of the universe.
The detection of simple falsehoods does not require omniscience, except
in people lacking in education and thinking skills and who want the false
to be "allowed" on an equal footing with the true.
Once again, you show me that you lack the wherewithal to distinguish
between the negation of a negative (it does _not_ yield a positive!) and
the negation of a positive. What kind of philosophical background do you
_have_, when you have no clue about either negation or the distinction
between observation and conclusion? You sound immensely illiterate to me
when you make these fantastically stupid mistakes.
| The existing newsgroup for comp.lang.lisp is for all dialects of Lisp,
| and I have never seen (in print) anyone claim that Scheme is not a
| dialect of Lisp. You are the *only* person I've ever heard say such a
| thing, actually.
Paul Foley said it very recently in this newsgroup, you unobservant
mental slob. There have been discussions here about this in the past.
I was far from the only one to argue against "Scheme is a Lisp", for the
simple reason that Scheme freaks mean something different by it than the
more general Lisp community. "Scheme is not a Lisp" is true for a large
number of reasonable meanings of "Lisp". Scheme freaks have a real
problem with this, and, unsurprisingly, do not tolerate disagreement with
their stupid, stupid, stupid notion that Scheme and Lisp overlap in any
interesting way. They overlap in origin and history, and that's _it_.
I find it downright ridiculous that people who refuse to tolerate that I
express my opinion, conclude that I am wired the way they are, and only
have room for "One True Dialect" and have no room for disagreement, like
they do. I have no room for _falsehood_. People do not "disagree" with
something like "George W. Bush is a brilliant mind" -- it is simply false.
Now, as logic would have it, there is a lot more falsehood out there than
there is truth, and it is also a lot easier to determine that something
is false than to determine that something is true. Because every single
person wants to know what is true (or as true as possible), we need to
excise that which is known to be false, even though many people may want
to believe it. The earth is not flat. Microsoft is not a law-abiding
company who does more good than harm and is well-intentioned. In more
narrow contexts, other obvious falsehoods exist, too: E.g., here, it is
_false_ that a single namespace is better than many, it is _false_ that
Common Lisp would be better without special variables, etc. There is no
point at all in repeating these stupid claims.
Disagreement and agreement are completely worthless attributes of a
position in any group of thinking people. People have opinions of many
kinds, formed on a variety of bases, and some of them are nuts and some
of them are brilliant. Some of them turn out to be false when they are
examined closely, and when that happens, people are gently asked not to
repeat them, because repeating known falsehoods wastes everybody's time
and detracts from the purpose of finding whatever may be true. Thus, a
rejection of a falsehood means only that it is cannot be true and should
not be attempted to be argued to be true, because it is _false_. If this
is wrong, at _least_ try a novel and different angle on it.
I want people to work at proposing possible truths, and argue for them,
which is what "tolerate disagreement" means in a thinking population, but
I do not want to rehash proofs that something is false over and over
again, which is what "tolerate disagreement" means in an unthinking
population of idiots. Astrology is _bunk_. End of discussion. If you
have another opinion, the loony bin is in that direction --->. This is
not intolerance of disagreement, it is using your head to get rid of the
obviously insane and deluded monstrosities in stupid people's dreams.
The more time we spend refuting known falsehoods, the less time we have
to discover some possible truths. Scheme has made a large number of
design tradeoffs that Common Lisp considers to be _wrong_, and which
there is no point at all in revisiting. Common Lisp has taken a course
that precludes these design tradeoffs from being revisited and changed to
accomodate the anal-retentive Scheme freaks. They may change, but not to
become those of Scheme, simply because far too many people think Scheme
should be Scheme and Lisp should be Lisp, and never the twain shall meet
(again).
Improve your thinking skills, Thomas! The lack of coherence in your
extremely flawed "arguments" should be humiliating and embarrassing to
you, but that is not my fault, and it does not become less hurtful if you
keep making worse mistakes. Sometimes, I am simply right, and it does
not help to accuse me of being intolerant or anything else stupid people
tend to do. People must be allowed to say that Scheme sucks in vacuum in
this newsgroup without some hypersensitive Scheme freak going postal. We
must tolerate disagreement in the value system of people who agree that
Common Lisp is a great language and _therefore_ congregate here, but who
are likely to have all sorts of other, non-overlapping values and
interests. Just as those who all think Scheme is a great language
congregate in comp.lang.scheme. And just like they would have a right ot
throw someone out for saying "Scheme sucks" in their community, I demand
a right to tell people who spend their time talking about how much Common
Lisp sucks in this forum to go to hell. If people want others to be very
_friendly_ towards something as backward as Scheme, and do not want to
listen to other people's contrary opinions, comp.lang.scheme is the
place. Here, we tolerate disagreement, and therefore do not tolerate
those who want only _their_ One Truth about Scheme to be portrayed.
Grow a clue, Thomas Bushnell. You react to monsters of your own creation
and have long since stopped thinking or reading what I write. Take a
break, cuddle a cat (highly recommended), get laid, take an ocean-side
walk, whatever, just get back on track and start _thinking_ again!
And _please_ stop playing the moronic and childish game of "I'm not the
bad guy, the other guy is". Just accept responsibility for your _own_
actions and stop blaming me for them.
Kent M Pitman
> It is pretty pathetic that people need to ridicule both PL/1 and Common
> Lisp at the same time. It appears that large language throw some people
> off at an early stage and are considered bad by virtue of their size. I
> have seen people become frightend of English because of the Oxford
> English Dictionary in its full size, when they have only been exposed to
> some simple English Learner's Dictionary or something equally trivial.
> Perhaps it is some "fear of not mastering".
Actually, this last is not how I've have put it, since I don't define
"mastering" that way. However, working backward, because I don't think
you're incorrect there either, this is how I'd state it:
Step 1. Take on the mistaken belief that total knowledge is required
for mastering.
Step 2. Observe that total knowledge is out of reach.
Step 3. Conclude that mastering is out of reach.
I think I'd say that "fear of not mastering" is a fear any reasonable
person would have, at least to some degree, when confronted with a
language and asked if they'd like to use it.
A lot of it comes back to this issue of "do I have the core concepts?"
I have seen people conclude that they cannot learn the condition
system because they don't have a type tree of all conditions that can
be signaled. This fights the object-oriented notion of inheritance
and of abstraction. In some sense, a type tree is about learning a
language fractally. One can learn just CONDITION and one knows the
condition system. Or they can expand a ways and understand things
like SERIOUS-CONDITION and ERROR that happen near the root of the
tree. Or they can dive to things like FILE-ERROR where the CL type
tree stops. Or they can get down to what are (alas)
implementation-specific errors like DIRECTORY-NOT-FOUND or
TOO-MANY-LEVELS-OF-SYMBOLIC-LINK or whatever. One knows more "trivia"
at this point, but not more deep knowledge of the language. At this
point, the knowledge is really domain knowledge, not linguistic
knowledge. Just as one is not a better "scientist" per se if one
understands the details of the difference between this and that kind
of elephant or dog or flea. There are probably good scientists and
bad scientists who can recite inheritance trees.
It is impossible to imagine that anyone who we've awarded with our
highest linguistic honors, whether they be Pullitzer prizes or Hugo
awards, is fully aware of all words in English.
So the problem for us in outreach and in teaching is to get across
enough idea to people of when they have command of the core that they
may speak with authority.
The Scheme community, for example, has its formal semantics which
addresses the core set of special operator glue that they have. And
then they have a library. At the point of learning library, in some
sense one is in command of the language. For our community, the
special operators are just as finite although many book authors do not
present a complete knowledge of the core and so people are mystified.
It shouldn't be necessary to read the spec, but I don't know any other
work that seeks to treat all the relevant issues with adequate
thoroughness such that people can claim competency of the core
concepts.
The space of things to learn is quite finite, I think. But perhaps we
don't do as well as we might in bounding it "visually", in shepherding
people through it, in patting them on the head when they are done and
saying "you did it".
People want not just a language but a methodology. But "Lisp people"
have traditionally been people who haven't wanted to be told what to
do, so have pushed back on such "refining" concepts. Dictated
methodology is confining to those who generate their own, but is
enabling to those who would flounder without it. And I think the
latter set is larger. As I understand it, this is a lot about the
issue addressed in the book "Crossing the Chasm", which I still have
not found accasion to read, but always keep wishing i would. It's
easy to just look at the world and expect them to follow, but if we
were looking to lead, I think there are hints here about what people
are perhaps even still waiting for us to do.
Craig Brozefsky
> > who have thought otherwise, have left for other pastures, like D*lan and
> > Scheme and Arc. There are not "better" than Common Lisp by a long shot.
>
> You know, I haven't seen anybody but you arguing why one must be
> better than the others. *ONLY* *YOU*. Nobody else is saying any such
> thing.
Then you have not been reading this group very long Thomas. There was
recently a long thread on Arc and many people expressed negative
opinions of it. Same with Scheme, in fact Scheme is very frequently
used as a counterpoint to CL design decisions in discussion here, and
not just by Erik. There was a thread about Dylan awhile ago too with
the same bent.
I myself have a strong opinion on which is better too, CL.
> You seem concerned that there are lots of Scheme people saying "Scheme
> is the only thing worth considering", but I can't see any of them.
I think that's putting words into his mouth. The position I have seen
Erik consistnly expressing for the last few years is that Scheme is
not a dialect of lisp and that presenting it as such covers up the
major differences between the languages and does the community a
disservice. Several other people on this newsgroup have a similiar
position, in fact one might even say that it is accepted opinion
here and has been for quite some time.
--
Craig Brozefsky <cr...@red-bean.com>
http://www.red-bean.com/~craig
Ask me about Common Lisp Enterprise Eggplants at Red Bean!
Rahul Jain
> The position I have seen Erik consistnly expressing for the last few
> years is that Scheme is not a dialect of lisp and that presenting it
> as such covers up the major differences between the languages and
> does the community a disservice.
To emphasize what I think you meant:
It does _both_ communities a disservice, not just the Lisp community.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- mailto:rj...@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Thomas A. Russ
> I think every answer to this used the same k-supplied-p variable name.
Boy, talk about a pervasive naming convention!
--
Thomas A. Russ, USC/Information Sciences Institute t...@isi.edu
Jon Allen Boone
It seems to me that both Kent M Pitman and Erik Naggum wrote some
very salient points regarding the difficulties people may confront in
attempting to learn Common Lisp [and other programming languages].
In particular, Kent wrote the following excerpts:
> A lot of it comes back to this issue of "do I have the core
> concepts?"
>
> [snip]
>
> It shouldn't be necessary to read the spec, but I don't know any
> other work that seeks to treat all the relevant issues with adequate
> thoroughness such that people can claim competency of the core
> concepts.
I've been learning Common Lisp, primarily through reading CLTL2 and
the HyperSpec. I had a printed copy of CLTL, but I replaced it with a
copy of CLTL2 for "off-line" reading. When I'm actually programming,
I tend to use the HyperSpec exclusively. Every so often, I sprinkle
in some other sources [mostly on-line] for stylistic tips.
I've been assuming that the HyperSpec contains all of the core
concepts for mastering "Common Lisp". Is that correct? Should I be
concerned [at some point] with learning CLOS? MOP?
I'd assume that mastering any particular GUI-system (CLIM2?) is
beyond the scope of mastering Common Lisp itself...
> The space of things to learn is quite finite, I think. But perhaps
> we don't do as well as we might in bounding it "visually", in
> shepherding people through it, in patting them on the head when they
> are done and saying "you did it".
At the risk of getting somewhat off-topic for this newsgroup, it
seems to me that the trend these days is toward 3rd party
certifications provided [largely] by non-degree-granting
organizations. CCIE/CCNP/CCNA, MCSE, RHCE - the list goes on and on
and on...is there a Java certification yet? If not, there probably
soon will be.
It's my experience that inter-personal "networking" is effective in
obtaining employment because the "network" acts as both a source of
jobs and as a 3rd party "certification" system. To reach outside of
that network, however, requires a well recognized 3rd party to provide
the certification.
References from non-network members are viewed as increasingly
irrelevant for determining skill sets and instead are used as a means
of providing some minimal assurance that the candidate has no serious
behavioral or personality problems.
To try to bring this back on-topic, it would be useful for newbies
to have a reference that would walk them through all of the core
concepts necessary for mastering Common Lisp. But, I've seen posts
lamenting a lack of employment opportunities involving Lisp-based
development. So, I ponder these two questions:
1. Is the supply of Lisp jobs sufficient to maintain employment for
existing "masters" of Common Lisp? Will having more people
mastering Common Lisp help increase the job supply by making it
appear less risky to use Common Lisp?
2. Will lowering the barrier to entry for newbies do more economic
harm than good? I assume that it *is* possible to learn Common
Lisp from the available on-line sources. Do we newbies really
need any more assistance?
-jon
--
------------------
Jon Allen Boone
ipmo...@delamancha.org
Kent M Pitman
> I've been assuming that the HyperSpec contains all of the core
> concepts for mastering "Common Lisp". Is that correct?
Mostly, yes.
> Should I be concerned [at some point] with learning CLOS?
What is usually called "CLOS" is part of ANSI CL.
> MOP?
Some of the originally proposed CLOS design was accepted by ANSI CL
and some was not. That which was not is the spec for the "internals",
which were themselves object-oriented. Most major CL implementations
have a MOP implementation; there are small differences, but it's possible
to program relatively portably using the MOP and the CL spec (e.g., CLHS)
will not prepare you for that. You want what is called AMOP ("The Art
of the Metaobject Protocol" by Gregor Kiczales, orderable probably from
Amazon) if you want to learn about this. You don't need these concepts
in order to program competently in ANSI CL, but they provide additional
programming power you might find fun once you have mastered CLOS basics.
> I'd assume that mastering any particular GUI-system (CLIM2?) is
> beyond the scope of mastering Common Lisp itself...
Yes. As a general rule, ANSI CL addressed "the environment" (meaning the
interfaces to things outside of CL) only in ways that were necessary for
historical reasons.
> 1. Is the supply of Lisp jobs sufficient to maintain employment for
> existing "masters" of Common Lisp? Will having more people
> mastering Common Lisp help increase the job supply by making it
> appear less risky to use Common Lisp?
There are differing points of view on this. Certainly some people who wish
they were programming in CL are not. But there are also CL jobs waiting to
be filled. Not every job is for every person. And there is not as infinite
a supply of CL jobs as for other languages.
> 2. Will lowering the barrier to entry for newbies do more economic
> harm than good?
Heh. A really interesting question. I don't know how to answer this,
but I would not encourage anyone to act as if the answer were "yes".
Supposing even that it caused some initial harm, which is always possible,
I think in the long-term there would be overall benefit.
> I assume that it *is* possible to learn Common
> Lisp from the available on-line sources. Do we newbies really
> need any more assistance?
Sometimes. But the support from the community, to include this newsgroup,
is usually pretty good.
Erik Naggum
| 1. Is the supply of Lisp jobs sufficient to maintain employment for
| existing "masters" of Common Lisp?
I think it is impossible to determine this. There are two obvious
problems, even though there are employment opportunities with Common
Lisp: (1) they usually require a host of additional skills, some of which
are more important to the employer than Common Lisp; (2) you may not wish
to take advantage of them because there are more impotant things to those
seeking to use Common Lisp than Common Lisp, such as geographic location
(particularly if they have a family), the intellectual challenges that
come with the job, the working environment, etc. I think few of those
who master Common Lisp have any serious problems finding challenging
jobs, but I think they go for challenging before Common Lisp. An
employer of smart people would naturally want to offer an intellectually
stimulating environment and would therefore be amenable to requests to
use Common Lisp, but it is hard enough to do this that an employer would
not necessarily want to make Common Lisp a job requirements, lets he miss
out on other smart people who are able to fulfill his requirements.
| Will having more people mastering Common Lisp help increase the job
| supply by making it appear less risky to use Common Lisp?
I believe there is nothing to fear at all in more people mastering Common
Lisp. The demand for solutions to hard problems that make Common Lisp
able to supply such a solution is on the increase, and the more problems
are actually solved, the more programming languages that are able to
build upon past solutions will prosper. Why is this not C++ or Java,
with their extensive libraries and third-party vendors? Because, they
offer mostly alternative solutions to already solved problems which work
in incompatible ways, and the rare novel solution is so entangled in the
language that using it becomes harder and harder, the more it deviates
from the assupmptions made by the language. What Common Lisp does so
uniquely, is to offer all those who would have created their very own
language a means to create their own without having to return to square
one and build the entire development environment. Common Lisp makes it
so easy to capitalize on the existing resources of the system developers
that the little languages that you need to talk about your problems is a
non-issue. There are a number of books out there on designing little
languages and building parsers and such, and tools like lex and yacc were
written to accomodate those needs. That the "ya" stands for Yet Another
is no accident: There was a lot of interest in these things at the time
it was written. Common Lisp is able to accomodate these needs without as
much work and hassle.
| 2. Will lowering the barrier to entry for newbies do more economic
| harm than good?
I think yes. Newbies are not good -- if they remain newbies and go no
further, which is what hapens when it is easy to start and hard to get
further. However, making it easier for people to become masters is
clearly a good thing. I therefore think it is a good thing to make the
entry level reasonably high, but make it easier to go on once you have
made the entry. Common Lisp can, in my view, not afford to be depleted
by a large number of incompetents, frauds, and liars, although C++ and
Java have won big by this scheme. Being incompetent at Common Lisp hurts
the language, for whatever reason, but incompetence at C++ or Java is not
a problem for either language or programmer. I guess it simply is one of
the consequences of being and not being mainstream.
| I assume that it *is* possible to learn Common Lisp from the available
| on-line sources.
I do not think a dedicated student would stop at on-line sources. I also
do not believe education should be free. The willingness to spend a few
hundred, even a few thousand, dollars to learn something does two things:
It filters out those who would expend little effort of their own, and it
rewards those who take the time to write pedagogical works financially.
There is a limit to how long you can give things away before you want
something in return, so somebody has to fund it. People who want to
learn a new a new programming language without paying for it do not
strike me as the future of a living language. Hell, I have not yet made
a nickel on my Java skills, yet I have acquired the entire Java library
from Sun and spent countless hours reading and playing with Java, but I
do not consider myself capable of charging for my time at my regular
rate, yet. The same is true for SQL and cryptography. I also have a lot
of experience with SGML and XML, yet I do not _want_ to work with it, nor
do I want to use my Perl skills to write code for pay -- but I do debug
other people's disgusting Perl hacks and replace it with real software.
Many other peeple can make things work. What I do is not make it fail.
I believe it is possible to learn to make things _work_ nearly without
effort, just like you do not need any particular training to build a
house that stands, but you do need lots of experience, practice, study,
and expenditure of effort to make things that do not fail, just like you
need serious amounts of planning, adherence to standards and regulations,
and lots and lots of people who cost a lot of money to "rent". I see no
reason why programming should be different. However, most programmers
still build tree houses with free resources and argue that it would take
all the fun out of building tree houses if you had to build real houses.
Perhaps this is true -- I know of no carpenter who builds tree houses for
himself. Hm, I digress.
| Do we newbies really need any more assistance?
I think proof of effort should be rewarded liberally, and effort very
strongly encouraged. Likewise, people should know that without doing
anything on their own, they will not be rewarded with help. It is also
important to make people realize when to ask questions and that making
their assumptions clear and be up front about them. I believe this is
what makes people who are dedicated and willing to work hard to be able
to succeed, but when you start off with something, you first of all need
to study and obtain knowledge, not to question and doubt before you know.
This is difficult for people who have mastered a programming language
before they try a new one. I believe it is unfruitful to expect Common
Lisp to be the first programming language someone learns. Therefore, the
clue should be to attract intelligent people who already (think they)
know how to program and are not interested in spending a lot of time up
front on trivial things, but instead on counter-information to their
current beliefs, i.e., what they believe is true for their previous
languages which is likely to be false for Common Lisp as well as they do
not believe could be true, but which is indeed true for Common Lisp.
I personally think interaction with experienced programmers is the way to
go, but it is important to ask intelligent questions and to stay focused
on the purpose of learning something.
Janis Dzerins
Things have changed since 1982.
--
Janis Dzerins
Eat shit -- billions of flies can't be wrong.
Janis Dzerins
> tb+u...@becket.net (Thomas Bushnell, BSG) writes:
>
> > Right--some uses of set! are side-effect free. But all uses of let
> > are always side-effect free.
> >
> What about
> (let ((x (set! y 3)))
> ...)
> ? That's not side-effect free :)
The use of let is side-effect free here. It's set! which is not. As
described.
And looks like it has a potential bug, because it is not Common Lisp
[where setq and setf return a reasonable value].