MovableType Tips

Leverage Your RSS Feed

2008-05-15T21:41:50Z

Chances are your RSS or Atom feed template has a section that includes likes like these:

<$MTEntryTitle remove_html="1" encode_xml="1"$>
<$MTEntryBody encode_xml="1"$>
<$MTEntryPermalink encode_xml="1"$>
<$MTEntryDate format_name="rfc822"$>

If so, you're missing out on something very, very powerful.

]]> Let's make two assumptions:

Your feed will be republished
You don't know where your feed will be republished

You have an opportunity to "brand" each entry you publish in your RSS feed with additional, static content that you control. When your RSS feed is republished, that content will be included.

The magic happens here:

<$MTEntryBody encode_xml="1"$>

Why include only the body?

Here's the equivalent segment from the Ask Leo! RSS feed:

<$MTEntryBody encode_xml="1"$>
Continue reading
"><$MTEntryTitle remove_html="1" encode_xml="1"$>

Tech Questions?
Get Answers! -
Ask Leo! ... by Leo Notenboom

Leo's Answers Newsletter -
Ask Leo! in your inbox every week.

]]>

Examine that carefully. All I've done is added to the template some static text - encoded for XML - that appears at the bottom of every item in my RSS feed that adds:

An explicit "Continue Reading ..." link (not all news readers make this option obvious).
Branding and keyword targeted links back to my site (guess who's currently #1 for "Tech Questions" and #4 for "Get Answers"?)
An engagement link, encouraging newsletter signups.

So, in the RSS feed entry for Why am I not getting some emails in my MSN Live Hotmail account?, we get the entry body (which in my case is a "tease" to read the rest of the article) followed by this:

Continue reading Why am I not getting some emails i n my MSN Live Hotmail account?
Tech Questions? Get Answers! - Ask Leo! ... by Leo Notenboom
Leo's Answers Newsletter - Ask Leo! in your inbox every week.

As you might imagine, while I've used only some simple static text and links, which I believe are appropriate and inoffensive to my target audience, the gates are actually wide open for anything that most feed readers might display.

Regardless, it's an opportunity for some simple, easy and quick content distribution.

Place Ads Precisely with OpenAds

2007-09-29T22:03:23Z

OpenAds, formerly known as PhpAds, is an ad management server that many people are using to display and control ad blocks on their web sites. My site Ask Leo! used OpenAds to serve up ads, including both Google's Adsense as well as direct purchase advertising.

The "problem" is that OpenAds doesn't natively support the level of ad placement that I'm looking for. However things like that don't always stop me. This article describes the approach I've taken using OpenAds to place ads in my MovableType generated pages:

in specific articles
on specific pre-defined positions on a page
any combination of those two
in any specific category
site wide

All while maintaining most of OpenAds other features including weighted distribution of ad content.

Now, I do have to throw out a few caveats:

As I write this I'm running OpenAds 2.0.11. Naturally later versions might add features and functionality that make my efforts redundant.
I'm going to assume you have at least a basic understanding of OpenAds. It's non trivial, and documenting it is well beyond the scope of this site, and for that matter, my abilities.
My approach might be stupid. Someone more familiar with OpenAds might well say "you should do it this way" and define something much more elegant. Fair enough. My approach works, though.

With all that butt-covering out of the way, let's dive in.

]]> I don't use Zones.

As I understand it, Zones are OpenAds way of defining areas that ads can appear in. You might define the "above the fold" area of a page is a particular zone, and then later assign ads to run in particular zones.

I couldn't figure out zones.

As far as I could tell, defining a new zone, for say, each individual article or class of article or position on a page, or more importantly, arbitrary combinations of those was beyond me. I couldn't see it as being possible.

So I did it my way.

•

I've defined several conceptual ad block positions. For example what I refer to as "adblock #1" is my prime position, on the left "above the fold" block on every individual entry archive page. "adblock #3" is the newsletter subscribe box you see further down the page, also on every individual archive page. There are others, but I'll focus on those for purposes of example.

And as you know, in MovableType, each entry is given it's own ID number, and can be assigned one or more categories, each with its own label.

Given all that information we have enough to define every ad block on every page or within every category uniquely. The problem is getting that information to OpenAds in a way that will allow it to select ads based on somehow using those as criteria.

Buried deep in the OpenAds documentation is the concept of selection strings, advanced selection strings, and keywords.

The concept is simple: using the ad blocks I've defined plus the entry and category IDs MovableType generates, we define a set of keywords and use them in selection strings that are automatically generated when the pages are built by MovableType. Then by assigning the appropriate keywords to the ad inventory itself we can control with precision exactly what ad gets placed where.

This is best explained with examples.

•

Here's the line from the individual entry archive template on Ask Leo! (it's actually all on one line, but formatted here for readability):

Adblock.php is a small php script I'll discuss in a moment. What's of interest first are the parameters that it's being passed:

block is the adblock id number I dreamed up. As I mentioned earlier, ad block #1 is the upper left above-the-fold ad block, and that is where this line is positioned in the individual entry template.
entryid is exactly that: the entry ID number assigned to the current entry as defined by MovableType.
catid is a list of the dirified labels for all the categories and subcategories that the current article might be assigned to.

Using the article Who is Leo? as an example, that line is expanded when the page is built into this:

In English, that means this line is referring to ad block #1 on the page for entry ID #484 in the category "administration".

However if you view source on that page, that's not at all what you'll see. Adblock.php's job is to generate the Javascript used by OpenAds to place an HTML ad. In the current example, what you'll adblock.php generate is this:

You'll notice that, aside from the

I've placed around it for my own CSS needs, this is very similar to the JavaScript code that OpenAds offers you to copy/paste if you use their standard ad placement mechanisms. If you look closely, though, you'll see that the parameters passed to adblock.php have made it into the JavaScript in what is probably an unfamiliar fragment:

   "adblock1,_entryid484|adblock1,_administration|adblock1def"

This is an advanced selection string.

Again, I won't go into the details of selection strings, but to translate this one into English, it says, effectively:

select ads with both keywords adblock1 and entryid484
if there aren't any of those, then select ads with both keywords adblock1 and administration
if there aren't any of those, then select ads with the keyword adblock1def

Now, go have a look at the page in OpenAds where you define or modify an HTML banner ad. You'll notice a little field labeled "Keywords".

This is the point at which you should be excited.

If I want an ad to appear on only in this position and only on this page, then in the ad inventory I assign it the keywords "adblock1" and "entryid484". (Multiple keywords are space separated in OpenAds, so what I'd enter would be "adblock1 entryid484".)

If I want an add to appear in this position and on every page in the category "administration", I assign it the keywords "adblock1" and "administration".

If I want an add to appear site-wide in this ad block position I assign it only the keyword "adblock1".

And finally, I make sure to define an adblock that's to be used if all else fails, and assign that the keyword "adblock1def" for "ad block 1, default". If no other ads are configured to be in this particular spot on this particular page, then it's adblock1def that is show. In my case, adblock1def contains my Google Adsense code.

That's really all there is too it.

•

Summary

Come up with a numbering scheme that identifies your ad block positions.
Download and modify adblock.php to reference your own installation of the OpenAds ad server.
Upload adblock.php to your site
Modify your MovableType templates to reference adblock.php where you want adblocks to be placed. Make sure to pass the appropriate block ID that you defined in step 1.
Create default HTML ads in OpenAds referencing "adblockXdef" for each adblock that you've defined.
Start creating HTML ads to override those defaults using keywords as appropriate.

And finally, download adblock.php (in zip form). Caveat/disclaimer: this code is presented for your use without warranty or guarantee of any sort. For all I know it'll reformat your server, crash your car, give your cat fleas and eat your homework. I don't think it'll do anything of the sort, but I don't guarantee that it won't. By using it, you're assuming all responsibility for whatever it might do.

Oh, and you're free to use it wherever you like. A link back to either http://www.MTTips.com or http://Ask-Leo.com would be appreciated.

Tolerate Broken URLs

2007-05-18T23:05:08Z

If you use meaningful page names on your site, you'll often end up with URLs that are quite long. For example out on Ask Leo! you'll find an article entitled What's the difference between Windows Live Messenger, Windows Messenger, MSN Messenger and Windows Messenger Service?. If you look at the resulting URL, it's very long. So long, in fact, that I need to chop it down to show it to you here:

http://ask-leo.com/whats_the_difference_between_windows ... vice.html

More commonly you'll recognize this situation in email programs when you try to email someone a long link:

http://ask-leo.com/whats_the_difference_between_windows_live_messenger_
windows_messenger_msn_messenger_and_windows_messenger_service.html

As you see above, email programs see the "http://" on the first line and automatically treat the rest of it as a link. But since the line is too long to fit on the screen, they break it into two, and then don't include the second half in that link. If you click on the highlighted link you get an error from the destination site, since you didn't provide the full page URL.

And yet, if you click on that partial link above for Ask Leo!, you'll get to the intended page anyway.

Ask Leo! tolerates broken URLs. Here's how I do it.

]]> The steps are simple:

I have a custom 404 error handling page written in PHP called "404resolver.php".
When a page is about to be reported as "not found", the web server displays this page instead, passing in the name of the original page that was requested.
404resolver.php examines the files in the directory of the web site, looking for ".html" files that begin with what was passed in as the original request:
- If it finds none, it reports a "page not found" like any 404 handler would.
- If it finds exactly one, it performs an immediate 301 redirect to that page.
- If it finds more than one, it displays a list and asks the visitor to make a choice.

Let's look at those three scenarios in practice before we look at the code.

Page Not Found: http://ask-leo.com/whats_the_difference_between_windows_live_messenger_and_mttips: this page does not exist, and will get you a "page not found" error. Try it.

One match: http://ask-leo.com/whats_the_difference_between_windows_live_messenger_: this page doesn't exist, but there's only one page that begins with exactly that URL. Since there's only one possible match, you're redirected to it as if you had gone there to start with.

Many matches: http://ask-leo.com/whats_the_difference_between_: this page doesn't exist, and there are several pages that start with that URL fragment. Since we know there are options, but we can't know which one was intended, we present a list and let the visitor choose.

•

The Code

I'm only going to present snippets here. The full code is available below for download.

The real brains of the operation are in this code sequence:

  $szRequestedPage = $_SERVER['REQUEST_URI'];
  $cRequestedLength = strlen($szRequestedPage);

  $dir = $_SERVER['DOCUMENT_ROOT'];
  if ($dh = opendir($dir))
    {
    while (($file = readdir($dh)) !== false) 
      { // build array of possible matches
      $file = strtolower($file);
      if (0 == strcmp (".html", substr($file, -5)))
        { // limit to .html files only
        if (0 == strncmp (strtolower ($szRequestedPage), "/" . $file, $cRequestedLength))
          { // possible match
          $rgMatchingPages[] = $file;
          }
        }
      }
    closedir($dh);
    }

This code takes the originally requested page or "REQUEST_URI", and compares it against every file in the root of the website's document root on the server. Every page that begins with exact same string as was originally requested is added to a list.

When that code is done, we have a list of pages which might be the desired page.

Next we act based on how many potential matches were found.

  if (0 >= count($rgMatchingPages))
    { // none found. Redirect to the "real" 404 page
    header ("HTTP/1.1: 301 OK");
    header ("Location: /notfound.html");
    exit(0);
    }
    
  if (1 == count($rgMatchingPages))
    { // only one match. Redirect to it, we're done.
    header ("HTTP/1.1: 301 OK");
    header ("Location: /" . $rgMatchingPages[0]);
    exit(0);
    }

As you can see if there's no match found, we redirect to the "real" page not found page. And if there's only one possible match found, we simply redirect to that page.

If more than one potential match we're going to display something, so we start outputting actual HTML:

...

The HTML being output is really whatever is necessary to display a page of your own design. Naturally mine outputs the "look and feel" of Ask Leo!.

However, within that page is an important sequence of code:

     
$page\n";
        }
?>

This code outputs a bulleted list, in sorted order, of the possible matches to the pages requested. Each is output as a link for the visitor to make his or her choice and click on.

That's really all there is to it.

A couple of caveats, of course...

Even though this is MTTips.com, there's actually nothing MT-specific about this solution. Any site that uses static HTML pages and can run PHP can use this solution. Naturally the concepts can certainly be extended to cover other technologies. (I've heard of at least one WordPress-based solution as well.)
In that same vein, this solution assumes all pages appear in the root of your site. Additional logic can certainly be added to handle other site organizations. The basic idea here is simple: use the page name that the user tried to get to as some kind of clue for what they were actually looking for. If you can, give them that without delay.

The full 404resolver.php as used on Ask Leo! can be downloaded here.

Leaving Breadcrumbs in Movable Type

2007-01-20T00:15:27Z

Breadcrumbs are staple (pardon the pun) of many web sites. You've seen them, they're the line typically near the top of an article page that shows you where in the tree of semi-organized information that article resides. Something like:

News Home : World : National : Local : Seattle : Space Needle on Fire

Each of those encompasses everything to its right, and each would be a link to a summary page for that level of topic. The last might be the actual page you're on.

If you've used Movable Type for any length of time, you might be thinking something about categories, sub categories and the like.

As was I, when a friend prodded me with "If you come up with an MT hack for that, please post it."

I hate a challenge that I can't resist if I'm already overbooked - particularly for something I want myself. :-)

]]> Ask Leo! now has breadcrumbs. I still have work to do, though, as I'll explain in a moment.

First, here's the template snippet that I've placed in my Individual Entry template:

  Home »

   <$MTCategoryLabel$>

That's it. That generates a breadcrumb line based on your category assignment, and the arrangement of the category and subcategory hierarchy that you've created.

Here's an example on Ask Leo!: How do I determine the capabilities of my wireless network adapter?

So, a couple of important "how too" points:

It's important that you organize your categories and subcategories well. You're looking to create a sensible, hierarchical tree of categories. In my example, "Wireless Networking" is a subcategory underneath "Networking". (And herein lies my work for Ask Leo! - I need to retrofit a meaningful hierarchy for my categories.)
In general you want to assign each post to a single category, and that would typically be a leaf from that hierarchy tree. You can assign a intermediate or node value instead, if you like, but I'm assuming that leaves will give your readers the clearest understanding of your organization. In my example the post is assigned a category of "Wireless Networking" - that's all.

That's it. The template code above prints the path down your hierarchy to that particular category leaf.

•

And now, a word about multiple categories.

MovableType allows you assign multiple categories to entries. In such a case, the code above will print a separate breadcrumb line for each category you've assigned to a post. Typically if you do this, you'll want the categories to be leaves on different branches of the hierarchy tree. For example, it'd look kinda silly to assign both "Networking" and "Wireless Networking" when the later us a branch off the former. The breadcrumb lines would look like this:

Home » Networking
Home » Networking » Wireless Networking

That not only looks kinda silly, but is also redundant.

On the other hand, if I had a separate branch in my category hierarchy that this article also applied to, it might make sense to assign it a second category within that branch. For example:

Home » Hardware » Network Adapters » Configuration
Home » Networking » Wireless Networking

Not only is it not redundant, but shows your visitor that the post might very well have two larger contexts of interest.

References:

I got a boost from the information here: David Raynes: Subcategories. That was written before MovableType actually supported any of this, but includes a plugin for pre-3.x MT that I believe enables most of what I've just described.

Use Meaningful Page Names

2006-12-14T19:22:37Z

It's a fairly common search engine technique to use "meaningful" page names in your URL. "apples.html" is seen by the search engines as more likely to be about apples than, say, "000023.html". Similarly, pages that are at the root of your site may be considered more "important" than those in subdirectories.

My approach at Ask Leo! is to use the article title as the basis for the URL and to place it in the root. Fortunately, MovableType makes both of the steps easy.

]]> First we'll change the location of all the individual archives to be in the root. That's part of the Publishing Settings page in your Weblog Configuration (formerly the Core Setup page in versions prior to 3.2):

Two changes typically need to be made to the default settings:

The Archive Root (the Local Archive Path pre-3.2) needs to be set to the same value as the Site Root (Local Site Path), and
The Archive URL should be set to the same value as the Site URL. Note that the URLs end with a slash while the paths do not.

Now that all the pages are in the same place, we need to change the filenames that MovableType uses to generate them. Further down the Publishing Settings page in your Weblog Config you'll find a section labeled Archive Mapping (or simply the Archive Files page in pre 3.2 versions of MT).

The "Archive File Path" (or "Archive File Template" in pre-3.2) is more correctly thought of as the "archive filename template". Using templating variables, here you can control the filenames that MT will create.

Here you can see that that Individual Entry Archive File Path for Ask Leo! is set to:

<$MTEntryTitle dirify="1"$>.html

This causes MT to use the Entry Title, "dirify" it (an MT function that removes or replaces illegal characters and the like), and append a ".html". So, for example, the pagename for my article entitled "How do I keep my computer safe on the internet?" becomes:

http://ask-leo.com/
how_do_i_keep_my_computer_safe_on_the_internet.html

Warning: there's a catch to this approach, though it's easily solved.

MT does not prevent two entries with the same title from overwriting one another. So if I have two entries with the title "Test" both would get written to "test.html". The most recent one written by MT would "win," and be accessible, the other would disappear from the site (though not MT's database).

In the case of Ask Leo! I've made the conscious decision to avoid duplicate titles. But that's not always possible, or efficient. The solution? Append or prepend the entry ID to the filename using this Individual Entry Archive File Path:

<$MTEntryTitle dirify="1"$>_<$MTEntryID pad="1"$>.html

This uses the title as before, but then appends an underscore, followed by the six-digit entry ID and ".html". Since entry IDs are unique, entries with identical titles will now have distinct filenames. If you have a look at the individual entries at ForwardedFunnies you'll see I've taken this approach there.

Changing Page Names Mid-Stream

2006-10-09T03:21:30Z

Ask Leo! was originally set up to name files using MovableType 2.x's default structure. Individual articles were archived with old style names of the form: http://ask-leo.com/archives/000001.html

That works, but current thinking is that search engines "like" seeing keywords in URLs. Since I wanted to do all I could to improve my search engine rankings, I decided to change my page names from being numbered and in a subdirectory to being the article title and in the root of the site.

Changing names midstream becomes a bit of a challenge. With several hundred articles on the site already, I wanted to switch to the new naming scheme while still allowing the old-style URLs, that people had perhaps bookmarked, to work.

I'm presenting these steps in the order that you need to do them to a live, running site. Review the entire set of steps before proceeding. If you follow these steps in this order, your site should never appear "down" and links will not be broken as you make this conversion.

]]> Step 1 - Create a Mapping Index Template

We'll start by creating some support infrastructure for the name change. The first is the tool that will allow the old names to be redirected to the new names.

The first step is creating a new template that actually writes a tiny program in PHP. This program maps the internal article number to the new "dirified" name.

In List Templates, create a new Index Template, called ArticleMap:

$rgEntries[<$MTEntryID$>] = "<$MTEntryPermalink$>";

?>

Yes, that is the entire template. If your MT site has more than 10,000 articles, then feel free to increase the "lastn" number.

Configure its output file to be "articlemap.php".

This is an index template... meaning that it has access to all of the entries, and is regenerated each time an article is added or modified.

Rebuild this template. You'll see that the created articlemap.php contains a series of entries like this:

$rgEntries[1] = "http://ask-leo.com/archives/000001.html";

With the PHP indicators "" at the bottom.

Step 2 - Create the Redirector

Create a new file "byid.php" in the root of your site, and place into it the following:

include "articlemap.php";
$szLoc = "http://ask-leo.com";
$id = $_GET['id'] + 0;
if ("" != $rgEntries[$id])
$szLoc = $rgEntries[$id];
header ("location: $szLoc");
?>

(You can also download this from http://mttips.com/files/byid.zip).

This tiny PHP program uses the article map we created in Step 1. It takes as a parameter an article number, looks up that article number in the mapping table, and redirects to the corresponding page.

Replace the "ask-leo.com" in the script with the location you want visitors to be redirected to should the look-up fail. As you can see I typically use the home page, but you could redirect to an error page, or your website's 404 page.

Try it now. Try this link: http://ask-leo.com/byid.php?id=1, but:

Use your own site instead of ask-leo.com.
Use an ID number that shows up in articlemap.php.

You should be redirected to the permalink for the article number you specified. (If you use the link as presented above, you'll go to the article that was originally Ask Leo! article #1.)

Step 3 - Rewrite the URLs

Now that we have a script that will take an ID and redirect it to the "right" page, we need to transform the incoming requests for what will become the old style URLs using URL Rewriting.

Our goal is that an incoming request that looks like this:

http://ask-leo.com/archives/000001.html

should be processed as:

http://ask-leo.com/byid.php?id=000001

That's accomplished with the following URL Rewrite:

RewriteRule /([0-9]+)\.html$ /byid.php?id=$1 [PT]

In English, that rule says that any incoming page request whose filename is a series of numbers followed by ".html" be changed to a request for "byid.php" with the "id" parameter set to equal the string of numbers. The string of numbers, of course, is the MovableType ID for the article being requested.

So now, let's make sure that works. Did you notice that we didn't include the word "archive" in the rewrite test? That's on purpose, because it means that this should now also work:

http://ask-leo.com/000001.html

Remember to use your own site, and your own article ID for that test. Even though there is no 000001.html in the root of your site, the rewrite to use byid.php will trigger, and redirect you to the correct filename.

Step 4 - Turn on 'dirified' Filenames

OK, now it's time to change the filenames that MovableType saves your articles as.

In your weblog config, under the Publishing tab, in the Archive Mapping section (formerly the Archiving tab), set the Individual Entry Archive, Archive File Path to:

<$MTEntryTitle dirify="1"$>.html

MovableType uses this field as a kind of "mini template" for the filename to be used for each entry. Be careful not to introduce any additional characters, such as trailing spaces, because that will confuse both MovableType and you.

Setting this field instructs MovableType to use the "dirified" entry title (taking out or altering characters that would cause problems in filenames) plus ".html" as the filename to use for each article.

If it's possible, you may have more than one article with the same title, then you can make sure that each article's filename is unique by including the ID in the filename as well:

<$MTEntryTitle dirify="1"$>_<$MTEntryID$>.html

Since no two entries will have the same ID number, even if they have the same title, this approach will guarantee that they have unique filenames.

NOW... the first scary test.

Rebuild your site. All of it.

Here is what will happen:

MovableType will create new pages for all of your articles with the new names as specified above.
Articlemap.php will be regenerated to use those filenames as the permalinks to redirect to. This means that ...
byid.php will now start redirecting to the new names. This means that ...
Old requests using the old format:

http://ask-leo.com/archives/000001.html

will be redirected to their new names:

http://ask-leo.com/archives/article_title.html

All other references throughout your MovableType weblog will also simply use the new article file names.

Note that we're still using "archives" in the resulting URL. The last step gets rid of that too.

Step 5 - Move your archives to the root

The default in MovableType 2.x was to place articles in a subdirectory off of the root named "archives". I wanted my articles to be placed in the root of my site instead (the theory being that files in the root might be perceived as "more important" to the search engines).

In your weblog settings, under the Publishing tab (formerly the Core Setup tab), remove "/archives" from the Archive Root (formerly the Local Archive Path), and the Archive URL.

For example:

/home/httpd/vhosts/ask-leo.com/html/archives

Becomes

/home/httpd/vhosts/ask-leo.com/html

And:

http://ask-leo.com/archives/

becomes simply

http://ask-leo.com/

Together, those two settings instruct MovableType to place the files in the desired location - the root of the site - and generate any references to them in that location as well.

Time for the scary test again.

Rebuild your site. All of it.

Here's what will happen this time:

MovableType will create new pages for all of your articles with the new names as specified in the previous step, this time placing them in the root of your site.
Articlemap.php will be regenerated to use those filenames in the root as the permalinks to redirect to. This means that ...
byid.php will now start redirecting to the new names. This means that ...
Old requests using the old format:

http://ask-leo.com/archives/000001.html

will be redirected to their new names:

http://ask-leo.com/article_title.html

Exactly what we wanted.

All other references throughout your MT weblog that MT generates will also simply use the new article file names in their new location.

One you have this in place, you're done. You could stop at this point, if you wished. You've successfully renamed and moved your articles, and no visitors noticed while you were doing it.

But there is still a little clean up, and one more step that I have found pretty handy:

Step 6 - Rewrite the simplest URLs

This step is entirely optional, and falls into the category of "while you're in there anyway ..."

One side effect of using article titles in their URLs is that the URLs can get kind of long. That's ok when the URL is being generated automatically and referenced in web pages such as the rest of your MT website. But if you want to perhaps send someone a pointer to a specific article, it can be rather cumbersome.

We've seen already that the existing URL Rewrite allows us to still reference an article as

http://ask-leo.com/0000001.html

Well, it turns out that this also works:

http://ask-leo.com/1.html

Try it on your own site. Now, wouldn't it be handy to get rid of the ".html"? Wouldn't it be nice if you could simply point people at:

http://ask-leo.com/1

Because of everything we've done so far, we have all the pieces in place. Just add one more URL Rewrite rule to make it happen:

RewriteRule /([0-9]+)$ /byid.php?id=$1 [PT]

This redirects all URLs ending in "/" followed by a number to byid.php with that number as the id parameter.

Step 7 - Clean up your archives

Even though we've moved our entries out of the archives directory, we've not actually deleted any of the files therein. That's been kind of a safety precaution so far. If, for example, the rewrite rules failed to operate, those files would still be there for your visitors to access.

But now that you've moved everything and verified that it's all working properly, you can remove the archives and free up the space associated with them.

I recommend a two-stage approach:

Rename the archives directory to something else like "delete-soon", for example. Now, watch your site's error log for a while to make sure doing that hasn't caused archive pages to not be found. It shouldn't add any errors because if things are working properly, the references to all your archives should be caught by URL Rewriting and redirected to their new, correct, location. If renaming does cause pages to suddenly not be found, rename it back to "archives" and review all the preceding steps, because something's not working.
After you're convinced that renaming the archive directory hasn't introduced any errors, delete it, and all its contents.

Now you're done.

Get creative with Templates

2006-07-23T22:47:25Z

There's nothing that says MovableType templates can't be added to create other types of files.

The challenge I had was this: I want to be able to have a list of all my category archive pages on some of the other pages that are not built by MovableType.

The solution? Create an index template that contains that list - and only that list - and have it produce an include file that I can use anywhere I like.

]]> Here is the template, in its entirety:

The Full Archive

• <$MTCategoryLabel$>

We'll create that as a new index template, called "catlist.inc":

Now, when we cause a rebuild of the indexes, catlist.inc is updated. Here's what the beginning of that file looks like as I write this:

The Full Archive

• Administration

• EMail

• General Computing

...

That's a fine file that can be included elsewhere. For example, on my actual "Ask a Question" page, http://ask-leo.com/askleo.html, which is a manually created page, below the entry form for a question you'll see a list of the categories available for browsing:

That's the result of the following include:

If that looks very similar to the category list that's presented on the Ask Leo! homepage, it should ... the home page uses the exact same include to present the category list.

Get creative with HTML

2006-06-24T22:46:31Z

Remember that the goal of the templates is simply to transform your content into your desired results - normally HTML pages for display.

When dealing with templates, it's easy to think that you have to do everything using MT's constructs and easier still to get stuck into the rut of using only the examples or variations of the default templates.

]]> Take the category list, for example. The most common category list is generated as follows:

<$MTArchiveTitle$>

Which generates a list of all your categories, that are clickable to get to their corresponding archives. On Ask Leo! the result would begin like this:

Administration
EMail
General Computing
Hardware
Instant Messaging

and so on...

Since I have a lot of categories, it can take up a fair amount of the page's real-estate. For a time I decided to use a drop-down list. Quite easily done with the following template fragment:

Here's the old "Administration" category archive page:

Note the dropdown list on the right. Here it is again, with the list opened:

If you go back and look at the template fragment, you can see that the items "Select..." and "The Full Archive" are manual, hard coded entries in the list, but the rest of the dropdown is created when MT processes the template and builds the HTML output.

This is just an example. The true "tip" here is to use your knowledge and familiarity with HTML to look outside of the default templates.

Repurpose the Excerpt

2006-06-13T17:45:00Z

I found myself wanting to add a "Summary" for each article on Ask Leo! The summary is written by hand for each article - partly for the search engines, and partly to help people decide whether the article is, in fact, what they're looking for.

One complicating factor is that with over 860 articles, I wasn't about to add summaries for most. So I wanted summaries to be visible only if a summary had, indeed been written.

As we all know, there is no "Summary" field in MovableType, instead there's something called an "Excerpt". Excerpt serves my purposes well, but only after a minor configuration change.

]]> In my Individual Entry Archive template, I now include the following:

Summary: <$MTEntryExcerpt$>

That seems fairly straightforward, right? There's only one problem. The Excerpt is, by default, automatically generated from the first 'n' words of your content if not explicitly supplied. As a result, the tag was always non-empty, and every article had a "Summary", whether or not I had written one.

The solution turned out to be fairly simple.

In the Settings for the weblog, I set Excerpt Length to zero.

Now, the default Excerpt is, indeed, empty. If I purposely fill in the Excerpt, then it exists, and the condition in my template triggers, and the Excerpt ... no, Summary ... appears.

I know that there are other plug-ins for MT that allow you to add additional fields to each entry, but I thought this was a rather convenient use of built-in functionality to effectively re-purpose the Excerpt field.

But, of course, you can only do that once. As soon as I need something in addition to my Summary, I'll be looking at other options.

Dealing with a Wealth of Comments

2006-04-28T22:44:15Z

One of the interesting things about writing a technical Q&A site that deals primarily with Microsoft Windows is that people have no shortage of questions - and opinions. Lots of questions and lots of opinions. When some article pages became slow to load due to there being literally hundreds of comments I needed a solution. What I found was a MovableType extension: MTPaginate.

Have a look at the article What are "LSASS", "LSASS.EXE" and "Sasser" and how do I know if I'm infected? What do I do if I am? - it's one of my most viewed articles. One of the most commented on also. As I type this there are almost 400 comments on the article. Displaying all 400 at once (the way that MovableType's default templates work) would make for a very unwieldy page.

Now my approach is this:

]]> First, the individual entry template only shows the 10 most recent comments:

If you visit the LSASS article referenced above, you'll see the results.

Second, I've created an additional entry template for paged comments:

That template is much like the individual entry archive, except:

It does not contain the article
It only lists comments
It uses MTPaginate to break the comments into pages of 10 each
It does not include a comment form, but rather a link back to the original article page where comments can be entered.

MTPaginate also requires that the pages be processed by PHP, a server-side programming language, so as a result the output of the Page Comments template is a .php file.

Here's the "meat" of the paged comments template:

      
       Comments
       
        All Comments on: <$MTEntryTitle$>
       
       
        
         (Read the article
         that everyone's commenting on.
        
       
       
        Comment Page: <$MTPaginateNavigator$>
       
       
        
         There are no comments on this article yet.
        
       
       
        
         
           <$MTCommentBody$>
           
            Posted by: 
            at <$MTCommentDate$>
           
         
        
        
       
       
        Comment Page: <$MTPaginateNavigator$>
       
       
        (Read the article that everyone's commenting on.)
       
       
         Post a Comment
         
         To post a comment on "<$MTEntryTitle$>", please return
         to that article's main page.

MTPaginate still generates a single output file, but by using PHP, that file takes parameters that then control which comments are actually displayed.

If you click on the "See all 390 comments..." link (or whatever the number is today), you'll be taken to the results. At the top and bottom of that page will be a traditional navigation list of page numbers:

10 comments are displayed on each page. If you look at the URL behind each of the links, you'll see that they refer to the same page, only with an additional parameter:

http://ask-leo.com/comments_000194.php?page=2

Where the "page=" parameter defines which group of comments to display.

MTPaginate is a valuable solution for articles that generate lots of comments. I encourage you to check it out.

MovableType Styles

2006-04-24T05:26:17Z

The default set of templates that come with MovableType make extensive use of the stylesheet "styles-site.css". It's possible, by manipulating only the stylesheet, to achieve dramatically different looks for a site based on the default templates.

MT's default CSS is far from trivial, nor is it documented anywhere that I can find. It requires an investment of time to understand. My original "Tip" was to invest that time understanding the default CSS.

]]> With the 3.2 release of MT, the default styles increased in complexity by an order of magnitude. If you're alreay CSS conversant, and have the time, understanding exactly how these styles work may be worth your time. However I can no longer recommend it for the average user.

So, I now have two tips:

Keep using the default styles, but make only minimal changes. One approach might be StyleCatcher, an MT plugin that allows you to select a style from a collection of styles in real time. As long as you use the default templates and styles, you can change the look and feel of your blog completely - with a mouse click or two. My site Taming Email uses a StyleCatcher style.

Start from scratch. This'll require a little more understanding not of the styles, but of the MT templating syntax. The basics are relatively simple, but the total templating language is very powerful and flexible. The style sheet and templates for this site, for example, are extremely simple, very clean, and much less confusing than the default MT templates.

Reader Comments

2006-04-24T05:17:35Z

Rather than sprinkle comments throughout MovableType Tips, I'm setting aside this item specifically for your questions and feedback.

]]> •

Get between your Entry Body and Extended Entry

2006-04-23T04:32:53Z

When you create a new entry in MT, you're presented with the default entry form that contains areas for both an Entry Body and an Extended Entry. Most folks use them for either of two purposes:

The entry body is the "tease" portion of the entry that goes on to the home page, while the extended entry is the rest of the entry that shows up only on the entry's individual archive page.
The entry body is what shows up in the RSS feed. The extended entry is the rest of the entry that shows up only on the entry's individual archive page.

]]> As you can probably guess, those are really two instances of the same principal. And it's a principal I use on Ask Leo! quite successfully, for both RSS and the Ask Leo! home page.

The nice thing about having the article broken into two pieces like that is that you can insert something between the two pieces in your template. For example, the Ask Leo! individual entry archive contains this fragment:

<$MTEntryBody$>


  

•
<$MTEntryMore$>

In-between the <$MTEntryBody$> and the <$MTEntryMore$> tags, I've placed a

in which there's an include statement. As you might guess from the name, that include file contains my Google Adsense code which causes the ads to be displayed in the body of the entry, rather than before or after it. In fact the CSS style for ID "entrygoogle" allows me to further control positioning relative to this insertion point:

#entrygoogle
{
  background-color: #FFFFFF;
  float:right;
  padding-left:15px;
}

The "float" option allows the text of the article to wrap around the ad block.

Next and Previous - Within a Category

2006-02-18T23:35:48Z

MT automatically gives you the next and previous items for your individual archives with and items. The problem is that's within the global list of all entries within your blog. What if you wanted to link to the next or previous item within a given category?

As an example, check out any of the entries on Forwarded Funnies. There, in the upper right, you'll see not only a previous and next for "All Entries", but a separate previous and next for entries of the same rating as the current. In other words a previous and next for all the "G-Rated" entries if the current item is itself G-rated.

Needless to say, ratings within Forwarded Funnies are simply separate MT categories.

My approach uses a combination of PHP code generated from a category archive template, and a server-side include, or "SSI", in the individual entry archive template.

]]> The category archive template I added is this:


     $rgArchive[<$MTEntryID$>] = "<$MTEntryPermalink$>";
     $rgTitle[<$MTEntryID$>] = <<
<$MTEntryTitle$>
H<$MTEntryID$>;
    

    if (array_key_exists ($szID, $rgArchive))
      {
      while (key ($rgArchive) != $szID)
        {
        $szPrev = key ($rgArchive);
        next ($rgArchive);
        }
      $szNext = next ($rgArchive);
      $szNext = key ($rgArchive);
      
      if (("next" == $szOp) && ("" != $szNext))
        echo "$szText " . $rgTitle[$szNext] . "";
      elseif (("prev" == $szOp) && ("" != $szPrev))
        echo "$szText " . $rgTitle[$szPrev] . "";
      }
?>

The MT Entries section generates PHP code such as this:

  $rgArchive[500] = "http://www.forwardedfunnies.com/do_not_be_late_000500.html";
  $rgTitle[500] = <<

In other words, it defines two arrays that map the item's ID to its Title and Permalink. When used, this PHP code takes an entry ID as a parameter, and then outputs a link to either the next or previous item in the list.

We'll see exactly how that's used in just a second. First, I have to make sure that the files generated when this template is built are named appropriately.

In the weblog's Settings, in the Publishing tab, down in Archive Mapping, I created a new Archive Mapping for our new template. It is, as we said, a Category archive, using the new template we added above.

Most importantly, I defined the Archive File Path to be: "catnav_%c.php"

This will then cause a category navigator, as I call it, to be built for each category defined in the system. For example:

catnav_grated.php
catnav_pgrated.php
...

Now, to hook it up with the individual entries.

In the individual entry template, I place this code:


  

  <$MTCategoryLabel$> Entries:

There are several interesting parts to this fragment, so I'll go over them one by one.

First, note the use of "". While within Forwarded Funnies, each item is assigned only one category, that's not a required limitation. So the code that we'll generate here will be repeated once for each category that this entry is assigned.

I start with a link to "<$MTCategoryArchiveLink$>" - that's a link to the standard category archive page that simply lists all entries that have been assigned the category. Nothing really new here.

I invoke the appropiate "catnav_??.php" within an SSI. This requires a little more detailed explanation:

"catnav_<$MTCategoryLabel dirify="1" $>.php" gives me the name of the category navigator for the current category, dirified so that improper characters are removed. A G-Rated item will result in "catnav_grated.php" being the file processed by the SSI command.
The ".php" file is passed parameters as part of its execution by the SSI.
"id=<$MTEntryID$>" passes the ID of the current entry to the .php script.
"op=next" or "op=prev" tells the script whether to get the next or the previous entry relative to the current entry.
"text=Next:" or "text=Previous:" is additional text that the script should include, but only if it does, in fact, output an entry. There is no next for the last item, and no previous for the first, in which case this text is not output.

Note that I include the SSI twice - once with parameters indicating that the next item be fetched, and once again for the previous.

When all is said and done, each entry has a next and previous link within their category, something like this:

G-Rated Entries:
Next: Horse For Sale
Previous: Colorado Barbie

Or, in HTML:

G-Rated Entries:

Next: Horse For Sale

Previous: Colorado Barbie

Dealing with Comment Spam

2006-02-15T01:33:00Z

Comment spam is the bane of the modern weblog. In an effort to boost their own ranking in the search engines, nefarious webmasters create software tools or "bots" that go out, find weblogs, and post scores of comments which contain links back to their sites. Those links are then seen by the search engines, which use the general rule that "the more people link to you, the more important you must be". The goal of comment spam is that the spammers' websites about poker, Viagra and body part enlargement get better search engine ranking as a result.

As weblog owners, not only do we not want to help the spammers, but we also just don't want their off-topic posts included in our weblogs.

]]> I've tried several techniques to combat comment spam. The most effective I found prior to switching to MT 3.1 was something called a "captcha" test (completely automated public Turing test to tell computers and humans apart) - you've seen them, they're the tests where before you can do something you need to type in the letters presented in a distorted image. Computers can't read the image (yet), but humans can. I used the captcha plugin developed by James Seng with great success.

MT 3.1 did some major rework on comment entry and user validation in order to enable TypeKey. Now, TypeKey is fine, but to me it seems yet another place people would have to log in, and yet another barrier to legitimate comments. Unfortunately that rework seems to have broken the Captcha test, and I was unable to get it to work.

So, after all that backstory, here's my current approach on Ask Leo!:

I have only one comment entry form for each article: on its main page.
I've replaced all other comment entry forms with a pointer to that comment entry form on the main page of each entry. Thus there is only one place to enter a comment on any particular entry.
I've modified the
tag for the comment form in the entry template to begin with this:
Note that the action of the form has been changed to a static html page.
I created a static page, "commentspam.html" with the following text:
If you're seeing this page, either you have javascript turned off in your browser (it's required in order to post a comment), or it looks like you're using one of the techniques comment-spammers use.
I added these two lines after the existing
I renamed MT's comment submission script to "something.pl", and updated the "CommentScript" setting in my mt.cfg.
And lastly, I created "comment.js", placed it in the root of my website. It contains only this:

document.comments_form.action = "http://pugetsoundsoftware.com/cgi-bin/something.pl"

The goal of all that is to rename the comment submission script, and make it difficult for the spam-bots to determine what it is. Most spam-bots either assume the name of the comment script and just post directly to it, or they scan a weblog entry for the and read the name of the script from the "action=" attribute.

In my case, the default comment script name doesn't exist. The "action=" attribute points to a completely different page ... one that, if invoked, is nothing more than a static html page. (Have a look: http://ask-leo.com/commentspam.html).

The magic behind this trick is the javascript in comment.js. When the