I keep meaning to post, but never really get around to doing it. This is somewhat of a general post, glossing over some of the stuff I have been meaning to post about. In reverse chronological order even. We had this startup talk today, and this thing was probably better attended than any recent CS talk in recent history. The free food helped, but considering all the other people give out free food too, that couldn't be the only reason for attendance. It's interesting to look around the room to see who's attending one of these things, for instance today's was attended by quite a few CS professors, professors who don't normally attend these things. And then there were all the other people I had never seen, and the usual CS department attendees at these things. But this in general fits in with Itay and other people's observations about how everyone in the class below us seems to be infected with the startup bug. Well not everyone, but the people we happen to be close to, and it is sort of interesting, since most people my year seem to be looking for more traditional jobs. Traditional jobs with exciting work, but traditional large companies nevertheless, and one wonders what changed between now and then.

Following the publication of a weird paper about MapReduce and ML, Itay (you should go to his blog, he has finally updated it) and I worked on an implementation of MapFold in Erlang. We actually intended on making MapReduce in Erlang, but forgot to read the original paper, instead taking our cue from what Functional Programming defines map and fold to be. Well they are equivalent anyways, except for the part where distributing fold with our semantics is hard (think about how you'd distribute folding product over matrices). Doing this in Erlang is surprisingly easy, neither of us had ever used Erlang before, and yet within a night we got a fairly substantial part of this done. This led us to some questions about why Erlang receive clauses work the way they do, turns out scala and most other languages have similar semantics, but it would seem that with very little overhead at compile time, one could make it so that in some cases message receiving is fast. Specifically, people in the past have complained about how Erlang's slow when you're looking for one specific, static, message in a queue full of other messages you aren't interested in. We did not want to change the preexisting receive construct too much, since the entire pattern matching thing is fairly intuitive, and changing the structure doesn't get us much gains in the worse case. The compiler tricks simple, but people with more PL experience than us seem to agree that it cannot really be done easily without looking at the program text, and hence outside the compiler, which is really quite sad.

My PL class just started using Scheme macros for performing Fischer transforms into CPS, and I am a little freaked out by them. It is hard to say why, they are powerful, make sense, and are well liked, I am just not convinced that using macros isn't cheating in some sense of that word.

I seem to be traveling far too much in the next month, this should be interesting.

Panda