Overview of Blogging
The term “blog” is a shortened version of “weblog,” which refers to a web site that is frequently updated, diary fashion. “Weblog” itself is based on “web,” as in the World Wide Web, and “log”, in the sense of a record of events.
Anton Zuiker has written an excellent, concise description of blogging.
From a user perspective, blogging is straightforward. The simplest way to create a blog of your own is to sign up for one of several blog services. Some of the free ones are Blogger, JRoller, Pitas, Blog-City, and 22 Blog.
Blogging is supported by a web application, a blog server, that generates pages and allows authors to upload new blog entries. Blog servers vary in complexity, but all offer the same basic functionality:
Authors can upload new blog entries. Most of the time, they enter blog updates into a form in a browser. I’ll describe some of the other possibilities in this article.
Readers can view a list of blog entries using a web browser. The blog server usually presents these in reverse chronological order, so that the newest entries are at the top of the blog page.
Advanced features have appeared:
Some servers allow readers to post comments in response to blog entries. Each blog entry may thus be the root of a complete discussion between the blog’s author and its readers.
The server may automatically generate RSS feeds. An RSS file is an XML document that summarizes a site’s content; some blog servers will create an RSS file based on the current blog entries.
Many blog servers are open source projects. Some examples:
Blog Server APIs
The most common client is an HTML form in a browser. This is a relatively simple solution because the update form can be easily packaged as part of the blog server application.
As blogging has grown in popularity, however, alternate blog clients have emerged. Alternate clients are possible only when the server publishes an application programming interface (API). Suppose I write a blog server. The only way other people can write blog clients is if I publish an API that clients can use to update a blog.
What’s the only thing better than a published API? That’s right, a standard published API. Probably the most widespread API is the Blogger 1.0 API, which was followed up in Febrary 2003 by the Blogger 2.0 API. Some of the other popular blog server APIs are MetaWeblog metaWeblogApi and LiveJournal.
Another standard currently in development is Atom, which is the goal of the Echo Project.
Diego Doval has written an interesting summary of the different APIs (as a blog, appropriately enough).
All the current blog server APIs are accessed via XML-RPC; basically, the client sends a request as an XML document, and the server responds with another XML document after it has performed some work. To add a blog entry, for example, the client sends an XML document that describes the entry. The server creates the entry in its database, and returns to the client an XML document reporting success.
Once the server has a public API, anybody can write a client. Various desktop clients have already been written for popular blog server APIs. Two examples of the available clients are BlogBuddy and w.bloggar.
What about blogging from a mobile device, called moblogging? At first blush, this sounds ideal — you’re in the middle of Yellowstone Park, or at the top of the Eiffel Tower, and you dash off a quick blog entry from your phone, the ultimate convenience in sharing your thoughts with the world. But once you start thinking about it, doesn’t it seem excessively painful to enter text using a numeric keypad for input? I know that millions of teenagers send gazillions of characters of SMS text to each other using only a numeric keypad, but comparing text messaging to blog entries is not really fair. SMS messages are short by necessity, and the people that use them have developed a fairly elaborate shorthand which speeds up input. Blog entries, on the other hand, tend to be real prose, with real sentences and in many cases multiple paragraphs per blog entry.
If textual blogging has a future on mobile devices, it will most likely succeed on devices that have more sophisticated input mechanisms than a numeric keypad alone. Palm OS devices, for example, have a stylus that makes it significantly easier to enter text. Other devices, like the RIM BlackBerry and the Sharp Zaurus, include a small QWERTY keyboard.
Even if your MIDP phone isn’t well suited to capturing your prose, it may have a camera, and here I believe blogging and mobile devices can combine with great success. It would be extremely convenient to be able to take pictures using your mobile phone, then upload them directly to your blog. You could add text later when you get to a computer with a keyboard.
Current Moblogging Software
Moblogging has a brief but exciting history. For a comprehensive collection of links and information, browse to www.moblogging.org/.
Current moblogging clients rely on email and SMS to submit blog entries. Usually some kind of script responds to an incoming email or SMS message to create a new blog entry.
The first moblogging system in wide use was Hiptop Nation, a communal blog based on Danger’s Hiptop device. Nowadays a broad variety of mobile blogging tools are available, among them NewBay Software’s FoneBlog products_general.html, BlogPlanet, and KABLOG.
A Napkin Sketch
In the spirit of a late-night supper conversation, I’ll sketch out the architecture of an all-Java MIDP-based photo-blogging application, starting from the client and progressing back to the blog server.
On the client end, you’ll need a device that has a camera and supports video capture from the camera via MMAPI. The Nokia 3650 is one such device. More information about using MMAPI for video capture is in the article “Taking Pictures with MMAPI”.
Once you capture an image on the device, it’s straightforward to send the bits to a server. Chances are good, though, that you won’t want to have the MIDlet talk to the blog server directly, for several reasons:
The MIDlet would need to use XML-RPC to converse with the server, which means that it would need to generate and parse XML. There is a variety of solutions to this problem, ranging from using a generalized parser and generator to hardcoding most of the XML and filling in the blanks at runtime. Either solution, however, may be heavier than you want in a MIDlet, which needs to respect the constraints of a mobile device. You can simplify the client by having it send images to an intermediate server using a simple protocol, then have the intermediate server talk XML-RPC to the blog server.
Even if you bit the bullet and included XML generating and parsing in your MIDlet somehow, you would still face the question of which API to support. To create a general solution, you’d want to support two or three of the most popular blog server APIs, which would entail even more code in the MIDlet. Again, moving all the blog server interaction onto an intermediate server would solve this problem.
Your application might well have a second market: users who don’t have a blog, yet want a place to go look at pictures they’ve taken. The intermediate server could meet their needs as well as those of your blogging users.
In the future, J2ME phones that support JSR 172, the J2ME Web Services Specification, will have most of the overhead of generating and parsing XML messages built into the phone.