not from the language:
headache from the people in the newsgroups.
as in other newgroups: no precision, no gentleness, no focussing on the
posters problems & questions. Many throw out all their psychological
garbage (auto-collected).
unprofessional *"language-lovers"*, which protect "their language" like
their destructive egos. But some highlights. And of course some
'watchers'. Whos is this guy? Don't talk know, learn him, and then talk.
Now, the language LISP?
just finished with page page 64 of
"Basic Lisp Techniques"
<http://www.franz.com/resources/educational_resources/cooper.book.pdf>
The 64 pages? many red remarks i've made.
Some incosistencies in function naming, some in writing style, "calling
conventions".
Straightforward design? - No way. It's a myth!
But it triggers me already into new thinking-directions & dimensions.
I feel... its the last step of the long preparation.
"((((((((((((())))()()()())))))))))))))))" a problem? not really!
(let ((result 1))
(dotimes (n 10 result)
(setq result (+ result n))))
READABILITY WIZARD (for C)
(
let ((result 1))
(
dotimes (n 10 result)
(
setq result (+ result n)
)
)
)
it hurts, eh? ok, could agree to this?
( let ((result 1)) (
dotimes (n 10 result) (
setq result (+ result n)
)
)
)
today i don't code in C++. i made a break.
Did i told you, that i love this language. With all its *strenths* *and*
all its *weaknesses*. I grow up with it, and prior with its small
brother "C". Many other languages. But i stay with my *love*.
i think i'll continue with chapter 4:
"*CL as a CASE tool*" - overlooked on that. makes me 'hungry'.
maybe sooner as i think, i'll love LISP.
It will be hard, to leave my long-term *love* behind.
people, be happy.
·····@lazaridis.de writes:
>
> "((((((((((((())))()()()())))))))))))))))" a problem? not really!
>
> (let ((result 1))
> (dotimes (n 10 result)
> (setq result (+ result n))))
>
> READABILITY WIZARD (for C)
>
> (
> let ((result 1))
> (
> dotimes (n 10 result)
> (
> setq result (+ result n)
> )
> )
> )
>
> it hurts, eh? ok, could agree to this?
>
> ( let ((result 1)) (
> dotimes (n 10 result) (
> setq result (+ result n)
> )
> )
> )
>
> today i don't code in C++. i made a break.
Are you actually proposing to use parens like C/C++ curly braces? If
so, you're making it difficult on yourself. I think you'll be much
better served by learning and using the conventional Lisp formatting
rules.
>
> maybe sooner as i think, i'll love LISP.
Write a few systems with Lisp, once over the hump I think you'll like
using it.
Gregm
·····@lazaridis.de wrote:
> headache from the people in the newsgroups.
>
> as in other newgroups: no precision, no gentleness, no
> focussing on the posters problems & questions. Many throw
> out all their psychological garbage (auto-collected).
If your interest in Lisp is serious and you ask technical
questions, you will get very precise asnwers here. I admit
that flame wars happen here as in other newsgroups, but at
the same time this group is very knowledgable.
> unprofessional *"language-lovers"*, which protect "their
> language" like their destructive egos.
They are rather professional. They are not akways abjective
but you can disregard this.
>
> (let ((result 1))
> (dotimes (n 10 result)
> (setq result (+ result n))))
>
> READABILITY WIZARD (for C)
>
> (
> let ((result 1))
> (
> dotimes (n 10 result)
> (
> setq result (+ result n)
> )
> )
> )
>
> it hurts, eh? ok, could agree to this?
>
> ( let ((result 1)) (
> dotimes (n 10 result) (
> setq result (+ result n)
> )
> )
> )
In Lisp it is unusual to code like this. You should put the
closing paretheses into the same line.
>
> today i don't code in C++. i made a break.
>
> Did i told you, that i love this language. With all its
> *strenths* *and* all its *weaknesses*. I grow up with it,
> and prior with its small brother "C". Many other
> languages. But i stay with my *love*.
That is all right.
--
JB
-----------== Posted via Newsfeed.Com - Uncensored Usenet News ==----------
http://www.newsfeed.com The #1 Newsgroup Service in the World!
-----= Over 100,000 Newsgroups - Unlimited Fast Downloads - 19 Servers =-----
·····@lazaridis.de writes:
> as in other newgroups: no precision, no gentleness, no focussing on the
^^^^^^^^^^^^
> posters problems & questions. Many throw out all their psychological
> garbage (auto-collected).
> Some incosistencies in function naming, some in writing style, "calling
> conventions".
Bits of the language are over 40 years old. Of course it will be
inconsistent in places.
> it hurts, eh? ok, could agree to this?
>
> ( let ((result 1)) (
> dotimes (n 10 result) (
> setq result (+ result n)
> )
> )
> )
Please, if you're asking for precision from the other newsgroup
contributors, it would be helpful if you would employ more of it
yourself. I realise that English may not be your first language, but
when you say "could agree to this", it's impossible to tell whether
you mean that _you_ could agree to that (for example, as an
intermediate position while adjusting from C style indentation) or
you're asking whether _we_ could agree to that. Don't omit words if
you're unsure whether they can safely be inferred from context.
I'm going to assume you mean the latter, though, and the answer is
"no". There is a convention for Lisp indentation and paren style, and
there is a bast amount of Lisp code written using it. Even aside from
any aesthetic arguments for one form or the other, if you become an
adept Lisp programmer you will spend far more time reading code
written by other people than you will writing code, so you may as well
get used to the standard layout.
How do we cope? We've learnt not to worry about it. Our editors
balance the parens for us - we trust that works correctly and don't
need the reassurance of confirming it by eye. When we read code, we
look at the indentation. When we write code, we hit the TAB key and
add/remove parens until the indentation is correct. Some people even
customize their editor to display them in a less obtrusive colour.
Just don't /worry/ about them.
-dan
--
http://ww.telent.net/cliki/ - Link farm for free CL-on-Unix resources
·····@lazaridis.de wrote:
> maybe sooner as i think, i'll love LISP.
Stop worrying about love. Just worry about using the language well. That's
all that's needed...
faa
From: Paul F. Dietz
Subject: Re: LISP - 24hours in a few days - headache
Date:
Message-ID: <3D5EE945.24A6BD6E@dls.net>
·····@lazaridis.de wrote:
> as in other newgroups: no precision, no gentleness, no focussing on the
> posters problems & questions. Many throw out all their psychological
> garbage (auto-collected).
Gee, you get the same reaction in other newsgroups? Fancy that.
Paul
From: Tim Bradshaw
Subject: Re: LISP - 24hours in a few days - headache
Date:
Message-ID: <ey3adnlowpz.fsf@cley.com>
* ilias wrote:
> as in other newgroups: no precision, no gentleness, no focussing on the
> posters problems & questions.
You ask for this but then produce n lines of `English' which is all
but unparseable to a native speaker. If you want precision *ask
precise questions*. Or, if you can't manage that, at least ask
questions in a language which has a detectable grammar.
--tim
·····@lazaridis.de wrote:
> READABILITY WIZARD (for C)
>
> (
> let ((result 1))
> (
> dotimes (n 10 result)
> (
> setq result (+ result n)
> )
> )
> )
>
> it hurts, eh? ok, could agree to this?
>
> ( let ((result 1)) (
> dotimes (n 10 result) (
> setq result (+ result n)
> )
> )
> )
Please don't do this. Use Emacs. Matching parentheses
blink when you close them, tab automatically indents to
the correct place. There's also indent-region (Meta-Control-\).
Emacs was written with Lisp programming in mind many years ago.
(It's aware of the syntax of many other languages too.)
Le Hibou
--
Dalinian: Lisp. Java. Which one sounds sexier?
RevAaron: Definitely Lisp. Lisp conjures up images of hippy coders,
drugs,
sex, and rock & roll. Late nights at Berkeley, coding in Lisp fueled by
LSD.
Java evokes a vision of a stereotypical nerd, with no life or social
skills.
ilias writes:
> I feel... its the last step of the long preparation.
>
> "((((((((((((())))()()()())))))))))))))))" a problem? not really!
>
> (let ((result 1))
> (dotimes (n 10 result)
> (setq result (+ result n))))
>
> READABILITY WIZARD (for C)
>
> (
> let ((result 1))
> (
> dotimes (n 10 result)
> (
> setq result (+ result n)
> )
> )
> )
>
> it hurts, eh? ok, could agree to this?
>
> ( let ((result 1)) (
> dotimes (n 10 result) (
> setq result (+ result n)
> )
> )
> )
Lisp has been around since before 1960. That's over 40 years. One
thing that a newcomer to the scene should realize is that a lot of
smart people have been thinking about it for a long time. Thus, when
one sees something that seems obvious but isn't currently being done,
one might ask oneself if there's a reason, assuming that, just maybe,
some smart person has thought about this before.
The above is an example of this. The poster asks why people don't
format Lisp somewhat more like C or C++. `Obviously' it would be more
readable.
In fact, it wouldn't. We've had numerous discussions about this, and
the consensus is that one shouldn't emphasize the parentheses. Let
them become invisible. Thus
( let ((result 1)) (
dotimes (n 10 result) (
setq result (+ result n)
)
)
)
is bad because it sticks parentheses in what are, to me (having
programmed in Lisp for a while), random places. Now I have to look at
them and figure them out.
What's more, part of the readability of Lisp comes from its relatively
regular syntax. Doing the above conceals this.
dotimes (n 10 result) (
seems to be an attempt to program C in Lisp. Please get over such
things. It just shows that you're still fighting the language.
If you want to program in C, program in C.
A couple months ago I had to write some code in Java. It wasn't the
most enjoyable thing I ever did, partly because I kept saying, "Gee,
the language is trying to do something that's much clearer in Lisp,
why can't I just program in Lisp?" but partly because I kept fighting
the language. I didn't want to find the "Java way" and follow it.
After a while I just said to myself, "If I want to have some chance of
enjoying coming to work, I have to stop fighting Java." It got much
easer after that, though I still hate
VariableNamesThatRequreHittingShiftInTheMiddle.
It's the same for Lisp. A lot of Lisp programmers think the "Lisp
way" is FUN. It's not torture to read
(let ((result 1))
(dotimes (n 10 result)
(incf result n)))
It's a pleasure. It lets one focus on the code. One's eye gets
trained to see and read the Lisp forms without thinking about the
parentheses.
For example, I don't know, without counting or using the editor's
facilities, whether the parentheses in the above form balance. That's
because it doesn't matter to me. It just matters to the Lisp
interpreter. But if I use my Lisp-aware editor (emacs) I don't have
to worry about such things.
If you want to `give Lisp a try', try giving Lisp a try instead of
trying to shoehorn it into your current viewpoints. Imagine trying to
have a romantic relationship on such terms. "Hey, my previous
girlfriend was like this! Why aren't you?" I suspect such a
relationship would have a lifetime measured in microseconds.
--
Fred Gilham ······@csl.sri.com | If sophists such as Richard Rorty
are correct, and the West has moved from a post-religious age to a
post-metaphysical age, then there is literally nothing Western left
about the West to defend. --David Dieteman
·····@lazaridis.de wrote in message news:<················@lazaridis.de>...
> headache from the people in the newsgroups.
>
> unprofessional *"language-lovers"*, which protect "their language" like
> their destructive egos.
[snip]
> today i don't code in C++. i made a break.
>
> Did i told you, that i love this language. With all its *strenths* *and*
> all its *weaknesses*. I grow up with it, and prior with its small
> brother "C". Many other languages. But i stay with my *love*.
Oh, the irony.
Anyways, I am someone who was in the same boat as you. I learnt to
code in C, on
my own. I jumped on the Windows programming bandwagon in 95. I learnt
more
languages, APIs, technologies, acronyms and "innovations" than I care
to remember.
I have invested time and money learning every detail about the
miscrosoft platform. Everything, from high level COM automation, to
the most intimate datastructures (I can guess the offset ranges of
Win32API on my Windows NT box, with very high accuracy!!!)
I own close to 100 books on computing (most of them references.) I
have writen
demos, commercial API, little games, virii, device drivers, little
compilers,
file browsers, databases, and many more.
Then I got sick of all of it, I couldn't get myself to write yet
another main
functions. Coding in C/C++ is expensive; you have to include the
appropriate
header files, declare your functions and data structures before you
can use
them, wrestle with extremely low level data types, before you can even
test
the simplest new ideas.
I am an application developer, but I lean towards compiler
construction. The
simplest excercise in a compiler construction book, requires you to
read a
character stream, tokenize it, and parse it into an appropriate ADT,
so you can
test your new operation on it. Doing that in C/C++ requires bitchy
string
manipulation, and re-customization for every new language you work on.
Please
don't tell me about yacc, or I will slap you with the agonizing hours
I spent
groking its mood swings.
Then came the day where I decided to find something better, something
that works.
I went out to search for a programming language. My criteria where
sharp and
clearn: 1) No C lookalike, 2) No corporate hype. I found ML, Haskell,
Lisp, and
Python.
I have taken the time to sample all of them, then decided to settle on
Lisp, not
because I knew it was going to be the best, but because I HATED it the
most
at first :-)
Lisp was repulsive at first, because I used to use Vim ;-) then I
learnt about
emacs and how to set up inferrior processes and multiple screens. I
had Clisp
running for days, and I was using it as a nifty prefix calculator.
Then I discovered it had rational numbers, very nifty.
Then I figured how to define my own functions, my own data types, I
learnt about
"let" and fencing. I learnt about closures, high order functions,
multiple-values, and macros.
Then I learnt that everything I typed in emacs, and C-M-x'ed, was
still in my
Lisp core. I have defined wrapped functions around "documention",
"describe"
"disassemble" and "apropos", and they remained there forever. I learnt
how to
dump core and make permenant changes to my lisp, and every little
addition I
have made always there.
Nirvana, free atlast free atlast, tears of joy and programming made an
art again.
On 18 Aug 2002 13:51:06 -0700, ·······@flop.co.uk (Andy Reiter) wrote:
> my own. I jumped on the Windows programming bandwagon in 95. I learnt
> more
> languages, APIs, technologies, acronyms and "innovations" than I care
> to remember.
>
> I have invested time and money learning every detail about the
> miscrosoft platform. Everything, from high level COM automation, to
> the most intimate datastructures (I can guess the offset ranges of
> Win32API on my Windows NT box, with very high accuracy!!!)
[...]
> I am an application developer, but I lean towards compiler
> construction. The
[...]
> Then came the day where I decided to find something better, something
> that works.
[...]
> I have taken the time to sample all of them, then decided to settle on
> Lisp, not
From time to time someone asks whether a Win32 port of CMU CL is available.
I'm not interested in it myself, but I know there is some interest. You
might consider contributing your Windows skills to such a project.
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://www.paoloamoroso.it/ency/README
·····@lazaridis.de writes:
> not from the language:
>
> headache from the people in the newsgroups.
>
> as in other newgroups: no precision, no gentleness, no focussing on the
> posters problems & questions. Many throw out all their psychological
> garbage (auto-collected).
Many people, most of the responses in fact, have responded to your
questions in a positive manner, attempting to provide an explanation
for the curretn conditions and how to operate within them. Why do you
choose to ignore them when writing this screed?
--
Sincerely,
Craig Brozefsky <·····@red-bean.com>
Free Scheme/Lisp Software http://www.red-bean.com/~craig
Craig Brozefsky wrote:
> ...Why do you choose to ignore them when writing this screed?
I agree with your sentiment. I am puzzled by your reference to a rough
ayer of plaster placed on a wall before the top coat or skim is
applied! screed -- who he?!?
:)w
Will Deakin <···········@hotmail.com> writes:
> Craig Brozefsky wrote:
> > ...Why do you choose to ignore them when writing this screed?
> I agree with your sentiment. I am puzzled by your reference to a rough
> ayer of plaster placed on a wall before the top coat or skim is
> applied! screed -- who he?!?
Well duh, because I was only ever a drywall monkey.
--
Craig Brozefsky <·····@onshored.com> Senior Programmer
onShore Development http://www.onshore-devel.com
Free Common Lisp Software http://alpha.onshored.com/lisp-software
Craig Brozefsky wrote:
> ·····@lazaridis.de writes:
>
>
>>not from the language:
>>
>>headache from the people in the newsgroups.
>>
>>as in other newgroups: no precision, no gentleness, no focussing on the
>>posters problems & questions. Many throw out all their psychological
>>garbage (auto-collected).
>
>
> Many people, most of the responses in fact, have responded to your
> questions in a positive manner, attempting to provide an explanation
> for the curretn conditions and how to operate within them. Why do you
> choose to ignore them when writing this screed?
>
actually i don't.
*you* choose to do it. another undfriendly behaviour in c.l.l., and
generally in newsgroups: *quoting uncompletely*
here again:
> as in other newgroups: no precision, no gentleness, no focussing on the
> posters problems & questions. Many throw out all their psychological
> garbage (auto-collected).
>
> unprofessional *"language-lovers"*, which protect "their language" like
> their destructive egos. But some highlights. And of course some
> 'watchers'. Whos is this guy? Don't talk know, learn him, and then talk.
*But some highlights.*
These *highlights* are the people, that give a friendly & professional
response.
ilias <·······@pontos.net> writes:
> Craig Brozefsky wrote:
> > ·····@lazaridis.de writes:
> >
> >>not from the language:
> >>
> >>headache from the people in the newsgroups.
> >>
> >>as in other newgroups: no precision, no gentleness, no focussing on the
> >>posters problems & questions. Many throw out all their psychological
> >>garbage (auto-collected).
> > Many people, most of the responses in fact, have responded to your
> > questions in a positive manner, attempting to provide an explanation
> > for the curretn conditions and how to operate within them. Why do you
> > choose to ignore them when writing this screed?
> >
>
> actually i don't.
>
> *you* choose to do it. another undfriendly behaviour in c.l.l., and
> generally in newsgroups: *quoting uncompletely*
>
You are reading unfriendliness into a misunderstanding of your use of
english. Above you did not qualify who you were talking about and I
assumed "headache from the people in the newsgroup" meant the
newsgroup at large. Your later qualification "But some hilights." was
basically unintelligible and I had no way to tie it to the rest of the
post even with my several decades of English usage.
--
Craig Brozefsky <·····@onshored.com> Senior Programmer
onShore Development http://www.onshore-devel.com
Free Common Lisp Software http://alpha.onshored.com/lisp-software
Craig Brozefsky wrote:
> ilias <·······@pontos.net> writes:
>
>
>>Craig Brozefsky wrote:
>>
>>>·····@lazaridis.de writes:
>>>
>>>
>>>>not from the language:
>>>>
>>>>headache from the people in the newsgroups.
>>>>
>>>>as in other newgroups: no precision, no gentleness, no focussing on the
>>>>posters problems & questions. Many throw out all their psychological
>>>>garbage (auto-collected).
>>>
>>>Many people, most of the responses in fact, have responded to your
>>>questions in a positive manner, attempting to provide an explanation
>>>for the curretn conditions and how to operate within them. Why do you
>>>choose to ignore them when writing this screed?
>>>
>>
>>actually i don't.
>>
>>*you* choose to do it. another undfriendly behaviour in c.l.l., and
>>generally in newsgroups: *quoting uncompletely*
>>
>
>
> You are reading unfriendliness into a misunderstanding of your use of
> english.
not true, see below.
> Above you did not qualify who you were talking about and I
> assumed "headache from the people in the newsgroup" meant the
> newsgroup at large.
you assumed correct.
> Your later qualification "But some hilights." was
> basically unintelligible and I had no way to tie it to the rest of the
> post even with my several decades of English usage.
so you tied it to "nowhere"?
why don't you ask: what do you mean by "but some highlights"?
especially, as you realize that my use of english is unprecise?
switch.
we can start now to be productive.
you are a friendly one.
From: Jeff Sandys
Subject: Re: LISP - 24hours in a few days - headache
Date:
Message-ID: <3D6262F5.CBF5BAF6@juno.com>
·····@lazaridis.de wrote:
>
> "Basic Lisp Techniques"
> <http://www.franz.com/resources/educational_resources/cooper.book.pdf>
This is a good introduction. It is used to train ICAD programmers
in the fundumentals of Lisp.
>
> (let ((result 1))
> (dotimes (n 10 result)
> (setq result (+ result n))))
This is the cleanest format, but sometimes ICAD programmers break off
the
trailing parenthesis to make it easier to copy chunks from expressions.
(let ((result 1))
(dotimes (n 10 result)
(setq result (+ result n))
)
)
When I first learned Lisp we called "(" "paren" and ")" "thesis".
Does anyone still do this?
Thanks,
Jeff Sandys
Jeff Sandys <·······@juno.com> writes:
> This is the cleanest format, but sometimes ICAD programmers break off
> the
> trailing parenthesis to make it easier to copy chunks from expressions.
>
> (let ((result 1))
> (dotimes (n 10 result)
> (setq result (+ result n))
> )
> )
That's only useful if you have an editor that's less powerful than
both emacs and vi(m?)... C-M-k and v%d
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- ············@techie.com /- <-
-> -X "Structure is nothing if it is all you got. Skeletons spook X- <-
-> -/ people if [they] try to walk around on their own. I really \- <-
-> -\ wonder why XML does not." -- Erik Naggum, comp.lang.lisp /- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Rahul Jain <·····@rice.edu> writes:
> Jeff Sandys <·······@juno.com> writes:
>
> > This is the cleanest format, but sometimes ICAD programmers break off
> > the
> > trailing parenthesis to make it easier to copy chunks from expressions.
> >
> > (let ((result 1))
> > (dotimes (n 10 result)
> > (setq result (+ result n))
> > )
> > )
>
> That's only useful if you have an editor that's less powerful than
> both emacs and vi(m?)... C-M-k and v%d
It might be due to poor code structuring habits on my part, but I find
(let ((result 1))
(dotimes (n 10 result)
(setq res ult (+ result n))
))
helpful when moving chunks of code around at a given level within a
deeply nested structure- it saves retyping all the closing parens.
Gregm
From: Christopher C. Stacy
Subject: Re: LISP - 24hours in a few days - headache
Date:
Message-ID: <ubs7xxmr5.fsf@dtpq.com>
>>>>> On 20 Aug 2002 16:11:54 -0400, Greg Menke ("Greg") writes:
Greg> It might be due to poor code structuring habits on my part, but I find
Greg>
Greg> (let ((result 1))
Greg> (dotimes (n 10 result)
Greg>
Greg> (setq res ult (+ result n))
Greg>
Greg> ))
Greg>
Greg> helpful when moving chunks of code around at a given level within a
Greg> deeply nested structure- it saves retyping all the closing parens.
In Emacs, you can use the command c-m-K which smartly "kills"
an s-expression or atom. Then you move to where you want to go.
This can be done in a variety of ways, including forward/back by lines,
characters, words/atoms, sexprs, or by searching, etc. See c-m-F.
Then you can use c-Y to "yank" the code into its new place.
No need to type or re-type or edit any parens at all;
it's all done automatically for you.
You might also enjoy the m-\ and m-SPACE commands for managing
horizontal whitespace. Finally, there is c-m-Q which will
automatically re-indent your Lisp code.
······@dtpq.com (Christopher C. Stacy) writes:
> >>>>> On 20 Aug 2002 16:11:54 -0400, Greg Menke ("Greg") writes:
> Greg> It might be due to poor code structuring habits on my part, but I find
> Greg>
> Greg> (let ((result 1))
> Greg> (dotimes (n 10 result)
> Greg>
> Greg> (setq res ult (+ result n))
> Greg>
> Greg> ))
> Greg>
> Greg> helpful when moving chunks of code around at a given level within a
> Greg> deeply nested structure- it saves retyping all the closing parens.
>
> In Emacs, you can use the command c-m-K which smartly "kills"
> an s-expression or atom. Then you move to where you want to go.
> This can be done in a variety of ways, including forward/back by lines,
> characters, words/atoms, sexprs, or by searching, etc. See c-m-F.
> Then you can use c-Y to "yank" the code into its new place.
> No need to type or re-type or edit any parens at all;
> it's all done automatically for you.
Ahhhh. I regularly use the c-m-F and c-m-B, but haven't tried c-m-K
yet.
Even after a couple years, I'm still unlearning Windows-style
cut/copy/paste defaults. Its really amazing how learning on limited
Windows tools impedes taking advantage of an environment.
> You might also enjoy the m-\ and m-SPACE commands for managing
> horizontal whitespace. Finally, there is c-m-Q which will
> automatically re-indent your Lisp code.
Thanks! I'll give them a try tomorrow.
Gregm
Jeff Sandys wrote:
> ·····@lazaridis.de wrote:
...
>>(let ((result 1))
>> (dotimes (n 10 result)
>> (setq result (+ result n))))
>
>
> This is the cleanest format, but sometimes ICAD programmers break off
> the
> trailing parenthesis to make it easier to copy chunks from expressions.
>
> (let ((result 1))
> (dotimes (n 10 result)
> (setq result (+ result n))
> )
> )
looks good!
From: Tim Moore
Subject: Re: LISP - 24hours in a few days - headache
Date:
Message-ID: <ak0ml3$8v1$0@216.39.145.192>
On Wed, 21 Aug 2002 19:41:54 +0300, ilias <·······@pontos.net> wrote:
>Jeff Sandys wrote:
>> ·····@lazaridis.de wrote:
>...
>>>(let ((result 1))
>>> (dotimes (n 10 result)
>>> (setq result (+ result n))))
>>
>>
>> This is the cleanest format, but sometimes ICAD programmers break off
>> the
>> trailing parenthesis to make it easier to copy chunks from expressions.
>>
>> (let ((result 1))
>> (dotimes (n 10 result)
>> (setq result (+ result n))
>> )
>> )
>
>looks good!
No.
Tim