Musings on my contributions to and membership of the perl community

Fri Jun 19 17:30:00 2009

Digg! submit to reddit Delicious RSS Feed Readers

Possibly this is a bit of an odd post, but I'm feeling kind of introspective at the moment.

Anyway ...

I've been thinking about the various stuff I've been involved in since I first got into the perl community, and what the things I've done mean to me, and what they might mean to other people.

But first, rewind a little bit to where the journey started.

It started early in 2004 when I'd been messing around with using GNU guile and call/cc to produce a non-event-driven control software layer over the top of POE (I later re-attempted to do with with MLEHMANN's coroutine stuff before eventually realising that Coro::AnyEvent plus AnyEvent's POE support was sufficient, but by that time the client had missed their next round of funding and vanished into the aether).

So, I discovered I couldn't pass an array of stuff including a continuation out from guile space to perl space, swore a lot, and in spite of my appalling incompetence at C (which mostly persists to this day) managed to produce a fixed version. Then I mailed Sam Tregar with the patch and asked him to ship a release. He replied saying he didn't have time and wasn't really using that code anymore, but suggested that if I really wanted the fixes on CPAN I should sign up for a PAUSE account and he'd give me permissions to ship it myself.

I did, he did, and my release of Guile.pm is still the latest and probably horribly broken again because I don't use that code anymore (anybody want it? drop me a mail :). But now I had a CPAN id, and I started thinking about things I could release.

The following year, I wandered onto #catalyst on irc.perl.org because I was poking around at doing something moderately crazy with web dispatching, chatted to the development team and discovered I'd found a home. Not long after that, Marcus Ramberg mentioned he didn't really have time to run the Catalyst subversion repository anymore and asked for volunteers.

I put my hand up, and now Shadowcat hosts most of the infrastructure for the Catalyst and DBIx::Class projects along with the repositories for Reaction and Moose and their related projects.

Of course, DBIx::Class didn't exist at that point - it was born out of a combination of (a) me getting hugely tired of helping with Class::DBI problems on #catalyst, (b) being sick of having to say "no, we can't do that for a reasonable amount of money" to clients and (c) a conversation with Tony Bowden based on my work on Class::DBI::Sweet where we came to the conclusion that the existing codebase couldn't be sensibly refactored and it was worthwhile starting again greenfield.

Somewhere around then I started hacking on the Catalyst dispatcher and got told to give myself a commit bit and later became part of the core team, and much later a similar loss of temper moment to the one that inspired DBIx::Class - this time over helping people set up homedir installation for CPAN modules - produced the local::lib module, but I'm very definitely getting off the point now.

Oh, and of course rather than create a Catalyst foundation, and a Moose foundation, and a ... a group of us who care about the new perl enlightenment formed the Enlightened Perl Organisation to promote and further the community. And Shadowcat ended up running the european half of irc.perl.org. And I guess a bunch of other things - the Devel::REPL interactive shell fell out of my attempts to write email processing scripts I didn't hate maintaining (plus my previous attempt to blog), I wrote the original version of Devel::Declare which powers such wonders as Florian Ragwitz' MooseX::Declare and there's probably some other interesting things that I've completely missed.

So ... which of the above is my most important contribution to the community?

I suspect a lot of people would say my work on Catalyst and DBIx::Class is it, because of their wide user base and the stable, extensible platform they've provided to the community for building web and database applications.

I know Shadowcat's Systems Administrator would say that local::lib is it, because of the abilities it gives him to compartmentalise dependencies for applications so he doesn't have to worry about upgrading a module for one and accidentally breaking another in the process.

I think Stevan Little, creator of Moose, might claim that Reaction has been the most personal use to him since while he's never used it, the writing of it shook out a lot of interesting edge cases in Moose during the early days and provided the proving ground for Devel::Declare before Florian took it over, fixed my crappy C, and made it mainstream with MooseX::Declare (and because Stevan stole the "automatic strict and warnings" thing from Reaction, even if he forgot to credit me in the code ;).

As for me? I say none of the above.

In fact, I don't think that any of the code I've written has really been that important, except in a few cases where nobody else would believe it was possible and I had to write a first cut to prove to them it was - and in most of those somebody else then went away and wrote a much better version now they could see it could be done.

And that is part of what I think is important. Every time somebody reports a bug in a module of mine, I try and talk them into writing up a test case and then walk them through writing a patch. Once the patch is good, I try and convince them to let me give them access to commit it themselves. If one person makes substantial contributions towards a particular release, I do the same thing Sam Tregar did to me and get them to get a PAUSE account, hand them co-maint and get them to upload it rather than me.

Every time I see somebody talk about an interesting feature idea on IRC or on a mailing list, I try (or these days one of the people who's been around on the projects for a while tries before I get there) and work out with them how it could be implemented, and talk the idea through until they're confident enough to implement it themselves. Then once again I throw a commit bit at them (sometimes several times before they believe me and let it stick) and with a bit of luck we end up with a new contributor.

I think in the past year, I've probably spent the majority of my open source time convincing people that there's no such thing as not being good enough to contribute, and talking people through design work, and often just acting as a sounding board while a smart person who doesn't yet believe they're smart works out their ideas, and even occasionally just being somebody the other person respects saying "yes, this is good, you should do it" (if they saw the number of stupid mistakes I make before publishing the code that works maybe they wouldn't believe that, but I try and keep the mistakes in my head and only start writing when I have some idea what I'm doing, but anyway ...).

Perhaps in the past two years, now.

And you know what? I love it.

One man can only write so much code. By yelling "well volunteered" and by all the other things I do, I've helped cause a vast amount more code to be written than I could ever have written myself, and much of it by people who were closer to the particular problem than me so probably had a much better idea of what was required and how to test it effectively.

Better still, I've watched so many people go from raw newbie with no confidence to experienced contributor, helping the next batch of raw newbies overcome the shock of being told they should try and have a go themselves and get them to the "wow" moment of their first patch, their first commit, their first CPAN release. I've given out at least a hundred commit bits in the past couple years and I think people I've given them out to have given out a couple hundred more between them.

When I first realised this was happening, I was kind of upset, because you know, I actually really enjoy programming. Then I asked myself what I cared about the most. And the answer was that it wasn't "writing lots of cool code", it was "making the most amount of cool code be written", with a side order of "making people into better, happier, more confident programmers and watching them achieve things I didn't think were possible".

So to every person who didn't run away fast enough when I yelled "well volunteered" at you, to every person who put up with my abrasive profanity to hear the ideas I was trying to get across, to every person who submitted a patch to anything I've ever been involved in, whether directly or indirectly through something I said or did or just because they felt like it, I say this:

I'm proud of you all. Thank you for making the community a more fun place to be. Thank you for making the world a better place. Thank you for being shoulders to stand on when I was stuck.

Most of all, thank you for providing the motivation that keeps me keeping talking the next person into contributing even when things get too much and I feel like I'm losing my way.

-- mst, out.