Planet PLUG

Elizabeth Bevilacqua Debian Installation Over SSH (Lenny RC1)

2008-11-16T21:37:47+00:00

The Debian Installer lenny release candidate 1 was released on November 12th, which inspired me to check it out and give the installation over ssh a try. Installation over ssh has been supported since the Etch installer, but I embarrassingly have to admit that I didn’t know about it until just recently, and it was just last month that I tried it out for the first time. So this post is more of a “Look, this thing exists and is neat and easy!” than a formal how-to for something tricky.

The screenshots and CD I burned were from Lenny (Testing) which I downloaded here this morning, but this is also supported in Debian Etch in a similar way.

Boot from the CD and in the Installer boot menu select “Advanced options >”

Then select “Expert install”

The installer will load up and you will be presented with the Debian installer main menu.

Since the default language and keyboard are fine to get me going (I can reconfigure them later once I get this going over ssh), I skipped these and went straight for “Detect and mount CD-ROM”. When it asked me if I wanted to Start PC card services I selected “No” since I’m not using any PCMCIA cards.

The next option on the menu is “Load installer components from CD”, which you want to select. Browse the list, but for my basic needs the only thing I needed to load up was “network-console: Continue installation remotely using SSH”

Now you’ll need to get networking going. Select “Detect network hardware” and then “Configure the network”.

Next you want to “Continue installation remotely using SSH”

This will generate SSH host keys and have you set a remote installation password. Once it has these set up you will be presented with a screen giving you an installer@ipaddress location for the install and an SSH fingerprint. Use these to ssh into the installer!

Finally - log in from your remote PC and complete the installation.

I went back and configured keyboard to confirm it was correct and languages so I could add a couple of locales, so don’t forget to do this if you need to change something about your configuration.

JonathanD New Job

2008-11-15T14:03:34+00:00

Well, it seems I've finally found a new job. I'll be starting next week, and it should be an awesome opportunity. More updates to follow!

JonathanD Who Am I?

2008-11-13T18:10:28+00:00

Welcome to my site. Yes, it's a goofy name, but I'm a bit of a goofy person. So let me summarize who I am and what I do briefly.
I am:
* A single father of two amazing boys.
* The family Geek (I love those calls asking how to forward an email.)
* A systems/storage engineer with over 5 years of IT experience.
* That guy who can't go anywhere without his laptop (Really, though, I just superglued it to my arm!)
* A freenode staffer. (Since I am a useless coder this makes me feel a bit better about using stuff other people made for free.)

mjd Flag variables in Bourne shell programs

2008-11-12T17:37:00+00:00

Who the heck still programs in Bourne shell? Old farts like me, occasionally. Of course, almost every time I do I ask myself why I didn't write it in Perl. Well, maybe this will be of some value to some fart even older than me..

Suppose you want to set a flag variable, and then later you want to test it. You probably do something like this:

        if some condition; then
            IS_NAKED=1
        fi

        ...

        if [ "$IS_NAKED" == "1" ]; then
          flag is set
        else
          flag is not set
        fi

Or maybe you use ${IS_NAKED:-0} or some such instead of "$IN_NAKED". Whatever.

Today I invented a different technique. Try this on instead:

        IS_NAKED=false
        if some condition; then
            IS_NAKED=true
        fi

        ...

        if $IS_NAKED; then
          flag is set
        else
          flag is not set
        fi

The arguments both for and against it seem to be obvious, so I won't make them.

I have never seen this done before, but, as I concluded and R.J.B. Signes independently agreed, it is obvious once you see it.

mikegrb Ruby’s not Ready

2008-11-12T03:28:20+00:00

Was looking for a specific essay about some of the issues with Ruby to point my boss to and stumbled across this instead, still haven’t quite finished reading it yet but good stuff. Increases my desire to further my Python skillz.

Ruby’s not Ready at glyphobet

mjd Another note about Gabriel's Horn

2008-11-11T05:53:00+00:00

I forgot to mention in the original article that I think referring to Gabriel's Horn as "paradoxical" is straining at a gnat and swallowing a camel.

Presumably people think it's paradoxical that the thing should have a finite volume but an infinite surface area. But since the horn is infinite in extent, the infinite surface area should be no surprise.

The surprise, if there is one, should be that an infinite object might contain a merely finite volume. But we swallowed that gnat a long time ago, when we noticed that the infinitely wide series of bars below covers only a finite area when they are stacked up as on the right.

The pedigree for that paradox goes at least back to Zeno, so perhaps Gabriel's Horn merely shows that there is still some life in it, even after 2,400 years.

yonkeltron Org-Mode has changed my life!

2008-11-11T03:16:29+00:00

As I move more and more of my life into Emacs, the best editor ever to grace God’s silicon earth, I discover new jewels of computing elegance and productivity. One of the most recent additions to my arsenal is org-mode, the most fantastic tool for keeping my life in order. Initially, I was excited because it supports todo lists very well. After that, I realized what a powerful tool it is for outlines, managing dates and even publishing. I began by reading the LJ article by Abhijeet Chavan and continued on to watch the Google Tech Talk by Carsten Dominik.

Right now, I’m doing most of my planning, outlining and writing in org-mode. Since org-mode enables you to have an agenda view which gathers your todo items from multiple files, I can keep tasks associated with their relevant contexts. So, when planning a blog post, I have the research todo items in with my other notes and might keep them tagged as such.

One of the coolest things about org-mode is that org files are just plain text. All of the fun stuff is added when Emacs uses org-mode to edit the org files themselves. Thus, org-mode files are exceedingly portable and can be read and edited anywhere. However, org-mode has several fantastic exporter engines which allow you to convert org files to a multitude of formats. My personal favorite is org-export-as-html which will convert the file to an HTML document, preserving hierarchy, numbering, bulleting, links and loads more. So, I’m writing all of my important stuff using org-mode and then just exporting it to HTML to be printed and shared. It makes all of my handouts for meetings and workshops look really sweet and the pages include some JavaScript to make web-viewing easier as well.

Additionally, I’m really enjoying using features like the table editor which automagically builds plain-text tables (that’s right kids, ASCII-only tables!) and takes care of nastiness like resizing, etc. Although I don’t have a real use for it yet, tables can have formulas which allow them to be used like lightweight spreadsheets and such.

Other neat features include (but are not limited to):

Hyperlinks
Property drawers (key-value data)
Dates and times, with one of the best date-input methods in all of Emacs
Selective display of document hierarchy using the tab key as a catch-all trigger for cycling through visibility options.

Really, it does lots more so for more info, look over The Org Manual, check out the website or view the Worg, a sort of distributed wiki-like project using git to sync org files.

Org-mode made it into Emacs22 and is included by default thereafter. However, the version that came with the emacs22 package on Debian Lenny wasn’t exactly up-to-date so I installed the org-mode package and it all worked fine.

mjd Gabriel's Horn is not so puzzling

2008-11-10T21:12:00+00:00

Take the curve y = 1/x for x ≥ 1. Revolve it around the x-axis, generating a trumpet-shaped surface, "Gabriel's Horn".

Elementary calculations, with calculus, allow one to show that although the Horn has finite volume, it has an infinite surface area. This is considered paradoxical, because it says that although an infinite amount of paint is required to cover the interior surface of the horn, the entire interior can be filled up with a finite amount of paint.

The calculations themselves do not lend much insight into what is going on here. But I recently read a crystal-clear explanation that I think should be more widely known.

Take out some Play-Doh and roll out a snake. The surface area of the snake (neglecting the two ends, which are small) is the product of the length and the circumference; the circumference is proportional to the diameter. The volume is the product of the length and the cross-sectional area, which is proportional to the square of the diameter.

Order
Elementary Calculus: An Infinitesimal Approach

with kickback
no kickback

Now roll the snake with your hands so that it becomes half as thick as it was before. Its diameter decreases by half, so its cross-sectional area decreases to one-fourth. Since the volume must remain the same, the snake is now four times as long as it was before. And the surface area, which is the product of the length and the diameter, has doubled.

As you continue to roll the snake thinner and thinner, the volume stays the same, but the surface area goes to infinity.

Gabriel's Horn does exactly the same thing, except without the rolling, because the parts of the Horn that are far from the origin look exactly the same as very long snakes.

There's nothing going on in the Gabriel's Horn example that isn't also happening in the snake example, except that in the explanation of Gabriel's Horn, the situation is obfuscated by calculus.

I read this explanation in H. Jerome Keisler's caclulus textbook. Keisler's book is an ordinary undergraduate calculus text, except that instead of basing everything on limits and on limiting processes, it is based on nonstandard analysis and explicit infinitesimal quantities. Check it out; it is available online for free. (The discussion of Gabriel's Horn is in chapter 6, page 356.)

[ Addendum 20081110: A bit more about this. ]

mjd Addenda to recent articles 200810

2008-11-10T17:04:00+00:00

I discussed representing ordinal numbers in the computer and expressed doubt that the following representation truly captured the awesome complexity of the ordinals:
```
        data Nat = Z | S Nat
        data Ordinal = Zero
                     | Succ Ordinal
                     | Lim (Nat → Ordinal)
```
In particular, I asked "What about Ω, the first uncountable ordinal?" Several readers pointed out that the answer to this is quite obvious: Suppose S is some countable sequence of (countable) ordinals. Then the limit of the sequence is a countable union of countable sets, and so is countable, and so is not Ω. Whoops! At least my intuition was in the right direction.
Several people helpfully pointed out that the notion I was looking for here is the "cofinality" of the ordinal, which I had not heard of before. Cofinality is fairly simple. Consider some ordered set S. Say that an element b is an "upper bound" for an element a if a ≤ b. A subset of S is cofinal if it contains an upper bound for every element of S. The cofinality of S is the minimum cardinality of its cofinal subsets, or, what is pretty much the same thing, the minimum order type of its cofinal subsets.
So, for example, the cofinality of ω is ℵ₀, or, in the language of order types, ω. But the cofinality of ω + 1 is only 1 (because the subset {ω} is cofinal), as is the cofinality of any successor ordinal. My question, phrased in terms of cofinality, is simply whether any ordinal has uncountable cofinality. As we saw, Ω certainly does.
But some uncountable ordinals have countable cofinality. For example, let ω_n be the smallest ordinal with cardinality ℵ_n for each n. In particular, ω₀ = ω, and ω₁ = Ω. Then ω_ω is uncountable, but has cofinality ω, since it contains a countable cofinal subset {ω₀, ω₁, ω₂, ...}. This is the kind of bullshit that set theorists use to occupy their time.
A couple of readers brought up George Boolos, who is disturbed by extremely large sets in something of the same way I am. Robin Houston asked me to consider the ordinal number which is the least fixed point of the ℵ operation, that is, the smallest ordinal number κ such that |κ| = ℵ_κ. Another way to define this is as the limit of the sequence 0, ℵ₀ ℵ_ℵ₀, ... . M. Houston describes κ as "large enough to be utterly mind-boggling, but not so huge as to defy comprehension altogether". I agree with the "utterly mind-boggling" part, anyway. And yet it has countable cofinality, as witnessed by the limiting sequence I just gave.
M. Houston says that Boolos uses κ as an example of a set that is so big that he cannot agree that it really exists. Set theory says that it does exist, but somewhere at or before that point, Boolos and set theory part ways. M. Houston says that a relevant essay, "Must we believe in set theory?" appears in Logic, Logic, and Logic. I'll have to check it out.
My own discomfort with uncountable sets is probably less nuanced, and certainly less well thought through. This is why I presented it as a fantasy, rather than as a claim or an argument. Just the sort of thing for a future blog post, although I suspect that I don't have anything to say about it that hasn't been said before, more than once.
Finally, a pseudonymous Reddit user brought up a paper of Coquand, Hancock, and Setzer that discusses just which ordinals are representable by the type defined above. The answer turns out to be all the ordinals less than ω^ω. But in Martin-Löf's type theory (about which more this month, I hope) you can actually represent up to ε₀. The paper is Ordinals in Type Theory and is linked from here.
Thanks to Robin Houston, Luke Palmer, Simon Tatham, Tim McKenzie, János Krámar, Vedran Čačić, and Reddit user "apfelmus" for discussing this with me.
Regarding homophones of numeral words, several readers pointed out that in non-rhotic dialects, "four" already has four homophones, including "faw" and "faugh". To which I, as a smug rhotician, reply "feh".
One reader wondered what should be done about homophones of "infinity", while another observed that a start has already been made on "googol". These are just the sort of issues my proposed Institute is needed to investigate.
One clever reader pointed out that "half" has the homophone "have". Except that it's not really a homophone. Which is just right!

mjd A proposed correction to an inconsistency in English orthography

2008-11-10T17:04:00+00:00

English contains exactly zero homophones of "zero", if one ignores the trivial homophone "zero", as is usually done.

English also contains exactly one homophone of "one", namely "won".

English does indeed contain two homophones of "two": "too" and "to".

However, the expected homophones of "three" are missing. I propose to rectify this inconsistency. This is sure to make English orthography more consistent and therefore easier for beginners to learn.

I suggest the following:

thrie
threigh
thurry

I also suggest the founding of a well-funded institute with the following mission:

Determine the meanings of these three new homophones
Conduct a public education campaign to establish them in common use
Lobby politicians to promote these new words by legislation, educational standards, public funding, or whatever other means are appropriate
Investigate the obvious sequel issues: "four" has only "for" and "fore" as homophones; what should be done about this?

Obviously, the director of this institute should be a thoughtful, far-seeing individual who will not allow his good judgement to be clouded by the generous salary. I refer, of course, to myself.

Happy Halloween. All Hail Discordia.

[ Addendum 20081106: Some readers inexplicably had nothing better to do than to respond to this ridiculous article. ]

mjd Representing ordinal numbers in the computer and elsewhere

2008-11-10T17:04:00+00:00

Lately I have been reading Andreas Abel's paper "A semantic analysis of structural recursion", because it was a referred to by David Turner's paper on total functional programming.

The Turner paper is a must-read. It's about functional programming in languages where every program is guaranteed to terminate. This is more useful than it sounds at first.

Turner's initial point is that the presence of ⊥ values in languages like Haskell spoils one's ability to reason from the program specification. His basic example is simple:

        loop :: Integer -> Integer
        loop x = 1 + loop x

Taking the function definition as an equation, we subtract (loop x) from both sides and get

0 = 1

which is wrong. The problem is that while subtracting (loop x) from both sides is valid reasoning over the integers, it's not valid over the Haskell Integer type, because Integer contains a ⊥ value for which that law doesn't hold: 1 ≠ 0, but 1 + ⊥ = 0 + ⊥.

Before you can use reasoning as simple and as familiar as subtracting an expression from both sides, you first have to prove that the value of the expression you're subtracting is not ⊥.

By banishing nonterminating functions, one also banishes ⊥ values, and familiar mathematical reasoning is rescued.

You also avoid a lot of confusing language design issues. The whole question of strictness vanishes, because strictness is solely a matter of what a function does when its argument is ⊥, and now there is no ⊥. Lazy evaluation and strict evaluation come to the same thing. You don't have to wonder whether the logical-or operator is strict in its first argument, or its second argument, or both, or neither, because it comes to the same thing regardless.

The drawback, of course, is that if you do this, your language is no longer Turing-complete. But that turns out to be less of a problem in practice than one would expect.

The paper was so interesting that I am following up several of its precursor papers, including Abel's paper, about which the Turner paper says "The problem of writing a decision procedure to recognise structural recursion in a typed lambda calculus with case-expressions and recursive, sum and product types is solved in the thesis of Andreas Abel." And indeed it is.

But none of that is what I was planning to discuss. Rather, Abel introduces a representation for ordinal numbers that I hadn't thought much about before.

I will work up to the ordinals via an intermediate example. Abel introduces a type Nat of natural numbers:

Nat = 1 ⊕ Nat

The "1" here is not the number 1, but rather a base type that contains only one element, like Haskell's () type or ML's unit type. For concreteness, I'll write the single value of this type as '•'.

The ⊕ operator is the disjoint sum operator for types. The elements of the type S ⊕ T have one of two forms. They are either left(s) where s∈S or right(t) where t∈T. So 1⊕1 is a type with exactly two values: left(•) and right(•).

The values of Nat are therefore left(•), and right(n) for any element n of Nat. So left(•), right(left(•)), right(right(left(•))), and so on. One can get a more familiar notation by defining:

0	=	left(•)
Succ(n)	=	right(n)

And then one just considers 3 to be an abbreviation for Succ(Succ(Succ(0))) as usual. (In this explanation, I omitted some technical details about recursive types.)

So much for the natural numbers. Abel then defines a type of ordinal numbers, as:

Ord = (1 ⊕ Ord) ⊕ (Nat → Ord)

In this scheme, an ordinal is either left(left(•)), which represents 0, or left(right(n)), which represents the successor of the ordinal n, or right(f), which represents the limit ordinal of the range of the function f, whose tyoe is Nat → Ord.

We can define abbreviations:

Zero	=	left(left(•))
Succ(n)	=	left(right(n))
Lim(f)	=	right(f)

So 0 = Zero, 1 = Succ(0), 2 = Succ(1), and so on. If we define a function id which maps Nat into Ord in the obvious way:

        id :: Nat → Ord
        id 0       = Zero
        id (n + 1) = Succ(id n)

then ω = Lim(id). Then we easily get ω+1 = Succ(ω), etc., and the limit of this function is 2ω:

        plusomega :: Nat → Ord
        plusomega 0       = Lim(id)
        plusomega (n + 1) = Succ(plusomega n)

We can define an addition function on ordinals:

        + :: Ord → Ord → Ord
        ord + Zero    = ord
        ord + Succ(n) = Succ(ord + n)
        ord + Lim(f)  = Lim(λx. ord + f(x))

This gets us another way to make 2ω: 2ω = Lim(λx.id(x) + ω).

Then this function multiplies a Nat by ω:

        timesomega :: Nat → Ord
        timesomega 0       = Zero
        timesomega (n + 1) = ω + (timesomega n)

and Lim(timesomega) is ω². We can go on like this.

But here's what puzzled me. The ordinals are really, really big. Much too big to be a set in most set theories. And even the countable ordinals are really, really big. We often think we have a handle on uncountable sets, because our canonical example is the real numbers, and real numubers are just decimal numbers, which seem simple enough. But the set of countable ordinals is full of weird monsters, enough to convince me that uncountable sets are much harder than most people suppose.

So when I saw that Abel wanted to define an arbitrary ordinals as a limit of a countable sequence of ordinals, I was puzzled. Can you really get every ordinal as the limit of a countable sequence of ordinals? What about Ω, the first uncountable ordinal?

Well, maybe. I can't think of any reason why not. But it still doesn't seem right. It is a very weird sequence, and one that you cannot write down. Because suppose you had a notation for all the ordinals that you would need. But because it is a notation, the set of things it can denote is countable, and so a fortiori the limit of all the ordinals that it can denote is a countable ordinal, not Ω.

And it's all very well to say that the sequence starts out (0, ω, 2ω, ω², ω^ω, ε₀, ε₁, ε_ε₀, ...), or whatever, but the beginning of the sequence is totally unimportant; what is important is the end, and we have no way to write the end or to even comprehend what it looks like.

So my question to set theory experts: is every limit ordinal the least upper bound of some countable sequence of ordinals?

I hate uncountable sets, and I have a fantasy that in the mathematics of the 23rd Century, uncountable sets will be looked back upon as a philosophical confusion of earlier times, like Zeno's paradox, or the luminiferous aether.

[ Addendum 20081106: Not every limit ordinal is the least upper bound of some countable sequence of (countable) ordinals, and my guess that Ω is not was correct, but the proof is so simple that I was quite embarrassed to have missed it. More details here. ]

JonathanD Welcome

2008-11-09T14:00:45+00:00

The purpose of this site is to further my pursuit of some of the things I enjoy...

mjd Election results

2008-11-06T18:51:00+00:00

Regardless of how you felt about the individual candidates in the recent American presidential election, and regardless of whether you live in the United States of America, I hope you can appreciate the deeply-felt sentiment that pervades this program:

        #!/usr/bin/perl

        my $remain = 1232470800 - time();
        $remain > 0 or print("It's finally over.\n"), exit;

        my @dur;
        for (60, 60, 24, 100000) {
          unshift @dur, $remain % $_;
          $remain -= $dur[0];
          $remain /= $_;  
        }

        my @time = qw(day days hour hours minute minutes second seconds);
        my @s;
        for (0 .. $#dur) {
          my $n = $dur[$_] or next;
          my $unit = $time[$_*2 + ($n != 1)];
          $s[$_] = "$n $unit"; 
        }
        @s = grep defined, @s;

        $s[-1] = "and $s[-1]" if @s > 2;
        print join ", ", @s;
        print "\n";

Elizabeth Bevilacqua Philadelphia Ubuntu Intrepid Ibex Release Party! And how we almost got arrested

2008-11-04T02:58:27+00:00

On Saturday the 1st the Philadelphia team of the Ubuntu Pennsylvania LoCo held our release party. Just like last year, we decided to celebrate the release with a Halloween influenced costume party at Drake Tavern in Jenkintown.

Drake Tavern is quite the hospitable place for our events, it’s a pretty family-friendly environment (Zoe was our youngest participant last year) and they gave us plenty of space and were tolerant of us spending a few hours there. We had several new folks show up (including one who trekked out from Pittsburgh!) and a few of us dressed up… I couldn’t resist a Leia costume, ssweeny as Indiana Jones, ChinnoDog as an executioner and jedijf, the primary organizer of the party, as a satanic priest.

More photos here: UbuntuPennsylvania.org Gallery: Ubuntu Intrepid Ibex Release Party

As a whole, the party was a blast, but a very unexpected event very early on almost made it end very quickly…

Paraphrased from jedijf in IRC, here is what happened:

So a 14 year old kid who had frequented our IRC channel shows up with his friend and mom, Randy and I are the only ones there, standing outside on their deck above the Ubuntu banner so people know where to come. I am in costume as a priest with the pentagon chain, Ubuntu satanic edition! Randy is of course with his teddy bear. So the mom asks “When is everyone supposed to get here?” We tell her “around 3″ but it’s now 3:20 ish and no one else is there. Some 20-somethings leave the bar to smoke and she decides this is not the right place for her son, says so and leaves with her son and his friend. I say “No problem,” I don’t want the kid to feel uncomfortable.

10 minutes later 2 Jenkintown police cars show up. They ask me what am I doing and why am I dressed like that. I say “It’s Halloween and we’re having a party” and the police ask for some ID. I point out the banner, explain that we we have reservations, but end up going to get ID and some CDs. The police officer checks Randy’s ID and tells him someone called in a complaint that we were trying to lure young boys. InHisName (another regular of the IRC channel) comes up with his son and the police take his son aside and talk to him. In the end I show the officer my ID and offer him CDs to take back to the station, he only accepted one.

Wow! I absolutely respect this mother’s decision to remove her son from a situation she was uncomfortable with, but taking the additional step of calling the police really says a lot about the culture of fear here in the United States. It was a bit upsetting. We’d rather not restrict attendance of our events based on age (and I’m positive the Ubuntu Youth folks wouldn’t be pleased with this either!), and probably won’t. However we are now more aware of what kinds of things can happen and it has gotten me to think what we can do to prevent this kind of situation in the future.

mjd Atypical Typing

2008-11-03T14:46:00+00:00

I just got back from Nashville, Tennessee, where I delivered a talk at OOPSLA 2008, my first talk as an "invited speaker". This post is a bunch of highly miscellaneous notes about the talk.

If you want to skip the notes and just read the talk, here it is.

Talk abstract

Many of the shortcomings of Java's type system were addressed by the addition of generics to Java 5.0. Java's generic types are a direct outgrowth of research into strong type systems in languages like SML and Haskell. But the powerful, expressive type systems of research languages like Haskell are capable of feats that exceed the dreams of programmers familiar only with mainstream languages.
In this talk I'll give a brief retrospective on the history of type systems and an introduction to the type system of the Haskell language, including a remarkable example where the Haskell type checker diagnoses an infinite loop bug at compile time.

I did not say in the abstract that the talk was a retread of a talk I gave for the Perl mongers in 1999 titled "Strong Typing Doesn't Have to Suck. Nobody wants to hear that. Still, the talk underwent a major rewrite, for all the obvious reasons.

In 1999, the claim that strong typing does not have to suck was surprising news, and particularly so to Perl Mongers. In 2008, however, this argument has been settled by Java 5, whose type system demonstrates pretty conclusively that strong typing doesn't have to suck. I am not saying that you must like it, and I am not saying that there is no room for improvement. Indeed, it's obvious that the Java 5 type system has room for improvement: if you take the SML type system of 15 years ago, and whack on it with a hammer until it's chipped and dinged all over, you get the Java 5 type system; the SML type system of the early 1990s is ipso facto an improvement. But that type system didn't suck, and neither does Java's.

So I took out the arguments about how static typing didn't have to suck, figuring that most of the OOPSLA audience was already sold on this point, and took a rather different theme: "Look, this ivory-tower geekery turned out to be important and useful, and its current incarnation may turn out to be important and useful in the same way and for the same reasons."

In 1999, I talked about Hindley-Milner type systems, and although it was far from clear at the time that mainstream languages would follow the path blazed by the HM languages, that was exactly what happened. So the HM languages, and Haskell in particular, contained some features of interest, and, had you known then how things would turn out, would have been worth looking at. But Haskell has continued to evolve, and perhaps it still is worth looking at.

Or maybe another way to put it: If the adoption of functional programming ideas into the mainstream took you by surprise, fair enough, because sometimes these things work out and sometimes they don't, and sometimes they get adopted and sometimes they don't. But if it happens again and takes you by surprise again, you're going to look like a dumbass. So start paying attention!

Haskell types are hard to explain

I spent most of the talk time running through some simple examples of Haskell's type inference algorithm, and finished with a really spectacular example that I first saw in a talk by Andrew R. Koenig at San Antonio USENIX where the type checker detects an infinite-loop bug in a sorting function at compile time. The goal of the 1999 talk was to explain enough of the ML type system that the audience would appreciate this spectacular example. The goal of the 2008 talk was the same, except I wanted to do the examples in Haskell, because Haskell is up-and-coming but ML is down-and-going.

It is a lot easier to explain ML's type system than it is to explain Haskell's. Partly it's because ML is simpler to begin with, but also it's because Haskell is so general and powerful that there are very few simple examples! For example, in SML one can demonstrate:

        (* SML *)
        val 3 : int;
        val 3.5 : real;

which everyone can understand.

But in Haskell, 3 has the type (Num t) ⇒ t, and 3.5 has the type (Fractional t) ⇒ t. So you can't explain the types of literal numeric constants without first getting into type classes.

The benefit of this, of course, is that you can write 3 + 3.5 in Haskell, and it does the right thing, whereas in ML you get a type error. But it sure does make it a devil to explain.

Similarly, in SML you can demonstrate some simple monomorphic functions:

	  not : bool → bool
	 real : int → real
	 sqrt : real → real
	floor : real → int

Of these, only not is simple in Haskell:

            not :: Bool → Bool
    fromInteger :: (Num a) ⇒ Integer → a    -- analogous to 'real'
           sqrt :: (Floating a) ⇒ a → a
          floor :: (RealFrac a, Integral b) ⇒ a → b

There are very few monomorphic functions in the Haskell standard prelude.

Slides

I'm still using the same slide-generation software I used in 1999, which makes me happy. It's a giant pile of horrible hacks, possibly the worst piece of software I've ever written. I'd like to hold it up as an example of "worse is better", but actually I think it only qualifies for "bad is good enough". I should write a blog article about this pile of hacks, just to document it for future generations.

Conference plenary sessions

This was the first "keynote session" I had been to at a conference in several years. One of the keynote speakers at a conference I attended was such a tedious, bloviating windbag that I walked out and swore I would never attend another conference plenary session. And I kept that promise until last week, when I had to attend, because now I was not only the bloviating windbag behind the lectern, but an oath-breaker to boot. This is the "shameful confession" alluded to on slide 3.

On the other hand...

One of the highest compliments I've ever received. It says "John McCarthy will be there. Mark Jason Dominus, too." Wow, I'm almost in the same paragraph with John McCarthy.

McCarthy didn't actually make it, unfortunately. But I did get to meet Richard Gabriel and Gregor Kiczales. And Daniel Weinreb, although I didn't know who he was before I met him. But now I'm glad I met Daniel Weinreb. During my talk I digressed to say that anyone who is appalled by Perl's regular expression syntax should take a look at Common Lisp's format feature, which is even more appalling, in much the same way. And Weinreb, who had been sitting in the front row and taking copious notes, announced "I wrote format!".

More explaining of jokes

As I get better at giving conference talks, the online slides communicate less and less of the amusing part of the content. You might find it interesting to compare the 1999 version of this talk with the 2008 version.

One joke, however, is too amusing to leave out. At the start of the talk, I pretended to have forgotten my slides. "No problem," I said. "All my talks these days are generated automatically by the computer anyway. I'll just rebuild it from scratch." I then displayed this form, which initialliy looked like this:

I then filled out the form appropriately for OOPSLA:

I pushed the button, and poof! Instant slides.

Wadler's anecdote

I had the chance to talk to Philip Wadler, one of the designers of Haskell and of the Java generics system, before the talk. I asked him about the history of the generics feature, and he told me the following story: At this point in the talk I repeated an anecdote that Wadler told me. After he and Odersky had done the work on generics in their gj and "Pizza" projects, Odersky was hired by Sun to write the new Java compiler. Odersky thought the generics were a good idea, so he put them into the compiler. At first the Sun folks always ran the compiler with the generics turned off. But they couldn't rip out the generics support completely, because they needed it in the compiler in order to get it to compile its own source code, which Odersky had written with generics. So Sun had to leave the feature in, and eventually they started using it, and eventually they decided they liked it. I related this story in the talk, but it didn't make it onto the slides, so I'm repeating it here.

I had never been to OOPSLA, so I also asked Wadler what the OOPSLA people would want to hear about. He mentioned STM, but since I don't know anything about STM I didn't say anything about it.

View it online

The slides are online.

[ Addendum 20081031: Thanks to a Max Rabkin for pointing out that Haskell's analogue of real is fromInteger. I don't know why this didn't occur to me, since I mentioned it in the talk. Oh well. ]

mikegrb Quick & Easy Temperature Logging with the Arduino

2008-11-03T03:29:50+00:00

Basic Voltage Divider with a Thermistor:

Typical voltage divider, matched would have made better sense but the thermistor was a random one salvaged from consumer electronics so I didn’t know the value in advance.

Would work just fine like this with TP1 connected to an Arduino analog input and Vcc and GND connected. Energy savings for the win though, connected the top of the divider (Vcc) to a digital pin on the Arduino. Set the pin HIGH when you want to take a reading, LOW the rest of the time. Now the divider is not consuming power when a reading isn’t being taken.

Arduino Code

int pinDivEn   = 4;
int pinDivRead = 1;
int pinLED     = 13;

void setup() {
    Serial.begin(9600);
    pinMode(pinLED, OUTPUT);
    pinMode(pinDivEn, OUTPUT);
    Serial.println(“READY“);
}

void loop() {
    if (Serial.available() > 0) {
        digitalWrite(pinDivEn, HIGH);
        digitalWrite(pinLED, HIGH);
        delay(100);
        while (Serial.available() > 0)
            int serByte = Serial.read();
        Serial.println(analogRead(pinDivRead));
        digitalWrite(pinDivEn, LOW);
        digitalWrite(pinLED, LOW);
    }
}

pinDivEn is the divider enable pin (Vcc), pinDivRead is the analog input connected to TP1 in the divider, pinLED is is a digital pin with an LED that is lit while a reading is taken.

Once the Arduino boots it sends READY on the serial port at 9600 bps. It then waits for any data to be available on the serial port, when bytes are available, the voltage divider is enabled, the LED is lit, the bytes on the serial port are consumed, the value of TP1 is read and then written to the serial port, the divider enable pin is brought back low and the led is extinguished.

Perl Code

#!/usr/bin/perl

use strict;
use warnings;

use IO::Handle;
use Device::SerialPort;

my $dev = tie (*FH, ‘Device::SerialPort‘, “/dev/tty.usbserial-A4001JwW“)
    || die “Can’t tie: $!“;

$dev->baudrate(9600);
$dev->databits(8);
$dev->parity(“none“);
$dev->stopbits(1);

open (my $log, ‘>>‘, ‘ohms.log‘) || die “can’t open: $!“;
$log->autoflush(1);

# wait for arduino to boot
while (1) {
    my $val = <FH>;
    last if $val;
}

print FH “1\n“;
while (1) {
    my $val = <FH>;
    next unless $val;
    chomp $val;

    my $vR2 = $val / 1023 * 5;
    my $vR1 = 5 - $vR2;
    my $i   = $vR1 / 1_000 * 1_000;
    my $R2  = $vR2 / $i;

    print $log time . ‘ ‘ . $R2 . “\n“;
    # printf(”V_R2=%.2fV, i=%.2fmA  R2=%.2fK&#8486;\n”, $vR2, $i, $R2);

    sleep 10;
    print FH “1\n“;
}

Opens the serial port, waits for something (the Arduino sending ‘READY’ but it pays no attention to what) on the serial port then every 10 seconds sends a 1\n to the Arduino prompting it to send a value. The result of analogRead is an integer from 0 - 1023 so this is converted to a voltage. The current through the divider is found allowing the resistance of the thermistor to be solved for. The resistance and time are written to a space separated log file. If the thermistor wasn’t unknown it would make more sense to solve for the actual temp using the Steinhart–Hart equation or similar and logging that rather than the resistance.

Sample log file entries
1224349429 10.1195652173913 1224349439 10.3666666666667 1224349449 10.3666666666667 1224349459 10.3666666666667 1224349469 10.4943820224719 1224349479 10.3666666666667 1224349489 10.2417582417582

A few lines in a text file gets us a graph from the log file by way of GnuPlot:

set term png transparent nocrop enhanced font “./arial.ttf“ 9 size 800, 600
set xdata time
set timefmt “%s“
set format x “%m/%d %H:%M“
set xtics  rotate by -45
set title “Thermistor Value“
set xlabel “Date/Time“
set ylabel “Resistance (kOhms)“
set grid
set output “ohms.png“
plot \
    “ohms.log“ using 1:2 title “10 sec interval readings“ linecolor 2, \
    “ohms.log“ using 1:2 title “Bezier fit curve“ smooth bezier linecolor 4 lw 2, \
    10 title “77 F“ lw 2 linecolor 1

yonkeltron And, let’s not forget the many failures of Apple

2008-10-30T23:47:38+00:00

For reasons I really don’t understand, people really like Apple these days. I’ve long felt that they offer an overpriced product which are generally inferior to similar products on the market. Still, simply because the iPod is popular, people assume it’s good. So too, do people have a positive opinion of the iPhone. With a little luck and some common sense, devices running Android will offer up some serious competition and hopefully displace the iPhone, for the good of the consumer. In fact, I’ve often been very angry at Apple for selling products which I consider to be technologically inferior, much in the same way that I’ve become angry with Microsoft for the embarrasment that is the Windows family.

In any case, there is an article in Forbes about ten of the biggest Apple failures. Enjoy it.

yonkeltron My Hacker Key

2008-10-29T03:35:57+00:00

It’s been far-past time to replace the Geek Code, so I’m very glad that I discovered the Hacker Key. My key:

v4sw6/7ALRU$hw4ln5+7pr5FOP$ck0ma0u8Lw2m1l7Di6e4t5NTVb8ADHKMOPRen5a2Xs0r5$p-2.38/-2.31g5G hackerkey.com

Make your own, at hackerkey.com!

yonkeltron Saving myself lots of bandwidth with apt-proxy

2008-10-19T18:49:35+00:00

I have at least 3 machines running Debian on my network at any given time and I’m using Debian testing (currently Lenny) because it’s so close to being stable anyway. Still, there are plenty of updates on a regular basis and keeping my machines up to date is a rather big drain on my network connection considering that machines share basic packages anyway.

I looked around and found a wonderful tool called apt-proxy which will act as both intelligent cache and partial mirror for machines on a network. You set up apt-proxy on one machine with the names of whatever package repositories you want to use along with a few other settings. I got some pointers from a wonderful article at Debian Administration by Steve when I was messing with the default config provided with the package. Once that’s all set up, you change all of the other machines’ sources.list point to the apt-proxy mirror you just set up. Then machines requests will get intelligently filtered through apt-proxy and duplicate packages will be cached for multiple machines. It’s great because it makes subsequent updates faster and simplifies mirror management on different machines. I could see this being very handy for clusters and doing large installs.

yonkeltron Finally broke down, joined Twitter

2008-10-16T04:21:48+00:00

After months of being above it all, I have finally so broken down and got a Twitter account. I have a widget displaying my status on the sidebar of my site and you can follow me directly from my page, http://twitter.com/yonkeltron whenever you like. I sort of wish that they would bring back the Twitter IM feature which they killed because Jabber/XMPP integration would be delightfully wonderful…

yonkeltron Why must it be so hard to cluster?

2008-10-08T02:30:06+00:00

In the past, I’ve gotten pretty upset by how difficult it is to take advantage of multiple computers on a network for general tasks. In this age of advanced Linux software, I’m still shocked at how hard it is to cluster machines.

Let’s say I have three or so machines on my local network. If the task is something commonplace like encoding audio or compiling, I can use either distmp3 or distcc, respectively.

Alternatively, if I want to share disk space among nodes, I could use a clustered file system such as Lustre or GFS. After that, I’d have to put together a more formal cluster like OpenMosix (now abandoned), OpenSSI, Kerreghed (comparison paper, PDF) or some other option. The next step is to write my own applications to do something explicitly parallel using any number of options like OpenMP, PVM along with trendy stuff like hadoop and MapReduce. I can always opt for just doing it by hand using distributed objects for a given language. Apropos, Ruby has positively stellar support for distributed objects indcluding Rinda, an implementation of tuple-spaces (ala Linda) which provides nifty things (auto-discovery, among other features). Still, these options don’t help me build a general usage cluster out of machines.

Then there are the tools to control the actions of the machines remotely like clusterssh, dsh and gsh.

So far, my options are:

Settle for the limited capabilities except for select tasks.
Write my own app to do something (or everything, which is a bad idea).
Deal with it and control actions using a remote, group-admin tool.

I understand how the landscape could reach such a state, but I don’t like the fact that this is the same set of options I’ve had for the last five years or so. Are there options I’m overlooking? Is there something I don’t know about? The only thing I can see down the pipeline is GNU Queue (got a tipoff from mct) which might very well be exactly what I’ve been dreaming of. Unfortunately, no releases have yet been made, so certainly no chance of using it now.

yonkeltron Palm should go Android

2008-10-06T03:21:04+00:00

Palm would benefit from adopting Android for so many reasons!

Stop funneling profits to Microsoft
Get enthusiastic Android developers from the community
Support free software and change the business model enough to ensure future solidity. How long before someone does a *really* good clone of HotSync? Why not just move to an open standard like SyncML and monetize the transition?
Focus on kickin hardware and stop worrying about the OS. Remember the fiasco with PalmSource?
Contributing the upcoming Linux-based new Palm OS to the community would be a kickin way to give back, a great PR stunt and it would free up talent assets to work on the coolness that is Android

Just one person’s opinion but I remember my old Palm hardware and wouldn’t think twice before dropping some cash on a Palm device that ran Android.

yonkeltron Linux boots even faster!

2008-10-04T23:42:14+00:00

I have always been a super-huge fan of Linux for it’s quick and elegant startup. Ok, so various versions of init aren’t exactly the most elegant things but projects like upstart enrich the landscape all the same. Anyway, I got wind of efforts to make Linux boot faster by way of a Slashdot post or two which pointed me to some major coolness. Basically, there are numerous individuals trying to track the boot process, reduce the resource consumption of the whole process and set stronger goals for the whole affair. All in all, they’ve shaved boot time down to 5 seconds. Whoa….

mjd The Lake Wobegon Distribution

2008-10-02T00:08:00+00:00

Michael Lugo mentioned a while back that most distributions are normal. He does not, of course, believe any such silly thing, so please do not rush to correct him (or me). But the remark reminded me of how many people do seem to believe that most distributions are normal. More than once on internet mailing lists I have encountered people who ridiculed others for asserting that "nearly all x are above [or below] average". This is a recurring joke on Prairie Home Companion, broadcast from the fictional town of Lake Wobegon, where "all the women are strong, all the men are good looking, and all the children are above average." And indeed, they can't all be above average. But they could nearly all be above average. And this is actually an extremely common situation.

To take my favorite example: nearly everyone has an above-average number of legs. I wish I could remember who first brought this to my attention. James Kushner, perhaps?

But the world abounds with less droll examples. Consider a typical corporation. Probably most of the employees make a below-average salary. Or, more concretely, consider a small company with ten employees. Nine of them are paid $40,000 each, and one is the owner, who is paid $400,000. The average salary is $76,000, and 90% of the employees' salaries are below average.

The situation is familiar to people interested in baseball statistics because, for example, most baseball players are below average. Using Sean Lahman's database, I find that 588 players received at least one at-bat in the 2006 National League. These 588 players collected a total of 23,501 hits in 88,844 at-bats, for a collective batting average of .265. Of these 588, only 182 had an individual batting average higher than 265. 69% of the baseball players in the 2006 National League were below-average hitters. If you throw out the players with fewer than 10 at-bats, you are left with 432 players of whom 279, or 65%, hit worse than their collective average of 23430/88325 = .265. Other statistics, such as earned-run averages, are similarly skewed.

The reason for this is not hard to see. Baseball-hitting talent in the general population is normally distributed, like this:

Here the right side of the graph represents the unusually good hitters, of whom there aren't very many. The left side of the graph represents the unusually bad hitters; there aren't many of those either. Most people are somewhere in the middle, near the average, and there are about as many above-average hitters as below-average hitters in the general population.

But major-league baseball players are not the general population. They are carefully selected, among the best of the best. They are all chosen from the right-hand edge of the normal curve. The people in the middle of the normal curve, people like me, play baseball in Clark Park, not in Quankee Stadium.

Here's the right-hand corner of the curve above, highly magnified:

As you can see here, the shape is not at all like the curve for the general population, which had the vast majority of the population in the middle, around the average. Here, the vast majority of the population is way over on the left side, just barely good enough to play in the majors, hanging on to their jobs by the skin of their teeth, subject at any moment to replacement by some kid up from the triple-A minors. The above-average players are the ones over on the right end, the few of the few.

Actually I didn't present the case strongly enough. There are around 800 regular major-league ballplayers in the USA, drawn from a population of around 300 million, a ratio of one per 375,000. Well, no, the ratio is smaller, since the U.S. leagues also draw the best players from Mexico, Venezuela, Canada, the Dominican Republic, Japan, and elsewhere. The curve above is much too inclusive. The real curve for major-league ballplayers looks more like this:

(Note especially the numbers on the y-axis.)

This has important implications for the analysis of baseball. A player who is "merely" above average is a rare and precious resource, to be cherished; far more players are below average. Skilled analysts know that comparisons with the "average" player are misleading, because baseball is full of useful, effective players who are below average. Instead, analysts compare players to a hypothetical "replacement level", which is effectively the leftmost edge of the curve, the level at which a player can be easily replaced by one of those kids from triple-A ball.

In the Historical Baseball Abstract, Bill James describes some great team, I think one of the Cincinnati Big Red Machine teams of the mid-1970s, as "possibly the only team in history that was above average at every position". That's an important thing to know about the sport, and about team sports in general: you don't need great players to completely clobber the opposition; it suffices to have players that are merely above average. But if you're the coach, you'd better learn to make do with a bunch of players who are below average, because that's what you have, and that's what the other team will beat you with.

The right-skewedness of the right side of a normal distribution has implications that are important outside of baseball. Stephen Jay Gould wrote an essay about how he was diagnosed with cancer and given six months to live. This sounds awful, and it is awful. But six months was the expected lifetime for patients with his type of cancer—the average remaining lifetime, in other words—and in fact, nearly everyone with that sort of cancer lived less than six months, usually much less. The average was only skewed up as high as six months because of a few people who took years to die. Gould realized this, and then set about trying to find out how the few long-lived outliers survived and what he could do to turn himself into one of the long-lived freaks. And he succeeded, and lived for twenty years, dying eventually at age 60.

My heavens, I just realized that what I've written is an article about the "long tail". I had no idea I was being so trendy. Sorry, everyone.

yonkeltron Squeak without an OS: I don’t get it

2008-09-28T00:21:12+00:00

Caught wind of a neat sort of project from OSNews about a project called SqueakNOS which seeks to implement the Smalltalk programming language as close to the bare metal as possible, i.e., without an operating system. It’s not that the real Squeak isn’t cool, but might this be somewhere along the same lines as Movitz is with Common Lisp?

It might just be me, but I’m very happy with my current OS (which is GNU/Linux) and I’d like to see better integration of virtual machines into the system before I do away with the system entirely!