Mainstream VP of Technology at Rational Interaction, an interactive marketing agency in Seattle. I blog here about marketing technology, analytics, and the business behind the numbers.

09 April 2011 ~ 0 Comments

Posted in: Uncategorized

Forrester Research just wrapped up the 2011 Marketing Forum, and their outlook on interactive marketing at the big brands is not too positive. Most firms’ internal digital teams are too siloed, too understaffed, and too slow to react to the changing interactive landscape.

Consumers increasingly expect responsiveness from mass marketers across channels. If someone voices a complaint or compliment on Twitter or FaceBook, they expect the brand to engage. And they expect brands to follow them when they go to new channels.

How is a big brand supposed to meet (and exceed!) expectations in this area when manpower is short and every area of digital marketing is competing for corporate attention? The only way is to integrate social responsiveness into every area of your business. Here are four ways your brand can be responsive without breaking the budget.

Follow your customers

You can’t be active in every channel, but need to make sure you’re touching your customers where they are spending their time. Take the time to make sure your market research uncovers what channels your key customer segments are in. How else do you know whether to spend time and money monitoring and responding to Twitter?

It’s not enough to do a search and see how much chatter there is about your brand. The tools out there can go a level deeper than that, teasing out demographics and influence networks so you can quantify the impact of investments in Twitter, YouTube, and other channels.

These trends change quickly, so you should track your audiences at least quarterly. Stay agile, so you can respond to changing attention trends and train your staff in time to sync up with the shifts to new channels.

Good tools to start with include QuantCast and the suite from Visible Technologies. Visible is especially interesting because their offerings go beyond the standard Facebook/Twitter analytics to track conversation on forums and other channels.

Your marketers must be empowered to experiement with new tools and channels. Think of your interactive marketing team as a science lab; constantly forming a new hypothesis and testing it until it either sticks or falls. This means there will be more failures than successes. The key is to fail fast and fail forward.

Acknowledge their pain, and give them an aspirin

Your customers’ experiences with your brand aren’t always going to be perfect. Social media gives you the chance to move the needle on these experiences from negative to neutral to positive.

To do this right, you have to break the customer service team’s shell! A complaint on Twitter is more than a support incident. It’s a chance to cast your brand in a responsive, helpful light.

I encountered an example of this recently when my favorite bakery, Grand Central Bakery, was unexpectedly closed on Presidents’ Day. After blowing off steam on Twitter, I got an unexpected but welcome reply to my tweet-plaint!

Further, easing your customer’s pain is about more than one-on-one interaction. Watch the trends that come from these interactions, and feed it back into the metrics that power your business. It’s the tightest, most valuable feedback loop your company can create, so take advantage of it to improve your products and services.

Amplify their conversations

Your customers are already talking about your brand. They’re tweeting it, posting photos and experiences to their Facebook wall. Many of these conversations are tailor-made to be amplified to your brand’s entire network.

When appropriate, go ahead and repost fan’s conversations to your Facebook wall. Re-tweet like it’s going out of style (it’s not!)

Chobani upped the ante on this approach by retweeting its fans on billboards and even prime-time television ads! They are working through several agencies to do this, but there’s no reason your internal department can’t take this as inspiration.

The producers of the movie Bottle Shock came to us at Rational Interaction for a social media contest, and we couldn’t help but be amazed about how passionately people engaged with the campaign. The winner wrote a beautiful poem and shared it with her network, sparking a chain-reaction of conversations that was the biggest bump for Bottle Shock in the entire campaign.

Taking this approach lets you meld your campaign to focus on consumer-first messaging. Your messages will be less polished and more real. In a media marketplace that’s more crowded by the day, you can’t beat that.

Inform, but don’t invade

Whatever your product or service, there is a wealth of information you can provide that will help your customers make better use of your products, leading to repeat buyers and more referrals. If you’re a food company, give your fans recipes. If they’re wondering how to solve a problem, show them how your product helps.

This works on Twitter, on Facebook, but is even more powerful in deeper channels like online forums.

But be careful! There’s a fine line between helping your customers and “astroturfing!” Every interaction with your customers must be authentic and honest, and your marketers must always disclose their affiliation with your products.

More than that, there are some forums in which corporate marketing just isn’t appropriate. Do you really want drug company reps in your breast cancer support group forum? This is an extreme example but there are many more gray areas here. Wherever you post, keep track of the tone of the responses. You’ll often get some people who aren’t happy to see you, and that’s fine. If the feedback is consistently negative, move on or change your approach.

02 April 2011 ~ 0 Comments

Posted in: Uncategorized

This single-location outdoor ad got people talking around the world. Brilliantly simple; check in on Foursquare  at the Granata Pet dog food billboard and your pooch gets a sample of dog food dispensed in the bowl!

Ingenious integration of outdoor advertising with an engaging online component!

Video:

Via Creativity Online.

23 November 2010 ~ 0 Comments

Posted in: social media

There are as many ways to measure social media as there are social media “experts”. The metrics are different on each channel – a Like is not the same as a Retweet. And each measurement tool takes its own approach. It’s a confusing, fragmented space to understand even if you spend 8 hours a day analyzing social media.

I look at social media metrics in four dimensions. Each dimension is as applicable to Facebook as it is to Twitter, Digg, Foursquare, and every other social media channel out there.

In this series of posts, I’ll explore each of the metrics within these dimensions, dissect how they’re measured, and share my research on the tools that claim to measure them.

Impression Metrics

It’s not about page views anymore. The “social” aspect of social media is where impressions get their value. There’s a big difference between a post from a faceless corporation and a tidbit shared by someone in your network. And as each item is shared, its value and impact increases exponentially.

  • Views
  • Shares
  • Virality

Audience Metrics

These metrics fit the same exponential scale as impression metrics, but are focused on potential impact. To get a great picture of your social media efficacy, measure these over time in conjunction with impression metrics.

  • Audience size
  • Network influence
  • Network effect (influence times size)

Engagement Metrics

You’ve gotten your message out to millions of friends, followers, and their extended networks. But that’s a one-way conversation. Engagement is the beginning of the full circle of social media, when your audience starts coming to you to learn, enjoy, and get ready to buy. Unfortunately for the numbers crowd, engagement is the buckshot of social media. Each network provides a different way to engage, and different audiences engage differently even within the same network.

  • Click-through
  • Likes / Recommendations
  • Comments
  • Ratings
  • Attention
  • and more

Value Metrics

This is where social media really starts to hit the bottom line. The value of social media can be measured much like the web analytics that you’re used to, but you’ll miss a huge part of the picture.

  • Leads
  • Conversions
  • Conversion Value
  • Customer Satisfaction
  • Brand Awareness

06 July 2010 ~ 0 Comments

Posted in: Uncategorized

My hands-on experience with software patents has been limited to ooh-ing and aah-ing over the black obelisks that Microsoft gives to employees who build patent-worthy features. Some people there had a whole platoon of these polished black chunks of granite. I was never involved with a patent filing at Microsoft, although I really envied those awards.
Perhaps that’s why I’ve regarded the software patent discussion as a largely academic matter. But I had to stand up and take notice as I followed the development of the <video> tag in HTML 5.

HTML 5 native video is supposed to be the the knight in shining armor that will unseat Flash as the king of web video. We’re counting on the <video> tag to save us from having to download plugins, bring web and mobile together with common video formats, and end global poverty.

Not going to happen. Back in 2007 the HTML 5 spec recommended a baseline video codec (Theora). The W3C removed it because the big companies (Microsoft, Apple, et al) were too afraid to adopt and distribute the codec due to patent risk. Nevermind that Theora is a free and open source codec with no known patent encumbrances. The mere possibility that there is some potential unknown patent out there was enough to freeze Theora out of the HTML5 spec. No one wanted to be first.

Fast-forward to the present day: There is still no baseline codec that all the big browser companies are comfortable with. HTML5 video is still essentially “coming soon”. The chilling effect of potential “submarine patents”, even for a product that the creators have specifically made free and unencumbered, has frozen innovation in the web video space.

Google has now come forward as the wannabe knight in shining armor by announcing WebM, their royalty-free, unencumbered video format. Chrome and Firefox will support WebM out of the box. Microsoft announced that IE9 will support it, although they won’t be shipping the codec – you’ll have to install it.
Apple has gone their own way, as usual, with no plans to support WebM in Safari, on iOS or on Macs. They claim that potential unknown patents keep them from considering WebM support – so they are keeping all of their eggs in the H.264 basket.

This fragmentation hurts everyone except one party – Adobe.  With all of this noise about H.264 vs. WebM vs. Theora, Flash player is sticking around.  The best solution for now is the status quo – use Flash video players where you can, with special handling for mobile devices that don’t support Flash.

It’s the VHS vs. Betamax war all over again – with no clear choice of a video format that will let us create the best cross-platform user experience, we have no idea whether we can safely dive into pushing forward HTML 5 video capabilities. The format wars are only impeding developers’ efforts to create the next generation of web media experiences.

11 May 2010 ~ 3 Comments

Posted in: Uncategorized

Jakob Nielsen’s team ran a usability study on several iPad applications, and published their preliminary results.

Their user base was a group of 7 experienced iPhone users who were new to the iPad. In other words, 99% of the current iPad install base. They tested an interesting cross-section of iPad apps, including heavy hitters like ABC Player, NYT Editors’ Choice, and IMDb. Also included was Alice in Wonderland from the awesome iPhone/iPad shop Atomic Antelope.

The results are none too surprising – here are the highlights.

The lack of consistency trips up users

The chief stumbling block of iPad usability is the very same thing that makes iPhone and iPad development such a joy. iPad is a fantastic showcase for innovative UI. Everyone who uses the device quickly gets into the experience of touching, flicking, dragging. Pinching has to be learned, but once learned it feels natural. This free-form UI metaphor gives developers a canvas for experimentation and whimsy – and Apple gives them a user base willing to accept it.

The experimental and artistic nature of iPad applications rips to shreds any semblance of UI consistency. Every artist/developer has the opportunity to create a new user experience, which leads to thousands of different solutions to the same problems. Many developers feel the standard UI guidelines are a constraint on their ability to create a unique, immersive experience.

IMDb is a great counterpoint that proves an engaging iPad app can be built with consistent UI.

Immersive UI, begging for exploration, yet once you notice the controls at the bottom, it’s obvious how to navigate through the sections. It would help to lose the useless ‘IMDb’ button at the bottom – it only works in landscape mode – but this is consistent, useful UI.

Discoverability eludes new and experienced users alike

The New York Times Editors’ Choice is one of the first and most popular iPad apps. Pop quiz: How do you move on to the next page of articles in the News section?

You flick the screen to the left. Of course! The only clue on the screen that there is more information to be found is the two dots at the bottom. This summarizes the problem with the majority of iPad apps out there – it is only intuitive once you have randomly stumbled upon the way it works.

Check out the IMDb application again- see the subtle clue on the right that there are more movies in the list? This is a nice hint to flick that list over to the right. How many different ways of hinting at more content do you think you could catalog from the top 100 iPad apps?

Some apps like GoodReader have resorted to a “follow the bouncing ball” method of UI discoverability. You start off in a tutorial mode much like a video game. Your first few experiences in the app are accompanied by alerts and animated arrows that guide you through common tasks. I found it helpful on the first launch, and annoying for a while thereafter until the hints subsided.

Every developer is approaching discoverability in their own way. iPad is a delightful device to learn through exploration. Unfortunately, the things you learn in one app are very rarely applicable to other apps.

Whither Apple’s UI Guidelines?

Every true Apple developer is supposed to live and die by Apple’s Human Interface Guidelines. Even in the Mac Office group at Microsoft, these guidelines were the bible by which we reviewed our interface decisions. Each choice was a tradeoff between consistency with Office for Windows and consistency with other elegantly-designed Mac applications. (Mac-like UI was the automatic winner in a tie.)

The Guidelines for iPad and iPhone are much less prescriptive than the Mac HIG. The Mac guidelines are full of nitty-gritty details such as how to display free disk space and how to layout modal dialog boxes.

The iPad Guidelines are a different story altogether – in the iPad HIG in a big blue <h2> tag is “De-emphasize User Interface Controls”! Apple recommends developers create apps in which the “controls are discoverable, without being conspicuous.” In other words, it’s OK to hide the controls to make a beautiful app.

This is going to leave confusion in the app landscape for quite a while.  GoodReader hides its menus automatically until you touch the center of the screen. ABC Player hides its entire library in landscape mode – you have to rotate the device to see other videos.

As iPad users and developers, we have to vote with our downloads, dollars and code for apps that use standard UI metaphors. Every app

09 May 2009 ~ 0 Comments

Posted in: Uncategorized

I’m working on a Virtual Earth application that uses AJAX to retrieve points of interest and plot them on the map. The long term direction for this application is to move the data source into the cloud, while the front-end web page is hosted onto a customer site.

For the front-end, I’ve been using jQuery, which now supports cross-domain AJAX with JSON  with Padding (JSONP). The back-end is a Windows server with SQL Server 2008.

It’s a bit complicated to get JSONP working with a simple WCF service. Luckily, there’s some sample code on MSDN to do it for you; it’s just not obvious how to take advantage of it.  Here it is in 3 “easy” steps!

  1. Implement and test the WCF service with JSON
  2. Convert the WCF Service to support JSONP
  3. Implement the front end with jQuery

1. Implement and test the WCF service with  JSON

Get that WCF service up and running, returning plain-vanilla JSON. This takes a whole host of variables out of the mix – the database connection, WCF endpoint configuration (ugh), etc. You want to end up with a working WCF service with an interface somewhat like this:

public interface ILocationService 
{
[OperationContract] 
[WebGet(ResponseFormat = WebMessageFormat.Json)] 
Location GetLocation();
}

Test your service with cURL, Fiddler, or another suitable tool.  Before you start with JSONP, you want to be able to call this service on localhost with HTTP GET.

My GetLocation web service returns a current location in JSON, like this:

{“Latitude”: 47.621389,”Longitude”:-122.356660}

2. Convert the WCF Service to support JSONP

The MSDN article JSON with Padding (AJAX) has a link to some sample code that will makes JSONP easy. You have to download the massive sample package (just do it, it’s worth it). Once you have the samples unzipped, find the JSONP project in WCFWFCardSpace\WCF\Extensibility\Ajax\JSONP\CS and grab these four files from the service directory:

  • JSONPBehavior.cs
  • JSONPBindingElement.cs
  • JSONPBindingExtension.cs
  • JSONPEncoderFactory.cs

Add these files to your project. In a future post I’ll dive into how JSONP works and how these files implement it in WCF. For now, let’s just hook your WCF service up to the JSONP interface.

The Interface

The only thing do to in the code is to add the JSONPBehavior attribute to your interface. The example function GetLocation() above becomes the following:

public interface ILocationService
{
[OperationContract] 
[WebGet(ResponseFormat = WebMessageFormat.Json)] 
[JSONPBehavior(callback = "method")] 
Location GetLocation();
}

The (callback = “method”) parameter dictates what query string parameter should be sent in the request URI. We’ll see more about that below.

Configuration

This is where it gets a little hairy.  Getting the configuration right is always the most annoying part of implementing a WCF service. Here’s the system.serviceModel section from my Web.config:

<system.serviceModel>
<behaviors>
<endpointBehaviors>
<behavior name="LocationServiceBehavior">
<webHttp />
</behavior>
</endpointBehaviors>
</behaviors>
<services>
<service name="LocationServiceJSONP.LocationService">
<endpoint address=""
binding="customBinding"
bindingConfiguration="jsonpBinding"
behaviorConfiguration="LocationServiceBehavior"
contract="LocationServiceJSONP.ILocationService">
</endpoint>
</service>
</services>
<bindings>
<customBinding>
<binding name="jsonpBinding" >
<jsonpMessageEncoding />
<httpTransport manualAddressing="true"/>
</binding>
</customBinding>
</bindings>
<extensions>
<bindingElementExtensions>
<add name="jsonpMessageEncoding"
type="Microsoft.Ajax.Samples.JsonpBindingExtension, LocationServiceJSONP,
Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
</bindingElementExtensions>
</extensions>
</system.serviceModel>

Remember the (callback = “method”) parameter in the JSONPBehavior attribute? That’s the key to making sure this works.  To trigger the JSONP behavior, you must put a “method” parameter in the query string with the name of the callback method that will be used to wrap the JSON:

http://yourserver.com/LocationService.svc/GetLocation?method=jsonpCallback

This causes the JSON returned by the service to be wrapped in the callback method you specified:

jsonpCallback( {“Latitude”: 47.621389,”Longitude”:-122.356660} );

3. Implement the front end with jQuery

Finally! It’s time to implement this on the front end. In your web page, make the web service call like this:

$.getJSON(“http://yourserver.com/LocationService.svc/GetLocation?method=?”, callback);

function callback(data) {
 // data is the JSON returned – do whatever you want with it!
 }

The method=? syntax tells jQuery to fill in the “method” parameter with the JSONP callback it generates. The rest is transparent to you – your function gets the unwrapped JSON.

There you go! JSONP lets you do cross-domain web service calls from any web page, as long as the target service supports JSONP.


02 May 2009 ~ 1 Comment

Posted in: Uncategorized
Static analysis is a technique that analyzes the source code (or compiled object code) of your software. Static analysis tools can help you improve your code quality by alerting you to design issues, performance problems, and maintainability constraints.

These tools are designed to be integrated into the development process, and we have baked it into ours.  Team Foundation Server even lets you enforce check-in policy so that code that fails FxCop cannot be checked in. We don’t go that far, but every developer is asked to run code analysis before checking in. It’s a key part of our code review process.

My goal here is not to get developers to blindly change code to make the warnings go away. Rather, each warning that comes up is a change to learn something.

Here is some C# code that will trigger a common warning: Do not cast unnecessarily.

void start_Click(object sender, EventArgs e)
{
   Size controlSize = ((Control)sender).Size;
   RightToLeft rightToLeftValue = ((Control)sender).RightToLeft;
   Control parent = (Control)sender;
}

This code casts the same object variable to Control three times. Casting is slow, so this will have a small negative impact on performance. This can easily be fixed by casting the parameter once and storing it in a local variable.

You may be thinking that this is going to be a negligible speed increase – and you would probably be right in most cases. However, it’s not just about saving those two unnecessary casts. By seeing this warning and learning how to fix it, the developer will think about this in the future as well. The performance boost lives forever!

Here’s another one of my favorites: Do not catch general exception types.

try
{
   outStream = File.Open(outFile, FileMode.Open);
}
catch (Exception e)
{
   Console.WriteLine("Unable to open {0}.", outFile);
}

This is in big bold letters in our coding guidelines document, but it still comes up frequently. The code as written here would catch any exception – even exceptions that have nothing to do with the file operation. It’s important to catch a more specialized exception class – in this case IOException would be a good choice. Wherever this code is in your application, it should only be handling IO-related exceptions.

There is certainly a time and place to catch Exception and other general types of exceptions – and that’s when it’s appropriate to ignore these messages. The important part is that you take the time to decide what is the right time, and discuss it with others on the team.

The most frequent objection to using these tools is the noise level. Admittedly, these tools can produce a lot of warnings, especially when running them on pre-existing code. Make the investment! As you bake it into your process, you’ll build up a list of messages to mark as ignorable, and the signal-to-noise ratio will go up day by day. The payback is two-fold; not only do you get more robust code in the project you’re working on, but it’s another way for your team to learn good development practices.

There are great static analysis tools out there for every platform.   For .Net programmers, it’s built into Visual Studio Team System, or you can download FxCop for free. If you’re on a Java project, Checkstyle is a good place to start. Whichever platform you’re working on, at least give these tools a shot.