I decided to give them a try during the conference. That is until Foursquare decided to give me a “Hookup Badge.”

Apparently, the Hookup Badge is given to someone who checks in at two different hotels.

For anyone visiting Austin who doesn’t stay at the historic Driskill Hotel, there is a good chance you’re going to check in at two hotels during your trip. The Driskill is a must see and you will likely check in at the hotel you’re staying at.

That is what happened to me.

I checked in at the Driscoll Hotel when I met friends there. I purposely asked Foursquare not to tweet the check in because I feel like it is spam in my Twitter stream.

However, I didn’t remember that I had allowed Foursquare to post updates about badges that I won. Foursquare didn’t tweet the check in, but it did tweet about my “Hookup Badge.”

So part of the blame is mine. I shouldn’t have let Foursquare post to Twitter at all.

At the same time, I had no expectations that Foursquare would be posting inappropriate tweets. I’m a happily married man. Joking about hooking up while I’m on business travel is not funny.

Thankfully the damage was limited. A few months ago I disconnected Twitter from Facebook. Otherwise, my new “Hookup Badge” would have been shared with family members who would have no idea what Foursquare is nor understand Foursquare’s idea of a “funny” badge.

When I relayed this story with Péter Green of Finnish Mobile Association, he told me how he had received the “Hangover Badge,” and received many comments from his friends back home.

Those comments were funny, but imagine how quickly they would have turned into concerned or panic if the Hangover Badge was handed out to a recovering alcoholic who was half a world away.

I like the idea of gaming mechanics to get people to participate in a location-based service, but Foursquare seems to be making some big mistakes here:

• The incentive structure in the game should be known instead of a surprise. For example, if you check-in more times than another person, you become mayor. That’s well known and easy to understand. The Hookup and Hangover badges use rule combinations that you don’t known until you unwittingly unlock a badge.
• The badges indicate a lack of perspective on what issues they may cause for the people who receive them.
• The overall impression of the service based on these badges is one that is designed for party-going twenty-somethings. It’s hard to take such a service seriously.

We’ve heard a lot about location-based services and cell phone logs getting people in trouble for their infidelity. There’s no need for services like Foursquare to create problems where none exist.

As far as I’m concerned, this was inexcusable breach of trust. I deleted my Foursquare account and will not use their service again.

Previously, if you retweeted something, your retweet was your own. Only you had the ability to delete it.

But with Twitter’s new retweet feature, your retweet is tied to the original author’s tweet. And if the original author deletes the tweet, your retweet is deleted from your timeline.

I’m not sure what the proper way to handle this is.

On the one hand, if the original author shared something they wished to retract, it would be nice to honor that.

On the other hand, the tweet didn’t happen in a vacuum. More importantly, the act of retweeting should be tied to the timeline of the person who retweeted it. Someone else shouldn’t be able to scrub that history.

What do you think?

My plan was simply to ignore the new retweet feature until they fixed its shortcomings. However, Loren Brichter released a new version of my favorite Twitter client for the iPhone, Tweetie, that incorporates the new retweet feature and “deprecates” the old way of retweeting.

After spending some time with the new version of Tweetie, it became clear that the new retweet feature and all of its warts are here to stay. Instead of ignoring it, it was more important to document the ways it is broken and try to get Twitter and the developers of Twitter clients to fix it.

What Ev Got Wrong

Ev’s post does an excellent job of outlining the perceived shortcomings of the old way of retweeting. I’m grateful for his explanation. Not only is it helpful to understand the design decisions they made, but it also helps me understand where Ev missed important uses of retweets.

Attribution Confusion vs. Credibility and Reputation

One of the main things that Twitter was trying to solve with the new retweet feature is attribution confusion. “Most notably, the text of the tweet is not written by the person whose picture you’re seeing, nor the username that’s at the beginning.”

The solution to this in the new retweet feature is to show the name and picture of the original person who wrote the tweet and annotate below the tweet the name of the person you are following who retweeted the post.

The problem with this solution to attribution confusion is that it eliminates one of the main values of retweets: the credibility and reputation of the person who is retweeting.

By removing the picture of the person who retweeted and making the name much smaller, it becomes much harder to tell quickly which of the people you are following retweeted the post.

The person who retweeted a link to an article matters a lot. We place different value on the people we follow and the information they share.

In the example above, it is more important to me to know that Dave Winer was the source of the retweet than it is to know that jenny8lee—someone I don’t know—wrote the original tweet.

Tim O’Reilly is someone who I find to have very intelligent takes on technology. When I see his picture in my twitter stream, I stop scanning and pay closer attention. His credibility and reputation is what makes me pay attention to what he tweets or retweets.

This is something that the independent Twitter clients have done a better job of addressing than Twitter itself. Both Tweetie and Tweetdeck have included both the picture of the person who originated the tweet as well as the person who retweeted.

I much prefer the way Tweetie handles the retweet in the screenshot above to the way Twitter handles it. I see both Dave Winer’s name and picture. My only complaint is that the picture of the person retweeting is often too small to recognize quickly.

Redundancy vs. Dipping in the Stream

Another point that Ev makes is that “if five people you follow retweet the same thing, you get five copies, which can be useful but is a lot of noise.”

Ev is right that if you are reading every single tweet having redundant retweets can be a bit of noise. That said, it isn’t something that has ever bothered me.

The multiple retweets has however been something that has alerted me to important information. When you think of Twitter as a stream that you dip your toes into when you have time, important information can be missed if it only shows up in your stream one time. However, the more people retweet it, the more likely you are to encounter it whenever you decide to dip your toes in your Twitter stream.

I have to look no further than this past weekend to see the importance of this. On Saturday, the City of Portland announced that e-coli had been found in some of its water supply.

I happened to be out with the family in one of the affected areas. While waiting in line, I checked Twitter. By the time I checked, it had been several hours since the announcement. Yet, I saw one of the many retweets about the outbreak and was able to advise the people around me what water to avoid.

Let me repeat, the only reason I learned about the e-coli outbreak was because I received multiple retweets.

Another reason multiple retweets are valuable is because of reputation and credibility. A retweet from someone I follow whose opinion I value more highly than others is more likely to catch my eye.

There is value in multiple retweets. I’d love to have this be an option to see all retweets or only the first one.

Problems with the Current Implementations

Aside from the two viewpoints about credibility and the value of multiple retweets, there are things lacking in the current retweet implementations. As my friend Peter Whooly pointed out, it’s hard to tell if these are problems with the Twitter clients or Twitter’s API.

No Way to See Who Has Retweeted Your Tweets

In Tweetie, when you go under your profile and look at the retweets, there is no way to tell who retweeted your tweet. This is possible on Twitter’s web interface.

No Notification of Retweets

One of the nice aspects of the old style of retweeting was that retweets also contained the @reply syntax. This meant that you could not only could see the retweets easily, but if your Twitter client offered notifications for replies, you would be prompted when someone retweeted you.

Knowing when someone retweets you is important so that you can participate in the conversation.

Retweets Don’t Show Up in Lists

This again is an issue of credibility and reputation. Say you create a list of people whose opinions and thoughts you highly value. It is a very select list and you read every tweet these people write. When you look at that list, you will miss any retweets using the new feature.

Being able to see retweets in Twitter lists is a big deal.

Ability to Annotate Retweets

This is already on the Twitter team’s radar. Ev says they have some ideas on how they might implement it. This isn’t a show stopper for me, but it is for a lot of other people.

Vocal Minority or Silent Majority?

One of the things that got me worked up about this was seeing Loren Brichter’s take on the new retweet feature. He said, “vocal minority have problem with change – no doubt once they try it they’ll realize how awesome it is.”

Because Loren is the developer of Tweetie, the iPhone client I prefer to use, his opinion about the retweet feature matters. The fact that he thinks that:

1. it is only a vocal minority that has problems with it and
2. that we simply have a problem with change

frustrated me. From the conversations I’ve had with other users, that isn’t an accurate description.

Many of the same people who have problems with the new retweet feature embraced the new lists feature. Discounting opinions by saying people simply have a problem with change is a way of marginalizing contrary opinions without having to address them. There are legitimate issues with the retweet feature as I’ve outlined above.

And I’m not convinced that it is a minority of people who have problems with the new retweet feature. So far, I haven’t seen a single person who thinks the new retweet feature is complete.

Unlike lists which a majority of people raved about and immediately started using, the new retweet feature is something that most people seem to be at best accepting with hopes that Twitter will address its issues and at worst, so strongly opposed to the new feature that they are taking actions like refusing to upgrade Tweetie to avoid it.

How to Fix Retweets

I don’t disagree with most of what Ev said were the reasons for the new retweet feature. I also think formalizing retweets can lead to some really interesting information and features.

That said, the new feature has significant shortcomings that need to be addressed before we should consider the old way of retweeting deprecated.

I’m thankful that Loren implemented the new feature in Tweetie. It made me recognize that the feature wasn’t going away and was already impacting me even if I choose to use the old style retweet because others may use the new feature and I won’t see their retweets.

Therefore, the most important thing we can do to fix the situation is provide feedback to Twitter and Twitter client developers.

My hope is that if enough people provide feedback to Twitter (they are asking for feedback on the feature) that we can have a new retweet feature that we embrace as enthusiastically as we did Twitter lists.

In case you missed it, the FCC sent letters to Apple, Google, and AT&T asking them about Apple’s rejection of the Google Voice for iPhone application and what role each company played.

Apple and AT&T released the full content of their responses to the FCC. Google asked for portions of its response to be redacted. However, a Freedom of Information Act request prompted Google to divulge the full content of their response.

And yet despite this latest revelation, the he said, she said nature of the follow ups, and word that Google may even have a screenshot proving that Apple is lying, Google Voice is nowhere near the most important App Store rejection.

That distinction belongs to Freedom Time.

Why Freedom Time Matters More than Google Voice

Like many iPhone applications, Freedom Time was a frivolous application. The application displayed a cartoon character of George Bush with arms like a Mickey Mouse watch. But instead of telling time, the application counted down the days until Inauguration Day.

Freedom Time wasn’t one of the more high-profile iPhone App Store rejections. Unlike Google Voice, people barely noticed when the application was rejected.

What is important is the reason why Freedom Time was rejected. Apple’s response to the developer was:

Upon review of your application, Freedom Time cannot be posted to the App Store because it contains content that does not comply with Community Standards. Usage of such materials, as outlined in the iPhone SDK Agreement section 3.3.12, is prohibited:

“Applications must not contain any obscene, pornographic, offensive or defamatory content or materials of any kind (text, graphics, images, photographs, etc.), or other content or materials that in Apple’s reasonable judgement may be found objectionable by iPhone or iPod touch users.”

Defaming, demeaning, or attacking political figures is not considered appropriate content for the App Store.

Can you imagine political discourse of any significance that doesn’t include demeaning or attacking political figures? Like it or not, that’s part of the exchange of ideas that form a democracy.

This policy essentially bans any editorial cartoons—cartoons that have been part of America’s history since its inception.

The idea that political discourse might be rejected from the App Store as a matter of policy surely must be a mistake, right?

Think Different? What’s the Point?

Unfortunately, it isn’t a mistake. The developer of Freedom Time emailed Steve Jobs, and he actually got a reply. Steve wrote:

Even though my personal political leanings are democratic, I think this app will be offensive to roughly half our customers. What’s the point?

Steve

I’ve often wondered what the Steve Jobs who attended Reed College during the early days of the Watergate scandal would think of that quote.

Steve Jobs, George Bush, Richard Nixon, and Scott Ritter

These four people—two that I admire and two that broke our trust—have become linked in my mind because of the Freedom Time rejection.

Freedom of speech is easy to defend when the speech is popular, but the real test comes when you have to defend unpopular speech or things that you don’t agree with.

In Fall 2008, George Bush had the worst approval ratings since Nixon. At a time in which we had one of the most unpopular Presidents in American history, Apple didn’t have the courage to approve a simple, stupid application like Freedom Time.

What is the likelihood that Apple would approve a truly controversial and unpopular application during a time when popular opinion makes it difficult to stand up for what’s right?

I find myself wondering what would have happened if former marine and U.N. Weapons Inspector Scott Ritter had tried to release an application in 2002 talking about how there were no weapons of mass destruction in Iraq.

When Ritter did speak up in 2002 and told the world that he had been in Iraq and that there were no weapons of mass destruction, popular opinion was so high in favor of Bush policies that despite being known as a patriot, conservative, and a hawk, Ritter was called a traitor by some.

What if the only means Scott Ritter had to share what he knew with the rest of the world had been through an App Store?

Flickr Censorship Pales in Comparison

Recently Flickr received a lot of scrutiny and pressure because of perceived censorship of a political image. The image showed a modified version of Obama on the cover of Time Magazine where Obama was made to look like the Joker from the most recent Batman movie.

Yahoo, the parent company for Flickr, later explained that they removed the image from Flickr because they had received a copyright infringement claim.

I don’t care to debate the Flickr censorship case. Instead, I want to ask simply why Flickr got a lot of grief for censoring a single image that they say they removed because of a copyright claim, but Apple has thus far escaped scrutiny for a standing policy that rejects any applications that attack political figures.

The image that Flickr removed would have never made it through the iPhone app review process in the first place.

The Mobile Proposition: Trade Liberty for Security

Apple has good reasons for why it has an App Store review process. It told the FCC that:

We created an approval process that reviews every application submitted to Apple for the App Store in order to protect consumer privacy, safeguard children from inappropriate content, and avoid applications that degrade the core experience of the iPhone.

This is a very similar argument that carriers and handset manufacturers have been making for years now. The argument is that mobile phones contain so much personal, sensitive information that applications need to be vetted to ensure that consumers are protected.

This is the same argument that Ben Franklin famously warned us about when he said:

Those who would give up Essential Liberty to purchase a little Temporary Safety, deserve neither Liberty nor Safety.

And despite the fact that we would not accept similar arguments from our government, we seem willing to give up our freedoms to mobile companies for the sake of our own security.

It’s Not About Apple. It’s About Gatekeepers

While I’ve spent most of my time focusing on Apple, please don’t mistake this as a tirade against Apple. Apple just happens to be leading the way in this area of mobile as well.

The reality is that if mobile is going to live up to its promise, we need a future without gatekeepers.

It isn’t hard to conceive of a future where more people have smartphones than have PCs. In some countries, people get more news from their mobile phones than they do from their desktop computers.

Before we get to the point where mobile phones have become the primary way that people get their news and information, we need to ensure that we have the freedom to publish what we want without restrictions.

For these reasons, I’m encouraged by the work of organizations like the Open Mobile Consortium. They are tackling the difficult work of providing truly open mobile solutions that allow people in repressive regimes to communicate freely.

The Moral Imperative of the Mobile Web

In addition to the Open Mobile Consortium, we need to make sure that there are alternatives to app stores and their gatekeepers. The best alternative is web technology.

This is why I’ve gone from thinking about mobile web technology as a smart business decision for some applications to thinking of it as a moral imperative.

Even if you are an Objective-C programmer who has had a lot of success on the iPhone App Store, it is in your best interest that the mobile web develop into a viable alternative to app stores. It is in society’s best interest.

To get to that point, we need to solve the short-coming of the mobile web. We need the technology to stabilize. We need real browsers on all phones. And we need a reliable and easy way to accept payment for our mobile web applications and services.

I cannot state this strongly enough: we need an open and free mobile web to be a viable alternative to the mobile gatekeepers to ensure that we have the freedom to say what must be said and the ability to have our voices heard by others.

In a nutshell, with a bit of tweaking, you can GZIP and concatenate the scripts that come packaged with WordPress. GZipping and concatenating anything else–plugin scripts or scripts in your own theme–is not currently supported in any obviously sane way (using WP’s WP_Scripts management class anyway).

I’m going to give away the ending to save you some time:

add_action('wp_enqueue_scripts', 'lyza_force_compress');
function lyza_force_compress()
{
    global $compress_scripts, $concatenate_scripts;
    $compress_scripts = 1;
    $concatenate_scripts = 1;
    define('ENFORCE_GZIP', true); 
 
    /* enqueue your scripts here */
}

Putting the above in your functions.php file may result in insanely good compression on your subsequently-enqueued JavaScript files. I say may because GZIP is one of those fidgety server-side things that varies from hosting provider to hosting provider. I tested this approach on two vastly different environments and had good success, but as always with these things, YMMV.

While this may look rather silly and simple, figuring out exactly which constants and globals to set and when to set them took me just about forever.

The most important thing to note is that this only works on scripts that come pre-packaged with WordPress and are listed in the wp_default_scripts() function in wp-includes/script-loader.php. This is slightly irritating.

When it Does Work

The above will concatenate and GZIP all of the applicable enqueued JavaScript into a single request, served out through the wp-admin/load-scripts.php script.

• By “applicable”, I mean scripts listed in wp-includes/script-loader.php in the wp_default_scripts() function.
• If you have applicable JavaScript in both the head and the foot, you will end up with two script src tags. If everything is in the foot (or the head), you’ll get one tag. You not only get GZipping, you get fewer HTTP requests! Yay!
• JavaScript in plugins and your own theme won’t get concatenated and GZipped in this approach, but it certainly doesn’t break it.

In testing, the following:

    wp_enqueue_script('jquery');
    wp_enqueue_script('thickbox');
    wp_enqueue_script('scriptaculous');
    wp_enqueue_script('editor');

Went from:

10 requests, 310kB

to

2 requests, 90kB

with the activation of the above function. Nice! I got two requests because the above enqueueing puts stuff in both the head and the footer.

That’s a 340% improvement on filesize alone.

Why Won’t It Work for All JavaScript?

Because there are no, nada, zilch, none hooks for making it do so without doing some deep surgery and writing a plugin. It boils down to a couple of places in code:

From wp-includes/class.wp-scripts.php in the do_item() function:

100
101
102
103
104
105
106
107
108

	if ( $this->in_default_dir($srce) ) {
		$this->print_code .= $this->print_scripts_l10n( $handle, false );
		$this->concat .= "$handle,";
		$this->concat_version .= "$handle$ver";
		return true;
	} else {
		$this->ext_handles .= "$handle,";
		$this->ext_version .= "$handle$ver";
	}

To get the built-in concatenation and GZIPped delivery, it is necessary that the if statement here evaluate true. I won’t explain the nitty gritty unless you really want me to.

So, my first approach was to add paths to the $wp_scripts->default_dirs Array to add entries for my theme’s scripts and my plugin dir’s scripts. Big fat fail.

The reason is that the actual file — wp-admin/load-scripts.php — that serves up the concatenated, zipped JavaScript is a standalone script. I imagine that this is both for security and for performance. It does not have the complement of WordPress constants and hooks that we are accustomed to. In fact, it is completely and absolutely unpluggable (unless I missed something). It only includes the files that define the WP_Scripts and WP_Dependencies classes, and utility functions for those. It does not include any theme- or plugin-level items.

And it does something that completely shuts down the game. It instantiates a new, clean WP_Scripts object and then calls wp_default_scripts().

If you’ll recall, the WP_Scripts object in a normal WordPress request is a global singleton that manages all of the enqueued scripts. By creating a new instantiation, the load-scripts.php script has obliterated any notion of any enqueued scripts. Further, the wp_default_scripts() function is a hard-coded list of the JavaScript files that WordPress comes packaged with. While this function nominally triggers the ‘wp_default_scripts’ action, this is not usable here because no files are getting included in which I could take advantage of that hook. Further, it redefines do_action() and other API functions as blank functions that do nothing.

The load-scripts.php file then iterates through the requested JavaScript handles (comma-delimited GET) and sees if it recognizes them from the wp_default_scripts() list. As anything that’s in your own theme or in a plugin won’t be in this list, FAIL.

Though I see some possible options for me in the writing-a-plugin realm, I also sadly see that it would replicate functionality and am highly curious as to what the WordPress developers had in mind here.

Overview: Really Getting JavaScript Into the Footer

Quoth the WordPress Version 2.8 feature list:

– Improvements to the script loader: allows plugins to queue scripts for the front end head and footer, adds hooks for server side caching of compressed scripts, adds support for ENFORCE_GZIP constant (deflate is used by default since it’s faster)

At the time, I thought Wow, cool. When I have time, I’ll investigate that and then immediately forgot about it for a few months. During RSS-coffee-breaks I read Lester Chan’s post about how to put JavaScript in the footer (sounds easy enough!) and Andrew Ozz’s post, which left me coated with an intense and foolish optimism about compression.

What I aim to do in this post — part one of a series of three if I find time to investigate the second and third pieces — is explain why it’s not as easy as you’d expect to get some scripts (specifically scripts that come with WordPress by default) into the footer, and how you can make it happen.

If you’re in a hurry, you can skip to the Summary section at the end of the post.

WP JavaScript Inclusion: Header vs. Footer

What I read had me believe that it is falling-off-log easy to put all WordPress JavaScript in the footer. If you are trying to include a piece of JavaScript, say, in a plugin, that WP has not previously known about, it is that easy. But woe if you try this on certain scripts that come packaged with WordPress.

Let’s take a look at the functions that are involved in letting WordPress know that you want to use a given piece of JavaScript.

These are taken from wp-includes/functions.wp-scripts.php.

wp_register_script() and wp_enqueue_script()

37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

/**
 * Register new JavaScript file.
 *
 * @since r16
 * @see WP_Dependencies::add() For parameter information.
 */
function wp_register_script( $handle, $src, $deps = array(), $ver = false, $in_footer = false ) {
	global $wp_scripts;
	if ( !is_a($wp_scripts, 'WP_Scripts') )
		$wp_scripts = new WP_Scripts();
 
	$wp_scripts->add( $handle, $src, $deps, $ver );
	if ( $in_footer )
		$wp_scripts->add_data( $handle, 'group', 1 );
}

83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

/**
 * Enqueues script.
 *
 * Registers the script if src provided (does NOT overwrite) and enqueues.
 *
 * @since r16
 * @see WP_Script::add(), WP_Script::enqueue()
*/
function wp_enqueue_script( $handle, $src = false, $deps = array(), $ver = false, $in_footer = false ) {
	global $wp_scripts;
	if ( !is_a($wp_scripts, 'WP_Scripts') )
		$wp_scripts = new WP_Scripts();
 
	if ( $src ) {
		$_handle = explode('?', $handle);
		$wp_scripts->add( $_handle[0], $src, $deps, $ver );
		if ( $in_footer )
			$wp_scripts->add_data( $_handle[0], 'group', 1 );
	}
	$wp_scripts->enqueue( $handle );
}

As a theme developer, you may only ever have encounters with wp_enqueue_script(). But let’s look at what each of these functions does so I can then explain the issue.

wp_register_script() tells WordPress about a script, but does not actually cause it to be included in a given page request. By default, WordPress registers a gripload of scripts that are then available to you, the theme hacker, when or if you should need them. A list of these can be found in wp-includes/script-loader.php in the wp_defalut_scripts() function. Highlights include jQuery, prototype, scriptaculous, etc., as well as extensions to those frameworks (e.g. jQuery UI). WordPress (via the WP_Scripts class, itself extended from WP_Dependencies) handles dependencies and makes sure that jQuery UI doesn’t get included without its necessary jQuery, if you should forget to enqueue jQuery itself or it gets enqueued after jQuery UI.

wp_enqueue_script() tells WordPress, hey, I actually need this script, in this request. You may have seen or done something like this:

wp_enqueue_script('jquery');

This spools up jQuery and spits out a script tag to include the requested script.

In a lot of cases, it seems easy and straightforward to do this simple enqueue request. jQuery comes packaged with WP and is automatically registered for you, so you just have to hand the wp_enqueue_script() function one argument: $handle.

As a clever theme hacker, you may have noticed that the signature for wp_enqueue_script() and wp_register_script() changed in version 2.8 and this seems exciting. An $in_footer parameter was added:

wp_enqueue_script( $handle, $src = false, $deps = array(), $ver = false, $in_footer = false );

Totally psyched, you update your theme and use:

wp_enqueue_script('jquery','','','',true);

And wait for the magic. RELOAD! Wait, maybe something’s cached. RELOAD! Wait, what? RELOADRELOADRELOAD.

jQuery is still in the head.

So you get irritable and you quit trying, or like me you spend a few hours deactivating all of your plugins and trying to figure out where the problem is. You notice that the same thing happens with other scripts that WP already knows about (that is, the scripts in wp_default_scripts()). Stubbornly, they won’t get out of your page’s head element.

Here’s why.

Why WordPress Default JavaScripts Won’t Move to the Footer

The crux is: if the script you are enqueueing has anything defined as a dependency in WordPress’ wp_default_scripts() function, it will ignore your request to put it in the footer (I’ll provide a workaround shortly).

The reason for this is twofold.

Dependency Handling and “Groups”

Part of WordPress’ dependency handling for scripts involves “groups”, the ins and outs of which I’ll leave as an exercise for an intrigued reader. In an oversimplification, it put scripts with dependencies (e.g. jQuery, Scriptaculous) in groups[0]. It explicitly puts scripts that depend on other scripts in groups[1]. The default behavior of both wp_register_script() is to put a script in groups[0] if the $in_footer argument != true.

How Groups Handling does Something Possibly Confusing

OK, now check out this snippet from class.wp-scripts.php (do_item() method):

85
86
87
88

if ( 0 === $group && $this->groups[$handle] > 0 ) {
	$this->in_footer[] = $handle;
	return false;
}

This piece of logic puts groups > 0 into the footer. So that’s how WP decides to move things into the footer–it’s based on where the script is in the $wp_scripts->groups Array.

But here’s a potential pitfall in the wp_enqueue_script() function:

	if ( $src ) {
		$_handle = explode('?', $handle);
		$wp_scripts->add( $_handle[0], $src, $deps, $ver );
		if ( $in_footer )
			$wp_scripts->add_data( $_handle[0], 'group', 1 );
	}
	$wp_scripts->enqueue( $handle );

If you don’t give wp_enqueue_script() a $src (which you don’t have to provide do if the script has already been registered) for your $handle, it is going to enqueue it in whatever group it’s already registered in. So, when you do your little simple enqueue:

wp_enqueue_script('jquery','','','',true);

The entire part of the function where it would put it in the footer doesn’t execute because the if($src) test fails. And jQuery has already been registered—in groups[0].

Possible Workaround

I don’t like this but it works:

wp_enqueue_script('jquery','/wp-includes/js/jquery/jquery.js','','',true);

jQuery is now in the footer.

This does still appear to handle dependencies correctly, but I haven’t deeply tested. Also, there are some valid reasons to have some scripts, and possibly jQuery, in the head. This was just a demo.

Getting JS into the Footer: Quick Summary

// This will NOT put jquery in the footer
wp_enqueue_script('jquery','','','',true); 
 
// But this will, if inelegant and circumventing abstraction
wp_enqueue_script('jquery','/wp-includes/js/jquery/jquery.js','','',true);

For My Next Trick…Compression

Really, this post was a red herring. I tripped into this oddity while investigating the second part of the WordPress 2.8 feature claim: adds hooks for server side caching of compressed scripts, adds support for ENFORCE_GZIP constant (deflate is used by default since it’s faster). We’ll talk about that next time.

Consider this a looking-forward-to WordCamp Portland post! WordCamp is this weekend in Portland, Sept. 19-20. It is utterly sold out!

This post is aimed at those comfortable with WordPress hackery and PHP programming.

Making things work for our customers often–nay, all the time–ends up with the need for multiple WordPress loops on pages

On a given day, one of our enterprise or otherwise-crafty-and-complex clients may request, say, the three most recent posts about foo in the right sidebar, “upcoming events” (e.g. date-sensitive posts in some events category) in another box, a couple of embedded and editable WordPress page components, a random post or two, and then the “traditional” post loop itself. Whew.

I have long tried to find the best way to handle custom loops. For sake of definition, custom loop here means querying and displaying posts and/or pages within a page that are not that page’s “natural” queried posts (that is, the landing page of a WordPress blog by default “naturally” queries the most recent posts, and a category page “naturally” queries for posts in a given category).

There are a number of plugins and even entire themes keyed toward custom-loop-heavy development and modular formatting of posts in loops, including the Carrington JAM theme. But I find that most solutions either are a bit too baked–the Carrington theme feels like it would require a lifestyle change and an adoption of a new outlook (not that I’m ragging on the Carrington stuff; I’ve actually heard good stuff about it)–or a little bit too under-baked and soggy in the middle (“Here’s a two-line code snippet to call query_posts! I think? I mean, this should work, probably.”).

I’m Tired of Solving these things Ad Nauseum

Problems I keep running into:

• The dreadful tendency to forget to restore the “natural”, appropriate global post and wp_query objects after one is done messing about. Those are sort of inviolate and should not be sullied, but it’s wretchedly easy to lose track.
• Yet, if one does not pollute the global namespace with posts in the custom loop, one cannot access certain template tags and the like.
• The mishmash of logic and formatting that often happens when one munges together a custom query in a page or post template is totally aesthetically unpleasing and betrays a certain lack of character/mettle.
• Duplicated markup across a site that would better be modular and re-used.

It occurred to me recently that there is a straightforward way to deal with this. By creating a custom function (in a given theme’s functions.php file) of relatively low complexity, one can solve some of these problems once and for all.

The function: lyzadotcom_custom_loop($args)

It’s prefaced with lyzadotcom because I initially wrote it for my own site, but you can call it whatever.

This is what it looks like, and we’ll talk about it more below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

/**
 * To use when a loop is needed in a page. Use $args to call query_posts and then 
 * use the template indicated to render the posts. The template gets included once
 * per post.
 * 
 * @param Array $args               Wordpress-style arguments; passed on to query_posts 
 *                                  'template' => name of post template to use for posts
 * @return Array of WP $post objs   Matching posts, if you should need them.
 */
function lyzadotcom_custom_loop($args)
{
    global $wp_query;
    global $post;
    $post_template_dir          = 'post_templates';
    /* The 'template' element should be the name of the PHP template file
       to use for rendering the matching posts. It should be the name of file,
       without path and without '.php' extension. e.g. the default value 'default'
       is $post_template_dir/default.php
    */
    $defaults                   = Array('template' => 'default' ); 
 
    $opts = wp_parse_args($args, $defaults);
 
    // Bring arguments into local scope, vars prefixed with $loop_
    extract($opts, EXTR_PREFIX_ALL, 'loop');
 
    // Preserve the current query object and the current global post before messing around.
    $temp_query = clone $wp_query;                                  
    $temp_post  = clone $post;
 
    $template_path = sprintf('%s/%s/%s.php', dirname(__FILE__), $post_template_dir, $loop_template);
 
    if(!file_exists($template_path))
    {
        printf ('<p class="error">Sorry, the template you are trying to use ("%s")
            in %s() does not exist (%s).',
            $template, 
            __FUNCTION__, 
            __FILE__);
        return false;
    }
    /* Allow for display of posts in order passed in post__in array
       [as the 'orderby' arg doesn't seem to work consistently without giving it some help]
       If 'post__in' is in args and 'orderby' is set to 'none', just grab those posts,
       in the order provided in the 'post__in' array.
    */
    if($loop_orderby && $loop_orderby == 'none' && $loop_post__in)     
    {
        foreach($loop_post__in as $post_id)
            $loop_posts[] = get_post($post_id);
    }
    else
        $loop_posts = query_posts($args);
 
    /* Utility vars for the loop; in scope in included template */
    $loop_count             = 0; 
    $loop_odd               = false;
    $loop_even              = false;
    $loop_first             = true;
    $loop_last              = false;
    $loop_css_class         = '';                               // For convenience
    $loop_size = sizeof($loop_posts);
    $loop_owner = $temp_post;       /* The context from within this loop is called
                                       the global $post before we query */
 
    foreach($loop_posts as $post)
    {
        $loop_count += 1;
        ($loop_count % 2 == 0) ? $loop_even = true : $loop_even = false;
        ($loop_count % 2 == 1) ? $loop_odd  = true : $loop_odd  = false;
        ($loop_count == 1) ?     $loop_first = true : $loop_first = false;
        ($loop_count == $loop_size) ? $loop_last = true : $loop_last = false;
        ($loop_even) ? $loop_css_class = 'even' : $loop_class = 'odd';
        setup_postdata($post);
        include($template_path);
    }
    $wp_query = clone $temp_query;  // Put the displaced query and post back into global scope
    $post = clone $temp_post;       // And set up the post for use.
    setup_postdata($post);
    return $loop_posts;
}

Loop Templates

• By default, this function will look for loop templates in a directory called ‘post_templates’ in your theme’s template directory. Also by default, it will look for a file called ‘default.php’ in this directory. You can change the directory for templates if this bugs you.
• Templates are PHP files and you can do what you will in them. All template tags are available.
• You can create as many template files as you want and use them for different chunks of content.

Example Loop Template File

For example, this might be your default.php template file.

    <div class="post <?php echo $loop_css_class ?>" id="post-<?php the_ID(); ?>">
        <h4><?php echo $loop_count; ?><a href="<?php the_permalink(); ?>" title="<?php the_title(); ?>">
            <?php the_title(); ?>
        </a></h4>
        <em><?php the_date(); ?></em><br />
        <?php the_excerpt(); ?>        
    </div>

You can see that, in addition to standard “>WordPress template tags, I’ve used a couple of the batching variables made available by the function.

Batching Variables Available to Loop Templates

Available variables in loop templates are:

$loop_count                         // The count of the current post within the loop
$loop_odd                           // True if we're on an odd item (e.g. $loop_count = 1, 3, 5...)
$loop_even                          // True if we're on an even item (e.g. $loop_count = 2, 4, 6...)
$loop_first                         // True if this is the first post/page in the loop
$loop_last                          // True if this is the last post/page in the loop
$loop_css_class                     // 'even' if $loop_even, 'odd' if $loop_odd
$loop_size = sizeof($loop_posts);   // Total number of posts/pages in loop
$loop_owner = $temp_post;           // The post in global scope before this loop was entered

How to Use this Thing

Requirements

• The use of clone means you need to have PHP5.
• I have not tested this on any versions of WordPress 2.8. I imagine it would be OK, but YMMV.

Usage

1. Edit your themes functions.php file and stick this function in it.
2. Create at least one loop template file. By default (unless you tell it otherwise, which likely you will) this function looks for a template in

   <template_directory>/post_templates/default.php

   We’ll talk about templates shortly.

3. Call the function from any WordPress template file you might need it from. You talk to it with WordPress query-string-style arguments. This function takes any argument that the query_posts() function takes.
4. It also takes an additional argument, ‘template’. This is how you tell it which loop template to use.

Usage Examples

Embed an editable Page into Content

1. In the desired WordPress template:

       <?php
           $args = Array('pagename'         => 'embed-this-page',
                         'template'         => 'embed');
       ?>  
       <?php lyzadotcom_custom_loop($args); ?>

2. This is going to look for the template ‘embed.php’ in your $post_templates directory. This template might look like this:

       <div class="embedded" id="embedded-page-<?php the_ID(); ?>">
           <strong><?php the_title(); ?></strong><br />
           <?php the_content(); ?>
           <?php edit_post_link(); ?>
       </div>

Display 5 Most Recent Posts from Several Categories, Titles Only

1. In the desired WordPress template:

       <ul>
       <?php 
           // This assumes you have category IDs. 
           // Getting them is beyond the scope of this pos
           $args = Array('category__in'        => Array(5,6,4), 
                         'showposts'           => 5
                         'template'            => 'list_with_link');
           lyzadotcom_custom_loop($args);
       ?>
       </ul>

2. list_with_link.php might look like:

       <li id="link-<?php the_ID(); ?>" class="<?php echo $list_css_class>">
           <a href="<?php the_permalink()" title="<?php the_title(); ?>"><?php the_title(); ?></a>
       </li>

Display Your Posts Tagged ‘Banana’ from March of 2009

1. In the desired WordPress template:

       <h3>March's Bananas</h3>
       <?php
           $args = ('tag'              => 'banana',
                    'showposts'        => -1, //show all posts
                    'monthnum'         => 3,
                    'year'             => 2009,
                    'template'         => 'month_archive_list');
           $banana_posts = lyzadotcom_custom_loop($args);
           /* Hint: You might used the returned $banana_posts to
              populate another call to lyzadotcom_custom_loop(), 
              e.g. 'post__not_in' => [ids from $banana_posts] 
              to avoid duplicating posts!
           */
       ?>

2. month_archive_list.php might look like:

       <div class="archive_post" id="archive_post-<?php the_ID(); ?>">
           <?php echo $loop_count; ?> of <?php echo $loop_size; ?> Bananas:
           <strong><?php the_title(); ?></strong><br />
           <?php the_content(); ?>
           <?php edit_post_link(); ?>
       </div>

FAQ (In Which I Anticipate Questions)

Will this work with pages as well as posts?

Yes. Sure. Just fine! Anything that query_posts() can do, I can do too!

Why isn’t this a plugin?

It took me hours just to write this post; I’ve got stuff to do! If there’s a lot of interest, maybe I’ll consider it.

I found a bug/horrible security hole/idiocy?

Please let me know! Gently! Comments to this post is a fine method to do so.

How is this bad boy licensed?

GPL. Do with it what you will!

OMG! Don’t you know about XYZ plugin? It totally does this, but better!

Nope! But I’d like to!

Download, with Examples

I’ve gone ahead and zipped up some stuff for you:

• a functions.php file with the function in it (add it to yours)
• Several example files in a post_templates directory
• Example.php with several calls to the function

Download ZIP

Megan will be helping us mostly in a project management role, but we will be putting her development skills through the paces, too.

We feel fortunate to be growing during these challenging economic times–and we feel particularly lucky to have someone of Megan’s caliber joining us. We think she’s going to contribute a lot to our company right away, but we also expect her to help shape what comes next for Cloud Four.

Cloud Five?

During the hiring process, the most common question we got asked was whether or not we would change our name to Cloud Five.

The simple answer is no.

We picked Cloud Four not because of the four founders, but instead because we wanted a name that represented our values and our roots.

We wanted a name that conveyed transparency and openness. A cloud has those characteristics while also being something with substance. And as Portlanders, we see our fair share of clouds.

Those values and characteristics are not changing as we grow. The qualities of the name that originally appealed to us remain true no matter how many people we have in the company.

We’re excited about what comes next and we’re very happy to have Megan as part of our team.

More on how performance is connected to the environment in a moment, but first, the details on when and where:

Beer and Blog – Make Your Blog Load Fast & Save the Environment
Green Dragon Bistro & Brewpub
928 SE 9th Ave.
Portland, Oregon 97214
RSVP | Add to Calendar | Map

The Impact of Data Centers on the Environment

Everyone is aware that our ability to reduce our energy consumption is a key component to reducing the impact we have on the environment.

However, it wasn’t until I was asked to speak to the Storage Networking Industry Association (SNIA) at Storage Networking World last fall that I realized how important this is for those who run data centers.

At the time, I observed:

Several businesses are now being told that they cannot bring any more power into their data centers. The power company is simply refusing to provide them with more capacity.

In many cases, the cost of powering and cooling a data center exceed the costs of the hardware within two years.

The people in the storage industry get it. The SNIA has started the Green Storage Initiative to foster innovative ways of reducing power consumption in data centers.

The question is are those of us who are web developers doing our part? Sadly, no.

Web Site Gluttons

Web developers live insulated lives. We have broadband at our homes and our offices and it shows. We’ve stopped paying attention to the size of web pages.

Andrew King recently highlighted research showing that the average size of web pages has doubled since 2003. “Longer term statistics show that since 1995 the size of the average web page has increased by 22 times, and the number of objects per page has grown by 21.7 times.”

Source: http://www.websiteoptimization.com/speed/tweak/average-web-page/

In addition to the size of web pages, few sites are optimized to ensure that browsers cache the files and don’t request the same files repeatedly.

Steve Souders recently conducted a thought experiment on how much CO2 would be saved by optimizing the Wikipedia home page. He used the CO2stats.com estimate that “three minutes on a Web site generates three grams of CO2 – roughly equal to the amount one person generates by breathing for 4.5 minutes.”

Steve estimated that the optimization could save “5,000 kilowatt-hours per year or approximately 500-1000 pounds of CO2 emissions.”

Why Now?

I’ve been interested in web optimization for ever since it saved my prior company tens of thousands of dollars a few years ago. I’ve been speaking on the topic whenever possible and trying to help web developers understand how much benefit they can get by optimizing their pages and how easy it is to do.

A couple of weeks ago, I finally watched An Inconvenient Truth. At the conclusion of the film I started thinking about what more I could do. I’m getting a bike ready to use for my commute to work. I’m reducing the energy I use. I’m contemplating a vegetarian diet.

And I’ve redoubled my commitment to getting web developers to take site performance seriously. It saves money, improves the experience for your customers, and it’s easy to do.

Most importantly, if you care about global warming, optimizing your site is a moral imperative.

So come join us tomorrow at the Green Dragon to make your blog faster and reduce the energy it consumes.

Akismet is a comment spam protection service that is free to use for non-commercial use and integrated with popular blog software (e.g. WordPress, which we use at Cloud Four).

But I never knew the true numbers before: of the 3.67 billion comments Akismet has seen, only about 295 million are legitimate. That means only about 8% of all blog comments filtered through Akismet are legitimate. That’s kind of grim.

It makes me realize that having Akismet activated for my blog isn’t just a nice-to-have, but a must.