End of Year Library Report (and GRADUATION!)

There’s a whole lot of CRAZY going on right now in my work life. Typically, I like to keep the library open as long as possible, I always make exceptions for kids who need just one more book (LOTS of … Continue reading →

The Power to Recommend

(or my Library Superpower OR why I read MG books so obsessively) I like to think that my greatest library superpower is my ability to put the right book in the right hands. It’s a job that I take very … Continue reading →

Lamenting over Layout

The school year is winding down quickly — tomorrow I go back from spring break for two weeks of state testing/chaos, then just two more weeks of circulation before I have to shut the library down to get the library … Continue reading →

Edtech Karaoke Party 2012

Creating Assignments That Work for Digital Learning Environments

A letter to my seniors (updated)

Google’s new Knowledge Graph

Google Docs news

Bookloose!

Map of Life launches its demo

Plagiarism: That 'P' Word!  

Ah, tis' spring! The smell of the flowers, the warmth of the sun, and the dreaded end of the term's essay assignment! For most students, that means a heavy reliance on the Internet, where they have virtually instant access to information. This tempting av...

Classroom Publishing: Enable students to create ebooks of their work with these easy-to-use applications

Technology has changed what it means to be an author and how people can discover your work. Today, anyone with a computer and Internet access can create an ebook, which is great news for schools. Now teachers and students can build their own reference...

Messages That Stick: A hip marketing concept can work for libraries

Do you have permission to contact your students with updates from the library? I don’t mean having to approach your administrator or IT department, but rather, do you have permission from the students themselves? It’s a concept known as “permission m...

Kindle Fire vs. Nook Tablet: An educator weighs the pros and cons in the big smackdown

In this Article The Details It’s been a frequently asked—and highly contentious—question since their nearly simultaneous release in mid-November: Which is the better color ereader/tablet, the Kindle Fire or the Nook Tablet? I had the opportunity t...

The Truth About Tablets: Educators are getting iPads and ereaders into students’ hands—but it’s not easy

In this Article Sticking Points Talk about a revolution. Since Amazon unveiled the first Kindle in 2007, digital devices have dramatically changed the way kids read and even think about books. But it’s less clear how ereaders and tablets will affe...

Sarah Ludwig to Blog at ALA TechSource

I’m delighted to welcome Sarah Ludwig to the ALA TechSource blog team. She will join bloggers Jason Griffey and Kate Sheehan and new Code Words columnist Jason Clark.

A 2010 ALA Emerging Leader, Sarah is academic technology coordinator at Hamden Hall, a preK-12 school in Connecticut. She previously worked at Darien Library, where in various positions she managed reference, technology, and teen services. She is author of Starting from Scratch: Building a Teen Library Program (Libraries Unlimited, 2011) and is one of VOYA’s “Tag Team Tech” columnists.

Experienced in working with children and teens, Sarah will bring a new perspective to the blog. But it won’t be all about the kids. Throughout her young career, Sarah has taught colleagues, patrons, and students alike how to use technology. At Darien Public Library, she oversaw the the technology education series. At Hamden Hall, she helps teachers integrate technology into the classroom curriculum. Sarah finds and uses technologies that serve learning, research, and critical thinking. We’re looking forward to posts that you will find useful in your work.

The TECH SET 11-20 is Published

The TECH SET is here, on my messy desk, as well as in our warehouse and ready to ship.

Congratulations to Series Editor Ellyssa Kroski and authors Amanda Beilskas, Marshall Breeding, Jason Clark, Kathleen Dreyer, Amanda Etches, Robin Fay, Michael Lascarides, Joe Murphy, Greg R. Notess, Michael P. Sauers, Aaron Schmidt, Sarah K. Steiner, and Kenneth J. Varnum on publication of their TECH SET books.

Purchase the books 11–20 for $385 and save $215 off the list price. Use coupon code TECH12 at checkout.

Read sample chapters on Scribd.

See The TECH SET Twitter list and follow the authors.

Check for complementary content on the companion web pages.

Using the Google Spreadsheets Data API to build a Recommended Reading List - Code Words

Welcome to Code Words. A new column looking to demonstrate how simple programming tasks and emerging technology trends can be applied to libraries. My goal is to provide an introduction to the role that programming and computer tools can play in building the digital branch of the library. Topics will include everything from relational databases, to mobile services, to simple Javascript routines, and much more.

Many columns will explain a specific concept and then show how it might be applied in a live, application setting. In this first column, we will look at the idea behind a “data store” that might power an app or website. In generic terms, a data store is the place where you store the data that you will use. This “place” usually takes the form of a database, but it can be anything from a spreadsheet to a text file delimited by commas. (See http://en.wikipedia.org/wiki/Data_store.)

Our first example will show how to use a Google Docs spreadsheet as your data store. Once you have the spreadsheet and data in place, we’ll create a little HTML and add some Javascript to query the spreadsheet data and produce a recommended reading list.

Check out the demo in action here: http://goo.gl/df9Y3
Download and view the full source code here: http://goo.gl/0jbRe
Get sample spreadsheet and data here: http://goo.gl/7ZObf

Step 1: Create your data in a Google Spreadsheet

Most applications that you create will need some form of data to run the display. We are going to create a spreadsheet to hold data related to our book list. Sign into Google Docs using your Google account. Choose “Create new spreadsheet” and create six columns of common book data fields - Title, Author, Publisher, OCLC#, ISBN, Notes - and add a few empty rows for single item book data. When finished, begin adding your data in the data rows under the column fields that you just created. If you don’t want to bother with creating a new spreadsheet, here's a link to a Google Docs spreadsheet with the sample values in this example as a template - http://goo.gl/7ZObf.

Two dev notes are worth mentioning here. We are using the Open Library Book Cover API to get our cover thumbnails (http://openlibrary.org/dev/docs/api/covers). When adding your own data to a spreadsheet, it works best if you navigate to Open Library records and grab data from Open Library items that have thumbnails in their display. One other important format note: be sure to set the formatting on those columns where you are entering numbers as “plain text.” Google docs likes to strip leading zeros from number strings, which can break your ISBN and OCLC# values. (See this Google Docs thread for details - http://goo.gl/8Bkq1.)

Step 2: Make the spreadsheet available as a public feed

Once you have added all the book data, the next thing to do is make the spreadsheet available as a public feed. The script that we will create in later steps will use this public feed to bring in data to display. Go to the settings on your spreadsheet, make the document available to "all on the web," and save it. If you check the URL (address bar in the browser), you should see an alphanumeric id after the “key=” parameter in the URL. Copy that id and add it to the URL below to set your public feed.

https://spreadsheets.google.com/feeds/list/ADD-YOUR-ALPHANUMERIC-ID-HERE/od6/public/values?alt=json-in-script&callback=?

Notice that there are two extra values in the URL: "alt=json-in-script&callback=?". The "alt=" value tells Google to display the public feed as Javascript Object Notation (JSON) - a structured data format optimized for web delivery - and the "callback=" value sets up an empty value that our Javascript will use to cause the script to run. For more info on retrieving JSON feeds from Spreadsheets Data API, see https://developers.google.com/gdata/samples/spreadsheet_sample.

Step 3: Create the HTML foundation
[See the full booklist HTML in this gist - http://goo.gl/pTSwI

All buildings need a foundation, and in the case of web programs, that foundation is HTML markup. In this example, we start with the head information for the HTML file that provides a title, defines the character set for the file, and brings in the jQuery Javascript library that will create the behavior for the application.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<title>New Books We Recommend</title>
<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script>

Whenever possible in Code Words, we will try to use frameworks and code libraries (like jQuery). Programming tasks can be automated, and many times these frameworks and libraries are tested and vetted across multiple browsers and operating systems.

Step 4: Finishing the HTML markup & giving the script a place to display the spreadsheet data.

...
</head>
<body>
<h1>New Books We Recommend</h1>
<div id="book-list"></div>
</body>
</html>

Our script needs a home in the HTML to place the values from our spreadsheet. In the above HTML markup, we introduce <h1> and <div id="book-list"> tags for this purpose. Our display now has a title explaining what type of data is being displayed and markup that will be used to place the dynamic content from the external spreadsheet.

Step 5: Building a Javascript function to get the data from our spreadsheet and display it
[See the full booklist Javascript in this gist - http://goo.gl/hmxlh]

Once we have opened the HTML document and included the jQuery library, we can create a script that will retrieve the JSON data feed from our spreadsheet. First, we tell the script to run once the page has loaded using a built-in jQuery function - $(document).ready(function(). Next, we create a custom function, "listBooks" that will do all of the work - request the data, parse the data, and create a display for the data.

<script type="text/javascript"> 

$(document).ready(function() {
//source file is https://docs.google.com/spreadsheet/ccc?key=0Ak0qDiMLT3XddHlNempadUs1djdkQ0tFLWF6ci1rUUE
$(function listBooks() {
$.getJSON( "https://spreadsheets.google.com/feeds/list/0Ak0qDiMLT3XddHlNempadUs1djdkQ0tFLWF6ci1rUUE/od6/public/values?alt=json-in-script&callback=?",
function (data) {
$('div#book-list').append('<ul class="items"></ul>');
$.each(data.feed.entry, function(i,entry) {
var item = '<span style="display:none">' + entry.id.$t + '</span>';
item += '<img src="http://covers.openlibrary.org/b/isbn/' + entry.gsx$isbn.$t + '-S.jpg"/>';
item += '<span class="meta"><a href="http://www.worldcat.org/isbn/' + entry.gsx$isbn.$t + '">' + entry.title.$t + '</a>';
item += '<br/>Author: ' + entry.gsx$author.$t;
if (entry.gsx$notes.$t) {
item += '<br/>Description: ' + entry.gsx$notes.$t;
}
$('.items').append('<li>' + item + '</span></li>');
});
});
});
});

</script>

Yeah, so there is a much going on here... We’ll work through it from top to bottom. First, "$.getJSON" is a jQuery function telling the script to load our spreadsheet. With the spreadsheet data loaded into memory, we are now in our second phase of the script which is to parse the data that was returned. "function (data)" will play this role. We use a jQuery selector syntax to tell the script to find the <div id="book-list"> tag and place a <ul> (unordered list) inside so that our new books will display as a bulleted list. Next, we tell the script to work or "loop" through all the entries (or rows) in the spreadsheet using a the jQuery $.each syntax. We haven’t seen the JSON that our spreadsheet returns. It looks something like this:

...
"gsx$title": {
"$t": "This house of sky : landscapes of a Western mind"
},
"gsx$author": {
"$t": "Ivan Doig"
},
"gsx$publisher": {
"$t": "New York: Harcourt Brace Jovanovich, 1992."
},
"gsx$oclc": {
"$t": "25629631"
},
"gsx$isbn": {
"$t": "0151900558"
},
"gsx$notes": {
"$t": ""
}
…

We want the script to walk through and store all the values it retrieves. Note that we create our thumbnails by passing the ISBN from the “gsx$isbn” value to a URL for an image from Open Library - http://covers.openlibrary.org/b/isbn/' + entry.gsx$isbn.$t + '-S.jpg. With these various pieces of data available, we create a "item" variable that we can use to store the data. The script works through all pieces of the JSON and prints the HTML inside of the “var item” variable. In the end, the script generates and returns an HTML snippet for each row that looks like this:

<li>
<span style="display:none;">...</span>
<img src="http://covers.openlibrary.org/b/isbn/0151900558-S.jpg">
<span class="meta">
<a href="http://www.worldcat.org/isbn/0151900558">This house of sky : landscapes of a Western mind</a><br>Author: Ivan Doig
</span>
</li>

Each of these <li> snippets are pushed into the <div id=”book-list> on the HTML page when the browser loads the page.

Step 6: Apply the grid layout with CSS
[See the full booklist CSS in this gist - http://goo.gl/ctL9h]

<style type="text/css">
.items {display:table;list-style:none;margin:0;padding:0;border-spacing:5px;}
.items li {display:table-row;-webkit-border-radius:10px;-moz-border-radius:10px;border-radius:10px;border:1px solid #ccc;padding:5px;margin:0 0 10px 0;}
.items li img {display:table-cell;vertical-align:top;}
.items li span.meta {display:table-cell;vertical-align:top;margin:0;padding:0 0 0 5px;}
.items li {margin:0 0 5px 0;}
</style>

And finally, we create our display styles for the recommended reading list. The CSS declarations above create the grid view with a leading thumbnail. We are styling the unordered list <ul class=”items”> as a table with rows. Once you combine all the above steps, you will have the complete file. Once satisfied with the output, place it in a web accessible directory and make it live.

Final thoughts

This sample script is just one example of how you might use a Google docs spreadsheet as your data store. Things start to get interesting when you consider other options:

• A list of subscription databases from your library
• A rudimentary news and events ticker
• Record common keywords from search queries on your catalog and link them in a popular/recent searches widget

The key is that you have a publicly available spreadsheet that numerous editors in your library can access and add data to. You might even create a form for your editors to simplify data entry (http://goo.gl/ddd4U). Opening your options for contributing to your data store is the first step in making this happen. (One last side note: a quick hat tip to Karen Coombs for inspiration and for pointing out to me that Google Spreadsheets had a feed API in the first place.)

I’ll be back in a few weeks to take a closer look at bookmarklets, those little bits of Javascript that add functionality to your browser. In the meantime, play around with this sample and feel free to ask questions here or on twitter @jaclark.

Experiences Become Expectations

Editor's note: This post is adapted from the introduction to Jason Griffey’s new Library Technology Report “Gadgets and Gizmos: Libraries and the Post-PC Era.” Jason revisits the technologies that he highlighted in his 2010 report. And he beats himself up a bit over it. Help him let go of the past; excuse him from predicting the future; and join him in discussing the gadgets your patrons are using today: Jason will be presenting a two-part workshop on May 10 and May 24.

Way back in April 2010, Library Technology Reports published “Gadgets and Gizmos: Personal Electronics and the Library,” but it was January of the same year when I turned in the manuscript for editing and effectively locked down the content. Nearly every single thing about it is now irrelevant at best, and downright ridiculous at worst.

The iPad gets small mention in that original report, but only because it had been announced just a week or so before the manuscript was locked down for publication. I published a guide to technology that missed the biggest tech shift of the decade and talked about how companies like Copia, Plastic Logic, Spring Design, Blio, Flip, and Zune might be ones to watch.

Boy, did I ever screw that up.

Copia and Blio have become also-rans in the e-book race, with the major providers (Amazon and Barnes and Noble, with a side of Apple) effectively owning the market for e-books.

The Plastic Logic QUE e-reader and the Spring Design Alex were dead out of the gate, with the QUE never even being released to the public as a product.

Microsoft finally killed its Zune products this year.

Flip was purchased by Cisco and subsequently killed.

The portable video camera market is mostly getting consumed by the cellular phone, as is the pocket camera market.

Of some 23 gadgets that I mentioned in my original report, at best and being very kind to myself, only 8 or so are viable products that I would still recommend purchasing.

I can’t claim to be Nostradamus, but I pay a lot of attention to these things. And if I screwed it all up as badly as all that, what hope does someone who couldn’t tell a Kindle from a Nook have?

That’s why it’s more important than ever that libraries and librarians act as information filters for their community. When patrons ask if they should buy the new Kindle they heard about, someone in your library needs to be able to answer basic questions about it. That person should try to provide some resources that might help patrons determine if the Kindle or the Nook is a better fit for their reading habits, or if they should splurge and get that iPad thing they’ve been seeing the commercials for.

In my previous Library Technology Report on gadgets, I identified three reasons why libraries should be paying attention to these technologies:

1. Patrons use them and increasingly expect libraries to be aware of them.
2. They often change the nature of information interactions.
3. They provide interesting opportunities for the delivery of content, something libraries should always be interested in.

Presenting on the topic of gadgets has helped me distill my message down to its essence: Experiences become expectations.

Our patrons are increasingly coming to expect that our resources will be available and easily used on their devices. Libraries are the democratizers of information. As information is increasingly amorphous digital content, we need to be familiar with the containers that give our digital bits form and substance. Being democratizers of technology, as well, ensures that everyone has the ability to use the latest and greatest in electronics.

Libraries and User Interfaces

During the past few months, I’ve been lucky enough to give a handful of presentations with a similar theme: What does the Post-PC world mean for libraries? In the talks, I cover a lot of ground, ranging from why we should care about shifts in information consumption on devices, how we should determine where to focus our attention when we have limited resources (and we always have limited resources in libraries), and what we can expect from the next 3-5 years when it comes to delivering information to our patrons.

One of the aspects of information delivery that is overlooked by libraries is the user interface with which people interact with our digital resources, whether our website, catalog, or the content that we either create or purchase. The biggest shift in the past few years has been towards touch-based interfaces, driven by smartphones and tablets. We’ve had exemplars to follow in this area for a half-decade now. Nearly every major website has a mobile-and-tablet version that makes touch a more pleasant experience for users, with features like increased touch-target sizes, more scroll-based navigation , and other touch-specific flourishes. Amazon, Google, the New York Times, all have changed their websites to improve the experience for people using the iPad or other tablets.

How many libraries do you know that have designed a version of their website solely for patrons using a touchscreen?

Judging from asking that question as I present across the country, I think the answer is very, very few. And this is only one small, small piece of the way user interfaces are changing, and will continue to change, during the next 3-5 years. Interacting with gestures (think of using the Xbox Kinect) or voice (a la Apple’s Siri service) is growing in popularity and may soon be a normal part of the way we use our devices.

The natural progression of computers' integration into our lives seem to be leading towards invisibility. We are using computers, in the form of smartphones and tablets, on the go; whereas we used to always be stationary when interacting with computers. With experiments like Google’s Project Glass and Valve games looking into wearable computing, it seems to me that we are almost certainly less than a decade from on-the-go, heads-up displays being a relatively normal part of our lives.

How will libraries be ready to deliver information in that way, when we’re already a half-decade behind?