"Bruno Medeiros" <brunodomedeiros+spam@com.gmail> wrote in message news:ij1guf$694$1...@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"<newshou...@digitalmars.com> wrote in message > > news:iicfaa$23j7$1...@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).
