One was so bizarre and I never did figure out the root bug. It occurred when I did a search for the most recent post with a certain tag. The bug would occur when no post met that criteria. I was incorrectly using the query_posts function instead of the get_posts function and I would fail to check for an empty array but things would still work. But for some reason the page would load twice. Two calls to the WordPress ‘init’ action and double everything else. The referrer would change for the second page load (to the page being loaded) but but it didn’t show obviously in the browser although there were some bizarre symptoms there as well.

The debug messages I was getting were bizarre and would change depending on whether I used curl, Safari, or Firefox. It took me a while to find out it was caused by the array bounds issue, but fixing that fixed the symptoms.

Still I’ve never seen this bizarre double page load issue. I assume it’s a WordPress thing but who knows. Once the bug was fixed I didn’t care much about further root cause analysis especially since with expected data the bug wouldn’t even show up using the original code.

Add in some issues with my local development server slowing to a crawl for some unknown reason and it was quite a day.

After a long time of installing WordPress manually on my test machines, I have finally switched to using subversion. It is so much easier.

It wouldn’t be, except that for some reason WordPress will not update properly if your site is not on the open internet. I don’t know what their deal is with that, but this gets around it easily. If you use subversion for other things and are familiar with it, but don’t yet use it for your local WordPress installations, I highly recommend making the switch.

For instance, if all your pages have a format involving a header element, a body element, and a footer element, then you have to duplicate that HTML in single.php, page.php, 404.php, etc. Then if you ever change it you have to edit every one of those files just to make the same changes over and over again. You’re probably going to forget to do it in some files and you’re going to do it wrong in others.

Wouldn’t it be great if you could just call a function that would establish this pattern for you in all files? Then if you needed to change it, you would only have to change it in one place and all your site’s pages would be effected. But what if you need to tweak the template slightly for different pages? This is exactly why object oriented design is important.

So you have a base class that draws the usual page structure and then provide override-able and abstract methods so that a new class can be created if you need to customize. It works perfectly because it gives you maximum code reuse and there’s no duplication.

However, it does make the theme very code heavy. There’s not a ton of code, but enough that would intimidate most people. Plus, if you don’t have a lot of experience with object oriented design getting the extensibility right is going to be a bit difficult.

But that’s kind of my point for this post. It’s not necessarily that you need to do this, because obviously themes can be made without it. But it’s the fact that object oriented design is important to web applications and even blogs too. If you do a lot of PHP coding but aren’t yet familiar with the concepts behind object oriented programming, then learning more about that will really be a benefit to you.

add_filter('the_content', 'MyPluginClass::FilterTheContent');

This is pretty handy, but sometimes when you’re writing a WordPress theme you want to allow plugins to add content, not just filter the usual content. Using apply_filters makes this pretty easy because you can call apply filters with custom “tags” and it will just work. For instance in your theme you can put:

<?php

    $theMessage = apply_filters('CustomThemeMessage', '' /* default value: empty string */);

    if (!empty($theMessage))
    {
        echo '<div class="Message">', $theMessage, '</div>';
    }

?>

If nobody ever filters on the tag ‘CustomThemeMessage’ it’s fine, your theme won’t break or anything. But plugins that know this tag is available can use it:

add_filter('CustomThemeMessage', 'MyPluginClass::FilterTheContent');

When you’re developing themes and plugins in tandem, this is incredibly useful and robust. It’s also not as risky as filtering a tag like ‘the_content’ where a mistake can really mess up your site. It will also be more performant when you only need the custom content on one or a few of the pages on your site.

$string = format_gmt_time_for_time_zone(
    'l, F jS g:ia', 
    $myGMTTimestamp,
    'America/Los Angeles');

or even better, using and object oriented approach:

$string = $date->Format(
    'l, F jS g:ia', 
    'America/Los Angeles');

It’s important because it’s kind of a “best practice” to store dates in the database in GMT (or really UTC) format and then translate them as necessary. Then I want someone in New York to see times in their time zone and also someone in Seattle. It would also help if WordPress had a per user time zone.

I know that PHP 6 is doing some enhanced date stuff, so hopefully that will include this simple functionality. But right now, both WordPress and PHP don’t seem to imaging a case where someone wants to print out a time for a timezone they’re not in.

What I ended up doing was this:

$oldTimeZone = date_default_timezone_get();

date_default_timezone_set($requestedTimeZone));
        
$convertedString = date($formatString, $gmtTimestamp);
        
date_default_timezone_set($oldTimeZone);
        
return $convertedString;

It works, but it’s fairly clunky. From my experience at Microsoft I know sometimes when there’s a whole category of things that needs improving, it can be hard to find someone to take that on. What has to happen is a person needs to say, “I’m going to take on times and dates and make the API better.” But either people aren’t interesting or people are too afraid to suggest such a drastic move. Furthermore, the people who wrote the original code will often be offended that someone would suggest it could be better. They will point to something like my code above an say that’s good enough. It isn’t.

I’m actually considering getting involved with WordPress on this, however, I am honestly scared that they will not be into it. I’d also like to add the per user time zone, but I sense something like that would be controversial.

Tonight was the first time that I needed to write some code for a business that would send email to customers, or at least email that needed to be reliable and feature rich. I looked at the documentation for the PHP mail function and after a lot of reading realized it was not going to work. If I wanted to use HTML, that involved a lot of uncertainty, if I wanted to use UTF-8, that involved a lot of uncertainty. There were a lot of unknowns but one thing that was quickly becoming a known was that I was not going to fix this problem.

I knew I could send simple text emails with a URL to details if I had to, but before I did that, I wondered if someone else had solved my problem since what I wanted was reasonable and obvious. To my great surprise a few people had. It came down to two tools, Swift Mailer and PHP Mailer.

After doing some Google searches and research, it became clear that Swift Mailer was probably going to be better for me. And the reasons why are big lessons for PHP Mailer. Swift Mailer had a nice simple website, they had one product, and they had a download link on the front page. Right off the bat, it was looking simple. On the other hand PHP Mailer has four products which I would have to investigate to find out which one was right for me. Their home page is a mess that for some reason seems to focus on ads for other people’s products along with tons of text about who knows what. It would take me hours just to parse the homepage.

But, what took it over the edge was that Swift Mailer has a beautiful object oriented design to their API and they talk about that being a goal, they have full easy to understand documentation, installation is a breeze, as it should be, all while offering an incredibly feature rich product. Swift Mailer wins by a mile.

Was it as easy as it looked? Well, in about an hour I had built a WordPress plugin that would include Swift Mailer’s functionality in my blog on demand. I had added code to another plugin to enable Swift Mailer at the right time and send an email from one Gmail account to another using Gmail’s smtp server with a secure connection over SSL.

One hour.

I literally copied the code over and changed the important bits. I had one issue where Gmail didn’t like the port the Swift Mailer docs used for SSL, but the Gmail docs listed the alternative port and things worked perfectly.

Furthermore, there are tons of features of Swift Mailer that will actually inspire me to do more with email.

Kudos to the Swift Mailer team, you’ve really created a great product and you are a poster project for open source. Thank you!

add_action('init', 'MyPlugin::Init');

class MyPlugin
{
    public static function Init()
    {
        // Put Some Code Here
    }
}

Pretty easy. What I really like about this is that the class name acts as a namespace, so I can use the simple function name Init instead of naming my function something annoying like myplugin_init.

I use this pattern all the time to initialize an instance of the class so that it can be used elsewhere, such as in a theme:

add_action('init', 'MyPlugin::Init');

class MyPlugin
{
    private $userName = null;

    public static function Init()
    {
        global $myPlugin;

        $myPlugin = new MyPlugin();

        // The following line would probably go into a 
        // constructor method and get the real current
        // user name.

        $myPlugin->userName = 'bob';
    }

    pubic function GetUserName()
    {
        return $this->userName;
    }
}

Then any other non-plugin code, like a theme for instance, can detect the presence of the plugin and use it.

global $myPlugin;

if (isset($myPlugin))
{
    echo 'MyPlugin is installed, ', $myPlugin->GetUserName();
}

Happy Coding!

One of the many things I’ve found useful over the past couple of days has been the WordPress function do_action. I have a base theme that I repurpose for all of my websites. I really try to keep it flexible enough to do just about anything. Sometimes that can be difficult, but do_action really helps. You can place do_action calls throughout your theme files in handy places and then customize your theme outside of your standard theme files using the add_action function. If you don’t customize, everything works fine, but if you do, you can do it in a different file so you don’t have to modify the core theme files.

Obviously, this paradigm is used throughout WordPress in many different ways, and I have been a “consumer” of it many times. But it wasn’t until recently that I realized how much this could help me with my many different themes and save so much time. Or at least it will, after this exhausting week is over!

At the start of the process I had a PHP function that I would call to import some data. The problem is, that process would take longer than 30 seconds after which it would time out. A while ago, I changed the function to stop itself after 20 seconds. The result was an administrative web page where you had to hit an “update” button multiple times, waiting for 20 seconds each time.

My dream of dreams was to have this function work via AJAX instead and just update one record, return with status indicating how much work was left and then do another. I did this with the JQuery.post method. This is using the WordPress admin AJAX functionality.

cancelProcess = false;

function ImportOneRecord()
{

    jQuery.post(
        '/wp-admin/admin-ajax.php', 
        {
            'action': 'ImportOneRecord'
        },
        function (data)
        {
            if (data.succeeded 
                && (data.recordsLeftToImport > 0) 
                && !cancelProcess)
            {
                // Update Status
                jQuery('#statusBox').html(data.status);

                // Do It Again
                ImportOneRecord();
            }
        },
        'json');

}

My initial concern was one of stack overflows, but then I realized that the asynchronous nature of AJAX takes care of that. When this function runs, it doesn’t block. It sends the AJAX request that lives out in the ether and when that request receives a response, it runs my event handler. When that event handler runs it doesn’t block either, meaning it can be released. But when it did run, it created another AJAX request that also lives in the ether. Nothing is hanging onto it.

This function made it through thousands of records and I’m not sure how big the JavaScript stack is, but it didn’t overflow. I think it’s because like I thought, that’s not an issue here. There is no stack build up. This is just a very very complex loop… I think.]]> http://designoplasty.com/2009/09/18/jquery-post-recursion-or-not/feed/ 0 http://designoplasty.com/2009/09/14/wordpress-plugins-and-ajax/?utm_source=rss&utm_medium=rss&utm_campaign=wordpress-plugins-and-ajax http://designoplasty.com/2009/09/14/wordpress-plugins-and-ajax/#comments Tue, 15 Sep 2009 04:36:55 +0000 Matt http://designoplasty.com/?p=967 The last couple of days I’ve been doing a ton of AJAX programming on some WordPress plugins. Wordpress actually does have one very handy AJAX feature that makes using AJAX just a little easier. I also use jQuery because it’s really nice for a lot of things including AJAX work.

AJAX is a great technology, and while I know what I’m doing, sometimes even I am amazed at how difficult it is. You’ve got HTML, Javascript, PHP, and usually database tables to get right. If any one of those isn’t working it won’t work.

If you don’t already have good debugging skills, I wouldn’t even try it. I very much try to integrate my debugging in with my development to save time. For instance, I have a function that checks to make sure a database call went OK. If not it sends an ajax response with the query and the error string. My calls to AJAX are always prepared to receive and display that error. Even my CSS for the page even handles displaying the returned error string in the most clear way possible. This is code I can use again and again in all my plugins, and if I didn’t reuse it I would never get anything done..

Now that I’m getting it down, it’s so nice. I love AJAX. But the more I work on the web the more I see we need a replacement for JavaScript. I mean most of the language is fine, but it needs to be a real language with the standard object oriented features implemented in the standard way: class, public, private, protected, property getters and setters, etc. The prototype keyword needs to be completely removed from the language. JavaScript and PHP need to align such that AJAX is a natural part of both languages. It’s possible, but the web is a funny thing and its technologies have a heck of a time moving forward.

Yes, its a cutsie name, but The Bug Genie is a PHP bug tracking system that is the opposite of Trac in the best possible ways.

First of all you create a MySQL database and copy The Bug Genie files to your web server. Then you go to your website, where The Web Genie greets you with a short setup. At the end, it gives you an administrator login and password and you’re ready to go.

It’s that simple to set up. No command line required.

The help is built right into the system in the form of little question marks strategically placed that you can click on. They usually answer any beginner questions you’ll have.

How to create users? Well you can do it quite easily, but why bother? Just let your users sign themselves up with their email address and create an account. Just like WordPress.

It’s very powerful and has Subversion integration. Actually, for my purposes, it’s a bit too powerful for the minor issue tracking I need, but after having worked at Microsoft and using their bug tracking, The Bug Genie seems better. It’s certainly prettier, and prettier than everything else out there as well.

I predict great things for The Bug Genie for a lot of great reasons, but maybe for no other reason than nobody can set up any of the other bug trackers without dedicating their life to them.

]]> http://designoplasty.com/2009/09/08/forget-trac-the-bug-genie-is-awesome/feed/ 0 http://designoplasty.com/2009/09/05/mysql-counters/?utm_source=rss&utm_medium=rss&utm_campaign=mysql-counters http://designoplasty.com/2009/09/05/mysql-counters/#comments Sun, 06 Sep 2009 03:24:22 +0000 Matt http://designoplasty.com/?p=940 Today I went to Panera (free wi-fi) to get some work done away from the distraction of my dachshund. I’m changing a lot of my PHP code to use classes, and needed to focus. After enjoying some soup on a bread bowl (it must be fall) I started working.

I didn’t get far. I realized what I needed was a thread-safe counter. Simply a function that spits out numbers one after the other, and absolutely positively guarantees it will not give out the same number more than once. I know how to do this many different ways using many different languages, but I wasn’t sure of the best way to do it using WordPress, PHP, and MySQL.

MySQL does have auto increment where if you add a row to a table it will make give a field a value that’s incremented. This is atomic, but I didn’t need a new row in a table, I just needed the number.

I figured I could store the number in a text file and have PHP use file write protections to do the locking I needed to make it atomic, but the performance would not be that great for such a simple task.

I thought I could create a simple table with the number in a row, and use MySQL table locking to accomplish this. For a while, I had settled on that plan, but something made me think there must be a better way.

I went about researching the MySQL update statement. It turns out that doing this is atomic.

UPDATE plugin_counters
    SET counter_value = counter_value + 1 
    WHERE counter_name = 'invoice_id';

But the problem is how to get that value before this happens again. Apparently you can just add one more expression to the WHERE clause.

UPDATE plugin_counters
    SET counter_value = counter_value + 1 
    WHERE counter_name = 'invoice_id'
        AND @value := counter_value;

This expression will always return true and will place the original value of counter_value into the MySQL variable @value.

I spent a good deal of time trying to verify that this is absolutely positively atomic and it seems to be. Even naysayers were accepting this to be atomic while pointing out that longer updates would not be atomic if the database crashed in the middle of the update. So to me, this means they’re saying as long as the database doesn’t crash, it’s atomic, which is good enough for me.

After installing Snow Leopard on my other machine and thinking I found all the kinks my MacBook still won’t connect to a MySQL database from a WordPress installation. I have followed all the instructions, I have found more instructions online and figured those out.

I can connect to my mysql database from either the command line or a database utility program.

My webserver seems to be running fine with php enabled.

But WordPress just won’t work. Not a big deal? My business is WordPress and this particular machine has at least 10 different WordPress installations on it and none of them work. I literally can’t work on anything for my customers at this point.

Also there’s nothing in the error logs to give me any hint as to what’s happening.

Fun!

Update:

Oh My God! For Snow Leopard on my MacBook apparently the host in wp-config.php needs to be ‘localhost’ instead of ‘127.0.0.1′. On Leopard it was exactly the opposite. But either should work fine. Whatever. And ‘127.0.0.1′ works fine on my other machine running Snow Leopard. This is just truly junk.

I know I tried this before but that my have been before I did all the other MySQL wrangling. Whatever.

Update:

I just checked and my other machine also requires ‘localhost’ and will not work with ‘127.0.0.1′. However, I don’t remember changing it. It must have either worked all along on that machine or I changed it in passing. Bizarre.

Pre Snow Leopard Installation Warning

Be sure to back up your

/etc/apache2/extra/httpd-vhosts.conf

file before you install Snow Leopard. It is going to replace that file without backing up the one you had before. That is not a file that’s included in Time Machine backups.

Post Snow Leopard Tasks

1. First you need to copy the vhosts file you saved back where it belongs. Otherwise you need to recreate your entries. Luckily I had two computers with this setup so I had the one on the other computer to look at for reference.

2. Next, MySQL probably won’t be working. In my case the was because the Snow Leopard install deleted the

   /usr/local/mysql

   symbolic link to my current version of MySQL. You just need to replace this using the following terminal commands:

   cd /usr/local
   sudo ln -s mysql-5.1.30-osx10.5-x86 mysql

   Your current version of MySQL will of course probably be different than that, but you get the idea.

3. There is a bizarre issue where Snow Leopard deletes the php.ini or reacts differently if it isn’t there. The symptom is that when viewing websites on your local server PHP will complain about not having a time zone set. This web page has the solution for that, and it’s not difficult, but long enough that I don’t want to repeat it here.

For me, these three steps got me working again. Hopefully they will work for you or will at least get you started. Good luck.

But the way I work is that I have one common theme for all my sites and then I retheme each site as appropriate. Each time I focus on a theme, I usually make changes that need to go back into the base theme as I learn to make the base theme more flexible and more themeable.

Sometimes a site gets ignored for a while so there are a whole bunch of these changes to bring into it. That’s one of the things I’m working on now. And I’m happy to say that while I’m practically rewriting the whole stylesheet because he base theme has changed so much, I can also see that it’s much easier and faster to theme than my old base theme. The style is much smaller than before while accomplishing a lot more.

As a base theme moves forward, it starts to reflect common things that need to happen and takes care of those for you. At the same time I try not to include much that would need to be undone. In fact, there is almost nothing that would ever need to be undone unless I needed to make dramatic changes for a particular theme.

You’ll see there are a lot of theme designers out there that work this way. However, I am surprised that nobody has taken the time to update the default WordPress themes to be more themable. At the same time, they are good learning themes, so maybe it’s for the best.