and I'm all out of bubble gum…
Social Media
I’m working with faculty and students to develop personal learning networks that tie together all of these Web 2.0 tools to create an online identity and a group of “fellow travelers” studying and exploring the same area. In students’ case, we’re working on this as a class (blogging), but for faculty tools like Twitter (and personal blogs) may also be useful. Also looking at other sharing sites (e.g. Flickr) for use as collaborative tools.
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!
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.
Photo Portfolios on Flickr
03 years ago
by Seth Battis
in Social Media
This post is part of a series that are components of my “Expert Plan” at my school, looking to create a shared resource for my colleagues as the school moves towards greater adoption of laptops and technology in our pedagogy.
The Model
I have long used Flickr for my own personal photo sharing needs — it’s pretty much a de facto standard in circles in which I travel: a clean interface, strong support for connections between Flickr and other Web 2.0 services, and very real support for innovation in terms of user-designed and coded add-ons. All this adds up to Flickr being a very flexible, very powerful photo sharing service.
My idea was that my students could get to know one of the standard photo sharing services as part of the new media design experience. Using Flickr would expose them to some of the new media concepts inherent in working with Web 2.0: hosting information online and then reusing that information in other forums (for example, embedding their Flickr-hosted pictures in blog entries on our blog server). As Flickr also supports sharing within groups, comment boards and tagging, my hope was to have the students engage with each other’s photos online via Flickr.
In Practice
Signing up for Flickr was a real challenge for my students. Partly this was because they needed more support from me in understanding how to sign up for access to a web site. Partly this was because Flickr is owned by Yahoo, so they needed to (confusingly) sign up for a Yahoo ID and then link that Yahoo ID to a new Flickr account. (I had signed up for Flickr so far back in the day that I hadn’t had to jump through those hoops — and had already had a Yahoo ID to link to my Flickr account when they merged). The sign up process provided an opportunity to discuss digital footprints and privacy online, to help my students think about both protecting their privacy (concurrent with the school’s legal obligations under FERPA) and about how they present themselves to future employers and the like.
My students also wanted a significantly more structured guide to how to upload photos and share them to our class group on Flickr. Note that I say “want” — they were not eager to explore and figure out features on their own (or to read the help documentation from Flickr itself). I gave them a (privately throw-away) assignment to post their first few pictures that only one student completed, who already had a Flickr account before the class.
When it came to linking our class blog to their Flickr accounts, my students also ran into difficulties. The process, while well-documented on Flickr, is somewhat technical and they did not have a clear enough idea of the purpose or desired outcome to really dig in and engage with the process. Plus, they had a lot of typos trying to enter the blog XML-RPC address by hand. It was not a confidence-inspiring performance. Similarly, when it came to posting to the class blog from Flickr, very few of the students really grasped that this was a one-click process — almost all opted for much harder (and, frankly, lower quality and more annoying, approaches to embedding their photos in the blog initially).
By and large, once photos were uploaded, students were successful in sharing those photos to the group photo pool. They were also good about going in and providing comments to each other, when assigned to do so. Interestingly, they could spend an entire class totally obsessed with flipping through each other’s photos online, but actually adding comments was not a voluntary instinct.
After the first few photo uploads, we ran into Flickr’s free account limitations (which, again, I had forgotten about because I don’t run up against them): only 20MB of uploads a month, only 200 photos per account maximum. Complicating this was that the Flickr interface (uniformly reliable in other environments), routinely hung when attempting to upload files from the media lab (probably having to do with the school firewall). Students would spend 20 minutes trying to upload three photos and find that the process had, in the end, failed. To get around this, by the end of the first quarter, I was uploading the lion’s share of the classes photos to my own Flickr account.
In addition, once uploaded, the photos in free accounts are not available at full resolution. My hope had been to use Flickr as a repository for the class’ photos. Instead, it was at best a secondary viewing area: the students didn’t have access to the full resolution images for editing purposes via Flickr. Worse, several of the students didn’t grok that they could download photos from Flickr at all and opted to take screenshots of the photos at very low resolution on the web. And then edit those screenshots. Rather than working with their original files. And I discovered this not because they asked me how to do this, but because I saw them at work editing the screenshots. Enterprising. Stupid, but enterprising.
Flickr did provide a great basis for discussion of photography, composition and style. Flickr’s gallery function allowed me to collect sample photos “live” from the web to present concepts and be the focus of class discussions. This could be a useful tool for having students do a photo scavenger hunt, for example.
Reflection
I was distinctly underwhelmed by the experience of trying to use Flickr in the classroom. I think that there were really three things that were a marked failure in this:
- I really failed to anticipate all of the limitations of a free account on Flickr (and the complexity of needing a Yahoo ID to play the game at all). This was totally my bad: I knew all of these limitations, but either didn’t think that they would be an issue (“oh, we won’t take that many photos…”) or just didn’t process their ramifications (“20MB a month should be enough!”). I had actually looked around at other photo sharing sites, including Google’s Picasa, SmugMug and using our FirstClass class conference and decided that Flickr provided the best interface and flexibility for what we were doing in class.
In retrospect, I think I would have separated the photo sharing from the photo archiving plan and explicitly started my students off using the Classes share as a repository for all their images, and then having them post images directly to the class blog for discussion and portfolio purposes. - I mistook “digital natives” for web experience. Which is pie on my face, since I’ve long made the argument that these are not one and the same, and that our students really benefit from our teaching in terms of critical analysis, literacy and just plain common sense online. The students just didn’t get how to sign up for an account on a web site online by themselves, and they weren’t really interested in learning. I should have structured that process differently, and, well, in a more structured manner.
I think that I came in with misplaced expectations about both the background and attitudes of the students. I anticipated a more web-savvy crowd and they were not. In retrospect, I was rushing through much of my material at that point, trying to “stay on top” of the course outline as I understood it. Everyone would have been better served if I had taken a day or two out of my outline earlier in the semester to sit down and talk through:- Sharing files online. Literally: where are those files and how do you put them there.
- Accounts on web sites, how to get them and how to use them
- How different web sites can be made to work together.
- The school firewall and web filter did me no favors. As I learned over the course of the first quarter, any time that I decided to rely on sites not directly hosted by the school, I was in for a world of pain at some point along the way. Usually, this pain took the form of problems signing up to use the site (as happened with Flickr) or uploading content to the sight (as happened with Flickr). On the one hand, this is a strong reminder that the school does host a number of useful tools and that I should turn to those tools first, where appropriate. On the other hand, this was just infuriating — I was having experiences with web sites that I have not had ever before — and that I didn’t have when I left our campus network. They claim that the the home crowd is the 12th player on the field at football games. The school network was definitely the 12th player on the field in my classes this fall.
Using external sites does raise very real and very consequential privacy concerns — and concerns that need to be presented clearly to faculty at the outset in the form of simple guidelines. The rule of thumb that students’ last names never appear online is great, and workable. But cutting us off from free and useful technology is really just exasperating.
In the end, I came away from this experiment feeling pretty dejected.
Short Focused Screencasts
03 years ago
A week or so ago, I recorded a long screencast for my computer animation class, explaining — soup to nuts — the process of constructing an armature for a model in Blender. It’s got a lot of tricky steps, and you have to do it just so: an ideal candidate for screencasting. You can see it. You get it narrated. You can pause and rewind. It’s great.
Except.
It’s not so great if your idiot teacher gives you a fifteen minute video that explains the whole process, without bookmarking key moments in the process. This is one of those wonderful learning moments, when teaching material helps you understand how to teach that material better. Which doesn’t do your (well, my) students a lot of good if they’re trying to figure out a particular step.
Screencast-O-Matic offers some bookmarking potential that I need to play with on my long video. But, in the short term, it’s been just as easy — maybe even easier — to just record 1-2 minute videos of specific key steps. We’ll see if this works better for my poor, confused students. None of what they see in these videos is new. But they need to be able to pull up the instruction á là carte, rather than as the prix fixe seven course meal.
So, a playlist of the short videos:
And, for comparison’s sake, the original long video (broken into two pieces on YouTube below):
