catechu

In addition to the mutable records mentioned in the post, arrays and references are also mutable in OCaml. Aside from objects, I consider this impurity to be the biggest difference in practice. Mutability allows simple OCaml solutions to problems that would otherwise demand monadic gymnastics in Haskell.

FWIW, I've also never been able to design a large project in Haskell (a la darcs), whereas I could write fairly large projects in OCaml without much awkwardness. I suspect the ability to "cheat" with mutability outweighs in practical terms the theoretical elegance and enjoyment of programming in Haskell.

Unity looks nice, but its improvements over GNOME seem to be mainly cosmetic -- not compelling enough to pull me away from the simplicity of dwm (http://dwm.suckless.org/), at least not yet.

Students who've taken systems programming classes (e.g. Operating Systems) would be your best bet -- in my experience, most low-level programming is shafted to those classes, except in the cases where a professor arbitrarily requires C, which doesn't necessarily happen in algorithms classes either.

But even better would be to find students who hack on open-source projects written in C (e.g. Linux-related efforts) -- that's much more representative of a graduating student's ability to be productive using C. There are a lot of students working on such projects, and it might be worth starting there.

That's a great point -- currently, I'm in the process of scraping specs from other sites, and I really like your idea of putting a layer of understanding over that to simplify the display for the user.

Kind of like Google Squared, but easier to generate the table.

I'd like to check it out, but it doesn't seem to be up.

I wanted to be able to see products on Amazon side-by-side with their pros and cons: http://silvos.com.

I need to add more products, product specs, and fix the way the pros/cons work, but I'm already using it to start thinking about which digital camera to get.

Ouch. In retrospect, "Falling Sky Entertainment" was a good name choice for the production company.

I'm not familiar with Arc's internals or the effect that this would have in the context of GC, but as a hack, perhaps you could assign multiple people to a single interpreter instance, prepend prefixes to symbols to avoid collisions before evaluating (e.g. user_1_total, user_1_total, user_2_total), and make each user optionally aware of commands from other users on that instance (e.g. implemented as in-browser chat), letting individual evaluations block each other -- I doubt anyone's doing anything particularly heavy-duty or time-sensitive on your server.

This is convoluted and fragile, but if I wanted to roll out "sandboxes" on limited hardware I'd start with something like this.

Interesting premise! Trying the description itself:

"Enter a paragraph of text. We'll run it through our highly sophisticated algorithms* and output a lovely, totally original piece of text."

rather amusingly yields:

"come in a piece of writing of text. We'll run it done our extremely advanced algorithms* and end product a lovely, wholly unoriginal part of text."

As a next step you could encode rules from Strunk & White [Strunk: http://www.bartleby.com/141/].