Choose the Setting Application

Touch the Store Icon

Touch your Apple ID

Touch Sign Out

Important: if you’re doing this to test in-app purchases do not sign in with your test account. You will instead be prompted to sign in during the in-app purchase test.

“A corporate blog is for your corporate story”

This advice not only inspired me to start blogging for our company, but started to bring light to the benefits of blogging with a purpose.  The following list is what convinced me to restart blogging…

• It will help me and our company stay current in our industry,
• It will help our clients understand and optimize their systems,
• It create more information leading to exposure/promotion,
• It will help us understand our clients,
• It will help our client understand what technologies to invest in for greater returns,
• It will communicate our mission & vision,
• It will demonstrate our work process,

…I quickly started to realize the true value of our blog and was uber excited to start building a stronger presence.  Before jumping the gun, lets walk through the blog plan I like to follow these days.

Blog Plan Template

Open an excel spread sheet and create space for 7 columns and as many rows as you’d like (feel free to download our template to save a minute or two).  Label these columns Goals, Audience, Tools, Research, Messages, Timeline, Resources.  And that’s my super fancy template.  I work with this template for a few reasons:

• Excel/Numbers provides a simple way to lay things out with complex functions,
• I can export this data into several formats for reuse,
• I can simply create presentations rich with tables and charts to rally support for my blogging efforts to be.

From time to time I add different variables to this template such as Competition, Services, Networks, etc. to account for more specific needs.  Now you’ve got a blank blog plan sitting on your computer, lets start filling that sucker out.

1. The 3 Goals of Blogging

It’s time to choose the overall goal of your blog.  The three core reasons for creating a blog are generating revenue, building a following and, hobby writing.  Take a moment to ask yourself the following questions:

• Are you going to be advertising on your blog?
• If so, are you promoting your company products/services or are you promoting external products/services?
• What outcome do you need to have a successful blog campaign?

If it’s money your after then chase it hard and setup plenty of sales funnels.  If it’s people you’re after then listen to what they want and cater to their needs.  If you’re the hobby writer, you really won’t need much of a plan unless your a neat freak.  Deciding the goal of your blog will determine how to measure your blogs return on investment.

2. Audience

This is the first column to be filled in and it should be the most simple.  If you don’t exactly know who it is that you’re writing for why not ask your company owner, or your companies marketing team for some advice.  If you’re a sole proprietor or just blogging for the heck of it, I’ve crafted the following questions to ask yourself to help identify your target audience:

• Where does our target audience congregate online?
• What is your target audience looking for? What are their interests?
• What is your target audience talking about?
• What are your target audiences largest problems?
• What are your target audiences biggest success stories?

Answer these questions and record them in your blog plan and start drawing high-level conclusions about what posts will satisfy your readers hunger.  If you’re proper stumped, why don’t you search for blogs in your industry and learn from what they do well, and where they fall short.  Be sure to make note of blog post topics, keywords being used, blog comments, blog features, etc.

Once you understand your market, it’s time to plan the tools you’ll be using to produce blog posts.

3. Tools

This is more a work-flow symantic however the goal here is to build a benchmark sheet for everyone contributing blog posts.  This benchmark should include (but never limit yourself):

• How updates are to be made,
• How to work with your blogging platform,
• What functionality does your blog require?
• Will you be collaborating the development blog posts or will a single person be in-charge?
• Who is responsible for what blog posts?

Again it’s time to list your answers within your blog plan.  Do this with your company in mind so everyone (young and old) can understands how your blog platform works, and how everyone is expected to help.  When it comes to our company, my team is my most valuable asset so we chose that each of us would blog about our interests and area of expertise.  The content (copy) for blog posts are created in Google Docs where any of us can contribute, sharing the load of writing/editing posts.  Speaking features, we’re looking to create a mobile optimized version of our blog, easier navigation for accessing different blog posts, and integrate sales funnels for linking our blog posts directly to services/products RANDOMTYPE offers.   We’re happy with our side-bar offerings such as Last Ten Articles and, Popular Tags but it’s time to listen to our users.

Enough about me… If you’re cozy with the tools you’ll be blogging with, it’s time to figure out how you’ll be preforming research.

4. Research

Solid research makes all the different in properly crafting a blog posts.  To get an idea of what you’ll need to research its time to address the following questions:

• How do your competitors blog?
• What is your target audience hungry for?
• Where does your target audience rely on information from?
• What information does your target audience not receive well?
• What is the source(s) of credible information within your industry?

I like to brainstorm ideas on my own then bringing them to our team, ask for their input.  Be sure to hear out all criticism offered and try to check your ego at the door.  My purpose here isn’t selling my team that I’m coming up with great ways to research information, it’s to show them what makes the most sense to me while seeing if they have anything to further evolve my thoughts.  After talking with my team, I’ll then make any tweaks to the research column within my blog plan and move onto crafting messages.

5. Message

This is going to be the meat and potatoes of your blog.  There is no golden ticket for the messages you communicate in blog posts though there is a strategy behind any great blogger.  When planning blog campaigns I follow a very fluid model where I map out each of the messages I plan to craft throughout a few months (and up to a year) and connect each post with synergies.  Just imagine a huge connect the dot mind map of my posts to come.

For example lets assume I’ll be blogging the following messages:

1. Best blogging platforms,
2. Setting up new features on your blog,
3. How to start a blog plan,
4. Top ten features for blogs.

I’ll take a look at all these blog posts to be and decide what the most logical flow for crafting and releasing these posts would be.  The order I would blog these posts would look as followed:

1. How to start a blog plan,
2. Best blogging platforms,
3. Top ten features for blogs,
4. How to setup new features within your blog.

I chose this order because my readers will first see how to plan, followed with how to start blogging, moving onto popular features, and summed up with how to integrate these features.  If information flows well, and your posts are of quality, you’ll receive well deserved subscribers to your blog.  If your information is scattered, expect varying levels of traffic and varying time spent on your site from users.

Speaking of time, you’re now ready to start putting deadlines to each of your posts.

6. Timeline

In order to meet your blog goals it’s important to tie each of your posts to a timeline.  This is done for a few reasons:

1. To allow your users to understand when they can expect a new post,
2. To keep you accountable for producing new posts and,
3. To keep your blog promoters in sync with when a new post is ready to receive traffic.

At RANDOMTYPE we use Google Calendar to share our timeline for publishing blog articles.  This keeps everyone on the same page while spacing our posts to keep a balance of information flow.

With a timeline for publishing new blog posts you’re ready to lay out the resources at your disposal for blogging.

7. Resources

This is a fairly broad column within your blog plan yet crucial for understanding your approach in creating, publishing and sharing blog posts.  Take a moment to explore the following questions:

1. What section of your blog are you able to post to?
2. What social networking sites will you use to promote your post?
3. Do you have any staff to help you create blog posts?
4. Do you have staff to help market your blog posts?
5. Do you have a budget for out-sourcing the writing for blogs?

Though you don’t need to answer all of these questions, it’s good to know the resources you have at your disposal. Continually planning, writing and marketing blog posts can be a time consuming job which is why it’s a great practice to leverage all resources to accomplish your goal.

Great Success

You’ll now have a more or less complete plan for blogging.  Let this plan be your road map for building your blog and be sure to update it as you start to learn about your users.  A plan like this should be great ammunition to bring to executives in your company to convince them to adopt new, low cost initiatives for communicating with your clients, users and the rest of the world.  As you start blogging remember to keep up with user comments, constantly review your blogs usage metrics and, start talking with the people visiting your blog.

I don’t have time for this!

If you’re too busy around the office, feel free contact us by email or phone to explore how RANDOMTYPE can help you plan and execute your blog campaign.  We don’t mind if you’re experienced or brand new to blogging, we’re friendly folk passionate about most things online!

Feedback

I would love to hear what you have to say about forming blog plans.  Leave a comment, and I’ll get back to you however needed.

If you find yourself repeatedly putting down a technology, then take some time to actually learn and use it. All the jokes and snide remarks aside, Perl is tremendously useful. Ditto for PHP and Java and C++. Who wins, the person who has been slamming Java online for ten years or the author of Minecraft who just used the language and made tens of millions of dollars?

The latter part of this quote strikes close to home. As a partner at RANDOMTYPE I’ve really had to focus on creating value for our company and not just chasing the shiny. As well, the quote also exemplifies a sub-category of cargo-culting. That is, programmers picking on a language because they’ve heard/seen others do it.

That quote is a solid gold nugget. And is also one of the reasons I keep close tabs on Google Webmaster Tools (GWT) for randomtype.ca. So when the site started generating the following results in GWT I started to take notice:

URL               Detail	    Detected
================================================
/blog/listify/    Redirect error    Nov 16, 2011
/tag/html/        Redirect error    Nov 16, 2011
/tag/net/         Redirect error    Nov 16, 2011
/tag/book/        Redirect error    Nov 16, 2011
...

My first thought was that we had made a huge mistake and the site was down. Panic! randomtype.ca was typed manically into the browser… and… and… the page loaded. Phew!

“That’s weird,” I thought “must be an error with Google.” As I’ve proven before, <sarcasm>I’m smarter than Apple</sarcasm>, so I must be smarter than Google! So I left it for a day. But when I came back to check again, I was getting the same results with fresher dates. That concerned me. GWT has a feature called “Fetch as Google Bot” so I tried that. Same results, randomtype.ca was in an infinite loop (redirect error) when fetching via Google Bot.

My next thought was to use curl to see what happened. So I executed the code curl -L http://randomtype.ca the -L switch tells curl to follow redirects. Sure enough it returned the following results:

Running :: curl -L http://randomtype.ca
Results :: curl: (47) Maximum (50) redirects followed

So now I’ve got two sources reporting that there’s an infinite loop of redirects happening. This invalidates the first assumption that something is screwing up at Google and leads me to believe that I’ve made a mistake somewhere. The next step is to look at the headers that curl is returning and compare them to a browser’s headers since the browser is successfully loading the page.

curl -I http://randomtype.ca returns the following:

HTTP/1.1 302 Found
Server: Apache/2.2
Vary: Accept-Encoding
Content-Type: text/html; charset=UTF-8
Date: Fri, 18 Nov 2011 16:56:38 GMT
Location: /
Transfer-Encoding: chunked
Connection: Keep-Alive
Set-Cookie: wptheme8850c883ba7bf80cad64b51b5d039df9=RANDOMTYPE+Inc.; expires=Sun, 19-Feb-2012 16:56:38 GMT; path=/
Set-Cookie: X-Mapping-cffoajmn=B07F1917A2C28FA3759FA175EBC10612; path=/

And firebug:

HTTP/1.1 200 OK
Server: Apache/2.2
Vary: Accept-Encoding
Content-Type: text/html; charset=UTF-8
Content-Encoding: gzip
Date: Fri, 18 Nov 2011 16:53:47 GMT
X-Pingback: http://randomtype.ca/cms/xmlrpc.php
Connection: Keep-Alive
Content-Length: 7565

Hmmm… those are two very different headers. During that time I had been working on our site’s .htaccess file so maybe reducing to the default WordPress .htaccess might fix the issue… But it didn’t, still had the same result, including that cookie line. That started to peak my interest, so I ran another curl query to include saving the cookie.

curl -LIc cookie.tmp http://randomtype.ca which returned:

HTTP/1.1 302 Found
Server: Apache/2.2
Vary: Accept-Encoding
Content-Type: text/html; charset=UTF-8
Date: Fri, 18 Nov 2011 17:10:55 GMT
Location: /
Transfer-Encoding: chunked
Connection: Keep-Alive
Set-Cookie: wptheme8850c883ba7bf80cad64b51b5d039df9=RANDOMTYPE+Inc.; expires=Sun, 19-Feb-2012 17:10:57 GMT; path=/
Set-Cookie: X-Mapping-cffoajmn=451B32BFF54A8789442A5D320937FD91; path=/

HTTP/1.1 200 OK
Server: Apache/2.2
Vary: Accept-Encoding
Content-Type: text/html; charset=UTF-8
Date: Fri, 18 Nov 2011 17:10:57 GMT
X-Pingback: http://randomtype.ca/cms/xmlrpc.php
Transfer-Encoding: chunked
Connection: Keep-Alive

Ahhha! That was it! My investigation into the cookie showed that some of our code for detecting mobile browsers was buggy. And since Google Bot didn’t set the cookie it created an infinite redirect loop. A quick code change and a retest with “Fetch as Google Bot” in GWT confirmed that our code was working.

While it took almost an entire month for those redirect errors to clear out of GWT, we knew that the issue had been solved. Had we not dealt with the issue as swiftly as we did, our entire site may have disappeared off of Google. Clearly not something we’re aiming for!

What is SR&ED

The SR&ED program was created by the Federal Government to bring money to Canadian businesses and entrepreneurs who are pushing the bounds of their industry. Obviously such “thinking outside the box” requires large monetary investments. SR&ED helps companies take those risks by softening the cost via tax credits.

Last year alone the Federal Government gave away $4 billion dollars in tax credits through the SR&ED program. A typical tax credit for a tech startup can see 35 cents on the dollar – which is HUGE! Moreover any size business can apply for SR&ED; there is a cap on how much can be claimed, which is $3 million dollars IIRC. So if you spend $10,000 or $2 million on R&D you can apply for credits. The other great part of the program is that the Federal Government doesn’t cap what they are willing to give away, so like some grants or incentives there’s no money to run out – meaning that if you apply and qualify for the credits you’re going to get them.

In addition to the Federal SR&ED credits there’s also a provincial side of things. Those of us in Alberta are lucky since the Province contributes approximately 10 cents on the dollar. Jason didn’t dive too much into the details here, other than mentioning the credit varies from province to province with some provinces not even providing one.

Finally, IT/Technology/Computer Science all falls under the science section of SR&ED so tech companies can apply to receive the credits.

Who is Eligible?

There are 3 major eligibility criteria that must be met:

1. Have to have a scientific achievement
   • The idea here is to have some type of measurable or metrics that can prove that an achievement was made. For example: We developed an algorithm to sort an array in O(n) which beats the current best O(n log n) algorithm.
2. Have to have an obstacle
   • For this criterion a basic litmus test would be: can I get a company to build this for me easily? Keeping with the sorting algorithm example, you’d be hard pressed to find someone that you could pay to achieve an O(n) sort (except on eLance :P) The nice thing about the obstacle portion of the criteria is that you don’t have to actually overcome the obstacle to claim SR&ED you just have to prove that there was an obstacle for what you were trying to accomplish.
3. Has to have systematic investigation
   • Simply put show that you’ve actually done the work.

To be eligible all 3 criteria must be met and application should be very data heavy with these points. Jason overstated that the adjudicators are looking for intimate details here vs. features. Your customers care about the features, market to them, the government cares about how you achieved the feature.

Eligibility Threshold

Obviously the above begs the question of how is eligibility determined? Jason provided a good rule of thumb: If it takes less than a month to develop – you’re likely not eligible for credits. That gives a pretty good idea of the scope of work being undertaken. Further to this it’s important to know that internal products are less desirable than something that is for sale externally, whether that’s a SaaS, SaaP or product doesn’t matter.

One thing that was hugely interesting was that to qualify for SR&ED tax credits the advancement doesn’t have to be a success. That is, there is no criterion for a successful discovery, which is one of the reasons why failed scientific advancement is still eligible for the credit. I think that’s an awesome part of this policy because the only way you can disqualify yourself is if you don’t try! Whether you’re successful or not doesn’t matter.

Other Tidbits

A couple of other points that don’t fit above:

• Historical documentation is super valuable because it helps you prove the work was done and how long it took to complete.
• Journals, source control commits, emails, basecamp discussions, etc. all fit under the category of historical documentation. Effectively anything with a date or ability to place it within a time frame is game here.
• Obstacles are your friend; iterations are your friend. Doubly so if it’s documentably provable.
• Smoke em if you got em! If you don’t file for your SR&ED credits within 18 months after the company’s yearend you will lose the credits forever.

Take Aways

Overall Jason did a great job of distilling SR&ED into easily digestible information. It was a great presentation, and my take away was that I now know RANDOMTYPE isn’t doing the type of work that would qualify us for a SR&ED tax credit.

With that said, now that I know such a credit exists, our company will certainly be game for tackling harder projects knowing that we could have some of our costs (and thus risk) associated with such an undertaking paid for. Win!

If you’re thinking about tackling an SR&ED proposal definitely give Jason at BDO a call or email. He knew what he was talking about, and he had a technical background to boot, which would certainly make the process easier to undertake.

In code this can be difficult to read and easy to make a mistake with. With Ruby you can run code against a constant string before it gets constantized (“pre-processing”):

NUMBER = '+1 (777) 239-3636'.gsub(/[^0-9+]/, '')
puts NUMBER  #=> +17772393636

This morning we received a notification from Rackspace that one of our clients had exceed the send limit and that their email account had been temporarily disabled. Obviously a problem for our client, so it was time to put on the investigator cap and dig in.

The shutoff notification contained a copy of the email that was being sent out. Written in the email was the following:

Helen Stevens commented on your Wall post.
Helen wrote: “you are full of shit!”

Those are hurt words! The email looked like this:

Yikes! That is a really authentic looking email. Which is what our client was going to send out to some 400+ recipients, which thankfully Rackspace blocked. Now I can’t know for sure, but likely our client received that same email and followed one of the 3 links that appeared on that page. So where do those links go?

Digging into the html behind the email, turns out all the links go to a malicious site that isn’t Facebook (go figure) at the address: http://cefalo.de/neu/neu.html. Here’s the screenshot of that website:

Other than a bad url in the title bar, that website looks like Facebook and there is no fault to be placed on someone that unknowingly enters their email and password into that site. Doing a check on the root of that domain (http://cefalo.de) reveals the following page:

So it’s easy to conclude that the website owner doesn’t know their website has been compromised and is being used to launch phishing attacks (albeit they do now since I sent them an email informing them as much.) The sad thing is that it doesn’t look like this could have been prevented automatically for our client. Doing a check using McAfee’s SiteAdvisor turned up the following sunny report:

This really got me to thinking. Are the tools to detect phishing only re-active? Namely do they require enough potential victims to declare a webpage as unsafe before they’re flagged as such? Or are there any tools out there that are preventative? A couple of ideas come to mind on how that could be accomplished… but that seems like a hard problem – much like spam was back in the day…

The full stack trace was big and ugly:

Grit::GitRuby::Internal::LooseObjectError - size mismatch:
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby/internal/loose.rb:59:in `get_raw_object'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby/internal/loose.rb:32:in `[]'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby/repository.rb:84:in `block in get_raw_object_by_sha1'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby/repository.rb:83:in `each'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby/repository.rb:83:in `get_raw_object_by_sha1'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby/repository.rb:105:in `get_object_by_sha1'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby/repository.rb:155:in `cat_file'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby.rb:27:in `block in cat_file'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby.rb:224:in `block in try_run'
/.rbenv/lib/ruby/1.9.1/timeout.rb:58:in `timeout'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby.rb:223:in `try_run'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/git-ruby.rb:27:in `cat_file'
/.rbenv/lib/ruby/gems/1.9.1/gems/grit-2.4.1/lib/grit/blob.rb:43:in `data'
/.rbenv/lib/ruby/gems/1.9.1/gems/gollum-1.3.1/lib/gollum/page.rb:151:in `raw_data'
/.rbenv/lib/ruby/gems/1.9.1/gems/gollum-1.3.1/lib/gollum/page.rb:160:in `text_data'
/.rbenv/lib/ruby/gems/1.9.1/gems/gollum-1.3.1/lib/gollum/markup.rb:15:in `initialize'
/.rbenv/lib/ruby/gems/1.9.1/gems/gollum-1.3.1/lib/gollum/page.rb:171:in `new'
/.rbenv/lib/ruby/gems/1.9.1/gems/gollum-1.3.1/lib/gollum/page.rb:171:in `formatted_data'
/.rbenv/lib/ruby/gems/1.9.1/gems/gollum-1.3.1/lib/gollum/frontend/app.rb:190:in `show_page_or_file'
/.rbenv/lib/ruby/gems/1.9.1/gems/gollum-1.3.1/lib/gollum/frontend/app.rb:182:in `block in <class:App>'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:1152:in `call'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:1152:in `block in compile!'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:724:in `instance_eval'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:724:in `route_eval'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:708:in `block (2 levels) in route!'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:758:in `block in process_route'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:755:in `catch'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:755:in `process_route'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:707:in `block in route!'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:706:in `each'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:706:in `route!'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:843:in `dispatch!'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:644:in `block in call!'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:808:in `instance_eval'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:808:in `block in invoke'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:808:in `catch'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:808:in `invoke'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:644:in `call!'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:629:in `call'
/.rbenv/lib/ruby/gems/1.9.1/gems/rack-1.3.3/lib/rack/head.rb:9:in `call'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/showexceptions.rb:21:in `call'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:1272:in `block in call'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:1303:in `synchronize'
/.rbenv/lib/ruby/gems/1.9.1/gems/sinatra-1.2.6/lib/sinatra/base.rb:1272:in `call'
/.rbenv/lib/ruby/gems/1.9.1/gems/rack-1.3.3/lib/rack/handler/webrick.rb:59:in `service'
/.rbenv/lib/ruby/1.9.1/webrick/httpserver.rb:111:in `service'
/.rbenv/lib/ruby/1.9.1/webrick/httpserver.rb:70:in `run'
/.rbenv/lib/ruby/1.9.1/webrick/server.rb:183:in `block in start_thread'

Because we have a ton of important information in that repository, if it became corrupt that would be a bad thing! Not being able to rely on an internal system of documentation is a big deal, so I needed to get to the bottom of the issue.

Step 1 – The Googles!

Obviously finding a solution to the problem is much easier, and faster than trying to track it down myself. The first search result on the string Grit::GitRuby::Internal::LooseObjectError - size mismatch turned up the following page: https://github.com/mojombo/grit/issues/65 and the first comment on the issue looked similar to my issue:

This is already fixed in master, installing the current master branch fixes the issue:
https://github.com/mojombo/grit/commit/593f6cae465aa6d4b089cede8dc0cd8c4b5fe6cc

I also opened a ticket for gollum: https://github.com/github/gollum/issues/147

Following that link to the gollum repository I got a bug report about Umlaut (UTF-8) characters causing the issue. That certainly wasn’t my issue since the string that was breaking my repository was this:

* [[Meta-programming in Ruby: It’s All About the Self|http://yehudakatz.com/2009/11/15/metaprogramming-in-ruby-its-all-about-the-self/]]

So what I had was a potential solution for the problem I was experiencing.

Step 2 – Applying the Fix

Now this was a really small fix, and I would prefer not to update Grit until the gollum team pulled the changes into the gollum repository and I also don’t know for sure if this patch was going to solve my issue. So instead I opened up the gem and added the patch myself. You can rake me over the coals later for this unsafe practice if you like.

This last year I took Marc-André Cournoyer’s awesome Owning Rails Course where he taught me about the useful gemedit gem. With gemedit you can open up gem code quickly and easily into your favorite text editor. It’s really a brilliant piece of work for quickly diving into gem code, and allows you to explore, poke, and prod at the code on your box.

So if you don’t have it gem install gemedit will get it installed on your machine. Then you could run the command:

gem edit grit

Whichever editor you have setup in your GEMEDITOR, BUNDLER_EDITOR, VISUAL or EDITOR environment variable will load with a tree of the grit source. I use vim and have nerdtree installed so this works nicely – not sure if it works without nerdtree.

I navigated to lib/grit/git-ruby/internal/loose.rb, and made the 5 changes from length to bytesize which was in the patch referenced earlier. Super easy. Save the document, and the gem has been modified.

At this point I restarted the gollum server so that it could pick up the gem changes. I then pasted in my offending reference to Yehuda Katz, and saved the wiki post. No Error!

And there you have it, a quick and easy application of gemedit, and how it can be used to patch a gem.

class Array
  def listify
    length < 2 ? first.to_s : "#{self[0..-2] * ', '} and #{last}"
  end
end

["dave"].listify
#=> "dave"

["dave", "bill"].listify
#=> "dave and bill"

["dave", "bill", "murray"].listify
#=> "dave, bill, and murray"

Update – Turns out that I didn’t look hard enough in Rails. Rails has a method called to_sentence which accomplishes the same end as noted above. The Rails version is great if you’re working in a Rails environment, or if you want to bring ActiveSupport into your project as a dependency.

Update 2 – Peter Cooper pointed out that my Stunk usage was incorrect for two commas, and added a nice little golf solution. I’ve updated the post to reflect this feedback. Thanks everyone for the constructive criticism!

# BEGIN WordPress
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /

RewriteRule ^index\.php$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]
</IfModule>
# END WordPress

It’s easy to cargo cult this change, and simply paste the code into your own .htaccess file. And I want to make it easy for you to paste that code into your .htaccess. The goal of this post is to examine what the .htaccess rules are doing, and why they’re doing it. With information like that, you can make better decisions around your site. So let’s break this down line by line.

Line 1:

# BEGIN WordPress

It’s a comment. Easy.

And that wraps up this post. Thanks everyone, click the links below to see Part 2, 3, 4, 5, 6 of the series so that we can get more page views and sell more ads!

No wait, that would be a dumb thing to do… so let’s continue instead.

Line 2:

<IfModule mod_rewrite.c>

IfModule is a test that occurs within Apache, and it tests whether the mod_rewrite.c module is included in Apache. If mod_rewrite.c is included the code between <IfModule> and </IfModule> is run. If mod_rewrite.c isn’t included the code within the if statements doesn’t get run.

Line 3:

RewriteEngine On

RewriteEngine On tells Apache to turn on its Rewrite Rules. That’s all there is to this rule. Also, if you want to turn off all of your rules at once set the value to off.

Line 4:

RewriteBase /

RewriteBase is a bit trickier because it affects how your other rules work, and it’s not immediately intuitive how it works.

When a url comes into Apache it looks something like this:
    randomtype.ca/blog/wordpress-htaccess-explained

Before the url hits the rewrite rules, the domain name, and leading slash are stripped from the url:
    blog/wordpress-htaccess-explained

At this point, the url is run through all of the rewrite rules that you’ve specified, and changed accordingly.

Once those steps have been completed, the RewriteBase rule is applied. In the case of WordPress that line is RewriteBase /, so the leading slash is added to the url:
    /blog/wordpress-htaccess-explained

Because the WordPress RewriteBase uses just a forward slash, it doesn’t look like RewriteBase does a whole lot. So let’s expand with an example. Here’s an .htaccess file that has had it’s RewriteBase changed:

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /blog

RewriteRule ^blog/wordpress-htaccess-explained$ post-12.html
</IfModule>

Now if you were to access the url randomtype.ca/blog/wordpress-htaccess-explained, Apache would perform the following steps:

1. Strip the domain, and leading slash and pass the following path to the rewrite rules: blog/wordpress-htaccess-explained
2. Apply the rewrite rules
   • In the example, the single rule matches, and the path becomes post-12.html
3. Apply the RewriteBase rule to the path to create a path of: /blog/post-12.html
   • Apache adds in the forward slash between blog and post-12.html
   • Alternatively, you could write RewriteBase /blog as RewriteBase /blog/ which would accomplish the same thing.
4. Apache then looks for the content at /blog/post-12.html on the file system.
5. Assuming the content is found the url randomtype.ca/blog/wordpress-htaccess-explained serves up the physical file from /blog/post-12.html

It took me awhile to get my head around how RewriteBase works, especially because the apache documentation isn’t crystal clear on that point. You’ll not use it very frequently, but at least now you have an idea of what it does.

Line 5:

Empty – it does nothing – So easy!

Line 6:

RewriteRule ^index\.php$ - [L]

Now we can get to the meat of the .htaccess file – the RewriteRules. This particular rule is easy to understand: if the path is index.php then perform no replacement (that’s what the dash means), and exit out of the apache rewrite loop.

The final part of the rule [L] tells Apache to stop processing any remaining rules.

While this rule may seem silly, hang on to it in the back of your mind, because we’ll come back around to it.

Line 7:

RewriteCond %{REQUEST_FILENAME} !-f

This rewrite conditional uses a couple of special values, %{REQUEST_FILENAME} is a variable based upon the url you request, and !-f is an apache specific extension added to the regular expression language.

Let’s use an example for what the output of %{REQUEST_FILENAME} might look like. Let’s hit the webpage randomtype.ca/test_page.html. Within apache the value of %{REQUEST_FILENAME} gets set to reflect the physical filepath for our request. When I tested this on our servers the value came out like this: /mnt/stor0-wc0-dfw0/123456/randomtype.ca/test_page.html.

The second part of the RewriteCond would typically be a regular expression, however Apache provides some extensions that are being used. The first character – the exclamation mark (!) – is a negation. The second part -f asks whether the test string (in this case %{REQUEST_FILENAME}) exists or not on the file system.

Taken together this RewriteCond makes the following check:

If a file, taken from the variable %{REQUEST_FILENAME} does not exist on the file system, then return true.

Now RewriteCond is a cumulative rule. That is, you can’t just have a RewriteCond, you also have to have a RewriteRule. In this case the next line (Line 8) is another RewriteCond, so what happens then?

What happens is that the two conditions are combined together with a logical AND, and then the RewriteRule is applied when the two conditions are met.

Line 8:

RewriteCond %{REQUEST_FILENAME} !-d

Line 8 is almost identical to Line 7. But instead uses the -d special case, instead of the -f. The -d asks whether the path it is given is a directory or not.

So in plain english:

If a directory, taken from the variable %{REQUEST_FILENAME} does not exist on the file system, then return true.

Line 9:

RewriteRule . /index.php [L]

This rewrite rule says that every request that goes to your website should be rewritten to instead go to /index.php. A little bit greedy huh!? Now of course Line 7 and Line 8 come into play here, and if the conditions aren’t met, then /index.php isn’t used.

Overall, the 3 lines combine to make the plain english statement:

If the variable %{REQUEST_FILENAME} does not exist as a file on the file system and if the variable %{REQUEST_FILENAME} does not exist as a directory on the file system, then send the request to /index.php

So what happens if %{REQUEST_FILENAME} exists on the file system as a directory or file? Well then this rule isn’t applied, and the file is served.

For example when you make a request to the RANDOMTYPE website, the html also tells you to download our favicon with the path: http://randomtype.ca/cms/img/rti-favicon.png. If those two conditionals didn’t exist, then the request would instead be sent to /index.php and you wouldn’t get our favicon.

The cool thing about the WordPress /index.php file is that it picks up what the original url was, and displays a dynamic page for your website. Which is why pretty permalinks work in the first place.

Once again the [L] rule tells apache to stop processing rules.

Now let’s back up the boat a little bit and return to Line 6. What’s the point in having a such a simple rule. Well it turns out that [L] does not stop rule processing, instead Apache skips the remaining rules on its current pass. Then Apache starts another pass from the top of the .htaccess file, and starts reapplying rules. Line 6 exists to pop apache out of that loop, and prevent Line 9 from being re-ran. The exact details can be found here.

Line 10:

</IfModule> simply closes the if statement that was started on Line 2.

Line 11:

Another comment!

And that’s it. A full explanation of the WordPress htaccess file.

And before we get started, if you’re unfamiliar with rbenv, be sure to have a read through the documentation.

Step 1: Install rbenv – Part A

1. From your terminal clone rbenv into /.rbenv

   $ cd /
   $ git clone git://github.com/sstephenson/rbenv.git .rbenv
   

2. Add /.rbenv/bin to your $PATH for access to the rbenv command-line utility.

   $ cd ~
   $ echo 'export PATH="/.rbenv/bin:$PATH"' >> .bash_profile
   

3. Redefine the rbenv installation path – this is the meat and potatoes here:

   $ echo 'export RBENV_ROOT="/.rbenv"' >> .bash_profile
   

4. Setup rbenv to manage the shims directory addition into your $PATH.

   $ echo 'eval "$(rbenv init -)"' >> .bash_profile
   

   => In the case of a server, steps 2-4 would need to be done for any users that need access to the Ruby install.
5. Restart your shell by logging out, and back into the ssh session.
   NOTE: rbenv isn’t completely installed yet, we first need to install a version of Ruby using ruby-build.

Step 2: Install ruby-build

1. Run the following commands in terminal:

   $ cd ~
   $ git clone git://github.com/sstephenson/ruby-build.git
   $ cd ruby-build
   $ ./install.sh
   

2. Remove ruby-build files:

   $ cd ~
   $ rm -r ruby-build/
   

3. Install Ruby 1.9.2:

   $ ruby-build 1.9.2-p290 /.rbenv/versions/1.9.2-p290
   

Step 3: Install rbenv – Part B

1. Rebuild your shims. You should do this any time you install a new Ruby binary (for example, when installing a new Ruby version, or when installing a gem that provides a binary).

   $ rbenv rehash
   

2. Set a global Ruby version

   $ rbenv global 1.9.2-p290
   

3. Verify successful Ruby/rbenv installation:

   $ ruby --version 
   

   If you’ve done everything correctly, this will return 1.9.2

For RubySource I did a 5 part series on switching from .NET to Ruby:

• .NET to Ruby: The Ruby Environment
• .NET to Ruby: Classes
• .NET to Ruby: Methods and Variables
• .NET to Ruby: Namespacing, Naming Conventions, Comments & Documentation
• .NET to Ruby: Types

For yycApps I’ve written the following articles:

• Creating a Keyboard Show Hide Button
• A Review of Broken Kings’ Dirt
• Testing to Touch Success
• Making the iPhone Responsive to a User’s Touch
• How to Build a 2×2 UITableView Grid

As I write more articles elsewhere on the web I’ll link to them from this page. As well, I will continue to write on this blog, so sign up for our RSS feed, or follow @randomtype for tweets on when our articles are posted.