> True, but a major reason why we couldn't find a convincing design was
> the macro system or, rather, the lowest common denominator.
>
> When we have made our decision about the macro system of R7RS (large),
> which extends the syntax-rules of R7RS (small), we should give SRFI
> 177 another try.
>
> I know that John had reasons to do it the other way round, but I still
> think that fixing the unportable stuff (reader syntax, macro system,
> extensions to the library system) first (i.e. in the red edition)
> would have made a lot more sense.

Having something more powerful than syntax-rules in R7RS-large would be
nice, agreed.

> Luckily, there are alternatives besides fine dining and McDonald's! :)

:D Here too the lambda family hits a sweet spot. Recursion, closures and
macros do require "attention to the irrelevant" (an apt description of
low-level programming) but once mastered, the payoff is immense.

That's why I'm suspicious of languages like Haskell, Rust and even
Common Lisp it's not clear that the advanced features pay for themselves
when applied to real programs. Recursion pays for itself a million times
over.

>> If only there was a way to convince languages to use the same names for
>> the same things. Perhaps it could be done with shims if there's enough
>
> I think it is dangerous. Language semantics differ (good so because
> otherwise there's no reason for another language!) and making people
> believe things are the same because they look the same is not a good
> thing.

Names always lie. Scheme `cons`, Racket `cons` and Haskell `cons` are
different but there's not much point to changing the name. Same with
high-level stuff: the difference between `read-jpeg-file` in one
language and `loadJPEGImage` in another language is not useful to point
out in the name.

It worries me a lot that the point of programming is to write
applications, and language designers are too wedded to making intricate
faberge egg like things because they can. Python has the right idea in
making things simple and accessible. Unfortunately they made them so
accessible that they threw out effective lambdas and don't have the
elegant consistency of Scheme.