SEO Werkt!

Monthly subscription services have appeared on our virtual pages countless times already, offering consumers the convenience of home delivery on everything from fresh-pressed juices to tampons to DIY crafting kits. The latest spotting? Mantry, a brand-new Canadian company that aims to be nothing less than “the modern man’s pantry.”

Borrowing a page from Hiskit‘s service delivering curated samples of consumer products targeting men, Mantry promises “a curated selection of items to fit the modern man’s lifestyle, from the rare and exotic to the downright functional,” in the company’s own words. “Break out Norwegian Reindeer Jerky over brews with the boys, or mix in an Oaxacan Hot Chocolate that shows her you’re not some hack that only orders in.” Items come from around the globe and are shipped in full-size quantities, Mantry explains. There’s currently a waiting list to sign up for Mantry and monthly pricing is CAD 38, according to a Huffington Post report.

After years of tracking what our sister site would call “female fever,” it’s been interesting to watch the counterbalancing upswing in products targeting men. Culinary entrepreneurs: be inspired!

Website: www.mantry.com
Contact: kyle@mantry.com

The popular car company, Honda, was not so “sneaky” about leaking a commercial that is bound to go down in the history of Super Bowl commercials as one of the best ever (at least in my opinion!) and they sure were smart about how they did it. The commercial was a play on a super popular 1980’s movie Ferris Bueller’s Day Off that is about a teenager named Ferris Bueller, played by actor Matthew Broderick, who feigns a cold to get a day off from high school. Need I go on? Most likely not because if you are like me, you’ve seen it countless times, can recite lines from memory complete with the deadpan tone of his Economics teacher (“Bueller? . . . Bueller?”), and loved it every time.

Kudos to the Honda advertising team, not only for thinking of this *brilliant* commercial, but for also snagging Matthew Broderick to reprise his role as an adult-like Bueller, and for creating one helluva buzz on the internet to make sure that everyone, and their mother, father (mine included, who actually forwarded me the commercial, although I had already seen it), brother, and sister see this incredible mini-movie before millions of more people see it during the actual Super Bowl. How’d they do it? They simply sent out a newsletter to their entire opted-in email customer base saying “See our ad before 100 million people do” and embedded the extended version (a whopping 2 minutes, 25 seconds) of the commercial in the newsletter and invited people to “share with your friends and family too”.

What was the overall goal for releasing the commercial early and online? While I can’t speak on behalf of Honda, I can always speculate:

1. Possibly they were excited to show off the new CR-V.
2. Possibly they were thrilled with how the commercial turned out and just couldn’t wait to show it off.
3. Possibly they were testing out the effectiveness of internet marketing and wanted to see how fast the buzz about the commercial would spread.

Let’s go with option three because the whole point of making a commercial is to expose it to as many people as possible, right. (Note: no question mark needed in the previous sentence because I wasn’t asking a question, okay).  The beauty of internet marketing is the measurability of outreach. And this commercial certainly “outreached”. The commercial was emailed out 2 days ago. In about 48 hours, I see that the commercial (hosted on YouTube) has been viewed 6,518,483 times, garnering over 23,000 “likes”. Searching on Google for “Honda CRV Super Bowl Commercial” returns 5,880,000 results from the Christian Science Monitor to ABC News to people’s personal blogs and everything in between. The commercial posted on Honda’s Facebook page has 1,170 “likes” and 112 comments. Wow!

I would deem that Honda successfully used the power of the internet to leverage their commercial.  They reached over 6 million people in 2 days, some of whom may not necessarily have seen the commercial otherwise (me included: Super what?). The commercial has been talked about in countless online publications and the video will live forever on the web, available for viewing again and again. And for all the rest of the people that haven’t seen it, they will see it on Super Bowl Sunday. The combination of releasing the commercial early online and airing it on a day when 100 million people are expected to see it on TV, will insure that this commercial makes a lasting impact. Just as the original movie did. Well done, Honda!

Web Marketing Related Posts:

1. Small Businesses: Smart-Up About Your Social Media
2. What’s the Secret to Smart Blogging? Keep it Simple!
3. How Far Would You Go To Win $50 Million?

This guest post is by John Davenport of Phogropathy.com.

It’s been said countless times in the blogging world that in order to be successful we need a plan. But how do we create this plan in a way that will help us reach our goals?

Do we scratch it onto a piece of loose paper?

Do we grab a crayon and write it on a napkin?

Do we create a text doc on a PC and save it in some folder filled with hundreds files?

No. We create a roadmap.

When I first started blogging I had one goal in mind: to grow my audience. I was a nobody (and still I pretty much am a nobody) in this busy world of blogging, but I want to be a somebody, someday. So I created a roadmap to get there. You should too!

Recognizing the problem most new bloggers face

What’s the problem we all face when we start out blogging?

Too many great ideas at once.

We’ve all been there, right? That first idea pops into your head, and then another, and then, oh my, you’re already thinking of redesigning the layout of our blog, but you also have that ebook you want to start, and you’re supposed to have a newsletter out at the end of the month! Your to-do list keeps growing and growing and there’s no end in sight.

Every new blogger who does any amount of research on how to gain blogging knowledge has certainly found themselves here at ProBlogger; the problem is that it’s too good a resource!

Every day there’s a new post telling us to do something with our blog. Maybe what to do if your niche blog fails to make money, or that you should have built a newsletter opt-in box before you published your first post.

Regardless of what we’re learning, these posts always will generate new ideas for us to apply in our own blogs—I mean, that’s what they’re there for, right?

When it comes to planning your blog’s future, we need to put all this information in an organized spreadsheet that we can glance at. This way, we’ll and know exactly what we need to get done in January and what will be done by October.

Creating a roadmap

Organization is probably the most vital skill in the blogging world. You might not have to have all your papers in line and all your photographs in perfectly named folders, but your plans should be organized.

This is precisely where a blogging roadmap will come in handy. You might ask, “John why do I need a roadmap? Won’t a simple to-do list do the same thing?” Here’s my answer.

A roadmap gives you:

1. an organized layout
2. a clear-cut timetable
3. accountability (optional).

Let’s break this down a bit further shall we?

A list is a great way to start your roadmap, but ultimately you’ll want a plan that’s visual. When we have multiple projects spread across many months, if not years, a simple list can become an overwhelming thing to look at. At that scale, it’s definitely not informative.

So, sure, a list can be a great starting point, but at some point it’s necessary to break that list into chunks—I broke mine up by yearly quarters—that reflect the things we want to accomplish in a given timetable. To give you an idea, here’s a screen shot of my 2011 – 2013 roadmap for Phogropathy.com.

What you want to make sure you do when you create your roadmap is to spread things out. You don’t want to have a roadmap that ends next month: you’re building your blog for the future. So let’s make sure we plan things accordingly.

Once your to-do list is in roadmap form, you’ll have a few years of targets planned. Now you’ll be able to visually see how all your blogging efforts fit together and ultimately, that will help lead you to successful growth.

How? The clear-cut timetable gives you the ability to predict when you need to buckle down and get your work done on a specific project. For example, if you want an ebook ready to be published by Q3 of this year, you’d better start the final draft by the end of Q2, and the pre-marketing campaign sometime in early Q3.

I made accountability an optional advantage in the list at the start of this discussion, and that’s mainly because some people like to be more secretive about their overall plans. But if you do choose to publish your roadmap, your readers will know exactly what you’re planning and when these things will take place. This means that you’ll be more likely to meet your deadlines, so that you keep your readers happy. But regardless of whether you share the information or not, with a roadmap, you’re always accountable to yourself.

Planning ahead is key when you’re the only one driving your blog. You don’t want to get lost and you certainly don’t want to drive off a cliff. So make sure you create a blogging roadmap, and never leave home without it.

Do you already work off a blogging roadmap? What’s your major goal for 2012?

John Davenport is an avid amateur photographer and blogger. He shares daily photographs on his blog Phogropathy.com. You can also find him on Facebook and Twitter.

Originally at: Blog Tips at ProBlogger

Feeling Lost? Let a Blogging Roadmap Lead You to Success

One of the things we were led to believe in 2011 was a myth about Steve Jobs being a perfectionist. This myth was given a free pass by everyone from The New Yorker on down.

In reality, his perfectionism, while noted and admired on this blog countless times, was highly selective and limited only to those items, like the shapes of screws and the desire to have no buttons, that captured Jobs’ imagination.

Other things at Apple were not subject to his selective perfectionism.

Take the iOS-to-USB sync cable. Please.

I’m thinking the  Sync Cable Team is to Apple what the Delta Tau Chis are to fraternity row on Animal House. Steve obviously did not care what went on there. Heck, they could have been dropping acid, for all he cared. At least that’s my theory.

How else can one explain why, after manufacturing these cables for a decade, Apple still hasn’t perfected a means to produce them in a way that will make them last longer than a few months without become frayed and cracked?

I currently have three cables that all look like the one pictured above. Well, not exactly like the one above. The one above is the only one I’ve added some duct tape to.

Very frequently in Web development (and programming in general), you need to store a long list of boolean values (yes/no, true/false, checked/unchecked… you get the idea) into something that accepts only strings. Maybe it’s because you want to store them in localStorage or in a cookie, or send them through the body of an HTTP request. I’ve needed to do this countless times.

The last time I stumbled on such a case wasn’t with my own code. It was when Christian Heilmann showed me his then new slide deck, with a cool feature where you could toggle the visibility of individual slides in and out of the presentation. On seeing it, I was impressed. Looking more closely, though, I realized that the checkbox states did not persist after the page reloaded. So, someone could spend a long time carefully tweaking their slides, only to accidentally hit F5 or crash their browser, and then — boom! — all their work would be lost. Christian told me that he was already working on storing the checkbox states in localStorage. Then, naturally, we endlessly debated the storage format. That debate inspired me to write this article, to explore the various approaches in depth.

Using An Array

We have two (reasonable) ways to model our data in an array. One is to store true/false values, like so:

[false, true, true, false, false, true, true]

The other is to store an array of 0s and 1s, like so:

[0, 1, 1, 0, 0, 1, 1]

Whichever solution we go with, we will ultimately have to convert it to a string, and then convert it back to an array when it is read. We have two ways to proceed: either with the old Array#join() (or Array#toString()) and String#split(), or with the fancier JSON.stringify() and JSON.parse().

With the JSON way, the code will be somewhat shorter, although it is the JavaScript equivalent of slicing bread with a chainsaw. The impact on performance doesn’t seem to be significant, but you’d be cutting down browser support quite a bit.

The main drawback of using array-based strings is their size in bytes. If you go with the number method, you would use almost 2 bytes (or characters) per number (or, more precisely, 2N − 1, since you’d need one delimiter per number, except for the last one):

[0, 1, 1, 0, 0, 1, 1].toString().length // 13, for 7 values

So, for 512 numbers, that would be 1023 bytes (or 1 KB). If you go with the boolean method, it’s even worse:

[false, true, true, false, false, true, true].toString().length // 37, also for 7 values

That’s around 5 to 6 characters per value, so 2560 to 3072 bytes for 512 numbers (which is 2.5 to 3 KB). JSON.stringify() even wastes 2 more characters in each case, for the opening and closing brackets, but its advantage is that you get your original value types back with JSON.parse() instead of strings.

Using A String

Using a string saves some space, because no delimiters are involved. For example, if you go with the number approach and store strings like '01001101010111', you are essentially storing one character per value, which is 100% better than the better of the two previous approaches. You can then get the values into an array by using String#split:

'01001101010111'.split(''); // ['0','1','0','0','1','1','0','1','0','1','0','1','1','1']

Or you could just loop over the string using string.charAt(i) — or even the string indexes (string[i]), if you don’t care about older browsers.

Using Bitfields

Did the previous method make you think of binary numbers? It’s not just you. The concept of bitfields is quite popular in other programming languages, but not so much in JavaScript. In a nutshell, bitfields are used to pack a lot of boolean values into the bits of the boolean representation of a number. For example, if you have eight values (true, false, false, true, false, true, true, false), the number would be 10010110 in binary; so, 150 in decimal and 96 in hex. That’s 2 characters instead of 8, so 75% saved. In general, 1 digit in the hex representation corresponds to exactly 4 bits. (That’s because 16 = 24. In general, in a base2n system, you can pack n bits into every base2n digit.) So, we weren’t lucky with that 75%; it’s always that much.

Thus, instead of storing that string as a string and using 1 character per value, we can be smarter and convert it to a (hex) number first. How do we do that? It’s no more than a line of code:

parseInt('10010110', 2).toString(16); // returns '96'

And how do we read it back? That’s just as simple:

parseInt('96', 16).toString(2); // returns  '10010110'

From this point on, we can follow the same process as the previous method to loop over the values and do something useful with them.

Can We Do Better?

In fact, we can! Why convert it to a hex (base 16) number, which uses only 6 of the 26 alphabet letters? The Number#toString() method allows us to go up to base 36 (throwing a RangeError for >= 37), which effectively uses all letters in the alphabet, all the way up to z! This way, we can have a compression of up to 6 characters for 32 values, which means saving up to 81.25% compared to the plain string method! And the code is just as simple:

parseInt( '1001011000', 2).toString(36); // returns 'go' (instead of '258', which would be the hex version)
parseInt('go', 36).toString(2); // returns  '1001011000'

Base 64

The previous method allows us to go up only to base 36. But in modern JavaScript, we can use the methods atob() and btoa() to utilize a base 64 encoding system. That’s 64 = 26, which means we can pack 6 yes/no characters into a single character, saving us 83.3% compared to the plain string method. Let’s look at the code:

atob(parseInt('1001011000', 2)); // returns 'ëM'
parseInt(btoa('ëM')).toString(2) // returns '1001011000'

For some of you, this will be enough. But I can almost hear the more inquisitive minds out there shouting, “But we have 255 symbols, we are still not using strings to their full potential!” And you’d be right. There is a reason why every time you open a binary file in a text editor, you get weird symbols mixed with numbers, uppercase letters, lowercase letters and whatnot. Every character in an ASCII string is a byte (8 bits), which means that if we use the right compression algorithm, we should be able to store 8 yes/no values in it (saving 87.5%).

The problem is that JavaScript doesn’t offer a built-in way to do that, so the code becomes a bit more complicated.

Packing 8 Values Into One Character

You can use String.fromCharCode to get the individual characters. It accepts a numerical value of up to 65,535 and returns a character (and for values greater than that, it returns an empty string). In this case, however, we’re going to use character codes of up to 255 (8 bits).

(Aside: Unicode characters are variable width, so they take up from 1 up to 4 bytes per character. Thus, if you pack your data in characters beyond the first 255, you will be consuming 2 bytes instead of 1, so you might as well have used 2 ASCII characters instead — the file size would be the same. Only if, for some reason, you have a limit that is set in number of (Unicode) characters, then using the full range might be a good idea. But in most cases, the main concern is byte size, so it’s entirely pointless.)

So, we have to split our string into chunks of 8 characters in size. We can do that through .match(/.{1,8}/g). To sum up, the full solution would look like this:

function pack(/* string */ values) {
    var chunks = values.match(/.{1,8}/g), packed = '';
    for (var i=0; i < chunks.length; i++) {
        packed += String.fromCharCode(parseInt(chunks[i], 2));
    }
    return packed;
}

function unpack(/* string */ packed) {
    var values = '';
    for (var i=0; i < packed.length; i++) {
        values += packed.charCodeAt(i).toString(2);
    }
    return values;
}

It wasn’t that hard, was it?

With these few lines of code, you can pack the aforementioned 512 values into — drum roll, please — 64 characters!

Quite an improvement over our original 1 KB (with the array method), isn’t it?

Limitations

Numbers in JavaScript have limits. For the methods discussed here that involve an intermediate state of converting to a number, the limit appears to be 1023 yes/no values, because parseInt('1111…1111', 2) returns Infinity when the number of aces is bigger than 1023. This limit does not apply to the last method, because we’re only converting blocks of bits instead of the whole thing. And, of course, it doesn’t apply to the first two methods (array and string) because they don’t involve packing the values into an integer.

“I Think You Took It A Bit Too Far”

This might be overkill for some cases. But it will definitely come in handy when you want to store a lot of boolean values in any limited space that can only store strings. And no optimization is overkill for things that go through the wire frequently. For example, cookies are sent on every single request, so they should be as tiny as possible. Another use case would be online multiplayer games, for which response times should be lightning-fast, otherwise the games wouldn’t be fun.

And even if this kind of optimization isn’t your thing, I hope you’ve found the thought process and the code involved educational.

(al)

Image on front page created by Ruiwen Chua.

© Lea Verou for Smashing Magazine, 2011.

Talking to My Cats: 03-04-08

Long story short, my middle name was supposed to honor my uncle Sal and my aunt Tanisha. I’d be more comfortable it if the reasoning behind the name was something along the lines of "A Boy Named Sue" by Johnny Cash — something to toughen me up a bit. Alas, my parents didn’t really give it a whole lot of thought (obviously), and by the time they did, it was already on the birth certificate. So I am Bruce Satan Pilgrim.

Thus, throughout my life, I’ve had a bit of a PR problem. I’ve been taunted countless times, endured such sobriquets as Devil Boy, Beelzebubba, Lucy Fur, Satan’s Little Helper, and the Prince of Snarkness.

Carrying the baggage of Mephistoles has made it pretty much impossible to pass myself off as angelic. When my mom declaimed my full name in a certain tone of voice, I knew I was in very big trouble. Each year in grade school, the new teacher would take me aside and warn me that they wouldn’t tolerate any of my tricks. Which I always took as a challenge.

As a teenager, I experimented with using initials as an alternative, but B.S. Pilgrim has its own set of problems. Bruce S. Pilgrim didn’t really ring, either. In my senior year in high school, I briefly embraced the opposite strategy and unsuccessfully campaigned as "Satan for Student Council." This did not go over very well in an all-boys Catholic institution.

Continue reading “My Middle Name is Satan”