D vs Go on reddit

[Bruno Medeiros]

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"<newshound2 at digitalmars.com>  wrote in message
 > news:iicfaa$23j7$1 at 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...

-- 
Bruno Medeiros - Software Engineer