Schemers in Haskell country

Before coming to this conference I hadn't realized how much the Functional Programming community is dominated by Haskell people. Most of the presenations are very Haskell-y even though in theory much of the work should be universal.

Although the Scheme people occasionally point out to a presenter that his work sure looks like something the Scheme people figured out fifteen years ago, the two camps seem to get along fine most of the time. Wait'll the coffee runs low, though.

Why you should attend academic conferences

I really should apologize to my readers for the content of my posts on the presentations at the ICFP. Most of what I am saying about these have to do with my own level of knowledge about the subject (ranging from very minimal to completely innocent) and extent to which it piqued my interest, instead of the content of the talk. This is the way it has to be, as I am, with some exceptions, not sufficiently knowledgeable about the field to speak with authority about the talks - in fact I generally can't even provide a synopsis.

If you want to know about one of the presentations you'll need to find other bloggers, or better yet, read the paper. At least the abstract. But than since such papers are almost always available on the web, I have to ask: why are you reading this? Probably you are one of my regular readers (hi Mom!). Or you wrote the paper and are interested in what the community thinks of it (hi Jacob!). It's to the second group that my apology is directed: I'm sorry. I really don't know. You may as well ask the congressional page what he thinks of the Constitutional implications of a bill being debated. (I originally had that "ask the dog about the craftsmanship of a Persian rug he just soiled" but this is a family blog and a cheap dog poop joke just won't do now, will it?)

But if, like me, your understanding of most of the papers is limited, then maybe you are reading this blog to help you to decide if you should go to next year's ICFP. The answer is yes. Go, even if you must pay your own pay like I did. You meet really interesting people. I've met the authors of my favorite computer book of all time for example (one of them, Dan Friedman, and his co-author of another book, Robert Byrd, are right now sitting directly to my right, huddled over a cons cell diagram and some Scheme code scibbled on some hotel stationary trying to puzzle something out. Cool, eh?) You get to talk to interesting people and get a real feel about what the work of an academic is like (at least the research part). You get an idea of where the field is going, who is considered to be doing the most interesting work, and most of all, what parts of the field have attracted the most interesting and enthusiastic people and how to participate in those parts. I can tell you that I'm much more seriously thinking of grad school now than I was when I arrived. I want to understand more of these papers.

ICFP presentation: Practical Proofs of Concurrent Programs by Marc Shapiro

I'm not especially interested in concurrency issues (read that: I'm not sufficiently knowledgeable in the field to be interested). They tend to be difficult, non-hackable problems. That is, you can't just start hacking away on the problem to see what works. You have to prove that your solution works; no amount of testing (much less a quick try through a few edge cases) can prove that it will work. That said, I'm all for people coming up with abstractions or frameworks that ease this problem for those of us who would rather not think about these problems so much. Hats off to them!

Everything before lunch today (Tuesday, the second day of the official conference, my third day day here since I attended this pre-conference Scheme workshop) is on the topic of concurrency so I'm not exactly on the edge of my seat. I wonder if I can catch a nap somehow...

Nevertheless I was interested by the first talk, by Marc Shapiro on using Rely-Guarantee analysis to prove correctness of concurrent programs. If I understand what he is doing, his work shows a new way to divide the concurrency issues of a given program into smaller pieces, each of which may be divided into smaller pieces using the same technique, until the pieces are small enough that the set of all the things that the pieces rely upon are guaranteed by the pieces. If you can do this, your program is proven to be safe with concurrency. I need to read the paper, except it looks like only the abstract is present in the Proceedings of the conference.

Planet - PLTScheme's central package storehouse and installation system.

Surely everyone envies Perl's CPAN. Other languages either already have such a system (like Ruby Gems or Common Lisp's asdf-install) or are building one.

So one of the happy warriors who hack PLTScheme, Jacob Matthews, has come up with a system of his own, Planet. It sounds good. I really don't know much about it but at least one can be heartened by his choice of models, CPAN and Debian's apt-get.

It has some nice features:
They enforce standards on the numbering of versions. If you release a version that breaks users of your previous version, you must call it by a new major number (5.0, 6.0, etc.)
They have integrated Dr. Scheme with this so that you can visually see what functions came from what packages, using the arrow pointing thing that Dr. Scheme uses to show you your stack trace when your code crashes. (Wait, is this just part of the packaging system? I'm not sure that Planet added this. In any case, it's a good thing for Scheme.)

Of course the real difference between this and CPAN is that CPAN has 2 gigabyes of perl source made up of who knows how many gazillions of modules. Planet has 115 packages (or modules, I don't know about Scheme packaging).

Given the trouble I've had getting Common Lisp's asdf-install configured properly on my Windows machine, I am hopeful about the prospect of something better in the Scheme world.

Technorati: scheme, icfp, lisp, pltscheme, drscheme, planet, packagerepositories

Ray Rischpater: Scheme on the mobile phone. From the Scheme workshop at ICFP

Ray Rischpater gave an gratifying talk on what his company, RocketMobile Phone has done with Scheme on the mobile phone. They've done it with a port of TinyScheme.

It sounds like they wrote their own browser so that they can get access to things like the address book, the list of recent phone calls, etc. Probably GPS data too. They do this by serving WML-like pages to the browser that include Scheme between script tags. I'm interested in knowing why they chose the browser route. They were building their own client to interact with thier own server... is the browser model superior even for a single application, single server situation? I suppose a major factor was that they already had server-side infrastructure ready to go, including programmers that are accustomed to that model. And who knows, maybe they are reserving the option to dominate the wireless browser market for the glory of Scheme!

Question: are they sending WML to their browser when not sending blocks? It would seem so.



(Technorati Tags: icfp, scheme, lisp, wireless, rocketmobile, tinyscheme)

2006 Scheme workshop at ICFP - Jay McCarthy and Shriram Krishnamurthi on continuation passing for web state.

So far this was the best session for me here at the ICFP. We've been hearing a lot about using continuations for keeping state in web applications. This was a good, non overreaching presentation on the subject. It was something of a revelation for me. I was previously under the impression that if you choose the continuation-passing method of preserving state, then you forsake all others. Putting data in cookies, keeping session data in the database (with session id in URLs or in a session variable), putting data directly in session variables... I had thought that this new statefulness required you to kick these to the curb. But it turns out that continuation passing is not jealous. There's no reason not to use them for some of the state in your application and whatever other method for other parts of your state. This is great. Basically you keep using the older methods of state as long as they are working fine for you. It's only when the state becomes problematic (Jay implies that this especially comes up when the user has multiple views of the same data open at once) that you turn to the continuations. Kudos to Jay for being pragmatic about this. Jay's paper (with Shiriram Krishnamurthi) and presentation was based on the the production code they shipped for the PLT Web Server to do these continuations.

Great talk.

(Technorati Tags: icfp, scheme, lisp, continuations, pltwebserver, web)

More from the Scheme workshop at ICFP - Guillaume Germain and Termite Scheme

SeaFunc's own Guillaume Germain presented on Termite Scheme. This is his implementation of the interesting and useful principles of Erlang in Scheme. As I know nearly nothing of Erlang, I appreciated his overview of what exactly it's principles are. Those include : "Every process has a mailbox, the only way to talk to it is send it a message." "Sending a message won't block." "Receiving a message might."

Interesting talk. It was good to talk to Guillaume again, too.


(Technorati Tags: icfp, scheme, lisp, erlang, termitescheme)

Blogging the Scheme workshop at ICFP - William Byrd, Dan Friedman and miniKanren

Some very interesting stuff so far. William Byrd - coauthor of The Reasoned Schemer (along with Dan Friedman, who is sitting behind and to the right of me which is pretty damn cool. Dan and Mattias Fellesen co-wrote The Little Schemer, which is probably my favorite book ever. Mattias sat right next to me earlier. There's the advantage of a working with a language that hasn't achieved mass popularity - beginners like me are have access to the leading people. That the leading people of your language are a big chunk of the leading people in the field of Computer Science is a good indication that you are working with the right language.) - gave a talk on his and Dan Friedman's creation, miniKanren, which apparently is a more or less an implementation, in Scheme, of an imaginary language described in that book. It's for logic programming - interesting. He lost me several times - I need to read the paper. And learn more about logic programming generally. Byrd is a very clear speaker. It would seem he's given the talk before, based on his polished delivery. If not he's someone a conference-goer really appreciates: a speaker who rehearses a lot.


(Technorati Tags: icfp, scheme, lisp, minikanren, logicprogramming)

Switching to Blogger, leaving behind my old blog.

Hello, readers. I've been mulling the advantages of moving my blog to an automated and hosted option for a little while now. I think now's the time. Now if I can figure out how to add my old blog's posts here with the proper dates...

My old blog is www.herdrick.com