October 2002 Archives

Video Blog Experiment Follow-Up.

Jeremy Allaire has posted a frank assessment of Macromedia's experiment with audio and video weblogging that I recently wrote about.

Overall, I agree that it was a good and worthwhile experiment. One area where I'm not so sure is the coarse grained nature of video weblog entries. Jeremy says "this is somewhat analogous to the world of weblogs in general, where most writers do not have a lot of polish, and often the entries are short, unedited, and not meant to be replacements for full on reporting or commentary."

To a certain extent this is true, weblog writing is typically unpolished. (This entry being a case in point.) However, even as I write this entry I am editing myself. First in my head before typing and then again in a quick read over what I typed. Video is more difficult to edit and structure because it either requires scripting and rehearsing of lines or the skill and availability of a video editing facilities. I've been typing since grammar school, but I couldn't edit a video today if I tried. The majority of us are not accustomed to how video is best structured and utilized creating a barrier to its common use in weblogging.

[UPDATE: Jon Udell posts has posted his comments on this topic here.]

I released two new versions of my plugins today -- mt-rssfeed (finally!) and mt-list.

mt-rssfeed v1.0, is a MovableType plugin that provides a series of tags for retrieving an RSS feed and inserting it into a MovableType template. RSS is an XML-based syntax for facilitating the exchange of resources in a lightweight fashion through the syndication of links to content. The changes from the previous version 0.35a are quite substantial. In fact, its been completely rewritten from the ground up. Changes include:

  • New tags including complete <image> tag support, <MTRSSFeedItemCount>, <MTRSSFeedURL>, and <MTRSSFeedDescriptionEncoded>
  • Introduced new <RSSFeedElement> and <RSSFeedItemElement> tags to access to access any data in the RSS feed that is not directly supported by the plugin.
  • New version of RSS liberal parser (XML::Parser::LP) is completely namespace aware.
  • Complete rewrite of code to reduce the impact on MT system performance, better overall error handling and make the plugin more robust, extensible, maintainable.
  • More intelligent bandwidth friendly caching system using If-Not-Modified headers.
  • Intelligent mapping of tags. For instance, <$MTRSSFeedLanguage$> looks in <dc:language> and then <language>.
  • Ability to support and configure proxy usage.
  • Introduction debugging facilities including standard and verbose modes.

mt-list v0.2, is a MoveableType plugin for creating simple lists (arrays) within a template or text file. Once defined, the list can be looped over, sorted or selected from randomly during the template generation. mt-list enhances the capabilities of mt-rssfeed by allowing multiple feeds to be retreived and inserted using the same layout. (See the included documentation for more information.) This plugin has designed to be easily integrated with other plugins requiring this type of list and looping functionality. This is a minor release includes a few bug fixes, improved documentation and introduces its own debugging mode. It is recommended that you upgrade your mt-list plugin, particularly if you are going to use it with mt-rssfeed.

Both tags can be downloaded from my MT plugins page here.

Macromedia's annual developers conference, DevCon 2002, began in Orlando today. In his weblog, Macromedia CTO Jeremy Allaire notes, "one of the most interesting things that we're doing is trying to leverage our community managers and other blogging Macromedians to keep the extended community of developers up to speed with what's happening at the conference. While we're certainly not the first group of people to religously blog conferences, speeches and events, I think we're the first major software company to do live, employee-driven blogging of a corporate event, and certainly the first to integrate audio and video into our digital journalism toolbox."

The audio and video postings from the conference are located here. A SOAP web services of the can be found at http://bilbo.macromedia.com/devconblog/activeblogs.cfc?wsdl. For fun and kicks I banged out a quick script that converts the data from their SOAP Web service to an RSS feed every 15 minutes. My feed can be found here.

Phil Ringnalda writes about the irony in Sam Ruby's post about valid RSS and the problems with entity encoded HTML. I've been quite vocal that entity encoded HTML is a bad idea that we need to get away from. Phil's post just illustrates exactly what I'm getting at. The forefathers of the XML specification intended for markup to be encoded with CDATA, NOT with entity encoding. Had the practice of entity encoding been avoided as bad form (as it should), issues like Phil's would almost be non-existent.

In related news, Shelley Powers points out an unexpected surprise she had when using the MovableType templates that the RSS Validator provides -- its will included the entire text of the post in the feed. This is OK if that is your intention, but it also means large feeds which suck up bandwidth. In being a good citizen I've begun offer a feed with the full content in addition to the standard feed with just a descriptive excerpt.

It no secret that RSS 2.0 format contains many questionable design decisions that where developed with an even more questionable approach. Guidelines for developing namespaces are virtually non-existent in the current documentation. The default namespace cannot be declared. Entity encoded HTML is not only permitted (and evil) but encouraged. (My thoughts here.) Overlapping tags such as language and webmaster are not depreciated and no guidelines are given to precedence between these tags and their modular equivalents. Then there is my favorite, all tags within an item are completely optional -- either a title or description must be present. The list goes on and is quite long. The RSS 2.0 design team format had the opportunity to rectify these issues and failed to do so. In fact in some cases it made the situation worse.

Some will argue that RSS's current design is advantageous as they provider publishers to choose what suits them. I disagree because they generally undermine predictability for consumers impeding them with a plethora of variables that seem to change daily. This is unfortunate because developers of RSS consumer software, such as aggregators or toolkits, will be forced to repeatedly put effort into addressing these odd, yet "legal," variants. This effort would better serve the community and the proliferation of RSS if it where focused on advancing RSS applications. I believe in flexibility and evolable formats to a degree, but these issue cross that line into design flaws.

Recently, while testing the latest release of my RSS Feed plugin for MovableType, I found a feed that uses a guid tag instead of the commonplace link tag most software expects will be present. Perfectly legal, but it breaks existing software. So what is the point?

Brent Simmons asked whether RSS feeds should allow relative hyperlink in embedded HTML and if so what should an aggregator like his NetNewsWire do? The general consensus was that hyperlinks should be absolute, but there where those who disagreed and felt like browsers, the aggregators should resolve relative URLs. The lack of documentation leaves the question open to interpretation. (For the record I believe hyperlinks should be absolute. Its easier for the publisher to resolve and RSS feeds often exist in different location then the HTML that is embedded.) The fact that this question needs to be asked seems silly to me.

Sam Ruby points out that "a number of things which are quite legal RSS, but are less than neighborly." He is calling for the community to discuss best practices that he and Mark Pilgrim will then implement as warnings in their RSS Vaildator service. I completely agree and back this as the next logical step.

The purpose of the XSS profile I drafted was to add additional constraints to the existing RSS 2.0 format that makes feeds more predictable and more "neighborly." The XSS profile draft attempts to balance ease of use and authoring with ease of consumption by applications while maintaining the richness necessary to be extended and adaptable. I resubmit XSS for the community's consideration in the discussion Sam has proposed.

Being valid RSS (or XSS for that matter) does not guarantee that a feed's content is well-formed enough to be useful to an end user. Here are some additional editorial recommendations to making feeds more useful and well-formed:

Use CDATA for embedding HTML in description tags. I can't advocate this enough. This is perhaps the most important recommendation I can make because it goes a long way to avoiding malformed XML/RSS files with almost no fuss. The method of entity-encoded HTML, also known as double entity-encoding, while quite common and not going away anytime soon you should consider avoiding it and saving yourself and others some headaches. Besides being a nonstandard practice within the XML specification, this method requires more processing cycles, adds to the file size unnecessarily. It’s also prone to occasional error.

Minimize the use of HTML in descriptions. John Postel's maxim on robust protocols says "be conservative in what you do..." and its in this same spirit that I make this recommendation. None of the RSS specification actually limit what you can embed in a description tag. While feed consumers should be prepared to strip out unwanted formatting, it's simply good manners as a content publisher to help avoid issues that could break their aggregator or layout.

Include a descriptive title for each item. Examine any collection of written thought, such as a magazine, newspaper or book, and you will note how information is organized in layers that can be easily scanned and processed by a reader. A good title, subtitle or summary (referred to as heads, desks and leads in media parlance) will not say anything that that isn't contained in the main body of the piece. Without scannability content consumption simply becomes too laborious and time intensive that most of us would hardly bother reading a thing. Try removing titles from any magazine or newspaper and you'll come to appreciate what I'm referring to. Besides being good for scannability, descriptive tiles are good for accessibility. Despite these time-tested best practices, many feeds fail to include titles let alone informative ones. Some webloggers claim its too time consuming and difficult to create a title for the numerous and short posts that they make daily. While I appreciate their standpoint a title, such as the site or collection name with a timestamp ("tima thinking outloud: September 1, 2002 20:13 -4:00") is more helpful and perhaps appropriate. The end user does not have to guess at a title usually by taking some number of characters or words from the beginning of description. ("Today I saw something that..." )

Avoid embedding HTML in the title. The channel and item titles in RSS, like its counterpart in HTML, are considered metadata and thereby is not expected to have display elements such as HTML tags. Embedding markup, even encoded with CDATA, could break an end user's application with your feed. Keep HTML in the description only – if at all.

Consider writing a meaningful and concise summary for the description. Like including a descriptive title, including a meaningful and descriptive summary improves the scannability, and thereby the utility, of your feeds. It helps readers determine if they want to continue reading and communicate the main point of the content for readers lacking time.

If you insist on including the full content of items in a feed, offer end users a choice. This can be a bit of a controversial issue as some users prefer include the full content of an item in the feed so they can read the content in their aggregator. Others prefer concise excerpts that can be quickly scanned or consumed over low bandwidth connections. These viewpoints are neither right nor wrong. It is the content publisher's decision based on the use of their content and needs of their intended audience. However publishers would be wise to offer end users a choice. Since most feeds are generated by a tool this is not difficult to provide. Also consider that end users may only be interested in a particular topic or resource. RSS is highly versatile and can be used to create feeds on a specific topic or resource like a calendar of events, mailing list archive, recent comments, or document repository.

Include contact information in your feed. With vague documentation and varying interpretations of RSS implementations issues will happen. Publishing an email contact responsible for the generation and management of the feed opens the lines of communication in rectifying these issues and collecting feedback.

I look forward to the feedback and insights that these community discussions with certainly produce.

A Bad Hair Day For Coding.

| No Comments

Thursday was what I refer to as a "bad hair day for coding." After completing a beta version of the mt-rssfeed plugin and its underlying liberal parser, I began testing myself and was in for a rude, time-consuming surprise.

I made the fateful decision to support XML::Parser::Lite as a fallback option to its bigger brother XML::Parser. Lurking in the MoveableType support boards I noted a significant number of users work with hosts that do not have XML::Parser and do not allow users to compile software (the module is a wrapper to Expat that uses C) or simply do not have the expertise to do it themselves. XML::Parser::Lite is an all Perl solution that uses a mega regular expression routine called REX. Lite does not support namespaces though, so I had to reverse engineer Expat's namespaces handling and put it into my liberal parser. While time consuming and in a sense reinventing of the wheel, it was interesting educational work that I thought was well worth the effort to make this code more useful to all MoveableType users. The rude surprise came Thursday when I began testing against Lite producing a "Segmentation Fault" -- Perl's version of a core dump or general protection fault. I spent all day Thursday trying to figure out why my code performed flawlessly with Expat and completely crashed with Lite. It ends up Lite uses some experimental regular expression code (the ?{ } construct) to call the event handlers you have registered. If you have any regular expressions in your handlers (as I did to support namespaces) it will crash Perl. This wasn't documented unless you examine the code. (Insert your favorite expletives here.) I spent Thursday evening and Friday weighing my options and reworking the code to accommodate this quirk. What's noteworthy is that the original REX code does not use this experimental construct. The question begs to be asked is there a better and safer way to implement such a parser? I think there is with some thought that I don't have just yet. I assume the module was coded this way for better performance, however convenience and simplicity are the reasons for using Lite (for me at least) that the use of these constructs seem to undermine. Furthermore it makes inserting namespace handling code in Lite, something I've considered after all the trouble I've gone through, difficult perhaps impossible. Another option to consider is XML::SAX::PurePerl.

Some much to do and so little time.

For MoveableType users waiting for the rewritten and substantially enhanced version of mt-rssfeed Wednesday is the day -- assuming I don't find another surprise.

Mark Pilgrim and Sam Ruby have announced the launch of a RSS validator service. The service is optimized for the recently proposed RSS 2.0 format, but supports prior versions. This is some excellent work! I particularly appreciate the friendly and instructive error messages is generates. This validator will be quite helpful and instructive to those who do not understand (or simply don't have the patience for) the mostly vague and loosely worded documentation. Being valid RSS does not guarantee that a feed's content is well-formed enough to be useful to an end user.

In other related, while the flaming on RSS has subsided for the time being, active discussion continues. Joel Spolsky raised the issue of RSS bandwidth consumption. The persistent downloading of his feed by aggregators using a brute force GET is costing him in bandwidth overruns. Mark suffers from the same issues and summarizes the conversation thus far here. Sam proposes a bandwidth friendlier solution here. I've noticed that my syndication feed hits also outweigh my web pages -- however I'm not the rock star that Mark and Joel are so I haven't had to pay extra. Yet. I know blagg that I use as the basis for my own homegrown aggregator is one of those pigs. Implementing DJ Adams' ETag-enabled wget script with blagg should help.

Ben Hammersley points out Ian Davis' LiSA "a SAX-like API for processing syndication formats. It's intention is to abstract away all the fluff contained in the current raft of syndication formats into a set of event notifications such as startDocument, startChannel, startItem, endItem etc."

I haven't been writing as much because I've been heads down coding the next version of the mt-rssfeed plugin and the underlying liberal parser. The liberal parser will be fully namespace-aware -- or at least as I understand it. The plugin has been completely rewritten and has too many new features and enhancements to list here. I should be starting my own internal testing today with a public beta test in the coming week.

While I admire Opera Software's work and persistence in advancing browser design, I can't help but roll my eyes reading their recent announcement. Opera has developed a mobile browsing technology that has, as Paul Festa reports, "finally solved the long-standing problem of reading big, bulky Web pages on tiny cell phone screens, posing a potential threat to both WAP and to Microsoft."

Mobile users don't browse like they do from their desks, so let's stop trying to repurpose content designed for the Web.

WAP has failed for a host of reasons including the inherent security hole of the WAP gateway architecture, initial deployment on circuit-switched networks as opposed to always-on packet-switched data networks, and a lack of well-designed and useful applications. Even once addressed, browsing would still have its issues and limitations in the mobile arena. Mobile users are "on the go" and generally not in environments where they have the time or patience to navigate content as they would seated at their desks. Their environment requires useful content and applications to be location-based, time sensitive and concise. In addition, utilizing an architecture where nearly all the data and logic resides on a remote server is a poor fit with the reality of unreliable and low bandwidth connections. It frustrates users and erodes their confidence.

Besides, WAP and more specifically WML (WAP's markup display language) is becoming more symbiotic with the Web. WML2 is an extension of XHTML that utilizes a mobile specific profile. (In his CNET article, Fiesta incorrectly compares WAP and HTML that is apples and oranges. WAP and Web Architecture or WML and HTML would have been more appropriate.)

I've always been skeptical when it comes to these attempts to repurpose web content on a mobile device as Opera's proposal or existing implementations such as Danger's HipTop browser. I've never seen them succeed at anything but frustrating users.

Web pages are designed for large high-resolution color displays, the use of keyboard and mouse and a reliable and relatively high bandwidth connection. Being a display language HTML is not terribly efficient or reliable for consumption by another application. "Qualified guessing" will yield the equivalent of a Frankenstein monster. It’s a hack at best.

Yes, if designed properly a Web page will scale gracefully and adapt to different displays and resolutions -- IF is the operative word though. Like eating your vegetables, most of know we should do it, but don't. Face it, web sites do some rather freaky things with HTML. You don't have to go past the world's most prominent software company's site to witness that.

Despite my criticisms in this area, I still believe in the promise of mobile computing. Mobile data devices will eventually surpass the number of desktops. They're more affordable and the constraints of these devices insist on a simplicity that will assist the mass-market in embracing interactive services.

Repurposing Web content for mobile is not the answer, it’s a hack. Studying mobile users’ needs and tendencies, getting content into easily consumable formats and developing more usable and appropriate mobile applications are the real answers.

An Introduction to WSIL.

| No Comments

My article "An Introduction to WSIL" was published yesterday. The Web Service Inspection Language (WSIL) is an XML document format to facilitate the discovery and aggregation of Web service descriptions in a simple and extensible fashion. While similar in purpose to UDDI, the WSIL model is more RESTful. In many ways, WSIL is like RSS for Web services. RSS is a file format with pointers to published content that can be syndicated and aggregated. WSIL is a file format with references to published Web services that can be discovered and bound.

It was submitted some time ago, but it quite timely. The recent release of Apache Axis toolkit includes a Java implementation for working with WSIL.

In Praise of Evolvable Formats.

Mark Pilgrim rewrites Clay Shirky's In Praise of Evolvable Systems to explain RSS.

RSS 0.9x and 2.0 are the Whoopee Cushion and Joy Buzzer of syndication formats. For anyone who has tried to accomplish anything serious with metadata, it’s pretty obvious that of the various implementations of a worldwide syndication format, we have the worst one possible.

Except, of course, for all the others.

Well done Mark. I agree with your general sentiment, but think some of the flaws cited could have been easily avoided and the format would have been just an evolvable. Instead we get to endure the shortcomings of one person's rash decision making and whimsy.

The XSS profile I have proposed is an attempt to apply some common sense and make the most of what has already been done.

mt-meta 0.3 Now Available.

| No Comments

In case you missed it in my earlier post, I've released a new version of my plugin mt-meta, a MovableType plugin for displaying embedded metadata, that can be downloaded here. This version adds support for the new keywords/metadata field introduced in MovableType 2.5.

Past versions of mt-meta and my other plugins can be found here.

MovableType 2.5, the latest version of personal publishing tool that I and thousands of others use to publish their weblogs, was released. Some of the more tasty technical bits reported in the release notes are:

  • You can now easily ping blo.gs and other update services that accept pings adhering to the Weblogs.com XML-RPC interface.
  • A new "Keywords/Metadata" field has been added... (I've already updated my mt-meta plugin.)
  • Added optional TrackBack auto-discovery, which can automatically find TrackBack ping URLs based on permalinks in entry bodies.
  • TrackBack pings are now sent using HTTP POST instead of HTTP GET. (In other words it’s now more RESTful.)

This also marks the one-year birthday of MovableType. The dynamic duo of Ben and Mena Trott reflect on the past year here.

Great job Ben and Mena. A tremendous accomplishment for a "a hobby, a way to occupy time previously filled by, well, employment." Thanks for sharing and congratulations! I'm looking forward to what the next year will bring.

This is a second draft of the Extremely Simple Syndication (XSS) I proposed here. XSS was drafted up a more detailed description of recent discussions and proposals for a simple core that maintains a high level of backward compatibility with RSS 0.91 and its descendants. I have classified XSS as a profile (a restricted subset) instead of a specification. I'm developing it in the spirit of "release early, release often." Feedback and suggestions to improve this description are greatly appreciated.

This draft incorporates additional clarification and feedback I received after publishing the first draft September 27.

I've set up my weblog to produce feeds in this format (here and here). The MovableType templates I'm using can be found here and here.

Extremely Simple Syndication (XSS) Profile

DRAFT 2

ABSTRACT

The XSS profile defines a restricted subset of previous RSS formats that balances ease of use and authoring with ease of consumption by applications while maintaining the richness necessary to extended and adapt to various problem domains. It is designed for applications operating in resource constrained environments such as mobile phones, PDAs and other devices or sites needing to conserve bandwidth for economic or physical reasons. It is also designed for authors wishing to provide a well-formed "feed" of information to consumers.

The XSS profile is designed around a simple common core of elements that may be extended. It is also designed to maximize backward compatibility with the RSS 0.91 format and its descendents. This allows XSS to leverage the existing install base of 0.91 feeds and prior bodies of work such as Dublin Core meta data and RSS 1.0 modules. The XSS profile contains three document types -- Strict, Transitional, and Extensible.

The goal of the XSS profile is to serve as guidelines to best practices in a balanced and simplified approach to authoring and consuming of syndicated resources with RSS.

COMMON CORE TAGS

<rss>
Description: The root tag for the syndicated resources collection.
Sub-Elements: channel (required)
Attributes: version - a string identifying the version including profile and document type.
Notes: Only one channel is permitted.

<channel>
Description: Container tag for a specific channel
Sub-Elements: title (required), description (required), link (required), item (required)
Attributes: none.
Notes: Only one title, description or link is permitted. Language is depreciated.

<item>
Description: Container tag whose contents represents one resource in the channel. At least one item must be present in a channel.
Sub-Elements: title (required), link (required), description (optional but highly recommended)
Attributes: none.
Notes: Recommended to not exceed 15 per channel.

<link>
Description: A unique URI using a IANA-registered scheme that specifies the location of the channel or item (resource). Applications are required only to support one of any of these IANA URI schemes however http:// is highly recommended. A required sub-element of channel and item.
Sub-Elements: none.
Attributes: none.

<description>
Description: A plain text excerpt of the channel or item (resource). A required sub-element of channel. Optional, though highly recommended, sub-element of item.
Sub-Elements: none.
Attributes: none.
Notes: The XSS profile supports plain text and does not permit encoded markup such as HTML to be included in the description. Recommended not to exceed 500 characters. Those wishing to embed markup language or larger pieces of content in the description tag should use the mod_content module.

<title>
Description: A plain text descriptive title of the channel or item (resource).
Sub-Elements: none.
Attributes: none.
Notes: Is the equivalent of the HTML title and only supports plain text. Encoded markup such as HTML is not permitted to be included in the title. Recommended to be no more then 100 characters.

DEPRECIATED TAGS

Tags not defined other tags from RSS 0.91 and its descendents are considered depreciated from the core in the XSS profile. This data can be furnished though various modules such as Dublin Core, mod_content and mod_admin. All depreciated tags in the XSS profile where previously considered optional except language which was required by the 0.91 specification, but made optional in later specifications.

DOCUMENT TYPES

Strict. RSS 2.0/XSS-strict. This document type only permits the use of core elements. Depreciated tags are not permitted. This document type does not expect the use of extension modules in order to maintain a simple lightweight footprint. Authors requiring more rich meta data and/or extensibility should use the Extensible document type. This document type is compatible with versions 0.92, 0.93 and 2.0. Other then the removal of the required language tag and content lengths, this document type is also compatible with 0.91. Since modules are not permitted, a namespace cannot be declared.

Transitional. RSS 2.0/XSS-transitional. All the stated expectations of the Strict document type apply. Depreciated tags such as language, copyright, and image found in the 0.91 format and its descendants are allowed, but should be ignored in favor of their extension module counterparts, when those counterparts are present. All tags deprecated in the XSS profile were previously considered optional (except language which was required by the 0.91 specification, but made optional in later specifications).

Extensible. RSS 2.0/XSS-extensible. All the stated expectations of the Strict document type apply except modules are permitted and expected. The default namespace must be defined. With this added capability to the document type, the X can be considered as representing 'extensible' rather then 'extremely.' Extensible Document Type can become quite complex and tedious to author without automated tools for generation. This document type breaks compatibility with formats prior to version 2.0. (XML namespace aware applications developed prior to version 2.0's release are likely to be able to process this document type, but are not guaranteed to do so.)

Content publishers are recommended to always utilize the Strict document type and only utilize the module extension document types (Extensible and Transitional) if richer meta data is required. When such a need exists, content publishers are also recommended to produce both a Strict document type feed and an Extensible or Transitional feed. This practice provides consuming applications a choice as to the depth information and the necessary sophistication to process it.

EXTENSIBILITY

Without detailed information to extending RSS 2.0 with modules and XML namespaces, the XSS profile Extensible and Transitional document types will follow the guidelines set forth in the RSS 1.0 format module documentation.

EXAMPLES

OUTSTANDING ISSUES

  • How to identify the profile/document type? Place in version? or use XML document type? Both?
  • Need to build DTD or schemas?
  • Need to list out depreciated tags and map to specific modules and fields.
  • link tag language sufficient? http:// is highly recommended or should it be required?
  • Need to better address non-English language feeds. Morten Frederiksen suggests inclusion of a clause like "if the language is not English, please include the dc:language element according to XXX." Should non-English feeds be forced to use Extensible or Transitional? Is there a better way?
  • RSS 2.0 can never use a default namespace?

CHANGE LOG

DRAFT 2, Oct 4 2002

  • Corrected numerous offenses on the English language. (Misspellings etc.)
  • Added revisions to Document Types Strict paragraph. (Michael Bernstein)
  • Resolved omission of item as sub-element of channel. (Morten Frederiksen)
  • Added omitted item description.
  • Added hyperlink to RSS 1.0 modules document.
  • link tag now has IANA-registered URI scheme clause to with link. (Morbus Iff)
  • Recommendation on Document Type usage selection. (Sam Ruby)
  • Added compatibility and namespace notes to document type descriptions.
  • Added clarification that Extensible is a superset of the Strict document type.
  • Added mod_slash tags to Extensible MovableType template.

DRAFT 1, Sept 27 2002

  • Initial release.

In his content syndication weblog, Ben Hammersley points out a nifty mobile application named PeekAndPick that he's begun using on his new Java enabled phone. PeekAndPick is a J2ME MIDP application for reading headlines and excerpts from RSS feeds and selecting the items you are interested in reading later. Your selections can be compiled into a list of links and emailed to your desktop for later reading.

PeekAndPick, the work of Jonathan Knudsen, is a brilliant mobile app because it illustrates good mobile application design. It doesn't try to do too much or be like a desktop application. It does demonstrates how mobile and traditional Internet channels can be used to provide a useful and appropriate solution together -- though it could do that a bit better. (More on that in a bit.)

The application's design acknowledges that mobile means "on the move." This mobility generally finds the end user in a less then ideal setting (context) that requires information be concise and interactions simple in order to be useful. Mobile users do not browse -- especially on a screen that typically is not much large then a postage stamp. (Note to telcos and device manufacturers: Web content was not designed or with a mobile devices or users in mind. It futile to try because it really doesn't work out and it just annoys people.)

While very well done application that we have to give Jonathan a great deal of credit for, PeekAndPick is not without its issues or room for improvement.

PeekAndPick underlines the need for RSS feed publishers to exercise good form and provide descriptive titles and concise well-formed excerpts. Since quite often this is not the case, PeekAndPick would probably benefit from a server-side proxy that retrieves feeds, cleanses them and strips any extraneous information that the app does not need. Besides heading off trouble this approach also helps keep bandwidth use to a minimum. Optimizing bandwidth usage not only improves response time, but it saves the end user some money. Remember mobile data services are typically priced by the bandwidth consumed.

Most of the configuration for the app, such as defining your list of feeds, should be handled through a web interface and not the mobile device. At a former employer, where I consulted on a number of mobile projects, we professed "configure while seated, consume while mobile." Who wants to type in a URI like http://www.timaoutloud.org/xml/index.xml with their phone's keypad?

In my cursory review of the code, the application does not queue messages if a connection if not available. Given the unreliable nature of mobile networks, handling these occurrences is important, even crucial, to developing user-friendly and reliable mobile applications.

I could really use PeekAndPick myself because I find myself woefully behind when I'm away from my desk for any extended period of time. Alas, I cannot use it because I use a Blackberry 957 that is not Java-enabled. (I love my Blackberry and still find it useful, but I've been deeply disappointed that RIM has forsaken users and not continued to advance this model's capabilities by providing J2ME support as its descendants. I suppose that's for another posts though.)

Check out PeekAndPick and consider your mobile application future.

Mark Pilgrim's Four Lights.

One year ago today, my (now former) manager told me to shut down my weblog and remove all traces of it from my server. He tried to convince me that the Internet was too small to mix the professional and the personal.

One year ago today, I gave him my answer, and the rest is history.

Today, to celebrate this anniversary, I would like everyone to read my resumé, admire this full-screen picture of my cat, and link to this post.

There are four lights.

Microsoft Fiddles While Rome Burns.

InfoWorld . My take on this article is very similar to Dave's I would entitle the article: "Microsoft fiddles while Rome burns" Basically, Microsoft is focusing all their attention on enterprise computing, which is a major dog right now (and likely to remain so for years to come), while the market for PC's falters due to a lack of innovation.  With O/S release cycles now stretching to 4 years, there needs to be a change in strategy. [John Robb's Radio Weblog via Mobilog]

About this Archive

This page is an archive of entries from October 2002 listed from newest to oldest.

September 2002 is the previous archive.

November 2002 is the next archive.

Find recent content on the main index or look in the archives to find all content.

Powered by Movable Type 4.2rc2-en