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 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"<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 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