Free Software

  • strict warning: Non-static method view::load() should not be called statically in /var/www/ on line 906.
  • strict warning: Declaration of views_handler_argument::init() should be compatible with views_handler::init(&$view, $options) in /var/www/ on line 0.
  • strict warning: Declaration of views_handler_filter::options_validate() should be compatible with views_handler::options_validate($form, &$form_state) in /var/www/ on line 0.
  • strict warning: Declaration of views_handler_filter::options_submit() should be compatible with views_handler::options_submit($form, &$form_state) in /var/www/ on line 0.
  • strict warning: Declaration of views_handler_filter_node_status::operator_form() should be compatible with views_handler_filter::operator_form(&$form, &$form_state) in /var/www/ on line 0.
  • strict warning: Non-static method view::load() should not be called statically in /var/www/ on line 906.
  • strict warning: Declaration of views_plugin_style_default::options() should be compatible with views_object::options() in /var/www/ on line 0.
  • strict warning: Declaration of views_plugin_row::options_validate() should be compatible with views_plugin::options_validate(&$form, &$form_state) in /var/www/ on line 0.
  • strict warning: Declaration of views_plugin_row::options_submit() should be compatible with views_plugin::options_submit(&$form, &$form_state) in /var/www/ on line 0.

Slash code to drupal conversion, finally done!

[[updated feb 17 to include info on redirecting old slashcode urls to the new drupal urls]]

Started as part of a workshop I did at the 3rd NYC Drupal Camp on converting to/from drupal, I have finally finished converting the Autonomedia/Interactivist Info Exchange site from slash to drupal. It will relaunch soon at

While it might have been somewhat more "correct" for me to have written a php script that bootstrapped drupal and then just grab the data and pass it through drupal's user and node api's, I was stubbornly determined to convert the site by only writing sql queries between the databases.

Part of my reasoning for doing this sql only was that converting thousands of nodes and users via the drupal api can take forever, where direct database manipulation is fast.

While I will write this up better later and post it to, I wanted to get it up before I got distracted onto other tasks.

so, without further delay: here are the step by step notes I took as I went through the process.
[much thanks to Blake Carver of LIS News for the motivation to finish and the queries that populate the node and node revisions tables]

first step:
setup two databases; one for drupal one for slash
in this example they are
autono_slash and autono_drupal

install drupal

go to modules config page and make sure all the modules you need are on:
in my case I had to turn on


Create taxonomy vocabularies for the topics and sections of slashcode

make note of the vid's for those vocabularies
in my case:

In order to make tagging of old content easier at a later step, we add in a column to the term_data table here that we will delete at the end of the process

ALTER TABLE `term_data` ADD `oldid` VARCHAR(5) NULL;

Now we move over terms for Sections (vid1)

INSERT INTO autono_drupal.term_data (vid,name,oldid) SELECT "1",title,id from autono_slash.sections;

And the same for Topics (vid2)

INSERT INTO autono_drupal.term_data (vid,name,oldid) SELECT "2",alttext,tid from autono_slash.topics;

Next we set all terms at having no parent terms

INSERT INTO autono_drupal.term_hierarchy (tid,parent) SELECT tid,"0" from autono_drupal.term_data

At this point you can check in the taxonomy admin page to see that your terms have been moved over.


This is the simple part.

drupal uses uid 0 for anon, slashcode uses uid 1 for anon

so, the primary admin of a slashcode site is usually uid2

this allows you to setup your drupal site, create a primary admin (uid 1) and not have any problems moving over your user data (no collision of ids)

later we'll set content and comments that should be anon from uid 1 to uid 0.

INSERT INTO autono_drupal.users (uid,name,mail,pass,status) SELECT uid, nickname, realemail, passwd, "1" FROM autono_slash.users WHERE uid >1;

Set user roles

create new user roles manually in drupal. you might need more roles depending on the various seclev settings you are using in slashcode. for my use I need the following in addition to the standard drupal roles:
blog user
site admin
full admin

make note of the rid's for those roles
in my case:
blog user=3
site admin=4
full admin=5

for my site, I'm using those with slashcode seclev of 99 or higher = blog user, 200 or higher = site admin, 800 or higher = full admin

INSERT INTO autono_drupal.users_roles (uid,rid) SELECT uid,"3" from autono_slash.users where seclev > 99;

INSERT INTO autono_drupal.users_roles (uid,rid) SELECT uid,"4" from autono_slash.users where seclev > 200;

INSERT INTO autono_drupal.users_roles (uid,rid) SELECT uid,"5" from autono_slash.users where seclev > 800;



now we create a temporary table in the database that will be used to create all content.

it is a merger of the node table and the slash story table

CREATE TABLE autono_drupal.slash_content_convert (
nid int( 10 ) NOT NULL auto_increment,
sid varchar( 16 ),
tid smallint( 5 ),
newtid smallint(5),
uid mediumint( 8 ),
title varchar( 100 ),
dept varchar( 100 ) default NULL ,
time datetime,
hits mediumint( 8 ),
section varchar( 30 ),
discussion mediumint( 8 ),
submitter mediumint( 8 ),
day_published date,
last_update timestamp,
body_length mediumint( 8 ),
word_count mediumint( 8 ),
vid int( 10 ),
type varchar( 32 ),
status int( 4 ),
comment int( 2 ),
promote int( 2 ),
moderate int( 2 ),
sticky int( 2 ),
body longtext,
teaser longtext,
log longtext,
timestamp int( 11 ),
format int( 4 ),

now we move over the content!
the main idea here is to move the stories over and get a nid/sid relationship created by the auto increment column

first standard slash "stories", the primary content type for slashcode become story nodes (note the type of "story" in the select/insert)

INSERT INTO autono_drupal.slash_content_convert (sid,tid,uid,title,time,section,discussion,submitter,day_published,last_update,teaser,body,type)
SELECT autono_slash.stories.sid,autono_slash.stories.tid,autono_slash.stories.uid,autono_slash.stories.title,autono_slash.stories.time,autono_slash.stories.section,autono_slash.stories.discussion,autono_slash.stories.submitter,autono_slash.stories.day_published,autono_slash.stories.last_update,autono_slash.story_text.introtext,autono_slash.story_text.bodytext,"story" from autono_slash.stories join autono_slash.story_text on autono_slash.stories.sid = autono_slash.story_text.sid;

next we move over the slashcode journals preparing it to become blog content.

INSERT INTO autono_drupal.slash_content_convert (tid,uid,title,time,discussion,body,type)
SELECT autono_slash.journals.tid,autono_slash.journals.uid,autono_slash.journals.description,,autono_slash.journals.discussion,autono_slash.journals_text.article, "blog" from autono_slash.journals join autono_slash.journals_text on =;

soon we'll come back to content and move things to the drupal node/revisions tables, but first we prepare comments in the same way as we did content

create a unified table combining critical elements of both schema, essentially this is a subset of the drupal comment table with the sid of slashcode. the important thing is that this will be used to combine journal "discussions" with story comments, as drupal does not make the same distinctions that slash does. (we will add name and email fields for comments after comments are converted to make the queries more simple to follow (fewer joins)

CREATE TABLE autono_drupal.slash_comment_convert (
cid int(11) NOT NULL auto_increment,
pid int(11),
nid int(11),
uid int(11),
subject varchar(64),
comment longtext,
timestamp int(11),
comment_date datetime,
format int(11),
thread varchar(255),
name varchar(60),
mail varchar(64),
discussion int(11),
oldcid int(11),
oldpid int(11),

INSERT INTO autono_drupal.slash_comment_convert (uid,subject,comment,comment_date,oldcid,oldpid,discussion)
SELECT autono_slash.comments.uid,autono_slash.comments.subject,autono_slash.comment_text.comment,,autono_slash.comments.cid,,autono_slash.comments.sid from autono_slash.comments join autono_slash.comment_text on autono_slash.comments.cid=autono_slash.comment_text.cid;

now... at this point in my work, I realize that we might just need to use the slashcode discussionID as nodeID to make it all easier; as well we might just need to keep the old cid and pid's as well.

so for that we alter the node and comment table
ALTER TABLE `comments` CHANGE `cid` `cid` INT( 11 ) NOT NULL


clean up and sync of meta data (taxonomy, etc)

we need to set the newtid to the drupal term id instead of the slash topic id

update autono_drupal.slash_content_convert set newtid = (select tid from term_data where oldid=slash_content_convert.tid and vid=2);

next we need to map the slash section column with the drupal tid
mysql> select distinct section from slash_content_convert;
| section |
| articles |
| features |
| Events |
| BookReviews |
| news |
| the_new_war |
| analysis |
| announcements |
| books |
| |
| rnc |
| NULL |

| tid | vid | name | description | weight | oldid |
| 1 | 1 | Articles | NULL | 0 | 1 |
| 2 | 1 | Announcements | NULL | 0 | 2 |
| 3 | 1 | Events | NULL | 0 | 3 |
| 4 | 1 | All Sections | NULL | 0 | 4 |
| 5 | 1 | Analysis & Polemic | NULL | 0 | 5 |
| 6 | 1 | Reviews | NULL | 0 | 6 |
| 7 | 1 | News | NULL | 0 | 7 |
| 8 | 1 | At the Brink | NULL | 0 | 8 |
| 9 | 1 | Books | NULL | 0 | 9 |
| 10 | 1 | Index | NULL | 0 | 10 |
| 11 | 1 | RNC 2004 | NULL | 0 | 11 |

update autono_drupal.slash_content_convert set section=1 where section="articles";
update autono_drupal.slash_content_convert set section=2 where section="announcements";
update autono_drupal.slash_content_convert set section=3 where section="Events";
update autono_drupal.slash_content_convert set section=1 where section="";
update autono_drupal.slash_content_convert set section=5 where section="analysis";
update autono_drupal.slash_content_convert set section=6 where section="BookReviews";
update autono_drupal.slash_content_convert set section=7 where section="news";
update autono_drupal.slash_content_convert set section=8 where section="the_new_war";
update autono_drupal.slash_content_convert set section=9 where section="books";
update autono_drupal.slash_content_convert set section=1 where section is NULL;
update autono_drupal.slash_content_convert set section=11 where section="rnc";

move all comments and content tagged as uid1 to uid0

update slash_comment_convert set uid=0 where uid=1;
update slash_content_convert set uid=0 where uid=1;

turns out that some journal entries don't have discussion id's. so to fix this and make sure I did not use a nid already in use

update slash_content_convert set discussion=(nid+5000) where discussion is NULL;

move nodes to node table and revisions table

insert into node (nid,vid,type,title,uid,status,created,changed,comment,promote,moderate,sticky) SELECT
"2","0","0","0" from slash_content_convert;

insert into node_revisions (nid,vid,uid,title,body,teaser,log,timestamp,format) SELECT
"Imported From Slashcode",
"1" from slash_content_convert;

move comments to comments table

insert into comments (cid,pid,nid,uid,subject,comment,timestamp,status,format,thread) SELECT oldcid,oldpid,discussion,uid,subject,comment,UNIX_TIMESTAMP(slash_comment_convert.comment_date),0,1,'01/' from slash_comment_convert;

update node_revisions set teaser = body where teaser ="";

set taxonomy terms for nodes based on section and tid

insert into term_node (nid,tid) select discussion,tid from slash_content_convert;

insert into term_node (nid,tid) select discussion,section from slash_content_convert;

some nodes came over with out body copy

update node_revisions set body = teaser where body ="";

reset nid and cid as auto_increment

set sequences, for no real logical reason I wanted to add 10 to the highest node/comment/user id when I set the sequences table.

update sequences set id=(select uid from users order by uid desc limit 1)+10 where name="users_uid";

update sequences set id=(select nid from node order by nid desc limit 1)+10 where name="node_nid";

update sequences set id=(select vid from node_revisions order by vid desc limit 1)+10 where name="node_revisions_vid";

and with that, we're done

I still have some more modules to put in.

I could put in userpoints and move over old user's karma

I should put in captcha and recaptcha for preventing spam

I need to put in the event module and start using event nodes instead of stories for the events section.


i screwed something up, so I had to do the following to get the blog content in the node_revisions table

UPDATE node_revisions LEFT JOIN slash_content_convert ON node_revisions.nid=slash_content_convert.discussion SET node_revisions.body= slash_content_convert.body WHERE slash_content_convert.type="blog";

UPDATE node_revisions LEFT JOIN slash_content_convert ON node_revisions.nid=slash_content_convert.discussion SET node_revisions.teaser= slash_content_convert.body WHERE slash_content_convert.type="blog";

then I realized I did not move over the account creation date and last access dates. this confused the initial test users so I added it in

update autono_drupal.users left join autono_slash.users_info on autono_drupal.users.uid=autono_slash.users_info.uid set autono_drupal.users.created = UNIX_TIMESTAMP(autono_slash.users_info.created_at);


ok, now it's time to launch the site and get the old slash urls redirecting to new urls

make a table for this in the drupal db
CREATE TABLE `slash_redirects` (
`sid` VARCHAR( 36 ) NOT NULL ,
PRIMARY KEY ( `sid` )

then populate that from the slash_content_convert table
insert into slash_redirects (sid,nid) select sid,discussion from slash_content_convert where sid !="";

now, we need to write a simple perl script to handle taking calls to, parsing out the sid and sending a 301 redirect to the browser. this hopefully will keep the damage to search engine listings to a minimum and preserve people's bookmarks to specific old content

here is my script

#!/usr/bin/perl -w
use strict;
use CGI;
use DBI;
my $query = CGI->new();
my $sid=$query->param('sid');
my $nidquery='SELECT nid FROM slash_redirects WHERE sid ="'.$sid.'"';
my %varinfo = do 'hide/vars.txt';
my $dsn = "dbi:mysql:$varinfo{sqldbname}:localhost:3306";
my $dbh = DBI->connect($dsn, $varinfo{sqldbuser}, $varinfo{sqldbpass});
my $sth= $dbh->prepare($nidquery);
my $nid;
my @nidresult=$sth->fetchrow_array();
my $nodetogoto="".@nidresult[0];
my $q = CGI->new();
print $q->redirect(
-location => $nodetogoto,
-status => 301,

the script calls in db user/pass info from an external file that is protected from download/access by .htaccess

the var file is in the following format

sqldbserver => 'mysql',
sqldbname => 'database_name',
sqldbuser => 'database_user',
sqldbpass => 'db_password',
sqldbhost => 'localhost',


Nice conversion

I understand how much trouble that probably was and why you did it.

I came across this article searching for some unrelated drupal answers.

nice to hear from you simon

thanks for the compliment (and it is good to hear from you again)

Sorry for a dumb question,

Sorry for a dumb question, but I really can't get, what SELECT is?...

I seem to be having some

I seem to be having some trouble with the script


post some details and I'll help you out. what's the exact error you are seeing in the browser, and are there any errors in the apache logs?

Thanks for sharing your knowledge

Thanks for sharing your knowledge dude ! It works well for me !

Any thoughts/advice one year later?

I need to launch a site that works like Slashdot, but just the thought of using Slashcode & Perl is intimidating, so had been looking unsuccessfully for a Drupal-based site and came across your site

Just curious if, one year later, you'd do anything differently? Is there a way to get Slashcode functionality without having to install Slashcode?

Thanks in advance, and thank you for the notes!

it depends on what features are most critical to you

even though I don't get to use it often anymore, I still love perl. The more I use php, the less I like it and the more I want to go back to perl.

But, I could never go back to using slashcode.

You can get most, if not all, of the features of slashcode with any number of different Free Software tools these days. I am really happy with Drupal, the size of and activity of the community makes up for my hate of php. I've used bricolage for some projects and want to look more at joomla and cms made simple.

I'd suggest you write up a detailed list of functionality that you want and do a comparison of drupal, joomla, bricolage, cms made simple, and even plone. Each has strengths.

It's a shame that slashcode abandoned any idea of community in favor of exclusively developing for sometime back in 2002 or so. It could be where Drupal is now if they had taken a different path. Think about it: before anyone used the word Blog, there was the journal feature of slashcode; before anyone friendstered or facebooked, slashcode had a friends/foes system. But without a community to use it and move it forward, it stagnated and is, in my opinion, dead as anything other than the tool that runs

To directly answer your question: A year later, I think I made the right choice. The few things I gave up are far overshadowed by the strength of drupal as a tool and a community.

Now that is what I call an

Now that is what I call an excellent post, thanks...

Yes very good post, I agree

Yes very good post, I agree .


great work and thanks

It is great to see a lot of people supporting drupal, no wonder it is getting more popular from time to time.
Great work and keep it up.

great site! I'm so glad I

great site! I'm so glad I came across it. so many wonderful pieces of advice! exactly what a new person in this stuff like I need:) have used to find great blogs with useful pieces of information by search engine, but always search for smth more. I really liked what your tutoial has to offer. Hopefully one day I will be in the possition to do stuff with drupal without looking up tutorials every step of the way. thanks!

thanks for the code,

thanks for the code, bookmarked

Hopefully one day I will be

Hopefully one day I will be in the possition to do stuff with drupal without looking up tutorials every step of the way. thanks!

Very nice step by step

Very nice step by step walkthrough, I'm installing slashcode in a new site, and doing some test.

Nice code

Thanks for the code. It is so helpful to me.

that's nice company to be in...

Openflows got a nice shout-out from radical reference member (and International Documents Librarian at Stanford University) James Jacobs who, when interviewed by Red Hat Magazine, listed Openflows Community Technology Lab as one of the inspirational forces in the creation of Stanford University's new Open Source Lab.

The Stanford Open Source Lab is an interesting experiment. "The vision of the Open Source Lab is to be a nexus on campus for the discussion, advocacy, and technical support of community-based technologies and information systems."

Being credited with helping to inspire such a project is high praise but to be listed along with groups like the Free Software Foundation, Oregon State University’s Open Source Lab, Drupal, and MIT’s Open CourseWare, well... that just made me blush.

another big lie: obscurity == security

I was doing some research today, keeping up on new developments in HIPAA compliant software. (HIPAA is U.S. law which regulates the portability, privacy and security of healthcare information)

On the site of a software company that is selling a "secure email system" that they claim is HIPAA compliant, I found the following completely ignorant statement about the relationship between security and free/open source software

"Why does SafetySend use Proprietary Code and Technology?
Because any code or technology that can be purchased is vulnerable. Generic security codes and technology is is considered 'at risk' because of its shared accessibility. SafetySend code and technology is exclusive and not sold or shared. If you can buy security technology, it can be compromised."

This is completely false and misleading.

Before I continue to rant, let me explain that there are two ways of looking at digital security: Security by obscurity or Security by design.

SafetySend believes that there product is secure because the code is kept secret (security by obscurity). There could be very serious holes, but they think that by keeping prying eyes away from the code that no one could ever figure out where the holes are. History has shown that keeping something secret rarely works to keep it secure.

The security by design camp believes that by releasing code for frequent and open auditing, code can truly be made secure. It is not a failure when a security hole is found via such an audit, it is part of the process, it is a good thing as it allows for that hole to be patched.

Technologists have to assume that the entire design of a security system is known -- at least to those that want to compromise your system. The only piece of data that must remain private is the cryptographic key, which also should be easy to regenerate from time to time (and not be a hard-coded part of the application).

Releasing code does not automatically mean it is vulnerable -- any code is vulnerable. The issue is how you handle that reality.

Think of it as the difference between hiding under your bed because you are afraid someone might pick your lock and learning how to pick locks (or hiring a locksmith that knows how to pick locks) to test and make sure your locks are secure.

When security related code is released in Free/Open Source Software, the developers explicitly deny the ideas of security through obscurity, we must design secure code. It has been argued that this publication of source code can actually improve security because the code can be peer-reviewed by anyone.

The end result is that bugs are found and fixed, instead of hidden. Many security holes that are ignored, for example, in proprietary operating systems have been found, published and patched in Linux. This is not despite the open nature, but due to the open nature of the code that it becomes more secure.

PGP is a publicly published codebase for encryption. The fact that it is public has not changed its status as a military grade encryption tool. The argument put forth by the folks at SafetySend to sell their product is completely false.

Keeping insecure code private does nothing to make it more secure or less vulnerable.


Every once in a while I find myself talking with a vendor who thinks they'll get anywhere by pulling that particular batch of wool over my eyes and it really pisses me off.

Too many organizations are overwhelmed by anxiety about security and don't really understand the difference between obscurity and real security. In my experience, many organizations also get stuck on the difference between open source software and publishing data for the world to see. I usually go back to the same lock analogy: security by obscurity means that you're relying on the lock-maker to be telling the truth (this lock is secure. trust me.) where as a free and open source lock, by necessity, is available for scrutiny. I can look over the lock design, take the lock apart and study its inner workings: if I do the leg work, I can *know* that this is a well designed lock. I'm not leaving it to trust.

The Free Software LOL-war

The king of LOL-stuff, I Can Has Cheezburger, is looking for a developer. That would be a fun project, however, their job announcement specifies that the code be done in Microsoft's .NET and not using Free tools.

This has started a bit of a LOL-debate about the use of Free/Open Source Software. I'd participate, but trying to read and write comments about a serious topic using lolspeak makes my head hurt.

The highlight so far:

why doesn’t you use a php flaverd intertube for da kittehs? and a ceiling cat approved apache server? everyone know IIS is the work of basement cat.

Open Source/Free Sofware: What it is, how to use and defend it in your Union

Dec 6 2008 4:30 pm
Dec 6 2008 6:00 pm

more info to come soon, this is one of the two panels I'm on at the upcoming LaborTech conference. this one is another incarnation of my Introduction to Free Software Presentation. This time with a Labor Union focus.


University of San Francisco
2130 Fulton St.
San Francisco, CA
United States

Internet Telephony, Cell Phones and Open Source For Labor

Dec 7 2008 12:00 pm
Dec 7 2008 1:30 pm

more info to come soon, this is one of the two panels I'm on at the upcoming LaborTech conference. this one is a discussion of using Open Source internet telephony, sms and other communications technologies for organizing.

my rant on Open File Formats is going to be published in Spanish!

I was contacted today by some folks in Spain that are publishing a book about Media Art Conservation. They found something I posted to the mailing list of the Institute for Distributed Creativity last year and want my permission to translate and publish it. I'm really excited.

more info on the IDC can be found at their website or on the archive of the mailing list at

It took me a while to dig up the post from my archive so I could decide if I wanted to give permission, I'm posting it here for no particular reason other than procrastinating other things I should be doing.

Subject: re: [iDC] shelf life

As someone who is a technologist and rather explicitly not an academic, I tend to lurk on this list and don't contribute often, however a lot of this conversation has missed something that I feel is very important so I've forced myself to take some time away from deadlines and add my thoughts to the thread. This post might be a bit jumbled, but if I take the time to write another draft -- given how often I find the time to write -- it won't get out this year. I hope some might find the ideas valuable to the discussion.

As creators of digital works, if we want our work to survive over time, we need to be aware of a number of issues. Many comments have confused or combined content/storage media and file/content format into one (and most if not all have ignored licensing). It is critical that they be seen as separate factors that lead to either the digital-dumpster of history or to the potential of being archived and accessed over time.

Critical to the issue of shelf-life for digital works is the use of Free Software and Open File Formats.

Content/license: how you view your place in history defines how you try to control your work. Will you allow people to disassemble your creation and make parts of it their own? Are you the latest link in a history/long chain reaction of creativity, or are you an island in time claiming no connection to the past and with nothing to pass to the future?
Do you let your tools/software/etc make this decision for you by using proprietary tools and closed file formats or do you make an active decision on tools based on a desire to create something that can be shared? The more you try to keep control over your work, the less possible it will be to have a long shelf-life.

Storage Media: a couple of posts in this thread have made reference to a physical storage media and its potential to go extinct. CD's degrade, drives die, paper can burn... It is important to not tie your creation too tightly to the physical means of distribution if you desire a long shelf-life.

Content/file format: this is critical if you want shelf-life. if you do not create using open file formats that can be accessed and converted over time, you are locking the life of your work to the whim of a corporate board room. This is especially critical if you have created a work that requires the tools of creation in order to be displayed. If the works that Leonardo da Vinci created while looking through his telescope required such a telescope to be viewed, would any of us have ever seen them? If you want to create work that can be preserved, you must use formats that you have the right to access, even if the company that produced it decides to never upgrade it.

The tools you use: while many of you might not have the skill to modify software, using tools that you have the right to modify is critical. Someone mentioned having created a work that will never again be accessed because viewing it is locked to tools that require Mac OS 9. Based in proprietary tools and locked to a proprietary operating system, there is little hope of ever being able to change that situation.

Why have the works of Euripides had long shelf-life? Public domain tools and open formats -- encodings that can be converted to modern languages even if the original format is no longer in use.

The discussion of what it means to create art with tools you don't own or control is one I'd like to see happen more often (keep in mind that you never own proprietary software even if you pay for it).

I think that this is an important part of the shelf-life discussion. Do you use Free tools and open formats? If not, why? Is the thought of tools and formats even part of your creative process? If not, why?

Radical Reference, Free Software Use in Librarianship

Apr 28 2009 4:30 pm
Apr 28 2009 5:20 pm

Radical Reference is an online reference service provided by volunteer library workers in a collaborative virtual setting using free/open source technology. Come learn more about how you can use this model to deliver services in your own communities (social, political, familial, spiritual, etc.). Presenters will share the five year history of the group and discuss how it collaborates, as well as give an accessible history of free/open source software.


Ocean Place Resort & Spa Long Branch, NJ
United States

Free Software, Drupal, and Kittens

This past Saturday was the 7th NYC Drupal Camp, and apparently something I said started a little bit of a twit-storm.

As part of the introduction to the event, I was asked to give a quick introduction to Open Source/Free Software. I've given similar presentations at many of the past camps and other conferences, and it was a busy week so I did not really prepare as well as I should have so I improvised a bit more than I usually do.

I pulled out one of my earlier presentations and gave the fastest possible history of the GPL, Free Software and the relationship between the copyleft nature of the GPL sofware license and the community-centric development process of a tool like Drupal.

Along the way I babbled about how participation in use of and development of Free Software tools is in itself a political act. Our agreement to be bound by the license and to return our modifications to the community -- a community that in traditional economic perspective includes one's competition -- is a radical act that in many ways is building a new cooperative economic model within the rotting corpse of free-market Capitalism.

I love Drupal Camp, it's not often I get to say "the rotting corpse of free-market Capitalism" to a crowded room of people.

In order to explain the use of the word free in the context of Free Software -- to get past the non-specific meaning of free in english -- often the phrase "Free as in Speech" is used to make it clear that even though most Free Software is also "Free as in Beer" we're talking about the rights the license protects more than the cost.

A while back, I had read an article and a blog post by a librarian, Karen Schneider, where she discussed Open Source/Free Software and compared Free Software to kittens.

“But how do I maintain it?” is another reasonable concern of librarians. Sure, OSS doesn’t cost, but that’s free as in "free kittens." Like all software, open source products require maintenance by knowledgable staff.

So, inspired by Karen's writing, I opted to use the phrase "Free as in Kittens"

This got tweeted and re-tweeted and I wanted to make sure that credit for the idea went to the right person.

For those that asked me to give the exact quote from my presentation, here it is as close as I can get based on my notes and memory: Free Software is Free as in kittens -- you can have it but you need to take care of it, nurture it, and clean out its litter box. Drupal is one of those cute kittens, it's free but you have to take care of it and maintain it, and if you do it won't shit all over your server.

Nice turn of phrase!

I'll have to remember that one.

A recent article of mine

A recent article of mine also references Karen's quote: