schrödinger's dog

A Steaming Pile

What a steaming pile of doodoo compiz is. On a lark I turned it on today and it caused some annoying repaint problems in my konsole session. I googled some solutions, tweaked my xorg.conf file and tried again. This time it completely barfed on my desktop when I opened a PDF. It then locked up my machine.

"Compiz: just say no."

On the other hand, turning on the compositing in Metacity works nicely for drop-shadows. All that other eye-candy is pretty worthless, but drop-shadows actually help your brain work with multiple overlapping windows. This isn't well know, but you can turn it on by opening gconf-editor and finding apps->metacity->general, then clicking on the "compositing_manager" check box.

Jim on 10.19.09 @ 08:12 PM ET [link]

Comhaltas Ceoltóirí Éireann

Comhaltas Ceoltóirí Éireann (CCE) is an organization that promotes Irish music worldwide. There is a branch in Boston that provides lessons in traditional Irish music on harp, fiddle, whistle, bodhrán, accordion, and concertina. I've been studying there with Christian Stevens, a wonderful American Irish concertina player. (The music link to the tune The Moving Cloud on Chris's home page from his band Junior is an excellent example of contemporary Irish concertina playing).

Jim on 10.17.09 @ 08:38 PM ET [link]

Haskell

This weekend was spent learning Haskell, or a least starting to learn it. Haskell is a purely functional programming language that's really starting to surge in popularity.

After looking through several Haskell tutorials on the web, I've found the best to be Learn You a Haskell for Great Good by Miran Lipovača. His tutorial isn't quite finished, but what's there is quite good, complete with cute little hand-drawn pictures.

As an example, here is Quicksort first in Perl:


sub quicksort
{
    my @a = @_;
    !$a[0] ? () :
        (quicksort(grep {$_ < $a[0]} @a[1..$#a]),
         $a[0],
         quicksort(grep {$_ >= $a[0]} @a[1..$#a]));
}

and in Haskell:


quicksort :: (Ord a) => [a] -> [a]  
quicksort [] = []  
quicksort (x:xs) =   
    let smallerSorted = quicksort [a | a <- xs, a <= x]  
        biggerSorted = quicksort [a | a <- xs, a > x]  
    in  smallerSorted ++ [x] ++ biggerSorted

My biggest beef with Haskell so far is the same one I have with Python: whitespace matters. Fortunately, you can use curly braces and semicolons instead of whitespace for formatting. It just takes some serious time to determine how to use {;} properly since almost all posted examples use whitespace formatting.

Once I have the nuts and bolts of Haskell under my belt the next thing is to try to apply it to actual real-world problems rather than the toy problems seen in tutorials. The shift from procedural to functional languages requires a real shift in the way you think.

I've also started looking through the related book by Mark Dominus, Higher Order Perl, which treats Perl as a functional language and shows how to use recursion, iterators and closures to maximum effect. It's an excellent book and I'm considering paying for the dead tree version. There's a free PDF of his book available, too.

Jim on 10.11.09 @ 03:58 PM ET [link]

Windows 7 Snapshot

Gooey Fun

A Steaming Pile

Comhaltas Ceoltóirí Éireann

Haskell