🚀 go-pugleaf

In article <GATELEY.91Jun25134644@gefion.rice.edu>, gateley@rice.edu (John Gateley) writes:
> In article <583@smds.UUCP> sw@smds.UUCP,   I (Stephen E. Witham) write:
> 
>    ...Do you mean that syntax is unimportant, or do you
>    mean that changing the syntax of Scheme would be easy, or what?
> 
> I mean that syntax is relatively unimportant. My personal preference
> if for the prefix notation of scheme, but many people don't like it.
> What is important about a language though, is the ease with which you
> can express algorithms and ideas. This has very little to do with
> syntax, unless you choose a completely confusing syntax. Perhaps the
> scheme-syntax bashers are claiming that its syntax is completely
> confusing. If so, I have to disagree, it's very simple, easy to learn,
> and there are lots of tools available to help with those nasty little
> parenthesis. 

Scheme is a great language.  Lisp notation is simple to understand--for
my "left brain."  That means I can easily figure out (given a manual)
how to write a program, or figure out (given a manual) what a program
means.  But I think this thread is about "write-onliness," which to me
includes when I look at a program and my eyes (or "right brain") can't 
immediately grasp the structure of it.  I think visual "graspability" is 
also important to let a program serve as a visual pegboard that memories 
and ideas about the program stick to.

The problem with Lisp notation, for my "right brain", is that *every*
*structure*looks*the*same*.  It's all just forms with arguments.
With C, there are visual differences between function definitions,
variable declarations, variable assignments, control structures,
expressions, array references, structure field references, and function 
calls.  In Lisp or Scheme, in order to tell what type of thing something 
is, you have to look at the word at the beginning of the expression or 
special form it's in, know what types of arguments that form takes, and 
then count down through the arguments.

This issue is, for me, only about half of what makes a language readable,
clear, or simple, or not.  Scheme is very elegant otherwise.

(Lots of discussion of how do Scheme in C style.  John makes good
suggestions.  He doesn't get this question:)

>    and how do you put lambda expressions in
>    the middle of expressions.
> 
> Whats wrong with saying function (arg ...) { exp ... } a la C? Since
> Scheme is expression oriented, these guys can appear anywhere. Perhaps
> I missed something here?

Well, what I meant was, in C, function definitions are always on the
top level, and trying to stick them into the middle of expressions
would make a visual mess, sort of like the worst of C and Scheme
combined.  Of course, visual mess doesn't bother you. ;^] 

My main point was, anybody who can say "just syntax" is either ignoring
the issue of visual clarity, or they have parsers and reference
manuals built into their corneas.  Perceptual simplicity is hard to
produce, and Lisp takes a simplistic approach to simplicity.

In order to make a language visually simple, you have to have a good idea 
of the kinds of things people will do in it, and in order to do that, you
have to make assumptions.  Scheme (even more than older Lisps) goes the
other way and insists on generality in everything.  So maybe that makes
Scheme a good AI language--it makes it hard to do easy things, but easy
to do hard things. :-)

--Steve