Such "corner cases" include for example iteration or recursion which I'd say is a pretty common thing to do for computers nowadays. Generally you can write

f^0 = id
f^(n+1) = f(f^n)

which is consistent with sin^(-1) notation, and is especially common in areas of mathematics that are close to computer science.

The readability or usability by humans was never questioned. The only argument is about whether the notation can be used for writing computer programs. To keep compilers simple, they need to build a syntax tree first before they can apply semantics. The inconsistencies vastly complicate this. (What would you suggest? Markov chains to predict whether an upper index means composition of functions or composition of their output?)

No, the question was not about readability by humans, but instead suitability to be part of a computer program. I give to you that the class builder { : } or the \mapsto operator would possibly become unwieldy.

These are just functions with (commonly) three arguments. Not much different from if conditionals or for loops in a computer program.

What is wrong with abs()? Also |x| notation creates an extra difficulty for compilers because opening and closing delimiter are the same.

Write as predicates.

I don't see a particular problem with those?

The mathematical notation was invented for allowing mathematicians communicate efficiently with each other, and it does its job well. Nobody disputes that I think. Any attempt to make it more accessible to computers will of course affect human readability.

But could you code this convention into a compiler, e.g. by formally specifying precedence for trigonometric operators? It would have to account for the most common interpretations:

sin x*y = sin(x*y)
sin x * sin y = sin(x)*sin(y)
sin^2 x = sin(x)^2
sin^(-1) x = arcsin(x)

Now continue this for log, lim, summation notation, and all the other clever ways mathematicians have devised in order to avoid writing parentheses. It will quickly become clear that this is an arduous, error prone task and the time better be spent elsewhere by using proper notation from the beginning.

Yes, and the OP said that this language is ill-suited for writing computer programs and hence predicted that it will see declining use in the computer world.

I have seen authors write "sin a * sin b" and mean "sin(a)*sin(b)", not "sin(a*sin(b))". So there is some further inconsistency in the implicit precedence rules for the sin operator.

Because in other contexts, (f^2)(x) means f(f(x)). And there is sin^(-1) which is a popular way to denote the arcsine. So the superscript after a function can mean totally different things which the compiler will have to figure out from the context. Concerning x*y see my other reply further below.

The problem is not that it isn't properly defined, the problem is that it is not consistent.

The problem is that these symbols are no longer suitable for the modern world. They were fine at the time when they were conceived, but technology has moved on and requires something better.

The criticism was not that the symbols are undisplayable, it is that their use is not consistent and not possible as part of a computer program, aside from very special languages which specifically cater for Math. A few attempts have been made to reconcile these (for example RPN and stack-based languages like Forth) but have not seen widespread adoption so far.

With regards to the GP, I think that the inconsistency is especially bad. For example, whether N is meant to include 0 or not often depends on whether the author thinks that the natural numbers include 0 or not (which are two totally different things). Then many authors use trigonometric functions like operators to avoid writing parentheses, but without formally specifying the binding/precedence level. So when one reads "sin^2 x*y" does that mean "(sin(x)^2)y" or "sin(x*y)^2" or "sin(sin(x))*y" or "sin(sin(x*y))"? The list goes on.

I would rather claim the reverse. Tablet sales are displacing sales of "more capable machines" at an astonishing rate. A $45 tablet already fulfills the computing needs of a whole lot of people, why should they spend more on a PC? Those high-priced PCs will be relegated to the niche of users who require functions that a tablet or smartphone cannot provide.

The problem that Bouncer is trying to solve (telling whether an app is malicious or not) is otherwise known as program verification. Rice's theorem states that this is undecidable, not totally unlike the Y2K problem. It may even be highly undecidable, so even if Google had a hypercomputer at their disposal, Bouncer would still lose.

So if Google wants to keep malware out, Bouncer is fundamentally the wrong approach.

There are some indicators for a botnet behind the WP7 facebook app, which artificially inflates the numbers: http://www.investorvillage.com/mbthread.asp?mb=1911&tid=10271927&showall=1

Zones are somewhat lacking. They don't even support live migration. OpenVZ has been able to do this for years using network, pid, etc. namespaces, most of which have been merged into the Linux kernel now: http://lwn.net/Articles/256389/ . But Sun/Oracle are dragging their feet on this.

I agree that it should work in theory. However, Google turned up only posts that said it does not work. Another filesystem, reiser4, is only supported since LILO 21.6, so LILO appears not entirely filesystem-agnostic.

Booting Linux from btrfs has been possible since the release of syslinux 4.0 in mid-2010.

0.999... = 1 is a convention. Whether it is true depends on how you define the real numbers. In standard analysis you have 0.999... = 1, but in other (non-standard) forms of analysis you can assume without contradiction that there is some w with 0.999... = 1 - 1/w.

Actually this proof is false. In step 2, you assume that the difference between 0.999... and 1 is the same as between 10*0.999... and 10, thus making your proof circular.

Indeed the above proof is circular, because you assume in step 3 that the difference between 1 - 0.999... and 10 - 10*0.999... is the same. In some forms of non-standard analysis, you can assume without contradiction that there is some w (should be omega but slashdot does not allow this character) with 0.999... = 1 - 1/w.