Lambda the Ultimate

I always hear people talking about "growing a language."
What about "shrinking a language" ?

That's what the people in the Waba world did. [ Ewe for iPAQ , In Recent Discussion ]

There are enough parsers for java that you could devolve (de-evolute....anyway the opposite of evolution into annoying special cases) Java with, like Antlr.

Then you could use good ole macros to evolve it the R5RS way! All the time using the extensive tools available for Java.

A good language is a language where removing any single language feature would render the language useless

I disagree with this statement. While a minimalistic syntax that still provides all the required feature sounds appealing, I prefer to have choices. Even at the expense of a bit more complexity. In other words, I prefer to have more than one way to say the same thing. As with spoken languages, such richness allows you to express yourself in a way that is the most appropriate to the case at hand. Also, having a minimalistic syntax may result in excessive verbosity.

Secondly languages that take regularity to extremes (Scheme comes to mind here) tend to be harder to learn because everything looks the same. I prefer different things to look different. Because these differences make it easier to remember. That's not the same as saying that there ought to be many different ways to do the same thing. It should be possible for different things (function calls, member access, assignment, etc) to look different and still have only one way to do them.

I tend to be suspicious of attempts to make programming languages like spoken languages. After all languages like English are notoriously awkward ways to communicate precisely because they encourage ambiguity by allowing the same thing to be said in multiple ways. Consider words like Loughborough and ghoti or examine a legal document which has to go contort the language to be able to achieve any precision.

Languages exist to help us communicate. Ideally as precisely/clearly as possible. That is the most important thing. If the set of primitives for expressing some idea becomes too rich then the language becomes a less effective way of communicating.

As a general rule I agree that making different things look different can help readability etc.

However, notice that there is a strong case for hiding the difference between calling a member function and field (slot) access. This is the setters/getters debate, and comes from thinking about data abstraction.

But the design of Scheme also recognizes that people want different things to look different. And so different combinations can be given their own syntax to make them easier to use and easier to read.

Look at the SRFIs and see that a number of them have to do with syntax! These are language extensions ("different things looking different") that are not needed at the core of the language. You can bring these into your programming environment *if* you want to.

If you have other ideas, or as other ideas are developed in other languages, they too can be brought in as desired. Not as the core of the language that can only be implemented in The Compiler. But as new syntax based on the core elements that have been proven useful over time. (Almost 70 years and counting.)