Implementation Favoritism, a question of Lisp mindsets
Andrew Burton
start a language war. This is a question I had this weekend, and wanted to ask
as part of my "trying to understand the Lisp mentality."
Lately I've been trying to play with various (free) Lisp implementations just
to get the feel of the overall language. I've used clisp, scsh, MIT Scheme,
and I've even tinkered with Emacs Lisp and Dr. Scheme a little bit. In playing
with these different Lisps, I can see the similarities, and I can see the
differences. Now, I'm no where close to being anything but a hobbyist with it
so far, but I'm worndering: when one gets to the point that one can program
marvelous software with a specific implementation, does one kind of focus on
that specific implementation? I mean, do Lisp hackers generally focus on
learning one implementation, or is it better to kind of learn them at a
paralell pace?
I'm wondering -- and again, this isn't trying to say one is better than the
other -- should set MIT Scheme, Emacs Lisp, and such aside until I get better
at clisp? Or should I continue working with each one as I have been? What do
most Lisp hackers do? Any opinions are welcome. Thanks.
Andrew Burton -- tuglyraisin at aol dot com
Felecia Station on Harvestgain
Jipi: Don't Believe everything the Net tell you.
Chip: I agree with this. My inputs are not to be trusted.
CROW: Quick, save the Robot Ashley!
Barry Margolin
Andrew Burton <tugly...@aol.commune> wrote:
>Lately I've been trying to play with various (free) Lisp implementations just
>to get the feel of the overall language. I've used clisp, scsh, MIT Scheme,
>and I've even tinkered with Emacs Lisp and Dr. Scheme a little bit. In playing
>with these different Lisps, I can see the similarities, and I can see the
>differences. Now, I'm no where close to being anything but a hobbyist with it
>so far, but I'm worndering: when one gets to the point that one can program
>marvelous software with a specific implementation, does one kind of focus on
>that specific implementation? I mean, do Lisp hackers generally focus on
>learning one implementation, or is it better to kind of learn them at a
>paralell pace?
Most of the general concepts that you learn about Lisp programming apply to
most dialects. There may be minor syntactic differences (e.g. Lisp's DEFUN
vs. Scheme's DEFINE), and occasionally some more significant differences
(e.g. Emacs Lisp is dynamically-scoped, the rest are statically-scoped),
but they all share enough qualities that it's not difficult to go from one
dialect to another (the dialect analogy seems quite proper for this -- it's
not too different from the American and British differences in the English
language).
Where implementation-specific stuff becomes important is if you need to go
outside the features provided by the standard language, e.g. foreign
function calling or fancy UI libraries.
--
Barry Margolin, barry.m...@level3.com
Genuity Managed Services, a Level(3) Company, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
Andrew Burton
> becomes important is if you need to go
> outside the features provided by the
> standard language, e.g. foreign function
> calling or fancy UI libraries.
Which is pretty much standard with every language/dialect, correct? So what
I'm doing now, playing with as many dialects (which, I agree is a god word), is
prebably a more comman, generally accepted means of learning Lisp?
Henrik Motakef
> I'm not sure how to ask this, so I want to preface this by saying I'm not try
> start a language war. This is a question I had this weekend, and wanted to ask
> as part of my "trying to understand the Lisp mentality."
>
> Lately I've been trying to play with various (free) Lisp implementations just
> to get the feel of the overall language. I've used clisp, scsh, MIT Scheme,
> and I've even tinkered with Emacs Lisp and Dr. Scheme a little bit. In playing
> with these different Lisps, I can see the similarities, and I can see the
> differences. Now, I'm no where close to being anything but a hobbyist with it
> so far, but I'm worndering: when one gets to the point that one can program
> marvelous software with a specific implementation, does one kind of focus on
> that specific implementation? I mean, do Lisp hackers generally focus on
> learning one implementation, or is it better to kind of learn them at a
> paralell pace?
There is a difference between different "dialects" of Lisp, and
different implementations of one dialect. For example, Common Lisp is
a programming language distinct from Emacs Lisp and Scheme, while
CLISP, CMUCL and LispWorks are implementations of Common Lisp.
I'd say the different dialects are roughly about as far away from each
other as C and Java are - it is possible to learn how to write code
that works quite quickly in any of the dialects if you already know
one of them, but it may take some time until you know common idioms of
the dialect, and can write code that is actually beautiful. There is a
lot of similarity, but the mindsets differ significantly.
On the other hand, switching from one implementation of Common Lisp
to another one isn't really hard. Sure, the environment may be a
little different, non-standard extensions like for networking or
threads are notoriously incompatible, the performance characteristics
differ, but these are details.
> I'm wondering -- and again, this isn't trying to say one is better than the
> other -- should set MIT Scheme, Emacs Lisp, and such aside until I get better
> at clisp? Or should I continue working with each one as I have been? What do
> most Lisp hackers do? Any opinions are welcome. Thanks.
My impression is that most people more or less focus on one dialect,
probably mostly because they are good at different things and it is
hard to find someone who is interested in all of them. So the question
really is, what do you want to do with Lisp?
Regards
Henrik
BTW: This newsgroups is almost exclusively populated with users of
Common Lisp. You might want to ask in comp.lang.scheme and the various
*.emacs.* groups for opinions of Schemers and Elisp fans.
John M. Adams
> I'm not sure how to ask this, so I want to preface this by saying I'm not try
> start a language war. This is a question I had this weekend, and wanted to ask
> as part of my "trying to understand the Lisp mentality."
>
> Lately I've been trying to play with various (free) Lisp implementations just
> to get the feel of the overall language. I've used clisp, scsh, MIT Scheme,
> and I've even tinkered with Emacs Lisp and Dr. Scheme a little bit. In playing
> with these different Lisps, I can see the similarities, and I can see the
> differences. Now, I'm no where close to being anything but a hobbyist with it
> so far, but I'm worndering: when one gets to the point that one can program
> marvelous software with a specific implementation, does one kind of focus on
> that specific implementation? I mean, do Lisp hackers generally focus on
> learning one implementation, or is it better to kind of learn them at a
> paralell pace?
>
> I'm wondering -- and again, this isn't trying to say one is better than the
> other -- should set MIT Scheme, Emacs Lisp, and such aside until I get better
> at clisp? Or should I continue working with each one as I have been? What do
> most Lisp hackers do? Any opinions are welcome. Thanks.
Well, people around here tend to believe that Common Lisp is the
better choice. Clisp is a Common Lisp and is probably the best thing
for you to play with. Unless you have a specific reason to prefer a
scheme implementation, for example you are going to take a sicp based
course, I'd recommend that you continue with clisp. There are other
Lisps you can try including cmucl, Open MCL, Franz Inc.'s, trial
version of Allegro Common Lisp (ACL). In my opinion, although I
prefer ACL professionally, clisp has the best combination of features
and user-friendliness of the free Lisps, especially for the new user.
However, I have never tried Open MCL.
--
John Michael Adams
Andrew Burton
> want to do with Lisp?
I have no idea really, aside from learning Lisp. Not to sound silly, but I
find the syntax very relaxing. Right now it's sort of an off-shoot of my
Spreadsheet fascination -- Lisp being much more powerful than a Spreadsheet and
friendlier at handling algorithms.
> You might want to ask in
> comp.lang.scheme and the various
> *.emacs.* groups for opinions of
> Schemers and Elisp fans.
Duly noted! The ANSI Common Lisp, clisp, was the first Lisp I played with, so
this was the only one, so far, I've subscribed to. Thanks. :)
Pascal Costanza
tugly...@aol.commune (Andrew Burton) wrote:
> > Where implementation-specific stuff
> > becomes important is if you need to go
> > outside the features provided by the
> > standard language, e.g. foreign function
> > calling or fancy UI libraries.
>
> Which is pretty much standard with every language/dialect, correct? So what
> I'm doing now, playing with as many dialects (which, I agree is a god word),
> is
> prebably a more comman, generally accepted means of learning Lisp?
>
There is not one right way to learn Lisp. What I like about Lisp is that
it allows a wide variety of expressing programs. However, this also
means that it's mainly up to you in what order you want to learn the
details about Lisp. Your insistence seems to suggest that you _want_ to
learn Lisp by learning many dialects in parallel. If that's the thing
you want to do, then just go ahead and do it. If that's not what you
want to do, then first learn one of Common Lisp or Scheme. It really
doesn't matter with which to start, as long as you are going to look at
the other language as well at some stage.
Emacs Lisp is an old-fashioned dialect and especially lacks lexical
scoping. Use it only when you want to tweak Emacs.
Pascal
--
"If I could explain it, I wouldn't be able to do it."
A.M.McKenzie
Mario S. Mommer
tugly...@aol.commune (Andrew Burton) writes:
> The ANSI Common Lisp, clisp
Note that clisp is only one implementation of common lisp.
Regards,
Mario
M H
> So what
> I'm doing now, playing with as many dialects (which, I agree is a god word), is
> prebably a more comman, generally accepted means of learning Lisp?
If you want to learn how to program Lisp, I would recommend against this
strategy. Choose _one_ platform and learn this one properly. Then look
around and broaden your view (this will be easy once you understand the
fundamentals).
For a first Lisp-experience I would go for the Scheme-dialect of Lisp
(you mentioned Dr.Scheme which is a good platform for learning). There
is good literature on the web (Abelson & Sussman: "Structure and
Interpretation of Computer Programs", Felleisen et al. "How to design
programs") and this dialect is smaller than, e.g., Common Lisp.
Matthias
Matthew Danish
> Andrew Burton wrote:
>
> > So what
> > I'm doing now, playing with as many dialects (which, I agree is a god word), is
> > prebably a more comman, generally accepted means of learning Lisp?
>
> If you want to learn how to program Lisp, I would recommend against this
> strategy. Choose _one_ platform and learn this one properly. Then look
> around and broaden your view (this will be easy once you understand the
> fundamentals).
This I agree with.
> For a first Lisp-experience I would go for the Scheme-dialect of Lisp
> (you mentioned Dr.Scheme which is a good platform for learning). There
> is good literature on the web (Abelson & Sussman: "Structure and
> Interpretation of Computer Programs", Felleisen et al. "How to design
> programs") and this dialect is smaller than, e.g., Common Lisp.
Why? I've found every Scheme environment I've tried--including
DrScheme--to be lacking in comparison to the CL environments. If you
want to learn Lisp, you should start with CL. Xanalys LispWorks offers
an excellent IDE for personal use, or Emacs in combination with any of
the other CLs works well.
Scheme's "simplicity" does not in any way aid the learning process, and
it only discourages potential future Lispers. The several good books
that use Scheme can easily be paralleled with CL.
Better to learn Scheme when you already know what Lisp can do.
--
; Matthew Danish <mda...@andrew.cmu.edu>
; OpenPGP public key: C24B6010 on keyring.debian.org
; Signed or encrypted mail welcome.
; "There is no dark side of the moon really; matter of fact, it's all dark."
Matthieu Villeneuve
news:2003041510...@lain.cheme.cmu.edu...
> On Tue, Apr 15, 2003 at 09:59:05AM +0200, M H wrote:
> > For a first Lisp-experience I would go for the Scheme-dialect of Lisp
> > (you mentioned Dr.Scheme which is a good platform for learning). There
> > is good literature on the web (Abelson & Sussman: "Structure and
> > Interpretation of Computer Programs", Felleisen et al. "How to design
> > programs") and this dialect is smaller than, e.g., Common Lisp.
>
> Why? I've found every Scheme environment I've tried--including
> DrScheme--to be lacking in comparison to the CL environments. If you
> want to learn Lisp, you should start with CL. Xanalys LispWorks offers
> an excellent IDE for personal use, or Emacs in combination with any of
> the other CLs works well.
>
> Scheme's "simplicity" does not in any way aid the learning process, and
> it only discourages potential future Lispers. The several good books
> that use Scheme can easily be paralleled with CL.
Right. Common Lisp is quite big in terms of features, but isn't harder to
learn than Scheme when you start with a subset of the language, then
gradually learn the rest. For example, start with symbols and other types,
evaluation rules, list manipulations, function definition, basic i/o, and
you can already write nice little programs. Then you can learn about macros,
advanced data structures, condition system, CLOS, etc. And the whole
learning process should be pretty smooth.
--
Matthieu Villeneuve
Will Hartung
"Andrew Burton" <tugly...@aol.commune> wrote in message
news:20030414132007...@mb-fc.aol.com...
> I'm wondering -- and again, this isn't trying to say one is better than
the
> other -- should set MIT Scheme, Emacs Lisp, and such aside until I get
better
> at clisp? Or should I continue working with each one as I have been?
What do
> most Lisp hackers do? Any opinions are welcome. Thanks.
I agree with the others in that you should really focus on one system, that
way you learn the important details of the language rather than the
important details of porting software across different implementations. The
former is much more useful.
If you're comfortable with EMACS, then learning EMACS Lisp is an interesting
exercise because the EMACS Lisp environment is pretty good, and you don't
have to set anything up or download and configure a bunch of different
things. The other nice advantage is that you have a reasonably simple
environment to do Interesting Things with your code. You don't necessarily
need to contrive applications to create, rather you can make stuff you need
in your everyday "real" world outside of your Lisp hobby. If you want to
learn a language, you need to apply it, preferably in "real time" on "real
projects" where you have to just Get It Done and then you can come back and
do a post mortem to make it better. Writing extesions and utilities in EMACS
that can support your real work (assuming you use EMACS daily anyway) is a
great breeding ground for Real World things to do.
The dark side of EMACS Lisp is that it's an old dialect. So you end up
learning idioms and techniques that were important back in the late '70's,
but less relevant today with modern CL systems.
On the other hand, as another poster mentioned, personal Lispworks is really
an incredible value for most folks trying to learn the language. It's a
fully complete and modern system with good support of the things like CLOS.
It has GUI bits, network bits, and multiprocessing bits. It's a double-click
install which makes it easy to get into quickly, with minimal frustrations,
and it's editor is EMACS enough where you don't have to learn a whole new
system just to get your text saved.
Regards,
Will Hartung
(wi...@msoft.com)
M H
> On Tue, Apr 15, 2003 at 09:59:05AM +0200, M H wrote:
>>For a first Lisp-experience I would go for the Scheme-dialect of Lisp
>>(you mentioned Dr.Scheme which is a good platform for learning). There
>>is good literature on the web (Abelson & Sussman: "Structure and
>>Interpretation of Computer Programs", Felleisen et al. "How to design
>>programs") and this dialect is smaller than, e.g., Common Lisp.
>
>
> Why? I've found every Scheme environment I've tried--including
> DrScheme--to be lacking in comparison to the CL environments. If you
> want to learn Lisp, you should start with CL. Xanalys LispWorks offers
> an excellent IDE for personal use, or Emacs in combination with any of
> the other CLs works well.
>
> Scheme's "simplicity" does not in any way aid the learning process, and
> it only discourages potential future Lispers. The several good books
> that use Scheme can easily be paralleled with CL.
Name one CL book, targeted towards beginners, which resembles SICP in
how it teaches "how to think functionally". I know Graham's and
Norvig's books and I think they are outstanding. But they do not
explain how to work with functions returning functions and taking
functions as arguments. To beginners, these things are difficult to
grasp (not to speak about students who have already touched C or Java).
Background: At my university we just switched from Java to Scheme to
teach computer science fundamentals to about 350 first-year students. My
experience was: (1) Students need good literature targeted towards
beginners. (2) A programming envionment which especially supports
beginners is a plus (in DrScheme you have different language levels, in
some you can execute your code step-by-step stepping forwards and
backwards; also the error messages are helpful to beginners). (3) Some
things are more consistent in Scheme than they are in CL (names of
functions, e.g.).
> Better to learn Scheme when you already know what Lisp can do.
To cite Paul Graham (http://www.paulgraham.com/faq.html)
>Common Lisp is powerful but ugly. Scheme is small and clean, but the
>standard only defines the inner core of the language. If I had to
>deliver an application I'd probably use Common Lisp; if I were teaching
>a course I might use Scheme (but with Common Lisp macros).
Matthias
Mark Conrad
<mda...@andrew.cmu.edu> wrote:
> Scheme's "simplicity" does not in any way aid the learning process, and
> it only discourages potential future Lispers. The several good books
> that use Scheme can easily be paralleled with CL.
Disclaimer:
1) I am a Lisp newbie (with both CL and Scheme) - so please forgive me
if what I post here might not be correct.
2) I have no axe to grind about either CL or Scheme, although I prefer
CL because it has much more stuff "included" as an intregal part of the
language.
3) I really hope this post of mine does not confuse the original poster
as to whether CL or Scheme is the "better" Lisp for initial learning.
All that said, I have a question about this part of your post, namely:
> The several good books that use Scheme can easily be paralleled with CL.
Consider two "hairy" Scheme books:
Essentials of Programming Languages
- - and - -
Scheme and the Art of Programming
It seems to me that CL would have an extremely difficult if not
impossible task of doing some of the things described in those two
books, especially the code relating to "continuations".
As I recall, in Scheme, continuations are "first class" objects, which
means among other things that they can be "returned" as the returned
value of a function.
I don't think this is possible in CL, because in CL continuations are
not first-class objects, are they?
Just a dumb newbie question :)
Mark-
Kenny Tilton
M H wrote:
> [CL books] do not
> explain how to work with functions returning functions and taking
> functions as arguments.
Really? Not Graham? Hard to believe. Anyway...
> To beginners, these things are difficult to
> grasp (not to speak about students who have already touched C or Java).
>
> Background: At my university we just switched from Java to Scheme to
> teach computer science fundamentals to about 350 first-year students...
Nothing wrong with that, but the OP mentioned:
Andrew Burton wrote:
> I've used clisp, scsh, MIT Scheme,
> and I've even tinkered with Emacs Lisp and Dr. Scheme a little bit. In playing
> with these different Lisps, I can see the similarities, and I can see the
> differences.
This guy does not need training wheels and/or hand-holding.
Give him CL, the CLHS, and one of the CL books with a pedagogical bent
and get out of his way.
Andrew, go with the Real Deal, Common Lisp. The shortest distance
between two points and all that.
--
kenny tilton
clinisys, inc
http://www.tilton-technology.com/
---------------------------------------------------------------
"Everything is a cell." -- Alan Kay
Matthew Danish
> Name one CL book, targeted towards beginners, which resembles SICP in
> how it teaches "how to think functionally". I know Graham's and
> Norvig's books and I think they are outstanding. But they do not
> explain how to work with functions returning functions and taking
> functions as arguments. To beginners, these things are difficult to
> grasp (not to speak about students who have already touched C or
> Java).
I don't have Graham's book on hand, but I do know that Norvig's book is
not entirely devoid of functional programming techniques (and even
implements call/cc). However, you are making a mistake. You are
assuming that ``thinking functionally'' is overwhelmingly important. A
great thing about PAIP is that it covers many different ways of
thinking. With *Lisp*, functional programming is not so important that
it should trump all other paradigms. This is a Lisp group, and the OP
asked about Lisp programming, so I think it's fair to say that FP is not
held as the One True Way here.
On a side note, I never finished SICP myself, got tired of it.
> Background: At my university we just switched from Java to Scheme to
> teach computer science fundamentals to about 350 first-year students.
> My experience was: (1) Students need good literature targeted towards
> beginners. (2) A programming envionment which especially supports
> beginners is a plus (in DrScheme you have different language levels,
> in some you can execute your code step-by-step stepping forwards and
> backwards; also the error messages are helpful to beginners). (3) Some
> things are more consistent in Scheme than they are in CL (names of
> functions, e.g.).
So basically, we're going to have another 350 students who think that
Scheme is Lisp and that you can only use recursion and lists. And Lisp
is interpreted only.
> To cite Paul Graham (http://www.paulgraham.com/faq.html)
> >Common Lisp is powerful but ugly. Scheme is small and clean, but the
> >standard only defines the inner core of the language. If I had to
> >deliver an application I'd probably use Common Lisp; if I were
> >teaching a course I might use Scheme (but with Common Lisp macros).
I really don't see any reason why you wouldn't want to use your delivery
language for learning purposes. Especially when said delivery language
is as advanced. Truth be told, I'm having a lot of trouble figuring out
what niche Scheme fits into. CL fits the ``industrial strength dynamic
programming language'' bill, and Haskell/ML fits the ``functional
programming academic language'' mold.
Tim Bradshaw
> Name one CL book, targeted towards beginners, which resembles SICP in
> how it teaches "how to think functionally". I know Graham's and
> Norvig's books and I think they are outstanding. But they do not
> explain how to work with functions returning functions and taking
> functions as arguments. To beginners, these things are difficult to
> grasp (not to speak about students who have already touched C or Java).
You're making the mistake of assuming CL people think this is a
crucial skill. They don't, or at least not compared with the damage
done by the appalling theoretical-CS mindset often caused by exposure
to Scheme too early.
--tim
Mark Conrad
<mda...@andrew.cmu.edu> wrote:
> I don't have Graham's book on hand, but I do know that Norvig's book is
> not entirely devoid of functional programming techniques (and even
> implements call/cc).
I am a novice at this Lisp stuff, so I could well be wrong on some
points below.
Least anyone mis-interprets the following part of your post, namely:
> .....programming techniques (and even implements call/cc).
I would like to clarify a few points, for any newbie lurkers.
For example, this "full strength" version of call/cc in Scheme runs
okay:
(from page 771 of Norvig's book)
=> (+ 1 (call/cc (lambda (cc)
(set! old-cc cc)
(+ 20 (cc 300)))))
301
=> (old-cc 500
501
Norvig explains what is going on above in the Scheme code:
"Here, we first computed 301, just as before, but along the way saved
cc in the global variable old-cc. Afterward, calling (old-cc 500)
returns (for the second time) to the point in the computation where 1
is added, this time returning 501. The equivalent Common Lisp code
leads to an error"
Then Norvig shows the "equivalent" CL code below:
> (+ 1 (catch 'tag (+ 20 (throw 'tag 300))))
301
> (throw 'tag 500)
Error: there was no pending CATCH for the tag TAG
Norvig explains:
"In other words, call/cc's continuations have indefinite extent, while
throw/catch tags only have dynamic extent."
This points up the fact that any trivial attempt to duplicate what
Scheme continuations do by using CL's catch, throw, tag, block, go,
tagbody, return-from, and other built-in CL constructs will just not
work in many cases.
To get the full power of call/cc in Common Lisp, a full-blown
Scheme-like interpreter would have to be created within Common Lisp,
which Norvig describes how to do in pages 773-776 of his book.
I am not all that certain that Norvig covered all bases with this
imbedded interpreter, so I plan to check it out on some tough cases,
like "unwind" and "wind" techniques, and rather hairy coroutines
running the "Samefringe" problem, and other nasty applications of
coroutines.
I really hope that Norvig's imbedded interpreter passes my tests,
because I would like to have the option of using "real" continuations
within CL.
Mark-
M H
> On Tue, Apr 15, 2003 at 08:53:38PM +0200, M H wrote:
>
>>Name one CL book, targeted towards beginners, which resembles SICP in
>>how it teaches "how to think functionally". I know Graham's and
>>Norvig's books and I think they are outstanding. But they do not
>>explain how to work with functions returning functions and taking
>>functions as arguments. To beginners, these things are difficult to
>>grasp (not to speak about students who have already touched C or
>>Java).
>
> I don't have Graham's book on hand, but I do know that Norvig's book is
> not entirely devoid of functional programming techniques
I never claimed that either book is "entirely devoid of functional
programming techniques".
> (and even implements call/cc).
> However, you are making a mistake. You are
> assuming that ``thinking functionally'' is overwhelmingly important. A
> great thing about PAIP is that it covers many different ways of
> thinking. With *Lisp*, functional programming is not so important that
> it should trump all other paradigms. This is a Lisp group, and the OP
> asked about Lisp programming, so I think it's fair to say that FP is not
> held as the One True Way here.
I never claimed that functional programming was the only true way.
But: If you teach Lisp without stressing its functional aspects you will
end up having students program C in Lisp syntax, _heavily_ complaining
how complicated and ugly this is.
> So basically, we're going to have another 350 students who think that
> Scheme is Lisp and that you can only use recursion and lists. And Lisp
> is interpreted only.
They know that Scheme is _a_ Lisp. They built their own do-statement,
and they examined a simple closure-based OOP system. They know about
Scheme compilers and have been pointed to CMUCL. What point are you
trying to make?
> I really don't see any reason why you wouldn't want to use your delivery
> language for learning purposes.
The delivery languages for most of our students ultimately are Java and
C++. We found it hard to teach certain computer science concepts using
these languages. But of course, yes, it can be done. You can teach
programming and CS using almost any programming language. Depending on
a lot of factors it will be easier or harder.
If someone wants to learn Lisp because of a specific job or project in
mind where CL is involved I would also recommend to go for it directly.
The original poster just asked about learning Lisp. In my mind Lisp
is more than only CL, and I recommended an environment which I found
useful for beginners. That's all.
Matthias
Paul F. Dietz
> But: If you teach Lisp without stressing its functional aspects you will
> end up having students program C in Lisp syntax, _heavily_ complaining
> how complicated and ugly this is.
I would much, MUCH rather have this than the opposite: the student developing
a nervous tick where all loops have to be expressed as recursive function
calls (that is, as if with gotos, but less understandably) and higher order
functions are used just for the sake of being functional. I've seen too
much of this from the Scheme-initiated.
A true appreciation of lisp also requires, IMO, study of actual real lisp
programs, not just toy examples.
Paul
Tim Bradshaw
> I really hope that Norvig's imbedded interpreter passes my tests,
> because I would like to have the option of using "real" continuations
> within CL.
Why not just *use scheme* if what you want is call/cc?
--tim
Edi Weitz
> I really hope that Norvig's imbedded interpreter passes my tests,
> because I would like to have the option of using "real"
> continuations within CL.
This whole call/cc thing seems like a straw man to me. If you're
really interested in learning Common Lisp try to forget about
continuations for some time, try to write larger programs and look at
larger programs others have written. Then, after a couple of months,
you might want to raise the issue again and ask yourself whether you
ever really _needed_ the whole call/cc machinery for a _real_ problem
you came across.
Common Lisp has been designed by some _very_ smart people and you can
bet they knew about continuations - there are reasons why they weren't
included. This subject has been beaten to death here often enough but
you might want to search Google Groups for c.l.l postings about
"continuations" or "call/cc", specifically those by Kent M
Pitman. Here are some starting points:
<http://www.nhplace.com/kent/PFAQ/unwind-protect-vs-continuations.html>
<http://groups.google.com/groups?selm=slrnapmp2a.2bbm.Gareth.McCaughan%40g.local>
<http://groups.google.com/groups?selm=sfwwv2rubgp.fsf%40world.std.com>
Of course, if you decide before the fact that you can't live without
call/cc just use Scheme as Tim Bradshaw has already proposed...
Edi.
M H
> M H wrote:
>
>> But: If you teach Lisp without stressing its functional aspects you
>> will end up having students program C in Lisp syntax, _heavily_
>> complaining how complicated and ugly this is.
>
> I would much, MUCH rather have this than the opposite:
I do not want frustrated students.
> the student developing
> a nervous tick where all loops have to be expressed as recursive function
> calls (that is, as if with gotos, but less understandably) and higher order
> functions are used just for the sake of being functional. I've seen too
> much of this from the Scheme-initiated.
You won't see this from my students, though. :-)
> A true appreciation of lisp also requires, IMO, study of actual real lisp
> programs, not just toy examples.
Agreed. But my goal was to teach computer science to first year
students. Lisp was just the means, not the goal. Scheme worked well in
that most students now understand important key concepts of programming.
Which language they choose later for their projects and their job is
their thing. They know that they don't know everything yet to be a good
computer scientist or programmer.
Matthias
Thomas F. Burdick
I'd suggest using Paul Graham's continuations-in-CL system instead. I
suspect that anyone using it, if they thought twice any time they used
continuations, would pretty quickly figure out that (almost?) all its
uses can be better handled in CL another way. Switching to scheme is
just going to reinforce the erronious notion that continuations are
actually useful, as opposed to a cool toy.
--
/|_ .-----------------------.
,' .\ / | No to Imperialist war |
,--' _,' | Wage class war! |
/ / `-----------------------'
( -. |
| ) |
(`-. '--.)
`. )----'
Mark Conrad
wrote:
> > I really hope that Norvig's imbedded interpreter passes my tests,
> > because I would like to have the option of using "real"
> > continuations within CL.
>
> This whole call/cc thing seems like a straw man to me.
Of course, that is your prerogative, a personal opinion. I also have
my own personal opinions, believing OOP is a "straw man".<g>
As to whether continuations, OOP, or anything else is useful, now that
depends on what we are trying to do with our programs, doesn't it?
Lisp is touted as a language which is very good for creating the
initial-concept of some problem one is trying to solve.
This is how I intend to use Lisp, in order to take advantage of Lisp's
unique strengths.
With the Initial Concept, one does not usually have all the information
that one desires to have, in order to solve the problem by way of a
computer program.
Often in such a 'non-deterministic' sort of program, where crucial data
is lacking, a lot of brute-force searching has to take place in order
to 'bracket' missing data, to at least get a small range of data that
might contain what one is looking for.
Once the missing data is found 'within bounds', it becomes a lot easier
to get answers with enough precision to perhaps solve the overall
problem.
So one real application of using full-blown continuations is to speed
up these brute-force searches to the point where it is feasible to do
searching in the first place, by exotic backtracking techniques using
full-strength continuations
These continuations can avoid searching paths that show little or no
promise, thereby saving time and making the search worthwhile.
Now we could use CL's crippled continuations, implemented by these
built-in CL constructs:
throw
catch
block
go
tag
unwind-protect
prog
tagbody
return
return-from
...but continuations built using these built-in constructs can't do
things that real industrial-strength continuations can do.
We could use Paul Graham's six macros that implement continuations in
CL. They are a little better but still no cigar. The code of these
six macros is very non-intuitive compared to real call/cc
continuations, leading to the chance that mistakes will be made in
coding, and creating a code-maintenance nightmare.
We could temporarily load a Scheme application into RAM memory long
enough to 'do a continuation' - then reload CL back into RAM memory,
but the nature of some backtracking searches is such that this would
have to be done thousands of times for intermediate calculations,
making the search take an intolerable time.
We could build Norvig's imbedded call/cc interpreter, which preserves
the full power of Scheme's call/cc continuations, (including creating
continuations with indefinite extent) - and that is the approach that I
am going to take.
Mark-
Mark Conrad
> Common Lisp has been designed by some _very_ smart people and you can
> bet they knew about continuations - there are reasons why they weren't
> included.
No doubt.
> This subject has been beaten to death here often enough but
> you might want to search Google Groups for...<snipped>...
I will look up your references as to why the designers decided not to
implement continuations, it should be interesting.
They CL designers made a compromise, allowing CL users to create
'crippled' continuations using catch, throw, etc., which can do some of
the things that can be done with more robust continuations.
The fact that many CL users yearn for continuations shows that the
designers of CL might have goofed a little bit when they assumed that
users would not miss industrial strength continuations.
CL is so flexible that industrial strength continuations _should_ be
able to be added to CL, using Norvig's imbedded call/cc interpreter,
assuming Norvig covered all bases in his design of the imbedded
interpreter.
On page 774 Norvig even claims that his interpreter will even support
continuations that have "indefinite extent", as in Scheme.
Norvig's imbedded interpreter will run slower, due to the fact that the
heap is used for storage instead of stacks, but that should not create
all that much of a problem, because CL's garbage collector is
efficient.
It should be interesting when I compare the speed of the imbedded
interpreter against Scheme's continuations.
A note to other Lisp newbies like me:
There is no reason to fear continuations. They are merely a way to
jump out of a function before the function would normally finish.
The function is just "paused" at the point where the continuation was
activated in the middle of the function.
The function can then be "resumed" later if desired, at the exact point
in the code where it was paused or interrupted.
As you can imagine, jumping out of a function before it is normally due
to finish can cause all sorts of problems.
Jumping back into the middle of a 'suspended' function can also cause
all sorts of problems.
Despite all this, continuations allow for all sorts of flexibility if
they are used when no other means is available to solve a particular
programming problem.
Mark-
Edi Weitz
> The fact that many CL users yearn for continuations shows that the
> designers of CL might have goofed a little bit when they assumed
> that users would not miss industrial strength continuations.
I have yet to see a Common Lisp user who "yearns" for
continuations. (Obviously, my definition of a "user" is someone who
has actually used the language for serious stuff.)
Edi.
Kenny Tilton
Mark Conrad wrote:
> A note to other Lisp newbies like me:
>
> There is no reason to fear continuations. They are merely a way to
> jump out of a function before the function would normally finish.
>
> The function is just "paused" at the point where the continuation was
> activated in the middle of the function.
>
> The function can then be "resumed" later if desired, at the exact point
> in the code where it was paused or interrupted.
What is a good example demonstrating the utility of such a thing,
something that is made much easier/clearer/whatever by continuations?
Pascal Costanza
Mark Conrad <nos...@iam.invalid> wrote:
> In article <878yua4...@bird.agharta.de>, Edi Weitz <e...@agharta.de>
> wrote:
>
> > Common Lisp has been designed by some _very_ smart people and you can
> > bet they knew about continuations - there are reasons why they weren't
> > included.
>
> No doubt.
>
> > This subject has been beaten to death here often enough but
> > you might want to search Google Groups for...<snipped>...
>
> I will look up your references as to why the designers decided not to
> implement continuations, it should be interesting.
Please read those references first, _before_ you speculate and make
strong claims about Common Lisp, its designers and the "strength" of
continuations. It's easy to find what appear to be conceptual
shortcomings in Common Lisp on a superficial level, when in fact most of
the decisions in the specification are well-balanced. You need more than
a newbie's first look to find the real weak spots.
BTW, even continuations are not as general as you might think at the
moment. Monads are a generalization of continuations that have found
their way into the Haskell programming language (and they seem to me to
be much easier to be implemented in Common Lisp than continuations). And
they have already found another generalization of monads called arrows.
And there surely will be even further generalization of these things in
the future. "Only the sky is the limit."
At a certain stage you have to stop generalizing things and think about
which of the concepts are actually useful in practice, and then do some
real hacking.
So, as has been stated before, if you are really interested in getting
as abstract as possible, then Common Lisp is probably not the right
language for you. There's nothing wrong in trying to get as abstract as
possible, but there's also nothing wrong in not doing that, and Common
Lispers have a tendency towards the latter.
Matthew Danish
> They CL designers made a compromise, allowing CL users to create
> 'crippled' continuations using catch, throw, etc., which can do some of
> the things that can be done with more robust continuations.
>
> The fact that many CL users yearn for continuations shows that the
> designers of CL might have goofed a little bit when they assumed that
> users would not miss industrial strength continuations.
You are taking a rather strange view of things. If given a choice
between having call/cc only, or having a condition system, catch/throw,
block/return-from, tagbody/go, etc... I will choose the latter. While
call/cc may be used to implement these non-local control transfer
constructs, it is a gigantic pain in the ass. I do not want to use
call/cc to do these mundane tasks. The condition system is infinitely
more useful than call/cc, and Scheme's lack of it is one reason I will
not use Scheme.
I wouldn't call Scheme's continuations industrial-strength anyway. They
are almost useless in industry. Academic-strength, perhaps.
> CL is so flexible that industrial strength continuations _should_ be
> able to be added to CL, using Norvig's imbedded call/cc interpreter,
> assuming Norvig covered all bases in his design of the imbedded
> interpreter.
>
> On page 774 Norvig even claims that his interpreter will even support
> continuations that have "indefinite extent", as in Scheme.
It is not magic, you know.
> Norvig's imbedded interpreter will run slower, due to the fact that the
> heap is used for storage instead of stacks, but that should not create
> all that much of a problem, because CL's garbage collector is
> efficient.
>
> It should be interesting when I compare the speed of the imbedded
> interpreter against Scheme's continuations.
You are failing to understand the implementation of call/cc. I highly
recommend that you sit down and implement a very simple eval function
which can handle call/cc. The easiest way to write this is to do it in
continuation-passing style, and you do not need call/cc to do this.
Norvig covers this, so I presume you are following it.
What you will learn is that support for call/cc must be built into the
implementation of every operator of the language. This also increases
the difficulty of generating efficient code. Hopefully you will also
pick up the difference between writing an interpreter and having call/cc
in CL. Using an embedded interpreter is NOT what I mean by embedding a
language into CL. Compiling into CL is closer; but that is what macros
do.
Personally, I think you can do everything you need to do simply by
writing in continuation-passing style.
sv0f
Kenny Tilton <kti...@nyc.rr.com> wrote:
>What is a good example demonstrating the utility of such a thing,
>something that is made much easier/clearer/whatever by continuations?
The ability to teach undergraduates about...continuations!
Tim Bradshaw
> The fact that many CL users yearn for continuations [...]
Many? How many? And of those `many' how many understand the cost of
continuations-in-the-language? And how does this set compare with
those who insist on mandatory TCO?
> shows that the
> designers of CL might have goofed a little bit when they assumed that
> users would not miss industrial strength continuations.
Or that they made an informed decision based on the implementation
costs versus the benefits. But no, of course, they were fools, we
know that.
Please, the language you want is called *scheme* and it's over that
way.
--tim
Jochen Schmidt
> I will look up your references as to why the designers decided not to
> implement continuations, it should be interesting.
>
> They CL designers made a compromise, allowing CL users to create
> 'crippled' continuations using catch, throw, etc., which can do some of
> the things that can be done with more robust continuations.
>
> The fact that many CL users yearn for continuations shows that the
> designers of CL might have goofed a little bit when they assumed that
> users would not miss industrial strength continuations.
>
> CL is so flexible that industrial strength continuations _should_ be
> able to be added to CL, using Norvig's imbedded call/cc interpreter,
> assuming Norvig covered all bases in his design of the imbedded
> interpreter.
Continuations are a too highlevel tool for a lowlevel need.
Yes it is possible to implement multithreading, a condition system and
backtracking search algorithms using continuations. The question is if it
is really a good idea to do so.
Continuations are like a swiss army knife - they offer from all a bit but
nothing works out. If you want to cut fish for sushi it will be a bad idea
to choose your swiss army knife. The same counts for using it instead of a
real saw or a real screw driver.
Common Lisp is an industrial language. A tool for professional software
developers. Continuations are not an industrial strength tool but a half
arsed emulation utility for real world tools.
ciao,
Jochen
Marc Spitzer
> Continuations are like a swiss army knife - they offer from all a bit but
> nothing works out. If you want to cut fish for sushi it will be a bad idea
> to choose your swiss army knife. The same counts for using it instead of a
> real saw or a real screw driver.
You have just insulted my Swiss Army knife and Leatherman, I have
graduated to a Leatherman. The reason I think that your comparison is
unfair is that the root reason for the "tool box in a pocket" is so
that when you need a tool unexpectedly you have a good shot at having
it and that is a good thing. Scheme does not have that reason for
call/cc, from what little I know about it. I believe the reason is
the same as the refusal to have a looping construct, I know they
recently added "do" for looping. Remember recursion was pure and
looping was bad. call/cc was pure and all the useful bits of call/cc
aka the continuation system was bad.
marc
Nils Kassube
> What is a good example demonstrating the utility of such a thing,
> something that is made much easier/clearer/whatever by
> continuations?
This deserves the label "interesting":
Mark Conrad
> > There is no reason to fear continuations. They are merely a way to
> > jump out of a function before the function would normally finish.
> >
> > The function is just "paused" at the point where the continuation was
> > activated in the middle of the function.
> >
> > The function can then be "resumed" later if desired, at the exact point
> > in the code where it was paused or interrupted.
>
> What is a good example demonstrating the utility of such a thing,
> something that is made much easier/clearer/whatever by continuations?
Heck, I dunno, I am just a clueless newbie.
> ...easier/clearer/whatever by continuations?
Easier/clearer? - definitely not, continuations are tough to use, at
least for me, and they are far from being clear.
Hmm, that leaves "whatever"<g>
Lemme answer this indirectly, to see if it makes any sense to you.
(or to me, for that matter!)
If a new program I created is being executed, and I have periodic
"tests" within the code to determine whether or not the program is
making progress in solving the overall problem, and the tests start
returning indications like:
1) The built-in test code indicates that all is not well. Not only is
the program not making progress, but it is going backwards as regards
to solving the overall problem. Progress _could_ be made if it could
somehow get out of this dead-end part of the program, and jump into a
different part of the program before too much time is wasted.
2) The program needs additional information from a function that has
already completed running in an earlier part of the program. The
program needs to suspend what it is presently doing, get the needed
additional information from the earlier function, then jump back into
the suspended code section and resume running with the additional
information.
3) The program has several interdependent functions running
"at-the-same-time". The built-in tests indicate when it is time to
suspend operation of the one "active" function, and resume operation of
one of the "dormant" functions. Ordinary multitasking OS's can't
handle resuming a function at a specific point inside the function's
code.
All the above off the top of my head. If I was not a clueless newbie,
I could likely think of many more uses for continuations.
Continuations are basically "jumps", something like the "goto"
statements in the old fashioned Basic language.
When used with care, continuations have benefits.
For example, the ultimate "flexible" language is machine-code, which is
loaded with jumps of all sorts.
I think having the option of gaining added flexibility in CL is a good
thing, _provided_ continuations are used with extreme care.
Mark-
Mark Conrad
Costanza <cost...@web.de> wrote:
> Monads are a generalization of continuations that have found
> their way into the Haskell programming language (and they seem to me to
> be much easier to be implemented in Common Lisp than continuations).
Thanks for that info'.
> Please read those references first, _before_ you speculate and make
> strong claims about Common Lisp, its designers and the "strength" of
> continuations.
You are gonna take away all my fun, aren't you ;-)
Mark-
Mark Conrad
<mda...@andrew.cmu.edu> wrote:
> What you will learn is that support for call/cc must be built into the
> implementation of every operator of the language.
I suspected that. Norvig does not say one way or the other whether
his interpreter faithfully supports call/cc in most all respects.
Anyhow, I will have fun finding out what his interpreter will do.
Mark-
Mark Conrad
<j...@dataheaven.de> wrote:
> Continuations are not an industrial strength tool but a half
> arsed emulation utility for real world tools.
Well, I am still trying to make up my mind as to whether continuations
in CL are worth the trouble, as far as I personally am concerned.
My present attitude towards them are to only use them if no other way
is available to do the same thing.
For example, interdependent co-routines, where one of the functions is
run for awhile, then the other function, etc.
Multithreading OS's won't let me pick the exact place in the suspended
function where I want to resume operation. Continuations will.
Another thing, if I have a CL function that takes a long while to run,
say an hour for example, I can use a continuation to halt the function
half way through, shut off my computer, then resume operation later at
the exact point that I interrupted the function.
With conventional CL using catch/throw etc., I would have to restart
the function at the beginning.
Mark-
Nils Goesche
> In article <b7l725$9av$01$1...@news.t-online.com>, Jochen Schmidt
> <j...@dataheaven.de> wrote:
>
> > Continuations are not an industrial strength tool but a half arsed
> > emulation utility for real world tools.
>
> Well, I am still trying to make up my mind as to whether
> continuations in CL are worth the trouble, as far as I personally am
> concerned.
How could you possibly make that decision before actually learning CL?
> My present attitude towards them are to only use them if no other
> way is available to do the same thing.
There is /always/ another way...
> For example, interdependent co-routines, where one of the functions
> is run for awhile, then the other function, etc.
>
> Multithreading OS's won't let me pick the exact place in the
> suspended function where I want to resume operation. Continuations
> will.
So chances are you will design your program differently when writing
in Lisp. You sound like a C++ programmer who thinks he cannot write
programs in Lisp because he hasn't got call-by-reference available
then.
> Another thing, if I have a CL function that takes a long while to
> run, say an hour for example, I can use a continuation to halt the
> function half way through, shut off my computer, then resume
> operation later at the exact point that I interrupted the function.
> With conventional CL using catch/throw etc., I would have to restart
> the function at the beginning.
So you don't use CATCH and THROW but BREAK and CONTINUE or anything
like that. Why do you mention THROW and CATCH all the time? Lisp
programmers hardly ever use these because the condition system is much
more powerful. Defer all that worrying for now and learn to write and
/think/ in Lisp. Chances are you will not even remember ever wanting
continuations then.
Regards,
--
Nils Gösche
"Don't ask for whom the <CTRL-G> tolls."
PGP key ID 0x0655CFA0
Mark Conrad
<s...@below.invalid> wrote:
> > The fact that many CL users yearn for continuations shows that the
> > designers of CL might have goofed a little bit when they assumed that
> > users would not miss industrial strength continuations.
>
> Really? "The fact"? So where are these "many CL users", and why are
> none of them posting here?
Just going by what a previous poster said, about the subject of
continuations being "beaten to death" previously.
If that much energy was devoted to the subject, must have been a lot of
CL users doing the beating.
As to why they are not posting here, they know better because they will
get beaten up by the biased hardheads in this NG.
> > Despite all this, continuations allow for all sorts of flexibility if
> > they are used when no other means is available to solve a particular
> > programming problem.
>
> Like what? Multiprocessing? Most implementations already have that
> (and if yours doesn't, and you think you need it, get one that does).
> Error handling? We have a nice condition system.
Multiprocessing is not fine-grained enough, it can't resume operation
at the exact spot in the function where operation was previously
suspended.
Your "nice condition system" in CL can't handle the types of errors
that rely on CL having "infinite extent". Why? Because catch/throw
etc. only have "dynamic extent".
For example:
=> (+ 1 (catch 'tag (+ 20 (throw 'tag 300))))
301
=> (throw 'tag 500)
Error: there was no pending CATCH for the tag TAG
CL coughs up an imaginary error message here, when there is no error.
With continuations, no false error message is printed.
Mark-
Matthew Danish
> My present attitude towards them are to only use them if no other way
> is available to do the same thing.
You will find that there is almost always another way.
> For example, interdependent co-routines, where one of the functions is
> run for awhile, then the other function, etc.
A very cooperative way of multi-tasking.
> Multithreading OS's won't let me pick the exact place in the suspended
> function where I want to resume operation. Continuations will.
That's not what Multithreaded OSes are for, though. Where is the
pre-emption, as well?
> Another thing, if I have a CL function that takes a long while to run,
> say an hour for example, I can use a continuation to halt the function
> half way through, shut off my computer, then resume operation later at
> the exact point that I interrupted the function.
You have very strange ideas. First, you've forgotten the need to
program your function in such a way that this is possible. Next, you've
forgotten the need to have some way of triggering this "halt", ie. you
must check I/O constantly. Lastly, you forgot to save your image!
> With conventional CL using catch/throw etc., I would have to restart
> the function at the beginning.
* (defun f () (loop))
F
* (F)
;; running ........
;; now I hit Ctrl-C
Interrupted at #x108D3F94.
Restarts:
0: [CONTINUE] Return from BREAK.
1: [ABORT ] Return to Top-Level.
Debug (type H for help)
(UNIX::SIGINT-HANDLER #<unused-arg> #<unused-arg> #.(SYSTEM:INT-SAP #x3FFFE878))
Source:
; File: target:code/signal.lisp
; File has been modified since compilation:
; target:code/signal.lisp
; Using form offset instead of character position.
(DEFINE-SIGNAL-HANDLER SIGINT-HANDLER "Interrupted" BREAK)
0] 0
;; running ....
I will say this once again, since you haven't picked up on it. If you
want Continuation-Passing style, then write your code in CPS!
Catch/throw, conditions, etc, all have more specific purposes and they
do their jobs just fine.
Investigate the CPS interpreter in Norvig's book. It is not difficult.
And it's call/cc is not inferior to Scheme. Call/cc is for hooking into
the implementation's continuations. There is no magic involved.
Kenny Tilton
This particular example of being able to code a web page session as one
continuous top-to-bottom /code/ session sounds yummy, but we don't
program like that anymore anyway, because we need a modeless
architecture to give the user the flexible experience GUI apps were
designed to provide.
That means having enough state to pick up wherever they are and do
whatever they want us to do. And since I cannot anticipate "whatever",
hell, I /want/ to come in the top of my app, not start from a
continuation that will "start" me in the middle of a routine somewhere.
Matthew Danish
> In article <m2of35e...@mycroft.actrix.gen.nz>, Paul Foley
> <s...@below.invalid> wrote:
>
> > Really? "The fact"? So where are these "many CL users", and why are
> > none of them posting here?
>
> Just going by what a previous poster said, about the subject of
> continuations being "beaten to death" previously.
>
> If that much energy was devoted to the subject, must have been a lot of
> CL users doing the beating.
No, Schemers being annoying.
> Your "nice condition system" in CL can't handle the types of errors
> that rely on CL having "infinite extent". Why? Because catch/throw
> etc. only have "dynamic extent".
PLEASE GO AND LEARN CL ALREADY. CATCH AND THROW ARE NOT THE CONDITION
SYSTEM!
Nils Goesche
> In article <m2of35e...@mycroft.actrix.gen.nz>, Paul Foley
> <s...@below.invalid> wrote:
>
> > > The fact that many CL users yearn for continuations shows that
> > > the designers of CL might have goofed a little bit when they
> > > assumed that users would not miss industrial strength
> > > continuations.
> >
> > Really? "The fact"? So where are these "many CL users", and why
> > are none of them posting here?
>
> Just going by what a previous poster said, about the subject of
> continuations being "beaten to death" previously.
It was beaten to death just like now: Not because of Lispers wanting
continuations but because of newbies who do not even know Lisp but
think they have to teach everybody else what's wrong with this
language they don't know.
> As to why they are not posting here, they know better because they
> will get beaten up by the biased hardheads in this NG.
That's right: Call everybody who disagrees with your statements about
a language you don't even know and have no experience with a ``biased
hardhead´´.
> > > Despite all this, continuations allow for all sorts of
> > > flexibility if they are used when no other means is available to
> > > solve a particular programming problem.
You wouldn't believe how much some people would miss the immense
flexibility of FORTRAN's computed GOTO; let alone an Assembly JMP
instruction.
> > Like what? Multiprocessing? Most implementations already have
> > that (and if yours doesn't, and you think you need it, get one
> > that does). Error handling? We have a nice condition system.
>
> Multiprocessing is not fine-grained enough, it can't resume
> operation at the exact spot in the function where operation was
> previously suspended.
Where exactly do you believe operation is resumed after scheduling??
> Your "nice condition system" in CL can't handle the types of errors
> that rely on CL having "infinite extent".
You are being incoherent.
> Why? Because catch/throw etc. only have "dynamic extent".
>
> For example:
>
> => (+ 1 (catch 'tag (+ 20 (throw 'tag 300))))
> 301
>
>
> => (throw 'tag 500)
> Error: there was no pending CATCH for the tag TAG
>
> CL coughs up an imaginary error message here, when there is no
> error.
Of course there is: You misused exceptions. And it is not clear at
all which ``particular programming problem´´, for which there is ``no
other means available´´, calling (throw 'tag 500) a second time is
supposed to solve.
Ingvar Mattsson
> Mark Conrad <nos...@iam.invalid> writes:
>
> > In article <m2of35e...@mycroft.actrix.gen.nz>, Paul Foley
> > <s...@below.invalid> wrote:
> > > > Despite all this, continuations allow for all sorts of
> > > > flexibility if they are used when no other means is available to
> > > > solve a particular programming problem.
>
> You wouldn't believe how much some people would miss the immense
> flexibility of FORTRAN's computed GOTO; let alone an Assembly JMP
> instruction.
Nils, I thought we sent you the latest memo. This year it's computed
COME FROM that's hot. We're going for the inverse of "computed GOSUB"
next year, but we don't have a name yet. "SUB FROM" or "COME SUB" have
both been suggested.
//Ingvar
--
My posts are fair game for anybody who wants to distribute the countless
pearls of wisdom sprinkled in them, as long as I'm attributed.
-- Martin Wisse, in a.f.p
Tim Bradshaw
> Multithreading OS's won't let me pick the exact place in the suspended
> function where I want to resume operation. Continuations will.
Sure they will. Just use some one of the many standard semaphore /
lock mechanisms. I do this all the time.
> Another thing, if I have a CL function that takes a long while to run,
> say an hour for example, I can use a continuation to halt the function
> half way through, shut off my computer, then resume operation later at
> the exact point that I interrupted the function.
Similarly, just use some kind of lock or semaphore. This is hardly
rocket science.
And (native) threads will let you make good use of the multiple
processors that everything but the lowest-end machines now have.
Doing that with call/cc would be ... challenging.
--tim
Thomas F. Burdick
> If that much energy was devoted to the subject, must have been a lot of
> CL users doing the beating.
>
> As to why they are not posting here, they know better because they will
> get beaten up by the biased hardheads in this NG.
And the fact that god doesn't show himself is proof of his existence,
right?
Kenny Tilton
Mark Conrad wrote:
> As to why they are not posting here, they know better because they will
> get beaten up by the biased hardheads in this NG.
We'll know if cll is biased and hard-headed after you stop being both.
The bias is in thinking everything is a nail to the call/cc hammer. Your
problem solutions require call/cc only because the tool is a favorite of
yours and you tend to look for call/cc-centric solutions.
The hard-headedness is in reacting with name-calling to a lot of
sincere, well-meant advice. You won't be getting much more.
There were two ways to react the anti-call/cc chorus. One was to ask,
do these folks know something I do not? The other was to presume you
have run into bias.
The latter has the advantage of not requiring you to learn anything new.
Duane Rettig
> In article <m2of35e...@mycroft.actrix.gen.nz>, Paul Foley
> <s...@below.invalid> wrote:
>
> > > The fact that many CL users yearn for continuations shows that the
> > > designers of CL might have goofed a little bit when they assumed that
> > > users would not miss industrial strength continuations.
> >
> > Really? "The fact"? So where are these "many CL users", and why are
> > none of them posting here?
>
> Just going by what a previous poster said, about the subject of
> continuations being "beaten to death" previously.
>
> If that much energy was devoted to the subject, must have been a lot of
> CL users doing the beating.
Most of the energy I'm spending on this subject is being spent reading
this thread which you refuse to just let die.
> As to why they are not posting here, they know better because they will
> get beaten up by the biased hardheads in this NG.
You refuse to consider another possibility - that you're simply wrong,
and that there are not many CL users who yearn for continuations.
As an implementor, I have the right and the capability to add extensions
to the implementation I support. I add many such extensions, as time
allows, when my customers ask me for them.
I just went to our spr (softwware-problem-report) database, which has
every customer interaction from 1989 to present, and which includes
problems _and_ requests by customers for enhacement to our product.
I only found two sprs which even had continuations in the subject line,
and of those, one was really about debugging. The other was sent to
us in August of 1993 by a customer who was converting a Scheme program
to our lisp, and wanted Scheme-like continuations. We interacted with
him for a while, trying to be helpful by suggesting that he use Screamer,
but on his own he came back with the announcement that our multiprocessing
system would satisfy his needs.
No, CL users simply don't yearn for contiuations.
--
Duane Rettig du...@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
Tim Bradshaw
> Multiprocessing is not fine-grained enough, it can't resume operation
> at the exact spot in the function where operation was previously
> suspended.
Look, this is not hard.
(let ((x (make-lock :name "wait" :state :unlocked)))
(values (make-thread
"foo"
#'(lambda ()
...
(wait x)
...))
x))
--tim
Tim Bradshaw
> Just going by what a previous poster said, about the subject of
> continuations being "beaten to death" previously.
One person is quite enough to cause a huge frenzy in newsgroups.
Search for Ilias on cll in google groups, say.
--tim
Eduardo Muñoz
> In article <m2of35e...@mycroft.actrix.gen.nz>, Paul Foley
> <s...@below.invalid> wrote:
>
> > > The fact that many CL users yearn for continuations shows that the
> > > designers of CL might have goofed a little bit when they assumed that
> > > users would not miss industrial strength continuations.
> >
> > Really? "The fact"? So where are these "many CL users", and why are
> > none of them posting here?
>
> Just going by what a previous poster said, about the subject of
> continuations being "beaten to death" previously.
>
> If that much energy was devoted to the subject, must have been a lot of
> CL users doing the beating.
The beating was done by Mr Naggum with exquiste style. The
beating subject being the schemer wannabe though.
BTW, does anybody has news about Erik?
He has dissapeared from usenet and his website
(www.naggum.no) has been down for some time now. I remember
that he mentioned some kind of illness.
I really miss his icepick-like humor.
--
Eduardo Muñoz | (prog () 10 (print "Hello world!")
http://213.97.131.125/ | 20 (go 10)) ;)
William D Clinger
> ....Scheme does not have that reason for
> call/cc, from what little I know about it. I believe the reason is
> the same as the refusal to have a looping construct, I know they
> recently added "do" for looping.
True. Even more recently, in the early 1980s, Common Lisp followed
Scheme's lead on this by adopting a version of DO whose syntax is
similar to that of Scheme, albeit with a subtly different semantics.
Will
Fred Gilham
> 1) The built-in test code indicates that all is not well. Not only
> is the program not making progress, but it is going backwards as
> regards to solving the overall problem. Progress _could_ be made if
> it could somehow get out of this dead-end part of the program, and
> jump into a different part of the program before too much time is
> wasted.
This sounds like backtracking. Continuations CAN be used to implement
backtracking, but there are other ways to do it.
> 2) The program needs additional information from a function that has
> already completed running in an earlier part of the program. The
> program needs to suspend what it is presently doing, get the needed
> additional information from the earlier function, then jump back
> into the suspended code section and resume running with the
> additional information.
>
> 3) The program has several interdependent functions running
> "at-the-same-time". The built-in tests indicate when it is time to
> suspend operation of the one "active" function, and resume operation
> of one of the "dormant" functions. Ordinary multitasking OS's can't
> handle resuming a function at a specific point inside the function's
> code.
These two both sound like something that would be accomplished using
various multiprocessing constructs. Continuations can be used to
implement multiprocessing but there are other ways to do it.
I am particularly confused by your comment that "Ordinary multitasking
OS's can't handle resuming a function at a specific point inside the
function's code." I wonder what exactly you think ordinary
multitasking OSs do. (Or perhaps by "ordinary" you mean "cooperative"
or "products of Microsoft" or something, in which case I could
understand your comment a little better....)
One of the points of Scheme is to implement extremely powerful,
general constructs that can be used to implement programming
constructs that people are used to. Pedagogically speaking this seems
to be a good idea. However, for getting things done it is a bit like
asking a carpenter to carry the entire carpentry shop to the job site
in order to pound some nails. At the same time, as Eric Naggum once
said, using Scheme is like going to buy a beer mug and getting a pile
of sand and an electric furnace. You wind up with a lot of baggage,
but you still have to do much of the work yourself.
For example, one of the drawbacks of Scheme continuations is that they
require everything to be heap-allocated, since if a function allocates
things on the stack it can't be resumed once it has returned. This
can lead to inefficiency.
Another drawback is that it complicates the implementation of
unwind-protect. If you save a continuation inside an unwind-protect,
should you execute the exit clauses of the unwind-protect every time
you resume the continuation? This could result in, for example,
closing already closed files. Unwind-protect is such a valuable
feature that this alone would be considered a killer for call/cc by
some.
Here's a quotation from Kent Pitman about this:
I, for one, am glad not to see continuations in CL. If someone
proposed adding them, I would argue strongly against the move. I
feel about them the same way as others feel about GO. They
encourage unstructured programming and I think they're a semantic
mess. (No, I don't mean they can't be defined in a formal
semantics. I mean there is no proof that being modelable in a
formal semantics implies being a good way for a human being to
think about or describe something.) Critically absent from
continuations (i.e., procedurally embedded in them, and therefore
not always "apparent"--halting problems and all, you know) is the
answer to the question "is this the last time this continuation
will return?", which makes a mess of any attempt to attach a
rational semantics to unwind-protect. Scheme doesn't offer
unwind-protect, of course; it leaves it as an exercise to the
(human) reader. But you can see hints of how ugly the situation
would be in 6.6.1 Ports in the Revised^5 Report on Scheme by
realizing that unwind-protect or its equivalent is subprimitive
to call-with-input-file, and realizing the war between
unwind-protect and continuations is what leads to the mega-yuck
wording there.
> All the above off the top of my head. If I was not a clueless
> newbie, I could likely think of many more uses for continuations.
>
> Continuations are basically "jumps", something like the "goto"
> statements in the old fashioned Basic language.
>
> When used with care, continuations have benefits.
>
> For example, the ultimate "flexible" language is machine-code, which
> is loaded with jumps of all sorts.
>
> I think having the option of gaining added flexibility in CL is a
> good thing, _provided_ continuations are used with extreme care.
Nope, continuations aren't jumps. They are more powerful than that
because they snapshot the state of the computation.
The problem with continuations is not their *use* so much as their
implementation. Implementing continuations has an effect on the
entire system, but they only solve a small number of problems (in
fact, you yourself are somewhat hard-pressed to name problems they
solve). Thus Common Lisp designers, who are less concerned about
pedagogy and more concerned for obtaining production code, turn to
less general but also less expensive mechanisms for solving the
problems that continuations would otherwise solve.
This is a clue. Note that if you "have" it, you will no longer be a
clueless newbie. Are you willing to make the jump?
--
Fred Gilham gil...@csl.sri.com
The amazing thing is, back when I was a C++ programmer, I thought that
[Design Patterns] was SUCH a great book. And I guess it was, in a
way: it made it possible to use C++ and get something done. In the
long run, of course, that may have been a disservice... - Alain Picard
Paolo Amoroso
> They CL designers made a compromise, allowing CL users to create
> 'crippled' continuations using catch, throw, etc., which can do some of
> the things that can be done with more robust continuations.
It might be instructive to compare the experience and skills of the Common
Lisp users who yearn for "industrial strength continuations", and the
Common Lisp designers themselves.
Paolo
--
Paolo Amoroso <amo...@mclink.it>
Kent M Pitman
> BTW, does anybody has news about Erik? He has dissapeared from
> usenet and his website (www.naggum.no) has been down for some time
> now. I remember that he mentioned some kind of illness.
>
> I really miss his icepick-like humor.
(I do, too.) I correspond with him now and then by email, and find
his wit to be as keen as ever. He has a different ISP, which I'm sure
he is capable of advertising if he wants people to know about it, so I
won't do that for him. For reasons personal to him, he seems to just
be choosing to do other things, at least for now.
Ivan Boldyrev
> tugly...@aol.commune (Andrew Burton) writes:
> > The ANSI Common Lisp, clisp
>
> Note that clisp is only one implementation of common lisp.
Do you mean "is not only one"?
--
Ivan Boldyrev
PGP fp: 3640 E637 EE3D AA51 A59F 3306 A5BD D198 5609 8673 ID 56098673
Today is the first day of the rest of your life.
Erann Gat
<pit...@world.std.com> wrote:
One of the things that Erik did frequently was excoriate people for
talking about him instead of Lisp. So following his example:
Will all you pathetic whiners who are pining for the return of Lord
Naggumort please move your sniveling to this thread so that those of us
who don't miss his psychotic ranting can carry on talking about Lisp
without this distraction?
Thank you.
E.
P.S. I have a nice sharp ice pick here for anyone who really feels the need.
Kent M Pitman
Sure, I'll move my "I'm done for this month" post to this list. To be
clear, this message of mine here would not have happened had this new
thread not been created.
First, I don't happen to count what we were doing as whining. We were
exchanging a human courtesy of being concerned about one absent who
had been listed as ill, and assuring others that the person was still
alive. It was two messages, and it did not require a thread. A question
asked and answered, easily found by someone who cared using Google, easily
ignored by someone who didn't care.
Next, I hope that you, Erann, or anyone, if they are ever gone for a
community are remembered for the best they contributed, not the worst.
Not all of us come free of baggage. Some people seem to slug through my
posts because they find some value in them, but I'm forever amazed by the
ability of others to say the same thing as I often set out to say in
ever so much simpler a fashion. I'd like to think I'll not just be
remembered for being long-winded, even if that's clearly an aspect of
who I am.
I have said before and I'll say it again, I do not approve of people
writing detracting posts about other people. That's not to say I make
the rules. There are, effectively, no rules, since there is no material
mode of enforcement. This is a free speech forum.
http://www.nhplace.com/kent/PFAQ/usenet-freedom.html
I claim it's better to ignore what you don't like, since everyone
doesn't like something and there is no power to make things you don't
like go away. In this case, the thing you don't like is even gone,
and you still find the need to say something bad about it.
Furthermore, I have also said that I find it a faux pas of a higher
order to start a new thread to excoriate someone because then even
people who were just visiting the newsgroup and surveying the topics
discussed will find your post. Putting something in a subject line is
like putting a private conversation up a billboard. I think the
people who are deep down in an thread are few to start with, and
that's the _best_ time for something to get unnecessarily personal, if
it's going to be at all (which I wish it wouldn't be), because it's
largely buried by its nature. Putting something in a thread subject
adds fuel to what may be only a potential fire, veritably assuring it
will ignite. (Incidentally, I think it had burned itself out as of my
post. It was just two isolated messages, and you have now fanned the
dimming embers back to life.)
And finally, I have also noted that for the same reason as I don't think
people should whine at other people, I am being hypocritical myself if
I don't follow my own whining, into which you have drawn me, with some
sort of punitive action that acknowledges I'm doing exactly the thing
I'm saying shouldn't be done. I impose no sanction on you; I have no
power to do that, nor per se right to judge. But for myself, I do have
both the power and, arguably, the responsibility. So as penalty for my
contributing to the fanned embers of negativism, I withdraw from
newsgroup posts for the remainder of this month. Shame on me. See you
all when hopefully I've calmed down, and this thread, too, sometime
after the start of May.
--Kent
Daniel Barlow
> On 8349 day of my life Mario S. Mommer wrote:
>> tugly...@aol.commune (Andrew Burton) writes:
>> > The ANSI Common Lisp, clisp
>>
>> Note that clisp is only one implementation of common lisp.
>
> Do you mean "is not only one"?
"clisp" is usually a reference to the Common Lisp implementation
called "GNU CLISP", available from http://clisp.cons.org/ or
http://clisp.sf.net/
Overlaoding the term to refer to Common Lisp in general strikes me as
a bad idea, liable to lead to confusion, especially when "CL" already
does quite nicely in that latter role.
-dan
--
http://www.cliki.net/ - Link farm for free CL-on-Unix resources
Erann Gat
<pit...@world.std.com> wrote:
> g...@jpl.nasa.gov (Erann Gat) writes:
> > One of the things that Erik did frequently was excoriate people for
> > talking about him instead of Lisp. So following his example:
> >
> > Will all you pathetic whiners who are pining for the return of Lord
> > Naggumort please move your sniveling to this thread so that those of us
> > who don't miss his psychotic ranting can carry on talking about Lisp
> > without this distraction?
> First, I don't happen to count what we were doing as whining.
I was not addressing you specifically. I was addressing pathetic
whiners. If you are not a pathetic whiner then I was obviously not
talking to you.
> It was two messages,
Treacly nostalgia for he-who-must-not-be-named has been stealthily
appearing in many contexts since he went to ground. These two messages
just pushed me past my limit of tolerance.
> Next, I hope that you, Erann, or anyone, if they are ever gone for a
> community are remembered for the best they contributed, not the worst.
Well, I appreciate that. Do you hope that Saddam Hussein will be
remembered for the good he did for Iraq? Do you think we should remember
Hitler for lifting Germany out of its horrible economic conditions?
(Godwin was right.)
> Not all of us come free of baggage. Some people seem to slug through my
> posts because they find some value in them, but I'm forever amazed by the
> ability of others to say the same thing as I often set out to say in
> ever so much simpler a fashion. I'd like to think I'll not just be
> remembered for being long-winded, even if that's clearly an aspect of
> who I am.
There's nothing wrong with being long-winded. There's a lot wrong with
being uncivil, even on usenet (maybe especially on usenet). (And yes, I
admit I was somewhat uncivil before. I was emulating Erik's style for the
benefit of those who claimed to miss him. Sue me.)
> I have said before and I'll say it again, I do not approve of people
> writing detracting posts about other people. That's not to say I make
> the rules. There are, effectively, no rules, since there is no material
> mode of enforcement. This is a free speech forum.
I agree with this. I am on the record as defending Erik's (and by
implication everyone else's) right to post whatever they want on c.l.l.
http://groups.google.com/groups?selm=gat-1201021625040001%40192.168.1.50
Nonetheless I believe that he did far more harm than good, and that his
departure is a net win for Lisp.
In my assessment, c.l.l. has seen a renaissance since he left. A dozen
local Lisp interest groups have sprung up overnight. New people have come
and not been chased away. We even managed to talk about the war without
it degenerating into a flamefest! (Someone even commented on how
impressed he was that we could do that, though I can't find the reference
just now.)
> I claim it's better to ignore what you don't like,
Of course it's better. The problem is that it only works if everyone does
it, and the fact is that almost no one does it, not even you (and
certainly not Erik). If you did we would not be having this discussion.
> since everyone
> doesn't like something and there is no power to make things you don't
> like go away. In this case, the thing you don't like is even gone,
> and you still find the need to say something bad about it.
No, the thing I don't like is not gone, it is right here in my face. The
thing I don't like is the hypocricy of being told that I should ignore
what I don't like by someone who is obviously not ignoring what they don't
like. The gall! The minute you start to follow your own advice this
conversation will be over.
> Furthermore, I have also said that I find it a faux pas of a higher
> order to start a new thread to excoriate someone because then even
> people who were just visiting the newsgroup and surveying the topics
> discussed will find your post. Putting something in a subject line is
> like putting a private conversation up a billboard. I think the
> people who are deep down in an thread are few to start with, and
> that's the _best_ time for something to get unnecessarily personal, if
> it's going to be at all (which I wish it wouldn't be), because it's
> largely buried by its nature. Putting something in a thread subject
> adds fuel to what may be only a potential fire, veritably assuring it
> will ignite. (Incidentally, I think it had burned itself out as of my
> post. It was just two isolated messages, and you have now fanned the
> dimming embers back to life.)
You are making the false assumption that my intent was to stop people from
posting nostalgic remembrances of Erik. It was not. As I said, I too
believe in free speech. You Erik-worshippers have the right to advertise
your nostalgia for him. I likewise have the right to dissent, which is
what I am doing here. I think that as a common courtesy all such
off-topic posts should be clearly marked as such, which is the reason I
started this new thread. I don't want to silence this discussion, I
*want* to fan the flames (hopefully we can all get this out of our systems
once and for all), but I want the flames isolated and clearly marked.
That's how we managed to talk about the war without things getting out of
hand, and that's how I hope we'll get past this without things getting out
of hand. So all you folks who miss Erik, post here and get it out of your
system. All you who wish him consigned to the depths do likewise, but do
it here in this off-topic thread so the rest of us can get on with the
business at hand in the rest of the newsgroup.
> And finally, I have also noted that for the same reason as I don't think
> people should whine at other people, I am being hypocritical myself if
> I don't follow my own whining, into which you have drawn me,
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
I have done no such thing. I am not holding a gun to your head. You are
posting these things of your own free will. Don't try to blame your
shameful hypocricy on me.
> with some
> sort of punitive action that acknowledges I'm doing exactly the thing
> I'm saying shouldn't be done. I impose no sanction on you; I have no
> power to do that, nor per se right to judge. But for myself, I do have
> both the power and, arguably, the responsibility. So as penalty for my
> contributing to the fanned embers of negativism, I withdraw from
> newsgroup posts for the remainder of this month. Shame on me. See you
> all when hopefully I've calmed down, and this thread, too, sometime
> after the start of May.
Oh, Kent, grow up will you? You're really getting too old for this
I'm-going-to-take-my-ball-and-bat-and-go-home game.
E.
Nils Goesche
> hypocricy
Please, guys: It's /hypocrisy/, not hypocricy.
Just say NO to this thread.
Regards,
--
Nils Gösche
Ask not for whom the <CONTROL-G> tolls.
PGP key ID #xD26EF2A0
Tim Bradshaw
> P.S. I have a nice sharp ice pick here for anyone who really feels the need.
Just use it on your own head, why don't you, and do us all a favour?
--tim
Tim Daly, Jr.
> g...@jpl.nasa.gov (Erann Gat) writes:
>
...
> > One of the things that Erik did frequently was excoriate people for
> > talking about him instead of Lisp. So following his example:
> >
> > Will all you pathetic whiners who are pining for the return of Lord
> > Naggumort please move your sniveling to this thread so that those of us
> > who don't miss his psychotic ranting can carry on talking about Lisp
> > without this distraction?
> >
> > Thank you.
> >
> > E.
> >
> > P.S. I have a nice sharp ice pick here for anyone who really feels the need.
>
> Sure, I'll move my "I'm done for this month" post to this list. To be
> clear, this message of mine here would not have happened had this new
> thread not been created.
...
Sir Gat, at the risk of an ice pick through the toe, wasn't your post
meant to be amusing?
This is usenet, my good man! Psychotic ranting is the nature of the
beast.
I've also wondered what happened to Erik. It's not c.l.l without him.
-Tim
--
Pascal Costanza
wrote:
> I've also wondered what happened to Erik. It's not c.l.l without him.
Of course, this is c.l.l - check the settings of your news reader.
I am glad that EN has left this group, and I hope that he will never
return again. But I agree that this thread is not very useful.
Pascal
P.S.: I hope that kmp stays here, because usually I find his posts to be
extremely helpful and enlightening, even when I don't agree with some of
his conclusions.
--
"If I could explain it, I wouldn't be able to do it."
A.M.McKenzie
Nils Goesche
> In article <87u1cw3...@tenkan.org>, t...@tenkan.org (Tim
> Daly, Jr.) wrote:
>
> > I've also wondered what happened to Erik. It's not c.l.l
> > without him.
>
> Of course, this is c.l.l - check the settings of your news
> reader.
Nothing can beat German humor.
> I am glad that EN has left this group, and I hope that he will
> never return again.
What the fuck is wrong with you people? To make it clear even to
the ethically most challenged: Kicking at people who cannot
defend themselves because they haven't been around for several
months is not only immoral, it is also low, disgusting and a sign
of bad character.
> But I agree that this thread is not very useful.
Useful enough to add fuel to it, it seems.
Kenny Tilton
Nils Goesche wrote:
> What the fuck is wrong with you people?
Precisely. We have only had two bullshit threads lately, and Erann has
started them both. Pascal had chalked up a lot of points in my book,
then tossed them all with one mean-spirited sentence. And to think they
both pose as Protectors of c.l.l. chya!
The problem we all have is not wanting to perpetuate a bullshit thread,
but at the same time not wanting the bullshit to go unanswered. kwmp
dashed himself on the rocks of this conflict, lies now in drydock.
What we need is a non-continuing continuation, and your casting of the
problem ("what the fuck is wrong with [Erann and Pascal]") solves that
neatly; we can now dissect /their/ characters over the next couple of
dozen articles. Erann especially likes it when we dissect him when he
asks us to dissect others.
Scalpel!
ps. My honest take on this is that Erann was trying with his seemingly
harsh post to provoke the ENth Coming. And Pascal seems like an OK guy,
maybe he was doing his best to help. In this benign light, cll is forgiven.
Kumar Balachandran
I can easily think in terms of machine language to figure out how call/cc
would work. However, any serious scheme code with call/cc seems so bloody
obfuscated to me, I always give up trying to understand it.
If programs are a method of communicating with other programmers, then
call/cc has failed miserably, rather like my poem below.
Little Jack Horner
sat in a corner
Coding and Scheming against LISP.
He called Forth
obfuscation galore
but on continuation felt something amiss.
Seriously, I have never found the patience to really grok this wonderful
thing. I can always achive the set goals in a very readable manner in other
ways.
K.
>
> A note to other Lisp newbies like me:
>
> There is no reason to fear continuations. They are merely a way to
> jump out of a function before the function would normally finish.
>
> The function is just "paused" at the point where the continuation was
> activated in the middle of the function.
>
> The function can then be "resumed" later if desired, at the exact point
> in the code where it was paused or interrupted.
>
> As you can imagine, jumping out of a function before it is normally due
> to finish can cause all sorts of problems.
>
> Jumping back into the middle of a 'suspended' function can also cause
> all sorts of problems.
>
> Despite all this, continuations allow for all sorts of flexibility if
> they are used when no other means is available to solve a particular
> programming problem.
>
> Mark-
Erann Gat
<kti...@nyc.rr.com> wrote:
> We have only had two bullshit threads lately, and Erann has
> started them both.
Frankly, compared to how much bullshit was being slung around here in the
EN days I think two bullshit threads in a month is doing pretty well.
Still, I am fairly chagrined to realize that Kenny is right. I apologize,
and hereby depart this thread.
E.
Vijay L
> In article <sfwlly8...@shell01.TheWorld.com>, Kent M Pitman
> <pit...@world.std.com> wrote:
>
> > g...@jpl.nasa.gov (Erann Gat) writes:
>
> > > One of the things that Erik did frequently was excoriate people for
> > > talking about him instead of Lisp. So following his example:
> > >
> > > Will all you pathetic whiners who are pining for the return of Lord
> > > Naggumort please move your sniveling to this thread so that those of us
> > > who don't miss his psychotic ranting can carry on talking about Lisp
> > > without this distraction?
>
> > First, I don't happen to count what we were doing as whining.
>
> I was not addressing you specifically. I was addressing pathetic
> whiners. If you are not a pathetic whiner then I was obviously not
> talking to you.
>
written, you'd have given the same response. Since that "whining"
remark was directed specifically towards Erik (and some others), I
wonder what your response would have been if Erik'd said: "First, I
don't happen to count what we were doing as whining."
>
> Nonetheless I believe that he did far more harm than good, and that his
> departure is a net win for Lisp.
>
My memory of Erik is this: he was a lisp expert, and never hesitated
to bring anyone flying back to the ground. And I agree that in all
these `fights' started because of a reply from him to someone, he
always said that he added "hooks" in his posts to see if anyone would
fall for them; it turned out that most people did (especially, for
some reason, you and your colleagues). Then you would all get into
great verbal debates etc etc., which, as far as I always noticed,
ended up with Erik winning hands down. (I talk only about those posts
where the two parties argue about non-lisp matters etc.)
>
> > I claim it's better to ignore what you don't like,
>
> Of course it's better. The problem is that it only works if everyone does
> it, and the fact is that almost no one does it, not even you (and
> certainly not Erik). If you did we would not be having this discussion.
>
It would work if you had your own set of standards, and did not depend
on another person's behaviour to act on your own. If a man steals
from you, that does not justify your stealing from him. If you do
both of you are theives, with none nobler than the other. If you'd
chosen to ignore Erik, you were free to at all times. It takes two
hands to clap (or two to tango) and your continued arguing with him
puts you in no position to judge him. The only reason you continually
argued with him was ego. Refusing to respond meant losing, and that
was something you were never willing to accept. But at all times you
would talk about how degenerate the discussions were etc., but with no
end of them in sight. Again, saying "I shouldn't respond to your
trash." wouldn't work because Erik would always say, "And that
wouldn't have worked without this message would it?" or some such, and
you'd all be hooked in again.
> > And finally, I have also noted that for the same reason as I don't think
> > people should whine at other people, I am being hypocritical myself if
> > I don't follow my own whining, into which you have drawn me,
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> I have done no such thing. I am not holding a gun to your head. You are
> posting these things of your own free will. Don't try to blame your
> shameful hypocricy on me.
In that case, Erik never picked a fight with you; he wasn't holding a
gun at /your/ head either. You chose to draw yourself into a fight
(and always ended up making a fool of yourself). Don't try to blame
your shameful hypocricy on Erik.
P.S. Your next post will counter every statement I've made. So, FWIW,
you win.
Thanks,
Vijay L
Pascal Costanza
Nils Goesche <n...@cartan.de> wrote:
> > I am glad that EN has left this group, and I hope that he will
> > never return again.
>
> What the fuck is wrong with you people? To make it clear even to
> the ethically most challenged: Kicking at people who cannot
> defend themselves because they haven't been around for several
> months is not only immoral, it is also low, disgusting and a sign
> of bad character.
I wonder in which way my statement can be interpreted as "kicking at
people". I have just stated a personal, subjective opinion. How could
anybody be able to defend themselves against expressions of antipathy in
any case?
The reason for my statement is as follows: Several other people have
stated that they miss EN. It has just started to look as if this was a
generally accepted notion. I just wanted to clarify that it is not.
> > But I agree that this thread is not very useful.
>
> Useful enough to add fuel to it, it seems.
see above
Pascal
Mark Conrad
wrote:
> > Why? Because catch/throw etc. only have "dynamic extent".
> >
> > For example:
> >
> > => (+ 1 (catch 'tag (+ 20 (throw 'tag 300))))
> > 301
> >
> >
> > => (throw 'tag 500)
> > Error: there was no pending CATCH for the tag TAG
> >
> > CL coughs up an imaginary error message here, when there is no
> > error.
>
> Of course there is: You misused exceptions.
Okay, I will acknowledge that the error message was genuine.
So hang me, I made a mistake in my wording, I *know* that it was a real
error.
The point is, if I had used a "CL continuation", i.e. extended CL so it
would recognize continuations (continuations with infinite extent) - -
- then no error message would have occured.
Example:
[Assume this is done in an 'extended' CL that recognizes call/cc ,
I am guessing somewhat at the code below, but the important point is
that we are assuming that CL was extended to recognize call/cc and that
call/cc has infinite extent, allowing the continuation to be used
repeatedly to return to the same point in the code - - - immediately
after the (+ 1... ]
(defvar *prior-cc* "an unimportant initial value")
==> (+ 1 (call/cc #'(lambda (cc)
(setf *prior-cc* cc)
(+ 20 (cc 300))) ))
301
==> (funcall *prior-cc* 500)
501
==> (funcall *prior-cc* 300)
301
==> (funcall *prior-cc* 0)
1
The above continuation is "used" a total of four times, to return me to
the same spot in the lambda function, right after the (+ 1
(assuming I can force code somewhat like the above example to work)
The (+ 20... is ignored in all cases, that is how continuations work,
they depend heavily on the 'order of evaluation' rules of a language,
and in this case the (cc 300) in the lambda function is evaluated
*before* the (+ 20
I would give my eye teeth if I could do everything that continuations
do by some other means in CL.
Right now I am concentrating on the above trivial code.
Someone said that they did not believe that Norvig's Scheme interpreter
on pages 756-777 would do the job of getting CL "extended" to recognize
continuations.
Belatedly, I am inclined to agree. :-(
Mark-
Mark Conrad
<mda...@andrew.cmu.edu> wrote:
> > Your "nice condition system" in CL can't handle the types of errors
> > that rely on CL having "infinite extent". Why? Because catch/throw
> > etc. only have "dynamic extent".
>
> PLEASE GO AND LEARN CL ALREADY. CATCH AND THROW ARE NOT THE CONDITION
> SYSTEM!
PRETTY HARD TO DO WHEN "CONDITION SYSTEM" IS NOWHERE IN THE INDEX OF
RECOGNIZED CL BOOKS LIKE NORVIG'S "ARTIFICIAL INTELLIGENCE
PROGRAMMING".
SUBTITLE "CASE STUDIES IN COMMON LISP"
...or any other CL book I have, for that matter.
Speak Amelican, for crying out loud !
Mark-
Mark Conrad
> > Another thing, if I have a CL function that takes a long while to run,
> > say an hour for example, I can use a continuation to halt the function
> > half way through, shut off my computer, then resume operation later at
> > the exact point that I interrupted the function.
> > With conventional CL using catch/throw etc., I would have to restart
> > the function at the beginning.
>
> * (defun f () (loop))
>
> F
> * (F)
>
> ;; running ........
> ;; now I hit Ctrl-C
>
> Interrupted at #x108D3F94.
>
> Restarts:
> 0: [CONTINUE] Return from BREAK.
> 1: [ABORT ] Return to Top-Level.
>
> Debug (type H for help)
Your example code will work if I leave the power on to my computer, but
not if I shut the computer off, then power up later.
Is there some CL feature that will allow me to do that, so I can get
away from "continuations" for this particular chore?
Mark-
Paul F. Dietz
> PRETTY HARD TO DO WHEN "CONDITION SYSTEM" IS NOWHERE IN THE INDEX OF
> RECOGNIZED CL BOOKS LIKE NORVIG'S "ARTIFICIAL INTELLIGENCE
> PROGRAMMING".
Mr. Conrad, blaming others for your own mistakes is a sign of a
seriously defective character. You really shouldn't advertise this
on usenet.
Paul
Andrew Burton
> Note that clisp is only one
> implementation of common lisp.
This was actually my eyes and my brain having a fight. When I got home that
night I made them sit down, talk it out, and they had great make up synapses.
;;
(defun (very) (list (format t "very~%") (very)))
;;
I saw a link to a page about "The ANSI Common Lisp" or something at
clisp.cons.org and thought it was "The ANSI Common Lisp." Suffice to say I was
(very) wrong in what I read.
Andrew Burton -- tuglyraisin at aol dot com
Felecia Station on Harvestgain
Jipi: Don't Believe everything the Net tell you.
Chip: I agree with this. My inputs are not to be trusted.
CROW: Quick, save the Robot Ashley!
Lars Brinkhoff
> Pretty hard to do when "condition system" is nowhere in the index of
> recognized CL books like Norvig's "Artificial Intelligence Programming".
> ...or any other CL book I have, for that matter.
CLtL2 is a quite widely recognized CL book. Check out chapter 29.
Franz Kafka
(progn
(concatenate 'string "It can also be used to " "show American pride.")
(concatenate 'string "Use it on Ossama's Face " "along with a rusty razor.")
(concatenate 'string "Also use it " "on Saddam's face.")
(concatenate 'string "And on any " "Terrorists caught on American soil.")
(concatenate 'string "Then shove it" "up their @r$3.")
)
;; Writing vile sarcastic messages in Lisp code is sure fun.
;; Lisp can provide a solution to the problem of Terrorism.
;; And, the solutions to many other problems, too: Iraq, Ossama, etc.
;; Remember to dispose of the ice pick/ razor.
Paul Foley
> I would give my eye teeth if I could do everything that continuations
> do by some other means in CL.
Well, how about telling us what you actually want to do, rather than
just posting a bunch of nonsense code? Then perhaps someone could
tell you how to do it without continuations. If you don't say what
you want to do, noone can even try to help you.
> Right now I am concentrating on the above trivial code.
Fine, just replace
(1+ (call/cc ...))
with the much simpler
(funcall (setq *prior-cc* #'1+) 300)
--
There is no reason for any individual to have a computer in their home.
-- Ken Olson, President of DEC
(setq reply-to
(concatenate 'string "Paul Foley " "<mycroft" '(#\@) "actrix.gen.nz>"))
Eduardo Muñoz
> Will all you pathetic whiners who are pining for the return of Lord
> Naggumort please move your sniveling to this thread so that those of us
> who don't miss his psychotic ranting can carry on talking about Lisp
> without this distraction?
Talking about the war is so much better, isnt it?
Get a brain, a personality and some manners and you will be
missed when you go away too.
> Thank you.
Fuck you
> P.S. I have a nice sharp ice pick here for anyone who really feels the need.
Put it up your ass.
--
Eduardo Muñoz | (prog () 10 (print "Hello world!")
http://213.97.131.125/ | 20 (go 10))
Will Hartung
"Nils Goesche" <n...@cartan.de> wrote in message
news:874r4wvb...@darkstar.cartan...
> Pascal Costanza <cost...@web.de> writes:
> > But I agree that this thread is not very useful.
>
> Useful enough to add fuel to it, it seems.
The interesting thing is that, not knowing him personally, I have this
feeling that a lot of the ill will (in all directions) that surrounds EN
seems to stem not only from the personalities involved, but also the medium
of conversation.
If the conversations that explode off on to their own thread branches had
started in person, I bet they all would have died fairly quickly and
quietly, and ideally peacably, compared to the anger and such on USENET.
Inevitably the debate drifted off the topic and to various forms of debating
techique and understanding of the principles of formal argument and then
inevitably into the personal insults.
As has been made clear I think over and over, email, USENET, BBSs, etc are
great ways to exchange and transfer information, particularly technical and
factual information. But they are terrible ways facilitate "communication"
between people. It is such a low bandwidth medium compared to what we are
used to when working face to face.
The other example is how two people who meet each other on a street in their
cars end up screaming at each other (in their cars), whereas were they to
meet in person (say at a door), nothing would happen -- one would go first,
the other second and neither think twice about it.
So, consider this next time things get completely out of hand, that it might
not just be the messenger, but also the medium.
Regards,
Will Hartung
(wi...@msoft.com)
Nikodemus Siivola
> PRETTY HARD TO DO WHEN "CONDITION SYSTEM" IS NOWHERE IN THE INDEX OF
> RECOGNIZED CL BOOKS LIKE NORVIG'S "ARTIFICIAL INTELLIGENCE
Try HyperSpec:
http//www.lispworks.com/reference/HyperSpec/Body/09_.htm
Or Google, even:
http://www.google.com/search?hl=en&ie=UTF-8&oe=UTF-8&q=Common+Lisp+Condition+System
Cheers,
-- Nikodemus
--
I refuse to have a battle of wits with an unarmed person.
Ivan Boldyrev
> Ivan Boldyrev <boldyre...@cgitftp.uiggm.nsc.ru> writes:
>
> > On 8349 day of my life Mario S. Mommer wrote:
> >> tugly...@aol.commune (Andrew Burton) writes:
> >> > The ANSI Common Lisp, clisp
> >>
> >> Note that clisp is only one implementation of common lisp.
> >
> > Do you mean "is not only one"?
>
> "clisp" is usually a reference to the Common Lisp implementation
> called "GNU CLISP", available from http://clisp.cons.org/ or
First time I downloaded it 3 years ago :)
> Overlaoding the term to refer to Common Lisp in general strikes me as
> a bad idea, liable to lead to confusion, especially when "CL" already
> does quite nicely in that latter role.
Prbably, my English teacher will give me bad mark :)
"clisp is not only one implementation of Common Lisp" means "There are
lot of other implementations of Common Lisp standard", doesn't it?
And "clisp is only one implementation of Common Lisp" is "There are no
other implemntations". Or?
--
Ivan Boldyrev
PGP fp: 3640 E637 EE3D AA51 A59F 3306 A5BD D198 5609 8673 ID 56098673
Perl is a language where 2 x 2 is not equal to 4.
Zachary Beane
Boldyrev wrote:
> "clisp is not only one implementation of Common Lisp" means "There are
> lot of other implementations of Common Lisp standard", doesn't it?
Preferable:
"clisp is not the only implementation of Common Lisp."
> And "clisp is only one implementation of Common Lisp" is "There are no
> other implemntations". Or?
Actually, it implies "one of many" as in:
"clisp is only one of many implementations of Common Lisp."
Your interpretation would be more correct for:
"clisp is the only implementation of Common Lisp."
Zach
Erann Gat
> "clisp is not only one implementation of Common Lisp" means "There are
> lot of other implementations of Common Lisp standard", doesn't it?
No, but you can hardly be blamed for not knowing this. The word pair "not
only" is an idiom with very subtle shades of meaning and rules for usage.
In colloquial English, "X is not only Y" is usually used as an
introductory phrase in a sentence like: "X is not only Y, but also Z."
The meaning is: X has property Y, and furthermore it also has property Z.
Example: "The Pacific Ocean is not only the largest ocean on the planet,
but it is also the deepest." Saying "X is not only Y" by itself just
sounds weird.
You can also rearrange things thusly: "Not only is the Pacific the larges
ocean in the world, it is also the deepest."
By contrast, saying "X is not *the* only Y" is OK as a standalone
sentence, and it means that X has property Y, but other things also have
property Y.
> And "clisp is only one implementation of Common Lisp" is "There are no
> other implemntations". Or?
You need the "the" there. "CLisp is not *the* only implementation of
Common Lisp" or "CLisp is the only implementation of Common Lisp."
(If you want to get really fancy you can say something like: "Not only is
CLisp not the only implementation of Common Lisp, it is even not the only
free implementation." Meaning: Clisp is an implementation of Common Lisp,
it is free, and there other free implementations besides Clisp. All of
which happens coincidentally to be true.)
I don't know Russian, but I notice that Russians speaking English tend to
leave out articles ("a" and "the") as in:
> Prbably, my English teacher will give me bad mark :)
You should say "... will give me *a* bad mark." Then you will get a good
mark. :-)
This is not a universal rule in English. The French, for example, seem to
make the opposite mistake, putting in articles where they are not needed,
e.g.:
"My English teacher will give me the grief". This sounds weird. It
should be "My English teacher will give me grief."
I'm note sure if there's a rule to decide when articles are needed and
when they are not. English is the C++ of natural languges. There are
many pitfalls, and you just have to remember them all.
The world would be a better place if everyone spoke Esperanto. (Actually,
getting the world to use Esperanto is not so very different from getting
the world to use Lisp.)
E.
Nils Goesche
> "My English teacher will give me the grief". This sounds
> weird. It should be "My English teacher will give me grief."
Beware: You are creating lots of people who'll say ``My English
teacher gives me creeps´´
;-)
I gave up long ago -- it is absolutely impossible to understand
the grammar of the English language. Not that German were any
easier. Or Russian, for that matter.
> The world would be a better place if everyone spoke Esperanto.
> (Actually, getting the world to use Esperanto is not so very
> different from getting the world to use Lisp.)
Nah -- it is all those inconsistencies that make poetry possible
at all.
Kenny Tilton
Ivan Boldyrev wrote:
> Prbably, my English teacher will give me bad mark :)
>
> "clisp is not only one implementation of Common Lisp" means "There are
> lot of other implementations of Common Lisp standard", doesn't it?
> And "clisp is only one implementation of Common Lisp" is "There are no
> other implemntations". Or?
>
The phrase you are thinking of (and having bad luck mutating) is "the
only one":
"There are many languages, but Lisp is the only one I want to use."
"one" there refers to one member of a collection established earlier
(languages). Less flamboyantly:
"Lisp is the only language I want to use."
"language" is directly paired with "only", so the indirect reference to
some collection (not!) specified earlier has no place.
Note that the collection can be implicit:
"I am not the only one who likes Lisp."
Marc Spitzer
> In article <sfwlly8...@shell01.TheWorld.com>, Kent M Pitman
> <pit...@world.std.com> wrote:
>
> > g...@jpl.nasa.gov (Erann Gat) writes:
>
> > > One of the things that Erik did frequently was excoriate people for
> > > talking about him instead of Lisp. So following his example:
> > >
> > > Will all you pathetic whiners who are pining for the return of Lord
> > > Naggumort please move your sniveling to this thread so that those of us
> > > who don't miss his psychotic ranting can carry on talking about Lisp
> > > without this distraction?
>
> > First, I don't happen to count what we were doing as whining.
>
> I was not addressing you specifically. I was addressing pathetic
> whiners. If you are not a pathetic whiner then I was obviously not
> talking to you.
Well Kent thought you were addressing him, to some extent anyway. I
guess you should have been clearer, perhaps a list would help.
>
> > It was two messages,
>
> Treacly nostalgia for he-who-must-not-be-named has been stealthily
> appearing in many contexts since he went to ground. These two messages
> just pushed me past my limit of tolerance.
So your complaint is that people like Erik and respect him, that is
why we wish he was here after all. And Erik is obscenely useful, iff
you can do four of things:
1: pay attention
2: think
3: honestly try to work towards a solution
4: keep personal and professional separate, aka behave like an adult
>
> > Next, I hope that you, Erann, or anyone, if they are ever gone for a
> > community are remembered for the best they contributed, not the worst.
>
> Well, I appreciate that. Do you hope that Saddam Hussein will be
> remembered for the good he did for Iraq? Do you think we should remember
> Hitler for lifting Germany out of its horrible economic conditions?
> (Godwin was right.)
Well that response was rude, abusive and uncalled for. Even if you do
not like Erik, what has Kent done to deserve this? Are you looking
for new enemies now that old ones are absent?
>
> > Not all of us come free of baggage. Some people seem to slug through my
> > posts because they find some value in them, but I'm forever amazed by the
> > ability of others to say the same thing as I often set out to say in
> > ever so much simpler a fashion. I'd like to think I'll not just be
> > remembered for being long-winded, even if that's clearly an aspect of
> > who I am.
>
> There's nothing wrong with being long-winded. There's a lot wrong with
> being uncivil, even on usenet (maybe especially on usenet). (And yes, I
> admit I was somewhat uncivil before. I was emulating Erik's style for the
> benefit of those who claimed to miss him. Sue me.)
Erik wan never uncivil first, from what I have observed. And that
included the time he zaped me when I first came here.
>
> > I have said before and I'll say it again, I do not approve of people
> > writing detracting posts about other people. That's not to say I make
> > the rules. There are, effectively, no rules, since there is no material
> > mode of enforcement. This is a free speech forum.
>
> I agree with this. I am on the record as defending Erik's (and by
> implication everyone else's) right to post whatever they want on c.l.l.
>
> http://groups.google.com/groups?selm=gat-1201021625040001%40192.168.1.50
>
> Nonetheless I believe that he did far more harm than good, and that his
> departure is a net win for Lisp.
And you are wrong.
>
> In my assessment, c.l.l. has seen a renaissance since he left. A dozen
> local Lisp interest groups have sprung up overnight. New people have come
> and not been chased away. We even managed to talk about the war without
> it degenerating into a flamefest! (Someone even commented on how
> impressed he was that we could do that, though I can't find the reference
> just now.)
And you claim that Erik's absence is the root cause for this? You
have to be joking or a fool blinded by his own opinion. Now let me
address each of your wrong statements in order:
First the users groups, lispnyc was the first publicly announced group
in the current crop. This group came into being because of my big
mouth, "Lets form a users group in nyc guys" posted here and the
generosity of David Bakhash, who let us use his office for the first
few meetings(thanks again Dave). Then there were the monthly meeting
announcements that showed it was working, people showed up. This lead
other people to start asking if there were lispers in their
neighborhood and the beer did not hurt. And it happened over the
course of 4-6 months.
Next Erik, to the best of my knowledge, has never chased away someone
who was serious about learning CL, ie. paid attention to the help they
were given and thought about it. He did not suffer fools though.
And now third, your deliberately and remarkably off topic post on Gulf
II. You were flamed idiot go reread the thread from google. I know
I flamed you.
>
> > I claim it's better to ignore what you don't like,
>
> Of course it's better. The problem is that it only works if everyone does
> it, and the fact is that almost no one does it, not even you (and
> certainly not Erik). If you did we would not be having this discussion.
No it works for you when you do it and it is that simple. Since you
choose not to shut up even when you post that you know you should it
is wholly your fault that you post. And your moronic logic is truly
silly when Kent is one of the people who is consistent in this
regard. The worst thing he does is say he is taking a break from the
group when he feels that there is too much screaming going on. And it
works because we want Kent to come back and stay.
> > since everyone
> > doesn't like something and there is no power to make things you don't
> > like go away. In this case, the thing you don't like is even gone,
> > and you still find the need to say something bad about it.
>
> No, the thing I don't like is not gone, it is right here in my face. The
> thing I don't like is the hypocricy of being told that I should ignore
> what I don't like by someone who is obviously not ignoring what they don't
> like. The gall! The minute you start to follow your own advice this
> conversation will be over.
Now you are trying to engage Kent as if he responded like Erik to your
flawed logic. How long have you been here? Idiot Kent does not do
that.
>
> > Furthermore, I have also said that I find it a faux pas of a higher
> > order to start a new thread to excoriate someone because then even
> > people who were just visiting the newsgroup and surveying the topics
> > discussed will find your post. Putting something in a subject line is
> > like putting a private conversation up a billboard. I think the
> > people who are deep down in an thread are few to start with, and
> > that's the _best_ time for something to get unnecessarily personal, if
> > it's going to be at all (which I wish it wouldn't be), because it's
> > largely buried by its nature. Putting something in a thread subject
> > adds fuel to what may be only a potential fire, veritably assuring it
> > will ignite. (Incidentally, I think it had burned itself out as of my
> > post. It was just two isolated messages, and you have now fanned the
> > dimming embers back to life.)
>
> You are making the false assumption that my intent was to stop people from
> posting nostalgic remembrances of Erik. It was not. As I said, I too
> believe in free speech. You Erik-worshippers have the right to advertise
> your nostalgia for him. I likewise have the right to dissent, which is
Now you are dehumanizing the people who want Erik around, fuck you.
And you have a right to shit in your hat, that does not mean it is a
good idea(even for you).
> what I am doing here. I think that as a common courtesy all such
> off-topic posts should be clearly marked as such, which is the reason I
> started this new thread. I don't want to silence this discussion, I
> *want* to fan the flames (hopefully we can all get this out of our systems
> once and for all), but I want the flames isolated and clearly marked.
> That's how we managed to talk about the war without things getting out of
> hand, and that's how I hope we'll get past this without things getting out
> of hand. So all you folks who miss Erik, post here and get it out of your
> system. All you who wish him consigned to the depths do likewise, but do
> it here in this off-topic thread so the rest of us can get on with the
> business at hand in the rest of the newsgroup.
>
> > And finally, I have also noted that for the same reason as I don't think
> > people should whine at other people, I am being hypocritical myself if
> > I don't follow my own whining, into which you have drawn me,
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> I have done no such thing. I am not holding a gun to your head. You are
> posting these things of your own free will. Don't try to blame your
> shameful hypocricy on me.
And no one is holding a gun to your head either, so why do you keep
posting? We /made/ you do it, right?
>
> > with some
> > sort of punitive action that acknowledges I'm doing exactly the thing
> > I'm saying shouldn't be done. I impose no sanction on you; I have no
> > power to do that, nor per se right to judge. But for myself, I do have
> > both the power and, arguably, the responsibility. So as penalty for my
> > contributing to the fanned embers of negativism, I withdraw from
> > newsgroup posts for the remainder of this month. Shame on me. See you
> > all when hopefully I've calmed down, and this thread, too, sometime
> > after the start of May.
>
> Oh, Kent, grow up will you? You're really getting too old for this
> I'm-going-to-take-my-ball-and-bat-and-go-home game.
You are one to talk??? Kent is simply stating that if he does not
like what is going on in the room he will leave. And he is not
blaming anyone else for the behavior, is that what you do not
understand?
marc
Boethius
> So your complaint is that people like Erik and respect him, that is
> why we wish he was here after all. And Erik is obscenely useful, iff
> you can do four of things:
> 1: pay attention
> 2: think
> 3: honestly try to work towards a solution
> 4: keep personal and professional separate, aka behave like an adult
Yeah, I guess point number 4 has always been his (and his minions's)
most noticeable virtue.
Were you serious? I hope not.
Marc Spitzer
What is it with this minion shit? As far as I know I have never had any
direct interaction with you so why do you choose to attack me personally?
>
> Were you serious? I hope not.
Yes and since I disagree with you I *must* be evil. What a /small/ mind
you appear to have.
marc
Mark Conrad
<s...@below.invalid> wrote:
> On Fri, 18 Apr 2003 12:30:31 GMT, Mark Conrad wrote:
>
> > Your example code will work if I leave the power on to my computer, but
> > not if I shut the computer off, then power up later.
>
> > Is there some CL feature that will allow me to do that, so I can get
> > away from "continuations" for this particular chore?
>
> What makes you think Scheme would keep working after you turn the
> power off???
Let me clarify what I meant. If CL had continuations, or something
closely approaching continuations, code could be written in such a
manner that I could manually interrupt a long-running function from the
keyboard, then turn the computer power off; I could then turn the
power on later, and resume running the long-running function from the
exact point it was interrupted.
Near as I can determine be looking at Matthew Danish's post below, it
does not appear that his solution will do what I want to do along these
lines, because it appears that he relied on the computer staying
powered up.
Francois-Rene Rideau
> If CL had continuations, or something closely approaching continuations,
> code could be written in such a
> manner that I could manually interrupt a long-running function from the
> keyboard, then turn the computer power off; I could then turn the
> power on later, and resume running the long-running function from the
> exact point it was interrupted.
In many CL systems you can just dump the system image.
For instance, see function ext:saveinitmem in clisp,
or extensions:save-lisp in cmucl or sb-ext:save-lisp in sbcl, etc.
If you really want to make continuation persistent independently
from the rest of the system, you'll find that even scheme doesn't allow that.
However, you'll find that with some metaprogramming, you can do that
on top of either Scheme or CL: see David Alan Hall's Tube for a
Scheme-based system that does precisely what you want.
As for implementing the Tube on top of CL,
I'm sure you could do that, too, by hacking Screamer.
[ François-René ÐVB Rideau | Reflection&Cybernethics | http://fare.tunes.org ]
[ TUNES project for a Free Reflective Computing System | http://tunes.org ]
That man who dares to waste one hour of time, has not discovered
the value of life. -- Charles Darwin
Christopher C. Stacy
Mark> In article <m2istcc...@mycroft.actrix.gen.nz>, Paul Foley
Mark> <s...@below.invalid> wrote:
>> On Fri, 18 Apr 2003 12:30:31 GMT, Mark Conrad wrote:
>>
>> > Your example code will work if I leave the power on to my computer, but
>> > not if I shut the computer off, then power up later.
>>
>> > Is there some CL feature that will allow me to do that, so I can get
>> > away from "continuations" for this particular chore?
>>
>> What makes you think Scheme would keep working after you turn the
>> power off???
Mark> Let me clarify what I meant. If CL had continuations, or something
Mark> closely approaching continuations, code could be written in such a
Mark> manner that I could manually interrupt a long-running function from the
Mark> keyboard, then turn the computer power off; I could then turn the
Mark> power on later, and resume running the long-running function from the
Mark> exact point it was interrupted.
That's not what "continuations" in Scheme are.
Kenny Tilton
Mark Conrad wrote:
> In article <m2istcc...@mycroft.actrix.gen.nz>, Paul Foley
> <s...@below.invalid> wrote:
>
>
>>On Fri, 18 Apr 2003 12:30:31 GMT, Mark Conrad wrote:
>>
>>
>>>Your example code will work if I leave the power on to my computer, but
>>>not if I shut the computer off, then power up later.
>>
>>>Is there some CL feature that will allow me to do that, so I can get
>>>away from "continuations" for this particular chore?
>>
>>What makes you think Scheme would keep working after you turn the
>>power off???
>
>
>
> Let me clarify what I meant. If CL had continuations, or something
> closely approaching continuations, code could be written in such a
> manner that I could manually interrupt a long-running function from the
> keyboard, then turn the computer power off; I could then turn the
> power on later, and resume running the long-running function from the
> exact point it was interrupted.
this is getting funny: von Neuman separated code from data, Lisp
accepted code as data, and now here we have a runtime snapshot not just
as data but as persistent data. somehow it is so hard to express the
ongoing state of some computation in a conventional data structure that
one needs to store the computation itself in some cryogenic deep freeze
along with Ted Williams, to be reawakened at some point -- when one gets
to work the next day? me, i would just leave the computer running, which
I do anyway.
just wondering, has the argument in favor of call/cc been backed into a
corner where the only justification is how to yo-yo the system in
mid-run? in a setting that does not have the luxury of a backup
shadowing system to carry on the computation? for an application whose
running computational state cannot be expressed in some conventional,
persistent data structure?
One thing that is consistent throughout this thread is that all the
"application" requirements offered in support of the argument for
call/cc boil down to this: "Suppose I want to use call/cc to solve some
problem. Now..."
kt
clinisys
Tim Bradshaw
> Let me clarify what I meant. If CL had continuations, or something
> closely approaching continuations, code could be written in such a
> manner that I could manually interrupt a long-running function from the
> keyboard, then turn the computer power off; I could then turn the
> power on later, and resume running the long-running function from the
> exact point it was interrupted.
Well, now you can see why we don't want them! Obviously continuations
have to store the entire OS state to nonvolatile storage, if you have
anything like open network connections, they probably have to fork a
copy of the entire universe, and dump *that* to disk. Ouch.
The rest of us just use OSs which have a suspend-to disk facility.
--tim
Daniel Barlow
> Let me clarify what I meant. If CL had continuations, or something
> closely approaching continuations, code could be written in such a
> manner that I could manually interrupt a long-running function from the
> keyboard, then turn the computer power off; I could then turn the
> power on later, and resume running the long-running function from the
> exact point it was interrupted.
My computer does that already, for all applications whether written in
scheme or not. You don't want continuations, you want APM (or ACPI)
suspend-to-disk.
-dan
--
http://www.cliki.net/ - Link farm for free CL-on-Unix resources
Mark Conrad
<fa...@tunes.org> wrote:
> Mark Conrad <nos...@iam.invalid> writes Re: Implementation Favoritism, a
> question of Lisp mindsets
> > If CL had continuations, or something closely approaching continuations,
> > code could be written in such a manner that I could manually interrupt
> > a long-running function from the keyboard, then turn the computer
> > power off; I could then turn the power on later, and resume running the
> > long-running function from the exact point it was interrupted.
>
> You want not just continuations, but persistent continuations.
Not only that, but I want "Network Persistant Continuations", (in CL) -
which would save the states of the entire network of computers at the
instant of the interruption. Such a system would require the
cooperation of all computers on the network, of course.
Such a system would allow all computer users in the network to come and
go as they please, power-on/power-off, yet still retain the option of
resuming/rerunning some past discussion of interest, with the assurance
that the state of all the computers online at that past time would be
faithfully preserved and recorded.
Mark-
Mark Conrad
<kti...@nyc.rr.com> wrote:
> just wondering, has the argument in favor of call/cc been backed into a
> corner where the only justification is how to yo-yo the system in
> mid-run?
Not at all. :)
Paul Graham, in his CL book "On Lisp" (1994) - makes many strong points
in favor of using continuations in CL, not even remotely connected with
my posts about "persistant continuations".
His best points are summed up in two pages, 284-285, which should be
required reading for those who ridicule the concept of using CL
continuations. (...and CL macros)
(in his book section "21.3". That section of his "On Lisp" book is
titled "The Less-than-Rapid Prototype")
I want to thank all the fine gentlemen here in this NG for assisting me
in my quest to pursue my own brand of programming in CL.
Unfortunately, I did not save the posts, so I will have to go back in
Google and dig up all the "juicy" posts for my archives.
Mark-
Paul Wallich
Mark Conrad <nos...@iam.invalid> wrote:
By "computers" one assumes that you're using the historical definition,
namely "person who performs computations" in a Turing-test-complete
sense? Otherwise the continuations wouldn't be nearly as useful.
paul