Six Apart News & Events: July 2005

The team at Backbone Media has published Corporate Blogging Survey 2005 a brief but useful look at a lot of key business blogging data. From case studies to analysis, the white paper (downloadable as PDF) includes an enormous amount of valuable information. And of course, the survey is accompanied by a Movable Type-powered blog to accept feedback from the community on their findings.

Though there's always questions about accuracy and sample sets with any survey, the key ideas in the survey are extremely credible:

We discovered that corporate blogs are giving established corporations and obscure brands the ability to connect with their audiences on a personal level, build trust, collect valuable feedback and foster strengthened relationships while and at the same time benefiting in ways that are tangible to the sales and marketing side of the business.

It's a common refrain for us to talk about Movable Type's wide platform support, but we really are committed to making sure Movable Type's full power is available on the widest variety of platforms. It's an investment that takes a lot of care and attention, but we think it's well worth the effort.

For example, take databases. Movable Type has long supported multiple databases, with MySQL and Berkeley DB being among the most popular. But two mature, popular open-source database technologies that a lot of our users have requested have also part of our platform support for over two years: PostgreSQL and SQLite.

With Movable Type 3.2, we now extend this database support with our powerful dynamic publishing options. Since version 3.1, Movable Type has offered MySQL users a choice of dynamic publishing either for their whole site or on a per-template basis. This choice lets you balance between scalability and faster publishing times, and the default settings make smart choices for you if you don't want to configure them manually. Now in v3.2, PostgreSQL and SQLite are a happy part of the family of dynamic publishing databases as well.

The ability to have the same exact functionality, configuration and templates with different database is not only convenient, but often necessary if, as most of you have indicated, your development environment is different than your testing or deployment environments. As Professional Network member Tim Appnel has amply documented in his entry entitled "SQLite: The Best MT Database Choice Most of the Time", SQLite doesn't require a separate database server at all so you can get up and running easily on your development machine. Once you've created your site, you can choose PostgreSQL or MySQL as your scalable, robust production database, with the backing of their strong developer communities and commercial support vendors.

We welcome you SQLite and PostgreSQL users to the world of dynamic publishing in Movable Type and we look forward to pushing forward in the future both in terms of breadth and depth of the application's already broad platform support.

[This is part seventeen in a series called "Our 32 Favorite Features of Movable Type 3.2".]

The BigPAPI plugin for Movable Type allows you to create plugins that can easily add features to Movable Type's interface. This article explains the background behind the develpment of BigPAPI, and walks through the creation of a simple working plugin.

Why BigPAPI?

With each new version, Movable Type has become friendlier to plugin development. The earliest plugins could do little more than add tags to the platform's templating system. Now (as of version 3.2), the Plugin API allows plugins to define not only template tags but text filters, conditional tags, global tag attributes, object callbacks, application callbacks, object actions, itemset actions, and junk filters. And a plugin can contain its own CGI scripts that are tightly integrated with Movable Type, and easy to develop, thanks to the constantly improving API.

There's always been one missing element, though. A plugin has never been able to incorporate itself directly into Movable Type's own interface. While plugins can have their own interfaces that coexist with the core system, or define certain types of actions that will show up on some of the system's screens, developers have never had the ability to do things like add a field to an editing screen, or reorder the items in a menu, without making users hack some of the Movable Type program files.

Since Movable Type 3.16, alternate application templates have been an option, but they're somewhat limited; you can use an alternate template to add static HTML elements to the interface, but a plugin doesn't really have a way to interact with those elements. Also, using alternate templates creates problems when a new version of the application is released with changes to the original templates.

I created BigPAPI as a way around these limitations. It's a fairly simple plugin that doesn't do anything to the Movable Type interface by itself. Once it's installed, though, other plugins can augment or alter any page of the application in any way they see fit—no hacking necessary. (BigPAPI expands the Plugin API, hence the name.)

The Approach

BigPAPI takes advantage of the fact that Movable Type's codebase is neatly organized into modules, and the fact that Perl allows you to override a subroutine within a module.

The plugin essentially inserts itself at a couple of points so that it can run some callbacks before the MT::App module displays any application page. This means that in order to modify an application template before it's displayed to the user, a plugin simply needs to define the appropriate callbacks.

There are two types of callbacks, template and param callbacks. These are described fully in the BigPAPI documentation, so we won't go into much detail here. Instead, let's dive into an example.

HTML::Template

Before working with BigPAPI, you should have some familiarity with the Perl module HTML::Template. This is the module MT uses to build the templates for its interface. (Please note that these templates have nothing to do with the templates you create and edit within Movable Type, which are used to publish content.)

The templates for the application interface are in the directory tmpl/cms within your Movable Type installation. You may want to browse through some of these files to get an idea of the type of template code you'll be working with when writing a BigPAPI plugin.

A BigPAPI Plugin From Start to Finish

To illustrate the process of creating a BigPAPI-based plugin, let's take a simple piece of information that might be handy to have displayed in the application interface. The Categories listing shows the title of each category in a particular weblog. Let's suppose we want this page to display each category's description as well.

Getting Started

First we need to determine which of the templates in the cms directory Movable Type is using to build this part of the interface. You can usually figure this out based on the names of the templates, and by perusing the code of a likely template to see if it contains the expected interface elements for the screen in question. If that doesn't work, try following these steps:

1. In Movable Type, navigate to the screen you want to modify.
2. Look for the __mode parameter in the URL. In this case, it's list_cat.
3. Open lib/MT/App/CMS.pm.
4. In the big $app->add_methods() statement toward the top of the module, locate the mode. In this case, we see that 'list_cat' maps to the list_categories() subroutine.
5. Find the subroutine in the module.
6. At the end of the subroutine, look for a build_page statement. In this case, we find:

   $app->build_page('edit_categories.tmpl', 
   \%param);

Thus, the template we want is edit_categories.tmpl.

This approach doesn't work in all cases. But by poking around in CMS.pm and the template files themselves, you should be able to figure out which template you're dealing with.

Now that we know which template to target, let's begin writing some code. First, we need to define our plugin with some basic code that should be familiar if you've written, or examined, other types of plugins:

require 
MT::Plugin;
require MT;

my $plugin = MT::Plugin->new({
	name 
=> "CatListDescriptions",
	description => 'Display descriptions 
on the Categories 
listing.'
});
MT->add_plugin($plugin);

This gives us a plugin object we can pass when adding callbacks, and also registers the plugin so it'll show up in Movable Type's listing of installed plugins.

Tweaking the Template

In order to modify the category listing template, we first define a BigPAPI template callback:

MT->add_callback('bigpapi::template::edit_categories', 
9, $plugin, \&_template);

This means that whenever the system is about to build the edit_categories.tmpl template, it will first call the subroutine _template() in our plugin, and pass it a reference to the text of the template. Now we need to figure out what to do to that text. The best way to do that is to open the template, tmpl/cms/edit_categories.tmpl.

We want to add each category's description after its label. After looking through the template code, it becomes clear that the actual category listing is generated within a loop called CATEGORY_LOOP, and this is what displays the linked label:

<span 
style="margin-left: <TMPL_VAR 
NAME=CATEGORY_PIXEL_DEPTH>px;"><a href="<TMPL_VAR 
NAME=SCRIPT_URL>?__mode=view&_type=category&blog_id=<TMPL_VAR 
NAME=BLOG_ID>&id=<TMPL_VAR 
NAME=CATEGORY_ID>"><TMPL_VAR 
NAME=CATEGORY_LABEL></a></span>

But the more text we search for with a regular expression, the more prone our plugin will be to break with a future version of the template. Let's narrow it down to just the label itself, plus the closing link tag (we don't want the description to be linked):

<TMPL_VAR 
NAME=CATEGORY_LABEL></a>

The important thing here is to confirm that this text doesn't appear anywhere else on the template; we need a string that's as short as possible, but also unique, so that the change is applied in the right place.

So here's the code we'll use in our callback subroutine:

my $old = qq{<TMPL_VAR 
NAME=CATEGORY_LABEL></a>};
$old = 
quotemeta($old);

It's always a good idea to use Perl's quotemeta() function on a piece of HTML you're going to use in a regular expression, in case it contains characters thathave a special meaning within a regex.

For the replacement text, we want to retain the original string, and add a new HTML::Template variable:

my $new = 
<<HTML;
<TMPL_VAR 
NAME=CATEGORY_LABEL></a>
<TMPL_VAR 
NAME=CATLISTDESCRIPTIONS_DESCRIPTION>
HTML
$$template =~ 
s/$old/$new/;

That'll do it for the template callback. Our subroutine doesn't need to return anything, because $template is a reference, so changes made to $$template will apply to the original variable in memory.

Setting Parameters

Now we need to populate the variable we added to the template. For that, we define a param callback:

MT->add_callback('bigpapi::param::edit_categories', 
9, $plugin, \&_param);

This means that before Movable Type builds the category listing page, it will call our _param() subroutine, passing it a reference to a hash containing all the HTML::Template parameters that the system itself has already assigned.

Looking at the template again, we see that each row of the CATEGORY_LOOP has an element called CATEGORY_ID. We can use that to load the MT::Category object for each category. Then it's just a matter of putting the description into an appropriately named element in the row:

require MT::Category;
for my $row 
(@{$param->{'category_loop'}}) {
	my $cat = 
MT::Category->load({ 'id' => $row->{'category_id'} });
 
	$row->{'catlistdescriptions_description'} = 
$cat->description;
}

Note that we've named the parameter with our plugin's name as a prefix, so it's unlikely to conflict with any of Movable Type's parameters, or anything any other plugin might want to place on the template.

We're Done

That's it! Here's the complete plugin:

use strict;
package 
MT::Plugin::CatListDescriptions;

require MT::Plugin;
require MT;

my 
$plugin = MT::Plugin->new({
	name => "CatListDescriptions",
 
	description => 'Display descriptions on the Categories 
listing.'
});
MT->add_plugin($plugin);

MT->add_callback('bigpapi::template::edit_categories', 
9, $plugin, 
\&_template);
MT->add_callback('bigpapi::param::edit_categories', 
9, $plugin, \&_param);

sub _template {
	my ($cb, $app, 
$template) = @_;
	my $old = qq{<TMPL_VAR 
NAME=CATEGORY_LABEL></a>};
	$old = quotemeta($old);
 
	my $new = <<HTML;
<TMPL_VAR 
NAME=CATEGORY_LABEL></a>

<TMPL_VAR 
NAME=CATLISTDESCRIPTIONS_DESCRIPTION>
HTML
	$$template =~ 
s/$old/$new/;
}

sub _param {
	my ($cb, $app, $param) = @_;
 
	require MT::Category;
	for my $row 
(@{$param->{'category_loop'}}) {
		my $cat = 
MT::Category->load({ 'id' => $row->{'category_id'} });
 
		$row->{'catlistdescriptions_description'} = 
$cat->description;
	}
}

1;

This brief piece of code is all it took to dynamically add a useful, if trivial, element to Movable Type's interface. And now any user can make the same addition simply by uploading CatListDescriptions.pl to their plugins directory (in addition to BigPAPI.pl). With Movable Type 3.2, you can easily add code so users can configure your interface changes not to appear, or to appear with different settings, on specified weblogs.

Scratching the Surface

The plugin we've just implemented is hardly earth-shattering, but hopefully it's given you an inkling of the possibilities. I've already released a few slightly more substantial BigPAPI plugins: LinkEntryToFile, which applies Movable Type's "Link this template to a file" functionality to the text of entries; MainMenuRecent, which displays the latest entries for each weblog on your Main Menu; UpdateAuthoredOn, which lets you set the Authored On timestamp of an entry by clicking a button; and WeblogsActionMenu, which lets you jump directly to somewhere other than the menu in a different weblog.

But there's much more to come, and the real potential for this type of plugin will be realized when it's used as one component of larger-scale plugin applications—a plugin might have its own CGI script interface, but also use BigPAPI to integrate itself into the main Mpvable Type interface.

I'll be updating the documentation with more plugins as they become available. If you come up with a plugin based on BigPAPI, please let me know, and I'll add it to the list. I look forward to seeing what the Movable Type developer community can do with this tool.

From the O'Reilly Radar blog comes word of JSAN, the JavaScript Archive Network. JSAN promises to be the central resource for the Javascript community in the same way that its near-namesake CPAN has strengthened and united the Perl development community for years.

You can check out the archive yourself, with a fairly robust site already in place, including the requisite tag cloud for browsing. It shouldn't be long until we have Javascript JSON on JSAN.

Alistair Shrimpton, who heads up our Six Apart efforts in the U.K., has teamed up with Hugh MacLeod to create a Blog Designers wiki where designers can list themselves and their skills.

It's a great outlet for ProNet members to solicit work by linking to a personal profile. If you're updating with your own listing, be sure to include your name, an email address for contact, a phone number (lots of clients still like to use the phone!) and links to your profile site as well as some example sites.

A good suggestion any time that you're listing your professional credentials is to include as many methods of contact as possible (IM or Skype contact information can't hurt if you're reachable that way) and to have a specific landing page offering an overview of portfolio projects and contact information for your reference clients.

If you're a Professional Network member, or if you've created plugins or won any awards for your work, it can help reinforce your expertise to list these accolades or credentials in your promotional text as well.

Brad Fitzpatrick from our LiveJournal team will be speaking at the planetwork.net Monthly Networking event here in San Francisco this Thursday, discussing the new OpenID decentralized identity system. The format is a brief discussion of several identity-related ideas, followed by informal discussion, and only a small contribution is requested, so it's well worth taking the time to stop by if you're in the Bay Area.

One of our goals for Movable Type 3.2 was to make the system more pleasant to work with every day. And one of the small improvements in this version that we think will help save the time (and sanity!) of all of us who use Movable Type every day is a revamp of the way authors can select multiple categories for an entry.

Movable Type has long supported assigning multiple categories to any entry, and since version 3.1, you've also been able to easily create an infinite number of subcategories as well. But the default drop-down box hadn't evolved to accommodate these powerful new options, and solutions like putting a giant collection of checkboxes next to every entry would add to amount of items on the screen and create visual clutter.

So, with the twin goals of simplifying multiple category selection and preventing an abundance of categories from distracting from the entry that you're trying to write, we made a slick new category selection drop-down, seen here.

[This is part sixteen in a series called "Our 32 Favorite Features of Movable Type 3.2".]

Intelliseek's BlogPulse service has just launched BlogPulse Profiles. It's a useful utility for getting a better understanding of an individual blog's frequency of updating, impact, and trends.

Bob Lutz, the Vice Chairman of General Motors who's the voice of the Movable Type-powered Fastlane blog, has a strong new essay in InformationWeek, and it's well worth a read if you're making the case for blogging within your organization. The key point Lutz makes:

To blog or not to blog? For a lot of senior executives these days, that is the question. The answer, simply enough, is to blog. No better opportunity exists to engage in an open dialogue and exchange of ideas with customers and potential customers.

We've just posted 25 new blog jobs over on the members-only Professional Network blog, as part of our biggest roundup yet. We'll be working to expand our job listings for Professional Network opportunities soon, as this list was culled from hundreds of blog-related openings that have been posted just in the past few weeks.

We're excited to see so much demand for blog work in general, and Movable Type and TypePad work in particular, and we're welcoming discussion on the ProNet mailing list on what additional resources we can provide to help you take advantage of these opportunities.

Mark Nottingham's doing what he does best, creating useful specs, in his post on Making Syndication Enterprise-Grade. The idea Mark's advancing is that feeds need to be persistent and reliably retrievable back to the origin of a blog, not just for the most recent entries.

Mark's suggestions are worth checking out, and we've been thinking along the same lines here at Six Apart for all our platforms, so we'll be following up on these ideas as well.

Popular Gawker Media blog Lifehacker has just announced they're hiring another editor. The Movable Type-powered site for productivity geeks s looking for another blogger to strengthen their team, and if you're a ProNet member, you're probably right in the target demographic.

Also, Lifehacker's sister site in the Gawker stable, Gizmodo, has just launched a redesign. A smart evolution for the gadget blog, it features smart space for display ads and an unusual layout of publisher information in the footer of the page. They're also making extensive use of the Tags plugin for Movable Type to categorize content. The design has come a long way from the original version, which launched back in 2002 with a design by our own co-founder Mena Trott.

LivingDot, popular hosting service and one of our Movable Type Hosting Partners, has just announced the LivingDot TypePad Booster Package. This collection of services lets you add a domain name, email accounts, and additional disk storage to your TypePad account, and they'll even help map your domain name to your TypePad site.

If you (or your clients) are running a high-traffic TypePad site, or are doing a lot of media serving for things like podcasting, it's a great complement to the core TypePad service, and it's as little as an additional $7.95 per month.

Joe Gregorio's posted a new article on XML.com, called Secure RSS Syndication, and the story covers just what the title suggests. Using a regular XML feed, some Greasemonkey magic, and a private key, Joe's able to syndicate data without his aggregation service being able to read it. Cool stuff.

Deeje Cooley's posted a link to a Macromedia Blog Authoring Survey. If you maintain a blog regularly, they're looking for your feedback, and survey participants who finish all 30 questions are eligible to win an iPod mini.

With all the new features in Movable Type 3.2, the question on the minds of a lot of our current users is, "Yeah, this looks good, but how easy will it be to upgrade?"

We think the new version's not just the easiest version of Movable Type by far to upgrade, but it's the easiest of almost any web application we've seen. It'd be easy to tell you all about it, but it's even better to show you. So we've created a brief (one minute) Flash video to show you just how simple it is.

You can click on the thumbnail to start the 818KB movie.

[This is part fifteen in a series called "Our 32 Favorite Features of Movable Type 3.2".]

Movable Type's long supported multiple databases, and now that feature's gotten evne more powerful, thanks to a clever script that Hirotaka Ogawa has just published. MT Database Converter makes it possible to easily convert between MySQL, PostgreSQL, SQLite and BerkeleyDB.

If you're moving from a staging or development environment to production, testing a plugin that you've developed, or just want to move to a new database, this utility will be invaluable.

Though it's not, strictly speaking, about blogs or blogging technology, you might want to take a look at The Big Fish. The article on keepgoing.org is a look back at the history of seminal web zine Suck, showing how the publication developed, what impact it had, and how it helped influence a lot of people who are active in the blogging industry today.

It's a lengthy piece, but well worth reading over for some perspective, and you can keep your eyes open for a brief appearance by our own Mena Trott and Andrew Anker towards the end.

At long last, this word from Tim Bray: "this draft is essentially Atom 1.0". The IETF process has some final details to iron out, but it's finally time to start building on top of the new standard.

We'll be announcing more details of our coming support for the Atom 1.0 format shortly, but we're excited to see this milestone approaching and are looking forward to the innovations that are built on top of the spec.

There are improvements to Movable Type 3.2 throughout the application, but perhaps some of the most striking are visible right on the first page you see when you log into the system: the Main Menu.

For people who contribute content to Movable Type blogs, this is the place where everything starts, and hence we wanted to make it more customizable and convenient.

Quicker Access to Your System

First, users of older versions will notice that there are more links under each blog listed in your system. A better-organized collection of task links now includes one-click access to TrackBacks on any blog, and the target area for the "Create a New Entry" link is bigger and easier to find. Plus, as with all the new features of the Main Menu, there are new color icons that make individual items easier to distinguish and a little bit more spiffy-looking, too.

But what if you've got different designs on the display of menu? Well, the link to customize display options that you've seen earlier on the new listings pages is present on the main menu as well, and you can choose between the new space-saving link layout for each blog or a larger text size with a vertical layout. (As with the entire Movable Type interface, you can always use your browser's text-sizing options to make fonts larger throughout the system as well.)

Once you're in the the display options, you can also choose the order of display of your blogs, either alphabetical (the default), by the order the blogs were created or, what many may find to be the most useful, by the order they were last updated. And any of these options can be displayed in reverse order as well.

Manage Your Whole System

The main menu also gives you direct access to Movable Type's powerful new system administration functions. Direct links to the system-wide listings of weblogs, entries, comments and TrackBacks are one click away, and configuration of plugins, access to system settings, and search and replace are at your fingertips. As always, you can view the activity log and create a QuickPost link from the main menu page as well.

To save space, we've shown only the most recent update to Movable Type news on the new main menu, but you can always visit the system overview page to check out the full text of recent updates. Or as always, you can click through to the Movable Type website itself.

[This is part fourteen in a series called "Our 32 Favorite Features of Movable Type 3.2".]

Perhaps one of the most underappreciated bits of functionality in past versions of Movable Type is the Activity Log. For years, all common actions that take place in a Movable Type installation have been logged, providing administrators with a view of lots of key information:

• Successful logins and incorrect login attempts
• Creation, updating or deletion of weblogs and entries, and deletion of comments and TrackBacks
• Detailed errors generated from plugins
• Search terms entered into Movable Type's integrated search engine (great for knowing your audience is having trouble finding)

But we've left all that alone in version 3.2 of Movable Type and made no improvements. Just kidding! There's tons of cool new features in the Activity Log that will simplify management of your blogs, help administrators tweak the system, and provide an even more detailed record of exactly how your system is running.

Blog-Level Activity

First, many things traditionally logged in the activity log are blog-specific (e.g. new entry creation). Now, we've surfaced the blog-context in the form of a blog activity log. That means it's easy to click from a particular blog to a view of just the actions that have taken place on that blog, perfect for focusing on a particular blog's performance or activity. Of course, administrators can easily view all the activity for all blogs, just like always.

And the system-wide search that's woven throughout Movable Type 3.2 now works on the Activity Log. If you're having trouble with a plugin, want to track down a subtle behavior on your system, or just want to see all the things a particular user has been doing, it's an invaluable addition. Even better, you can limit search to a particular date range to narrow down the log to just the most relevant items.

A couple of our longest-standing annoyances with the Activity Log has been resolved as well: You can now control the number of log items displayed on a page, navigate through log items a page at a time, and easily reset the log without having to wait for dozens of log entries to display. If you're upgrading from an older version of Movable Type, you'll know exactly how convenient these improvements are.

You Can Take It With You

These new features are useful, but our business users, in particular, have told us they need to get this kind of important system information out into their other applications for use in reporting, status updates, and other business process documentation. It's finally easy to get your valuable Activity Log data out of Movable Type, as we've added a simple CSV-formatted export to the log page.

Whether you're just backing up your log for peace of mind before resetting it, or if you're opening the CSV data directly into a spreadsheet application to analyze search trends on your blog, Movable Type 3.2 can provide the data you need. This extremely simple export format is already promising to turn the Activity Log from a useful record into an essential management interface for business blogging.

In all, Movable Type's Activity Log has always been a unique strength, and we think with the new updates in this version, you'll find that it's a must-have reference for keeping the platform running at peak performance.

[This is part thirteen in a series called "Our 32 Favorite Features of Movable Type 3.2".]

Food blogs are a great example of how blogging and traditional journalism have evolved in their relationship to each other. Though people like to present traditional journalism and weblogging as if they're in opposition to one another, they really fulfill complementary goals -- especially in niche subjects. And everyone has to eat food, so this is an area where amateurs really have a lot to add to the coverage offered by professional journalists, due to their enthusiasm and excitement.

The most recent example is Steve Plotnicki's post on his TypePad blog, Opinionated About Dining. Steve was dining at Craft, a popular upscale restaurant in New York City, after having commented on Chef/Owner Tom Colicchio's work on his blog in the past. Amazingly, Colicchio recognized Steve from his blog:

What happened next was a seminal moment for me, because two minutes later, none other than Tom Colicchio himself appeared at our table (I'd met him a few times at Gramercy Tavern), and he was loaded for bear. “I have four pages of your comments that I downloaded from the Internet. I am going to go up to my office to get them and I want to go over them with you.� Not only was it an amazing scene to watch, but it was an amazing display of the power of the Internet. Here I was, Joe Shmoe, never had a piece about food published anywhere, and Colicchio wanted to ask me about my comments. Okay, so I’m not giving myself enough credit for making comments that obviously hit close to home for Tom, but who was I to have my criticisms taken seriously? That interaction has a lot to do with why I am here writing on this platform today. After all, if I could say things that got under Colicchio’s skin, and which he didn’t dismiss as the writings of some nutjob, maybe this Plotnicki guy actually knows something about food and dining out.

We know that many of you are getting as excited as we are about the upcoming release of Movable Type 3.2 and we wouldn't want to keep you waiting any longer than necessary to experience what the new version has to offer.

So, without further ado, today we are announcing the availability of Movable Type 3.2 Beta. The beta test is a completely open beta test available to anyone who wishes to try out the latest.

Over on the Beta Blog, you'll find everything related to the beta test including, obviously, the code, but also an entire community of other people testing out the software at the same time.

It's going to be an MT party, so make sure you drop by. No need to RSVP. Everyone is invited!

Oh, also, we will continue covering our top 32 features of Movable Type 3.2 shortly. But don't wait for us! Go download it and tell us about yours!

Given the scope of changes, fixes, and improvements in Movable Type 3.2, it was clear that simply updating our existing documentation for the new version wouldn’t be enough. So Movable Type 3.2 features a completely rewritten set of documentation for the platform that's more task-oriented than ever.

The twelve-chapter (plus appendices) tome is a recipe book for doing nearly anything in Movable Type and makes it easy to not only understand but to utilize the full potential of the software.

What's more, as a blogging company, there's nothing more that we value than our community's feedback and expertise so we'll be enabling community feedback on every single page to make sure the creative and clever contributions of Movable Type users are an integral part of the documentation as well.

We Wrote the Book on Movable Type

Movable Type has had good documentation of individual features, configuration settings, and template tags for years, but as the platform has matured, you've told us that you want docs that focus on solving problems, not describing options. So the new manual organizes common goals into problems, solutions, and a brief discussion of how a particular technique can be used.

We think the new system of documentation won't just help you troubleshoot a setting or configure your system, but will help you better understand how the platform works, and will help inspire you to think of new ways to use it.

Spreading Knowledge

Customers who've made use of the Movable Type Knowledge Base have told us it's an invaluable reference. Unfortunatley, in the past it's been inaccessible unless you had a paid license and, even then, not very easy to navigate to.

When Movable Type 3.2 is launched, we'll be debuting a new Knowledge Base, open to the public and linked to directly from within the application. In doing so, we hope to make everyone's experience with the software the best it can be.

But I Love To Read!

In addition to the updated manual for Movable Type, we've got a thriving community of authors making valuable resources available to the community. Some of the most popular titles include Rogers Cadenhead's Movable Type 3 Bible, published by Wiley; Learn Movable Type in 24 Hours, by Molly Holzschlag and Porter Glendenning; and an upcoming title due shortly that we're looking forward to, Hacking Movable Type, which was written by a Movable Type superhero team including Product Manager Jay Allen and Engineer Brad Choate.

With all of that, we just hope you'll still have time to blog.

[This is part twelve in a series called "Our 32 Favorite Features of Movable Type 3.2".]

One of the primary concerns for this new release of Movable Type was to really enable the creation and management of a community around your blogs. But you can't build your community unless you know who's participating in it, so we've made individual profile pages for each commenter who provides feedback on your blog, along with powerful new listings pages for managing the members of your community.

What's New Since The Last Version?

In Movable Type 3.0x and 3.1x, the platform offered a simple listing of commenters with the commenter's status (whether they were banned or approved), their name, a link to their TypeKey profile, and some simple tools to approve or ban the commenter.

With the new version, we've retained all of this information, but radically improved its presentation and utility and added significant detail and context to the display. This information can help you to encourage positive contributions, reduce the impact of trolls or disruptive community members, and in general know more about the people who help keep your blog active.

The new commenter listing has all the power of Movable Type's new listings pages, but provides email and URL links for each commenter who's provided that information, so you can respond directly to a community member when they've made a contribution. In addition, there's a count of all of a person's comments and the date of their most recent comment, since activity is a good indicator of their commitment to your community.

As always, you can filter for a subset of your commenters, take bulk actions like banning or unbanning, or trusting or untrusting an individual or group of commenters. Even better, each listing lets you drill down into an individual commenter's profile page.

Commenter Profiles

Each person who leaves a comment on your system has an individual record you can use to find out more about the person, or to review their contributions to your site. All known information about the commenter is displayed, including name, URL, email, and profile links. In addition, a listing of all comments from that user is presented, and with the new ability to customize listings, you can even view the full content of their comments inline for convenience.

As in the main commenter listing, you have a full slate of management actions that can be performed on a commenter, including marking a commenter as trusted or untrusted, banned or unbanned.

[This is part eleven in a series called "Our 32 Favorite Features of Movable Type 3.2".]

Part of the reason so many attractive and uniquely-designed sites are published with Movable Type is because designers find the template tag system straightforward and easy to understand for anybody who knows (X)HTML and CSS. But we wanted to encourage even more customization and experimentation with templates in Movable Type 3.2 while still allowing for all the power of the new features being made available.

As a result, Movable Type 3.2 introduces a number of simple, logical template tags for configuring comment and TrackBack submission and presentation. These tags eliminate the need for much of the complicated JavaScript and logical loops used to enable authenticated comments and other advanced features in older 3.x versions of Movable Type, while still giving total flexibility in configuration and design.

For example, the javascript used to switch between authenticated and unauthenticated comment submission has been moved to its own template, where it never needs to be edited in order to be used in any design. In addition, the comment and TrackBack listings have been made much more modular, to reduce the need for repetition of parts of the template. Plus, comments and TrackBacks now have header and footer tags, making it easy to wrap each piece of feedback in custom markup.

Simpler Template Tags

We worked hard with Movable Type 3.2 to make sure that confusing and obscure conditional tags like MTIfCommentsAllowed, MTEntryIfCommentsOpen and MTEntryIfAllowComments have been replaced with simpler tags that just do the right thing and don't require you to make changes if you modify your weblog's feedback settings.

All of the old template tags will of course continue to work, so your templates won't break, but new templates can be as little as half the size of previous Movable Type 3.x templates, while offering even greater functionality. And as always, you don't need to know any complicated programming functions to choose which information from your posts you'd like to publish in a template.

[This is part ten in a series called "Our 32 Favorite Features of Movable Type 3.2".]

As the Tour de France rolls along, we're enjoying a few blogs that might be of interest as examples of event-targetted weblogs. First, the Race To The Tour is a Movable Type-powered site run by Subaru, offering coverage of contest winners whom they've sponsored to blog the Tour. It's hard to believe people who aren't professionals can still have the energy to blog after riding all day, but they're doing a great job.

For general coverage of the Tour, you can't beat TDFBlog. Now on its third year of coverage, this site was one of the first hugely popular TypePad-powered sites, and it's maintained its edge in 2005.

Michael Schneider, who runs the well-received new Movable Type weblog with tips and tricks, has just launched MTLookup.

The new site is a powerful tool for searching the full text of some of the most popular resources for the Movable Type community. The sites indexed include Elise Bauer's Learning Movable Type, Arvind Satyanarayan's Movalog, Michael's own Movable Type weblog, and the official documentation to the site. As MTLookup expands and additional documentation becomes available, this resource should become an invaluable part of any Movable Type power user's toolkit.

With Movable Type 3.2's focus on enabling community, we wanted to make sure that a blog administrator can recognize the people who build the community around a weblog. And if you're keeping a personal blog, you want to make sure your friends feel welcome when they visit your site.

TypeKey Authentication

Last year, we released the TypeKey authentication service to allow commenters to identify themselves in a consistent manner. This lets site owners assign persistent rules to an individual that act every time that person visits a blog. Since then, over a million people have signed in with the service, and a thriving community has sprung up around the TypeKey service and protocol.

The TypeKey authentication service can be used in custom applications written in any common programming language, and the TypeKey protocol has open documentation which has resulted in the creation of several third-party authentication systems that can be used in place of the TypeKey service. Requiring comment authentication has also become a very powerful way to nearly eliminate comment spam.

But, though an original goal for TypeKey was to provide a consistent identity for the purpose of banning spammers or abusive commenters, there are millions of positive contributions being made by authenticated commenters. So, the new version of the Movable Type platform features a new trusted status for commenters that lets you flag any individual as welcome in your community.

Trusted Commenters

By default, Movable Type 3.2's support for trusted commenters lets you flag any authenticated commenter as trusted. Trusted commenters are marked with a special icon in all application listings, and comments from trusted commenters are always whitelisted, so they're never sent to Movable Type's new junk folder.

In addition, trust status is an integral part of the commenter object within Movable Type. This means that plugin developers can build behaviors around a commenter's trust status, giving trusted commenters a custom display or granting them permissions on the system to do things like modify a comment's junk status.

In all, the authentication provided by TypeKey and TypeKey-compatible services, combined with the new ability to mark any individual as a trusted member of your community, should help you get the best possible feedback on all your blogs.

[This is part nine in a series called "Our 32 Favorite Features of Movable Type 3.2".]

The hundreds of plugins available for Movable Type are what define its power and flexibility for a lot of users, and we've tried to do justice to the creativity and innovation of our plugin developers in version 3.2.

Movable Type's plugin architecture dates back three years to version 2.2. In that version, we added the ability to create custom template tags, and version 2.6 built on that framework by adding custom text formatting plugins and the ability to store data for use by plugins.

In version 3.0, we radically revamped the plugin architecture to support the creation of full applications on top of the Movable Type platform. And version 3.1 extended this power with application-level callbacks that brought on a number of truly professional-grade plugins.

What's New for Plugins in Movable Type 3.2?

Now that we've got a rich and mature base of plugins taking advantage of the new platform's potential, we've focused on making them accessible and manageable for all the users on a system. To that end, there are a few new areas that make plugins an even more integrated part of the application.

First, the system overview section we've mentioned earlier has a section specifically for configuring system plugins, including the ability to enable or disable any individual plugin or all of them at once.

As always, plugins designed for version 3.0D or higher have the ability to display the name of the plugin's author and a link to documentation for the plugin. But now all plugins, even those designed for 2.x versions of Movable Type, can also display a list of which template tags, tag attributes, and text filters the plugin makes available.

In addition, plugin developers don't have to create an entire application user interface just to let users configure settings; Individual settings for plugins can be displayed inline on a single page.

Per-Blog Plugin Settings

In addition to all the new functionality around managing plugins, it's now possible to expose blog-level settings on any plugin. Each of the blogs in a large installation can customize the settings they use for the plugin, and Movable Type automatically stores the appropriate settings that are specific to each weblog.

Whether you're tweaking plugin settings for a specific blog, enabling a plugin application across your entire installation, or just reviewing your system's plugins using the new management interface, Movable Type 3.2 will make plugins easier to configure, use, and manage.

[This is part eight in a series called "Our 32 Favorite Features of Movable Type 3.2".]

Robery Sayre's just published a terrific overview of the Atom syndication standard and API, appropriately titled "Atom: The Standard in Syndication". While much of the basic material might be familiar, it's still one of the most comprehensive overviews of the power and purpose of the standard.

We've all been conditioned over the last few years of using the web to find stuff by searching, instead of having to browse through a hierarchy to find information. Even Movable Type has had, since the early days, a basic internal search and replace feature. But we wanted to go further to make sure that pervasive searching was part of the platform with Movable Type 3.2.

Search (almost) everything

Movable Type 3.2 introduces a whole new search and replace interface. Now you can search not only entries, but a wide variety of items in the application:

• Entries
• Comments
• Commenters
• TrackBacks
• Activity Log
• Templates

What's more, once you're viewing your search results, all the power of Movable Type's new listings pages is available for managing and acting on the found items. Forget about hunting through listings for that particular Trackback or scrolling through an impossibly long Activity Log to find a plugin error; Now all the content of your blogs is just a simple search away.

Search Everywhere in the System

In this new version, the powerful search box is present in the upper-right corner of almost every single page of the application. If you'd upgraded from 2.x versions of Movable Type to 3.x and missed the ability to search from any page, you'll be glad to know that the familiar search box is back and better than ever.

Just click into the search box (or use the search shortcut key to jump to the field), type your query and find items you're looking for. The best part is that searches are always within context: If you're editing an entry, searches will automatically be targeted to entries, and if you're listing comments, searches will default to looking within comments.

Searching Templates, and Fearless Selective Replacement

One of the most exciting new areas of search functionality is being able to search and replace within templates. Whether you're tweaking an item across a number of templates, or you want to make large-scale changes to your site, you can now easily modify all your templates, or just select specific templates to apply changes to.

In addition, the user interface for searching's been extensively revamped, so the previously intimidating replace functionality is now a lot less scary to work with. You can now choose to replace matches in just a few selected search results or even constrain your search and replace to certain fields of those items. This allows you to do something like, for example, replace a particular portion of the linked file path in only four templates. Or just add a particular keyword to all entries containing a certain term.

We've seen from early testing that the new search power in Movable Type changes the way that users work with the system. Instead of filtering entries by category and then paging through a list, it's easy to just enter in the title or some entry text, or any other part of the entry you remember, and zip right to the entry you'd like to work with.

Search Through All Your Blogs

As always, we've wanted to make sure all the new features of Movable Type 3.2 are available to administrators, so the power and flexibility of these new search features is available at the system level as well. All the search and replace features are available for use across all of your weblogs, right from within the system-wide administrative features that we've described.

Want to change a detail of a template across 50 blogs? With Movable Type 3.2, that power is just a few clicks away. We're sure that you'll find an infinite number of uses for the platform's new searching power while working with your blogs.

[This is part seven in a series called "Our 32 Favorite Features of Movable Type 3.2".]

Courtesy of Steve Rubel comes work of Vespaway, the cool new blog from popular scooter maker Vespa.

Though the scooters are already enormously popular, Piaggio USA, which makes Vespas, is making a big bet on blogs to help sustain and grow the enthusiasm around the brand. And there's another VespaBlog on the way, with good reason according to VespaBlogs.com:

Piaggio USA feels blogs are an ideal way to connect with Vespa brand loyalists and encourage them to become online evangelists. It is an extension of the scooter clubs that have existed offline for years. One reason is that U.S. scooter buyers are heavy online users. According to internal Piaggio USA research, a full 65% of prospective motor scooter buyers visited the Vespa USA Web site, while 56% visited other sites when conducting research prior to purchase. Piaggio USA hopes that by hosting a transparent peer-to-peer discussion, it will enable more individuals to embrace scootering for a wide array of daily lifestyle needs. In addition, it will enable Piaggio USA to actively listen to consumer feedback in real-time.

While creating our recent updates to TypePad, we needed to be able to create simple drop shadows for elements of our user interface. Randy Reddig, one of our engineers here at Six Apart, created a simple system that can be used in any CSS layout, and now he's written up a ProNet article about the technique so you can make use of it in your own applications and sites.

yDSF - Robust CSS Drop Shadows describes the way it works, offers up a sample page showing some (over)use of the technique, and documents how yDSF works with all modern browsers while gracefully degrading on older systems. If you're a TypePad user, you can already see it in action just by using the new comment and TrackBack management screens.

Except when you're writing or editing entries, much of the time spent in Movable Type is in managing the listings of entries, comments, TrackBacks, authors, or other items in the system. In past versions, listings could be inconsistent, with listings offering varying degrees of control, and the arrangement of information on some pages being frustrating. Worse, when the same type of information was listed in two different places, it wasn't always the same. For example, the comment listings page and the display of comments on an individual entry worked in completely different ways.

Every listing page improved

With Movable Type 3.2, we've made some massive improvements to the way that items in the system are listed, and early testers have told us it's not just an improvement over older versions, but it's one of the best listings interfaces they've seen on any web application. Simple status indicators commmunicate more about each item you're viewing, action buttons allow you to perform common tasks without having to click through to each item's detail page, and powerful filters let you view smart subsets of the information you're managing.

We've also made a consistent display for every list, with a selection checkbox at the front of the listing and common actions available as buttons for working with the selected items. And actions that you need to access infrequently are available on a drop-down menu next to the primary action buttons.

Each of these changes is a small addition on its own, but taken together, they make for a much more satisfying experience, and they streamline the workflow of any user who spends part of their day in Movable Type 3.2. (And, as a special note for plugin developers: If you've got a table listing in your plugin's user interface, this functionality is available to easily add in to your applications as well.)

Quick Selection in Item Lists

In addition to the powerful actions built into the system, there are some niceties that make managing items in the system a lot more pleasant.

Want to select an item? Just click on any empty area in that row; You don't have to hit the checkbox to highlight the item. Want to select a range of items? You don't have to manually check a series of boxes; You can just click on the first item and then shift-click on the last and the rows in between will be automatically selected. Check the box at the top of the column to select all, or to invert your selection if you already have some rows selected.

In all, managing the infinite number of comments, TrackBacks, entries, authors, and blogs which Movable Type supports is easier than ever with the new item listings features in Movable Type 3.2.

Customizing your display

Of course, we didn't stop there. While being able to easily manage bulk and single items is a timesaver, the listings might not always fit the way you work and think. For that reason, we've introduced the ability for each author to tailor each listing to their own liking.

Each listing allows you to customize the following options:

• Number of rows per listing
• Position of action bar (top, bottom, both)
• Relative or fully-qualified dates
• Compact or expanded view of entries, comments and TrackBacks

Shortcut keys throughout Movable Type

On top of the extensive new improvements to listing screens, we've added broad support for shortcut keys throughout Movable Type 3.2.

At any point, common shortcut keys to speed you through the most popular actions on a given page. Saving an entry from the Edit Entry screen is a simple Alt-S (Ctrl-S for Mac users). Alt-P lets you Preview, Alt-F lets you Find (or Search) from any page, and each listing screen features custom keys appropriate to its context. Once you're used to zipping through the application with shortcut keys, you'll never go back to mousing around. Here's a list of just some of the new shortcut keys available:

• Alt-D: Delete the currently selected entry, comment, TrackBack, category, author, or weblog.
• Alt-J: Send the current comment or TrackBack to the Junk Folder. (If Junk is selected, this recovers the selected item.)
• Alt-P: Preview the current entry, or publish selected comments or TrackBacks.
• Alt-R: Rebuild the selected entry or template.
• Alt-S: Save the current changes or edits to an entry, author, template, comment, TrackBack, or setting.
• Alt-F: Find items by Searching on any page.

[This is part six in a series called "Our 32 Favorite Features of Movable Type 3.2".]

Master hacker Phillip Torrone's documented some of his tips and tricks for working with Movable Type on the Make magazine blog. Take a look at Make out with FireFox for highlights on adding spellcheck, streamlined uploading, and automated entry of frequently-typed text to your blog using Firefox extensions and Movable Type.

Jeffrey Veen's "The Art and Science of Web Design" has been an influential work for many web designers for half a decade now, and to celebrate, Jeff's made a PDF of the book available on his blog for free download.

Though, as Jeff points out, some of the technical points are slightly out of date, the core principles are still important today, and the download is well worth a look.

We've worked hard to make sure all the configuration settings for your weblogs are more intuitively organized and simplified, while still retaining all the power and control that Movable Type affords.

New in Movable Type 3.2 is a reorganization of weblog configuration into a few weblog settings screens. One of the most notable is the Feedback settings, which govern comments and TrackBacks. At the simplest level, there's a blog-level on/off switch for both comments and TrackBacks, and the options for each have been reduced to cover all the common scenarios for enabling feedback on a blog. You can easily require authentication, make it optional, or not require it at all, and it's simple to moderate or publish feedback by default based on the status of the commenter.

Once you've got comments and TrackBacks flowing into your blog, you'll want to make sure you know about them. You can set email notifications to be sent to you when any new comment or TrackBack is posted, only when the item requires your attention, or you can shut off email notifications entirely.

Finally, the blog Feedback settings page lets you control the treatment of junk feedback you may receive. You can tweak your junk threshold to make your feedback rating plugins more or less aggressive and set up auto-deletion of items that land in your junk folder.

Overall, comment and TrackBack configuration has been made not only easier, but gives you far more control over the treatment of feedback on any weblog.

[This is part five in a series called "Our 32 Favorite Features of Movable Type 3.2".]

Many users are experiencing intermittent 500 errors when using Movable Type, apparently as a result of certain Perl modules being upgraded by CPanel. (CPanel is an application which automates the management of shared hosting accounts.)

The modules are currently identified as DBI and DBD::mysql. Preliminary reports suggest that reverting these two modules to versions 1.47 and 2.9006 respectively will eliminate the 500 errors.

Some limited testing in a non-CPanel environment with the latest versions of these modules (1.48 and 3.0000 respectively) has not produced any similar performance issues to date; thus, it is not yet clear whether the newer modules alone are responsible for these errors, or whether it is something inherent to CPanel itself which is contributing to the issue.

We are still gathering information on the various configurations which have been affected at this point. Once we've determined all of the incompatibilities and created a patch, we'll post additional information here on the Professional Network blog as well as on Movable Type news.

UPDATE (Jul 6th, 2005 11pm PST): The developer of the DBD::MySQL driver reports that he has discovered the source of the problem (with the help of our own Brad Choate) and posted a fix for the module. Those of your with hosts using automatic CPanel updates should see the updates within the next 24 hours.

Movable Type is the platform that introduced TrackBacks to the web, and now in version 3.2 we've given you the most powerful interface for managing, moderating, and editing TrackBacks that you receive.

TrackBacks are finally equal citizens in the Movable Type platform: Just like comments, they can be directed to go into moderation, and any TrackBack that's been received can be edited. These two features have long been requested by our users, and we're glad to include not just these improvements, but a full suite of TrackBack management options including the new junk folder for spam TrackBacks, and a powerful new user interface for performing bulk actions on TrackBacks including deletions, moderations, and approvals.

[This is part four in a series called "Our 32 Favorite Features of Movable Type 3.2".]

We've documented the improvements to TypeKey that were made last night, and some additional minor updates to the service meant that TypeKey registration was intermittently available tonight. The service is now back to 100% performance and, as always, you can follow performance updates on TypePad or TypeKey at any time on the status weblog.

Drop shadows are cool, but adding them to elements of a web page can be a pain. You can fiddle with background images, tables, pure CSS solutions, Internet Explorer PNG limitations, or fixed single-use shadows tied to an image and a particular background.

The latest release of TypePad has a new popup (or flyout) interface element which presents the user with a set of options or an expanded view of an object when clicked on. The flyouts are similar to the location bubbles used in Google Maps. They have soft alpha-blended drop shadows that scale with the size of the box. The drop shadows are implemented in valid XHTML and CSS, with no CSS hacks or JavaScript. We call it ydnar Drop-Shadow-Fu.

Besides filling the need of TypePad’s user interface, yDSF is good for floating or other positioned block-level elements where a drop shadow is desireable. This article will describe the CSS needed to implement this use case.

Example Files

• yDSF Demo Page
• yDSF CSS
• Shadow Image (PNG)
• Shadow Image (GIF)

Requirements

We needed drop shadows that would be as simple to add to a page as possible. With that in mind, yDSF was created to meet the following requirements:

• Pure CSS (no tables)
• As little extra markup as possible
• Scalable to arbitrary width/height boxes, without special-case images
• Best-of-breed display on modern CSS2+ browsers (Mozilla, Safari)
• Reasonable fallback for Internet Explorer (5+)

Implementation

yDSF is comprised of some lightweight structural (non-semantic) XHTML markup and a few CSS classes.

The Markup

<div class="ydsf">
	<div class="inner">content</div>
</div>

Content inside the inner div can be any regular XHTML. Content elements with vertical margins may cause the drop shadow to render incorrectly. Usage of additional containers with borders or clearing elements might be necessary. For instance, both Mozilla and IE require a br element after a single img, but for different reasons.

The CSS

The yDSF CSS is structured for Internet Explorer (<= 6), with CSS2 selectors used for the additional attributes necessary for more capable browsers. There are two class selectors and two pseudo-element selectors:

• .ydsf
• .ydsf:before
• .ydsf:after
• .ydsf .inner

.ydsf Selector

The .ydsf selector styles the container element. It has the background image (GIF for Internet Explorer, PNG otherwise) for the drop shadow. The base/IE code is as follows:

.ydsf {
	display: block;
	position: relative;
	margin: 4px -4px -4px 4px;
	background: url(shadow-grid.gif) repeat;
}

The .ydsf class also specifies a fixed-up margin to move the offset block element back to where it would normally be positioned in the absence of a drop shadow. To increase the visible margin around the .ydsf element, add to (don’t replace) the existing margins.

The CSS2 html>body .ydsf selector adds the soft 24-bit PNG drop shadow, and adjusts the margin for the difference in shadow width. The offset of the shadow is done in the shadow.png image. For this example, it has 4px of transparency on the bottom and right sides.

html>body .ydsf {
	margin: 10px -10px -10px 10px;
	background: url(shadow.png) right bottom no-repeat;
}

.ydsf:before and .ydsf:after Pseudo-Elements

CSS2 browsers use the .ydsf:before and .ydsf:after pseudo-element selectors to render the upper-right and lower-left drop shadow corners. They are rendered as block-level elements with content: " " and some negative margin hijinks. Both .ydsf:before and .ydsf:after share some common attributes, including inheriting the background image of .ydsf and block/layout attributes.

.ydsf:before,
.ydsf:after {
	content: " ";
	display: block;
	width: 10px;
	height: 10px;
	background: inherit;	
}

The upper-right drop shadow corner is described by .ydsf:before. It is absolutely positioned on Safari, and positioned via margins in Firefox:

.ydsf:before {
	position: absolute;
	top: 0;
	right: 0;
	margin: -10px 0 0 auto;
	background-position: right top;
}

The lower-left drop shadow corner is described by .ydsf:after:

.ydsf:after {
	margin: -10px 0 0 -10px;
	background-position: left bottom;
}

.ydsf .inner Selector

The .ydsf .inner selector styles the inner box element where the content sits. Like .ydsf it is divided into IE/base CSS and CSS2 areas. It mainly serves the purpose of offsetting the content back to the position it should be in as if the drop shadow was not present.

.ydsf .inner {
	display: block;
	position: relative;
	overflow: hidden; /* prevents margin leakage from child elements */
	left: -4px;
	top: -4px;
}

The CSS2 version is straightforward, except it uses negative margins instead of relative offsets to achieve the offset:

html>body .ydsf .inner {
	left: -10px;
	top: -10px;
	margin: 0;
}

Conclusion

With Internet Explorer 7 going into beta this summer, Microsoft may decide to support more of the CSS2 spec and hopefully parse and display the entirety of the yDSF drop shadow effect. If you can live with the IE6 and below rendering, or choose to omit the drop shadow entirely on that platform, yDSF is usable today.

This article (and technique) was inspired in part by some excellent precedents, including Sergio Villarreal’s article on A List Apart and Douglas Bowman’s sliding doors technique.

One of the great things about having had the LiveJournal team join us at the beginning of this year is that we've learned a lot of good ideas from them. Among the best, and simplest, is the monthly updates that the team posts to LiveJournal News. We've decided to steal share the idea, so here's a quick roundup of what we've been up to in the past month at Six Apart.

Continue reading 'Six Apart Update: June 2005'...

Movable Type 3.2 features a new take on an old friend: the Junk folder. In your email program, some messages are likely to be spam, and most email applications these days offer a folder that can be set to delete junk after a set period of time.

We've brought the same convenience and power to Movable Type. Using the new feedback scoring system described earlier, comments or TrackBacks that fall below your spam threshold score can be set to be automatically deleted after a configurable period of time. (The default is 14 days.) The best part about the new junk folder? You don't have to touch it. If you just want to accept the default settings and not mess with junk comments or TrackBacks again, they'll be taken care of without your intervention.

But if you really want to tweak your settings or adjust the amount of time that Movable Type stores junk you've received, the full power and customizability of the system is just a click away. Plugins for the new spam framework can automatically be trained by watching which comments or TrackBacks you mark as junk. Two new callbacks, named Is_Junk and Not_Junk make it easy for developers to make plugins that learn from your sorting. And the entire scoring system is tweakable, so you can make the filtering as aggressive or forgiving as you'd like, without ever having to worry about false positives blocking legitimate comments or being stuck fishing legitimate comments out of the junk folder.

[This is part three in a series called "Our 32 Favorite Features of Movable Type 3.2".]

For a lot of bloggers, participating in a community online is what motivates us and keeps us blogging. Good feedback from commenters and people sending TrackBacks can keep a weblog alive and vibrant, but negative comments or, worst of all, the plague of spam, can take all the satisfaction out of maintaining a blog.

Because nothing's more frustrating than spammers or trolls ruining your community, we've tried to make sure you have strong anti-spam tools out of the box in this new version of Movable Type. But eliminating the annoyance of spam is where the new community management features start, not where they end. So, we've made a powerful new Feedback Rating System in Movable Type 3.2.

If you're familiar with SpamAssassin — the wildly popular email spam filter — you probably already understand a lot of how this works. Our feedback rating framework scores comments and TrackBacks in real-time as they are received, and the system has the ability to take action on the basis of those scores.

There are a few differences from SpamAssassin-style systems, though. First, our framework is plugin-based, which lets you choose which types of rules work best for you, and provides the ability to quickly adapt and customize your system as necessary. (One of the best ways to make it hard for spammers is to make sure each installation of a system is unique, or at least less predictable, in the way it behaves.) Second, the system isn't just for fighting spam: Any feedback item can be have a positive score making it easy to promote the best content your community has to offer. And all of the rules that rate your feedback can work together, making a total judgement on the comments and TrackBacks that enter the system.

From the standpoint of fighting spam, there's no question that a collaborative, scoring-based framework works. Unlike previous version of Movable Type, plugins can finally work together to assess the desirability of a comment or TrackBack without stepping on one another's toes. Plus, when spammers change their tactics, the plugin developer community can respond quicker, with simpler plugins that add simple rules to counter new threats. And popular anti-spam or community management plugins from older versions of Movable Type, such as SpamLookup or Blacklist or Moderate, will of course still continue to work.

Whether you use the new rating framework to highlight your best commenters or send your most unwelcome to the dustbin, we are sure that you will find the feedback rating framework to be one of the best additions to Movable Type in a long time.

[This is part two in a series called "Our 32 Favorite Features of Movable Type 3.2".]