Friday, March 13, 2009

Beckett's Endgame at the A.R.T.

I saw Beckett's Endgame at the American Repertory Theater last night and liked the performance very much. Today they informed me they just added three shows, so you should go see it if you are in the area and enjoy that genre of absurd drama/are curious to see what Endgame looks like as a real play.

For those of you who don't know, Endgame is an absurd play (somewhat similar to Sartre's No Exit) about four people who are waiting in a room to die. There is Hamm, the blind protagonist who cannot stand, Clov, Hamm's friend/"son"/servant who cannot sit, and Nagg and Nell, Hamm's parents who exist in separate ash cans and have no legs. The play provides interesting food for thought on interactions between people, what it means to live, and what it means to wait for death. I was surprised that the A.R.T. managed to put humor into it; I had always thought of it as a fairly depressing and absurd tragedy. The show I saw was enjoyable and moving--an impressive feat with such tricky material.

If you don't believe me that the play is good, you should know that Endgame has been getting good reviews: everything from "exquisite" and "stunning" to "fulfilling," "exciting" and "gaspingly funny."

You can read other reviews here and get tickets here.

Wednesday, March 11, 2009

Gmail finally has a task list feature!

I don't know how slow I am on this; I found out about this by spying on Adam.

If you go to the Labs tab in the Settings in your Gmail, you can enable a Google tasks thing that shows up like a chat window. I have always wanted something like this, so this is very exciting. Instead of chatting, I can now do tasks! (Read more here).

Monday, March 09, 2009

Haskell vs. OCaml, or the ravings of a monomanic insomniac

Until fairly recently, I was a hardcore Haskell hacker who saw little reason to go elsewhere for needs of a higher-than-C level. Haskell is beautiful; Haskell is clever; Haskell has Parsec. A couple of weeks ago, I started using OCaml (after having used ML for a couple of semesters as an undergrad) and realized that you can get a lot farther in life if you are not limited to writing pretty code*.

Since then, I've gone back an forth between "OCaml is the future" and "But Haskell is so pretty." Here are my notes on OCaml vs. Haskell.

  • Haskell does datatype constructors right. As in, Haskell datatype constructors are functions whose types are the type of the constructor. For instance, if we have a data type data Thing = C1 Int Int | C2 Bool, we get constructors of types (C1 :: Int -> Int -> Thing) and (C2 :: Bool -> Thing). In OCaml, constructors take explicit tuples. The analogous constructor C1 would need to take something of the form ([int], [int]), not just something of type (int * int).
  • Haskell does type classes right. Not just type classes, but type class related utilities like deriving. Type classes are often nice for clever things but always nice for development. Being able to derive Show and Eq gets rid of a ton of boilerplate. Not believing in function overloading makes me not believe in ML! >:o
  • Haskell is way prettier. Small things make Haskell code way easier to read and maintain. (For instance, the support for defining things below functions with where instead of binding everything for let. I should not have to trade off cluttering my toplevel namespace with cluttering my function definitions!
  • Because Haskell is so clean and concise, it makes you produce prettier code in other languages.
  • Higher-rank polymorphism and the ability to write down my forall types is very convenient.
  • You can code without being constantly clever! In my senile senescence (which is also absolutely alliterative), I see this as a huge plus. ;)
  • Not having to work in monads all the time to deal with state in any kind of okay way is a huge productivity plus of SML/OCaml. Don't believe me? I have the following points: 1) 3D IO Arrays, 2) gensym**, and 3) monad transformers (yuck!).
  • OCaml has very nice library support (Batteries, arrays, etc.).
  • OCaml seems to have a larger user base, so there are more people doing stuff in it, more people to ask when things go wrong, etc. etc.
  • Though ML code is more verbose and generally less pretty than Haskell code, it disallows a lot of the clever use of syntax that obfuscates the meaning of Haskell code.
The conclusion is that while Haskell leaves a nicer taste in one's mouth, OCaml might be better for practical purposes, especially if you want to use 3D mutable arrays. It all depends on what you want to do.

* According to some fairly high standards of "pretty."
** Generate fresh variable names, for instance "__tempvar0." Note that being able to keep some state is nice so you can just increase your variable count each time.

I used to think correlation implies causation...

But then this xkcd comic caused me to believe otherwise. ;)