Can’t get to IRC because port 6667 is blocked on your local network? Here are some instructions for how to create a SSH tunnel using  PuTTY, and then connect to freenode (or any other IRC server) with Pidgin using the tunnel as a SOCKS5 proxy. You can most likely s/Pidgin/your IRC client of choice/, but the screenshots below will show the Pidgin config dialogs. These instructions also assume that SSH, port 22, is not also blocked. Woe be to you if that is the case.

My original source for how to do this was this post, which describes the same trick but for FireFox.

Step 1: create a new PuTTY session configuration. In this case I using the login me@ssh.example.com and calling the session irc-7777. I usually name the session based on the local port number I’m going to forward.

create and save a new PuTTY session

Step 2: go to the Connection -> SSH -> Tunnels node of the session config. In the Source port field enter “7777″ (or some other port number). In the radio button section below that select Dynamic and Auto. Click the Add button. You should see “D7777″ appear in the list of forwarded ports.

Configure the ssh tunnel

Tunnel D7777 appears in the list

Step 3: go back to the man session config node and save the session again. Then open the PuTTY session by clicking the Open button. A normal looking PuTTY terminal window should open. This session is your tunnel so you should probably leave it be. i.e., don’t use it for doing stuff in the shell and as a tunnel (although I don’t really know what consequences that would lead to). If the fact that this tunnel takes up space in your TaskBar (it does me) check out PuTTY-Tray.

You've probably never seen one of these before

Step 4: Configure your Pidgin IRC account to use the tunnel as a SOCKS5 proxy. Go to Accounts -> Manage Accounts. Highlight your IRC protocol account and click Modify (or create one by clicking Add). Go to the Advanced tab of the config dialog. In the Proxy Options section select SOCKS5 as the proxy type, enter “localhost” as the Host and “7777″ (or whatever port you used) as the Port.

Specify your local tunnel as the SOCKS5 proxy

Save and that’s it. You should be able to connect to IRC server through Pidgin.

On a *nix machine (or using Cygwin, I suppose) this is, of course, much simpler. You can replace the PuTTY steps with a single ssh command: ssh -D localhost:7777 me@ssh.example.com

I was playing around with the idea of parallelizing something the other day to eke out some performance. Unfortunately, I’ve gotten a bit rusty since writing some MPI code for a parallel computing course a few years back. I got stuck on what should be the simple part of dividing up my input across the threads.

The goal is to divvy things up into continguous blocks of roughly equal size. i.e., if the size of your input is 38 (n) and you start four threads (p) you don’t want to give the first three threads chunks of 12 and the last thread gets 2. You want slices of 10, 9, 10 and 9.

So I flailed away with loops and the POSIX::floor for little awhile and came pretty close to what I remembered. I had to finally drag out my textbook (and translate from the C Macros) to get it right.

#!/usr/bin/perl

# Block Data Decomposition:
# Divide array n into p contiguous blocks of roughly equal size

use POSIX qw(floor);
use strict;

sub block_start {
    my ($i, $p, $n) = @_;
    return floor(($i * $n) / $p);
}

sub block_end {
    my ($i, $p, $n) = @_;
    return (block_start($i + 1, $p, $n) - 1);
}

my @input = get_input();
my $n = scalar @input;
my $p = 4;

for my $i (0..$p-1)
{
    my $start = block_start($i, $p, $n);
    my $end = block_end($i, $p, $n);
    my @range = @input[$start..$end];
    do_something(\@range);
}

The idea is that

sends a slice of input off for processing by one of your threads. A pretty useful algorithm when doing this sort of thing. Certainly not rocket science. Which is why we should all be happy I’m not a rocket scientist.

To cut to the chase, I extracted the hCal events from the 2009 conference schedule and fed them into a Simile Timeline. I then linked each event to the corresponding slice of my IRC client log. If you want to take a look it’s here.

I don’t remember what initially sent me there, but my introduction to Code4Lib was through the IRC channel. I’ve been logged in there off and on ever since. It keeps me informed and entertained and, yes, occasionally distracted. I’ve since attended all four of the yearly conferences, met and meatspace-friended a good percentage of the #code4lib regulars, contributed a patch here and there to a couple of projects, and helped organize a one-day regional gathering. I guess you could say at this point that I’m pretty fond of the whole thing.

This is why I take it somewhat personally when the annual hand-wringing debate begins over the perceived “cliquishness” of the community. There was much fuss this year–an awkward amount, even, IMO–over 1st-timers vs. old-timers. I make it a point to try and sit with people I don’t know during the lunches and shake a few hands. Lots of folks do the same for dinner.  Basically, IMO, if you feel like an outcast n00b, YOU’RE NOT TRYING HARD ENOUGH.

There is, however–and maybe I have a bit of “I haz a straw man. Let me show u it” going on here, but anyway–an aspect of the “code4lib is just a big fat secretive, juvenille high school-ish in crowd” argument where I think we majorly fail, and that is the non-open nature of the backchannel.

I met a lot of awesome new people over the past few days attending the 4th code4lib conference in Providence, RI, Jon Phipps of the NSDL MetaData Registry. I was a little suprised to read he didn’t enjoy the program, but that’s cool. I give him big props for calling it as he sees it. The part that got under my skin, because he’s totally right, was his mention of “the hugely active IRC back channel of ongoing commentary (which really should be displayed where everyone including the presenters can read it)”. This simply rang true to me.

Let me first say what I’m not saying: I do not think it’s rude and unfair that a bunch of us (100+, depending if you count those not physically present at the conf) are carrying on a parallel conversation while the presenters we have invited are getting up on stage and sharing projects and ideas that they care deeply about and have slaved over. This is the nature of our beast. To paraphrase something BillDeuber said in channel yesterday, is the channel and extension of the conf, or vice versa? I think the latter.

But I do think it’s rude and unfair that we are carrying on an un-open and inaccessible parallel conversation while the presenters we have invited are getting up on stage and sharing projects and ideas that they care deeply about and have slaved over.

The funny thing is, this reasoning is not what first prompted me to put my chat log up on the web. I did it because Corey Harper asked if I’d email him the section from when he was presenting at the linked data preconf and I figured others might like the same courtesy. I also thought Timeline would be a cool project to experiment with. I’ve since had a few conversations about whether or not it’s fair to the people in-channel who maybe didn’t realize what they were saying was going to be published later on. But if someone is accusing you of being cliquish and secretive, how is the proper response not to be more open and transparent? To say, “Here, take a look. See for yourself.”

This is probably making it seem like there must be some really juicy shit going on in the back channel, but that’s exactly the thing: there’s really not. It never gets any snarkier than your typical MST3K episode. And would anyone argue that Joel, Mike, Crow and Tom Servo didn’t really, deep down, love those old, bad movies they were forced to watch?