PMA Media Group

Database syncronization woes

Stewie — Wed, 04 Nov 2009 00:00:50 +0000

Database resyncronization depends on what went wrong but the steps below will most likely solve most issues.
Run these commands on the slave database

STOP SLAVE; # stop the Slave I/O threads
RESET SLAVE; # forget about all the relay log files

Then go to the master database and run these

RESET MASTER; # reset the bin log counter and wipe out bin log files
FLUSH TABLES WITH READ LOCK; # flush buffers and LOCK tables
show master status\G

Note what the show master status command returns. You’ll need to know the file name and the position.
You can do one of two things here, make a dump of the entire master database (in which case I suggest you follow this)
or you can just update the tables.
Usually we just need to update the tables so release the lock on the master database tables (UNLOCK TABLES;) and then run this command on the slave database (download maatkit tools here),

cd ~/maatkit-5014/bin && sudo ./mk-table-sync –[print][execute] u=[user],p=[pass],h=[master_host_name] –databases [database_name(s)] localhost

I suggest you run –print before you run –execute. If you run –execute first, you have no idea what just happened. –print will let you know what it’ll do without actually doing anything.
Back to the slave database mysql client, issue these commands,

CHANGE MASTER TO MASTER_LOG_FILE=’[file name from show master status command]‘, MASTER_LOG_POS=[pos];
SLAVE START;

Run this command,

show slave status\G

And check that these aren’t NO or NULL,

Slave_IO_Running: Yes
Slave_SQL_Running: Yes
….
Seconds_Behind_Master: 1634

If things aren’t back to normal, follow the instructions on this website.

Don’t Call it “Case Equality”

Brett Rasmussen — Thu, 30 Jul 2009 17:47:23 +0000

I’ve recently learned to love Ruby’s “triple equals” operator, sometimes referred to as the “case equality operator”. But I stand with Hal Fulton, author of The Ruby Way, in disliking the latter term, since there’s no real equality going on with its usage. It’s also not really an operator–it’s a method–but I’m not going to complain too loudly about that one, considering that I prefer the term “relationship operator”. I’m also not opposed to “trequals”, which has a certain jeunesse doree about it. You could say “trequals” at a trendy restaurant with post-modern decor and everyone wearing black.

With one equals sign you assign a value to a variable:

composer = "Beethoven"

With two equals signs you see if two things are the same thing:

puts "9th Symphony" if melody == "Ode to Joy"

With three equal signs you get, well, essentially you get a placeholder that you can use to define arbitrary relationships between objects which you will mostly never call by hand yourself but which Ruby will call for you when you run case statements:

class Composer
  attr_accessor :works
  def initialize(*works)
    @works = works
  end
 
  def ===(work)
    @works.include?(work)
  end
end

The trequals operator (ok, method) returns true or false depending on a condition I’ve defined. Now I can test a given work against a bunch of composer objects using a case statement:

beethoven = Composer.new("Fur Elise", "Missa Solemnis", "9th Symphony")
mozart = Composer.new("The Magic Flute", "C Minor Mass", "Requiem")
bach = Composer.new("St. Matthew Passion", "Jesu, Joy of Man's Desiring")
 
case "Requiem"
  when beethoven
    process_beethoven_work
  when mozart
    process_mozart_work
  when bach
    process_bach_work
end

The trequals is called behind the scenes by Ruby. Since I’ve defined it on the Composer class to look for a matching entry in that composer’s list of works, the case statement becomes a way of running different code based on which composer wrote the work in question.

This example is contrived, of course, because if it was this simple a need you’d probably just check “some_composer.works.include?(’Requiem’)” by hand. But the example demonstrates the crucial point, that there’s no equality being checked for. A work in no way is the composer. It’s a relationship that the case statement is checking for–the given work was written by the given composer–and it’s a relationship that I’ve defined explicitly for my own music-categorizing purposes.

That case statements work this way is yet another example of the magical and powerful stuff that characterizes Ruby. Instead of simply a strict equality match, we can now switch against multiple types, all with different definitions of what qualifies as a relationship:

class String
  def ===(other_str)
    self.strip[0, other_str.length].downcase == other_str.downcase
  end
end
 
class Array
  def ===(str)
    self.any? {|elem| elem.include?(str)}
  end
end
 
class Fixnum
  def ===(str)
    self == str.to_i
  end
end
 
string_to_test = "99 Monkeys"
case string_to_test
  when "99 monkeys jumping on the bed"
    do_monkey_stuff
  when ["77 Rhinos Jumped", "88 Giraffes Danced", "99 Monkeys Sang"]
    do_animal_behavior_stuff
  when 99
    do_quantity_stuff
  when /^\d+\s+\w+/
     do_regex_stuff
end

Here, if the string to be tested is the first portion of the larger string (case-insensitively speaking), if it is part of any of the elements in the specified array, if it starts out with 99 (string.to_i returns only leading integers), or if it matches the given regular expression, the respective code will be run. In this case, it matches all of them, so only the code for the first case–the string match–will be run (in Ruby, switches automatically stop at the first match, so you don’t need to give each case its own “end” line).

Note that I didn’t need to define (actually, override) the trequals on the regular expression. The relationship operator is a method on Object, so all Ruby objects inherit it. If not overridden, it defaults to a simple double-equals equality check (thus contributing to the momentum of the misnomer “case equality”). But some standard Ruby classes already come with their own definition for trequals. Regexp and Range are the notable examples: Regexp defines it to mean a match on that regular expression, and Range defines it to mean a number that falls somewhere within that range, as such:

num = 77
case num
  when 1..50
    puts "found a lower number"
  when 51..100
    puts "found a higher number"
end

Note that since === is really a method, it is not commutative, meaning you can’t swap sides on the call; “a === b” is not the same as “b === a”. If you think through it, it makes sense. You’re really calling “a.===(b)”. If a is an array, you’re calling a method on Array, which will be defined for Array’s own purposes. If b is a string, and you swapped the order, you’d be calling a String method, which would have a different purpose for its trequals operator, so “b.===(a)” would most likely be something quite different. This concept also means that the variable you’re testing in a case statement is being passed as a parameter to the trequals methods of the various case objects, not the other way around. These two snippets are equivalent:

case "St. Matthew Passion"
  when mozart
    process_mozart_work
end
 
process_mozart_work if mozart === "St. Matthew Passion"

Note that the second snippet was not

process_mozart_work if "St. Matthew Passion" === mozart

It’s also good (although I’m not sure how useful) to know that the relationship operator is used implicitly by Ruby when rescuing errors in a begin-rescue block.

begin
  do_some_stuff
rescue ArgumentError, SyntaxError
  handle_arg_or_syn_error
rescue IOError
  handle_io_error
rescue NoMemoryError
  handle_mem_error
end

In this example, Ruby runs ArgumentError.===, passing it the global variable $!, which holds the most recent error. If that returns false, it moves along, doing the same with SyntaxError, IOError, and NoMemoryError, each in turn. With errors, the trequals is defined to just compare the class of the error that occurred with that of each candidate class (in this case, ArgumentError, etc.) and its ancestors.

It took me a long time before I cared about this little Ruby feature, which I think is sad. I think I just saw the phrase “case equality” and thought something like “Hmm, another subtle variation on what it means for two objects to be equal. I’m sure I’ll have occasion to use this someday. I’ll figure it out then.” But it’s more useful than that, and I think it would get better traction without the specious nomenclature.

Ruby file trimming app

hals — Fri, 17 Jul 2009 22:26:33 +0000

We recently had an interesting experience with very large files. These were comma delimited files (.csv) containing hundreds of thousands of records, each with a dozen or so fields.

e.g.

rec1,field2,,,,,,xxx,fieldn,,,1,2,3,,,fieldx

rec2,field22,,,a,s,d,fieldmore,,,,etc

recn,field2n,,,,ring,,,,ring,1,2,,,hello?,,etc

While testing the setup, we had smaller files to work with. The goal was to create a new file containing only the first field from each record.

e.g.

rec1

rec2

recn

During testing this was easily done by opening the file in a spreadsheet program (such as OpenOffice), which would split the records on the comma delimiter and place each field in a different column. Then, it was easy to select the first column and write it out to the new file.

On switching to production files, we discovered that OpenOffice has a limit of 65k rows – a fraction of what we needed. We then tried some other spreadsheet programs, which produced the same results. We knew there was at least one spreadsheet program that would work, but it was not open source.

At this point the comment was made: “well, we ARE ruby developers …”

And that lead to the following simple solution to the problem at hand.

With a few lines of ruby code, the source files could be read in, line by line, split on the comma delimiter, and the first entry written out to the destination file.

So, when the usual tools just don’t work – remember that a new ruby tool might be just around the corner.

#!/usr/bin/ruby

# trimfile.rb

require “rubygems”

require “ruby-debug”

class Trimfile

attr_accessor :fileName, :newFile

def initialize(fileName, newFile)

puts “\nSplit off first comma delimited item of each line.”

@fnam = fileName

if @fnam == nil then @fnam = “trimin.txt” end

@newfnam = newFile

if @newfnam == nil then @newfnam = “trimout.txt” end

linecount = 0

puts “\nFilenames – input: #{@fnam}, output: #{@newfnam}”

aFile = File.new(@newfnam, “w”)

IO.foreach(@fnam) do |line|

aFile.puts line.split(‘,’)[0]

linecount += 1

end

aFile.close

puts “\nTotal lines: #{linecount}”

end

test = Trimfile.new(ARGV[0], ARGV[1])

Working with Git

Stewie — Fri, 19 Jun 2009 23:34:48 +0000

This tutorial covers all the commands (hopefully) we’ll need for the projects we build here at PMA. If there’s anything that needs to be added to it, feel free to comment.

Starting with the basics, we’ll first cover retrieving a project:

git clone [repository]

This will get the currently active branch from the repository

Obviously you’ll want to do something with this newly retrieved working copy of the project. Let’s first create a branch for the new features/bug fixes we’ll be coding.

git checkout -b [newbranchname] origin

Ok, so we got a new branch. While we’re coding, it’s a good idea to commit tons of times to preserve the changes we’ve just made. Don’t worry about the log, we’ll make it pretty later. Just commit often.

git add [filename(s)]
git commit

If it’s a small change that doesn’t require much explanation, you can use these commands

git add *
git commit -m "The commit message"

Or, even shorter

git commit -a -m "The commit message"

You finished that feature so now it’s time to merge that branch with the master branch (or some other branch depending on what VCS (Version Control System) paradigm you/your team chose). First, you should make those hard-to-read commits less hard-to-read. Let’s rebase!
Please note that if you rebase after pushing to the repository, you will create problems for those pulling from that repository. Rebase changes the history of the project. Your teammates merges will not be fast-forward[able]. It won’t be pretty, trust me.

git rebase -i HEAD~[number of commits back]

You’ll now be looking at something similar to this:

pick ce86448 A random commit
pick a8564a9 Another random commit

How you order things in this editor will affect the order of the commits. Note that merge commits are not shown here. They aren’t editable.
Replacing “pick” with “edit” will allow you to edit the changes you made as well as the commit message.
After you’ve edited the files you wanted to edit, you can now

git add *

then

git commit --amend

and move on.

As I mentioned before, you have the opportunity to clean up the mess you made with all those many commits using the rebase option. Here’s how:

Run the
```
git rebase -i HEAD~[x]
```
command from earlier

Replace “pick” with “squash” on the commit you want to be combined with one exactly previous to it.

pick ace72dd I squashed these commits. I'm cool.
squash e99fd59 This commit will be sqaushed with the one above it
pick d0770e8 commited again
pick af845d0 I'm really committed

Pretty straight forward and easy. Everyone loves rebasing
If you want to know more about git-rebase, I recommend checking it out here.

Now, you’ve made all these changes and everything looks great. What are you gonna call this pretty new feature? Are you gonna tag it? I would..

git tag -a [fancy_feature] -m "A fancy message for a fancy feature"

If you happen to leave out the -m, git will open an editor and you’ll be able to add your fancy message there, just like with commit!
Read more about tags here.
One scenario for using tags could be that, within a project, one wants to keep track of versions. Each commit could be tagged with a version number like with bug fixes in some VCSs. If something goes wrong, it’s really simple to go back to a previous version using git rebase, as we’ve already shown.

You’ve squashed those ugly commits, changed the commit message(s), and tagged everything. Time to merge. Switch to the master branch (or whatever branch you’re wanting to merge with) and type this command which will merge [branchname] with the current branch:

git merge [branchname]

You’ll probably want to fix any conflicts and continue with the merge.
It’s now safe to delete [branchname] because all the changes from that branch are now on the current one.

git branch -d [branchname]

This next feature is pretty neat. Say you’ve done a bunch of changes that haven’t been committed yet and you realize you aren’t on a feature branch. Here’s what you do:

git stash
git stash branch [newbranchname]

This will stash away all uncommitted changes, create a new branch and check it out, then unstash all your stashed changes into that new branch. Awesome

Stash is also useful in scenarios where you don’t want to commit yet but you need to switch to a different branch and do something. You could stash the current changes using the above git stash command, do the needed changes, then switch back to the branch you were working on and use this command to unstash the changes:

git stash apply

It’s a good idea to check out the other things offered by git stash (git-stash)

To get this new branch into the origin repository, do:

git push origin [branchname]

To delete a branch from the origin repository, do:

git push origin :[branchname]

Don’t forget the colon!

Another scenario; your co-worker does some work on a feature and gets stuck. You don’t want to type on their computer cause yours is set up just the way you want it. Is there a solution to this quandary? Yeah. There is…
Tell them to push their changes then do this:

git fetch origin [remotebranchname]:[localbranchname]

You now have the branch they were working on locally and can modify to your hearts content.

Noteworthy Notes

There’s a difference between

git pull

and

git fetch

The difference is that “git pull” will run a “git fetch” then a “git merge” to merge the retrieved head into the current branch.

git log -p path/to/file.rb

This command will show the history of a specific file;

git blame path/to/file.rb

will go line by line in a file and give a short description + the name of the person that changed the line last (brilliant, actually)

From the Git manual

check it out
A few configuration variables (see git-config(1)) can make it easy to push both branches to your public tree. (See the section called “Setting up a public repository”.)

$ cat &gt;&gt; .git/config &lt;
      [remote "mytree"]
           url =  master.kernel.org:/pub/scm/linux/kernel/git/aegl/linux-2.6.git
           push = release
           push = test
EOF

Then you can push both the test and release trees using git-push(1):

git push mytree

or push just one of the test and release branches using:

git push mytree test

git push mytree release

To rebase your current working tree to obtain the changes from the master tree,
Suppose that you create a branch “mywork” on a remote-tracking branch “origin”, and create some commits on top of it:

git checkout -b mywork origin
$vi file.txt
$ git commit
$ vi otherfile.txt
$ git commit

…
You have performed no merges into mywork, so it is just a simple linear sequence of patches on top of “origin”:
o–o–o <-- origin
\
o--o--o <-- mywork
Some more interesting work has been done in the upstream project, and "origin" has advanced:
o--o--O--o--o--o <-- origin
\
a--b--c <-- mywork
At this point, you could use "pull" to merge your changes back in; the result would create a new merge commit, like this:
o--o--O--o--o--o <-- origin
\ \
a--b--c--m <-- mywork
However, if you prefer to keep the history in mywork a simple series of commits without any merges, you may instead choose to use git-rebase(1):

$ git checkout mywork
$ git rebase origin

This will remove each of your commits from mywork, temporarily saving them as patches (in a directory named “.git/rebase-apply”), update mywork to point at the latest version of origin, then apply each of the saved patches to the new mywork. The result will look like:
o–o–O–o–o–o <-- origin
\
a'--b'--c' <-- mywork
In the process, it may discover conflicts. In that case it will stop and allow you to fix the conflicts; after fixing conflicts, use git add to update the index with those contents, and then, instead of running git commit, just run

$ git rebase --continue

and git will continue applying the rest of the patches.
At any point you may use the —abort option to abort this process and return mywork to the state it had before you started the rebase:

The commands

Here’s a list of all commands covered in this tutorial:
git-clone
git-checkout
git-add
git-commit
git-rebase
git-tag
git-merge
git-branch
git-stash
git-push
git-pull
git-fetch

Asynchronous Processing with Workling and Starling

jarodr — Thu, 18 Jun 2009 14:40:10 +0000

When working with applications whose actions may take some time to complete, it may be better to handle the request asynchronously. A quick and easy way to do this is using Starling and Workling. Starling is a light weight message queue based on the Memcache protocol, and Workling is a simple, lightweight consumer. Setup is dead simple:

First, install Starling:

 sudo gem install starling

This will install Starling and it’s dependencies (memcache-client and eventmachine) if you don’t already have them.

Now install Workling. This doesn’t have a gemspec so we will install it as a plugin:

cd ~/path_to_your_project
script/plugin install git://github.com/purzelrakete/workling.git

Finally, tell Workling, which will want to use Spawn by default if it is installed on your machine, to use Starling by placing this in your environment.rb:

Workling::Remote.dispatcher = Workling::Remote::Runners::StarlingRunner.new

That is it for the installation process! Easy. Now for actually handling requests. Believe it or not, it is just as simple as the installation. Say you have a controller that has to do several long running tasks:

class SkinnyController < ActionController::Base
 
  def fat_action
    .. do some crazy stuff that takes a few minutes ..
  end
 
end

Now typically, you should avoid doing things that take longer than a few seconds to complete. And this is okay for most application requirements, however in some cases, it is inevitable that a few tasks will take much longer, such as above. That is where Workling comes in. Simply refactor the code into a worker (conveniently located in app/workers):

# app/workers/fat_worker.rb
class FatWorker < Workling::Base
 
  # this method can be named anything you want
  def do_work(*args)
    .. you get the picture ..
  end
end

Now, in your controller, call the worker:

class SkinnyController < ActionController::Base
 
  def fat_action
    FatWorker.asynch_do_work(some_args)
  end
 
end

Just start up starling and workling (starling start, and script/workling_client start respectively) And that is all. You can now handle large tasks asynchronously, and because the tasks are queued with starling, the action can be called multiple times, and it will queue up the worker and process it as soon as the previous tasks are complete.

The Scan() Method for Regular Expressions

Chris Gunnels — Tue, 16 Jun 2009 19:59:36 +0000

As I was writing a simple script to display the education I received from reading The Ruby Way 2nd Edition chapters 2 and 3, I found a really neat method that helped me complete my task. If you didn’t read the title of this blog post then your out of luck, but if you read the title then you will know that I am talking about the scan() method.

Back to my script, since I wanted to find the number of occurrences white space showed up in a given string I had to come up with a way to count white space. My first thought was to do some regular expression matching. Well after a little thought and a lot of reading, I found a this:

answer = params[:string].scan(/(\s)/) puts answer.size
Here’s a little breakdown of whats happening for those that don’t know.

GIVEN: params is a hash with the values that were posted via a form.
Line 1: we are running the scan method on params[:string] which the value is a string. Then we pass scan method a regular expression that looks for any white space. Then the value of that is assigned to the local answer variable.
Line 2: we print the answer’s size.

Advanced Routing Wireless To Your LAN With Cisco WRT400N

Aaron Murphy — Wed, 10 Jun 2009 23:16:28 +0000

Advanced routing wireless to LAN with the Cisco WRT400N router is simple, once you know how. Just do the basic setup on the router as usual, only disable the DHCP server. Then go to the Advaned Routing page and disable NAT and enable Dynamic Routing. Now you can connect a local network to one of the four LAN ports. Don’t use the WAN port as the Internet connection will go through your main LAN.

Setting PowerDNS To Ignore Records For Downed Web Sites

Aaron Murphy — Wed, 10 Jun 2009 23:15:03 +0000

If you are using PowerDNS for round robin on multiple websites, you can set it up so that it will return only the records for sites that are up. I set up a Ruby daemon to monitor sites and connect to the PowerDNS MySQL table used by PowerDNS on Rails. You can use any language or system you like. It just needs to be able to access your PowerDNS database.

First add the following line to /etc/powerdns/pdns.conf:

 gmysql-any-query=select content,ttl,prio,type,domain_id,name from records where name='%s' and (prio<>-1 or prio is null)

Thats the trickiest part. If you mess up on the sql query, PowerDNS may not return any results for your domain.
Then restart pdns. I use CentOS so I type

service pdns restart

Now you just need a daemon to monitor your websites. Something like the following might work for you:

#!/usr/bin/env ruby
require 'net/http'
require 'rubygems'
require 'activerecord'
 
SITE_ADDRESSES = %w( www.yourdomain.com www.example.com )
SITE_THAT_IS_ALWAYS_UP = "" # some well known site that is always up
 
class Record < ActiveRecord::Base
  ActiveRecord::Base.establish_connection(:adapter => "mysql",
    :encoding => "utf8", :database => "powerdns_production",
    :username => "your_mysql_username", :password => "your_secret_password_here",
    :host => "ns1.your_isp.com")
  set_inheritance_column :ruby_type
end
 
$running = true
 
def signal_trap_exit(signal_name)
  puts "#{Time.now} received #{signal_name} signal"
  $running = false
end
 
our_exit_signals = ["TERM", "INT", "KILL", "HUP"]
for exit_signal_name in our_exit_signals
  Signal.trap(exit_signal_name, "signal_trap_exit('#{exit_signal_name}')")
end
 
def check_internet
  begin
    Timeout::timeout(5) do
      Net::HTTP.get_response(SITE_THAT_IS_ALWAYS_UP, "/", 80) do |response|
        return response.code.match(/2|3\d{2}/)
      end
    end
  rescue => e
    puts "#{Time.now} Error connecting to internet: #{e}"
    return false
  end
end
 
def get_site_ip_addresses
  begin
    Record.find(:all, :conditions => ["type = ? and name in (?)", "A", SITE_ADDRESSES])
  rescue => e
    puts "#{Time.now} Error finding all records: #{e}"
    return []
  end
end
 
def make_inactive(ip_record)
  Record.update_all("prio=-1", "name='#{ip_record.name}' and content='#{ip_record.content}'")
end
 
def make_active(ip_record)
  Record.update_all("prio=1", "name='#{ip_record.name}' and content='#{ip_record.content}'")
end
 
while($running) do
  get_site_ip_addresses.each do |ip_address|
    begin
      Timeout::timeout(5) do
        Net::HTTP.get_response(ip_address.content.to_s, "/", 80) do |response|
          puts "#{Time.now} Response code for #{ip_address.content.to_s}: #{response.code}"
          make_active(ip_address) if ip_address.prio == -1
        end
      end
    rescue => e
      puts "#{Time.now} Error connecting to #{ip_address.content.to_s}: #{e}"
      if check_internet
        make_inactive(ip_address) unless ip_address.prio == -1
      end
    end
  end
 
  sleep 15 if $running
end

Regular Expression Lookahead

Aaron Murphy — Wed, 10 Jun 2009 23:11:16 +0000

Using standard regular expressions is pretty easy for most tasks. However, there is one task that requires lookaheads. I am referring to using negative lookahead to check for strings that do not follow a desired match. The syntax is

(?!someregexp)

where “someregexp” is a regular expression to match. The negative lookahead will reverse the logic for you. So when I needed to find all Master’s degree programs except Master of Science, I used something like

master(?!\sof\sscience)

to match say “master of arts” or “master” but not “master of science”.

The lookahead doesn’t move the position, so you can think of it as saving the spot it was in, checking forward, then returning. If you like regular expressions, you should experiment with lookaheads to get a feel for what they can do. I like to use rublar, a ruby regular expression editor and tester.

Chain Blogging – Internal Link Building and Usability

Brandon Buttars — Wed, 10 Jun 2009 20:40:36 +0000

So some of you may have seen the term chain blogging and probably started to think about chain emails and chain mail. That’s not what this article is about. It’s not about putting a curse on someone that doesn’t fulfill their forwarding quota. I’m talking about blogging just like a chain smoker lights the next cigarette with the previous cigarette, and continues this on and on and on. I recommend igniting your next blog post by the previous blog post. Confused yet? OK, I’ll try to illustrate and explain the idea of “Chain Blogging”.

Content Relationship

I cannot speak for you, but as I blog and create content I do not think about the relationships between my content as much as I should. I try and categorize content best I can, but these categorizations are hard to do because some of our information might belong to the same category but it can be so different than the other information within that category. I’m sure most of you have seen “Related Content” or “Related Topics” widgets that will recommend other articles. These are great tools, but these tools are dynamic and most people install them and ignore their results. If leveraged properly the relationships that content have with one another can create a usability heaven.

How Chain Blogging Can Fix Common Usability Problems

One key to creating a successful website is your ability to keep your visitors on your site. Some things that make or help visitors leave are:

Articles that are too long.
Unhelpful articles.
External links.
Poor internal navigation.
No reason to stay.

There are more things that help visitors leave, but those are the things I want to focus on. I want to recommend some strategies and a technique that may help promote better readership, longer visits, more content consumption, and better usability. I call this technique “Chain Blogging”.

Issue 1 – Articles are too long.

Think of someone who smokes. Most internet surfers are addicted. When they have some free time they have to get themselves some internet. They find themselves with an extra five minutes. They want to find something fast and be able to read something quick. Cigarettes are only so long and only have so much that can be smoked out of them. Well these internet addicts are the same way. They have limited time and need some satisfaction. Short and to the point information is very satisfying to readers. Leave out the fluff. The fluff can make a great topic for an additional or supporting blog post.

Issue 2 – Unhelpful articles.

This one is pretty self explanatory. If your article isn’t helpful in any way, don’t expect much traffic. I know at times you find yourself blogging to blog, but try and make every little article that you make helpful in some way.

Issue 3 – External links.

When I read blogs I will click on links that help with the details. If you are smart about things, you can replace those external links with internal links to pages where you can offer the same information. This allows a “series” type of relationship between blog posts. Many of these series can relate one to another. You may think, this is starting to sound like a wiki. Well duh, it is organizing your blog or content in the same way that a wiki does. Remember to give credit where credit is due, but you can do this with footnotes or create an external resources section referencing these articles, much like wikis do.

Issue 4 – Poor internal navigation.

Poor internal navigation can lead visitors to dead ends or information that doesn’t help support the initial article that lead them to your site in the first place. If you can feed the topic and support the topic that is on their mind, you will have a better chance at keeping them on your site. Issue 4 can be resolved by implementing the same strategies alluded to in Issue 3, creating article relationships. By linking to other internal pages you encourage users to stay on your site. They become aware that your site contains many resources when it comes to the specific topic they entered your site seeking.

Issue 5 – No reason to stay.

I think you probably understand this issue. If you have done things right by resolving all the previous “Issues” we’ve discussed, you’ll find Issue 5 resolved. Giving good relevant content will keep visitors on your site every time.

Search Engine Benefits

Since we discussed the benefits to our users for resolving these issues for site usability, I thought we could discuss the search engine benefits of resolving these issues.

Great relevant internal linking strategy.
Gives you the ability to focus each article on a single keyword phrase.
More content to crawl creating a broader search reach.
Easy linkable resources for others to link to.

Benefit 1 – Great relevant internal linking strategy.

Relevance is a major element in link building. This strategy when done properly can make for extremely relevant links. The search engines were created to help people find what they are looking for, this strategy helps promote that right within your site. It helps to keep visitors on your site and create an impression that your site has a lot of relevant information on the topics it covers.

Benefit 2 – Gives you the ability to focus each article on a single keyword phrase.

I have found that a majority of my search engine rankings tie directly to the phrases that are used in my “title” and in my URL or “slug”. When you try to create content focusing on too many keywords you aren’t given the ability to nurse all the keyword phrases as they a need to be. By writing multiple articles with a single keyword focus it allows you to do this. It allows you to make sure that every keyword you are trying to focus on appears in both the title and URL.

Benefit 3 – More content to crawl creating a broader search reach.

More content can equals more results. This can help to get the desired “double” search engine listing results that many people seek after, along with Sitelinks in Google’s listings. It’s a matter of more is better in this situation. Remember you can always write other articles that piece it altogether after you have put together all the pieces.

Benefit 4 – Easy linkable resources for others to link to.

When I link to external resources I like to link directly to articles that are straight to the point at explaining what I need help explaining. When you create short to the point articles it makes people that link like I do more likely to link to you.

Operation

I thought I would discuss operational benefits to following this blogging/content management strategy but there are a few difficulties in managing it this way too. So I’ll discuss them all at once.

Quicker Blog Postings

By focusing on shorter, more straight to the point blog posts this allows you to publish and create blog posts more quickly. This is great because it can allow you to create a lot more blog posts in a day.

Easy Topical Decisions

If you have a hard time trying to figure out what you are going to blog about, this strategy should make things easier. By continuing off of the previous blog posts topic, it makes it easier to decide what to write about. While writing some blog post you’ll even discover other ideas you’ve missed and may want to link to later when you write supporting articles.

Requires More Upfront Organization

Using the “Chain Blogging” strategy does require a lot more upfront planning. You have to think a lot further ahead up front on what direction your blogging is going to go. What is going to be discussed. Things of that nature. You can always drop a random blog post here and there but it’s best to keep to the strategy.

Requires a Better Understanding of All Your Content

If you are going to be referencing other articles you’ve written it will require you to know your content and where to link to. It will require good planning while writing your articles.

May Require Retroactive Edits

It would benefit web masters to retroactively find articles that they can add links to. You may find yourself creating additional content that relates to previous articles that have been written. Creating retroactive links can help your new articles because old article already have credibility and have rankings in the search engines. Locating articles can be easily done through your site search.

Conclusion

I hope you’ve learned from this big long article. I know this article goes against all that I wrote above but I thought it would be easier all at once. This strategy may not work for every article, but where it will work, it can help out tremendously. So the key things that I hope you’ve gotten out of this article are that even though it may require better management of content, you can use large quantities of relevant posts using relevant internal linking strategies to influence your site credibility and web relevance.

Input Anyone?

Please leave your input and feedback below. What has worked for you? Are you already doing something similar? Are you a better SEO than me and have better suggestions about this strategy? I am no SEO prodigy and I’m sure I can learn a lot from you as readers. Please contribute by commenting to help increase the value of this article.