Hooks are places where a developer can fire a function that either performs specific actions or filters/changes the output that gets sent to the user.

The WordPress core effectively eats it’s own dog food. Rather than specifically formatting the output of the_content() inside the function, for instance, the WordPress core adds filters to the_content. This means, of course, that you, as a user/developer are free to unhook those formatting functions and do whatever you want.

The Most Interesting File in WordPress

To see all the actions and filters the WordPress core uses, you needn’t look any further than wp-includes/default-filters.php.

As an example, let’s explore what exactly happens when one uses the the_content(); function. Here’s that function:

<?php
function the_content($more_link_text = null, $stripteaser = false) {
    $content = get_the_content($more_link_text, $stripteaser);
    $content = apply_filters('the_content', $content);
    $content = str_replace(']]>', ']]&gt;', $content);
    echo $content;
}

Most of the WordPress core follows this sort of design pattern: the_something is a wrapper around get_the_something that only echoes out the value (and usually runs it through a filter).

In this case, the line we’re interested in is the apply_filters('the_content', $content);. This tells WordPress to fire the filter hook the_content. Any functions hooked into the_content will fire, receiving the post content as an argument. Now that we know which filter fires, we can go explore the default filters file to see what happens:

<?php
add_filter( 'the_content', 'wptexturize'        );
add_filter( 'the_content', 'convert_smilies'    );
add_filter( 'the_content', 'convert_chars'      );
add_filter( 'the_content', 'wpautop'            );
add_filter( 'the_content', 'shortcode_unautop'  );
add_filter( 'the_content', 'prepend_attachment' );

There are six separate functions hooked into the_content here — there are actually a few more hooked into the_content in other parts of the default filters file. Now that you know what functions are getting fired, you can go and figure out what exactly they do. wptexturize, for instance, converts certain characters into their html entity equivalents.

Why This Matters

Most of the time, how the core uses its own hook system doesn’t matter. But when you want to change WordPress’ default behavior, you are able to. It’s also possible that the filters the core uses may conflict or cause unexpected behavior in your theme or plugin. At that point, it’s up to you to track things down.

Earlier this month Google announced a brand new way to monitor who’s linking to your site, allowing users to view all the backlink URL’s via Google Analytics,

“Have you ever wondered which other pages on the web link to your own? Wouldn’t it be nice to know which sites are talking about your content, and in which context? Well, a problem no more: now you can see all the backlink URL’s, post titles, and more right within the new Social reports.”

Google explains,

“These reports provide another layer of social insight showing which of your content attracts links, and enables you to keep track of conversations across other sites that link to your content. Most website and blog owners had no easy mechanism to do this in the past, but we see it as another important feature for holistic social media reports. When you know what your most linked content is, it is then also much easier to replicate the success and ensure that you are building relationships with those users who actively link to you the most.”

For most, this sounds like a breakthrough.  The ability to analyze your impact on Facebook, Twitter and other social platforms is a valuable tool for any company website or blog.  However, the backlink reports currently lack the right configurations to view aggregated data.  This setup works great for Social Media experts who aren’t too concerned with the ability to segment or filter data but for SEOs who want the truth, keep reading.

A few simple tricks can shift the focus of these reports towards SEO, allowing users to see where links are originating, who’s linking the most and etc.  First, navigate through Analytics in this order: Traffic Sources > Social > Pages.

• Once inside Pages, select a URL and then click on the Activity Stream tab near the top of the page to view the activity for a specific URL.  Click on the Events tab near the middle of the screen to see an event list for that same URL.
• Backlink reports default to a view per page structure – to view all backlinks per site simply click “All” near the top of the screen.  This loads every backlink for the selected time period onto one page.
• Click on the green Trackback arrow (see below) to see a list of all external sites that are linking to that page.  This will filter the Activity Stream to Trackbacks only – listing all of your pages Trackbacks by date.
• To see how many new sites have linked to your website in the last day, go to the Date Range and change the date to Yesterday or choose a custom date.
• Skip the navigation process of monitoring Backlinks by creating a widget on your Dashboard.  Simply follow the previously mentioned steps to arrive at your destination and select Add to Dashboard near the top of the page.

Using these tips and tricks will better allow you to monitor which pages are getting the most links, and hopefully enhance your optimization process thereafter.  I expect we will be seeing more and more additions to this new Social Reports feature in the near distant future!

When Apple released the iPhone 4 with a retina display, and a super high resolution, they converted the default measurement of iOS from Pixels to Points. This made it super easy for native app developers to keep using the old iPhone measurements, with the device scaling up to the new resolution automatically. It was however, created problems for web developers who were building mobile sites. Before, they would only have to put an image src with the image, but now, they have to check the user agent string or use custom CSS/JS, see if the current device is a retina display, and then display a high quality image.

That was ok at the time because mobile sites were still in a baby stage, and web developers could write that code as they developed the mobile site. However, now, with the new Retina Display Macs, a real big problem comes into play. How does Apple handle Pixels vs Points.

I think Apple will keep it inline with iOS, and change the default measurement for applications to points. This would require no change for developers, other than to update their images with a high resolution version for Mac OS X to use. However, with the web, this still creates blurry images. When I first viewed Google on my iPhone 4, the logo looked pixelated, and a bit blurry. With Apple’s Retina Display Macs, that blurriness becomes a problem for the entire web.

Difference Between Retina Images and Standard Images

Applications that were built long ago will now have to pay more development and artists dollars to upgrade their code and images on the website to be retina display ready. Display Media will have to create two versions of ads, one for retina displays, and one without, and when you are talking about creating hundreds of banners, advertising agencies will now have to double that.

Featured Image from Ars Technica

Mr. Miyagi once said, “You trust the quality of what you know, not quantity.”

I like to apply this approach to SEO.  Starting out, you may share many of the same frustrations of Daniel-san as you begin to paint your Title Tags and polish your URLs but with persistence, it won’t be long until you’re kicking SEO butt!  Although learning Excel’s more advanced keyboard shortcuts and functions takes time, with that comes a wealth of knowledge that is sure to double your efficiency as you accumulate valuable functions along the way.

1. Find And Replace

This is a very practical tool that makes updating Title Tags a breeze.  For example, say you have a lengthy list of products where over 200 isolated instances of “Hat” needs to be renamed “Baseball Cap”.  Simply use the keyboard shortcut CTRL+F, or click Edit from the menu bar, and select Find to open the Find and Replace tool.  Where it says, “Find what:” type, “Hat” to select every instance of the word.  Now click Replace and where it says, “Replace with:” type, “Baseball Cap” and click Replace All.  Now you’ve updated over 200 products in only a few short clicks.

Now this,

Excel Find & Replace Step 1

Looks like

Excel Find & Replace Step 2

2. Excel Filtering

The Filter tool functions similarly to the Find and Replace tool; however filtering works better for more invasive editing.  If you have a workbook with thousands of products and you want to edit every product that contains the word “Portable”, simply click on the Product Column, and select the Filter tool.  If you’re using Excel 2011, you should see that your Product Column now has a drop down arrow.  Click on the drop down arrow and the Filter tool appears.  Locate the Filter Method box and select Contains.  Now type “Portable” in the toolbox and HiYa! Every portable product in your inventory is displayed.

3. The Excel Proper Function

This simple little function capitalizes the first letter of each word in the desired cells, which is an important step in developing your Title Tags.  Type “=PROPER” in the desired cell, specifying what cells to affect: “=PROPER(C2)”.  So if Column C requires some capitalization, scoot over to D2 and type “=PROPER(C2)” and apply this function to the remainder of Column D.

4.The Excel Len Function

LEN is handy for a number of reasons, two of which being that LEN displays the number of characters in a cell, making data crunching much easier.  This is particularly useful when working on Title Tags and Meta Descriptions.  To display Column D’s character lengths in Column E, Key in “=LEN(D2)” in E2.  Now column E displays the character length of all your Title Tags.

You want to shoot for less than 70 characters on your Title Tags and less than 156 on Meta otherwise the Black Belts over at Google will surely truncate you.

5. Total Concatenation

The Concatenate Function is the mother of all timesavers.  Think of it as the Karate Kid’s “Crane Kick” that delivers the final blow to win the championship.  In place of tediously keying in our Meta and Title Tags, we will use “=CONCATENATE” to aggregate all of our product information into one cell. So, if Columns A and C are product descriptions and Column D is your Title Tag column, key in “=CONCATENATE(A2,” : “,C2,” | YourCompany.com”).  Depending on your preferences, you may want to modify this function to enhance your Title Tags’ visual aspect.

For such a complicated task it’s a pretty simple function that will save you lots of time.

Congratulations Grasshopper, you’ve earned your White Belt in SEO!

How will this app benefit my audience?

How can I make it pretty enough to keep them interested?

How can I write this app with the least amount of code possible?

Does it need to be able to show different orientations?

Well in this post I’m going to at least answer that last question. You see, employing different UIInterfaceOrientations within your app can have many advantages. One example is for people who prefer typing in Landscape over typing in portrait.

Let’s say you have ten UITextFields in a form that the user is going to have to type a lot of information into. I don’t know about you, but I’m a landscape typer on my iPhone and if it were me, the first thing I do when I see that many UITextFields is flip my phone to the side so I can bust out my information pretty fast. If your app doesn’t have that capability, then personally I don’t care about using it. If I wanted to be forced to type my information into a form in only one way, then I’ll just pull out my computer so I can do it on there. I mean, what’s the point of having a phone with orientation capabilities if I can’t use it?

Well I created an app Project in Xcode 4.3 to show you step by step how to throw multiple UIInterfaceOrientations in your app.

First, you want to open up your app target in Xcode. It should look something like this:

You see, Xcode has lately made this process easier. Before, you had to go into your info tab, find the “custom IOS Target Property” that says “supported interface orientations” and add them in there by yourself but now, we have these nifty buttons that you can press that automatically does that for you. So first, you’re going to want to press each button that you see above that indicates which interface orientations you want your app to support. As you can see, my app supports UIInterfaceOrientationPortrait, UIInterfaceOrientationLandscapeLeft, and UIInterfaceOrientationLandscapeRight.

Next, go to your UIViewController that you want to support different orientations. For this post, I created a BlogViewController instance to show you how to do this with pictures.

In your XIB file, Xcode has an autosizing feature that autosizes any object that you have as the view itself changes. This is what you’re going to want to use for most of your controllers.

Inside of the autosizing box is everything you need to manipulate your objects as your view changes orientations. Each of the arrows when clicked makes your object expand with the screen in whichever direction you press the arrow. For example, clicking the red horizontal arrow causes your object (i.e. your UITextField) to expand as the width of your view expands.

But this is important so pay attention; you see the outside lines that look like H’s? Those are anchors. When you click those anchor lines, your object will anchor to the view on the side of the line you clicked. For example, if you clicked the anchor line on the left and you turn your device from Portrait to Landscape, that object will always retain the same distance from the left side of that view in Landscape as it does in Portrait. Turning off both left and right anchors keeps your object in the middle at all times.

Generally, there are about two methods out of quite a few that you’ll pretty much use all the time when manipulating your objects when you’re switching from UIInterfaceOrientationPortrait to UIInterfaceOrientationLandscape and vice versa. Below, I have a few examples of these methods and also a header file that I created that automatically generates the width and height self’s interface orientation :

First, create your header file that generates the width and height of self interfaceOrientation and import it into each controller’s header file that you want to use it in:

#import <Foundation/Foundation.h>

static float WidthForUIInterfaceOrientation(UIInterfaceOrientation orientation)

{

return (UIInterfaceOrientationIsPortrait(orientation)) ? 320.0 : 480.0;

}

static float HeightForUIInterfaceOrientation(UIInterfaceOrientation orientation)

{

return (UIInterfaceOrientationIsPortrait(orientation)) ? 416.0 : 268.0;

}
<div> 

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation

{

//     In here you're going to want to return YES for all supported orientations. As well, for each UIViewController in a UINavigationController you can limit that view's orientation to whatever you want. In this example, I'm limiting the view to only accept UIInterfaceOrientationPortrait. If your app supports UIInterfaceOrientationUpsideDown, then this line causes your view to accept that as well. If you want it to only accept, for example, UIInterfaceOrientationLandscapeRight, then you'd just replace this line with "return interfaceOrientation == UIInterfaceOrientationLandscapeRight;".

return UIInterfaceOrientationIsPortrait([self interfaceOrientation]);

}

- (void)willAnimateRotationToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation duration:(NSTimeInterval)duration

{

//          In this method, you're going to want to implement code that manipulates your objects <strong>BEFORE </strong>the animation finishes to your new orientation. I have an example below that changes my scroll view's frame according to each orientation.

CGRect blogScrollViewFrame = [blogScrollView frame];

blogScrollViewFrame.size.height = (keyboardIsShowing &amp;&amp; UIInterfaceOrientationIsPortrait(toInterfaceOrientation)) ?                                                   HeightForUIInterfaceOrientation(toInterfaceOrientation) - keyboardPortraitHeight : (keyboardIsShowing &amp;&amp; UIInterfaceOrientationIsLandscape(toInterfaceOrientation)) ? HeightForUIInterfaceOrientation(toInterfaceOrientation) - keyboardLandscapeHeight :                     HeightForUIInterfaceOrientation(toInterfaceOrientation);

blogScrollViewFrame.size.width = WidthForUIInterfaceOrientation(toInterfaceOrientation);

blogScrollViewFrame.origin.y = (UIInterfaceOrientationIsPortrait(toInterfaceOrientation)) ? 44.0 : 32.0;

[UIView animateWithDuration:duration

animations:^{

[blogScrollView setFrame:blogScrollViewFrame];

[blogScrollView setContentSize:scrollArea.frame.size];

} completion:^(BOOL finished) {

float textFieldY = (textFieldReference == addressLine2TextField) ? textFieldReference.frame.origin.y - 34.0 : (!keyboardIsShowing) ? 0.0 : textFieldReference.frame.origin.y - 3.0;

if ((textFieldY &gt; scrollArea.frame.size.height - blogScrollViewFrame.size.height) &amp;&amp; (textFieldY != 0.0)) {

textFieldY = scrollArea.frame.size.height - blogScrollViewFrame.size.height;

}

[blogScrollView setContentOffset:CGPointMake(0.0, textFieldY) animated:TRUE];

}];

}

Basically this is what the result will be:

Now I’ve found a couple of problems with Apple’s rotation system…one thing to look out for is a little quirk with UITabBarControllers. Basically, I’ve noticed that no matter what I do…when you initialize each tab with a UINavigationController as each tab’s respective RootViewController, then when you try to disable only one of the tabs RootViewController’s shouldRotateToInterfaceOrientation methods by returning NO on any supported orientation, then what happens is that the other tabs get disabled as well. As far as I can see, the phone won’t autorotate the tabs as soon as you press any other tab but the one you’re disabling.

I can’t really think of any other problems but hopefully I’ve taught y’all a bit about UIInterfaceOrientations…so with that, I bid thee farewell reader. Until next time!

Happy Coding!

Here’s where the option is in your account campaign settings:

With roughly 7% of impressions coming from misspelled keywords it also means 7% of searches result in undelivered ads. It’s an untapped stream of revenue for Google! So of course, the folks at Google immediately integrated this little feature and ‘secretly’ turned it on for all existing campaigns by default. So if you notice a 7% spike in impressions or clicks, you’ll know why.

The problem is it could lead to budget problems or ROI problems for campaigns that have already been optimized.  You can always turn this new feature off in the campaign settings, but I figured Google would have this option turned off by default once they gave us the option – but that’s not the case.

Here are a few other challenges I see with this new option:

1. Those misspelled keywords that you used to bid on, where no other competition existed before, will now be joined by other competitors.  This also applies to your trademark keywords!
2.  Who gets more preference out of the two settings? Let’s say you’re using the first option to cover misspellings and variations of correctly spelled keywords in your list while a competitor chooses the second option to not include misspellings however they include misspellings in their list. What’s going to happen?  Sounds like it will come down to a bidding war for top spot.

On the other hand, you could get more qualified traffic, you could get more conversions from that traffic, you could also find more exact keyword search queries to add and expand on for your campaign. So I can see why this new matchtype feature can turn out to benefit or be advantageous for some advertisers, I just didn’t like the fact that Google had it turned on by default without letting us do a little testing first.

If your wondering if this option is available in adwords editor (current version 9.7.1), unfortunately it doesn’t exist yet.  So at the moment if you want to change the option for this new misspelling matchtype feature to a few hundred campaigns at once it’s going to be through the web interface where you can enjoy the tedious task of clicking through to each campaign one at a time, changing the settings, and developing a minor case of carpel tunnel syndrome.

It would also be nice if Google gave us an option in their keyword tool to include misspellings.  Currently, the only way to gauge how often a misspelled keyword is being searched for is if you enter in the misspelling it self.

I’m sure we all can agree that a lot can happen in to to three weeks. In fact, in that time I’ve already had a baby, I finished trying to make the Bro Code app to move on to bigger and better things, and I’m already almost to the point where I can write 80% of an iPhone app on my own.

Let’s tackle each thing one by one shall we?

1. I had a baby

Yes, yours truly had his first baby and IT’S A GIRL!!! She is absolutely gorgeous and as of this posting, she is about 6-7 days old and already sleeps through the night. Her name is Brooke Abigail Matos and sad to say, but I may have fallen in love with someone other than my wife.

My Baby Girl

2. I stopped working on the Bro Code app

I know – for all you How I Met Your Mother fans out there, this would’ve been an amazing app to put out but unfortunately, the app was really only created to teach me the basics behind Objective-C and Cocoa. Challenge accepted! And job well done. We can actually put this little guy to rest until I decide to come back to him on my free time.

3. Bigger and better things

So what am I doing now that I laid The Bro Code to rest? Actual work. George reckoned that I should start on another  app for one of our clients that was created by someone else…who’s to argue with the boss?
 
I can’t tell you how many bugs we’ve found so far, and the sheer amount of UI mistakes as well. To say the least, I believe we’re about a third of the way through the app and we have a 6th of the amount of source files he does. The original author repeats hundreds of lines of code even though with Objective-C, it’s pretty easy to condense all of those lines of code with a couple of simple lines of code. For instance, let’s say you wanted to bring up a loading view in certain methods throughout your app when you make a call to the server:
 
Instead of writing this code over and over when you want it to pop up…

UIView *loadingView = [[UIView alloc] initWithFrame:CGRectMake(0.0, 0.0, self.view.frame.size.width, self.view.frame.size.height)];

UILabel *loadingLabel = [[UILabel alloc] initWithFrame:CGRectMake(110.0, (self.view.frame.size.height-46.0)/2.0, 100.0, 21.0)];

UIActivityIndicator *loadingIndicator = [[UIActivityIndicatorView alloc] initWithFrame:CGRectMake(150.0, ((self.view.frame.size.height-(loadingLabel.frame.size.height+25.0))/2.0) + loadingLabel.frame.size.height+5.0, 20.0, 20.0)];

[loadingLabel setBackgroundColor:[UIColor clearColor]];

[loadingLabel setTextAlignment:UITextAlignmentCenter];

[loadingLabel setLineBreakMode:UILineBreakModeWordWrap];

[loadingLabel setNumberOfLines:0];

[loadingView addSubview:loadingLabel];

[loadingView addSubview:loadingIndicator];

[loadingIndicator startAnimating];

[loadingView release];

[loadingLabel release];

[loadingIndicator release];

You can just take the above code, create a UILoadingViewController that is a subclass of UIViewController and implement a couple of methods that do exactly what I wrote above as you write your own code passing certain parameters to change the text, change the color of the loadingView background color, and throw in a couple of typedef enums to create different loadingView styles. Now, every time you have a ViewController that you want to have a loadingView in, you can just change the subclass on that ViewController to your LoadingViewController like this:

#import "yourHeader.h";

@interface YourViewController : LoadingViewController ;

{

}

And every time you want your loadingView to show up, just call whatever boolean method you wrote in your LoadingViewController to have it show up like this:

#import "LoadingViewController.h"

@implementation

- (void)setLoadingViewHidden:(BOOL)isHidden
{
    [loadingView setHidden:isHidden];
}

Call that method…

-(void)viewDidLoad
{
    [self setLoadingViewHidden:FALSE];
}

Now later on, all you have to do is call on line of code as opposed to about fifteen to twenty to call on you loadingView.

Open the Settings Application -> General -> Accessibility -> LED Flash for Alerts -> On

That is it, your iPhone will now blink using the flash when you receive a text message, and receive a phone call. You can customize which applications turn on the blinker using Notification Center.

Loading the Environment

When you fire up xterm or the Terminal.app, Bash looks for one of two files: .bashrc or .bash_profile. On most unix-like systems, including Ubuntu, xterm opens in a “non-login shell”, and non-login shells source (more on this later) .bashrc. Login shells — any shell where you have to type your username and/or password — will load the .bash_profile.

Bash will look for both .bashrc and .bash_profile in your $HOME directory. You can find out what that is like this:

shell$ cd ~
shell$ pwd
/Users/chris

On most linux distros it’s something like /home/[your_user_name]; in OSX it’s /Users/[your_user_name].

Use the Source

Above, the word source was thrown around. This just means read and execute the file. It’s roughly the same as Python’s import or PHP’s require and include. Any code statements in the main body of the file (eg. not inside a function definition) will be executed.

The essential idea of sourcing the .bash_profile or .bashrc file is to set up your environment. You can change whatever you want here — like defining a custom prompt or setting up aliases.

Unfortunately, the same “environment” might not be needed everywhere. Here’s a few examples:

• The EC2 command line tools requires several environment variables. If you manage multiple clients on EC2, they’ll need separate certificate files active in the environment. You’d have to set those up every time you needed to use the EC2 tools.
• Using Python’s virtualenv effectively replaces your current set up with one that uses a specific set of libraries

Enter the `.env` File

If you need to set up different environments, the solution is simple: create a file name .env and put all the things you need to run in it. Source the .env file after entering the directory to set up a directory specific environment.

shell$ cd /path/to/a/dir
shell$ source .env

Piece of cake! But that’s not very fun. Let’s see if we can make it happen automagically when we cd in.

Here’s a little function that checks to see if the file exists then sources it.

function make_env()
{
    if [ -f "$PWD/.env" ]; then
        source "$PWD/.env"
    fi
}

Now, let’s make that function run every time we cd into a directory. We’ll create another function that tries to run the build in cd and, if successful, run the maybe_env function to source the .env file.

function replace_cd()
{
    if builtin cd "$@"; then
        maybe_env
    fi
}

Now we just need to alias cd to run replace_cd

alias cd="replace_cd"

Every time you entire a directory, bash will look for the .env file and and source it if it’s there!

Problems & Improvements

The above works, but it will source the .env file every time you enter the directory. Not a big deal, but not efficient. It should only load the .env if it hasn’t already been loaded. As a way around that, let’s improve the maybe_env function to…

• Check if .env exists
• Check to see if the CURRENT_ENV environment variable is set or if it’s pointed to another .env file and source the current .env file if necessary

function maybe_env()
{
    local env="$PWD/.env"
    if [ -f "$env" ]; then
        if [ -z "$CURRENT_ENV" ]; then
            # no current environment, source .env file
            builtin source "$env"
            export CURRENT_ENV="$env"
        elif [ ! "$CURRENT_ENV" = "$env" ]; then
            # we have a current environment setup
            # the environ we have setup is not this one
            # check to see if we have a deactivate function to run
            if [ "$(type -t deactivate)" = "function" ]; then
                deactivate
            fi
            builtin source "$env"
            export CURRENT_ENV="$env"
        fi
    fi
}

The above will store which .env file is in use and only try to source if CURRENT_ENV isn’t set or is pointed elsewhere. It also attempts to deactivate the old .env file.

There are all sorts of cool things you can when CD’ing into a directory. Like setting up directory specific history or running git status. Settings up a little directory specific environment is just one example.

Leather and lace, serif and script.

One of the most popular trends in design is combining contrasting typefaces. There are a few guidelines to keep in mind if you want to do this well, but showing severe contrast can go a long way in communicating multi-faceted personalities.

An important thing to remember is that you want to use a very legible script, not an overly elaborate one with three-inch curls and super-tight kerning. Use one that doesn’t require squinting or head-tilting. Using a heavy serif font, a slab serif, will provide a canvas for the whimsical script and the result, if you choose your fonts well, can be country-charm or upscale elegance.

This wedding invitation, for example, combines an austere serif with an elegant script with elaborate, but sparingly-used swashes.

Bonnie’s Jams creates old-world charisma with its choice to showcase a simple schoolhouse cursive and using the serif font for the details.

This woman’s design blog shows off her last name and mimics an ink-pen signature. She reserves this script, using it only in the main heading and for blog titles, thus maintaining the legibility and professionalism of her site.