Amherst College: Web Observatory

[Twitter @WebObservatory]

aanderson — Thu, 06 Aug 2009 20:24:59 +0000

Andy Anderson Thursday, 8/6/2009, at 4:24 PM

Twitter @WebObservatory

The Twitter Event Stamp

aanderson — Wed, 11 Nov 2015 19:14:55 +0000

The Twitter Event Stamp Andy Anderson Wednesday, 11/11/2015, at 2:14 PM

If you’ve been to a conference lately, it’s hard to miss the “hashtags” such as #SXSW that are announced in introductory remarks and embedded in conference programs. Since the establishment of the microblogging service Twitter in 2006, it has become very popular for conference attendees to use them to provide live descriptions and comments on talks and related events. There are a number of web articles that describe best practices, e.g. A Complete Guide For Event Planners To Using Twitter At A Conference, and these have been taken to heart by conference organizers who want to promote conversations and engagement amongst attendees.

Nevertheless, what usually seems to be missing is some way to quickly get more information about the conference if you aren't attending it yourself and it’s not a high-profile event. I can't count the number of times that I've seen interesting tweets by one or more people that I'm following, but which are accompanied by an obscure Twitter hashtag, e.g. #dlfLAC. I click on the hashtag to find out more and I find myself scrolling backward through scores of tweets, never finding a reference to the conference web site or to the sponsoring organization unless I'm very lucky or very persistent. The 140-character limit of tweets encourages assumed knowledge and also short acronymic tags (although sometimes 4 valuable characters are wasted on the year, which is unnecessary given the short-term visibility of tweets).

I therefore propose a solution to this blind spot, the Twitter Event Stamp, which provides basic information about the conference, announces the tweeter’s attendance, and can be easily retweeted to provide enough weight to promote the stamp to the top of the hashtag search.

For example,

I’m attending #jsgeo! JS.Geo JavaScript for mappy things. Philadelphia, PA 2015-10-08 http://www.jsgeo.com

The basic format of the event stamp is:

I’m attending #<Tag>! <Organization Name> <Brief Description> <Location> <Date> <Web Site>

If you aren't actually attending the conference but rather monitoring it from afar, you can change the first line to

I’m watching #<Tag>!

which will also help bring attention to the conference.

Much as a hyperlink can be complex underneath but with a single click lead to a web page of useful human-readable information, an event stamp leverages the power of social media to focus attention on the basics of an event and provide context for all of the related tweets. Want to read the abstract of that presentation that looks so cool? The event stamp should lead you to it, and perhaps also to an online PowerPoint or video if it’s been made available.

To get the ball rolling, one conference organizer should compose the event stamp and tweet it before the beginning of the conference, and then provide a link to the tweet to other organizers and attendees and ask them to retweet it. Those tweets will also become a record of attendees using Twitter.

Even if the conference organizers don't think to create an event stamp, attendees can do it themselves, and encourage others to retweet it. Or ask that remote person you're following to do so, so that you can learn about what you're missing (thanks, @RhoBott!).

Conferences are collaborative activities, and by participating with a Twitter Event Stamp we can all help raise the profile of our favorite conferences. Once the event stamp becomes common enough, tweeters will get a feel for it and retweet when they see it, making it a useful “standard practice” in the Twitterverse. So I hope you’ll adopt the stamp!

Permalink

Tags: Twitter hashtag Conference event stamp

Google's Chrome OS: A Sculpture by Any Other Name

aanderson — Mon, 13 Jul 2009 22:34:05 +0000

Google's Chrome OS: A Sculpture by Any Other Name Andy Anderson Monday, 7/13/2009, at 6:34 PM

Last week, Google announced (in a low-key blog post) that they are sculpting a new computer operating system, Chrome OS. Starting with an armature of Linux, it will carve off the Desktop and cast Google's Chrome web browser as its user interface. Other common operating system features will be chiseled away to allow its computing power to better support web activities and improve security.

To furnish the all-important documents and applications, Chrome OS will depend on the Cloud, the growing network of remote web sites and databases erected on huge server farms such as those that Google operates. I've worked with a couple of the Google Docs applications (an implementation of Open Office), and found them to be a bit ponderous, but very useful for collaboration with remote colleagues. It's conceivable that a web-focused operating system could help polish their rough edges. But at the moment I'm happy to keep most of my "stuff" firmly on the ground and private.

I originally assumed that the name "Chrome" comes from Netscape's term for the controls and meta-fields of a web browser, usually gray-colored or metallic. Google certainly didn't want to imply that the browser/OS will be flashy but with little substance! However, given their stated intentions, I've now realized that the name must come instead from the Cloud Gate sculpture in Chicago's Millennium Park:

Permalink

Tags: Chicago cloud gate Google Open Office Millennium Park Chrome OS

Making AJAX Truly Asynchronous

aanderson — Mon, 01 Jun 2009 14:55:33 +0000

Making AJAX Truly Asynchronous Andy Anderson Monday, 6/1/2009, at 10:55 AM

AJAX (Asynchronous JavaScript and XML) is a technique that lets web pages update themselves with remote data without reloading the entire page, greatly increasing their interactivity. It uses JavaScript to change the content of the page, and the non-standard function XMLHttpRequest() to talk to remote web servers to obtain or provide new data. All of this occurs in the background, allowing the user to interact with other elements on the page at the same time.

AJAX is described in many places on the web and in technical books, but from what I've seen the usual examples are not truly asynchronous, as rapid multiple requests by the user can collide with each other. The following is typical code:

var request;

function action()
{
    request = new XMLHttpRequest();     // Browser variation and error catching code should be here, too
    request.open('GET', 'action.php');  // Open a connection to this URL, in this case a local page
    request.onreadystatechange = handle_action;  // Function to process the request results on completion
    request.send(null);                 // Send the request, which proceeds in the background
    return 0;                           // Returns control of the browser to the user
}

The basic problem is in the request variable, which is set up as a global so that the function handle_action can reference the returned data it contains. This means that a second request of the same type can possibly overwrite the previous request before it has completed its assigned task! And it's not truly asynchronous if it doesn't control its own state.

The following variation fixes the issue:

function action()
{
    var request;
    request = new XMLHttpRequest();
    request.open('GET', 'action.php');
    request.onreadystatechange = function () { return handle_action(request); };
    request.send(null);
    return 0;
}

By making request a local variable and providing it as a parameter to the request handler, each request has independent status. The request handler is implemented as an anonymous function and a closure, which preserves a reference to the local variable even after the parent function exits.

Permalink

Tags: javascript AJAX XML