There was a surreal mix of cyberspace and reality at this conference. Most attendees had laptops with wireless, and the conference organizers hacked up some sort of free wireless access in the main conference areas. As usual, there were thumbtack-board areas where people posted stuff as the conference progressed, but cyberspace upped it one level. People were posting blog entries as the conference progressed, and I overhead several conversations that started, "I read what you posted on blog this morning, and I wanted to tell you that...." Science fiction is becoming reality.
The Dynamic Languages Symposium (DLS), held all day on Tuesday, was excellent. I hope it happens more! All of the invited talks were great. Gilad Bracha gave an exciting but oft-misunderstood talk about using dynamic-language runtime techniques to make a system like web-services usable . Many folks misunderstood this to mean thing like, through away your version control system, or you are at the complete mercy of the whims of your upstream service providers. I hope more people take a closer look at this idea; it sounds to me more like a Debian's apt system applied to . Or, for that matter, web services, where the provider can swap out the code behind the API any time they please. It works well with apt and with web services, and it seems promissing for continually updated components as well.
Gerald Sussman's essayic talk was about different styles of language use, and in particular about the uses of computer languages to impose formality. He paints a spectrum where programming languages are in the middle, forcing you to be formal, and in particular unambiguous. Math is at one end of the spectrum, forcing you to be rigorous in addition to just being formal (writing down 2+2=5 is a formal statement but not one that rigorous reasoning would let you get away with). The opposite end of the spectrum is fun to think about as well. Sussman calls it impressionistic communication, where you do a lot of hand waving and where you rely on shared knowledge with each other to get the point across. Overall, while a lot of his particular examples were annoying (he plaintively asks why Seymour Papert's Logo program isn't followed these days, but it's because it was tried in spades and didn't work!), I loved thinking about these different styles of language use (rigorous, fromal, and impressionistic). Besides, as a language enthusiast, it was fon to dwell on the idea of improved languages making people effectively smarter.
Jans Aasman, a high-level guy from Franz, talked about some research he is doing on practical projects implemented in multiple languages. He has collected ten programs that have been implemented elsewhere in C or Java, and his team has rewritten them in Lisp. All of them have less code, and some of them have dramatically less code -- on the order of 10%. I hope he continues this work, because it's great to do apples to apples comparison. I hope he also ponders the importance of little trivial details that customers need, though. Someone asked him about deployment, and he didn't have anything to say at all.
Brian Foote brought the house down with his talk about static typing. He had lots of great graphics, word plays, jokes, and so on, and it was great having him finish the day off for us. My favorite part of the talk is his goalie analogy that he carries through. He compares dynamic checks of all kinds -- type checks, array out-of-bounds, preconditions/postconditions, whatever -- to goalies in a soccer game ("metric football", as he calls it). These checks are like goalies trying to stop the opposing team (bugs!) try to kick a ball through the goal (crashes!). Static typing, in this analogy, corresponds to making a detailed proof that no ball will ever be kicked through the goal, and then firing the goalie and sending them home. It's theoretically possible that this approach works out, but you had better get your proof exactly right! Wouldn't you feel better, even with the proof, that there was a goalie hanging around, just in case?
On the tecnhical side, I'll try to briefly mention just half a dozen of the highlights for me. There was loads of good material:
morphs select visible" instead of "
morph select: [ :m | m visible ]". A possible cleanup tossed out from the audience is to have some syntax for simple blocks where you only use the variable one time. Then the code might be something like "
morph select: >>visible". I'm conflicted -- the technique clearly is convenient and reduces errors, but I also like having a restricted semantics little notion of the control-flow in the program, having a notion of which places there might be something more complicated that message-in response-out.
Overall, the conference was a real blast. I found myself completely drained each night, and I crashed especially hard Thursday night after the conference ended.