🚀 go-pugleaf

In message <601@smds.UUCP>, sw@smds.UUCP (Stephen E. Witham) writes:

+In article <2925.UUL1.3#5129@willett.pgh.pa.us>, dwp@willett.pgh.pa.us (Doug Philips) writes:
+> And just because it is a problem for the so called masses means merely
+> that is it DIFFERENT from what they are used to.  Not wrong.  DIFFERENT.

+To an intellectual populist like myself, something that is inaccessible
+to large numbers of people for insufficient reason is WRONG.

Then any computer programming language is WRONG.  Your definition is
useless.  The dictionary definition even more so.

+> Once you get into the groove its not that big of a deal.

+Once you've banged your head enough, you become numb.  But that doesn't
+mean the damage stops.  Lisp syntax just doesn't make good use of the
+way human brains and visual systems work.  Practice can compensate,
+but not totally.  It means you spend conscious energy to do what you
+can do unconsciously with other languages.

There is almost nothing you can do unconsciously without first having
been trained.  All you are saying is that there has been sufficient
training/experience with other languages for internalization to have
occurred.  That is nothing inherent in the language, it is due to an
external artifact of experience.

In article <602@smds.UUCP>, sw@smds.UUCP (Stephen E. Witham) writes:
+That's true.  Learning the rules of Lisp syntax is easy.  But there are
+two reasons why that doesn't make it easy to read:

+#1 is that you're talking about consciously learning
+the rules and consciously parsing things.  But Lisp syntax doesn't 
+transfer easily to the unconscious.

Another unsubstantiated claim.

+#2 is that what other languages do with syntax, lisp does with special 
+keywords, like defun, lambda, cond, let, prog, loopxxx... I don't know
+the exact words, but they all have special structural meanings and
+special treatments of certain arguments.  Learning all the special
+forms and their argument forms takes longer than just learning to
+balance parens.  And still your eyes can't learn it very well.

Another unsubstantiated claim.  Oh, and by the way, obsfucated code
can be written in any language.  The formatting (as opposed to syntax)
has much to do with how easily "your eyes" can see structure.  That
factor would have to be accounted for as well.

+I still think syntax is what puts off most of the people who are put off.

We are still stuck at unsupported assertions.

+This sounds like a REAL INTERESTING point.  Do you mean you use the
+editor to step between arguments and to find matching parens?  If so,
+you're FEELING your way, or maybe more like WALKING, around the code--
+in any case, something kinesthetic is going on...COOL!  But notice how
+it's like groping in the dark (in a well-labeled, tree-structured space, 
+(wasn't that a short story by Hemingway?) I grant you).  In other words, 
+Lisp syntax is no help to your EYES, but with emacs as a CANE...  This 
+probably has some great implications for user interfaces for blind people!

Non-sequitur.  VI (the editor I use, no comment on preference here) lets
you step over C blocks easily.  That I use '%' to move around in a file
has nothing to do with my eyes, but my interaction with the editor.
Do not confuse the format and layout of the code with its syntax, nor
confuse it with the way in which the editor does things.  And, _I_
do use printed lisp.

In article <603@smds.UUCP>, sw@smds.UUCP (Stephen E. Witham) writes:

+Lisp has two features: an internal form for programs, and a (over:-) simple
+syntax.  I think with an "infix Scheme," having a well-defined internal 
+form would give you most of the power.  You'd need a "code-constant" or
+"internal-form-of-this-quoted-code-fragment" construct, e.g.,

+x = quote {
+    function ( a, b ) {
+        return a+b;
+        }
+    };

+(That's not a lambda expression, it's a quoted lambda expression.)

Ok, so that looks like something a Algol-ic would "understand" "easily."
The real question is to show how a program would have written it.  What
can the program do with 'x' and how.  There are no "built-in" data structres
in a language like (say C, or pascal) for representing that.  You'd have
to add one in.  Now you aren't talking the same language.  I am curious
to follow this part up, but it really isn't part of this thread any more.

+If the compiler (or a library routine) can do the parsing,
+and there's a standard (not idiosyncratic) internal form,
+and a library routine can print programs,
+(or else, you don't go to ASCII, but stay in internal form),
+then the situation would be pretty much the same as with Lisp.
+Lisp has to be parsed and printed, too, if you're working with ASCII.  

Yes, but to me the real issue is how do programs manipulate data-which-
is-program?  In Lisp you use the same functions you would for any other
list.  You'd have to add language level support (for quoted lambda
constants and the "internal form" at least).  I suspect, but am willing
to investigate further, that doing so would alter the language in a 
non-trivial way.

-Doug
---
Preferred:  dwp@willett.pgh.pa.us	Ok:  {pitt,sei,uunet}!willett!dwp