Gustavo Franco: Brazilian plane carrying 174 crashes in Sao Paulo
It's really confusing and we don't know all the details on what happened yet. What I know is that I went to Belo Horizonte from Rio and back yesterday (in a difficult flight with really bad weather) on one of the tam's airbus. I feel very bad about all that sad news. :/
The flight cited on the title was from Porto Alegre - where the International Free Software Forum takes place to Sao Paulo - the biggest city in the country.
In a totally unrelated event, one of the two airports in Rio de Janeiro (the smaller) is closed due to a fire incident, with no victims AFAIK. We've the international airport here (Rio) where it seems that the flights are being rerouted.
More information at: http://www.reuters.com/article/newsOne/idUSN1726359820070717
The flight cited on the title was from Porto Alegre - where the International Free Software Forum takes place to Sao Paulo - the biggest city in the country.
In a totally unrelated event, one of the two airports in Rio de Janeiro (the smaller) is closed due to a fire incident, with no victims AFAIK. We've the international airport here (Rio) where it seems that the flights are being rerouted.
More information at: http://www.reuters.com/article/newsOne/idUSN1726359820070717
So let me have a quick go. [UPDATE: Didn t turn out to be quick at all. This is, in fact, as long as Antti-Juhani s original post. Proceed at your own peril.]
All of this comes from denotational semantics, which is concerned with what expressions in a programming language mean and which ones mean the same thing. For example, 7 denotes the number seven, 7+2 denotes the number nine, and 5+4 also denotes the number nine.
Now, here s the knotty problem. If we have
f(x) = if x = 0 then 1 else x*f(x-1)
then f(4) denotes the number twenty-four, but what does f(-2) denote?
So, denotational semantics introduces a new, special value, recurses forever. An expression of type integer either denotes an integer, or, like f(-2), it denotes recurses forever.
Now, about these partial orders. (Reminder: A partial order says, for every pair (x,y) of elements of a certain set, that x is smaller than y, equal to y, larger than y, or incomparable to y.) Here is Benja s guide to what the partial orders of denotational semantics mean:
Let s say that you write a program where, in one place, you can plug in either x or y. If you can write such a program that prints foo when you plug in x and prints bar when plug in y, then x and y are incomparable. If you can t do that, but you can write a program that prints foo when you plug in y, and recurses forever when you plug in x, then x is smaller than y. If every program you can write will do the same thing whether you plug in x or y, then x and y are equal.
(We ignore details like out-of-memory errors and *how long* a program takes to do something.)
Examples:
- 5 and 7 are incomparable. Proof: if ___ == 5 then print foo else print bar .
- f(-2) f(2). Proof: if ___ == 2 then print foo else print foo if you plug in f(-2), this will loop forever, if you plug in f(2), it ll print foo .
- (5+2) = 7. Whatever program I write, it will do the same thing, no matter which of these expressions I plug in.
Now, with expressions of type integer, the resulting partial order is: Recurses forever is smaller than everything else. All other values are incomparable.
Recall from Antti-Juhani s post that the bottom element ( ) is defined to be the smallest element of a mathematical universe (if such a beast exists). Since recurses forever is smaller than everything else, it s the bottom element of this universe. That s what denotational semantics calls it. (Haskell, too.)
Of course, this partial order is kind of boring (the technical term is flat ). It gets more interesting when we consider functions.
In general, we can talk about functions from values of type S to values of type T, where we already know the partial orders of S and T. In particular, we can talk about functions from integers to integers.
Now, if you can find an x and a program that prints foo when you plug in f(x) and bar if you plug in g(x), then you can write a program that prints foo when you plug in f, and bar when you plug in g. (Exercise! 
) Further, denotational semantics wants applying a function to a parameter and then doing something with the result to be the *only* way you can get information about a function. No f.get_function_name, please. (If your programming language has that, you can t map the functions of your programming language 1:1 to the functions of denotational semantics.)
By my rule above, this implies that f = g if and only if f(x) = g(x) for all x. Since formal theories can t have fuzzy stuff like my rule, denotational semantics takes this as the *definition* of the partial order on functions.
The bottom element of this mathematical universe, then, is the function that always returns bottom, no matter what it is given or in other words, a function that recurses forever, no matter what parameter you pass to it.
(Side note. Denotational semantics allows only monotone functions that is, if x = y, then f(x) = f(y) for all f, x, and y. That s an example of how all these definitions allow us to make formal statements about the real world. In the real world, if you can find a function f and a program that prints foo when given f(x) and bar when given f(y), then you have a program that prints foo when given x and bar when given y so if f(x) and f(y) are incomparable, then x and y must be incomparable, and the other way around, if x and y are comparable, then f(x) and f(y) must be comparable, too. (This reasoning doesn t exclude the case that x = y and f(x) >= f(y). If you really care, prove it yourself.