Anonymous functions, also known as closures, allow the creation of functions which have no specified name. They are most useful as the value of callback parameters, but they have many other uses. Closures can also be used as the values of variables; PHP automatically converts such expressions into instances of the Closure internal class.

PHP has very few predefined classes that are part of the core language, so naturally I was intrigued by the Closure class. The PHP Manual has this to say about the class:

The predefined final class Closure was introduced in PHP 5.3.0. It is used for internal implementation of anonymous functions. The class has a constructor forbidding the manual creation of the object (issues E_RECOVERABLE_ERROR) and the __invoke() method with the calling magic.

The invoke magic method is also a new feature in PHP 5.3. It is called when an object is used in the context of a function (e.g. $object($parameter);). Since Closure objects will be used like functions, this is a critical feature of the Closure object. The Closure class may be perfectly equipped to act like an anonymous function, but it does not provide any extra utility beyond that. A var_dump() of a closure will reveal the functions parameters, but there is no way to get any other information about the Closure (like the actual code of the function). Trying to serialize the Closure throws an Exception and json_encode() just returns an empty JSON string. To make matters worse, the Closure class is final, so there is no way to extend it.

That simply wasn’t going to cut it for me. I wanted to make my own Closure class that was at least able to do the following:

1. Invoke the Closure (with __invoke()) just like the PHP Closure class
2. Retrieve the actual code of the Closure
3. Retrieve detailed data about the Closure’s parameters
4. Retrieve the names and values of any variables inherited from the Closure’s parent’s scope (with the use construct)
5. Serialize and unserialize the Closure

I decided to play around with the Reflection API to see what kind of information I could get from the Closure. A Closure is a function, so using the ReflectionFunction class provides the same information about Closures as it does about any other functions. PHP 5.3 also added the isClosure() method to the ReflectionFunction (in case you weren’t convinced that reflection would be helpful). After some tinkering, it became apparent that I would be able to accomplish all of my desires. I will walk you through the construction of my “SuperClosure” class and explain how the creative use of Reflection allows us to find ways around the problems normally blocking the ability to have my desired features.

1. Grant the ability to invoke the Closure

The first goal was to create the basic SuperClosure class that both encapsulates and allows invocation of the Closure. To do this I wrote a simple class with a constructor and the magic __invoke() method. I also included an accessor method (getter) for the actual Closure. In the constructor I created an instance of the ReflectionFunction class and stored it as a class member that helped allow invocation of the closure with a variable number of arguments. It also helped me accomplish other things later. The following code shows the basic class upon which I will be building. The complete will be shown at the end of the article.

class SuperClosure {

	protected $closure = NULL;
	protected $reflection = NULL;

	public function __construct($function)
	{
		if ( ! $function instanceOf Closure)
			throw new InvalidArgumentException();

		$this->closure = $function;
		$this->reflection = new ReflectionFunction($function);
	}

	public function __invoke()
	{
		$args = func_get_args();
		return $this->reflection->invokeArgs($args);
	}

	public function getClosure()
	{
		return $this->closure;
	}
}

The __invoke() method allows the SuperClosure object to be used exactly as if it was a Closure object. I had to recreate this functionality for the SuperClosure class since I was not able to extend the Closure to begin with. In order to pass arguments through to the real Closure, I used a combination of the func_get_args() function and the invokeArgs() method of ReflectionFunction to ensure that any variable number of arguments could be used. I could have also used call_user_func_array() function, but I prefer Reflection, and since I already had an instance of the ReflectionFunction, the invokeArgs() method seemed like a better choice.

2. Retrieve the actual code of the function

Secondly, I added code that allowed the SuperClosure class to find and store the actual code defining the closure. This feature is actually the key to doing the serialization later and is the most complicated part of the program. To accomplish this portion of the program, I used the instance of ReflectionFunction from Step 1 and the SplFileObject class, an SPL class which provides a nice object-oriented interface for dealing with files. The getFileName(), getStartLine(), and getEndLine() methods of the ReflectionFunction class allowed me to retrieve all the information I needed to find the source code of the Closure function. Using the SplFileObject to open and read from the source file and in combination with some string manipulation, I was able to obtain the closure’s source code. The following code shows the protected _fetchCode() method used to parse the closure’s code out of its source file:

protected function _fetchCode()
{
	// Open file and seek to the first line of the closure
	$file = new SplFileObject($this->reflection->getFileName());
	$file->seek($this->reflection->getStartLine()-1);

	// Retrieve all of the lines that contain code for the closure
	$code = '';
	while ($file->key() < $this->reflection->getEndLine())
	{
		$code .= $file->current();
		$file->next();
	}

	// Only keep the code defining that closure
	$begin = strpos($code, 'function');
	$end = strrpos($code, '}');
	$code = substr($code, $begin, $end - $begin + 1);

	return $code;
}

The only limitations with the current version of this function are that you cannot have multiple closures on a single line and you cannot use the word “function” anywhere besides the actual closure’s declaration.

3. Retrieve detailed data about the Closure’s parameters

Retrieving information about the closure’s parameters was as simple as adding a method that simply returns the result of the getParameters() method the SuperClosure’s instance of ReflectionFunction. That’s all. The getParameters() method returns ReflectionParameter objects which have several methods for getting information about the parameters including their names, values, default values, and more.

4. Retrieve the names and values of any variables inherited from the Closure’s parent’s scope

One of the biggest problems I had was retrieving the names and values of the variables added to the Closure’s scope with the use construct. There isn’t a documented way of doing this as far as I know, but I was able to figure out a way to do it after playing around some more with the ReflectionFunction class (it is just so helpful). These variables are actually included in the results of the getStaticVariables() method. If the closure declares any variables with the static keyword, these will also be included in the results. To get around this I added the _fetchUsedVariables() method that uses a combination of the getStaticVariables() method and some string manipulation of the Closure’s code (from Step 2) to find only the variables that were inherited from the parent’s scope. The following code shows the _fetchUsedVariables() method:

protected function _fetchUsedVariables()
{
	// Make sure the use construct is actually used
	$use_index = stripos($this->code, 'use');
	if ( ! $use_index)
		return array();

	// Get the names of the variables inside the use statement
	$begin = strpos($this->code, '(', $use_index) + 1;
	$end = strpos($this->code, ')', $begin);
	$vars = explode(',', substr($this->code, $begin, $end - $begin));

	// Get the static variables of the function via reflection
	$static_vars = $this->reflection->getStaticVariables();

	// Only keep the variables that appeared in both sets
	$used_vars = array();
	foreach ($vars as $var)
	{
		$var = trim($var, ' $&');
		$used_vars[$var] = $static_vars[$var];
	}

	return $used_vars;
}

5. Grant the ability to serialize and unserialize the Closure

Finally, I implemented the serialization capabilities. Since an actual closure object cannot be serialized (it gives a fatal error), I had to be creative to come up with a way to do my own serialization. The code I wrote for Step 2 and Step 4 made this possible. The sleep magic method allows you to hook into the serialization process, so I used this method to prepare my SuperClosure class for serialization. In order for my class to be serialized, I needed to first stop the Closure object and the ReflectionFunction object representing the Closure from being serialized. The __sleep() method should return an array of the class members you are serializing, so I simply left those variables out of the list. Because I was serializing the Closure’s code and static variables, it made possible in the __wakeup() magic method to recreate the Closure object using the code. To do this I had to use the extract() function on my array of used variables to import them back into the scope. Then I performed an eval() operation on the Closure’s code in order to recreate the Closure. eval() is always a risky operation, but in this case it makes sense. If you are planning to use this code for any of your own projects, I urge you to take precautions. The following code shows the complete SuperClosure class with the additions of the __sleep() and __wakeup() methods.

class SuperClosure {

	protected $closure = NULL;
	protected $reflection = NULL;
	protected $code = NULL;
	protected $used_variables = array();

	public function __construct($function)
	{
		if ( ! $function instanceOf Closure)
			throw new InvalidArgumentException();

		$this->closure = $function;
		$this->reflection = new ReflectionFunction($function);
		$this->code = $this->_fetchCode();
		$this->used_variables = $this->_fetchUsedVariables();
	}

	public function __invoke()
	{
		$args = func_get_args();
		return $this->reflection->invokeArgs($args);
	}

	public function getClosure()
	{
		return $this->closure;
	}

	protected function _fetchCode()
	{
		// Open file and seek to the first line of the closure
		$file = new SplFileObject($this->reflection->getFileName());
		$file->seek($this->reflection->getStartLine()-1);

		// Retrieve all of the lines that contain code for the closure
		$code = '';
		while ($file->key() < $this->reflection->getEndLine())
		{
			$code .= $file->current();
			$file->next();
		}

		// Only keep the code defining that closure
		$begin = strpos($code, 'function');
		$end = strrpos($code, '}');
		$code = substr($code, $begin, $end - $begin + 1);

		return $code;
	}

	public function getCode()
	{
		return $this->code;
	}

	public function getParameters()
	{
		return $this->reflection->getParameters();
	}

	protected function _fetchUsedVariables()
	{
		// Make sure the use construct is actually used
		$use_index = stripos($this->code, 'use');
		if ( ! $use_index)
			return array();

		// Get the names of the variables inside the use statement
		$begin = strpos($this->code, '(', $use_index) + 1;
		$end = strpos($this->code, ')', $begin);
		$vars = explode(',', substr($this->code, $begin, $end - $begin));

		// Get the static variables of the function via reflection
		$static_vars = $this->reflection->getStaticVariables();

		// Only keep the variables that appeared in both sets
		$used_vars = array();
		foreach ($vars as $var)
		{
			$var = trim($var, ' $&amp;');
			$used_vars[$var] = $static_vars[$var];
		}

		return $used_vars;
	}

	public function getUsedVariables()
	{
		return $this->used_variables;
	}

	public function __sleep()
	{
		return array('code', 'used_variables');
	}

	public function __wakeup()
	{
		extract($this->used_variables);

		eval('$_function = '.$this->code.';');
		if (isset($_function) AND $_function instanceOf Closure)
		{
			$this->closure = $_function;
			$this->reflection = new ReflectionFunction($_function);
		}
		else
			throw new Exception();
	}
}

Conclusion

With some cleverness and reflection, I was able to create the SuperClosure class and extend the Closure’s normal capabilities. Although my class does not enhance the typical use of a PHP Closure it does make it possible to serialize and transport a closure and provides an interface for examining the parameters and inherited variables. This means that we can do:

$closure = new SuperClosure(
	function($num1, $num2) {return $num1 + $num2;}
);
$serialized_closure = serialize($closure);
$unserialized_closure = unserialize($serialized_closure);
echo $unserialized_closure(1, 5);

without worrying about errors. Also, it would technically be possible to send closures through a remote service.

From what I have read in the PHP Manual, this class may have to be changed in the future. The Manual states this regarding anonymous functions:

Anonymous functions are currently implemented using the Closure class. This is an implementation detail and should not be relied upon.

So according to this, future versions of PHP might implement closures differently, and my class would have to be rewritten.

If you would like a copy of the code from this article (and an example of its use) you can find it on my Github account.

While managing your social networking presence on Twitter and Facebook, it can be difficult to quantify the impact of each medium. While I’m a huge fan of Twitter, traffic results from earlier today on one of my sites confirmed for me what may sound like common sense: Facebook fans drive far more traffic per-user than Twitter followers for a given promotional message.

I’m currently running a contest in association with T-shirt company Threadless. (It’s called Threadknits, and it’s based on knitting and crocheting their t-shirt designs into crafts.) Today, Threadless posted a message on their Facebook page and  Twitter, both with essentially the same content: an invitation to check out Threadknits. They were both posted at nearly the same time.

The numbers are what might surprise you. Threadless has almost 1,500,000 followers on Twitter, and “only” 102,000 fans on Facebook. With the posts made within an hour of each other, my traffic on the site shot up, with a couple thousand visitors hitting by day’s end. Here’s the breakdown of traffic driven from each:

 
The difference is absolutely staggering. Whereas Facebook generated an approximate 1.08% clickthrough rate, Twitter’s was closer to, well, 0%. 232 visitors came from Twitter or related sites directly and 450 additional clicks landed on the home page without a referrer, which I’m chalking up to clicks from Twitter clients. (Though, to be fair, this could easily overstate Twitter’s influence.)

On a previous contest, Threadless would tweet and I’d see between 1,000-2,000 clicks on their roughly 1.4 million followers, so while it may be a bit low today, I think the point stands: Even at its best, Twitter for large audiences generates clickthrough rates dramatically lower than Facebook. For 2,000 clicks, the rate at 1.4M followers stood at 0.14%. A quick look at the bit.ly stats on a few links from Ashton Kutcher (the #1 Twitter personality by followers) shows they typically net about 20,000-30,000 clickthroughs, on 4.3M followers, gaining a decent amount on the Threadless best-case scenario all the way up to 0.48% ~ 0.60%. (This accounts somewhat for the viral nature of Twitter as bit.ly clicks are counted for retweets as well.) Naturally, clickthrough rates will vary dramatically even amongst popular Twitter personalities for a variety of reasons. I’d like to focus more on the significant difference between the Facebook and Twitter rates I witnessed today.

There are likely several possible reasons for this:

• The audience may be slightly different—people willing to consider themselves “fans” on Facebook may be more picky with their allegiance than those willing to follow an account on Twitter.
• The phrasing and formatting of the message were slightly different—not exactly apples-to-apples as Facebook includes the logo and a text clip from the website, but I imagine this had a negligible effect.
• My mileage may vary—this is an admittedly small sample size, but I think the evidence and logic around these results indicate they’re not anomalous.
• Most importantly, Facebook lingers while Twitter sails by. Users are probably more likely to follow links during their Facebook time than from a passing Twitter notification unless it’s of particular interest to them.

That last point is particularly important. Facebook, having reconfigured their News Feed yet again, no longer sorts things there chronologically. They’ve merged the Highlights functionality back into the News Feed which they now use to keep certain posts “stickier” than others based on what they believe you might be interested in. (It manages to do a strikingly horrible job at this compared to how it used to perform, but that’s a conversation for a different post.)

With Twitter, the very nature of real-time can be summed up: blink and you miss it. While you can use a Twitter client to review tweets over the past day or two, it’s still less likely your tweet was as visible over Twitter as a post would be on Facebook’s News Feed. I’d like to see some more statistics on total audience reach. The clickthrough rate surely only tells part of the story—I’d be far more interested to learn what percentage of each audience even saw the post, and determine true clickthrough rates from that.

In the end, it’s important to consider the overall spirit of the findings here. Twitter is great for growing virally and interacting with customers, but your message on Facebook may have a far more lasting impression and generate greater returns, even if fans are more of a fight to procure. Engage on both, but recognize the differences between them and leverage each of their strengths. I’ll likely post about the best way to do that for each site in the near future.

(The above graphic represents the total clickthrough breakdown by medium assuming a linear progression of Threadless’ Facebook audience to match their Twitter audience, maintaining the same clickthrough rates from today’s traffic. It’s likely the Facebook clickthrough rate could in fact fall some as their audience grew, but it’s my belief that it would still beat Twitter, user for user.)

The official Google Support page describes the following subsidy tiers:

• Nexus One without service: $529
• Nexus One with new, 2-year T-Mobile US service plan for new customers: $179
• Nexus One with new, 2-year T-Mobile US service plan for qualifying existing T-Mobile customers who are adding data plans: $279
• Nexus One with new, 2-year T-Mobile US service plan for qualifying existing T-Mobile customers who are upgrading their data plans: $379

I’ve been a T-Mobile customer for a little over seven years now, and off-contract for pretty much that entire time. I’m thus now open to what T-Mobile calls their full subsidy. Except with the Google phone, where Google manages the subsidy, not T-Mobile. Since I had a $10/month sad, EDGE-based data plan with TMO, Google informed me after polling the TMO servers that I was eligible for the $150 subsidy, for a Nexus One price of $379. The next subsidy tier up is $100 cheaper for a price of $279.

The only distinction lies in whether you are “upgrading your data plan” or “adding a data plan.” This seemed like a simple enough problem to fix: I called T-Mobile support and asked them to cancel my data plan. They said it would be no problem, since I’m not under contract. I worried briefly that it wouldn’t be visible to the Google-based powers that be until the next billing cycle, but the TMO rep informed me that the change is instant. Since I knew I was buying a Nexus either way, I pulled the trigger.

Wouldn’t you know it, not five minutes later when I went to make the purchase again Google’s web store fetched my data and lo and behold, my Nexus price was now just $279. Easy-peasy, that.

The ironic part is that I’m moderately sure I could re-activate the data plan now without incurring any real additional fees in the day-and-a-half I may have to wait for the overnight shipping to get here, but I don’t use the slow EDGE service enough to warrant wrecking my cool here.

After all the dust settled, I realized how asinine Google had decided to make the checkout process by managing sales and subsidies of the device themselves. They limit you to just one rate plan during your purchase, which is more than a little infuriating as I received different answers from TMO reps over whether upping my minutes would cause Google to come after me for the subsidy. (It appears that you CAN upgrade your account to another Even More plan according to a recently-added note on this Google Support page.) The pricing rates are buried under a Support knowledge base article and not at all transparent. Google says $179 and then pulls an enormous J/K on you as they fetch your account information, seemingly pulling a figure out of thin air as it suits them. The T-Mobile reps can’t do anything about it since the purchase isn’t on their side of the pond at all. And Google is nowhere to be found.

Strange to me that a company so intent on delivering a device with their brand and full-throated support would instantly fawn off users to HTC and T-Mobile so that they don’t need to support their customers in any meaningful way. This isn’t the first time Google has proved shockingly absent with matters of support, but it feels very different when you’re purchasing a product subject to additional cancellation fees.

Further, it seems completely short-sighted to limit the subsidy as they have. Restricting the best price to new T-Mobile customers alone is frustrating, but they make it nearly impossible for anyone with a family plan to switch at the subsidized price. Worse, the subsidy at its lower rates really just amortizes the cost of the phone out over those two years, as the Even More plans cost $10/month more—that’s $240 over two years right there. Let’s be clear: At $379, you’re better off financially buying the unlocked phone and using the Even More Plus plan, which costs $10 less, for a total savings of $90 over the two year term. Even better since you’re not under any contract at the $529 rate.

Creating barriers to entry for new customers is always a bad idea, made all the worse when those barriers seem arbitrary and class-based. Google needs to stop with the silly tiers and subsidize the damn phone like they’re usually subsidized through carriers. They should allow purchases under family plans and not take the data plan into account. And they should allow you to select from any of T-Mobile’s Even More tiers, which would save me a phone call with T-Mobile’s (admittedly friendly and typically knowledgeable) support.

[1/18/2010 Edit: It was reported last week that Google is nixing the $379 rate entirely, so existing T-Mobile subscribers of all (out-of-contract) stripes will now qualify for the $279 offer. Early adopters who got hit with the $379 rate will have a refund check sent to them. Good on Google, but it'd be nice if it were $179 for all.]

Naturally your mileage will vary, but these are tips I’ve put together based on my experience with companies who are doing Twitter right, and some who haven’t quite got the hang yet:

1. DO: SPELL THINGS CORRECTLY. Don’t treat Twitter like you’re a third-grader sending a text message. If your message is so long that you find yourself having to edit “see” to “c” or “you” to “u”, find a way to make it shorter without resorting to sounding like an idiot. (I’m looking at you, @SarahPalinUSA.) Use the emdash (hold alt and press 0151 on the pc keypad) to break up thoughts—without spaces on either side—instead of ellipses, or other “open set” punctuation. Breaking messages down into “leet speak” or SMS chatter is unprofessional and sloppy. If it absolutely must be said in more than 140 characters, seriously consider a blog.
2. DO: TWEET SPECIAL OFFERS OCCASIONALLY. Use Twitter to incentivize your followers to stick around, but don’t spam them dozens of times throughout the day. Assume that one or two offers a day is a good maximum. (See tip #7.) Consider offering discounts or free products with a “code word” like Sprinkles Cupcakes does. Nearly every day, they give away a free cupcake to the first 25 or so customers who whisper their coupon phrase that day. This has the wonderful benefit of getting people in to your store, where they’ll likely make a purchase even if they’re not one of the 25. There’s also a good chance that they’ll buy something else even if they get the free cupcake, and by limiting it to the first few customers, you can contain your costs outright. Even if you’re not a brick and mortar, special offers can encourage customers to make purchases they had been holding off on but wouldn’t have otherwise known about. Dell claims to have booked $6.5 million in sales directly through their Twitter presence over the past two years.
3. DON’T: BE BORING. Special offers are great and might be enough to keep followers around, but you can engage your customers on a much deeper level by talking about your product, your business practices, and even offering some single-tweet behind the scene glimpses into how you operate. Restaurants especially can make use of this, and one local eatery called Liberty Market does a great job tweeting about new menu items they’re working on, showing pictures, and discussing special offerings of the day. It keeps your brand on people’s minds and makes the brand far more personable.
4. DO: PROACTIVELY ENGAGE CUSTOMERS. Use Twitter’s search capacity or any respectable Twitter client to set up a search with your brand or company name in it. For smaller businesses, you’ll likely see feedback directed to your Twitter account as a mention, but larger brands are going out of their way to engage customers who simply tweet ABOUT them. Pizza Hut is a fantastic example of a corporation that really engages their customers intelligently. They reply back to people simply mentioning Pizza Hut, asking what they had and thanking them for their patronage. They also try to resolve issues, which is my next tip.
5. DO: RESOLVE ISSUES WITH CUSTOMERS. Twitter is a valuable tool for companies to identify trends and monitor feedback about their brand. It’s also a powerful tool for customers to share their dissatisfaction. Because conversations through mentions/replies are public, it’s in a company’s best interest to identify negative tweets and attempt to engage the customer and make their problem right. Pizza Hut does this with nearly any negative experience tweet that comes through. You should focus on making things right, but feel free to move things off the “public” side of Twitter to resolve the issue.Similarly, I tweeted to @hpsupport about a problem my brother had with his HP laptop and they engaged me directly, asking me to send an email to one of their Twitter support staff. They’ve now set up a call next Monday. This is a level of service that’s above and beyond what I was expecting from going through normal channels, and you can believe that it’s in part because the alternative is a vocal, upset customer.
6. DO: TWEET THROUGHOUT THE DAY. Twitter is a different medium than an email newsletter. While mail can lose itself in the shuffle, it’s likely that a customer will at least see the message’s presence in their inbox even if they simply delete it. With Twitter, there is no such assurance. Depending on your audience, your customers may very likely not see tweets about offers or important news simply because you mentioned them earlier in the day. Most clients only fetch the last hundred or so tweets so a user who has just opened their client will likely miss a tweet from a day ago. If you’re going to have a Twitter presence, commit. An account with no new updates for three months looks worrisome.
7. DON’T: TWEET NONSTOP OR SPAM YOUR USERS. Keep things to a balanced 7-12 tweets a day. Don’t repeat yourself over and over, but don’t count replies (tweets starting with someone else’s name)  in that number. Encourage users to tweet back by asking questions about what your customers like or want to see more of. Hold mini contests, discuss upcoming events, or talk about your history. But keep things in check and try to spread out your tweets. CoTweet is a wonderful tool for scheduling tweets to go out so that you don’t have to be in front of a computer managing your account all day.
8. DO: FOLLOW COMPETITORS & OTHER LOCALS. Even though you compete with other local businesses, it’s vitally important that you follow them and see what they’re doing on Twitter, but you can also feel free to engage them online and stay friendly out in the open. You should also make a concerted effort to track down local businesses whom you work with and follow their accounts and engage with them. Word of mouth is everything and the people following your favorite businesses are likely to be great potential customers for you as well. Strike up conversations with others and you can bet they’ll return the favor. When other companies mention you (@reply within a message), it appears in their follower’s feeds, linking right to your name. A great way to earn free word of mouth is just to have productive conversations with your favorite local fellow businesses.

Twitter is a quick growing medium that companies are still feeling their way around within. It’s really exciting to see companies taking customer feedback over Twitter to heart, engaging users directly, offering great deals, and using Twitter to solve problems. Still, jumping in to social networking can be a bit of a challenge and is something that does require time and effort. If you need more advice or want some help establishing your Twitter or Facebook social media presence, we’d love for you to contact us. In the meantime, I’d love to hear any tips or favorite practices you’ve seen other companies make use of that I might have left out.

WELCOME TO THE WORLD WIDE WEB, AN INTERACTIVE MEDIUM IN WHICH SCREEN RESOLUTION STATISTICS ARE TRIVIAL, BROWSER VIEWPORTS ARE VARIABLE, AND SCROLLING BEHAVIOUR IS A STANDARD. THERE IS NO PAGE FOLD. LOVE YOUR SCROLLBAR.

The buzz on Twitter from “designer” types appears to be a knee-jerk “ZOMG YES SO TRUE!!!111one” while responses on the site’s reddit thread have been more measured. I especially appreciate the following comment, by one fletcher_t:

Well of course it depends on the context of what the site is providing… but there is indeed a fold and if you’re ignorant of that, may god have mercy on your soul.

Let’s be perfectly clear: There IS a “fold”. For the uninitiated, the “fold” refers to the literal crease in a newspaper. Editors recognized the importance of catching their reader’s interest “above the fold”, because the likelihood a reader will bother to look under the fold is lower as a whole. Readers who might not typically read the sports section, for instance, will notice a story above the fold if it’s of interest to them. If they’re just flipping past as they always do, they’re far less likely to look beneath the fold.

The assertion made by the “no fold” site is that, because technology has provided us with infinite page lengths, we should design our pages accordingly. We can space things out more, we can use larger print and increase readability, and we shouldn’t be so concerned with what lies above the fold because users will scroll anyway! We were on a roll there up until that third point, weren’t we?

The reality is that the science of user attention is a tricky one, and more of an art than anything. Heat maps and eye-tracking studies frequently show huge dividends by presenting the initial page-load in a clear, concise manner, with well delineated courses of action visible to the user and readily accessible. Users will absolutely scroll, if you’ve given them a compelling reason to believe anything of interest lies beneath the fold. Users are fickle types, though, who scan quickly, look for large visual cues, and make an off-the-cuff and perhaps misinformed decision to bounce away from your site in an incredibly short amount of time, if you don’t captivate them instantly. To capture their interest, you simply must pay attention to the content that resides above the fold.

With Google’s release of Browser Size the other day, Tech Crunch mentioned that Google saw a 10% increase in the number of installs of Google Earth, simply by moving the download button up 100 pixels. By placing the call to action and primary focus of the page above the fold, users were far more likely to follow through. Naturally, this will vary from site to site. Amazon.com has a rather long page, which they use to show multiple categories of products they think you’ll be interested in. Their primary feature and what they hope will have the most success is always at the top, though—a compelling enticement to scroll further and see what else they got right.

Understand, this is by no means an argument for cramming everything of any importance above the fold. Not even a little bit. (And I understand that the no-fold site is likely directed at those types—but does anyone actually try to force entire sites above the fold anymore?) Whitespace should be well utilized, large print is totally acceptable, and designers shouldn’t force pages to fit into any idea of a “standard” vertical viewport. CXPartners even argues that including less information above the fold can encourage users to scroll more, arguably by reducing the utility of the site to the point where they’re forced to scroll.

It’s not my claim the no-fold site is implying you should ignore the above-fold design or disregard its design entirely, but the cheeky site title and its assertion that there is NO page fold degrades the importance of how you construct your pages for those first 700 or so pixels. Encourage your users to scroll, not by reducing utility but by increasing interest. Facilitate this behavior by keeping large, blocking horizontal lines and blocks at bay (advice from CXPartners’ piece) and providing clear paths downward. Ensure that users see that additional content exists further down. But don’t forget that your site’s first impression is above the fold.

Browser Size allows you to enter any URL  and see an overlay of visible browser space broken up by user demographics. Specifically, you can see what percentage of the Google-using populous would be able to see what portion of your screen on an initial page load. Apparently, this is based on typical browser dimensions for users, and not screen resolutions outright. (Taking into account non-maximized browsers.)

I understand that Labs products are by their nature not fully baked, but this one lands on the other extreme: half-assed. Perhaps the overlay is a rough attempt at being cheeky, but to me, it’s ugly, and its jagged, hand-drawn lines reduce its utility, rather than amping up its “cute” factor. The percentages aren’t even consistently rendered—it’s like My First Photoshop session here.

This isn’t to say that the concept isn’t a good one. I just wish they let this one cook a bit more before releasing it.

Browser Size | Google Labs via TechCrunch

You can preview the book beforehand and regenerate the notebook as many times as you’d like, though for now, you can’t hand-pick tweets for the notebook. The notebook also appears to only have non-ruled pages much to my chagrin, but it sounds like TweetNotebook is planning on beefing up their offering in the near future if this takes off. For now, they have three different covers available, onto which your current avatar and cover tweet appears. Here’s mine:

Suffice to say, I’ve already bought mine. I think it’s a fun conversation piece, and I think that it’s a fun look into what was relevant to you a few days, weeks, or for some of us, even a year or two ago, in a blurb. It’s almost like thumbing through a diary in a sense, a simple snapshot at the bottom of each page that makes you pause and try to remember what context surrounded that tweet.

We’ve seen Threadless make T-shirts out of great tweets, and I think it’s no stretch to imagine other potential products that can be built out of a users’ Twitter feed. Consider a timeline, complete with tag cloud, friend diagrams, statistics, and more. Twitter lends itself to these sort of changes in medium because of their brevity and relevance—no one’s wearing a shirt with excerpts from their blog on it, but a poster that shows off my activity on Twitter is fun enough even if you’re not a raging narcissist.

For now, there’s also nothing to stop you from using someone else’s tweets, like a celebrity. (Or a friend, for a gift.) That situation may change if copyright issues arise. All told, my order was just $14.50, including shipping to Tempe, Arizona. Here’s hoping they’ll offer different sizes, bindings, and rulings in the future.

TweetNotebook | via TechCrunch

What makes Speed Tracer different?

Developers have long used Firebug to identify what AJAX requests were causing bottlenecks and to analyze responses to those requests. Firebug is an extremely powerful tool and does a serviceable job with this approach, but Speed Tracer takes things one step further, analyzing the “sluggishness” of your application by examining how busy or blocked the UI is in your browser. This can help developers analyze why their application feels slow, instead of simply focusing on network-based bottlenecks.

Speed Tracer makes use of specific, unique APIs built into Webkit for this very purpose, which gives it a unique advantage compared to other profiling tools. Instead of simply guessing and checking, developers will now have full visibility into what’s causing their applications to appear slow:

Using Speed Tracer you are able to get a better picture of where time is being spent in your application. This includes problems caused by JavaScript parsing and execution, layout, CSS style recalculation and selector matching, DOM event handling, network resource loading, timer fires, XMLHttpRequest callbacks, painting, and more.

Very cool stuff. What’s more, it’s free, open source, and available for users of Google Chrome right now. Check out their tutorial below:

Google Speed Tracer

It’s no surprise then that they’d take the time to get surveys right. Netflix (like most companies trying to make a profit) has a need for constant feedback from their customers. They want to know how their distribution system is working, where there may be bottlenecks, and other things like how their new instant streaming service is performing. Instead of producing staid, time-consuming, multi-page affairs, they send an email with a single question.

In my most recent survey, that question read “How was the picture and audio quality?” Simple enough. The real stroke of genius lies in how the user is asked to respond: Three links are displayed, each with a different quality option: “The quality was very good”, acceptable, or unacceptable. You click the link and your survey response is sent. Done. That’s all there is to it.

The survey requires exactly one click to respond to. Users aren’t asked to login, fill out demographic data, attempt to remember details they aren’t likely to, or even read anything to qualify their answer. They are given three relatively unambiguous options and clicking the link from within the email submits their response.

Since not every company has the luxury of being able to boil their customer feedback loop down into simple multiple choice questions, let’s look at a few key points almost anyone can replicate:

1. Keep it simple. Remember that users value their time, and while they may like to let you know what they think of your company and how you’re doing, they may simply not have the time. Focus on a few measurements that can be easily procured and ask just a couple of questions. Consider anything else an imposition for the sake of a casual survey.
2. Don’t require a login. If your users have accounts with you, don’t require them to login to complete their survey. Include a hash tag unique to the individual survey in every call to action link and compile your results from that. Every additional step a user has to complete is another hoop that will encourage them to close their browser and forget about responding. Remember that when you consider adding a confirmation screen, for instance.
3. Provide a call to action. Even if you can’t find a way to boil a survey down into a completely self-contained piece like Netflix does, provide the user with an initial call to action. Have them answer a single question up front, and present the user with an optional means to supply more information based on their response. In the Netflix example, the user might be prompted to explain the issue if they mark the quality as unacceptable.
4. Require as little data entry as possible. This goes back to items one and two: every next step or request for additional information is an opportunity to frustrate your user. In order to ensure the highest quality data, don’t give your users those opportunities to jump ship.
5. Allow users to opt-out or set email frequencies. Don’t abuse users with surveys, or you’ll find they’re no longer users. Provide an unsubscribe link that does the work for them so that they can go back to enjoying your service and so that you don’t frustrate them.
6. Keep the design simple, too. More than just the format of the survey itself, consider paring the design down dramatically. If you’re emailing the survey, the user shouldn’t have to activate images to make a selection. A logo, a border, and some simple elements that tie your corporate color scheme in are acceptable, but making the entire email HTML-based is yet another barrier for users to hit when they may have otherwise completed your survey.
7. Provide context. Users love to know they’re making a difference. While it may seem obvious, just mentioning that you’re issuing the survey as a means of proactively enhancing their experience can go a long way. Feel free to let some personality come through, but don’t forget to keep it simple overall. The less users have to read, the better your response rate will be.
8. Say “thank you.” This may seem like a no-brainer, but since the user will be directed to a page upon clicking your call to action/survey response link, make sure you thank them and provide them with options to navigate back to your site if they so desire.

Even with these tenets in mind, you may find it difficult to break out of the mold and build surveys based around such narrow data points. Consider it an exercise in analyzing what really makes your customers happy and what makes your business tick. Think a bit outside the box and consider: If you can only ask your customers one question about their experience with you, (a multiple-choice at that!) what would it be? Remember that you can rotate questions around of course, but start there.

Finally, if you’re reading this and not sure how to implement this sort of survey system on your own website, by all means please contact us over at Synapse Studios. It’s what we do!

Our company Synapse Studios is hiring a senior PHP developer right now. Specifically, we’re looking for someone who can help lead our talented team and establish methodologies that scale and make for a more powerful team. More information on the position is available here, but you’d be working in our offices in downtown Tempe, Arizona, right on Mill Avenue. It’s a great space with fun people and exciting work, so if you’re interested, view the job post on our site and follow our instructions over there.

Senior PHP Developer Job Posting | Synapse Studios