Isaac Clerencia: Foocast, podcast for (Spanish speaking) dudes
Several of my workmates and I are regular listeners of technology-related podcasts like Diggnation, TWiT or FLOSS Weekly (which BTW is as “weekly” as the Halley comet).
Some days ago we realized that there weren’t similar podcasts in Spanish (or at least we didn’t know about them), so we thought that creating one would be cool.
During this week we recorded our pilot, we had some problems with sound and I spoke a bit too fast, but I think it’s nice overall, at least I would enjoy listening to it 
Trying to emulate people like Kevin Rose or Leo Laporte (in the media business since 1991), who create podcasts professionally, is quite hard for amateurs like us, but we’ll do our best.
Be sure to check it at Foocast (sorry, Spanish only, that’s the whole point 
)
Trying to emulate people like Kevin Rose or Leo Laporte (in the media business since 1991), who create podcasts professionally, is quite hard for amateurs like us, but we’ll do our best.
Be sure to check it at Foocast (sorry, Spanish only, that’s the whole point )
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.