This Android App provides a fully functional blog interface for Michelle Malkin’s blog. It supports several ways of listing posts, a way to Star posts you like, post viewing, comment viewing, comment posting as well as new post notifications. A number of configuration options allow you to tweak text and image sizes as well as set the notification check frequency or completely disable them.

The primary benefit from the app is a much cleaner and very intuitive user interface (have you tried to read blogs for any length of time on any mobile browser?) that is themed for the site. It is also much more efficient since the app is not requesting fully rendered pages but instead requesting data via xmlrpc – so the response on the app is much faster than rendering and pulling an entire page. It also has to potential to reduce server load (theoretically – if enough people switch to using the app instead of the browser).

To give it a try, search for ‘Michelle Malkin’ in the android Marketplace. Alternatively, you can just scan the barcode shown above with your phone.

By the way, if you are running WordPress and are interested in an app like this for your site, feel free to contact me for a quote and timeframe.

Forcing businesses to comply with artificial benchmarks or mandated business plans eliminates the need (or ability) to make sound business decisions based on supply, demand and future planing. The end result is either government entitlements to keep businesses afloat or future bankruptcies. Sometimes it makes sense for a company to invest in a net loss market because it fits their long term plans, but lets allow them to make that decision. Unfilled market niches often become opportunities for smaller players or startups, but this kind of mandate permanently eliminate those opportunities. (They also discourage startups in an entire market segment since only the largest players are actually capable of meeting these kinds of mandates.)

I’m not impressed at all with the level of foresight those who legislate have – they seem completely unable to comprehend what effect (and side-effects) a piece of legislation will make on those affected.

The government that governs least, governs best.
Thomas Paine

I cannot agree enough.

(Hat-tip to John Henke)

The good news is I’m very close to releasing my first Android app which provides a direct interface to a high profile blog.  I’m hoping this is the first of many, now that I’ve got a mechanism to quickly get data from Wordpress.  Just a bit more spit and polish and we can load it up on the Marketplace.

I still have not found a decent way to order classes in a stylesheet that makes any sense (and is maintainable) but search functions make that passable. However, I still cannot help but feel like the stylesheet is messy since I really have no idea which classes I’ve obsoleted vs. which classes are still used by some obscure template I never touched.  I’ve always been meaning to find a better solution to this then my usual method: <i>leave them all there – just in case</i>.  A clean and tidy stylesheet reduces server load and is easier to maintain.

So instead of doing the work I was supposed to be doing today, I goofed off and coded a little stylesheet analysis program.  The idea is pretty simple:

• Read the stylesheet and parse out the style definitions
• Read sample pages from the site and track which styles are referenced
• Report back which pages use what styles, and which styles are not used at all

My original concept involved reading the sitemap.xml and checking all pages, but that would be a waste of resources for sites with any amount of history.  (Although it might be useful for a site where stylesheet styles were used in individual posts!)  Instead, I settled on a q&d (quick and dirty) php script driving a html form that lets you supply the stylesheet url and up to 9 urls from the site to analyze.  The idea is to add the index, date archive, category archive, about page and maybe a few individual posts so you get a sampling of every template in your theme.

The coding (and debug) took about 90 minutes and I’m pretty pleased with the result.  This little tool (named StyleCheck) makes it very easy to eliminate the chaff from your stylesheet.  Give it a try if you like: StyleCheck or download the source to see how it works and maybe improve it: StyleCheck Source Code. (And don’t laugh at the form or the code – again, this is a q&d project.)

Now to go and clean up some stylesheets.

Update: Here are a few more operational details and or caveats:

• When the stylesheet is scanned, all non-id and non-class items are ignored.  Also, derivative classes (i.e. ‘.myclass a’ or ‘.myclass ul li’) are reduced down to the base class name.
• When the html is analyzed, anywhere a class is used is consider a single use of that class.  The actual content is never checked, so if ‘.myclass a’ is defined as in the stylesheet, the analysis doesn’t look for anchor links in any element classed with .myclass.  It just knows that .myclass is defined in the stylesheet and looks for any use of it in the html.

Improving both of these items is very possible, but I just wanted a general tool that helps me identify unused class families plus I was spending time I did not have.

I’m currently working on a project that needs to get data from a WordPress installation. Fortunately, WordPress provides an XML-RPC interface which includes several stock APIs as well as a WordPress specific API. This is far more efficient than using custom templates or parsing actual html pages for both sides of the transaction.

With all that said, how do you use it? Depending on what you are trying to do and the platform you are using, there should (hopefully) be a nice library already coded so you can worry about requesting and receiving data without fretting about the details of xml-rpc. However, sometimes a q&d (quick and dirty) script is useful to test a request and look at what is actually coming back. I do that using a simple php script:

<?php
  $request = xmlrpc_encode_request("blogger.getUserInfo",
    array(1, "username", "password"));

  $context = stream_context_create(array('http' => array(
    'method' => "POST",
    'header' => "Content-Type: text/xml",
    'content' => $request
  )));

  $file = file_get_contents("http://wordpressblog.com/xmlrpc.php",
    false, $context);

  $response = xmlrpc_decode($file);

  if ($response && xmlrpc_is_fault($response)) {
    trigger_error("xmlrpc: $response[faultString] ($response[faultCode])");
  } else {
    print_r($response);
  }
?>

The key to this script is the first line where $request is defined. The first parameter is the name of the request, followed by an array of parameters for that specific request. From the API:

blogger.getUserInfo takes the following parameters. All are required:

• appkey: (Ignored in WordPress)
• username: User login
• password: User Password

If you do it right, you get a result something like:

Array
(
    [nickname] => Major Burns
    [userid] => 27
    [url] => http://mash.4077.gov
    [lastname] => Burns
    [firstname] => Frank
)

If your user & password is not correct, then you will get something like:

Notice: xmlrpc: Bad login/pass combination. (403) in /var/www/virtual/test.myserver.com/htdocs/xmlrpc_test.php on line 15

And if you are using an invalid request, you will get:

Notice: xmlrpc: server error. requested method pretend.badRequest does not exist. (-32601) in /var/www/virtual/test.myserver.com/htdocs/xmlrpc_test.php on line 15 on line 15

This should get you started using the standard requests, although keep in mind that they do come with some limitations. First, the exact request you want may not be defined (yet). Also, most of the requests require a WordPress user, with many of them requiring a user with author credentials.

One trick I find useful is, if I do not understand the parameters for a request or what a request actually does (the API documentation is definitely lacking in some ways), that information is available by just pulling up the WordPress xmlrpc.php in an editor.

The next step, and probably my next post, is how to add your own custom requests to WordPress.

So much to learn, so little time. (At least for us independent developers.)

Wikipedia topics are usually dominated by the fanatic with the most time to spare, which is why I don’t rely on Wikipedia when the matter is both controversial and important.

Jerry Pournelle

Since getting an Android phone, I’ve been installing (and uninstalling) lots of different apps. The creativity and variety is fantastic and the way the phone works with Google maps is incredible. But I still haven’t found the app I’m looking for.

I’m a backpacker and although GPS is a wonderful thing, you really need to couple it with a set of good Topo maps to make it useful when you are on the trail. Oh, and no cell service – the maps have to be locally stored on the device. Getting maps is not difficult – the USGS offers free downloads of the entire US (download here). These are extremely high quality maps which also makes them very large files – some approach 15MB for a single 7.5 minute square.

The app I want uses the phone’s GPS to show me where I am on a USGS Topo map. It should be able to zoom in and out (within reason) and it should not kill the phones memory, which means smaller map segments tiled in the same way the Google maps does.

Right now I’m just sketching out ideas on how to pull it off. Oh and I guess I should finish learning how to program in Android too.

The solution I came up with was to use php on the new destination (a dedicated server) and parse the export file itself, denoting when I’m in a body section, and using a regular expression to try and find any image tags that point to the domain being relocated. For each TypePad hosted image that was found, the same directory structure was created locally, and then the file was copied from the TypePad server to the local matching directory structure.

It took quite a while to run, since the client had been on TypePad since 2004, but the result was wonderful – all I have to do is relocate the created directory to the webspace and not only have all the images been released from they TypePad prison, but all the existing links will still work correctly. The one caveat is that the base image directory started with a period, which is not a problem as long as you understand that Unix variants hide all files and folders that start with a period. Use ls -la to see what is normally hidden.

Code is below the fold…

<?php

// Initialize Variables
$count = 0;
$title = "";
$status = "";
$body = 0;
$body_text = "";
$export = "mt-export.txt";
$domain = "http://somedomain.com"; // Be sure to set this to an appropriate value

// Open import file
$fh = fopen($export, "r") or die("Cannot Open export file '$export'");

// Process import file post by post
while($buf = fgets($fh)) {

  // If we are in a post body, look for images
  if($body == 1) {

    // Do all the processing once we have the entire post body in $body_text
    if(substr($buf,0,5) == "-----") {
      preg_match_all("/<img.*?src=(\"|')".preg_quote($domain)."(.*?)(\"|')/",
                            $body_text, $matches);
      $images = $matches[2];

      // Process all images found by the regular expression
      foreach($images as $image) {
        $data = pathinfo($image);
        $path = $data['dirname'];
        $file = $data['basename'];

        // Create the directory structure
        // (if the path is deep, this may need some tweaking)
        if(!is_dir($path)) {
          mkdir($path);
        }

        // Copy image to local server
        $remote = $domain . $image;
        if(!copy($remote, $image)) {
          print " - Copy failed for $image\n";
        }
      }

      // Reset body variables
      $body = 0;
      $body_text = "";

    // Add more body content to $body_text
    } else {
      $body_text .= $buf;
    }

  // Post status and look for the start of the next post body section
  } else {
    if(substr($buf,0,6) == "TITLE:") {
      preg_match("/^TITLE: (.*)/", $buf, $matches);
      $title = $matches[1];
      $count++;
    } else if(substr($buf,0,7) == "STATUS:") {
      preg_match("/^STATUS: (.*)/", $buf, $matches);
      $status = $matches[1];
      if($status == "Publish") {
        print "Processing: $title ($count)\n";
      }
    } else if(substr($buf,0,5) == "BODY:") {
      $body = 1;
    }
  }
}

// Clean Up
fclose($fh);
?>

As always, this code is provided free of charge and comes without warranty or guarantee. If you do not understand what this code is doing, you had probably best not be running it.

The load has not lightened at all, but I miss journaling and thought this would be a nice place to at least track how I solved a problem in the past, hoping that will help in the future.  It should also be a nice medium for sharing technical answers that might help others, just as I glean so much know-how from the blogs and forums of others.

Ed