- It's worth optimizing for more people than fewer.
- There are a thousand times as many future programmers than there are existing ones.
- One can measure how easy it is for a clean-room human to read and create software in different languages and build something for them.
If there's a good reason for the difference, by all means, go for it. But if there isn't, please reconsider.
So that leaves little room for alternative language paradigms then. If you want dictionaries to look like JS or Python then what are languages like Lisp and APL to do, not use coherent syntax. Or what about just making different use of the limited number of symbols on the keyboard to make the use more consistent?
Id rather have a more consistent language or one that introduced new concepts than one familiar in syntax just for the sake of being familiar.
Yes, but what about the benefits from the regularity and uniformity?
It's reminiscent of this: https://xkcd.com/927/
Edit: further to your point, I agree that my gripes are merely about an up-front cost, whereas consistency can be helpful throughout your use of a language.
Edit again: I essentially seek consistency within and among languages. I don't mean to state one should come at the cost of the other at all times.
If you're a programmer now, you're a secondary audience to the masses of people who will program in the future. If the language is going to have the most impact, what they prefer supersedes what you (and I) prefer.
> If there's a good reason for the difference, by all means, go for it.
Of course and agreed. Nothing should exist without reason. Antoine de Saint Exupery etc.
I think it is oversold, but the book "Design of Everyday Things"[1] goes over this for many common items. There is a long section on doors with many interesting points to consider.
[1] https://www.amazon.com/Design-Everyday-Things-Revised-Expand...
You're thinking of syntax as chrome. It is more than that.
I was speculating that this belief is from folks that think design is just chrome.
Many times I've discovered that altering the syntax for something (not its semantics) can completely transform its use.
old:
function double(double a, double b) { return a + b; }
(a, b) { return a + b; }
https://github.com/dlang/DIPs/blob/98052839441fdb8c6cc05afcc...
D has a different syntax for templates than C++, and is far more approachable and convenient:
C++:
template<class T> void foo(T t) { }
template<class T> class S { };
void foo(T)(T t) { }
class S(T) { }