and I'm all out of bubble gum…
Educational Technology
Transmogrifying those Google Reader JSON dumps into something useful
91 year ago
For the last few years (my JSON feed tells me: since 2008), I have been tagging and annotating articles of interest as they passed before my eyes in Google Reader. This served a two-fold purpose:
- I could find them again later, easily, because they were tagged and annotated.
- I could share an RSS feed with those annotations to particular interest groups that I worked with (e.g. anything tagged “for robotics” would show up on my advanced computer science class’ portal page, or anything tagged “for academic computing” would show up on my school home page).
This was a great way to share (and manage) resources. Granted, much of what passed before my eyes in Google Reader was trivial and not of lasting value, but this filtering allowed me to hang on to at least a few gems for future reference.
And then Google Reader got the Google+ treatment and sharing items broke. But you could download a JSON dump of all the items that you had ever shared. It wasn’t entirely clear what you could do with this JSON dump, but… there it was. And then: I realized that all of my other information is stashed on my web server (and that I have become increasingly distrustful of relying on cloud services to maintain my data and workflows — e.g. my weekly backup of all my Google Docs… just in case).
Wouldn’t it be handy to import that JSON feed into a new blog on my server? So I wrote a PHP script that converts (at least my) Google Reader JSON dump into an XML file that WordPress can import as a list of posts. With the tags and annotations converted over. In fact, with all of the data in the JSON dump embedded in the XML file (although WordPress doesn’t read all of it).
This comes with a few caveats:
- For items that came from blogs with a full feed, the result is a republication of the original post — which feels ethically dubious to me. (I have made my new blog of Google Reader shared items private, so that I have the data but I’m not sharing it with the world).
- I’ve made guesses as to how to treat some of Google’s data. Reasoned, educated guesses, but guesses nonetheless. For example, I’m not super-clear on which dates in the file correspond with what events — does a publication date refer to when the item was shared or the original post was posted?
- I’ve added in some arbitrary (and therefore, ideally, eventually, configurable) WordPress tags to make the import go more smoothly. Where I have done that, I mark it in the script as a TODO item. (And, in truth, I didn’t really test to see if all of these items were necessary.)
- The original authors of the posts are transfered to the XML file, which means that when the actual import into WordPress is done, you will have the option to either laboriously create a new user for each distinct author or simply revert authorship to the currently logged-in WordPress user. It doesn’t seem like WordPress has a format for exporting or importing users (or, at least, my cursory search didn’t find it). Clearly an ancillary SQL query could be generated that pre-populated the WordPress database with the users that the XML file refers to. But I haven’t bothered to do that.
- You’ll need your own PHP-compatible webserver to run the script, since I have been quick and dirty and simply imported the JSON file from and exported the XML file to the script’s local directory. And I have no interest in setting up my world-facing webserver to take the traffic hit of processing other people’s multi-megabyte JSON dumps.
With that said, here is the script, as it stands this morning.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 | /**********************************************************************
* Google Reader to Wordpress
*
* 2011-11-27
* Seth Battis (seth@battis.net)
*
* This script takes the output of Google Reader's JSON export of
* shared items and converts it into an XML file that can be imported
* into a Wordpress blog as posts. All of the data in the original JSON
* file is preserved in the XML file, either by transfering it to
* an appropriate format (e.g. Google Reader categories are converted
* to WordPress post tags) or simply as an additional XML tag (e.g. the
* Google Reader commentInfo metadata for recent shared items). In
* situations where actual data has to be converted to make it readable
* for WordPress, the original data is included as the JSON attribute
* of that tag (e.g. timestamps and categories).
*
* As currently written, the script looks in its local directory for
* Google Reader "shared-items.json" file and generates a matching
* "shared-items.xml" file, also in its local directory.
*
* There are a number of potentially configurable (i.e. arbitrary)
* values marked as TODO.
*
* Caveat emptor: this has been tested against my ~1000 item Google
* Reader shared items feed and on my WordPress 3.2.1 site. I would
* presume that it should work fairly well for others, but make no
* guarantees!
*********************************************************************/
/* returns a Wordpress slug-version of the given text (only
alphanumeric characters and dashes) */
function sluggify($text)
{
return preg_replace("|[^a-z0-9]+|", "-", strtolower($text));
}
/* SimpleXML doesn't really support namespaces unless you force it */
$xml = '<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0"
xmlns:excerpt="http://wordpress.org/export/1.1/excerpt/"
xmlns:content="http://purl.org/rss/1.0/modules/content/"
xmlns:wfw="http://wellformedweb.org/CommentAPI/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:wp="http://wordpress.org/export/1.1/"
></rss>';
$rss = new SimpleXMLElement($xml);
$namespaces = $rss->getDocNamespaces(true);
/* load the Google Reader JSON file */
$file = file_get_contents("shared-items.json");
$json = json_decode($file, true);
/* Wordpress will choke if our post names aren't unique, so we track
them separately */
$post_names = array();
/* header information describing the file itself */
$channel = $rss->addChild("channel");
$channel->addAttribute("direction", $json["direction"]);
$channel->addAttribute("id", $json["id"]);
$channel->addAttribute("self", $json["self"][0]["href"]);
$channel->addAttribute("author", $json["author"]);
$channel->addChild("title", $json["title"]);
$channel->addChild("link");
$channel->addChild("description");
$pubDate = $channel->addChild("pubDate", gmdate("D, j M Y G:i:s O", $json["updated"]));
$pubDate->addAttribute("json", $json["updated"]);
$channel->addChild("language");
$channel->addChild("wxr_version", "1.1", $namespaces["wp"]);
/* run through the list of items and add them to the XML */
foreach ($json["items"] as $item)
{
$rssItem = $channel->addChild("item");
/* a bunch of Google Reader-specific metadata */
if (isset($item["isReadStateLocked"]))
{
$rssItem->addAttribute("isReadStateLocked", $item["isReadStateLocked"]);
}
$rssItem->addAttribute("crawlTimeMsec", $item["crawlTimeMsec"]);
$rssItem->addAttribute("timestampUsec", $item["timestampUsec"]);
$rssItem->addAttribute("id", $item["id"]);
if (isset($item["commentInfo"]))
{
while (list($commentInfoKey, $commentInfoValue) = each($item["commentInfo"]))
{
$commentInfo = $rssItem->addChild("commentInfo", $commentInfoKey);
$commentInfo->addAttribute("permalinkUrl", $commentInfoValue["permalinkUrl"]);
$commentInfo->addAttribute("commentState", $commentInfoValue["commentState"]);
}
}
/* annoyingly, not every item has its content in the content
element -- sometimes it's in the summary element (and once in a
while, it's just not there). I think this is an artifact of how
the original RSS feeds were constructed. I think. */
if (isset($item["content"]))
{
$content = $item["content"]["content"];
}
else if (isset($item["summary"]["content"]))
{
$content = $item["summary"]["content"];
}
else
{
$content = "";
}
/* sometimes items don't even have titles */
if (isset($item["title"]))
{
$rssItem->addChild("title", $item["title"]);
}
/* most items store the original linkback information in the
alternate element -- Wordpress won't honor this link tag when
it's imported (i.e. it won' treat it like the Daring Fireball
feed), so I have embedded a more descriptive linkback after the
annotations at the start of the content, using some information
from the origin element. The linkback is in the
"google-reader-alternate-href" div (for easy CSS-wrangling!) */
if (isset($item["alternate"]))
{
$rssItem->addChild("link", htmlentities($item["alternate"][0]["href"], ENT_COMPAT, "UTF-8"));
$content = htmlspecialchars("<div class=\"google-reader-alternate-href\"><p>Originally posted at <a href=\"{$item["alternate"][0]["href"]}\">{$item["origin"]["title"]}</a></p></div>", ENT_COMPAT, "UTF-8") . $content;
}
/* I haven't bothered to figure out if the dates are really GMT or
localized -- GMT was an easier assumption to make */
$pubDate = $rssItem->addChild("pubDate", gmdate("D, j M Y G:i:s O", $item["published"]));
$pubDate->addAttribute("json", $item["published"]);
/* not every item has an a author, either -- again, an artifact of
the original RSS feeds */
if (isset($item["author"]))
{
$rssItem->addChild("creator", $item["author"], $namespaces["dc"]);
}
/* annotations were tricky -- I have added them as their own XML
tags _and_ inserted them within a "google-reader-annotation" div
at the top of the post content (to match the original format on-
screen). All of the original data is preserved in the XML tag,
with an ID that matches the embedded div ID. */
foreach($item["annotations"] as $annotation)
{
$annotationHTML = htmlentities("<div id=\"" . md5($annotation["content"] . $annotation["author"]) . "\" class=\"google-reader-annotation\"><blockquote><p>{$annotation["content"]}</p><p class=\"author\">{$annotation["author"]}</p></blockquote></div>", ENT_COMPAT, "UTF-8");
$content = $annotationHTML . $content;
$rssAnnotation = $rssItem->addChild("annotation", $annotation["content"]);
$rssAnnotation->addAttribute("id", md5($annotation["content"] . $annotation["author"]));
$rssAnnotation->addAttribute("author", $annotation["author"]);
$rssAnnotation->addAttribute("userId", $annotation["userId"]);
$rssAnnotation->addAttribute("profileId", $annotation["profileId"]);
$rssAnnotation->addAttribute("profileCardParams", $annotation["profileCardParams"]);
}
/* again, sometimes content is in content, sometimes it's in the
summary element */
$rssContent = $rssItem->addChild("encoded", $content, $namespaces["content"]);
if (isset($item["content"]))
{
$rssContent->addAttribute("direction", $item["content"]["direction"]);
}
if (isset($item["summary"]))
{
$excerpt = $rssItem->addChild("encoded", $item["summary"]["content"], $namespaces["excerpt"]);
$excerpt->addAttribute("direction", $item["summary"]["direction"]);
}
/* more Google reader metadata, this time about the original feed
that the item came from -- which is used above to format the
linkback that is embedded a the start of the content */
$origin = $rssItem->addChild("origin");
$origin->addAttribute("streamId", $item["origin"]["streamId"]);
$origin->addAttribute("title", $item["origin"]["title"]);
$origin->addAttribute("htmlUrl", $item["origin"]["htmlUrl"]);
/* it's not clear to me whether the published or modified date is
when the original post was published or when the item <span class="hiddenGrammarError" pre="item ">was
shared</span> -- I think when published refers to when it was shared. */
$postDate = $rssItem->addChild("post_date", date("Y-m-d G:i:s", $item["published"]), $namespaces["wp"]);
$postDate->addAttribute("json", $item["published"]);
$rssItem->addChild("comment_status", "open", $namespaces["wp"]); // TODO make configurable
$rssItem->addChild("ping_status", "open", $namespaces["wp"]); // TODO make configurable
/* make a Wordpress friendly title slug for the post */
if (isset($item["title"]))
{
$slug = sluggify($item["title"]);
}
else
{
/* if no title, generate the slug from the timestamp */
$slug = date("Y-m-d-G-i-s", $item["published"]);
}
/* make sure that our slug is unique -- add a counter to the end
if it is not, and track those counter values in $post_names[] */
if (isset($post_names[$slug]))
{
$post_names[$slug]++;
$slug .= "-" . $post_names[$slug];
}
else
{
$post_names[$slug] = 0;
}
$rssItem->addChild("post_name", $slug, $namespaces["wp"]);
/* more Wordpress metadata -- all of which could be tweaked */
$rssItem->addChild("status", "publish", $namespaces["wp"]); // TODO make configurable
$rssItem->addchild("post_parent", 0, $namespaces["wp"]); // TODO make configurable
$rssItem->addChild("menu_order", 0, $namespaces["wp"]); // TODO make configurable
$rssItem->addChild("post_type", "post", $namespaces["wp"]); // TODO make configurable
$rssItem->addChild("post_password", "", $namespaces["wp"]); // TODO make configurable
$rssItem->addChild("is_sticky", 0, $namespaces["wp"]); // TODO make configurable
/* convert categories to post tags -- nota bene that Google Reader
has conflated the reader's categories with the original post's
tags, creating a... mish-mash. */
foreach($item["categories"] as $category)
{
if (!preg_match("|.*/com\.google/.*|", $category))
{
$cleanCategory = $category;
$cleanCategory = preg_replace("|user/\d+/label/(.*)|", "$1", $cleanCategory);
$rssCategory = $rssItem->addChild("category", htmlentities($cleanCategory, ENT_COMPAT, "UTF-8"));
$rssCategory->addAttribute("domain", "post_tag");
$rssCategory->addAttribute("nicename", sluggify($cleanCategory));
$rssCategory->addAttribute("json", $category);
}
}
/* add comments -- note that for privacy reasons, while the
commenter's metadata is added as an XML tag, it is not embedded
in the Wordpress-readable wp:comment tags */
foreach($item["comments"] as $comment)
{
$rssComment = $rssItem->addChild("comment", "", $namespaces["wp"]);
$rssComment->addAttribute("id", $comment["id"]);
$commentContent = $rssComment->addChild("comment_content", $comment["htmlContent"], $namespaces["wp"]);
$commentContent->addAttribute("plainContent", $comment["plainContent"]);
$author = $rssComment->addChild("comment_author", $comment["author"], $namespaces["wp"]);
$author->addAttribute("userId", $comment["userId"]);
$author->addAttribute("profileId", $comment["profileId"]);
$author->addAttribute("profileCardParams", $comment["profileCardParams"]);
$author->addAttribute("venueStreamid", $comment["venueStreamId"]);
$commentDate = $rssComment->AddChild("comment_date", $comment["createdTime"], $namespaces["wp"]);
$commentDate->addAttribute("modifiedTime", $comment["modifiedTime"]);
$rssComment->addAttribute("isSpam", $comment["isSpam"]);
}
}
/* dump the converted XML out as a file */
header ("Content-type: text/xml");
echo $rss->asXML();
file_put_contents("shared-items.xml", $rss->asXML()); |
Building a Google Earth Tour in a Spreadsheet
12 years ago
For the last couple of months, one of my high school classes at Jewish Day School has been working on building an interactive tool about the Six Day War for a middle school curriculum unit. They have put a lot of work into researching their data and laying it out in Google Earth, and now we’re putting together a tour of the data for the middle school students, that will also teach them a little about how to use Google Earth. It’s been enormously fun.
But. But, we now have to do some programming or some very careful recording in Google Earth to create this tour (a là Al Gore’s Climate Change tours). And my students are far more interested in the design end of things than in the coding end of things. They’re great at what they do, but niggling coding details give them head aches.
So I built a Google Docs spreadsheet, into which they can plug various pertinent information and out of which comes valid KML instructions that will define the tour. I’m a little proud of this — I don’t think that there’s anything else quite like it out there. There are three kinds of information that need to be entered:
- SoundCue — any audio that should be played in the background. You can either enter the whole URL to the MP3 file that should be played, or just the file name (and make sure that you enter the path in which all the files can be found on the KML Generator tab). You also need to tell us both when the cue should be played and how long it should last.
- AnimatedUpdate — anything that should be happening in Google Earth in terms of showing photo overlays or placemarks or polygons or what-have-you. Enter what should happen, and when (and, if relevant, for how long).
- FlyTo — any time we change where (or when) we’re looking at Google Earth. Enter when and how long the transition should take, and the date (and time) that we’re meant to be looking at.
The AnimatedUpdate and the FlyTo also expect the user to enter KML code — which can be copy-and-pasted from Google Earth KML exports for each transition. Happily, if something needs to happen more than once, entering the KML for the first instance will automatically populate future instances. In addition, the pauses necessary to synch up all of the action are calculated by the spreadsheet.
Update March 25, 2011: The spreadsheet above is our live work (since I kept updating the spreadsheet after this post).
The end result is both a visual timeline of the tour (helpful for debugging any weird errors) and also KML code that can be copy-and-pasted out of Google Docs and into a KML file. (Caveat emptor: depending on what you’re pasting the KML into — I like Xmplify — you may see that there is a leading and trailing quote that need to be manually deleted.)
Right now the spreadsheet can handle tours up to four minutes and 10 seconds in length (250 seconds, for those of you keeping score at home). This is because I was originally copying the KML out of the KML Orderer worksheet, and Google Docs supports pasting of up to 1000 rows in total. You’ll see that the current KML worksheet is a single cell, getting around this limitation, but I didn’t bother to extend any of the other worksheets. Just make sure you fill down all the formulas if you extend any of the sheets!
Here’s a link to a scratch copy of the spreadsheet. Feel free to copy and use it for your own purposes — let me know how you used it!
Free-style Online Learning
03 years ago
One of my responsibilities at Jewish Day School is to write a weekly “tech tips” column for the online faculty news. This is one such tip.
Even as the end-of-year to-do lists are approaching critical overload, I find that one of the joys of the spring is the contemplation of what I will be working on next year. Not so much in a “next year I’ll do this all differently” kind of snit, but with more of a “year in review” focus: spring and graduation makes me sentimental and reminiscent.
With that in mind, in the past week I have come across two interesting resources both for teaching in general and for thinking about our work as “knowledge workers” in the 21st century (to infinity and beyond!). First, Merlin Mann discusses how we do (or do not) allocate our time and attention to getting our projects done. Thoughtful, provocative and entertaining stuff. Second, Williams College’s Project for Effective Teaching has gone online with a truly exciting, provocative array of professorial reflections and questions around specific aspects of classrooms and teaching and learning. Enjoy!
How, you might ask, do videos like these fall into my hands? I follow-up on the sources of interesting articles that I see. And then on the sources of those sources: I like to find where the ideas are swimming around raw and unfettered. I do this by following a boat-load of interesting “edu-bloggers”, by following (and engaging with) other teachers on Twitter, and by doing a lot of skimming.
PowerPoint makes us D-U-M-Dumb
03 years ago
One of my responsibilities at Jewish Day School is to write a weekly “tech tips” column for the online faculty news. This is one such tip.
As we head down the homestretch of May and June, more and more students (and teachers) are experiencing siyyum for their coursework, either as final papers or presentations or projects. Projects and papers are delightfully straight-forward and easy to facilitate and grade… at least, when compared to presentations, which have the added benefit of being a potential exercise in goodwill and patience to sit through.
The first hurdle our students have to get over is the technology itself — bringing together all the disparate elements of their presentation into one place and time. A few years ago, I wrote up a cheat sheet of tips that help to avoid the most common student pitfalls. I have not run into technical problems with student PowerPoints since I started giving them this handout (I kid you not).
In general, a good presentation has to nail not just the content and technology, but also visuals and public speaking. And this is the hardest thing to do right. For adults, even. Experts have started to decry PowerPoint as not just problematic, but actively destructive when it comes to communicating information and especially nuance clearly.
Gen. Stanley A. McChrystal, the leader of American and NATO forces in Afghanistan, was shown a PowerPoint slide in Kabul last summer that was meant to portray the complexity of American military strategy, but looked more like a bowl of spaghetti.
“When we understand that slide, we’ll have won the war,” General McChrystal dryly remarked, one of his advisers recalled, as the room erupted in laughter.
Shifting the focus from a PowerPoint document to the holistic presentation will further the student’s ability to communicate complex ideas — a key skill in today’s (or any day’s) world. Some further reading that is both informative and motivational on that front:
- Merlin Mann talks about “How [he] made his presentations a little better” (know this: he was pretty good to begin with)
- Business Week breaks down how to “Deliver a presentation like Steve Jobs” (the inimitable CEO of Apple)
- Edward Tufte (the master of information presentation — and notorious PowerPoint-hater) examines how to get the absolute most out of PowerPoint (or not)
PowerPoint Tips
13 years ago
One of my responsibilities at Jewish Day School is to write a weekly “tech tips” column for the online faculty news. This is one such tip.
Making Things Run Smoothly
- Make sure that you always insert pictures into your presentation using the Insert Picture command from the Insert menu. Do not copy and paste pictures into your presentation. For arcane reasons, copy and pasting pictures can make your PowerPoint fail to display your pictures on other computers.
- Keep a folder of all of the pictures and video that you add to your PowerPoint. Just in case you need to re-insert it (for example, if you messed up on following the tip above).
- Video is not embedded in PowerPoint, pictures are – share Zip files. That is, you can insert pictures into a PowerPoint presentation and send the presentation to someone else and they can see the pictures but you cannot insert video, send the presentation to someone else, and expect them to see the video. PowerPoint creates a link to the video instead. To get around this, if you are going to use video, put your presentation and your video files in a folder together, then insert the video. When you are ready to share your presentation, right-click on the folder and Send To > Compress or Zip Archive and send out the Zip file instead. Your recipient can unzip the archive and will have the presentation and the video.
Making Things Look Pretty
- Black text on a white background is not traditional by accident. It’s easy to read. Think carefully before trying a novel color combination.
- One picture per slide lets you show the picture big, in all its glory. Multiple pictures per slide lets you compare pictures. Think about which it is you want to be doing (and remember that postage stamps are hard to see!).
- Don’t stretch your pictures. You can scale your pictures proportionately by holding down the Shift key when you drag the grab boxes on the corners of the picture. This will make sure that the picture doesn’t get distorted.
- Use text judiciously. This one is complicated: you don’t want to have too much text on a slide because it will get small and hard to read. You don’t want to put your script on the slide, because then you’ll be reading from the slide, which is deathly dull (unless, maybe, you’re Morgan Freeman). But you do want to present text that will support your arguments and highlight important ideas. And you do want to present quotations that are illuminating. One rule of thumb is the “six by six” rule: no more than six words per bullet point, no more than six bullet points per slide. This is totally artificial and you should violate it as needed… but remember it and what it is really urging: don’t overwhelm your audience with text!
- Less is more. This is true of almost everything involved in PowerPoint, but particularly when it comes to animation and sound effects. They have a campy appeal, and can sometimes underscore a point you’re trying to make. But you ain’t Spielberg and PowerPoint ain’t ILM, so don’t go trying to put in gratuitous special effects just to make your PowerPoint more appealing. Your research and ideas should be the focus, not your ability to make car crash sound effects.
Category Shortcode
13 years ago
I just slapped together a very quick plugin for a teacher’s blog that adds a [category] shortcode to WordPress. Basically, it just passes through all of the attributes of the shortcode as parameters to wp_list_categories(), allowing the user to embed a list of blog categories in any page, post or widget. This feels like something that should already exist (but I couldn’t find it).
Whining to Protect My Copyright
23 years ago
A while back, I noticed that the Houston Chronicle had ripped off one of my Flickr photos for their web site. They had credited me, but had used my photo in a way that violated its non-commericial Creative Commons license. I posted about it, and didn’t have much hope that I’d ever get anything resembling satisfaction. It’s been resolved, or as resolved as it ever will be. I’ve been meaning to post something about it, but have been waiting… really, waiting and hoping that something else would unfold to make me feel better about how it had gone. In the end, I got connected with Dean Betz, the Chron.com Director of Content, and he told me:
It’s no surprise what I found; a well-intentioned producer, hoping to help illustrate an interesting story but not sufficiently trained in the appropriate use of Flickr, used your image not licensed for commercial use on our clearly commercial Web site.
That’s partly my fault in not giving better direction to our staff on Creative Commons. We’ve used this as a “teaching moment” to improve our training to staffers, and I very much appreciate your pointing this out.
We’ve removed that photo from our site, but by way of remedy, I’d like to offer to pay you our standard one-use fee of [none of your dang business] per image. I’d like suggest that I post a followup message to your blog with my mea culpa on not giving sufficient direction to our producers on Flickr and Creative Commons, and that we’ve taken remedies to close the gap.
I had been not anticipated much in the way of a response at all from the Chronicle, so this was all a pleasant surprise:
I’m a little guy and they’re pretty big. I can get up on my hind legs and complain. But I doubt they’ll pay attention to me. And besides, this particular violation of my rights is relevant to the world (and, really, me) for only the next few hours, until this cycles off their front page. And then it’s just something that happened that’s easy for them (and me) to ignore.
In the end, it took a bunch of follow-ups with Dean (Gmail counds 18 emails in that thread, back-and-forth), several versions of an invoice, and just plain a lot of patience, but I got a (token) payment for the use of my image, a vague promise that some education had happened in the newsroom, and no deeper explanation than what I posted from Dean above. I appreciate the payment. I appreciate the promise that education was happening… but the work to get all that was, in the end, much more than it was really worth.
I think that all of this goes to highlight the difficulty of working with intellectual property law in general: there’s a huge imbalance in terms of the amount of effort required for small fry like me and a major publisher to track down and combat the theft of their work. Nothing that the Chronicle asked of me in return for payment was excessive (it was all normal stuff that outside contractors have to do if they want to get paid by a corporation — but I feel like a sucker now that they have my social security number), but every additional effort that I had to make to obtain redress was increasingly less worthwhile for me. If I had to do this regularly, I would be the world’s grumpiest human being. There ain’t no such thing as a free lunch, and, it turns out (and I had already known this intellectually), there’s no such thing as redress without real effort (and now I really get it). Nobody’s gonna make it right to you unless you hold their feet to the fire. And I was dealing with nice people who meant well at a decently reputable company; it was still a hassle.
Would I raise my tiny fists and shout into the whirlwind in vain again in a similar situation? Probably. And I’ve got some new thoughts on how to do it — next time I can shortcut some of the email back and forth by just leading off with an attached invoice. And an invoice for an amount that I think is fair (now that I have something resembling a ballpark figure: more than the Chronicle paid me). But I hate how whiny and bitchy it makes me feel. Having the fact that I’m the little guy rammed home makes me feel even littler than before.
