If you had read the paper, you'd realize that with 'turn' (the proposed name for 2*pi), euler's identity gets prettier. e^(i*pi) is -1, but e^(i*turn) is +1. This is 'prettier'.
Technically this means euler's identity gets mangled to either: e^(i*turn) -1 = 0 or simply: e^(i* turn) = 1 + 0 but these manglings get to the heart of the non-perfectness of euler's identity: A 0 in a formula that involves addition / subtraction is kind of trivial anyway. Certainly this: e^(i* turn) = 1 is at least as amazing as the original euler's identity. Getting back on topic: Sure. From time to time an alternative way just looks better, but there's far too much inertia to try and change the world, and there's far too much benefit in an implicit standardization on the old, assumed to be somewhat worse, way. Thus, nothing changes. Also, while the case of 'turn' is quite solid, in many cases its not as clear cut and there are hidden benefits to the old way that might not become immediately obvious. In other words, the 'old' way has had years (for programming), even centuries (for math) of use, and thus the places where the old construct seems slightly more awkward than the proposed new one are very well known. This does not hold for the new construct - there'd be far less experience with where the new construct ends up being more awkward than the old. <poking the bear> case in point: at first glance scala looks really cool, but after working with it for a month you realize every compiler error requires a team of rocket scientists to figure out </poking the bear> This also goes to the heart of my theory about which programming languages end up in the 15%+ popularity zone (java, C, at one point fortran, etc): A language can't simply offer to be just plain better than an older one. It has to be better in a fundamental way, and this new fundamental way cannot be kludged in one of the current 15%+ popularity languages without such extreme pain nobody does it. This better way also has to be clear enough that non-users can actively tell that the grass is greener, so to speak. Hence, java, which really offered no particular language feature improvements _at all_ and even replicated some pretty crappy ones, still entered the zone, because garbage collection, one standardized library, and (the promise of) WORA were things that C fundamentally could not properly offer, and it all came in a very familiar package (very C like syntax) to boot. PHP entered the zone because at the time it offered a unique option that no other language did: A security model that had the property of allowing very cheap hosting with no setup required at all other than uploading some static PHP files. The fact that these files usually were a copy/pasted mix of spaghetti mess riddled with security holes didn't actually seem to impede PHP's meteoric rise much. I'd think few would argue PHP is a language that really did anything interesting on the language design front (in fact, it's the nickelback of programming languages!), and yet its one of the few post 1990 languages that entered the zone. Virtually every contender for 'next java' does not offer any single compelling argument to switch to it that's obvious even to casual/non-users. Taking scala as better than java as a given for a moment, then its rather clear to me that scala (or insert any other purported java.next here) is 'turn' to java's 'pi'. Of course we shouldn't just surrender and stop attempting to evolve programming altogether. Maybe I'm wrong :P -- You received this message because you are subscribed to the Google Groups "The Java Posse" group. To post to this group, send email to [email protected]. To unsubscribe from this group, send email to [email protected]. For more options, visit this group at http://groups.google.com/group/javaposse?hl=en.
