You guys are way on the wrong track here.
I'm very much a fan of simple and orthogonal languages. But this statement
has a big problem: it's not clear what one actually considers to be
"simple" and "orthogonal". What people consider to be orthogonal can vary
not only a little, but actually a lot. Sometimes it can actually vary so
much as to be on opposite sides. I remember seeing that first hand here on
D: two people were arguing for opposing things in D (I don't remember the
particular issue, but one was probably a greater language change, the
other as for the status quo, or a minor change from the status quo), and
both explicitly argued that their alternative was more orthogonal! I
remember thinking that one was stretching the notion of orthogonality a
bit further than the other, but I didn't find any of them to actually be
incorrect.
So people, please don't dismiss out of hand the principle that
orthogonality is a very worthwhile design goal. Rather, this principle
needs to be understood and applied in a more concrete and objective
manner. It cannot be described in a simplistic one-liner ("more
orthogonality is good." kthxbye!).
For starters, it only makes sense to evaluate the orthogonality of a
language alongside the expressive power of the language. Otherwise the
family of languages used in Turing machines (P'', and even brainfuck)
would be the unmatched best languages in terms of orthogonality. (the
whole language can be described in a few paragraphs... so simple!)
On 09/02/2011 13:01, Nick Sabalausky wrote:
"Walter Bright"<newshou...@digitalmars.com> wrote in message
news:iicfaa$23j7$1...@digitalmars.com...
http://www.reddit.com/r/programming/comments/fdqdn/google_go_just_got_major_win32_treats_now/c1f62a0
You'd think that things like JS, Haskell, LISP and Java circa v1.2 would
have taught people that extreme simplicity/orthogonality is a stupid
way to
design a language that's intended to be used in the real world. But
people
keep flocking to that silver bullet anyway.
Eh?? What exactly has "JS, Haskell, LISP and Java" taught us in terms of
"designing a language that's intended to be used in the real world"? You
seem to be implying these language did something massively wrong...
However Java became very popular and widespread (and the version of the
language when such happened, 1.3-1.4, was very similar to Java v1.2).
JavaScript is also quite popular and widespread, for a scripting language
at least (and not only in web/HTML). Only Lisp has widely been acknowledge
as a failure. Dunno about Haskell, maybe the jury is still out on that
one.
But in any case your argument is already starting off in a bad way (in at
least a 50% fuzzy manner).
Even if we were to imagine that all those 4 languages had been a failure,
or become obsolete, your argument still wouldn't be much useful. Because:
Java - Yes, Java is simpler than it's predecessor (C/C++), but not in
orthogonality. Java has less capabilities/functionality (like manipulating
pointers, or creating structs), it is not more orthogonal.
LISP - LISP syntax is very orthogonal, but it pushes it the extreme,
hurting readability. Also can one also say that LISP *semantics* are also
very orthogonal? Even with the macro system, I doubt that is entirely the
case for the generality of the language, although the true answer for this
would depend on the particular dialect of LISP (my experience has been
with Common Lisp and Scheme).
Don't know enough about Haskell. (And probably neither do you. Or anyone
else for that matter, except /that/ handful of people in the whole world?
:P )
As for JavaScript, well, this one I do agree, it is incredibly orthogonal,
one of the very few languages I would say that, and quite beautiful in
that way.
But regardless of all this, Lisp and JavaScript are not comparable to D
with regards to trying to evaluate how much orthogonality is good or
bad... because they are not even statically typed languages (also in the
case of JavaScript there is no metaprogramming). Because of this, it will
be much, much, more easy for them to orthogonal. Yet, if they fail, can we
say it was the fault of being orthogonal? It could have been plenty of
other things in the language design. (or even something entirely outside
the design)
In my view of the /worthiness of orthogonality/, it only is useful to
compare the simplicity of languages when the capabilities, functionality,
and expressive power of such languages are more or less comparable...
