D vs Go on reddit

[Nick Sabalausky]

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

IMO, some examples of what happens when "simple/orthogonal" is given too 
much importance are Java2, JS, LISP and Haskell.

LISP: We seem to agree how having too much "simple/orthogonal" messed up 
LISP. LISP *is* emmensely popular in certain circles. But I believe that 
certain consquences of its over-emphasis on simple/orthogonal (ex: "Lost In 
Stupid Parenthesis") is a major part of what prevented it from ever finding 
its way outside its niche circles.

Haskell: Haskell has had *huge* buzz for awhile. Especially about 5 or so 
years ago, IIRC. And like a lot of people, I gave it a try. And like most 
people who did, I found its design to have such a strong emphasis on 
simple/orthogonal that it was too impractical to be worth the functional 
benefits it offered. Fast-forward to now, and there's *still* practically no 
one actually using it for real-world software development. Just some 
theoretical/academic stuff and that's about it.

JS: Widely-used != Good. I admit I'm also impressed by how much 
expressiveness it gets out of such few and simple rules (its handling of 
semicolons notwithstanding). But I find that to be largely academic. 
Granted, most of JS's biggest problems aren't direct consequences of its 
focus on simple/orthogonal, but there are things it could improve by 
shedding some of that focus. And more than that, it is a good example of the 
fact that "simple/orthogonal" doesn't necessarily imply "good".

Java circa-v1.2: I agree that fewer capabilites does not necessarily imply 
more orthogonality, and that LISP/JS are possibly more simple/orthogonal 
than Java's ever been. But I don't see how C++ can be considered anywhere 
near as simple/orthogonal as old-school Java. C++ is a giant cancerous web 
of rules, features and special cases. In old-school Java, you have GCed 
classes with member vars and member funcs...and that's about it.  No sugar 
at all: No 'foreach' because 'for' already handles that. No type inference 
because manually-tracked types can be used instead. It already had classes, 
so delegates had to be made out of them (ie, "functors" - and see that 
infamously idiotic paper Sun wrote defending this decision). It already had 
upcasting/downcasting, so generic code had to be constructed via those. 
Separate code-generating tools could be written (for instance, through the 
editor), so metaprogramming had to be done via that. Objects could have 
member functions, so it didn't bother allowing operator overloading - you 
could just use a named function instead. Etc...

All those features were missing because you could get the same effect with 
what few Java it did provide you - Ie, those extra features would have 
*decreased* orthogonality. It was immensely popular, but fitting everything 
into those few multi-purposed building blocks like that (ie, fairly 
simple/orthogonal components) also made it an immense PITA. Maybe not as 
much of a pain as C++ for certain things, but that's really more due to C++ 
being a giant anachronistic puss-filled wad rather than due to Java being 
more simple/orthogonal.

Regarding Java 1.3/1.4: They may very well have been closer to 1.2 than they 
were to 1.5/1.6 (I wouldn't know), but IIRC 1.3 was when it finally started 
to give people little bits of suger (ex: foreach).