Re: Xah on Lisp

On Aug 16, 8:18 pm, Don Geddis <d...@geddis.org> wrote:
> "xah...@gmail.com" <xah...@gmail.com> wrote on Sat, 16 Aug 2008:
>
> > [...] stupid and wrong? [...]
> > But you morons [...]
> > you guys [...] are completely idiotic.
> > [...] just hot air. [...] off topic drivel [...]
> > [...] newsgroup [...] doomed to be stupid drivels [...]
> > [...] you morons [...]
> > [...] morons in newsgroup just tried to fuck around. [...]
> > my REPEATED tries to be reasonable are often met with fucking morons [....]
> > Don't be a moron. [...]
> > [...] show me the degree of your moronicity [...]
>
> Hey, quick suggestion for you Xah: if you're actually trying to convince
> your audience of your point of view, you might have more success if you
> aren't so rude to them at the same time.

You see, perhaps you don't know, but several have suggested this to me
in the past 10+ years.

of course, if my pure goal is education, then first of all, newsgroup
is the wrong medium. I LOL to think anyone should think i tried to be
a educator thru newsgroups.

as you know, newsgroup, judging from the posts on it, is rather a
playground.

you see, so for me, not only i want to teach, and have tech geeking
morons thank me, but, you know, i'm ambitious, so meanwhile i also
want to call morons morons, and fuckfaces fuckfaces, as truth and or
when they deserve it (n as u know, they deserve it). And, my writing
is to serve multi-purposes as a writting etude, relaxation, and thesis
drafting. Can you see, all the pieces fit together?

actually, surveying the results of my past decade of online writing, i
think i rather succeeded in my goals above.

> Perhaps -- just perhaps -- you're generally ignored ... because you deserve
> to be.

LOL. If you look at the number who responds to my posts or mentions me
out of the blue, i don't think i'm ignored at all. Many tech geekers,
in newsgroups and as well as in blogs, have explicitly claimed to love
reading my posts for one reason or another. There's delicious.com
website bookmark you can search my name “xah” to see.

hold your breath, let me run to take a piss then answer your lisp
question.

> > the fundamental problems lisp as shown in my essay here:
> >http://xahlee.org/UnixResource_dir/w..._problems.html
> > We can, itemize the essay, make it into precise statements, and we can
> > argue in detail. The statements can be made so that each is verifiable
> > and falsifiable, and most of us would agree that it is a reasonable
> > rephrasing from my essay. Then, we can argue in detail about which. Do
> > you want to do that??
>
> Ok. At least it will get the thread finally on-topic again.
>
> > Let me be more positive on this... since we don't have nothing to do.
> > Let me suggest, you pick some particular claim i made that you think
> > i'm stupid or wrong. Then, we can go on, with above guidelines perhaps
> > about precision of statement, verifiability, fasifiability, and any
> > other things about argument that make it a better one. Then, we can
> > argue in detail. So, in the end, we can see who's more right.
>
> Sure. Let's do it.
>
> Your first claimed "fundamental problem" of Lisp is:
>
> Lisp relies on a regular nested syntax. However, the lisp syntax has
> several irregularities, that reduces such syntax's power and confuses
> the language semantics. (i.e. those «' # ; ` ,» chars.)
>
> I'm aware that Lisp's reader, with the standard readtable, offers a
> syntax that includes the characters your mentioned. I happen to think
> they're convenient to the programmer, offer additional benefit, and cause
> no problems.
>
> Let me grant that the majority of Lisp has a "regular nested syntax".
> Let me grant that there are a few (deliberate!) "irregularities".
>
> The topics in dispute are:
>
> 1. Whether the syntax "irregularities" due to the five mentioned characters
> "reduce the syntax's power".

i have given many examples in my essay.
http://xahlee.org/UnixResource_dir/w..._problems.html

In summary:
• it makes parsing the source code more difficult than if the lang
doesn't have such irregular syntax. Note that a outstanding point
about lisp is that it features a regular syntax, and this is a major
point that lispers think lisp is great, as you can see in just about
every publication and advocacy of lisp. In these mostly fanatical
advocacy, you almost never see a mention, that lisp's regular syntax
actually contain quite a few irregularities.

• as i have given detail in my essay, that a pure nested syntax has
several advantegous consequences. Macros, pattern structure matching,
automated code formatting, etc. And as i have detailed, some of these
advantages are not realized or not realized fully. Part of the reason,
or perhaps the major reason, can be attributed to lisp's
irregularities in syntax.

In the article, the above are expounded in few thousand words. Which
part you do not agree?

Let me note here, questions like “why didn't xyz happen in history or
what's its cause” is in general cannot have exact, absolute, indelible
answers. However, reasonable research and progress can be made. In
fact, all important discussions in human subjects, almost none are
actually of the mathematical logic type, fact-checking type, or
verifiable by experiment type, where absolute answer can be given,
however, most subjects can have reasonable conclusions.

It is then my claim, that my criticism is very reasonable, that any
computer scientists who have studied various computer languages, and
with a exertise in lisp, should agree that my criticism is a very
valid one.

> 2. Whether the syntax "irregularities" due to the five mentioned characters
> "confuses the language semantics".

One easy way to see that it in fact confuses people is by checking the
frequency of such questions arise in lisp forums.

For example, one of the frequent question is what's the diff between:

(list a b c)
'(a b c)
(quote a b c)

you can see it asked in a recent post in comp.emacs or gun.help.emacs,
where you see experts give various probing type of answers. This is
just one example, and it i think a frequent question.

There are other more esoteric examples involving other such chars,
some used in macro etc.

As a example, let me ask this: among lispers who has at least 2 years
of coding lisp, how many can actually list all the lisp's syntax
irregularities? How many can actually say, that which is syntax sugar,
which is not? How many can entail each's meanings exactly? How many
can say, which is in Common Lisp only, or Scheme lisp, or emacs lisp?
And which's behavior are implementation dependent and what it is? Also
note, Scheme 6 in r6rs introduced few more of these, that
controversial among large number long time scheme experts and
implementators.

So, it is my claim, that these lisp irregular syntax, is a major cause
of confusion with respect to lisp's syntax. Also, in my article i used
5 of them «' # ; ` ,» as a example of lisp's irregular syntax. There
might be more.

> 3. Whether the syntax "irregularities" due to the five mentioned characters,
> even if (hypothetically) agreed to be non-optimal, are they a "fundamental
> problem of Lisp"?

Yes. Fundamental can have 2 senses here: (1) deep seated; rooted. (2)
critical; important.

It is not deniable that the irregular syntax such as «' # ; ` ,» are
deeply rooted in lisp. It has been with lisp since few decades if not
at the very beginning. As to whether it is a critical issue, i think
it is.
Note that whether this is “critical” depends on what one considers
critical... since what's consider critical is dependent on point of
view or there is a degree of it. I consider it is critical in the
context of lisp's often tauted regular syntax advantage. However,
this issue in contrast to the other issue in my essay about lisp's
cons business, i consider that the cons is more critical, or
absolutely critical. The issue of criticality or what's considered
fundamental, we can further refine, so as not to use these words. For
example, instead of saying the convenient phrase of “fundamental
problem” or “critical problem”, i can rephrase theminto something
like “is problem such that certain percentage of lispers ask these
questions or get confused by these” or other similar quantifiable
ways.

> You make all three claims. I disagree (strongly!) with all three.
>
> How can we resolve this? What process do you recommend, for eventually
> discovering whether you or I are in fact correct about this topic?

In the above, i give reasonable arguments. We can just argue about it
the usual online forum way by exchange writings. But if you do have
better suggestions, for example such as brining in arbitors, monetary
vouch for sincerity, bet, affidavit, credential, etc, as i have
suggested before, we can further discuss.

this post is posted to comp.lang.lisp and comp.lang.scheme .

Xah
∑ http://xahlee.org/

☄

The following is posted to comp.lang.lisp but i intended to post to
comp.lang.scheme too. This is a repost.


On Aug 18, 9:39 am, Don Geddis <d...@geddis.org> wrote:
> "xah...@gmail.com" <xah...@gmail.com> wrote on Sun, 17 Aug 2008:
>
> > On Aug 16, 8:18 pm, Don Geddis <d...@geddis.org> wrote:
> >> Your first claimed "fundamental problem" of Lisp is:
> >> Lisp relies on a regular nested syntax. However, the lisp syntax
> >> has several irregularities, that reduces such syntax's power and
> >> confuses the language semantics. (i.e. those «' # ; ` ,» chars.)
> >> The topics in dispute are:
> >> 1. Whether the syntax "irregularities" due to the five mentioned characters
> >> "reduce the syntax's power".
>
> > i have given many examples in my essay.
> > http://xahlee.org/UnixResource_dir/w..._problems.html
>
> You have not defined what it means for a syntax to have "power", nor have
> you given any specific examples of how the five characters "reduce" that
> so-called power.

You want me to define the power of a computer language?

You think i don't give sufficient explanation and needs to define the
term?

are you aware that defining such a thing is nearly impossible? For
example, let me cite 2 well known examples. In math, there's the
problem of definition of “random”. In science, or computer science,
there's the problem of defining “intelligence”. In biology,there's
the problem of defining “life”. You dont mean that any publication
involving these concepts must define them?

You are not, i hope, throwing out random retort to disrupt the
argument, right? Or, perharps you are not well aquainted of the role
of “definition” in philosophy and criticial thinking? I tend to think
it's the latter, to be bluntly honest.

let me give more specific example... the notion of the “power” of a
computer language, or “expressiveness” of a computer language. You
know, that these are widely used terms and abused. However, there is
really no good general definition. Some computer scientist, tried to
formalize it in some mathematical way, but basically went no where
(such's failure, for example, can be attributed or judged by lack of
effectiveness, practicality, utility).

Do you need me to cite papers, books, on these definition issues i
discussed above?

Ok, i don't mean to derail what might be your honest attemp to argue.
Let me say then, that the “reduced such syntax's power” notion in my
essay, i think is amply examplified in my essay. For example, i gave
examples in comparison to XML, Mathematica, automatic code
formating... (the essay is here:
http://xahlee.org/UnixResource_dir/w..._problems.html
possibly you might reread it carefully now since you might just have
scanned and dismissed it before. Note that the essay, links some 8 or
so more essays providing support on each part.
)

Let me give it another try. In general, the power of computing
language, is roughly the ratio of ease/possibility. The “ease” there
is ease of use, ease of learning, succinctness of source code, size of
existing functions or libraries, accessibility, etc. The “possibility”
in the denominator is roughly what it does, what it can do. For
example, it can be cover perspectives from areas of fitness, e.g.
mathematical computation, visualization system, web application,
networking, sys admin, “glue lang”, embeded scripting lang,low level
systems lang, proof systems ... etc. and ... and ... and ... but i'm
carried away into generalities. In short, my criticism on lisp in that
essay provide reasonable definition of power in its contex. Please
double check to see if you agree.

> Start there. What is the "power" of a syntax? If I had two different
> proposed syntaxes, how would I determine which one had more "power"?
> Why is "syntax power" even a good thing in a programming language?

Ok. See above.

Note, you used the “Start there” phrase. Is that jab? I believe you
are trying to have a good argument with me, not exchange of hotair,
right? I mean, at least, i believe, that you, thinks you are trying to
have a reasonable argument on my criticism of lisp, and not trying to
be a hotair balloon. I, myself, have not yet fully decided to commit a
full honest discourse with you. (for reasons, see:
http://xahlee.org/Netiquette_dir/disrespectfulness.html
) But, if you, decides that at least you, want to be fully polite and
earnist in this discussion, i would suggest, that you exercise care in
your intonation in your argument with me. Because, otherwise, you
might just be another target that i use for mainly ridicule purposes.
You still have a chance to redeem yourself.

> If I had two different
> proposed syntaxes, how would I determine which one had more "power"?

lisp uses nested syntax. As you know, many lisp publications and
advocacy say that is one of the source of lisp's power. For example,
lisp's macro relies heavily on lisp's nest syntax. Isn't this obvious
to you??

> > In summary:
> > it makes parsing the source code more difficult than if the lang
> > doesn't have such irregular syntax.
>
> Well, sure. But, in exchange for that (minor!) cost, you get the benefit
> of ease of use by humans.

Are those special chars ALL sugar syntaxes?

Could you, or anyone, summarize them all?

> Besides which, every Lisp implementation has already conveniently implemented
> the Lisp parser for you. So you don't have to write it yourself! Just call
> the built-in parser.

The issue is not about parser or compiler. The issue i mentioned about
syntax, has to do with the language's power that came from a nested
syntax.

For example, let's say perl. Perl's syntax is a syntax soup, quite
opposite of lisp. Suppose, if perl switched to lisp's syntax, then
perhaps it would develope lisp macros. Then, from a specific point of
view of lispers, we could say, that perl's syntax is less powerful,
because its syntax's irregularity in some sense prevent it from
developing into the concept of lisp's macro. Perlers might say, well
parsing is already done by perl compilers. But you see now, that is
really a narrow view.

Similarly, when i say that the irregularities in lisp hampered it from
developing many fruitful use of regular syntax (with many examples
given in my essay), you have to consider it from the the context of
computer language's syntaxes, and not construe it as whether lisp's
irregularity is a problem to lispers.

For example, one of the example i gave about how the irregularities in
lisp's syntax is that it hampered the development of a automated code
formatting facilitiest (see the article for detailed examples and
explanations).

> Certainly, it makes _writing_ a Lisp implementation (esp. the parser)
> somewhat more difficult than it otherwise would have been. But why in
> world do you think that writing an implementation is the goal to optimize
> when designing a programming language? Surely the Common Lisp choice,
> to optimize _using_ the language to write _other_ programs, rather than
> optimizing the ease of implementation of the language, is a far better
> choice than the one you are suggesting.

as i explained above, it is not about writing compilers or parsers.
See above.

> > Note that a outstanding point about lisp is that it features a regular
> > syntax, and this is a major point that lispers think lisp is great, as you
> > can see in just about every publication and advocacy of lisp. In these
> > mostly fanatical advocacy, you almost never see a mention, that lisp's
> > regular syntax actually contain quite a few irregularities.
>
> But how -- _exactly_ -- do those few irregulatrities actually cause a
> problem, in practice, for real programmers?

again, the criticism is about some particular aspect of lisp's syntax,
namely, the syntax's irregularity in the context of lisp's philosophy
of regular syntax. The proper vantage point of such criticism is to
look at it in the syntax design of computer languages, and apply it to
lisp's philosophy of syntax. It is not about, for example, whether
lispers would consider lisp's syntax a problem. As a analogy, if you
criticise perl's syntax, the perlpers retort that perl programers
don't have a problem with it.

> And keep in mind that these "irregularities" that you mention definitely
> do provide known benefits to programmers. (E.g. "#" is useful for commenting
> your code inline, etc.)

One of the question i have is, whether all lisp's irregular syntax are
all simply syntax sugars. For one thing, the comment system i.e. “;”
is not. For another, some of these irregularities, for example the
“'”, breaks the structure of nested syntax. i.e. compare “'(a b c) vs
(' a b c)”. I do not know much about the others.

You mentioned that some of the syntaxes provide convenience to
programers. for example, those so-called sugar syntaxes. Note here,
that i'm not against sugar syntaxes. But the criticism is that some or
all of these sugar syntaxes breaks many properties that is the
fundamental advantage of lisp's nested syntax. (again, please read my
detailed essay; don't just pick this paragraph and start argument all
over)

Also keep in mind, as i mentioned numerous times, that not all these
are merely variant syntaxes. For example, there's no parenthized form
for “;”. So, in this particular point, it means there cannot be a
uniform transformation on syntax that gets you the pure nested form.

> > as i have given detail in my essay, that a pure nested syntax has several
> > advantegous consequences. Macros
>
> You have stated this, but you are simply wrong.
>
> Perhaps you don't understand how Lisp works. I'm not trying to be insulting
> here. But your claim that "irregular" textual syntax makes writing macros
> hard betrays a critical error in thinking about what Lisp is doing.
>
> Here's what you've missed: Source code is written as sequences of characters
> in a text file (or typed into the interpreter). But then -- BEFORE macros
> ever get to do any work -- the text characters are processed by the Lisp
> reader, resulting in internal data structures in a kind of Abstract Syntax
> Tree.
>
> Lisp macros operate on the AST, _not_ on the text strings.

This is the part you common lispers, fully becomes stupid. When
discussion on this gets deeper, common lisping fans began to criticize
Scheme, or to the degree of saying that Scheme is not lisp or some
deviantiation. When Common Lispers defend my criticism of lisp syntax
and in their defense starts to attack Scheme Lisp, you can begin to
get the feeling of how Common Lispers failed to see the overall
picture.

You need to, as i said, not bury your head inside common lisp. Let me
say again, my criticism of lisp, part of which is about the
irregularities of its often-believed regular syntax. The proper
vantage point is the theory of computer syntaxes, applied to lisp's
philosophy of one particular way, namely, purely nested form. If you
simply view it from a lisp programing, with retorts such as “lisper
programers never found it a problem”, then you are not understanding
the criticism at all.

Let's discuss the idea that CL acts on its object, and the source code
merely a textual representation. Let me tell you, that most computer
languages, all have a syntax (we are excluding things like
spreadsheets and visual lang etc. (i'm trying to type fast, so morons
pls try not to pick on this and drivel about how spread sheets has
syntax too etc)). Regardless how CL has some the Abstract Syntax Tree
or Object idea, in the contex of computer languages, it still has just
one input form what we'd call the the language's syntax. Now, lisp's
lang's philosophy about syntax, emphasize that it should be fully
nested. This is a elementary feature of the lisp family of langs.
(lisps that breaks away from this nested syntax, are often alienated
by lispers and considered as only lisp derivative, such as logo,
dylan.) It is true that CL macros act on AST as you say, but however,
its nested syntax is a fundamental part of it. Theoretically, you
could have a lang with non-nested syntax (such as perl, C) yet still
have a macro system identical or almost identical to lisp.


> So, you are trying to claim, for example, that the "#" "non-regular" comment
> character makes writing Lisp macros "harder". And you are simply wrong.
> By the time a macro starts work, all the comments have already be stripped.
> In fact, you will be unable to write a macro that can even tell the difference
> between whether there was a comment character in the code or not.

See above.

Let me give another example to tackle criticisms of syntax of
languages.

One way, is to think of a lisp language (say, called regLisp), such
that without any irregularities in syntax as i criticised in my essay.
I mean, seriously, spend 20 mintues, to think of a lisp lang that
doesn't have any syntax irregularies described in my criticism.

Note, this does not mean not having any sugar syntaxes. Sugar syntax
is of course very convenient and practical, often even necessary, but
any sugar syntax are done so that the uniformity in syntax property
remains intact.

Now, if you imagine this language. Now, think about how would this
regLisp compared to CL for example? Would it lose any advantage that
CL have? (think in all aspects) Would it actually have any ADVANTAGES?

By my criticism, the answer is that such regLisp would lose nothing of
CL's advantage, but has far more advantages to gain (as detailed in my
essay; and Mathematica is cited as a living example and XML and its
vast number of derivatives are cited as a example of widely accepted
advantage of syntax regularity).

> So. We come to the first chance for Xah to rise above his apparent
> troll-ness. In every post I've read from you,Xah, you treat yourself as
> all-knowing and all-intelligent, and any disagreement with anyone else
> results in you calling the others "morons", "idiots", etc.

As i said above, if you really want earnest discussion with me sans
attitude, you can start with yourself, and drop paragraphs such as
above. As a guide, prevent you are writing to your family, friends,
who are very dear to you. When i see true sincerity, i will act
accordingly.

> Can you be honest, in this one case? Can you admit that you have claimed
> that Lisp's "irregular syntax" makes writing macros "harder", and you were
> simply mistaken on that point? It is not true, and you admit your mistake?

To be honest, i consider myself 50 years beyond this world.
Not 500, or 100. By “beyond”, it means my views in most things are
more advanced, correct, superior, than most experts in respective
areas where i cared to give forceful opinions.

Discussing with most people in newsgroups, to me, is more liking
playing with stupid highschool bullies.

You can quote me on this. I want you to know, that i earnestly meant
the above. You can forthwith now write me off as a cook, pseudo-
science crackpot, ergomaniac, whatever. But i hope you believe at
least what i really think of myself.

> This, I think, is the test case for actual productive discussion
> with you,Xah. My prediction is that your ego is too inflated to
> ever admit error.

I do admit errors. In fact it have happened publically few times over
the past 10+ years in newsgroup. I'm not going to search the exact
thread and show you the groups.google.com url. I have, admitted
errors, including technical errors, or errors in opinion oriented
argument. I have also, mind you, expressed sincere appreciation and
gratitude when being helped, or given opinion that i think are
worthwhile. This happens much more often than being corrected. The
fact that many, if not most, newsgroup tech geeking morons sees me as
a so-called troll, is partly because negative aspects are much more
visible.

> You are more interested in "winning" and annoying people, then you are in
> actually discovering truth or learning anything.

Shut ya yap.

> But perhaps I'm wrong. So let's see how you respond to having made a
> mistake. Are you man enough to admit it?

Shut ya yap.

If i see more such yap in your reply, then you'll fully become another
of my subject of a playhting, much like cat toys with mouses under her
paw.

How i play with my subjects are exhibited in my few hundreds archived
writings now on my website. I'm sure you don't need me to paste
another url.

> > It is then my claim, that my criticism is very reasonable, that any
> > computer scientists who have studied various computer languages, and with a
> > exertise in lisp, should agree that my criticism is a very valid one.
>
> I'm not a CS professor, but I've programmed in a dozen languages over time,
> and in Common Lisp for ~20 years. I don't agree that your criticism is valid.

Good to know.

> >> 2. Whether the syntax "irregularities" due to the five mentioned characters
> >> "confuses the language semantics".
>
> > One easy way to see that it in fact confuses people is by checking the
> > frequency of such questions arise in lisp forums.
>
> Ah, but that's a different claim. Let's leave aside for the moment whether
> Lisp's language semantics confused "people". (I happen to disagree with that
> too, but that isn't the topic we're discussing.)
>
> What you wrote is that the syntax "irregularities" confuse the language
> _semantics_. Not that they confuse people.

i'm not sure what does it mean that a language's syntax could actually
confuse its semantics. I used the phrase to convey the idea that the
correspondence of syntax and semantics becomes inconsistant or complex
due to lisp's irregularities in its syntax. In Von Newmann programing
langs, such as C, C++, Java, Perl etc, their syntax is a ad hoc syntax
soup, so there is little correspondence of their syntactical forms and
each's semantics. In lisp, there is, due to lisp's nested syntax. So,
i'm saying, lisp's irregularities in syntax breaks this syntax-
semantics correspondence.

In my previous post, i mentioned that the frequency of chars like «'
# ; ` ,» in lisp confuse people, as a support that irregularities in
lisp syntax increased its syntax-semantics complexity.

> Please justify your claim that Lisp's semantics are confused because of
> the syntax.
>
> Or, admit your error and withdraw the claim.

See above.

> > For example, one of the frequent question is what's the diff between:
> > (list a b c)
> > '(a b c)
> > (quote a b c)
> > you can see it asked in a recent post in comp.emacs or gun.help.emacs,
> > where you see experts give various probing type of answers. This is just
> > one example, and it i think a frequent question.
>
> People (especially those new to Lisp) can be confused by this, yes.
>
> The language itself (i.e. the Lisp semantics) are in no way confused.
>
> I also note in passing that your first and third example:
> (list a b c)
> (quote a b c)
> have exactly the same, completely REGULAR syntax. So whatever confusion
> there might be here (to new programmers), has nothing to do with the
> irregular syntax of Lisp.
>
> Another chance for you to admit that you made a mistake in blaming this
> confusion on the five "irregular" Lisp syntax characters that you mentioned.
>
> > As a example, let me ask this: among lispers who has at least 2 years of
> > coding lisp, how many can actually list all the lisp's syntax
> > irregularities?
>
> Why is that an important test? If I answer "10%", how does that matter?
>
> > How many can say, which is in Common Lisp only, or Scheme lisp, or emacs
> > lisp?
>
> We're generally discussing Common Lisp only on this newsgroup. The others
> are different languages. It doesn't even make sense to talk about how
> differences between DIFFERENT languages confuse people.

My criticism of lisp is about lisp, not specifically just Common Lisp.
More specifically, it is about Common Lisp, Scheme Lisp, Emacs Lisp.
My criticism, namely the irregularity of syntax and the cons business,
is equally applicable to all these lisp family langs.

> Do you think it's a legitimate complaint against Python, that it confused
> Perl programmers because some aspects of the language are different? It's
> a different language!

If a criticism that does apply equally well to Perl and Python, then
it is still a valid criticism. For example, if i made some criticism
regarding imperative programing, then it applies to perl and python.

In the same way, you can see that my cricisim of lisp, namely, the
irregularity in syntax, and the cons business, are applicable to
Common Lisp, Scheme Lisp, Emacs Lisp.

> You can be an expert Common Lisp programmer, while knowing nothing at all
> about Emacs Lisp. So what?
>
> >> 3. Whether the syntax "irregularities" due to the five mentioned characters,
> >> even if (hypothetically) agreed to be non-optimal, are they a
> >> "fundamental problem of Lisp"?
>
> > Yes. Fundamental can have 2 senses here: (1) deep seated; rooted. (2)
> > critical; important.
>
> Agreed.
>
> > It is not deniable that the irregular syntax such as «' # ; ` ,» are
> > deeply rooted in lisp. It has been with lisp since few decades if not
> > at the very beginning.
>
> I agree again.
>
> > As to whether it is a critical issue, i think it is.
>
> Still disagree on this one...
>
> > I consider it is critical in the context of lisp's often tauted regular
> > syntax advantage. However, this issue in contrast to the other issue in my
> > essay about lisp's cons business, i consider that the cons is more
> > critical, or absolutely critical.
>
> OK, understood. And, if we make productive progress on the syntax issue,
> perhaps we can begin to explore the cons issue later.
>
> But I suspect you aren't actually interested in learning anything.
> I suspect you just like to lecture (regardless of your state of knowledge)
> and rile people up.

Drop it.

> If I'm wrong, I apologize. If you do manage to keep your response on a
> technical level, then I'll do the same. And if we get past the syntax
> topic, then I'll be happy to continue on to explain the cons issue to you..

You don't explain the cons issue to me. Your position presently, if
you are earnest, is challenging my claims or criticise my criticism or
having a sensible debate with me. You are, not here as a teacher to
discipline or rebuke me. So, when writing, get your intonation
correct.

I suppose your intonation is inadvertent. That's fine. If you are
actually intentionally injecting little sneer here and there, let me
just say that my eyes are senstive, and i bite. The question you
should truely ask yourself is: Do i really wish to see Xah's earnest
opinion and reasons in my challenges to his lisp views?

> But I strongly suspect you are not capable of admitting that you made a
> mistake on when describing the "problems" of Lisp's syntax.

You can suppose what you want. You can now decide what you want to do.

> > For example, instead of saying the convenient phrase of "fundamental
> > problem" or "critical problem", i can rephrase them into something like"is
> > problem such that certain percentage of lispers ask these questions or get
> > confused by these" or other similar quantifiable ways.
>
> I think if you had used this more tactful language originally, you would
> have seen far less objection from the Lisp folks. And the discussion would
> have proceeded in a very different direction.

My language, writing style, in part, is to ridicule the tech geeking
morons, may they be perlers or lisper or javaer, who are typically
buried in their small world. As i have expressed here ambly, in
general it is not my intention, to simply participate in honest
discussion or exchange of views. My reasons or justification about
this are are written in many essays. The index page to these essays is
here:

Netiquette Anthropology
http://xahlee.org/Netiquette_dir/troll.html

> (For example, confusion can often be addressed by education or good
> tutorials. But "fundamental problem" can only be addressed by changing
> the core language.)

Although lisp's syntax irregularity and cons business are rooted, and
difficult to change, however, there are many ways to mend them, such
as happens language evolution. Even if we don't consider new langs as
fixes (such as Qi, arc, NewLisp, DyLan), but there are evolutions such
as Pascal to Object Pascal, Fortran to Fortran99, OCaml to F#,
Scheme's r5rs to r6rs, etc. These are all examples of the same
language that goes thru improvement with rather backward incompatible.

Similarly, lisp, has many gradual innovations and fixes. (although i
don't know CL, but for example of CL, there's asdf package system as
heard here, and Qi, which addes pattern matching and other functional
features to CL.)

The point of my criticism, is that i have some hope in raising
awareness. That essay, “fundamental problems of lisp” arosepartly due
to many times in the past years i tried to speak my own frustrations
of the cons business, or those confusing irregular syntax chars, or
speak of some ideas from my Mathematica background that relates to
these issues, and i met with absolute denial from the motherfucking
lisp regular morons. (comparable in the same way if lisper were to
give reasonable criticism (as opposed to vicious attack) or bring some
ideas from a lisper's experience to say perl or java groups.)

Ok, am sending out this. Not gonna do any editing work. Took me long
enough to type.

Xah
∑ http://xahlee.org/

☄

Dear lispers and functional programers,

there's this Don Geddis now having a debate with me.

The debate is about 2 criticisms on lisp, namely its irregularities in
its nested syntax and its use of cons for list. The criticism is
presented in this essay:
“The Fundamental Problems Of Lisp” at
http://xahlee.org/UnixResource_dir/w..._problems.html
(originally a newsgroup post)

The debate is in this long winding thread:
http://groups.google.com/group/comp....ee331cfe13f214
The debate start at the message where the subject is changed to “Xah
on Lisp”.

i ran out of patience in dealing with Don.

Is he just fucking with me? or should i really try a earnest effort at
the debate?

For example, he asked for concrete examples. My essay, are perhaps
over 10 thousands words counting all supporting essays linked from it.
Though, sometimes in complex issues that may not be sufficient. Also,
a open publication for the general public really needs painstaking
efforts and volumes of examples, theorizations, citations.

I can see how i could actually add some more concrete scenarios on how
the lisp irregularity reduces the syntax's power. But that takes much
more effort. I mean, to really present my criticism well is almost
like writing a publishing quality booklet. It could be a full time 2
week's job.

But, i do think my essay really sufficiently showed my ideas to any
computer language expert who are intelligent and open minded. Don
idiot avows that he don't see any point in it. I have no doubt lispers
like Rainer Joswig don't get it at all too. I'm not sure lisper Pascal
J Bourguignon would have anything good to say about it. Sure, these
are Common Lisp fanatics. Their opinions on a piece of negative
criticism on lisp can be safely discarded. What i would like to know,
is that whether the essay is really that unreasonable, insufficient,
in getting its idea across?

Xah
∑ http://xahlee.org/

☄

On Aug 21, 12:14 pm, Don Geddis <d...@geddis.org> wrote:
> >> I've asked you to give me a concrete example of a Common Lisp macro that
> >> can even notice the "irregular syntax" of Lisp. To repeat, the example
> >> is:
> >> (defmacroxah(f n m) (list (quote funcall) f n m))
> >> (defun test1 () (xah#'+ 1 #| HiXah! |# 2)) ; Hi again,Xah!
> >> (defun test2 () (xah(function +) 1 2))
> >> The challenge is: please rewrite the macro "xah", such that the functions
> >> "test1" and "test2" (which differ only in whether they use "regular" lisp
> >> syntax or "irregular" lisp syntax) return different values. (Right now,
> >> both return 3).
>
> > For example, in your example, using a lisp using regular syntax, might
> > be this:
> > (defmacroxah(f n m) (list (' funcall) f n m))
> > (defun test1 () (# (xah(' +) 1 (#| HiXah!) 2))) (; Hi again,Xah!)
> > (defun test2 () (xah(function +) 1 2))
> > Why is this better? Because, as you can see, the syntax all have this
> > regular form: “(f x1 x2 ...)”, no exceptions.
>
> You've missed the point. (I rewrote my "xah" macro above using your
> preferred notation.) The point is, the test1 and test2 functions.
> They are IDENTICAL, except that one uses a lot of "irregular" syntax,
> and the other only uses your preferred "regular" syntax.

Ok, i see the purpose of your 2 versions of xah macro now. Thanks for
the clarification. Yes i misunderstood you before.

Let me explain, that your macro example:

(defmacro xah (f n m) (list (quote funcall) f n m))
(defun test1 () (xah#'+ 1 #| HiXah! |# 2)) ; Hi again,Xah!
(defun test2 () (xah(function +) 1 2))

does not address the criticism on syntax irregularity.

For example, due to lisp's (almost) regular nested syntax, one of its
power is that the editor can understand the semantic structure of the
code, without actually being a parser or compiler. For example, in
emacs, you have forward-sexp, mark-sexp and a lot others that
manipulate lisp expressions. This can be done in lisp, precisely
because its syntax is based on a simple regular form. As a counter
example, this cannot be done in C, perl, java, javascript, python, etc
lang due to the fact that they don't use a regular simple syntax.

So, in your macro example, for example this one:

(defun test1 () (xah# '+ 1 #| HiXah! |# 2))

i cannot move my cursor to the “#|” part and call mark-sexpto select
it.
However, if suppore there is a RegLisp that does not have such
irregularity in syntax, suppose it looks like:

(defun test1 () (# (xah (' +) 1 (#| HiXah!) 2)))

then emacs sexp manipulation functions works anywhere in the code.

Can you see what i mean?

Also, this is one concrete, simple example, to illustrate one power
that's lost due to irregularities in syntax. I gave many detailed
explanation in my original article here: http://xahlee.org/UnixResource_dir/w..._problems.html

I quote 3 paragraphs:

«
• Lisp relies on a regular nested syntax. Because of such regularity
of the syntax, it allows transformation of the source code by a simple
lexical scan. This has powerful ramification. (practically, lispers
realized just one: the lisp macros) For example, since the syntax is
regular, one could easily have alternative, easier to read syntaxes as
a layer. (the concept is somewhat known in early lisp as M-expression)
Mathematica took this advantage (probably independent of lisp's
influence), so that you really have easy to read syntax, yet fully
retain the regular form advantages. In lisp history, such layer been
done and tried here and there in various forms or langs ( CGOL↗,
Dylan↗), but never caught on due to largely social happenings. Partof
these reasons are political. (thanks to, in part, sensitive and
ignorant lispers here that stops proper discussion of it.)

• One of the advantage of pure fully functional syntax is that a
programer should never need to format his source code (i.e. pressing
tabs, returns) in coding, and save the hundreds hours of labor,
guides, tutorials, advices, publications, editor tools, on what's
known as “coding style convention”, because the editor can reformat
the source code on the fly based on a simple lexical scan. This is
done in Mathematica version 3 (~1996). In coding elisp, i'm pained to
no ends by the manual process of formatting lisp code. The lisp
community, established a particular way of formatting lisp code as
exhibited in emacs's lisp modes and written guides of conventions. The
recognization of such convention further erode any possibility and
awareness of automatic, uniform, universal, formatting. (e.g. the
uniform and universal part of advantage is exhibited by Python)

• Lisp relies on a regular nested syntax. One of the power of such
pure syntax is that you could build up layers on top of it, so that
the source code can function as markup of conventional mathematical
notations (i.e. MathML) and or as a word-processing-like file that can
contain structures, images (e.g. Microsoft Office Open XML↗), yet lose
practical nothing. This is done in Mathematica in ~1996 with release
of Mathematica version 3. (e.g. think of XML, its uniform nested
syntax, its diverse use as a markup lang, then, some people are adding
computational semantics to it now (i.e. a computer language with
syntax of xml. e.g. O:XML↗). You can think of Mathematica going the
other way, by starting with a computer lang with a regular nested
syntax, then add new but inert keywords to it with markup semantics.
The compiler will just treat these inert keywords like comment syntax
when doing computation. When the source code is read by a editor, the
editor takes the markup keywords for structural or stylitic
representation, with title, chapter heading, tables, images,
animations, hyperlinks, typeset math expression (e.g. think of
MathML↗) etc. The non-marked-up keywords are shown as one-dimentional
textual source code just like source code is normally shown is most
languages.)

»

are you convinced?

Xah
∑ http://xahlee.org/

☄

Xah Lee wrote
> > For example, due to lisp's (almost) regular nested syntax, one of its
> > power is that the editor can understand the semantic structure of the
> > code, without actually being a parser or compiler. For example, in
> > emacs, you have forward-sexp, mark-sexp and a lot others that
> > manipulate lisp expressions. This can be done in lisp, precisely
> > because its syntax is based on a simple regular form. As a counter
> > example, this cannot be done in C, perl, java, javascript, python, etc
> > lang due to the fact that they don't use a regular simple syntax.

Rainer Joswig wrote:
> S-Expressions are not the syntax of Lisp code.
> They are the syntax for Lisp data. By understanding s-expressions
> the Editor still knows nothing about the syntax of Lisp code forms.
>
> If you write (defun) it is a valid s-expression, but not
> valid Lisp code. (defun (foo)) is also nicely nested, still
> it is not valid Lisp code.
>
> S-Expression support in the editor allows nice manipulations of
> tree-structured data. But the editor does not know because
> of just s-expressions what a variable is, what a function name is,
> what a list of bindings is, what an arglist is and so on.
> It does not know that the second item in

Rainer, i tried to explain this several times, you insist looking into
CL and clamour about its textual representation and internal object
differences.

The point here, is that a regular syntax can be parsed trivially by a
lexical scan and allow editors to reformat the code wihtout having a
parser proper builtin. Again, this is just one simple example of the
advantage. I have by now some 20 thousands words explanations and
examples. Are you ignoring them on purpose? perhaps because your
Common Lisp fanaticism, you simply don't see it?

I also explained in detail several times, that whatever your lisp
internal shit, the lang still just have one syntax. It is the one
programers types. It's great that common lisp has this and that
internal representation and shit and what's called textual
representation or print form, but still the lang has one syntax in the
context of lineaer, text based, computer languages, ok?

> (defun foo (a b) (baz a b))
>
> has to be a symbol and be there. It does not know that the third item
> has to be a list
> and be there. It does not know that after the arglist any number of
> Lisp forms
> is allowed.

It is not the editor's job to know.

The point about emacs's understanding of sexp, is to illustrate that
because lisp has a almost regular nested syntax, it allowed any editor
to parse and understand to great degree the lang's syntactic
structure.

The point is not about whether emacs contains a full lisp parser, or
whether emacs actually understands lisp semantics, or whether emacs
sucks and and true lisp editor blows.

> Just because of s-expressions, the editor will not know
> that DEFUN is the name of a macro, foo is the name of a function,
> (a b) is an arglist, a and b are parameters, (baz a b) is a function
> call
> and so on. All the editor would see is a list of things.
>
> (foobar barfoo (baz foo) (blah baz foo)) has the same semantic
> content as above. It is also a list of things. The editor
> will not tell you any difference just be understanding
> s-expressions. s-expressions also have nothing to do with
> semantics of code.

Moron Rainer, it's not about understanding the semantic of lisp.

lisp has a almost regular syntax. This syntax, has high degree of
correspondence to its semantics. So, any dumb editor can parse the
syntax by a lexical scan, and understand to some degree of the
semantic structure or its abstract syntax tree. This is in contrast
to, for example, langs with syntax soup as its syntax such as most von
neumann langs (e.g. C, C++, Java, perl, javascript, php...).

> > For example, in
> > emacs, you have forward-sexp, mark-sexp and a lot others that
> > manipulate lisp expressions. This can be done in lisp, precisely
> > because its syntax is based on a simple regular form. As a counter
> > example, this cannot be done in C, perl, java, javascript, python, etc
> > lang due to the fact that they don't use a regular simple syntax.
>
> > So, in your macro example, for example this one:
>
> > (defun test1 () (xah# '+ 1 #| HiXah! |# 2))
>
> > i cannot move my cursor to the “#|” part and call mark-sexp to select
> > it.
>
> That's the stupidity of Emacs. The editor I use has the command mark-
> form and
> happily marks the comment form (and all other forms in Lisp).
>
> Instead of demonstrating your non-knowledge in comp.lang.lisp for the
> past
> years, you could have learned some Lisp-dialect by now. Make a
> decision:
> either learn some Lisp dialect or stop posting here.

Rainer, after the numerous detailed exchange on this issue between us
and me and others, i don't know either you are truely a idiot, or your
lisp fanaticism really prevented you from seeing any validity in
negative criticisms, or that you are here just to fuck with me.

Xah
∑ http://xahlee.org/

☄

On Aug 21, 1:44 pm, Kenny <kentil...@gmail.com> wrote:
> Don Geddis wrote:
> > Kenny <kentil...@gmail.com> wrote on Thu, 21 Aug 2008:
>
> >>xah...@gmail.com wrote:
>
> >>>Don Geddis wrote:
>
> >>>>Not the power of a "language". The power of a language's _syntax_.
> >>>>Recall, _you_ are the one making the claim, that the irregularities
> >>>>"reduce [the] syntax's power".
>
> >>>In lisp, the comment is done by the char “;” running to end of line.
> >>>Note that this does not allow nested comment. So for example, if you
> >>>have multi-line code, and you want to comment out them all, you have
> >>>to prepend each line by a semicolon.
>
> >>I use a feature like #+nicetrybozo or #+chya for multi-liners.
> >>For print statements that are getting distracting but which may prove useful
> >>in the future I use #+shhhh
>
> > And also:
> > #|
> > ...<multiline code> ...
> > |#
> > is another easy way to quickly comment out multiple lines.
>
> Easy? Now I have to keychord to the end of the block, type in a separate
> delimiter, and when I want to restore take out two things.
>
> You must like typing.
>
>
>
> > So, Xah, Kenny and I have shown you two different ways, in standard Common
> > Lisp, to easily comment-out multi-line code.
>
> > On this narrow topic, can you admit that you were in error, and this isn't
> > a "fundamental problem of Lisp" after all?
>
> The Xah cannot be in error any more than Picasso can screw up by putting
> both eyes on one side of the face.
>
> kt


Kenny, is this Rainer Joswig and this Don Geddis truely idiots? or
they just fucking around?

Seriously, their IQs can't be at the idiot level. I do think they are
a bit of fucking around attitude, due to my returning insults.
However, i think overall they are still sincerely thinking they have a
point, even though i think they are beginning to see that my criticism
has valid points. I think what's really going on, is that their common
lisp fanaticism blinded their judgement.

As you know, in this month i tried a conversational styled posting
manner in gnu.emacs.help, and really tried to stick on topic, and
refrain from swearing at these idiotic tech geekers. My experiences is
that it actually worked. It actually taught, shown light, convinced
these tech geekers something in the few hundreds of posts among 3+
threads. However, in comp.lang.lisp esp in this thread, even though i
did chat style and reply to almost all posts addressed to me, but i
have not refrained from calling morons morons. I think that is the
cause that these morons are still being morons.

So, if i go all out in the effort to educate, i.e. refrain from
showing any attitude, be the most patient, i think i'll be able to
convince these morons. Should i? but i don't want to. I consider
myself a member of the lisp community, in particular in the faction of
emacs and emacs lisp. I don't see myself venturing into Common Lisp
anytime soon. I have a personal interest in seeing emacs prosper. I
don't have particular interest in seeing common lisp prosper. I mean,
sure i'd help whenever i can, or even learn CL tidbits, but not when
common lisp morons insist being obtuse and fuck with me. So, i don't
think i'll let common lisp morons run around here without a moron tag.
Yeah, Rainer and Don are morons. LOL. Rainer and Don, you are morons.
M, O, R, O, N, and i think i will be sticking around here to make sure
you wear the tag.

Also note, notice how other lispers, who probably see the validity of
my criticism by now, but they cower in their pants quietly and watch
the show. How funny. Chinese has a saying on this: 隔桥观虎斗, meaning,
watching the tigers fight over the other side of a river. What would
be a english saying for this situation?

This post is posted to:
comp.lang.lisp,comp.lang.scheme,comp.lang.function al

Xah
∑ http://xahlee.org/

☄

Rainer Joswig wrote:

> It's the same in Emacs Lisp. You don't even understand the basics.
>
> Look, this is ELISP:
>
> ELISP> (setq myprogram '(defun foo (a) (print a)))
> (defun foo
> (a)
> (print a))
>
> ELISP> (eval myprogram)
> foo
> ELISP> (listp myprogram)
> t
> ELISP> (foo 3)
> 3
> ELISP> (setq myprogram1 '(defun foo))
> (defun foo)
>
> ELISP> (listp myprogram1)
> t
> ELISP> (eval myprogram1)
> *** Eval error *** Wrong number of arguments: defun, 1
>
> Program source was a valid s-expression in both cases.
> Both were lists.

it's not about the lists. It's about syntax.

For example, let's say this non lang plain text:

[something [3 4] [yes [nah] oh] no but]

can you see, the regularity of this text? In in is a textual
representation of a tree.

And such textual representation, can be manipulated by a text editor
with a simple lexical scan, and do all sort of transformation on it,
yet the editor or tool needs not to know any meaning of it. You see?
XML is a good example.

But now let's say, instead of the regularity in
[something [3 4] [yes [nah] oh] no but]
you have
[something [3 4] yes[ [nah] oh] no] ; but

can you see that, it no longer has a simple tree structure?

For more detail, see:

★ “Fundamental Problems of Lisp”
http://xahlee.org/UnixResource_dir/w..._problems.html

★ “The Concepts and Confusions of Prefix, Infix, Postfix and Fully
Functional Notations”
http://xahlee.org/UnixResource_dir/writ/notations.html

> Xah, learn something useful to participate here, or just go and do
> something
> else. Paint keyboard bindings or such.

do you mean you liked my ergonomic based emacs shortcut set?

★ “A Ergonomic Keyboard Shortcut Layout For Emacs”
http://xahlee.org/emacs/ergonomic_emacs_keybinding.html

this messag is posted to: comp.lang.lisp, comp.lang.scheme,
comp.lang.functional .

Xah
∑ http://xahlee.org/

☄

xahlee@gmail.com wrote:
> So, if i go all out in the effort to educate, i.e. refrain from
> showing any attitude, be the most patient, i think i'll be able to
> convince these morons. Should i? but i don't want to.

Life is short. Move on. Many are called, few are chosen.

Exchanges of more than a certain length are probably futile and
certainly become less and less fun. We need one fo your formulas: fun
times chance of persuading times prospect of producing world peace over
frustration.

I consider
> myself a member of the lisp community, in particular in the faction of
> emacs and emacs lisp. I don't see myself venturing into Common Lisp
> anytime soon. I have a personal interest in seeing emacs prosper. I
> don't have particular interest in seeing common lisp prosper. I mean,
> sure i'd help whenever i can, or even learn CL tidbits, but not when
> common lisp morons insist being obtuse and fuck with me. So, i don't
> think i'll let common lisp morons run around here without a moron tag.
> Yeah, Rainer and Don are morons. LOL. Rainer and Don, you are morons.
> M, O, R, O, N, and i think i will be sticking around here to make sure
> you wear the tag.

We call this a non-disengaging disengagement.

>
> Also note, notice how other lispers, who probably see the validity of
> my criticism by now, but they cower in their pants quietly and watch
> the show. How funny. Chinese has a saying on this: 隔桥观虎斗, meaning,
> watching the tigers fight over the other side of a river.

Nice. Healthier or non-combatants than "when the elephants fight the
grass gets trampled".

> What would
> be a english saying for this situation?

"staying out of it".

kt

"xahlee@gmail.com" <xahlee@gmail.com> writes:

> On Aug 21, 1:44 pm, Kenny <kentil...@gmail.com> wrote:
>> Don Geddis wrote:
>> > Kenny <kentil...@gmail.com> wrote on Thu, 21 Aug 2008:
>>
>> >>xah...@gmail.com wrote:
>>
>> >>>Don Geddis wrote:
>>
>> >>>>Not the power of a "language". The power of a language's _syntax_.
>> >>>>Recall, _you_ are the one making the claim, that the irregularities
>> >>>>"reduce [the] syntax's power".
>>
>> >>>In lisp, the comment is done by the char “;” running to end of line.
>> >>>Note that this does not allow nested comment. So for example, if you
>> >>>have multi-line code, and you want to comment out them all, you have
>> >>>to prepend each line by a semicolon.
>>
>> >>I use a feature like #+nicetrybozo or #+chya for multi-liners.
>> >>For print statements that are getting distracting but which may prove useful
>> >>in the future I use #+shhhh
>>
>> > And also:
>> > #|
>> > ...<multiline code> ...
>> > |#
>> > is another easy way to quickly comment out multiple lines.
>>
>> Easy? Now I have to keychord to the end of the block, type in a separate
>> delimiter, and when I want to restore take out two things.
>>
>> You must like typing.
>>
>>
>>
>> > So, Xah, Kenny and I have shown you two different ways, in standard Common
>> > Lisp, to easily comment-out multi-line code.
>>
>> > On this narrow topic, can you admit that you were in error, and this isn't
>> > a "fundamental problem of Lisp" after all?
>>
>> The Xah cannot be in error any more than Picasso can screw up by putting
>> both eyes on one side of the face.
>>
>> kt
>
>
> Kenny, is this Rainer Joswig and this Don Geddis truely idiots? or
> they just fucking around?
>
> Seriously, their IQs can't be at the idiot level. I do think they are
> a bit of fucking around attitude, due to my returning insults.
> However, i think overall they are still sincerely thinking they have a
> point, even though i think they are beginning to see that my criticism
> has valid points. I think what's really going on, is that their common
> lisp fanaticism blinded their judgement.
>

Oh Xah, it has just been so entertaining!

However, this takes the biscuit. You see, the only two people who were
actually taking your claims at all seriously are Don and Rainer. Kenny
on the other hand is just stirring the pot and playing with you. I'm
surprised that a genius such as yourself hasn't realised this.

With respect to your claims regarding your writing being better than the
average english professor or journalist, I have to say your sadly
mistaken. Your expressive style actually confuses and detracts from your
arguements. You seem to believe your style is a new radical form of
expression and those that criticise it are just morons who don't
appreciate your great talent. Such an arguement may have merit in a work
of fiction in which you are trying to push the boundries. However, it
simply detracts from what your trying to express when your dealing with
issues of fact or arguements regarding issues of technology, sociology,
philosophy or belief. If you honestly want to address such issues, you
need to express them in a clear concise manner that presents your
arguments without the distractions of unfamiliar style. I persoanlly
always asumed your poor grammer was due to english not being your native
tongue. If this is not the case, then I'd just have to assume you were a
student who was above average at math, but below average in
english. This is not uncommon. Many students find the more precise
nature of maths easier to grasp than the less precise rules of english
grammer (noting that english is often cited as the most difficult
language to learn because of its inconsistent and complex grammatical
structure). If your aim is to communicate and educate, then yu need to
write in a style that makes your points clear. Your claim that you are a
genius with a new style of expression is just a poor excuse for not
having a good grasp of english grammer and an inability to honestly edit
yourself to assist the reader rather than stroke your own ego. Rather
than an intelligent and philosophical genius, you come across as an
extremely insecure, lonely and bitter individual who has trouble fitting
in and blames everyone else rather than considering that their own
actions and personallity may have some baring on the situation.

In this current thread, I believe I can understand your arguement and I
even think Don and Rainer have missed your point. However, this is
primarily because of how you have tried to express it. I can
appreciate what your saying about the irregularities intriduced by
the 5 characters you reference. I agree that new users may be a little
confused at first and I agree that to a limited extent, editors could
parse the code easier at some levels without them. However, these are
not fundamental limitations to the language and I disagree they have
fundamentally limited or restricted the development of the
language. Your criticism is in fact quite shallow and certainly doesn't
identify anything fundamental. To disprove this, you need to make a
distinction between using the language, in the sense of actually coding
with it and all the associated tools, editors and convenience and the
actual power of the language i.e. what you can do with it - the types of
problems you can solve and how difficult/easy this is with the
language.

The only possible merit in your arguement is that if all the language
had followed the nested syntax properly, we may have more consistent
formatting of code and maybe more sophisticated development
environments. However, it is also important to note that most of the
people I've seen comment on this who have actually used rigid structured
editors have ended up not liking them. I also feel that what you are
talking about is an abstract theoretical advantage which you imagine is
superior, but which has never existed with any general purpose language
(there are some special purpose domain specific languages that have done
this, but that is a different and more precisely defined environment and
therefore easier to do and less likely to be inconvenient).

While Don and Rainer may not have understood your arguement, you have
totally failed to appreciate what they have been saying. You
immediately take the position that anyone who doesn't automatically
agree with your arguement is just a tech geek moron who can't appreciate
your great genius. This arrogance on your part makes you blind to the
valid points they are making and makes you appear insecure and
defensive. Rather than viewing alternative positions and criticisms of
your arguuement as a personal attack, start by assuming they are genuine
and attempt to address them in a genuine manner.

As an example, you argue that due to the irregularities introduced by
the characters you refernce, lisp has lost the opportunity of having
powerful and automatic formatting. I imagine you dream of a development
environment in which you can just express the ideas and the environment
will take care of all the formatting and we will have a utopian world of
consistently formatted code which everyone can easily
udnerstand. However, as has already been pointed out to you, the nested
syntax is not sufficient for this. While s-expressions do provide a lot
of convenience and while they may be sufficient for formatting pure
data, they are not sufficient for good formatting of code. This is where
your comparison with XMl falls down. A clear example of this difference
was provided in an earlier post in this thread (which I note you failed
to respond to directly and instead attacked by stating the poster was a
moron. As they say, you should play the ball and not the player)

Your claim that these irregularities reduce the power of the language
and are a fundamental problem with the language are also misguided. As
pointed out many times in this thread, these irregularities are handled
by the reader and are gone by the time the code is evaluated. for this
reason, its not a fundamental limitation in the power of the
language. However, it could be argued that it does make it harder to get
consistent formatting by the editor or that it causes confusion for new
users and this may have impacted on the adoption of the language (though
I don't believe this has in fact had any real impact and that in fact
these irregularities actually make the language more convenient and
easier to use for the experienced programmer). It cold also be argued
that because of these so called irregularities, the user is required to
put effort into formatting the code (e.g. hitting tab, enter etc) that
could be handled automatically. However, having used systems that do
this type of thing, I find such 'convenience' inconvenient. More of a
problem is that I rarely think in completed well formed
s=expressions. My code is often 'broken' as I move from an incompleted
s-expression to modify an earlier piece of code because I've realised a
minor change earlier makes what I'm doing next easier. A structured
editor would make this more difficult and not easier. I can fully
appreciate that others may adopt a different style of progrmming and for
them, a structured editor may be more convenient. But this just
emphasises that we all come from different perspectives and what may
appear to be a valuable alternative to one may be irrelevent or of
little value to someone else. this is a point you seem unable to
appreciate and assume anyone who doesn't agree with your perspective is
a moron or fuckwit. Someone who is a genius or at least a little smart
should be able to realise this and acknowledge that different people
have different priorities and requirements.

Whatever your pespective, arguing that the irregularities impact on the
power of the language is simply incorrect. If it was true, it would be
easy to show a straight-forward example of something you can do with a
purely nested syntax language that you cannot do with the existing
language. Don and others have asked you to show such and example. You
have failed to do so. All you have done is repeatably reference your
existing 'essays' - if these had such proof, people wouldn't continue to
ask you to provide one.

I have noticed a theme in many of your posts and essays. On the whole,
they seem to be inspired by frustration and anger at what you find
difficult and beleive should be easier. On one hand, this is fair
enough. However, you often lable and describe the problem in a
misleading and aggressive manner that writes the whole thing off because
of one or two issues. You also tend to attack a specific existing language or
technology when the problem is really across the whole discipline. for
example, your arguement about lisps irregularities in syntax is less
compelling when you consider that lisp probably has the most consistent,
straight-forward syntax of any language. I suspect your real issue is
with inconsistency in syntax generally and not specific to the lisp
family of languages. If you had written a well thought out and
structured essay on why many programming languages ar difficult to use
because they lack a consistency of syntax, you would likely have found
many would have supported your ideas and commended you on writing such
thought provoking material. Remember, if your real goal is to educate
then you want people to both hear what you are saying and think about
it. Presenting yor arguements in poorly structured grammer with lots of
emotional over-loading just causes 'line noise' and makes you appear to
be nothing more than an emotional dumb ass venting over what they find
frustrating about whatever current thing they are working with.

Your arguements are often undermined by the obvious fact that many of
your posts and essays are written from the perspective of a new user
with little experience with or in the language. You have freely admitted
you don't know common lisp and you make lots of examples out of emacs
lisp, which is a specialised dialect of lisp with a specific goal and
not a general purpose lisp implementation. It is also very much an older
style lisp dialect and not a good basis for making any judgement on the
current state of lisp as a language family. to have any real credibility
in arguing about the lisp family, you need to show a higher than average
familiarity with the main language implementations in the lisp family,
including more than just a couple of hours 'playing' with each. You
indicate you don't have time for such things and thats fine. However, if
you don't hae the time to learn, then you don't have the credibility to be
listened to either.

While on the topic of credibility, don't refer to yourself as a
genius. Yor obviously not. A true genius dosen't consider themselves a
genius because their superior intellect lets them know how much they
don't know. The label of genius is given to someone by others who are
impressed by the work they do. I suspect your above average intelligence
in some areas and well below average in others - for example, I suspect
you have a very low emotional intelligence. You have an obvious desire
to gain knowledge and don't limit yourself to any specific field or
discipline, which is an admiral trait IMO. However, I would say that
you are more a jack of all trades and master of none than anything
else. This is fine too - there are too many who are experts in just one
limited area and completely ignorant in everything else. A thirst for
knowledge is a very admirable trait, but a belief that such a thirst
makes you in any way superior to everyone else is just proof that your
thirst has failed to really educate you or teach you anything and that
while you may have a broad scope of knowledge, it is shallow and
superficial.

Consider that whenever you argue you have a superior intelligence, you
are really saying you have a superior something which is poorly defined
and for which nobody has ever been able to find a means of measuring in
an objective manner. I have no issue in agreeing you have a superior
poorly defined something that cannot be measured.

tim

--
tcross (at) rapttech dot com dot au

Tim X wrote:
> "xahlee@gmail.com" <xahlee@gmail.com> writes:
>
>
>>On Aug 21, 1:44 pm, Kenny <kentil...@gmail.com> wrote:
>>
>>>Don Geddis wrote:
>>>
>>>>Kenny <kentil...@gmail.com> wrote on Thu, 21 Aug 2008:
>>>
>>>>>xah...@gmail.com wrote:
>>>
>>>>>>Don Geddis wrote:
>>>
>>>>>>>Not the power of a "language". The power of a language's _syntax_.
>>>>>>>Recall, _you_ are the one making the claim, that the irregularities
>>>>>>>"reduce [the] syntax's power".
>>>
>>>>>>In lisp, the comment is done by the char “;” running to end of line.
>>>>>>Note that this does not allow nested comment. So for example, if you
>>>>>>have multi-line code, and you want to comment out them all, you have
>>>>>>to prepend each line by a semicolon.
>>>
>>>>>I use a feature like #+nicetrybozo or #+chya for multi-liners.
>>>>>For print statements that are getting distracting but which may prove useful
>>>>>in the future I use #+shhhh
>>>
>>>>And also:
>>>> #|
>>>> ...<multiline code> ...
>>>> |#
>>>>is another easy way to quickly comment out multiple lines.
>>>
>>>Easy? Now I have to keychord to the end of the block, type in a separate
>>>delimiter, and when I want to restore take out two things.
>>>
>>>You must like typing.
>>>
>>>
>>>
>>>
>>>>So, Xah, Kenny and I have shown you two different ways, in standard Common
>>>>Lisp, to easily comment-out multi-line code.
>>>
>>>>On this narrow topic, can you admit that you were in error, and this isn't
>>>>a "fundamental problem of Lisp" after all?
>>>
>>>The Xah cannot be in error any more than Picasso can screw up by putting
>>>both eyes on one side of the face.
>>>
>>>kt
>>
>>
>>Kenny, is this Rainer Joswig and this Don Geddis truely idiots? or
>>they just fucking around?
>>
>>Seriously, their IQs can't be at the idiot level. I do think they are
>>a bit of fucking around attitude, due to my returning insults.
>>However, i think overall they are still sincerely thinking they have a
>>point, even though i think they are beginning to see that my criticism
>>has valid points. I think what's really going on, is that their common
>>lisp fanaticism blinded their judgement.
>>
>
>
> Oh Xah, it has just been so entertaining!
>
> However, this takes the biscuit. You see, the only two people who were
> actually taking your claims at all seriously are Don and Rainer. Kenny
> on the other hand is just stirring the pot and playing with you.


You must be honored. Only once a year am I so astonished by the
copiousness of someone's copiousness that I cut and paste it into
software capable of word count: the above error is followed by 2027
words? That is some biscuit.

As for the error, you mistake my persistent good humor in all directions
as directed at Xah, because you are so desperately insecure in your
conviction that your subconscious has dragged me onto your side. And
written 2027 more words.

I am neither pro-Xah nor anti-Xah. That is not why The Xah exists.

As for dictating my emotions for me.... the good news is that the hounds
will not be distrubed, the bad news is that I have /not/ had my shots.

hth, kt