Thread View: comp.lang.misc
2 messages
2 total messages
Started by Doug Philips
Thu, 27 Jun 1991 20:45
Re: scheme [Re: What does an anti-perl look like]
Author: Doug Philips
Date: Thu, 27 Jun 1991 20:45
Date: Thu, 27 Jun 1991 20:45
108 lines
5669 bytes
5669 bytes
In article <4601@optima.cs.arizona.edu>,
gudeman@cs.arizona.edu (David Gudeman) writes:
+No, WRONG. If it is uncomfortable for people, then it is by
+definition the wrong syntax to have them program in.
+Definition: A "wrong syntax" is any syntax that is uncomfortable for
+the people using it.
No, it is "uncomfortable syntax." (NOT (EQ 'Uncomfortable 'Wrong))
see also very last comment.
+It is possible that people could become comfortable with a syntax that
+they were once uncomfortable with. In this case it would cease being
+a "wrong syntax" for that individual. However, in order to make such
+an exercise worthwhile you first have to demonstrate that there would
+be some great advantage to the new syntax. There is no great
+advantage to lisp syntax.
Indeed. As someone else has already pointed out, Lisp syntax allows
programs/code to be data, and visa versa. Of course, if you come
from a background in Algol-like languages, you may not see how that
could be valuable. If you think that orthogonality between syntax
and semantics is useful, you would like lisp syntax.
+It is possible (but not certain, contrary to what some lispers would
+claim) that if everyone had grown up with lisp-like syntax in math
+classes that they would all be just as happy with it as they are with
+infix syntax. Who cares? The fact is that they didn't grow up with
+that sort of syntax, they aren't happy with it, and they shouldn't
+have to learn a completely different syntax just because a small
+influential community of programmers learned that syntax back in the
+days of dinosaurs and IBM 360's when parsing was poorly understood.
You have still failed to show whose these "they" are that are so
unhappy, and just how numerous "they" are.
The fact is part of what makes lisp powerful is its highly regular
syntax and that it permits the program/data division to be easily
crossed.
+It has become institutionalized by now. People who use that syntax on
+a regular basis usually had no trouble with it (or they wouldn't be
+using it now), and they assume that everyone is just like them, and
+should have not trouble with it either. And if anyone _does_ have
+trouble with it, then the person must be an uneducated, reactionary
+slob who uses phrases like "me'n'my'buddies donna like it".
Just as the people who use Algol-like languages have become
institutionalized and assume that everyone is just like them.
+Wake up. People are different. They have different tastes, different
+tolerance for change, and different backgrounds. And when you have
+something that a huge majority agree on (like infix notation) then you
+should exploit this miracle, not spurn it. And for heaven's sake,
+don't try to undermine it (which is just what the lisp community has
+been doing).
Wake up? Why? You haven't said anything new. You keep asserting the
same things over and over with no support.
All hail the long and venerated tradition.
+Does anyone have any non-anecdotal, non-fictional data to back up the
+claim that the syntax of lisp is _not_ a hindrance to learning it?
+(sheesh. If you live in a glass house, don't throw stones.)
You: X!
Me: Support it.
You: if not X, then X. Prove not X to me or I'll assume X.
Yawn. Can you distinguish between a challenge to support and a claim
for an opposite position?
+When the only evidence available is anecdotal, then that is what you
+have to use to form an opinion. My experience involves a
+non-scientific sample of perhaps 10 to 20 individuals who learned
+lisp and didn't like it. When asked why they didn't like it, the
+syntax is _always_ mentioned as a negative feature. The sample size
+is small, but the variance is impressively low.
When the sample size is small, the variance don't tell you squat.
You cannot prove your position by lack of opposition. Of course you
gave the game away when you admitted it was a matter of opinion.
+No, I've argued for making syntax comfortable for people in general,
+people who have grown up with modern mathematical notations and
+learned to program in C or Pascal or BASIC. Beginning programmers
+aren't the biggest problem, I expect that it is established
+programmers who have the most difficulty with radically different
+syntax.
I agree that beginning programmers aren't the biggest problem. They
haven't yet learned any preconceived notions about how programming
languages should be written. That admission undermines your position
about "modern mathematical notations", which is not the source of the
difficulty, and highlights that it is instead dogmatic adherence to the
syntax of an early learned language.
Since it is not confusing to beginners who have no preconceived
notions about programming languages, _and_ (tie in from first
comment...) since it is something that people can become accustomed
to, THEN the real point is that rightness/wrongness is nothing
*inherent* about the syntax itself, but is merely a matter of the
habitual experience of people.
-Doug
---
Preferred: dwp@willett.pgh.pa.us Ok: {pitt,sei,uunet}!willett!dwp
Re: scheme [Re: What does an anti-perl look like]
Author: Chris Dollin
Date: Fri, 28 Jun 1991 08:10
Date: Fri, 28 Jun 1991 08:10
42 lines
2604 bytes
2604 bytes
Doug Philips says:
Indeed. As someone else has already pointed out, Lisp syntax allows
programs/code to be data, and visa versa. Of course, if you come
from a background in Algol-like languages, you may not see how that
could be valuable. If you think that orthogonality between syntax
and semantics is useful, you would like lisp syntax.
Can we dispose of this myth for once and for all?
It's not ``Lisp syntax'' that allows code-as-data; it's because there's a
canonical representation for program texts as a supported datatype. In Lisp,
the supported datatype happens to be lists, and the mapping twixt source and
representation is at least translucent. But there's no reason an ``Algol-like''
language (whatever that means in 1991; are C, Ada, ML, Pop11, or Scheme
Algol-like? Answers on a postcard please ...) shouldn't provide a suitable
data-type and representation scheme.
For example ``here's one I prepared earlier'': in my Pop-like language Pepper,
I plan to include a construct such as ``<$ Expr $>'' to mean ``the parse tree
associated with Expr''. There will be operations on parse trees, such as gluing
them together and taking them apart, or generating code from them. (The present
compiler uses lists for parse trees - surprise! - but the post-bootstrap
compiler will have a more compact representation engineered to its needs.)
So it's not the (concrete) syntax of Lisp that gives code-as-data; it's the act
of making the parse tree *available*.
[Incidentally, rather than an anti-quoting syntax within the quote brackets, I
am thinking of making the quote take a left operand, viz, the names to be taken
as meta-variables inside the quotation, thus:
(x) <$ f(x) $>
would denote the parse tree for an application whose function-part is f and
whose argument part is the expression in the variable x. Any comments on this
idea?]
--
Regards, Chris ``GC's should take less than 0.1 second'' Dollin.
Thread Navigation
This is a paginated view of messages in the thread with full content displayed inline.
Messages are displayed in chronological order, with the original post highlighted in green.
Use pagination controls to navigate through all messages in large threads.
Back to All Threads