Six Apart News & Events: May 2005

The variety and breadth of ideas that weblogs can cover continues to be amazing. Witness one of the latest efforts, EPIDEMIca, a weblog about infectious diseases.

Powered by Movable Type, this site adopts a serious tone and a professional look appropriate for the topic it's dedicated to. Currently featuring a special focus on the bird flu epidemic, the blog format makes it easy to make sure that information can spread quickly enough to keep up with the spread of disease. As an example of a professional-level blog that isn't published by a company, M-J Milloy's work in creating Epidemica is an important example of the potential of blogs to contribute to education about something as important as public health.

One of the great things about Movable Type being localized into a number of languages and having such a broad international presence is that we get great contributions from our community around the world. The latest contribution is Jörg Petermann's Movable Type Cheat Sheet, which he's published in both German and English.

The Cheat Sheet, available in both PDF and PNG formats, covers all the standard Movable Type template tags, as well as common attributes for the tags and the date format used for output. Most of these tags also apply to TypePad's advanced templates as well, so it's worth keeping a copy of the Cheat Sheet handy if you're a TypePad Pro subscriber.

We've just posted the newest article to the Professional Network site: Customizing Movable Type's Interface with Application Templates. As we mentioned when Movable Type 3.16 was released, our support for custom application templates has been beefed up in current releases of Movable Type. This new article discusses how application templates work, why you'd want to make use of them, and some examples of how they've already been deployed.

From the article:

If you're looking for inspiration: Take a look at the work that's already been released in the community. Alex Sancho created a liquid template for displaying Movable Type's interface, letting the information in the application reflow to fit larger screens. Dan Wolfgang has built a number of application templates, customizing functionality ranging from the file upload screen to the entry preview page. If you've got some customizations of your own, be sure to let us know and we'll share them with the community on the Professional Network blog.

Introduction

This article explains how you can customize the user interface of the Movable Type application. This is a powerful area of functionality that's easy to get started with and almost unlimited in its potential. Some key points we'll cover: * How to create custom application templates for Movable Type's interface * The benefits of using application templates * Ideas for how to use application templates with your plugins or workflow * Links to some example application templates, to see what's possible and to inspire your own

Customizing the Movable Type user interface

To understand the potential of customizing your Movable Type interface, you'll need a little bit of background. Most Movable Type users are familiar with the templates that are used to generate HTML or XML files for output. But Movable Type also uses another template system, called HTML::Template, to produce the HTML files that define the application's user interface. This system allows for flexibility such as limiting the display of certain features to only users who have permission to access them. Fortunately, despite their power, the templates that make up the Movable Type interface basically look like standard HTML, with some little bits of logic added. Tip: If the only items you want to change in the user interface are things like font selection, formatting, borders, or the positioning or display of user interface elements, you can just edit the styles.css file in the root of your Movable Type installation and tweak to your heart's content. You can see the results of a number of these types of customizations under the tag "Pimp My CMS". If you want to follow along in your own Movable Type installation, you should check out the /tmpl directory underneath the directory where you have Movable Type installed. You'll find a subdirectory called cms that contains most of the templates that make up the screens you're familiar with when you log into the system.

What's an AltTemplatePath?

Once you've found the tmpl directory, it's pretty easy to understand the next few steps. Movable Type allows you to simply override the default application templates in this directory with ones of your own creation by making templates with the same name, putting them in a folder that the application can access, and then telling the system where to find them. For our examples, we'll assume that your custom application templates will live in a folder called /exttmpl underneath your Movable Type install. (That puts the exttmpl folder right next to the tmpl folder for easy access, and the "ext" part of "exttmpl" stands for "external" templates.) The configuration setting for the path to custom (or "alternate") templates is AltTemplatePath. To tell Movable Type where to find your application templates, you need to edit the mt.cfg file, which contains the system configuration for Movable Type. Just edit the file and add a line that says: AltTemplatePath ./exttmpl Once you've saved the mt.cfg file, you're all set: Movable Type will always look in the /exttmpl directory first to see if there's an application template available, and if it finds one, it will use your custom template in place of the ones built into the system.

A Simple Example

If you're just getting your feet wet with modifying the Movable Type user interface, the best place to start is by customizing the templates that come with the application. We'll copy one of the existing templates from the /tmpl/cms directory to /exttmpl/cms. For this example, header.tmpl, which generates the top of the page and the left toolbar for the Movable Type application, will serve our purposes. After you've copied header.tmpl to its new location, open it up in a standard text editor.

Side Note: In Movable Type's user interface templates, you'll see some standard HTML laying out the structure of the page, as well as some new tags that you may not be familiar with. The items that start with TMPL_VAR are template variables, which Movable Type generates depending on your system configuration. The ones starting with MT_TRANS are bits of text that are translated into the language selected by the user. (Movable Type has been professionally translated into half a dozen languages, and it's also possbile to create your own translations.) A full explanation of this template language is outside the scope of this article, but if you want to learn more the language used here, you can start with HTML::Template Explained. Full resources, including a mailing list, are available at the SourceForge site for the project.

The line we'll want to edit for our example is line 28 of header.tmpl in version 3.16 of Movable Type. Before any changes, it looks like this: <TMPL_IF NAME=BLOG_NAME>|  <a target="_blank" href="<TMPL_VAR NAME=BLOG_URL>"><MT_TRANS phrase="View Site"></a></TMPL_IF> If you've worked within Movable Type a lot and use a tabbed browser or are just meticulous about managing your browser windows, you probably already know what this (potentially annoying) bit of markup does: It's the "View Site" link on the top navigation in Movable Type. By default, it opens a new window to display your blog when you click on it. If you're administrating a blog for a workgroup in a company, opening in a new window might be a handy convenience for many of the authors who contribute to the weblog. But we're power users! We're in here mucking around with our application's templates! So we can't have Movable Type be coddling us by opening up new windows on its own. How do we fix this annoying habit? We just take out the markup that's instructing the browser to open up the new window: The target="_blank" attribute. So let's replace line 28 of header.tmpl with this new version: <TMPL_IF NAME=BLOG_NAME>|  <a href="<TMPL_VAR NAME=BLOG_URL>"><MT_TRANS phrase="View Site"></a></TMPL_IF> Then, just save the modified file, make sure it's located in /exttmpl/cms, and log in to your Movable Type installation. You should be able to click on "View Site" from the top navigation of any of your weblogs to verify that the changes worked.

Your Changes Are Safe

One of the most satisfying parts of working with application templates for Movable Type's interface is that your changes, improvements, or customizations to the Movable Type user interface are safe. If you upgrade Movable Type, the /exttmpl folder isn't overwritten, so your templates will continue to work. (Though, if the user interface for Movable Type is revised, you won't get any new functionality that's made available in the new version's templates.) In addition, your application templates can make use of the hundreds of strings that are localized for each of the international versions of Movable Type. If you make smart use of translated variables (refer to the HTML::Template links, above), your customizations will work for Movable Type users around the world, taking advantage of the translation work that's already been done. And the application templates that make up the Movable Type interface are being made available under the Artistic License, allowing you to customize the templates and redistribute them as needed, either for your own use, for your customers, or to share with the entire Movable Type community. Best of all, we'll be expanding support for application templates in future releases, to include items such as the email templates used for notifications from the Movable Type application. Once you've created a library of customizations encompassing all of your preferences and personalization, you'll be able to deploy it on any of the platforms where Movable Type runs.

What's Next?

The potential for custom application templates is limitless; If it's like most of the extensibility features we've built into Movable Type over the years, we'll be surprised by the creative ways that people make use of the potential. But we're already starting to see some good examples of what can be done. At a very basic level, an application template could rename elements of the user interface or change the places that links go. Don't like the word "blog"? Want to rename the "Extended Entry" field? Those changes could be done in minutes using the same technique we covered in the example above. If you're a plugin developer: The power of combining your custom plugin code with a truly customized user interface defined with an application template is amazing. By creating custom links, adding additional integration points in the user interface, or by simply displaying tips or documentation for your plugin inline on the application pages where it's most useful, customizing Movable Type's interface can make your plugins even more valuable for users. If you're looking for inspiration: Take a look at the work that's already been released in the community. Alex Sancho created a liquid template for displaying Movable Type's interface, letting the information in the application reflow to fit larger screens. Dan Wolfgang has built a number of application templates, customizing functionality ranging from the file upload screen to the entry preview page. If you've got some customizations of your own, be sure to let us know and we'll share them with the community on the Professional Network blog. If you really want to push the limits: Truly advanced functionality could be generated using application templates along with other markup and application languages. The XUL language which defines user interface elements on Mozilla browsers would let you make a rich application UI for any functionality in Movable Type or in a plugin. If you prefer Flash for certain types of interaction, an application template can let you embed Flash within the application. And if you're an information architecture astronaut, you can rearrange the pages of the Movable Type application to better fit the workflow you envision.

Show Off Your Work

We'll be offering up some examples soon of how our own team has built on the application template functionality in Movable Type. You can build on these examples, or just start from scratch with your own ideas, to truly make Movable Type fit your needs and expectations. Once you're on your way, let us know, and we'll share your customizations with our entire community.

As part of our participation in the upcoming BlogHer conference on July 30 in Santa Clara, Six Apart will be covering the registration costs of five women bloggers from our community. So if you’re a TypePad, Movable Type or LiveJournal user who wants to go to BlogHer and would be interested in Six Apart covering your cost of registration (we won’t, unfortunately, be able to cover travel expenses), please send us an email to blogher@sixapart.com.

Entries must be received by 6/3/05 and include answers to the following:

Your name:
Your email address:
Your URL:
Your weblogging tool:
What’s your site about?
How long have you been blogging?
Why do you blog?
Tell us a little bit about your history as a blogger?
What do you hope to gain from attending the conference?

We're looking for a diverse group of women so your answers will help us decide who we will be sponsoring.

In addition, Six Apart will be offering all BlogHer attendees with a 30 days free trial on Typepad and a 10% lifetime discount. This promotional offer will be available to BlogHer attendees upon check-in at the conference.

A great line-up of women will be at the conference and I look forward to meeting those bloggers who we are able to sponsor. This is a great opportunity for women bloggers to network and just hang out.

A number of tools have recently launched that can extend the capabilities of the websites you use today, while making it simpler to test their functionality.

The first one that caught our eye is Piggy Bank, an effort from the Simile project being jointly conducted by the W3C, HP, and MIT.

Piggy Bank is a Firefox extension that extends the browser to allow it to navigate semantic content. Despite all the praise and critcisms for Semantic Web ideas, very few practical implementations have been created by which average developers can find out the potential of these technologies for themselves. Piggy Bank is a good way to combine and work with information from a large number of websites, and can act as a complement to the techniques we've mentioned in the past that let you rip, mix and burn the web.

Once you've gotten all your applications connected together, you'll need to test them. Though it's still a fairly new project, one of the most promising systems we've seen for testing web apps is Selenium. A simple, browser-based test tool, Selenium lets you do browser compatibility testing and system function testing just by creating some very simple HTML scripts to guide the tests. It's a powerful concept that's hard to understand the value of, so check out the demos yourself if you want to get a better understanding.

Nick Bradbury, creator of FeedDemon (which was just acquired by NewsGator last week) has just put up a terrific analysis of the considerations all developers of RSS and Atom aggregators and syndication clients should be keeping in mind with regard to secure behavior and sensible defaults:

Even if I'm way off base about how spam will come to RSS, we all know that spammers will find a way to jump on the RSS bandwagon. Given past history, every new social technology needs to think about spam right from the start, or else risk being crippled by it.

Moving on to specifics, Nick adds:

I took a look at how a few of the existing tools were handling them. To my surprise, security didn't seem to be a big concern - they'd even download EXE enclosures, perhaps assuming that the user's anti-virus software would stop them from being executed if they were malware. Couple automatic enclosure downloading with dynamic search feeds which contain enclosures, and you've got a great spyware delivery system.

Upcoming.org, the popular web-based events calendar, has been growing by leaps and bounds lately, and the latest additions include related tags, new client libraries, and a Movable Type plugin.

The plugin gives Movable Type users easy access to watchlists, search results, and events, all available as simple template tags. It's exciting to see such robust features becoming available just a few weeks after the launch of the new suite of web services. If you want to build on the services yourself, you can check out the Upcoming.org Community Help wiki, which includes a section for developer documentation.

Our co-founder Mena Trott is attending the D: All Things Digital conference, where she just sent word that Steve Jobs did a demo of iTunes 4.9. The big news is, the new version of the popular music management app beloved by iPod owners will feature integrated support for podcasting. Current plans call for podcasts to be free downloads: Users will submit their podcasts and Apple will be hand-picking the content it makes available to iTunes users.

Update: For clarity on the last sentence. It wasn't completely clear whether the inclusion of the user-submitted podcasts would be automated or manual. There appears two methods for inclusion into the store: (1) Apple will be hand-picking content (like the Adam Curry show, which was one of the banner graphics) (2) Users will be able to submit their own content. It may be very similar to the way that users can currently upload their playlists -Mena

A nice (and timely) example of how traditional print media can take advantage of blogs: As part of their entertainment section's coverage of the new Star Wars movie, the Washington Post has been keeping a blog called "Sith Sense".

Jen Chaney's posts on the TypePad-powered blog end on Monday, but maintaining a blog linked to a specific event makes perfect sense, and it's likely to become a more common practice for all kinds of media outlets.

For those who aren't using the dynamic publishing feature of Movable Type (see below), experiencing slow rebuild times is not an infrequent complaint especially as the size or complexity of the blog and its templates grows. While there are very good reasons to rebuild, there are no good reasons for it to be painfully slow.

In this essay, we will detail a number of reasons why your rebuild times might be slow and steps you can take to drastically reduce or completely eliminate the time you spend waiting for Movable Type to finish its work.

Upgrade to Movable Type 3

Has anything significant happened to you in the 16 months? Probably so. Well, the same can be said for Movable Type. A lot of work has gone into making the static rendering engine in Movable Type much, much faster than what those of you using v2.x are used to.

That's not to mention all of the other goodies that MT 3 includes such as comment moderation, much more powerful plugins, a new and speedy interface, commenter authentication and a smarter, more pleasant and more secure application.

If you haven't upgraded, here's reason #2,819.

Use a SQL database

While BerkeleyDB is built to be a fast and efficient database for reads, it's not so good on writes and many older versions installed on hosting services are prone to corruption. To see an immediate speed boost (and gain a number of new features to boot), convert your database to one of the SQL options supported by Movable Type: MySQL, SQLite or PostgreSQL.

Although this is listed second in importance in terms of speed, it is always better to convert your database to a SQL DB first and then upgrade to the latest version. To convert your database, simple add (in addition to DataSource) your SQL database information in mt-config.cgi (before MT 3.2: mt.cfg and mt-db-pass.cgi) and run the mt-db2sql.cgi script.

Background Tasks

Movable Type 3 also includes a feature called "background tasks" which allows certain tasks to go on in the background on your server returning control to you immediately after they are started.

One of the biggest differences you'll notice with background tasks turned on is in saving an entry or rebuilding entries. Once you click the save button on a new or edited entry, the entry is saved to the database, the rebuild is kicked off in the background and then the page reloads. There's no need to wait as all of your templates and archives finish rebuilding. You get to go on with your day letting the server do the work it already knows how to do!

Before turning on background tasks, you should first test to see if your server supports them. There is a script in the main distribution called mt-testbg.cgi. Run that script through your web browser. If you see two numbers and they are different, background tasks are supported.

To enable background tasks, go into your mt-config.cgi and change:

LaunchBackgroundTasks 0

to

LaunchBackgroundTasks 1

Then go save an entry and see what I'm talking about. It's a dream...

Plugins

Each plugin that you add to your system adds at least a little bit of overhead to system. In most cases, this doesn't cause a problem, and in fact, this site is published using a number of plugins. However, all it takes is one poorly-written plugin to make molasses look speedy.

If your rebuilding suddenly got slower, think about any plugins you may have just added and get rid of them. If you installed a few of them, do the following:

1. Uninstall them all, rebuild and time the process
2. Install one, reubuild and time it
3. Repeat the process for each new plugin

By doing this, you may find your one inefficient plugin. If you haven't added any plugins lately, then move onto the other steps.

Archive lists

If you are regenerating the same MTArchiveList data in multiple templates, it will compound the amount of time it takes to publish a single entry. It's better to generate your archive list once in an index template and then include it via PHP or SSI in all the places you need to.

Unnecessary rebuilding of index templates

While most of your index template need to be rebuilt to reflect the latest content you post, there are some that do not. For example, those which don't have any MT template tags in them (e.g. a CSS stylesheet or static files that don't change with your MT data) should be configured to not rebuild with index templates. Then, when you make a change to any of those templates, you simply rebuild it after saving.

Unused template maps

Template maps are mappings between groupings of entries and particular blog templates. Look under Blog config » Archive Files and scroll to the bottom. There you will see all of your template maps. They are a little understood and highly powerful feature, so let's take just a second to detail this for the curious.

Movable Type comes with one template map for Indivdual and another for Monthly archives enabled. What this means is that when Movable Type goes to rebuild, it does so once for each month's worth of entries you have using the "Date-based Archive" template creating a single file for each month. In addition, it does so once for each entry (a grouping of one) using the "Individual archive" template creating a single file for each entry.

Some people enable category archiving which, again, uses the "Category Archive" template to create a single file for each category containing the entries in that category. Usually, this should be no problem. (A word on that in a second...)

While most people just fiddle with the checkboxes on the left, enabling and disabling different archive types, there is something far more cool and more powerful that you can do with Movable Type: Output the same content in many different formats.

For example, you could have two Individual archive mappings, one using the regular Individual archive template and another using an individual news feed template including updates for comments and TrackBacks. Other cool uses include publishing individual entries in PDF format (for essays?), ICS format (for an event blog?). Uses are limited only by the imagination.

It's sad really that one of the most powerful features of Movable Type is so poorly understood and presented. We intend to fix this problem in the future.

Anyhow, the thing to do here is to make sure that you only enable the template maps you care about. You can tell which ones are enabled by looking at the checkboxes on the right. Uncheck any you don't want and click Save.

Wasteful use of template maps

While template maps are ridiculously powerful, each one taxes the system during a rebuild. If you are using multiple template maps to output extremely similar content (or worse the exact same data) in multiple formats, you might benefit from some streamlining.

The worst case we've seen was a user who had hundreds of categories, tens of thousands of entries and was generating category archives in HTML, RSS 1.0, RSS 2.0 and Atom format. Ouch! That's nearly the same exact information being compiled and written out over and over and over again.

If you're doing this, you may want to consider having Movable Type output the information you need once and then include it, via PHP or SSI, into each format. Conversely, you could just skip to the next step.

Dynamic templates

Yes, Virginia, Movable Type 3.1x does have dynamic publishing. And it rocks! By switching some or all of your templates to dynamic publishing, you can drastically cut down or eliminate the time it takes to get an entry published or to rebuild your whole blog.

When thinking about moving to dynamic templates you must consider a few points:

1. Your blog's traffic - Dynamic generation of pages isn't a panacea no matter what the buzzmeisters might say. There's a reason that Yahoo has historically written all of their directory pages out to the filesystem every night (this may not be true anymore). In short, each hit to a dynamic page taxes your system just a bit and takes some CPU time. With dynamic publishing, you offload the task of building a single file to each and every person who views that file. On a small scale, this is not a big deal, but if you've got a huge amount of traffic and aren't set up for it, you will bring your server to its knees. What's more, static pages don't require that your database be up and working for your visitors to read your words.

2. Plugins - The Movable Type publishing system prior to MT 3.1 uses Perl to publish your blog. MT 3.1 introduced a parallel and identical PHP subsystem to publish dynamic pages. Similarly, pre-3.1x plugins were written in Perl whereas and are not called by the PHP subsystem.

Both of these issues can be resolved in most non-extreme cases.

First, Movable Type provides a caching functionality which saves all of the work of compiling the page (after the first hit) and only costs a single database connection upon each page view in order to grab the appropriate cache file. That will take care of all but the sites with the highest traffic.

Secondly, there's no reason to go whole hog. There is a balance to strike and, luckily, Movable Type gives you the ultimate flexibility to pick and choose what you want to be dynamic and what should be static.

For example, enable dynamic publishing for the archive type on your site with the least traffic and leave the rest static. Each file that doesn't have to be rebuilt is time saved. As you get more comfortable with dynamic publishing, you can move more of your templates over.

As far as plugins, nearly all of the most popular MT plugins have been updated to work with both or have analogs in PHP. Still, there is a chance that that one long-time favorite plugin of yours does not. Check first and be aware. And if you happen to write a PHP analog for it, let us know!

A few dynamic tips

There are a good number of lessons that many of us have learned in switching over to dynamic publishing (other than "My Lord, that's fast.) Below we will detail a number of these tips and time-savers.

Duplicate your template

Switching to dynamic publishing can be onerous for those of us with years of customizations built into our templates because the dynamic publishing subsystem does things slightly differently than the static rendering system. If you go full-bore into editing a particular template, you may find that you've broken that set of archives and your vistors will be staring at a PHP error instead of reading your words.

The way to avoid this problem is to make a backup of your template and work on it, while leaving your statically rendered template and archvies in place.

If you're making an index template dynamic, the way to do that is obvious, but if you are doing an entire archive type, it may not be.

Remember template maps? There was a reason for detailing all of that above.

First of all, let's assume you're moving your individual archives to dynamic publishing. In this case, you want to create another archive template. Call it "Individual Archive template - dynamic" or something like that.

Then go to Blog config » Archive Files and create a new template map (Template/Archive type association) between Individual Archive Type and your new template.

After that, customize the Archive File Template in the bottom section to be:

<$MTEntryDate format="%Y/%m"$>/<$MTEntryBasename dirify="1">-2.php

Make sure to enable the template map by checking the checkbox to the left of listing. Keep the "Preferred" radio button of the original archive selected for now and save changes.

What this will do is create a parallel page for each of your static individual entries. You may then have, for example:

• /2005/05/09/my_entry.php (static)
• /2005/05/09/my_entry-2.php (dynamic)

Now you can work on the dynamic pages without affecting your static ones!

Your last rebuild

Once you switch to dynamic publishing, you need to do one last rebuild of that template or archive type in order for the dynamic publishing to take effect. This last rebuild moves all of the static files previously built on your system to "FILENAME.static". Once those static files are gone, the special htaccess file that Movable Type creates in the process notices and pulls the content directly from the database.

If some of your pages don't seem to be dynamic, make sure that MT was able to remove the corresponding static file.

MT Tags in PHP blocks

In the past, you could do all types of interesting things by including PHP blocks in your template along with MT template tags to feed in relevant data. In Movable Type's dynamic publishing, this is no longer possible due to the use of the Smarty templating system.

However, you can still include the data from MT template tags in PHP blocks without using the template tag themselves using MT PHP functions or even Smarty itself.

For a simple example, instead of doing this:

<?php $weblog_name = '<$MTBlogName encode_php="q"$>'; ?>

You do the following:

<?php $weblog_name = $this->tag('MTBlogName'); ?>

There's a whole lot more where this came from. See the following for everything you always wanted to know about MT's dynamic publishing feature but didn't know to ask:

• Movable Type User Manual: Dynamic Publishing
• Dynamic Publishing: PHP Architecture Overview
• PHP Dynamic Publishing: Developing Plugins

Finally, thanks to use of the Smarty templating system by Movable Type, you can use every single Smarty plugin and any Smarty template construct inside of your templates as well. It can even replace MT plugins without you ever having to learn a lick of Perl or PHP!

That is raw power, folks.

BIG pages and pagination

One thing you may notice with dynamic individual archives is that if there are a large number of comments on a particular entry (greater than, say, 200-300), the entry page may time out with an error as the server reaps PHP processes which take longer than 30 seconds to execute. The same thing could happen on a category archive page where you have hundreds of entries. In both cases, you need to use pagination.

Luckily, MT developer Chad Everett boiled down Smarty pagination really, really well in these two entries:

• Pagination Using Smarty
• Automated Smarty Pagination
• True Smarty Pagination

With Smarty pagination, you can have virtually an unlimited number of comments or TrackBacks to an entry without a hitch.

In Summary

Movable Type doesn't have to take long to rebuild it's pages or even any time at all. If you've followed the steps above, you should find that you are waiting around watching that little popup a hell of a lot less, giving you more time to reload Blogdex or find interesting things on Google Maps. Or maybe even blogging about it.

This week, The New York Times announced TimesSelect, a subscription service where they'll be making their editorial content available. As is to be expected, it's prompted a lot of reactions from bloggers worried about whether they'll continue to be able to keep linking to articles in the Times, as well as questions about the ongoing influence that the Time will have if some of its content is behind a paid barrier.

Perhaps lost in the shuffle is one of the more interesting subtleties of the TimesSelect service, as pointed out by PaidContent in their interview with Martin Nisenholtz of Times Digital:

"We want to create a second robust revenue stream," he explained, filling me in on some of the details and answering key questions about the timing, advertising and the blogosphere. One aspect of the plan is specifically for bloggers -- an affiliate program a la Amazon.

Though most of us have moved from table-based layouts to CSS for positioning, there's a good reason column-based layouts have been used in print publications for hundreds of years: They work. With that in mind, it's worth reviewing Dave Shea's look at Columns & Grids, an exhaustive study of the variations that designers are using to breathe new life into designs with one, two, three, or even eight columns providing the structure.

The American Foundation for the Blind has published a new analysis of some popular blogs entitled Is Blogging Accessible to People with Vision Loss?

Two of the sites reviewed are powered by TypePad, and the other two are powered by Movable Type, so we're pleased that they all receive generally positive comments in regard to their accessibility for people with vision loss.

We're always looking for ways to make sure that blogs are accessible to the widest possible audience, and it's this sort of insight that makes improvements possible.

If you're looking for best practices to implement on your own sites, you can refer to the AFB's web accessibility guidelines for some good ideas to start with.

ProNet members are probably a few years past being interested in the debate over how to define blogs, but there's still some room left for being amused. RobotJohnny discovered how Apple's Tiger release of OS X defines the word "blog" in its new built-in dictionary.

We talked about ways to make your life easier with Firefox, and now there's some powerful new ways to hack the web pages you view, to customize the display of documents or extend and personalize web applications.

If you're familiar with the Greasemonkey extension we explained in the last post, then you'll understand why Dive Into Greasemonkey, the new guide from Mark Pilgrim, is going to be an indispensable resource.

Once you've read over the excellent examples in the book, check out Platypus. The Firefox extension will let you tweak and hack a page to your heart's desire, and then save the modifications as a Greasemonkey extension. If you really want to share your work with the broadest range of Firefox users, you can even follow the link in our last post and compile your script into a true Firefox extension.

If you've got customizations for TypePad, LiveJournal, Movable Type, or TypeKey, let us know, and we'll be glad to share them with the community.

One of the most powerful ways to customize Movable Type to your preferences is the mt.cfg file. As we've noted on here on ProNet, we've been working to improve documentation for the configuration directives that are available.

Grettir Asmundarson has already jumped to the next logical step: a fully-commented mt.cfg file. You'll want to download and read through the example if you're curious about all the potential ways your Movable Type installation can be configured.

Ann Elisabeth has created another resource for fighting blog spam, the Spamhuntress wiki. She's asking for community contributions to help document tools, techniques, and lessons in the fight against comment spammers. If you're interested in the topic, you'll want to add your own links and content to the wiki.

We had some issues with the TypePad XML-RPC API last night, but they're all resolved now. If you want to keep track of these types of updates for TypePad and TypeKey, you can follow the Six Apart Status Weblog, which also has an XML feed.

If you want to get started with creating an application or service that posts to TypePad, you should check out the ProNet Resources page, which includes documentation of the TypePad Atom API, including support for posting to Photo Albums and TypeLists.

If you've been kicking around the personal web for a few years, you might remember Metababy, a site where anybody could go and create a new page or edit the ones that were already posted. In these times when people know and use wikis frequently, this isn't that revolutionary, but for a site designed to enable personal expression years ago, it helped open a lot of eyes.

As with many similar efforts, MetaBaby succumbed over time to neglect and spam and offensive postings, but the new MetaBaby has just been relaunched with TypeKey support. There's still the opportunity to post offensive things, of course, but it's a much higher barrier for people who'd just want to automate their disruptive behaviors. And it's helped bring back one of the sites that influenced a lot of the early blogging community.

Of course, if you just want to make your own apps take advantage of TypeKey authentication, you can check out the Everything TypeKey wiki, where one of the newest additions is a Ruby client script to enable authentication. If you've got an application or site that's got a unique TypeKey implementation, you can add your own to the list.

Jeffrey Zeldman shows his trademark thoughtfulness in his look at tag clouds, the popular technique of displaying most popular tags by size.

Though we're big fans of tag displays as used on O'Reilly's Radar blog, especially when entropy is part of the display, Zeldman's word of caution are a good guideline to follow. Judicious use of techniques like Adam Kalsey's weighted lists display in his Movable Type-powered blog will keep the technique as an effective way of presenting relevant information, instead of merely being used because it's possible.