Path: utzoo!utgpu!news-server.csri.toronto.edu!rpi!zaphod.mps.ohio-state.edu!unix.cis.pitt.edu!pitt!willett!dwp From: dwp@willett.pgh.pa.us (Doug Philips) Newsgroups: comp.lang.misc Subject: Re: scheme [Re: What does an anti-perl look like] Message-ID: <2935.UUL1.3#5129@willett.pgh.pa.us> Date: 28 Jun 91 15:15:07 GMT Organization: (n.) to be organized. But that's not important right now. Lines: 107 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