A while ago I posted a quick SEO overview guide, and that had a section on how Social Media played an important role.

While mentioning these topics at a high level, when it gets down to the nuts and bolts, it can be quite time consuming and effort laden in order to actually get stuff done. Any shortcuts that exists, really go a long way in helping cater to the whole gamut of requirements. So, I’m going to pick out at some of these topics and share my personal experiences with them to try and help out a little.

To start with – self hosted WordPress sites (which is what this is) are by far the best combination of ease and flexibility in my opinion. So if you’re going for a blogging platform, start with WordPress.

Then, the first step for your subsequent Twitter integration, is easy. The plugin you want is “TweetMeme“. You can search for it in the WordPress plugin directory, or you can simply download it from their site. Whichever one you choose, once it is installed and activated, it just works. Nothing else required.

To go slightly deeper, and integrate every blog post with your twitter account automatically, you can use FeedBurner. FeedBurner is quite self explanatory to set up, and only requires you to have a Twitter and a Google account to get it working. FeedBurner also has the added advantage of pinging several other blog services everytime it detects a post from you. So that helps in additional link building.

Moving onto Facebook – there’s a minefield of plugins for WordPress out there. There are some that throw everything into the plugin including the kitchen sink, but then they become horrendously annoying to configure and very bulky to load. I narrowed down my requirements to two things that Facebook is really useful for today – “Liking” stuff, and “Comments”. Both of these get entered as stories into profiles. So this does exactly what you want by hitting newsfeeds. Other features like linking to my Facebook “Notes”, or duplicating/synchronising content and comments between the two defeat the purpose of me having a website. So after much hunting, I have found two applications that sort out everything I need:

1. Facebook Comments for WordPress by Graham Swan
2. Facebook Like by Ahmed Hussein

They need a little bit of configuration in order to run properly, but they come with comprehensive HowTo guides. They do the fantastic job of seamlessly integrating your blog into people’s newsfeeds with minimal brain power.

Have you used or made any other plugins that you’ve found useful?

So I’ve been playing with Google Maps and the location technology on my shiny new Xperia X10 Android phone, and I think it is all very cool. But there are some things which need fixing for the future… in no particular order, here are the results of my findings…

GPS
Accuracy: Obviously awesome in accuracy – pinpoints your location, but claims to have an error margin of about 20m. I’ve never had it off any amount that I could notice. If I hang out of my window on one side of the house it detects that window, and if I move to the other, it finds it there too. Very cool. This does depend on if your phone can see the sky, and also on how many high rise buildings are around you though.
Power: T3h lame. I guess you have to compromise on accuracy with battery juice. If you leave GPS on without being plugged into something, don’t try to use your phone for anything else. You’ll probably run the battery dry once you’ve finished typing the SMS you wanted to send. On my phone at least – if you have the map software up, and the GPS on you can see the percentage reading of your battery dropping…

Network Location
Accuracy: The accuracy really depends on how densely packed your area is with mobile cell towers. The fewer towers you have around you, the worse the accuracy. In rural areas I generally see accuracy ranges of around 800m. Which isn’t too bad when all things are considered. If you’ve moving, then the software is usually intelligent enough to refine that reading, and reduce the error margin – so I think this is a pretty reasonable level of detail for not doing much at all.
Power: Great usage of power! It doesn’t stress the phone that much at all. It has to be connected to cell towers, and it’s effectively performing a fancy variant of triangulation – so the work is mainly done in the software as opposed to communicating with external devices. So this is a great power saver, and allows you to get a good idea of where you are!

Wifi
Accuracy: It appears that either Google, or some database somewhere on the internet ( I have done no research into this and it is purely speculation) has a reference for infrastructure points, and where they are likely to be located. Presumably this database was hugely plumped up when the iPhone frenzy kicked in and everyone was walking around with their phones and wifi on. So the large database owners have attached the Lat+Lng location based on these devices and the corresponding surrounding wifi nodes. This is visible from items like the touch iPods – which don’t have GPS, or cellular reception, but do have Wifi – they can still “tell you where you are” on Google maps. Bear in mind though, that this has the potentially to be HUGELY inaccurate. Different continent inaccurate. I had a wifi node set up in my house in the UK, and someone clearly had an iPhone – because now that I’ve moved to a different country whenever I walk into range of the wifi node, apparently I am back in the UK! So I find this type of referencing REALLY BAD. In theory though – it says 75metres should be the accuracy when combined with mobile networks.
Power: Wifi sucks power out of these tiny devices – so I would recommend not using this as a location reference device, and really only for when you actually need to download data!

What about you? What has your experience been with mobile location technology? Either in phones or in-car GPS units?

Installing the Android SDK on my Ubuntu machine was a bit of a hassle this morning – especially given that I already had the Eclipse IDE installed from the repository! I was battling all morning with NullPointerExceptions for a reason that was previously unknown to me!

So in the event that this makes anyone’s life easier, I would recommend following these steps:

1. Get Java1.6 from the repositories – either using synaptic, or apt-get to download it
2. Open up a terminal window
3. Type in sudo update-alternatives --config java
4. Select the option in this list that points to Java 1.6 (or higher)
5. Download the Android SDK for Ubuntu
6. Unpack the tgz in a directory of your choice, and run “tools/android”
7. Click “Available Packages” and refresh the repository
8. Download the necessary SDK elements!

Doing in that sequence will save you a lot of headache. Of course afterwards you can pick up your preferred IDE – Android Dev recommends Eclipse – but not the eclipse from the repository. Instead you need to download the new(er) one from the eclipse website.

P.S. Thanks to LaiHiu for the entry graphic

When managing or developing object orientated programming sites in PHP, I find that I frequently forget the names of methods that belong to classes. Even though I try to have a standard naming format – my memory still seems to fail
So rather than run phpDocs over my objects continually, I knocked together this quick script to list all the methods in all my objects (I store all my objects in one directory). I call this file “_methodList.php” and keep it only on the development server. Here’s the code!
$dirpath = "/path/to/objects";
$dh = opendir($dirpath);
while (false !== ($file = readdir($dh))) {
//Don't list subdirectories
if (!is_dir("$dirpath/$file")) {
//only grab PHP files
if ((substr($file, -3)=="php")&&($file!="_methodList.php")){
echo $file."<br/>\n";
require_once($file);
$methArr = get_class_methods(substr($file, 0, -4));
if (sizeof($methArr) > 0){
foreach ($methArr as $method){
echo "-> ".$method."<br/>\n";
}
}
echo "<br/>";
}
}
}
closedir($dh);

Thanks to Honou for the opening graphic!

I’ve spent the past couple of years continually looking over Search Engine Optimisation (SEO) guides, blogs and tips from so many different sources, and while some have their own twist on the way things should be done, there are several core messages which keep coming through. I’m no SEO guru, but I try what I can, and I’ve summed up the core messages in this graphic below. If I’ve missed anything critical – then let me know! It’s a big graphic, but should be worth the wait

Special thanks go to the follow sites that I used information from:

SEOMoz.org, TheGoogleCache.com, GetClicky.com, ViktorViktoriaShop.com (for the great product graphic). If I’ve used your work and you don’t want me to, then let me know and I’ll blur you out of the graphic!

My wife gave birth to our beautiful little girl on the 7th of July, and so I have been quite busy the past couple of weeks!

I will return to regular posting shortly!

I recently switched from my Palm Treo 680 to a Nokia e71. It was a painful departure from a decade with Palm, but the phone is now old, and the battery life has begun to become a major issue during the normal working day.

The e71 has some great features over the Palm, but a couple of things I’ll definitely miss are the touch screen and the keyboard!

A hurdle that I came across during migration was my contacts. There didn’t seem to be a simple way to synchronise the two devices without hacking about with Outlook and some other garbage inbetween. I don’t run Windows, and so I don’t have Outlook. Short of spending ages trying to knock together a synchronisation profile in Ubuntu for both devices, I tried to find an easier way. It turns out, there is a very simple way that doesn’t seem to be well documented.

The process works like this:

1. On the Palm Treo 680, go to your contacts menu, and under the category “All” – press the “Menu” button (bottom right key on the keyboard)
2. Click “Send Category”
3. Select “Email” or “Chatter”, or some other file transfer method that allows you to get the file to your Desktop
4. You will then have a file called “All.vcf” on your desktop, this file now needs to be processed through my PHP vCardSplitter script. You can do this using PHP5-CLI, or if you don’t have this on your computer, then drop me a comment below to get in touch, and I’ll split the files for you
5. Once your files are split, you then need to connect your Nokia phone to your computer in “Mass Storage Mode” and copy all the split VCF files onto the phone under the folder “/Other/Contacts”
6. Safely disconnect your phone from the computer
7. On the phone, go to the Contacts menu, click the Options button and select “Copy > From Memory Card”
8. It will then begin copying all your contacts in their full glory to your phone! I had about 1500 contacts to copy across, and I started it just before I started writing this post, and it still isn’t done… (it takes a while)

You’re done! I don’t think the categories that were saved on the Palm are copied across, but at least you now have all your contacts, and all of their full vCard information with them. So this should have copied across email addresses, multiple phone numbers, addresses, etc.

As above – if you can’t execute PHP scripts on your own, then drop me a comment, and I’ll sort you out with a split up file and its outputs. There is a spam trapper running on my comments box below, so make sure you have JavaScript turned on when viewing this page!

Do you have an easier way to do this? If so, please let me know and I’ll link to your method from this post!!

I was breaking my head trying to figure out the best way to reference a particular set of constants in one of my objects so that I didnt’t unncessarily need to create a new database table. Fortunately, I found this thread about looping through class constants using reflectors.

As a summary, it can be done in a very small amount of code:
class test{
const CONSTANT = 'foo';
}
$t = new test;
$r = new ReflectionObject($t);
print_r($r->getConstants());

With the appropriate naming convention – everything else is easy!

Thanks to jpadie.

One of the things I get asked a lot about are the JavaScript widgets that I make, that can be installed on third party websites. The VenueMirror VenueSearch widget at the top of this page is an example of this. The search bar is actually loaded through a JavaScript call that pulls the information from another server. This technique for loading content onto third party websites is not unusual, but it seems there are too few tutorials out there about how to do this. Firstly though – one must question why indeed you would do this.

The Rationale

Placing a form onto a third party website that posts back to a different domain is simple and can be done using plain HTML. However, if the form is populated with a large amount of data, or if the data in the form is dynamic in nature then it makes sense to drive this dynamically. While that sounds logical, to make this easier to understand – reflect on the VenueSearch form above; the VenueSearch form has country and city data, and the choices in the dropdown list are dynamically driven by what cities venues are available in. As new venues are added everyday to VenueMirror, the size of the lists increases – so this in turn means that the options in the dropdown have to be updated. It is not feasible to go around updating partner websites everytime the lists change – so this must be done automatically.

There are many, many examples of such cases – including simple things like booking forms. How many times have you seen forms which include dates that are in the past? Hotel websites are notorious for this, as the third party booking sites are using static forms for the post back of information. These can be cleaned up by using dynamically driven forms.

Hopefully, I have now made the case and rationale clear for why and where dynamic widgets are useful.

The Logic behind the Method

Basic assumptions:

1. You have a website hosted at http://www.mysite.com
2. You have a need to place forms, or data, on third party websites that are data driven
3. The data driving the forms is either housed on, or accessible to http://www.mysite.com
4. The third party website can be any other website, but it allows you to place JavaScript code onto the pages (note that WordPress blogs hosted on WordPress.com do not support this)

The method then works like this:

1. A dynamic file is created on http://www.mysite.com, if it takes parameters then they must be supplied using the GET method
   • The dynamic file can be powered by PHP/ASP/etc etc, it doesn’t matter – but the output must be in plaintext format
   • The output is actually syntactically formatted to be in JavaScript
2. A naming structure for the third party websites is chosen, and will be the name of the DIV deployed on third party websites
3. A snippet of code that references the dynamic file, and the DIV is created, and can be deployed onto multiple third party websites
4. When the third party website is loaded, the JavaScript is also loaded, and executes the remote script by making a GET request to it
5. The remote script instructs the page to populate the predefined named DIV with new content

Sample Implementation

Step 1 – The dynamic content

Assume that in this implementation, your goal was to announce how many elements existed in your current working PHP directory, your remote code to do this simple task would look like:
<?
$d = dir(getcwd());
$count = 0;
while (false !== ($entry = $d->read())) {
$count++;
}
$d->close();
echo $count;
?>

While not the most useful of scripts by itself, it serves the purpose of being suitably dynamic. The next step is to work on a naming convention that can be used when deploying DIVs on remote servers.

Step 2 – The naming convention

The naming convention comes in two flavours – static or dynamic. A static naming convention is useful if you do not want to do any user/account specific logging, and just want to get your content out there and only expect one DIV to be updated on the page. A dynamic naming convention can be used to uniquely track JavaScript calls, and even have multiple dynamic widgets from the same server on the same page. Static is easy – so let’s go with dynamic to make things more exciting.

A simple dynamic naming convention would be to say we’ll use the name of the site (e.g. kaiesh_com) and append the username of the calling user to it. So if the user account Joe_Blogs were to deploy the JavaScript widget, it would look like: kaiesh_com_Joe_Blogs

The naming convention is totally up to you, there is nothing specific about this part, except for the fact that you must have a convention that you can predict and manage. Dynamic conventions are extremely useful as they allow for extensive logging/tracking.

Step 3 – JavaScript syntactic formatting

Now that the core dynamic functionality, and the naming convention have been defined, the code output must be updated to be JavaScript. And the path to the script must be defined, so assume this is held at http://www.mysite.com/myfile.php. So the code would now read:

<?
$userinput = $_GET['uname'];
$d = dir(getcwd());
$count = 0;
while (false !== ($entry = $d->read())) {
$count++;
}
$d->close();
/* === YOU SHOULD ONLY USE ONE OF THE FOLLOWING === */
/* if you are *not* using jQuery you would use this JavaScript line */
?>document.getElementById('kaiesh_com_<? echo $userinput'; ?>).innerHTML("<? echo $count; ?>");<?
/* if you are using jQuery then you would use this line */
?>$("#kaiesh_com_<? echo $userinput'; ?>").html("<? echo $count; ?>");<?
?>

The above code provides you with two options – one if you were using jQuery, and the other if you were not. So only use one of those – it also assumes that the username will be provided in the GET request through the parameter ‘uname’.

Step 4 – The client side code

So, you have now completed the server side programming, now we have to work on the client side snippet. Remember the naming structure that was defined in Step 2, and how we retrieved the dynamic component in Step 3, that now becomes important in generating the client side code. The code that would be deployed on other servers is now:
<div id="kaiesh_com_joe_Blogs"></div>
<script type="text/javascript" src="http://www.mysite.com/myfile.php?uname=Joe_Blogs"></script>

Step 5 – Deployment

Now the snippet we have made in Step 4, can be deployed into any page, in so long as the file in Step 3 has been created, and is uploaded to http://www.mysite.com/myfile.php

Demonstration

I don’t have time to write a mock up demonstration right now! So please explore the snippet used to make the search bar at the top of the page. I will write a simple demo for this tutorial soon!

Have you implemented dynamic widgets on sites before? Do you have another method? I would be keen to see you have used this. If you have any questions, suggestions, or find anything confusing, please feel free to let me know!

A while ago I wrote about making use of information collected by websites – I find graphs a great way to do this. And while there are lots of great graphing objects, or tools available today, it can be a hectic scene to try and find a free one that you want for basic use. So quick modifications to existing code can sometimes be exactly what you need! Below is the code that was used to create the graphs seen in that previous post.

At the top of my graphing file, I’ve added two functions that I need to make use of while processing input from the user:

//convert the submitted string to be only an integer
function parseInt($string) {
 if(preg_match('/(\d+)/', $string, $array)) {
  return $array[1];
 } else {
  return 0;
 }
}
/* given variable intVal, make sure it sits between a minimum number, and a maximum number! */
function bound($intVal, $min, $max){
 $thisVal = parseInt($intVal);
 if ($thisVal < $min){
  $thisVal = $min;
 }
 if ($thisVal > $max){
  $thisVal = $max;
 }
 return $thisVal;
}

Then I actually grab the input from the user – as this will usually be in within an IMG tag, all submitted parameters are going to be part of a GET request:

//How many points on the graph are desired
$idealRows = bound($_GET['points'], 5, 20);
//The currency to peg against
$baseValue = bound($_GET['base'], 1, 5);
//The currency that varies against the peg
$floatValue = bound($_GET['float'], 1, 5);
//How many days in the past to start the graph from
$skipDays = bound($_GET['skip'], 0, 45);

Now that we know what the user wants the graphic to do, we can pull the necessary information out of the database. I have modeled this for connectivity to MySQL, and have abstracted out table components so that you can easily adapt this to any table that you want:

/* Get the daily currency information over the user specified period */
$currencyQuery = "SELECT field1, field2 FROM tableName WHERE currencyRefCode='".$baseValue."' AND currency2RefCode='".$floatValue."' ORDER BY sequenceElement DESC LIMIT ".$skipDays.", ".$idealRows.";";

After you have structured your query to your database, then you need to run it and extract the data row by row:

//Run the SQL query
$cqRes = mysql_query($currencyQuery);
/* Find out how many rows were returned by SQL */
$num_entries = mysql_num_rows($cqRes);
/* As long as there was more than one row we can do some work! */
if ($num_entries > 0){
/* As our currency table is ordered the wrong way round (i.e. it goes back in time) we need to start from the end and work backwards! */
 $loadPos = $num_entries - 1;
 //While rows exist in the table, extract data
 while ($cqRow = mysql_fetch_array($cqRes, MYSQL_NUM)){
  //Store the floating value in an array
  $nt["currVal"][$loadPos] =$cqRow[0];
  /* Store the date of this value in an array, but crop the MYSQL datestamp down to only the parts that we want using substr */
  $nt["month"][$loadPos] = substr($cqRow[1], 6, 5);
  /* Move the array pointer back a value */
  $loadPos--;
 }
}else{
 // Woops! Nothing could be found using this query!
 die ("Invalid currency query");
}

Now that the data has been made available, preparations for the actual image canvas can be made:

$x_gap=40; // The gap between each point in y axis
$x_max=$x_gap*($num_entries+1); /* Maximum width of the graph or horizontal axis */
$top_gap = 20; /* The minimum distance to keep from the top of the image */
$y_elev = 30; /* The distance to elevate the graph from the bottom of the image */ 
$y_max = 150; /* The maximum height of the graph canvas */ 
/* Determine the lowest point and highest point that will be graphed */
$minVal = min($nt["currVal"]);
$maxVal = max($nt["currVal"]);
/* Now a scaling factor will be determined - this allows the graph to pronounce differences between values, otherwise the graph would look quite boring! */
if ($maxVal - $minVal ==0){
 /* There is no difference! So this graph will be a straight line */
 $scaleFact = 1;
}else{
 /* There is some difference, so this graph will have ups and downs */ 
 $scaleFact = $maxVal-$minVal;
}
/* Determine the full scaling factor to be used by determining the largest pixel difference between points */
$scaler=($y_max-$top_gap)/($scaleFact);

So this has now allowed us to determine the size of the canvas, and the distance between points vertically and horizontally – so prepare the image canvas in PHP:

//create the canvas
$im = @ImageCreate ($x_max, $y_max+$y_elev)
//if that failed, then kill the script
or die ("Cannot Initialize new GD image stream");
//set up all the colours (image resource, R, G, B)
$background_color = ImageColorAllocate ($im, 255, 255, 255);
$text_color = ImageColorAllocate ($im, 233, 14, 91);
$graph_color = ImageColorAllocate ($im,25,25,25);
$grid_color = ImageColorAllocate ($im,125,125,125); 

As the canvas is ready, the points have been loaded into an array, and the scaling factors are known, now we can actually plot each point onto the graph! By the way, I am using VenueMirror‘s currency objects here – and the added benefit that I get from that is that in this script is that they return things like currency codes. Above, where there is an SQL query – I would have actually used methods from the objects themselves to get the graphing points. If you copy/paste this code, it will break here – so please change yours to reflect the currency codes, or other data descriptors here!

$x1=0;
$y1=0;
$first_one=true;
/* Put the title of the image into the image! */
ImageString($im,2,5,5,"How many ".$floatCurr->getCurrCode()." buy 1 ".$baseCurr->getCurrCode()." - http://www.venuemirror.com/blog/74/useful-currency-information-by-accident",$graph_color);
/* Start walking through the array of points */
for($pos=0; $pos < $num_entries; $pos++){
 $x2=$x1+$x_gap; // Shifting in X axis
 $y2=$y_max-(($nt["currVal"][$pos]-$minVal)*$scaler); // Coordinate of Y axis
 //Write the floating currency value to the image next to the point
 ImageString($im,2,$x2,$y2,round($nt["currVal"][$pos],2),$graph_color);
 // Drawing the grid vertically//
 imageline ($im,$x2, $y_max,$x2,$y2,$grid_color);
 ImageString($im, 2, $x2-($x_gap/2), $y_max+($y_elev/2), $nt["month"][$pos], $graph_color);
 //Line above is to print month names on the graph
 if(!$first_one){ // this is to prevent from starting $x1= and $y1=0
  imageline ($im,$x1, $y1,$x2,$y2,$text_color); // Drawing the line between two points//
 }
 $x1=$x2; // Storing the value for next draw
 $y1=$y2;
 $first_one=false; // Now flag is set to allow the drawing
}
//Output the image
ImageJPEG ($im);

Credit also goes to this tutorial on Plus2Net, as that provides good insight on how to actually draw graphs. I took much of what they wrote (and their code), and rendered it into a complete actual example here.

Do you have anything that you’re looking to create report style graphs about? There are other features in PHP that let you make 3D bar charts, and pie charts, and we use them a lot for internal reporting. Do you need information on those too? If you have any examples of graphs that you’re making from internal data then please post links to them below!

Also, if you find any bugs, security holes, or other horrible things in this code then please let me know! Do you also want a full file to download?

Cheers!
K

P.S. I know that I said that I would post that the code the following day, but it’s a been a bit crazy recently – so I’m sorry about the delay!