November 27th, 2004

  • evan


I tend to get really into technologies and then drop them a year later. I think it's only natural; the only way to really learn [x] well is to become an [x] bigot, drink the [x] kool-aid, and actually use [x] for real projects for a while.

This is why I still don't have a good impression of lisp. I know I could get a program or two written if I needed to (and I understand the theory well enough to help students in an intro programming course), but I haven't really embraced it enough to get a fair picture.

So, a summary of things I have embraced and my ultimate decisions:
  • Python -- not so much. There's something fundamental about the approach to the language that I don't get along with, and it pokes its head out in many different ways, from ugly bindings, to len() not being a method, to the type/class distinction they used to have. It's ironic that a language that prides itself on cleanliness (no curlies!) can be so ugly (so many underscores!). However, the generators stuff is pretty cool (remind me to write a post in the future about generator expressions vs Haskell generators).

  • Ruby -- I recently returned to Ruby for a short project, and I'm surprised and happy to report it was even more enjoyable than I remembered. Their slogan is "the principle of least surprise", and there was a multitude of times where I encountered a problem, thought to myself, "the language ought to have [x]", and checked the reference to find it was there. Truly a joy.

  • O'Caml -- interesting in a different way. There are definitely some rough edges (namespace problems with record names comes to mind) and a general clunkiness beyond the language level (the Makefile/library infrastructure leaves much to be desired) but the ultimate radness of static typing and type inference shines through. Tied with Ruby, maybe -- the only reason I always post about O'Caml is because it has much more interesting theory and design work going on.

  • Haskell -- needs more investigation. May replace O'Caml in this journal as it's even more theoretic and researchy.

  • FreeBSD -- jeffr assures me of the kernel superiority, and the consistency of the documentation can't be argued. I was really impressed as well by the software RAID stuff. Once you get kinda usery it falls down for me, though; despite ports being reportedly simple I've had plenty of problems with it. And (as a representation of the problem) their Unicode support is reportedly terrible. My summary would be: if it was down to a generic Linux vs. FreeBSD, I'd probably pick FreeBSD. But there's also:

  • Debian -- a religious experience, both on a technical and social level. Either you believe or you don't, and I [don't need to / can't] convince you anyway. Somehow I just see past the flaws, though I know they're there.

  • Powerbooks -- such sweet sweet machines, but so expensive! If you're running Linux, I'm sorry to say that a well-supported x86 laptop will be more bang for the buck. If you're considering something non-Linux, though, I can't imagine getting anything else.

  • OS X -- it makes me a little sad because there's so much good technology there, especially in the audio and video, but I'm reluctant to make any software for it because it'll only be usable by a small fraction of the population, most of whom wouldn't share anything back with me. But (and I'm sure you already know this) against Windows there's no contest, so I have no problem endorsing it when friends buy computers. And I still use it.

  • arch -- I think the fundamental model is sound, but the implementation is so warty it hurts my head. (How do you convert a normal repository into a web-accessible repository? echo 'it sure does' > =meta-info/http-blows; tla archive-fixup -A my-archive) And, as that last remark exemplifies, the guy who makes it is kind of a jackass. (Which I'm especially sad to write, 'cause I have such a small window on to the guy, just his website and mailing list posts, and even though I really tend to give people the benefit of the doubt, I still have a really negative impression of the author.)

  • LiveJournal -- brad is brilliant, the community is great, but the aimlessness of design kinda throws me off. It sorely needs a Jobs to complement his Wozniak. Once or twice when the LJ's been really slow I've batted around the idea of moving all this to my own site, but all other "blogging" software I've looked at sucks so much more that I've always put it off. Definitely superior if you see these journals as a fundamentally social activity (which I do -- comments are not only useful, but central). As far as general web publishing goes there are likely other approaches that suit your problem space better.

  • gmail -- I don't use it for my personal mail; I have all sorts of procmail craziness going on that gmail can't do, and I don't know how I feel about using a, um, "web site" for mail. But I do use it for work mail and I have to say it's truly indispensable for managing information overload. I tried some other mail setups (mutt, evolution, and Matt tried and gmail wins hands down. It'd be even better as a native app, but its strengths make up for its non-nativeness.

  • GTK -- Maybe it's just because I've been looking at it for so long, but I think the design is elegant (or -- better -- as elegant as you can get given the technology it's based upon). But man, writing C apps for GTK is like pulling teeth. And there's still some O(n^2) problem with their text boxes; I can't even scroll my cursor through this (single-line, huge) paragraph without serious slowdown.

  • Gnome -- if they'd stop rewriting everything with each revision, they'd probably get somewhere. The newer versions are surprisingly good, but that may only be because the previous versions were so bad.
I think the next thing to investigate will be darcs.
  • evan

nerding out: spamassassin cutoff

Gather your SpamAssassin scores:
trout:~/Mail/danga/spam/cur% grep 'X-Spam-Status' * | sed -e 's/.*hits=//' | sed -e 's/ .*//' > ~/n
Then, in R:
> n = read.table('n')$V1
> summary(n)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
-38.800  -4.900  -4.900  -3.564  -1.400   4.000 

So if I lowered the cut off to 4, I'd have...
> length(n[n < 4]) / length(n)
[1] 0.9976526

99.7% accuracy.
> length(n[n < 3.5]) / length(n)
[1] 0.988263

One of the messages I'd lose, with a spam score of 3.9, is from my ex inviting me to dinner. I think it's 'cause it's HTML and it has a disclaimer footer inserted by her job.

( I posting too much?)