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 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 good 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"). 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...)
On 09/02/2011 13:01, Nick Sabalausky wrote:
"Walter Bright"<[email protected]> wrote in message
news:[email protected]...
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 outside the web/html). Only Lisp has widely been
acknowledge as a failure, dunno about Haskell, maybe the jury is still
out on that.
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 hold. 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
for D... because they are not even statically typed languages (and 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 lots
of other things in the language 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...
--
Bruno Medeiros - Software Engineer
