D vs Go on reddit

[Bruno Medeiros]

On 11/02/2011 03:08, Nick Sabalausky wrote:
> "Bruno Medeiros"<brunodomedeiros+spam at com.gmail>  wrote in message
> news:ij1guf$694$1 at digitalmars.com...
>> 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...
>>
>
> You seem to misunderstand. I never said that orthogonality or simplicity was
> bad. I just said that it was stupid to equate "more simple/orthogonal" with
> "better" and "less simple/orthogonal" with "worse". Ie, I was saying exactly
> the same thing about "orthoginality" as what you're saying. I beleive that
> as a consequence, it's dumb to make "simple/orthogonal" one of the primary
> design goals.
>

We must not be saying (or thinking) the same thing then, because I do 
think it is worthwhile to have orthogonality as one of the primary 
design goals.
I believe we are still not thinking of orthogonality in the same way. 
You seem to be thinking in terms of pure simplicity, how easy a language 
is to describe, learn and understand. I'm thinking of how much 
expressiveness you get per amount of "complexity" (how easy it is to 
describe, learn, and understand).


So considering C++ and Java again: then yes, C++ is much more complex 
than Java (even new-school Java, barring generics perhaps). But I never 
said otherwise. I did say that Java is not more orthogonal than C++, but 
not in the sense that Java is just as orthogonal as C++. Rather I was 
trying to say that the comparison doesn't make much sense in the first 
place, because Java has much less "capabilities". Like, you can compare 
D's meta-programming capabilites with C++, because in D you can do 
pretty much the same things as C++ (if not more) meta-programming-wise, 
yet the way things work in D are much more orthogonal, more simpler to 
describe and understand (and probably because of that, more powerful). 
The same comparison could be done with other features, like operator 
overloading between D and C++. But not between C++ and Java because 
doesn't support most of this functionality (and it doesn't make sense to 
compare with the Java alternatives)

-- 
Bruno Medeiros - Software Engineer