Archive: March 2009

You know how when you’re in a relationship, you sometimes just don’t connect with each other? You’re thinking “why don’t they know that their cereal munching is driving me insane?” and the other person is thinking “wow wonder why she’s so grouchy at breakfast”. Wouldn’t it be great if the grouch could just tell the muncher, “look this is what you need to do so that I’ll be all nice at breakfast”.

What does this have to do with marketing? Well, it turns out SMBs are telling marketers how to get their attention, but marketers are just munching away (loudly) on their cereal.

Despite a continued preference among small and medium-sized businesses (SMBs) for receiving information via direct mail and in other traditional ways, major marketers to SMBs are cutting back on these tactics and switching to lower-cost, online marketing to save money.

Or so says Bredin Business Information, who completed two research studies earlier this year, “Marketing to SMBs in 2009″. There’s lots of good info in the studies, reported on today’s Marketing Charts.

In the last few months, I’ve been reminded (several times) that bringing brand and technology together sometimes means creating marketing materials that funnel people to the web sites and interactive tools we spend so much of our time and energy creating.

More often than not, that means conceptualizing, designing, and building banner advertisements that drive people to these web experiences that we’ve shed blood, sweat, and tears over.

Oftentimes, our banners need to compete with a ton of visual distractions. Capturing an Internet user’s attention has become a big challenge. Thus, you need to incorporate the best-possible banner ad designs to make your ads attractive enough to compete for your target audience’s attention.

Obviously, creativity plays a big role in successful banner advertising. Developing that catchy headline, or just the right balance of colors and photography can go a long way towards effectively reaching your target audience.

But, before you can do any of that, it’s important to remember some of fundamental banner design guidelines.

Things to remember:

1. What is the objective? Are the banner ads an exercise in Branding or Conversion?
2. Where are the media placements?
3. What are the site-specific specifications (e.g. unit size, file size (k-size), frames per second (FPS), and maximum animation length)?
4. When in doubt, the Interactive Advertising Bureau (iab.net) is a good place to start.

Tips: 

1. Ask for an action.
2. Know your audience.
3. Keep it simple.
4. Emphasis the benefits, not the features.
5. Optimize source files in native applications.
6. Use words that attract or capture an emotion.

Before you know it, you’ll have created very interesting and effective ads that will drive millions of people to interact and experience the web sites that you’ve poured hours of your time and thinking into.

Late last year, Google announced their intention to create a new technology which would allow a web browser (presumably Chrome) to run native, x86 machine language from the web.  They have recently put out a ‘call to service’ to developers and web enthusiasts to assist in the testing & QA efforts, and ultimately contribute to project.  Obviously, the biggest concern here is security; the ability for a web server to execute native code on your machine is a potential vulnerability.  Microsoft went down this path with Active X in the late 90’s and early 2000’s, and the result was a security disaster.  The hope here is that by virtue of utilizing the open-source model, Google will be able to conquer the same hurdles which buried Active X.

The core of Google’s release is centered around a runtime, a browser plugin, and a set of GCC-based compilation tools.  The idea is that this framework will allow a developer to produce powerful, browser-based applications that can harness the full potential of the client’s CPU, while maintaining portability, neutrality, and security.  This is achieved by incorporating a strict set of rules for writing Native Client modules.  At a high level, these rules specify 1) that all modules meet a set of structural criteria that make it possible to reliably disassemble them into instructions and 2) that modules may not contain certain harmful instruction sequences.  The approach to runtime security is designed around a component called the ‘inner-sandbox’, which prevents unintended interactions between the Native Code module, and the client’s system.  The inner-sandbox uses statistical analysis to detect security defects in an untrusted code-base, and will prevent such code from being executed.

If you are interested in getting involved, please check out the Native Client homepage at http://code.google.com/p/nativeclient/.  This site contains information about how you can help Google, as well as the source code and demo modules for downloading.  In addition, you can check out the Google Code Blog, http://google-code-updates.blogspot.com/2008/12/native-client-technology-for-running.html, for detailed information on the Native Client framework.

Peter Bregman had an epiphany about crowd control during a weekend ski trip. The old slow lift was being underused while the new fast lift was drawing too many patrons. The ski resort launched a campaign that logically explained to skiers that their time would be better spent heading to the slow lift when lines are long. But nothing changed…until the fast lift broke down. From the source:

At first, believe it or not, nothing changed. We all stayed in line! After a few moments, a few people, the ones at the back of the long line, began to move over to the F-lift. Others followed. We went begrudgingly. Annoyed. Complaining. But it was our only choice. So we loaded onto the lift.

Bregman went on to relate this experience to business management:

A company wants all their employees to take everything on their personal hard drives (documents, emails, contacts, etc.) and move them onto a single company-wide shared drive. A sales director wants her people working together instead of individually chasing leads. A manager wants his employees to go to each other instead of him when they have problems.

In each case, they face resistance. People prefer inefficiencies they know over improvements they don’t.

Leaders usually respond the way the mountain did — big signs, marketing campaigns, people shouting in megaphones, rational “what’s in it for you” communications. And they usually get the same result: a brief, blank stare and then back to business as usual.

This idea of limited options can easily be applied to almost anything—call it the In-N-Out Burger effect. Limit the menu, quicken the ordering and production process. Check out the full article published on the Harvard School of Business blog.

I’ve recently been experimenting with a javascript database tool called nextdb.net. NextDB is an open source tool that offers users the ability to build simple databases and store information without ever touching the server. As a small introduction, This is how things have been going so far.

NextDB users begin by making an account. Once logged in, I began by naming and creating a new database and from there I had the option of either building my database from one of three template maps or simply starting from scratch. Since I don’t need much for my testing, I built a table from scratch. The admin interface isn’t much to look at but seems stable enough. Driven by javascript, we can create tables, columns, rows, etc., through a simple GUI. Not many database datatypes are supported (text, date, longinteger, decimal, longbinary), but NextDB is currently an alpha release so we can hope for more to come. As a quick test, I created a “USER” database with three fields; user_id, user_name, and user_pass. Because I am only interested in querying information from the database in this test, I added 5 names to the database again, through the GUI.

Hooking into the newly created database works with stored procedures written in “NextQuery”. The NextQuery scripting language is based off of SQL but I found it annoying at first due to the fact that you have to learn and understand it.

NAME=selectall;
ROW user FROM USER;

This simple stored procedure I’ve named “selectall” and is used to SELECT * FROM USER. You can see the similarity between it and a more common SQL language. The annoyance quickly faded once I got used to the admin query builder. And after combing through the documentation on how to build queries, simple SELECT, UPDATE, INSERT, and DELETE statements became a breeze.

Once I began building my actual website, there were two things necessary to start interacting with NextDB; the NextDBs hosted javascript API (80 KB) and javascript skillz.

var connect = new net.nextdb.Connection("accountname","chat_demo");
var selectAll = new net.nextdb.Query(”selectall”); 

I created a global connection variable (”connect”) that establishes a connection to NextDB and sends over my account name (this was created when I first signed up) along with the database I want to work with, in this case “chat_demo”. The “selectAll” variable creates a new query object and as a parameter, passes over the name of the stored procedure I want to run. The response is my queried data.

connect.executeQuery(selectAll,
function(rows,error) {
if(error) {
net.nextdb.Util.print(error.toString());
} else {
for (var i=0; i < rows[i].length; i++) {
var username = rows[i].user.user_name);
net.nextdb.Util.print(username);
}
}
});

Using my “selectAll” query object, I run a method of my connection object called “executeQuery”. The executeQuery method takes two parameters; the query and a callback function that parses the response of the query.  The callback function will expect a response that will be put into the array “rows” or it will receive an error. As you can see from the statement above, NextDB also offers a class of utilities, one being the Util.print method which creates a nice sort of debugger window for viewing your responses before parsing them.

My simple query is complete and all together, I get this:

var connect = new net.nextdb.Connection("accountname","chat_demo");
var selectAll = new net.nextdb.Query(”selectall”);
connect.executeQuery(selectAll,
function(rows,error) {
if(error) {
net.nextdb.Util.print(error.toString());
} else {
for (var i=0; i < rows.length; i++) {
var username = rows[i].user.user_name;
net.nextdb.Util.print(username);
}
}
});

With my test response, utilizing the print utility, looking like this…

And just like that, I have a working, javascript-driven database. From here, I could remove my print utility and start building off of my rows array.

My overall impression is still a bit phresh and security could pose as a big concern. Because we are constantly making javascript calls to NextDB, sensitive information should be avoided. There is a slight development delay to consider too, due to the fact that a new user needs to learn “NextQuery”.

Other than that, NextDB is winning me over. So far, it’s hella fast and easy to implement. The built in utilities are tight and make testing much easier. According to the docs, you have the ability to relate tables, pass parameters into stored procedures (which may handle some security issues), and all other kinds of fun stuff. I think I’ll continue playing around.

Businesses of all stripes are trying to fit into the social media crowd, thinking that it is a fast and free place to promote.  But pitfalls are abound in this hyper-public world where conversation is king, slip-ups go viral, and posers are quickly marooned. Stephanie Miller wrote a fine article for Email Insider that explains the lessons that social media can learn from email. From the source:

It’s not free. There are plenty of free social media tools out there.  You can certainly set up a MySpace brand page or LinkedIn profile for free.  However, no social media program will succeed without time, resources and expertise.

Be authentic. This is a universal marketing truth, but worth mentioning because too many email and social programs lack it.  Our customers know when they are being sold.  Relevance, honesty, believability, integrity: these are the only things that create value and drive predictable response.

Integrate, don’t imitate. Replicating your website on Facebook does not a compelling and engaging destination make. Posting your email offers on Twitter will quickly tire followers.  Selling product may not be the best objective of your social strategy. Perhaps your blog is about education and driving inquiries. Your MySpace brand community may be about reach for video ads. Twitter may be a great customer service outreach tool.

Have something to say. This is perhaps most important. Don’t start talking until you have something valuable to say. Make the commitment and stick to it. Fund it. Be ready to maintain it.

The big takeaway should be that these channels require an entirely different approach than your other marketing efforts. Read the full article here.

One of the amazing things about working at an agency is the sheer number of emails, IMs, and voicemails you receive per day. We’ve been talking on the blog a lot recently about communication tools, staying productive, and combating interruptions. All great tools and strategies. I’m here to suggest that another answer to confusion, ineffectiveness, and inefficiencies is remembering that how you say something is just as important as what you say. Try putting just a few of the tips below into practice and see what it does to make your communication more effective.

1. Know your subject.

Does your message recipient work well on IM but go dark on email? Do they reply via email to voicemails but never pick up the phone? Know the communication style of the people you’re working with. Don’t assume everyone is tethered to their Blackberry and checking email after hours or on the weekend. Send a message, but if it’s mission-critical, make sure you also give a phone call.

2. Increase click-through.

Create a subject line that means something. My team and I have so many messages floating around with subjects like “Database needed” and “QA progress.” Even adding something as simple as the project name helps the recipient start to understand what brainwave they should be tuning themselves to before even reading the message itself. The subject line “Wells Fargo draft schedule – please review” says much more than “schedule.” And guess what: if you’re replying to or forwarding a message, you have the power to rename the subject. It’s all for the greater good.

3. Say their name, say their name.

Messages should be addressed to a real person. It’s easy and perhaps even socially-acceptable to launch into the body of your message before so much as saying “Dear John.” But people like the sound (sight) of their name. It’s not even vanity. When multiple people are on a message, it’s especially important to clarify to whom the message is directed. If it’s directed the entire team, address it to “All,” before launching into the message. But if there are specific bits of information addressed to individuals within the message, be sure to call out their names.

4. Delete the chatter.

Often in a long string of email, too much unnecessary narrative gets sent around the thread, making it difficult to see the core issues at play and what needs to be done. Feel free to condense the message so that only the pertinent information remains. I often delete extraneous information and include ellipses […] to show that I’ve taken parts out. This helps people focus on the key points. Better yet, follow Tim Ross’s advice and use another means of communication altogether. If you’re discussing options, use an online poll. If you’re compiling documentation, create a wiki. If you’re choosing images, create a lightboard or photo album.

5. Cut the string.

Likewise, if the message is being bounced around, sometimes it means that people aren’t understanding the issue. Resist the urge to punt the message yet again and just pick up the phone or schedule a meeting to work out the issue. Then (and only then) follow up with a message summarizing the resolution.

6. Avoid CC surprise.

Never copy your team member on something that comes as a total surprise to them, especially if it is addressed to a client. Take a moment to get your team member’s opinion or brief them so that they know the news before the client does. CC surprise is the perfect way for your team members to feel blind-sighted and stressed. Avoid it at all costs.

7. Get active.

It might sound like a grammar lesson, but at pain of death, you should avoid the use of passive voice in your communication. What’s passive voice? It’s when the subject receives the action expressed in the verb. Examples include “It was decided,” or “It came to my attention.” You’ve probably seen these in messages in the past and thus know that this technique is pretty effective in obscuring the details and avoiding the background story! It is unclear who did what and more importantly, what needs to be done about it as a result.

In active voice, the subject performs the action expressed in the verb; the subject acts. Usually this makes language more straight-forward and clear. Consider the vagueness of the following passive voice example: “It was decided to go with option B.” But look what happens when you switch to active voice and say who decided to use option B and what that means: “The client decided that they liked the stripes, so please prep option B for production.” Passive voice leaves a lot open to interpretation. Again consider the difference between “The deployment was approved for 5 p.m.” and “Please deploy the website at 5 p.m.” Decide for yourself which method is better-suited for getting the message across.

8. Have an opinion.

Every day we work with people who have great ideas. But when we move from ideas to action, it’s important to no longer hypothesize. Sometimes clients will say “It would be great if. . . [fill in the blank]” when what they really mean is “This thing is broken, or cumbersome, or not what I expected.” Far better to say, “This thing is broken; please scope it.” Saying, “It would be great if the sky was pink,” often leads the recipient to say, “Yeah, that’d be something, wouldn’t it?” But if you say, “I’d like the sky to be pink,” then it’s easier to know to reply, “Well, that would involve these resources and impact the schedule this much.” If multiple options are available, outline them all, but say which one you think is best.

9. Give solution, then details.

Start off your message with the answer so that time-pressed executives can get to the crux of the matter quickly. Then if background details are needed, add them after the outcome. It’s really painful to read a message that gives all gory details of a problem gone awry only to get to the very end of it and read “But it’s fixed now.” Start the message with “We were able to fix the shopping cart issue that we discussed at Monday’s review.” Then if the details are pertinent, add them in after that.

10. Recap.

By the same token, when you give a solution or assign a task in a message (then give the details), be sure to recap what needs to happen. A bulleted list of action items is useful, each having an owner and deadline. Remember the basic composition outline you learned in school: intro, body, summary? Saying it twice helps hit the message home.

***

There are plenty of other good communication tips out there, including this list of email dos and don’ts, written by TechSoup. The fundamental truth is that clear communication can make everyone’s day go more smoothly, help you look good in front of the client, and help your team to be more effective.

In an article published on MarketingProfs, Michael Barr describes how Hyundai has successfully stayed afloat in a sinking industry. From the source:

Hyundai discovered that as the market changed so did their segmentation. Significant numbers of prospects were no longer focusing on gas mileage performance, and they weren’t necessarily looking for more discounts…Hyundai determined that the fear of losing one’s job was a high barrier preventing prospective buyers from purchasing a car.

After defining the segment, the company developed and aligned sales and marketing strategies to reach this new segment. By targeting prospects concerned about job security, Hyundai broadened its audience and increased the number of customers who considered its cars.

Hyundai was one of a few auto makers that posted an increase in sales in January. They took the shakey economy head-on and won. Read the full article here.

Postal addresses are one of the most basic form elements we encounter on the web and not much has been done to change the way they appear on a form since their inception. For most cases this format is functional, but it leaves much to be desired in the way of usability. Their layout is one of the remnants of the offline world that was not fully thought out when ported into the web.

Let’s look at how addresses are formatted in the United States:

Address line 1
Address line 2
City:
State:
Zip/Postal Code

When thinking web, a more usable layout would be to ask for the ZIP code before the state and pre-populate the state based on the ZIP code entered by the user. Ideally it  would have been nice to ask for the ZIP before the city, and then populate both the city and state fields for the user based on the ZIP, but there are some rare instances where a ZIP code can span multiple counties and therefore this does not work.

E.G.:

Source: http://www.zipinfo.com/products/cz/cz.htm

So we face a very common argument. Familiarity with what you are used to versus making the user’s online life easier. Is it worth changing this layout (i.e.: bringing the zip up above the state) to make this form more usable vs. keeping it in this format that everyone is already familiar with and therefore is usable due to familiarity? It is my opinion that the confusion caused by introducing a few approach here outweighs the improvement to the forms usability, so I would keep the traditional format.

It is when you start to make your address form compatible with international addresses that we start to encounter a real need to re-think how the form is presented to the user.

Some countries have addresses that need three address lines versus the two fields that is commonly used in the United States. The United States is one of the few countries that uses state and ZIP. Most others use province and postal code. While it is possible to list the states within the United States in a drop-down, is not possible to do the same for all the countries in the world.

Some sites overcome this problem by having just one input field labeled “State/Province.” While this works, it is not the most user-friendly.

One variation of satisfying both US and International addresses

An input field for the state causes quite a bit of confusion for the user. What does the site expect them to enter? Should they spell the entire state out? Should they enter the two character abbreviation? Will the system accept their entry if they make a spelling mistake or don’t enter it exactly as it’s programmed to accept?

In a traditional address format, the country comes last. This is the root of all our address formatting woes. The country tells us how the rest of the address fields should be formatted and therefore it makes sense to gather this information early on.

I’ve started advocating the collecting of the country early on for addresses in my wireframes and I find that once clients overcome their initial surprise of being asked for the country first they really like how it simplifies their interaction with the rest of the form.

The default selection will be the country of primary focus or where your primary user base is located with the form containing fields for that country. If the user changes the country selection to something else, the rest of the address fields can very easily be changed by either using AJAX or if needed a page refresh, to match the requirements of the selected country. One thing to keep in mind when doing a page refresh is that you should never lose information that a user might have already entered into the form. This is a golden usability rule that when ignored leaves you with some very unhappy users.

In most cases you will not need to have more than two variations to the address field, one that satisfies an international address format and one that satisfies US and Canadian address formats.
Eg:

Proposed US address format

How the form would look when an international address is selected

In computing, a Uniform Resource Locator (URL) is a type of Uniform Resource Identifier (URI) that specifies where an identified resource is available and the mechanism for retrieving it (http://en.wikipedia.org/wiki/URL). In a web application environment, pages and URLs are linked to each other in a database. When you request a page based on the URL, the application should “suggest” a page to load.

What I mean by “suggest” is that if the URL is not linked to an actual page the closest possible match to that URL will be viewed instead. What’s great about this is that when a user is browsing your website they will not get a pesky “404 Page not found” error. Instead they will get an actual page. An example of this is if the user loads the page “http://www.somesite.com/user/IwantContent/“. If “http://www.somesite.com/user/” exists and “http://www.somesite.com/user/IwantContent/” does not exist then “http://www.somesite.com/user/” would be loaded instead. Easy enough.

In MySQL this can be acheived by executing the following query (assuming this table and column exists):

SELECT * FROM {navigation} WHERE url LIKE 'user/' OR url LIKE 'user/IwantContent/' ORDER BY url DESC;

Lets say, “http://www.somesite.com/user/” outputs a list of users and “http://www.somesite.com/user/chris/” outputs some details about the user “chris”. In the previous example redirecting to the user list can be acceptable by most developers but clients could bring up an issue that when a user enters “http://www.somesite.com/user/IwantContent/” they would expect a page saying “User not found” and not the list of users. This is where wild cards could help. Instead of storing a URL with “user/IwantContent/“ in the database we could store “user/%/” instead where “%” is the wild card character being used.

In MySQL this can be acheived by executing the following query:

SELECT * FROM {navigation} WHERE url LIKE 'user/' OR url LIKE 'user/%/' OR url LIKE 'user/IwantContent/' ORDER BY url DESC;

The huge fundamental problem with this query is that using wild cards opens up countless possibilities of queries and results and not to mention a huge performance hit. If we have “http://www.somesite.com/user/chris/blog/” this would extend the where clause to be “url LIKE ‘user/’ OR url LIKE ‘user/%/’ OR url LIKE ‘user/chris/’ OR url LIKE ‘user/%/’ OR url LIKE ‘user/%/blog’ … ” not to mention if we have “http://www.somesite.com/user/chris/blog/URL_Page_Generation/” where “chris” is a user and “URL_Page_Generation” is the blog entry. The thing is “http://www.somesite.com/user/chris/blog/URL_Page_Generation/” logically makes more sense to a user than “http://www.somesite.com/user/blog/chris/URL_Page_Generation/” (putting all the dynamic parts at the end of the URL) and as a developer of course, I want to provide that solution.

The MySQL Solution:

SELECT * FROM {navigation} WHERE 'user/blog/chris/URL_Page_Generation/‘ RLIKE REPLACE(REPLACE(url, ‘%’, ‘.*’), ‘/’, ‘\/’)

The most notable thing from the previous query is “WHERE ‘user/blog/chris/URL_Page_Generation/‘ RLIKE REPLACE(REPLACE(url, ‘%’, ‘.*’), ‘/’, ‘\/’) “. Firstly we need to think about this logic in reverse. Instead of the table URLs stored being the strings to match, that column is turned into a list of expressions. This is why I put the “url” in column in the right operand of the RLIKE operator. RLIKE is used when comparing a value to a regular expression (http://dev.mysql.com/doc/refman/5.1/en/regexp.html) and using REPLACE to change the wild card “%” to “.*” and “/” to “\/” we create a valid expression from “user/%/blog/%/” to “user\/.*\/blog\/.*\/”

With this now you can create a logical menu system that “suggests” a set of pages using only 1 query. Good luck with your “http://www.somesite.com/user/chris/blog/URL_Page_Generation/comment/This_is_Awesome/agree/“.