Archive for the 'Web Apps' Category

Google Apps Script: Using a Google Spreadsheet to populate a Twitter list [Hashtag Communities]

Having recently rediscovered the joys of Google Apps Script I was looking for something to do after my Event Manager Spreadsheet. A couple of ideas I had were: something to do with linked data (possibly a email subscription list); or having read the Google Apps Script Twitter Approval Manager Tutorial something around an automated timezone retweet system.

But while wandering through the Virtual coffee shop at Innovating e-Learning 2010 I noticed a post from my colleague at RSC Eastern, Shri Footring asking:

Does anyone know whether there an automated way to create a twitter list of everyone who has used the tag #jiscel10 in a tweet?

I’ve been closely following Tony Hirst’s work on visualising community and user networks using Gephi (partly to play ‘Where’s Wally’ as I vainly try and spot myself in the various network visualisation). I also new Tony had released his Twitter Community Grabbing Code –, which if I had ever coded in Python would let me solve Shri’s problem in a blink of an eye.

Instead I thought it would be completely insane interesting to see if I could replicate some of Tony’s functionality in Google Spreadsheets. And guess what you can! So here’s how. [You can shortcut some of the steps in 1, 3–5 by copying this Spreadsheet]

How-to create a Twitter list from Google Spreadsheet

  1. Follow the steps in the Google Apps Script Twitter Approval Manager Tutorial up to and including authorising your spreadsheet with Twitter (if you start Tweeting you’ve gone too far)
  2. Generate a list of twitter usernames you would like to add to a list. I did this by exporting the jiscel10 hashtag archive from the Twitter archiving service Twapper Keeper (I used the export and download button. If you use Excel Permalink (beta) option increase the View Limit)
  3. Import this data to a sheet of the Twitter Approval Manager Spreadsheet. You can edit this data the important thing is that there is a column with the heading from_user and preferably it’s in column C
  4. Insert a new sheet called ‘To add to Twitter List’ and in the first cell enter ‘=UNIQUE(Sheet1!C:C)’ (this strips out an duplicate twitter usernames)
  5. Open the Spreadsheets script editor by clickingTools > Scripts > Script Editor and copy the code at the end of this post at the end of the spreadsheet script. Click on Run > onOpen (this should save changes to the script), then close the Script Editor.

In the Twitter drop down menu on the main spreadsheet  you should have 2 options Add to a List and Purge a List.

Add to a List
When you select add to a list you’ll be prompted for a list name. This list must already existing on your Twitter account even if it has no follower. Once you enter the list name the spreadsheet should start adding usernames. This process can take some time depending on the size of your list (the maximum is 500) and you will be prompted when it is done. You can always open a separate browser window with the twitter list to check if names are being added. 

Purge a List
I’ve included a purge option to allow you to rebuild the list without deleting it entirely. This means followers of a list won’t be lost. Again this process can take some time so be patient.

The code

Note: For this code to work you also need the code from the Twitter Approval Manager

// Add list of twitter usernames to a Twitter list
// coded by @mhawksey
// Available under Creative Commons Attribution-ShareAlike 2.5 UK: Scotland License
var SCREEN_NAME = "";
function onOpen() {
  var ss = SpreadsheetApp.getActiveSpreadsheet();
  var menuEntries = [ {name: "Add to a List", functionName: "addToList"},
                      {name: "Purge a List", functionName: "purgeList"},
                      {name: "Tweet", functionName: "tweet"},
                      {name: "Configure", functionName: "configure"} ];
  ss.addMenu("Twitter", menuEntries);
function getScreenName() {
  var oauthConfig = UrlFetchApp.addOAuthService("twitter");
  var requestData = {
    "method": "GET",
    "oAuthServiceName": "twitter",
    "oAuthUseToken": "always"
  var result = UrlFetchApp.fetch(
  var o  = Utilities.jsonParse(result.getContentText());
  SCREEN_NAME = o.screen_name;
function twitterList(method, list, query){
  if (SCREEN_NAME==""){
  var requestData = {
        "method": method,
        "oAuthServiceName": "twitter",
        "oAuthUseToken": "always"
   try {
      var result = UrlFetchApp.fetch(
      var o  = Utilities.jsonParse(result.getContentText());
    } catch (e) {
   return o;
function purgeList(){
  var list_id=Browser.inputBox("Enter list name to purge:");
  while(twitterList("GET", list_id,"").users.length>0){
    var object = twitterList("GET", list_id,"");
    for (var i = 0; i < object.users.length; ++i) {
      twitterList("POST", list_id, "?_method=DELETE&id="+object.users[i].screen_name);
  Browser.msgBox("List purged");
function addToList(){
  var ss = SpreadsheetApp.getActiveSpreadsheet();
  var dataSheet = ss.getSheetByName("To add to Twitter List");
  var dataRange = dataSheet.getRange(2, 1, dataSheet.getMaxRows(), 1);
  //get list name to add users to (must already exist)
  var list_id=Browser.inputBox("Enter list name to add users to:");
  objects = getRowsData(dataSheet,dataRange);
  for (var i = 0; i < objects.length; ++i) {
    var rowData = objects[i];
    if (rowData.fromuser!="" ){
      try {
        var o = twitterList("POST", list_id, "?id="+rowData.fromuser);
      } catch (e) {
  Browser.msgBox("The list now has :"+o.member_count+" members");
// The code below is reused from the 'Reading Spreadsheet data using JavaScript Objects'
// tutorial.
// getRowsData iterates row by row in the input range and returns an array of objects.
// Each object contains all the data for a given row, indexed by its normalized column name.
// Arguments:
//   - sheet: the sheet object that contains the data to be processed
//   - range: the exact range of cells where the data is stored
//   - columnHeadersRowIndex: specifies the row number where the column names are stored.
//       This argument is optional and it defaults to the row immediately above range;
// Returns an Array of objects.
function getRowsData(sheet, range, columnHeadersRowIndex) {
  columnHeadersRowIndex = columnHeadersRowIndex || range.getRowIndex() - 1;
  var numColumns = range.getEndColumn() - range.getColumn() + 1;
  var headersRange = sheet.getRange(columnHeadersRowIndex, range.getColumn(), 1, numColumns);
  var headers = headersRange.getValues()[0];
  return getObjects(range.getValues(), normalizeHeaders(headers));
// For every row of data in data, generates an object that contains the data. Names of
// object fields are defined in keys.
// Arguments:
//   - data: JavaScript 2d array
//   - keys: Array of Strings that define the property names for the objects to create
function getObjects(data, keys) {
  var objects = [];
  for (var i = 0; i < data.length; ++i) {
    var object = {};
    var hasData = false;
    for (var j = 0; j < data[i].length; ++j) {
      var cellData = data[i][j];
      if (isCellEmpty(cellData)) {
      object[keys[j]] = cellData;
      hasData = true;
    if (hasData) {
  return objects;
// Returns an Array of normalized Strings.
// Arguments:
//   - headers: Array of Strings to normalize
function normalizeHeaders(headers) {
  var keys = [];
  for (var i = 0; i < headers.length; ++i) {
    var key = normalizeHeader(headers[i]);
    if (key.length > 0) {
  return keys;
// Normalizes a string, by removing all alphanumeric characters and using mixed case
// to separate words. The output will always start with a lower case letter.
// This function is designed to produce JavaScript object property names.
// Arguments:
//   - header: string to normalize
// Examples:
//   "First Name" -> "firstName"
//   "Market Cap (millions) -> "marketCapMillions
//   "1 number at the beginning is ignored" -> "numberAtTheBeginningIsIgnored"
function normalizeHeader(header) {
  var key = "";
  var upperCase = false;
  for (var i = 0; i < header.length; ++i) {
    var letter = header[i];
    if (letter == " " && key.length > 0) {
      upperCase = true;
    if (!isAlnum(letter)) {
    if (key.length == 0 && isDigit(letter)) {
      continue; // first character must be a letter
    if (upperCase) {
      upperCase = false;
      key += letter.toUpperCase();
    } else {
      key += letter.toLowerCase();
  return key;
// Returns true if the cell where cellData was read from is empty.
// Arguments:
//   - cellData: string
function isCellEmpty(cellData) {
  return typeof(cellData) == "string" && cellData == "";
// Returns true if the character char is alphabetical, false otherwise.
function isAlnum(char) {
  return char >= 'A' && char <= 'Z' ||
    char >= 'a' && char <= 'z' ||
// Returns true if the character char is a digit, false otherwise.
function isDigit(char) {
  return char >= '0' && char <= '9';

eAssessment Scotland 2010: Twitter workshop reflections

Last Friday I ran a Twitter workshop as part of ‘eAssessment Scotland 2010: Marking the decade’. In the programme I described the session as:

What’s happening? Twitter for Assessment, Feedback and Communication

Twitter is a social networking site which continues to divide personal opinion. Some believe that the micro-blogging service is just an opportunity celebrities to boost their ego with millions of followers or just full of people ‘tweeting’ what they had for lunch. Whilst some users do use Twitter for this purpose a number of academics are now discovering that Twitter has the potential to support teaching and learning, providing a means to enable students to discuss and share within their personal learning network. Before you dismiss Twitter there are some basics worth considering: the service is free to register, status updates can be made from the most basic mobile phone, and users can monitor conversations through multiple means including, for some users, sending free SMS updates.

This workshop uses some of the features of Twitter highlighted above to let participants experience and use this service as a free electronic voting system (EVS), for classroom administration (assessment notification/reminders) and to monitor real-time student evaluation. As this technology is relatively new the workshop will begin with an overview of basic Twitter interaction making it suitable for novice and expert users.

I was perhaps too ambitious to include ‘novice’ users and it would have been better if I either focused on beginners or intermediate/advance users. The workshop I delivered was probably more beneficial for the later, but hopefully novice users were tantalised by the utility of twitter.

During the workshop I really missed having Timo Elliott’s PowerPoint AutoTweet tool (which is broken because of authentication changes at Twitter). This would have been really useful to send out links during the presentation (this example shows how I used it for another presentation).

As a number of participants had only just created Twitter accounts the week before it looks like Twitter quarantines their tweets preventing them from appearing in search results (I guess they wait until you hit some threshold in terms of following/followers/tweets to make sure the account isn’t being used from spam).

In the sides you’ll noticed I’ve revived the Twitter voting tool (TwEVS). Previously this solution relied on using Yahoo Pipes to manipulate results from Twitter, which meant graphs didn’t always have the latest results because of caching. To get around this I’ve created a script which can be run from a webserver. Here is the new TwEVS interface (you can also download the code).

What’s happening? The ‘utility’ of Twitter in teaching and learning

In this post I want to put down a marker as to the role I think Twitter could have within education. When previously presenting on the use of Twitter in education I’ve always tried to emphasis its not just about a tool for discussion (in fact I try to avoid the word discussion because 140 characters can seriously hamper the depth you can go into), but instead Twitter which can be easily interacted with via its API and 3rd party services has the potential to be used as the building blocks for a service to support teaching and learning.

Some examples for you.

Does your institution use (or is about to cut) a SMS service to send administrative information to students? If so you could save yourself 4p per text by asking students to follow a Twitter account and receive free SMS updates if they are customers of one of the four big mobile network operators.       

Do you use or want to use electronic voting in the classroom but don’t have enough handsets or are frustrated when students don’t bring them in? If so Twitter can be used as a mechanism for collect votes even using the most basic mobile phones.

Making a strategic decision to use Twitter for different aspects of the educational experience I believe students are less likely to perceive it as a gimmick and consequently more likely to take more ownership of it as a tool to support their own education.

A nice diagram I came across recently which illustrates the ‘different aspects of Twitter’ this is Mark Sample’s Twitter Adoption Matrix which featured in his A Framework for Teaching with Twitter post.

Twitter Adoption Matrix  

(Mark has followed up his post with another expanding on Practical Advice for Teaching with Twitter, which is also worth a read)

The idea of building applications around social network sites to aid teaching and learning isn’t new. Examples like OU’s SocialLearn and Purdue’s Hotseat spring to mind. Perhaps the issue with these is they are designed around breadth instead of depth, trying to tap into the illusive Personal Learning Environment.

What if instead we ignore the personal and focus on the functional. That is building applications around Twitter to provide students and tutors with the tools to support learning, focusing on formal uses enabling opportunities for serendipitous informal learning. 

But why Twitter and not Facebook or FriendFeed et al.? For me it comes down to a couple of things. With Facebook there is the ever distraction of games, friends and family. Twitter stripes a lot of this away. FriendFeed is better in terms of simplicity but you are not restricted by 140 characters. Whilst this makes FriendFeed a better tool for deep discussion it makes it less mobile friendly (i.e. you can read notifications from Twitter on the most basic phone via SMS).

Finally flexibility. My favouring of Twitter’s flexibility is perhaps down to my own limitations as an educational mash-up artist. I find it a lot easier to extend Twitter’s functionality because of the simplicity of the core product and number of examples that can easily be adapted.

Hopefully you are getting my gist. Focus on adopting Twitter as a tool. Think of Twitter’s utility. The utility to collect comments. The utility to collect votes. The utility to send notifications. Through focusing on utility you are creating opportunities for other learning theories to come into play enabling the transition from formal to personal.

Twitter/YouTube commenting: Embeddable, open sourced and with its own WordPress plugin [uTitle]

Player embedPlayer embed with jump navigation

Having added embed options for the Twitter subtitling of live events (iTitle), it made sense to include these with the Twitter/YouTube commenting tool (uTitle). As both these tools have some code in common adding embed options for the player and player+navigation was relatively straight forward. So now you can embed Twitter commented YouTube videos in other sites.

But what about providing an interface to let people comment on videos from your own site? This is now also possible … kind of.

Using the same method for embedding the player with jump navigation <iframe>, it is possible to just make a bigger one which includes the whole of the screen. The issue I haven’t been able to resolve is that the user needs to authenticate via Twitter. This processes unfortunately breaks the user out of the <iframe>, before automatically redirecting back them back to the comment interface on My preference would be if a users is making a comment via uTitle embedded on that you stay on that site.

A possible workaround would be for to host their own version of the uTitle interface. So here it is the uTitle source code on github.

That just leaves the WordPress plugin. This was suggested by Dries Bultynck
in response to the original uTitle post. As I plan on using commentable videos on this blog it seemed like a good idea to put something together on this. So here it is the WordPress uTitle Plugin. This turns a custom shortcode into an embed/iframe.


is turned into …

Comments powered by Twitter Click here to add yours ...

which is nice

Twitter subtitling, the three E’s: Embed, embed, embed

downloadA conversation with Brian Kelly led to a quick refresh of the Twitter Subtitle Generator (iTitle) [I’ve got tired of linking to all of mine and Tony’s previous posts on this so started the Twitter subtitling wikipedia entry].

Brian was interested in using iTitle to create twitter captioned versions of videos from IWMW10. Their plan was to use Vimeo to host the videos as it allows upload of videos greater than 10 minutes. This led me to update the iTitle code to include the timeline jump navigation which I originally developed for YouTube videos.

Whilst doing this it occurred to me that I should really get around to providing a way for users to direct link to the results page (something I had been meaning to do from the very beginning). What this means is if you are using the iTitle for in-browser playback of subtitled YouTube or Vimeo videos you can share the results with a direct link. So for example you can see Brian’s open address for IWMW10 at or the Google I/O 2010 Android Demo at 

More importantly I thought it would also be useful to include the ability to embed the results in other websites. With the introduction of the timeline jump navigation using the typical <embed> code you see with YouTube video isn’t possible (also I’m also using the HTML5 version of Vimeo videos which also doesn’t <embed>).

I’ve instead opted to automatically generating some <iframe> code which is included in the display/result page. So using Brian’s speech again as an example the resulting code generated to embed the video in your own website is:

<iframe style="border-bottom: medium none; border-left: medium none; width: 470px; height: 570px; overflow: hidden; border-top: medium none; border-right: medium none" src="" frameborder="0" allowtransparency="allowtransparency" scrolling="no"></iframe>

which gives:

To display just the video player with twitter subtitles I was able to <embed> code for the YouTube videos as they are Flash based. The JW Player which I use for playback has a ‘viral plugin’ which can generate the embed code (and send email links). A big plus point is that it preserves the link to the Twitter subtitle file. The player only version of Vimeo uses <iframe> again. With all these embed options I leave it to the author to decide if they link back to the original.

An update on YouTube/Twitter commenting (uTitle) coming soon …

Embeddable web services for student support

I was recently asked to identify some free embeddable web services which could be used in a website to support students considering articulation/progression routes from further to higher education. In particular they were interested in producing a visually appealing timeline which allowed students to see key dates, linking to additional resources. Below is a quick screencast I put together of 6 web services which might be of interest and where possible examples of their use in existing educational sites:


Timeglider is a free service for making embeddable timelines. Here’s an example of a Timeglider timeline  (clicking on timeline items allows you to link to other resources). This tool uses specific date ranges but you could get around reprogramming it each year by setting it around 0AD or 1900.


Google Calendar is embeddable calendar.  This could be used in a similar way as the timeline tool but is less visually attractive. Unlike Timeglider key dates could be set as reoccurring so once created there could be minimal updates required. The advantage of Google Calendar is it automatically generates links which when clicked offer to be included in the students calendar software, if it is compatible.  Example of embedded calendar at the Wittenburg University


Wallwisher is a online interactive notice board. There are potentially two ways you could use this: as a constructed noticeboard made by staff linking to resources, highlighting important information (a variation on the timeline idea). Alternatively as the University of Central Lancashire TAG site use it, as a method for getting feedback from students.

Online chat widget

Meebo is a chat widget used by a number of libraries in the region (and further afield). This allows a visitor to chat with a staff member via a little instant messaging window. An example of this can be seen on the QMU library site ‘Ask us’. (Along similar lines there is another embeddable video chat service call Tokbox)


getSatisfaction is a web service designed to allow companies to integrate a customer engagement/support service within their website. The service allows a user to ask a question, share an idea, report a problem or give praise. The process of creating a question or comment also automatically generates a FAQ. An example of how this can be integrated is on the University of Hawaii Library site.

Other examples gratefully received …

Using Google Spreadsheet to automatically monitor Twitter event hashtags and more

I recently read Tony Hirst’s onFormSubmit – Raising Web Scale Events in Google Spreadsheets post which highlights opportunities with the new event triggers (the ability to trigger scripts on events like form submit or time-driven like every x minutes) and was blown away by the possibilities. My first thought was to re-examine my event booking spreadsheet but when I saw the twitter conversation below between Brian Kelly and Tony (psychemedia) I saw something better to do - a Google Spreadsheet which could capture and report the daily/weekly twitter activity from an event hashtag .

Brian Kelly (briankelly) @psychemedia @mweller Ive just captured stats & image of word cloud if#iwmw10 tweets to observe changes over time.
7:34 PM Jun 14th via Seesmic

Tony Hirst (psychemedia) @briankelly have you scheduled that capture using a service, or is it a manual chore?
7:43 PM Jun 14th via TweetDeck in reply to briankelly

Brian Kelly (briankelly)@psychemedia A manual capture now, week b4, during & after. Will help understand if worth development effort.
7:48 PM Jun 14th via Seesmic in reply to psychemedia

So here it is my Twitteralytics Google Spreadsheet. The video below gives a quick overview of how to set it up and what it does:

In summary the script is designed as a way to automatically pull daily or weekly results from twitter, summarise them and push an update via email. The spreadsheet also keeps a copy of the sampled tweets which could be used for further analysis down the line but I would recommend you only use this as a backup for a separate twitter archive on Twapper Keeper. There are also a number of other services which are probably better for more in-depth post analysis of event hashtag communities like Andy Powell Summarizr or Tony Hirst’s Yahoo Pipes for Personal Twitter Networks in Hashtag Communities.

While the spreadsheet was created to monitor event hashtags it could easily be modified for other applications. For example, I’m sure it could be easily modified to collect continuous student with twitter (as highlighted by AJCann). Also, it doesn’t have to be limited to Twitter results, the same framework could be used for other XML and HTML data.

How it was done

As always I like to document how it was done. The rough process of the script is:

  1. Open spreadsheet by ID (required when using event triggers)
  2. Copy the TMP sheet giving it the script execution date/time as a name
  3. getTweets from Twitter – more about this later
  4. Write results to new sheet
  5. Copy total and top tweeters to ‘Summary’ page
  6. Prepare and send email of summary results

The getTweets script I picked up from Mikael Thuneberg from, making a small modification to include date limits. The script uses built-in functions for fetching external data and parsing the results.

The TMP sheet also has some useful formula’s worth highlighting.

  • H2 - ‘=UNIQUE(E2:E)’ creates a list of the authors removing duplicate entries.
  • I2 - ‘=EXPAND(ArrayFormula(IF(ISBLANK(H2:H), "", COUNTIF(E2:E,H2:H))))’  for every unique author in column H the formula count the number of times there name appears in column E
  • A2 - ‘=SORT(H2:I, I2:I, FALSE)’ sorts the values in column H (author names) by column I (the number of occurrences) 

All of these formula automatically fill the column with results. More information on Google Spreadsheet formulas is here.

Convergence @youtube meets @twitter: In timeline commenting of YouTube videos using Twitter [uTitle]

Previously when looking at twitter subtitling of videos the focus has been on replaying the backchannel discussion with the archive video from live events. The resulting ‘Twitter Subtitle Generator’ has now been used to generate and replay the twitter stream for programmes on the BBC iPlayer (some iPlayer examples), the JISC 2010 Conference (See Searching the backchannel with Twitter subtitles) and more recently as a way to enhance lecture capture. The founding premise behind all these examples and the question originally posed by Tony Hirst was how to allow a user to experience and replay the synchronous channels of what was said from the stage, and what was said about what was said from the audience (physical and virtual). Having looked at synchronous communication I was interested to extend the question and look at asynchronous communication (i.e. what was said about what was said after it was said).

My first step has been to experiment with the use of Twitter for timeline commenting on YouTube videos. The idea of timeline commenting of media isn’t entirely new and has been a feature of audio services like SoundCloud for a while. Likewise I’m sure the idea of integrating with the Twitter service as a method of capturing comments has also been used (but for the life of me I can’t find an example- another project perhaps).

The result is a prototype tool I’m calling uTitle. How it works is best explained in the video below:

As can be seen in the video uTitle allows a user to make comments at any point in the video timeline. These comments are also captured and can be replayed and added to at a later point. The link below lets you try out uTile for yourself (the paint is still wet so if you come across any problems or have any feedback this is greatly appreciated – use comments below).

Click here to try uTitle (or here for an existing example)

Some notable points

A couple of features of uTitle worth highlighting. Firstly, as demonstrated by the example link above it is possible to directly link to a timeline commented video making sharing resources easier. Another important point is that because twitter comments for YouTube videos are aggregated by using the video id this makes it possible to use this data with other services (at one point I was considering short-coding the ids to make less an impact on the Twitter 140 character limit, but I wanted to make generated tweets has human readable as possible.

How it was done

For those of you interested here are a couple of the key development milestones:

Step 1 Indentify way to integrate with Twitter
I already knew Twitter had an API to allow developers to integrate with the Twitter service so it was a case of finding a head start on which I could build upon. As I do most of my coding in PHP I went straight to this section of the Twitter Libraries. Having tried a couple out I went for TwitterOAuth by Abraham Williams (mainly because it used OAuth and when I looked at the code I could understand what it was doing).

Step 2 Submit a form without page refresh
Something I’ve known is possible for a while but never needed. I knew I wanted to allow users to make comments via uTitle without refreshing the page and loosing their place in the video. This post on Ask About PHP was perfect for my needs.

Step 3 Jot down the pseudo code
This is what I wanted uTitle to do:

  • Get YouTube video id
  • If video id doesn’t exist as a notebook on Twapper Keeper make one
  • Else get results from Twapper Keeper for video id
  • Get results from Twitter Search
  • Merge data and remove duplicates
  • Generate XML subtitle file from results
  • Display interface page
    • On comment submit to twitter

Step 4 Put it all together
Some late nights pushing bytes across the screen …

These examples demonstrate how it is relatively straight forward to extract part of the Twitter timeline

Future development areas

Some quick notes on areas for further research/development:

Comment curation/admin – currently anything on the public timeline with a YouTube video is pulled in. A similar problem exists for the Twitter Subtitle Generator and it is something Tony and I have identified as a feature … but just haven’t had a chance to implement a solution. Part of the reason for developing the prototype is to start finding use cases (ie find out where the ship is leaking)

Merging synchronous with asynchronous – basically how can Twitter Subtitle Generator and uTitle be merged so comments can be collect post event (the issue here is there are two ways the subtitle timestamps would have to be generated and distinguishing what was said from what was said about what was said).

Other video sources – I’m primarily interested in how uTitle might work with BBC iPlayer (particularly as the latest developments are exploring social networks – as highlight by Tony).

Spamming your followers with comments – Interested to see if users are willing to use there main twitter account for generating comments.

Hmm I think I may have bitten off more than I can chew …

Using Yahoo Pipes to generate a Twitter ‘out of office’ messaging service

[This post is probably less about creating a Twitter out of office service and more about an illustration of the power of Yahoo Pipes (and embedding flickr images with notes), I’ll let you read and decide]

Whilst the majority of twitter users will probably never need to setup a email style ‘out of office’ messaging service to respond to ‘@replies’ because they are never that far away from their timeline, I sure there are emerging cases where certain twitter accounts might need this feature. In particular, I thinking of something like a class twitter account is being used to send notifications (you might like to read this post on free SMS broadcast via twitter), curate discussions or one of the many other ways you can teach with twitter (compiled by Steve Wheeler).

In this scenario we want to respond to ‘@replies’ (tweets directed at you from other users), with a message to indicate that your won’t be able to immediate respond.  I did a quick ‘Google’ to find if anyone had setup a ‘Twitter – Out of Office’ service and couldn’t see anything (which probably suggests no-one needs this service or they just haven’t thought of it yet).

Starting with the Twitter Advance Search you’ll see there are a number of options to search for tweets based on keywords, people referenced and dates (as well as some other options). So it is very easy to setup a search which will filter messages sent to a user between dates, tweaking to remove tweets which might include RTs or via. Here is an example which ignores RT and via to mhawksey since 29th May until 29th May (twitter search is limited to the last 7 days so if you are trying this after the 5th June you won’t see any results, but hopefully you get the idea).

Twitter search results

Twitter - Feed for this querySo it is easy to setup a search which can identify possible messages you might want to send an out of office response, but how can we use this information? The key is that Twitter provides a feed for the search query. That is it provides the data for the search results in a machine readable format, RSS.

The next step in to use the data from twitter to generate a response message. The best service I know to do this is Yahoo Pipes. Pipes is a free service which provides an nice graphical interface for manipulating data like RSS.

Below is a screenshot of a pipe output I’ve created which takes a twitter username, date range and custom response message and manipulates it to produce a unique response message.

Yahoo Pipe results

If you are interested in how this pipe works you can click here for the Twitter – Out of Office (Date Range) pipe and view the source or the image below contains hotspots which explains what the blocks are doing:

The final step is to get your twitter account to send the ‘out of office’ message. This is where RSS comes to our rescue. As well as Yahoo Pipes being able to manipulate RSS it can also output in this format as well. By copying the ‘Get as RSS’ from after you run your pipe you can use this with one of the RSS to Twitter services (currently I use either or the ‘Publicize –> Socialize’ option in Feedburner). It will look something like:


When setting this up choose to tweet ‘Title only’ and untick ‘include link’ or ‘post link’. Once you’ve created your RSS to twitter service you can also reuse it for future holidays. To save you going back through running the pipe you can just edit the feed url with new start and finish dates.

There are a lot more things you can do with Yahoo Pipes. For example, here is another pipe which uses as named day to create a recurring out of office message (notes on this pipe are here). 

Hopefully you get the idea of what is possible. If you are interested in more ‘Pipe’ manipulations I would recommend having a browse through Tony Hirst’s offerings.

Presentation: Twitter for in-class voting and more for ESTICT SIG

Today I presented some of my work on twitter voting to the Engaging Students Through In-Class Technology (ESTICT) special interest group. This group “is a UK network of education practitioners and learning technologists interested in promoting good practice with classroom technologies that can enhance face-to-face teaching.”

I used this slot as an opportunity to try out some some presentation techniques. The first was using Timo Elliott’s PowerPoint auto-tweet plugin which allows you to automatically tweet notes as you work through the slide deck. The plan was that this would provide ready made links and snippets for re-tweeting, favouring or just copying into a users personal notes. I also did this to generate information to twitter subtitle my presentation. An unforeseen benefit was that the tweets provided a stimulus for further discussion after the presentation.

The other technique I picked up from was from a presentation by Tony Hirst in which he included links to secondary resources by only displaying the end of a shortened url. This is demonstrated in the presentation (with twitter subtitles of course ;-) (the link also contains a recipe for lecture capture enhancement):

ESTiCT Presentation link


This blog is authored by Martin Hawksey e-Learning Advisor (Higher Education) at the JISC RSC Scotland N&E.

JISC RSC Scotland North & East logo

If you would like to subscribe to my monthly digest please enter your email address in the box below (other ways are available to subscribe from the button below):

Subscribe to MASHe to monthly email updates


The MASHezine (tabloid)

It's back! A tabloid edition of the latest posts in PDF format (complete with QR Codes). Click here to view the MASHezine

Preview powered by: Webthumb

The MASHezine (eBook)

MASHe is also available in ebook and can be downloaded in the following formats:

Visit to manage your subscription


Opinions expressed in this blog are not necessarily those of the JISC RSC Scotland North & East.

JISC Advance Logo

JISC Advance is a new organisation that brings together the collective expertise of established JISC services:

For further information visit

Creative Commons Licence
Unless otherwise stated this work is licensed under a Creative Commons Attribution-ShareAlike 2.5 UK: Scotland License