The first step of course was to come up with a cool name for the framework. After much brainstorming with the front-end Tech Lead (who was the co-creator of the framework) we finally came up with a name we both agreed on – Skeletor – not only a powerful villain from one of my favorite childhood toy franchises, but the name just seemed so damn appropriate for a framework. I was super excited with the name and the project, and I wanted everyone else to get on board and be as excited as I was. I also had the vision that the framework would belong to a web suite and comprise of various user interfaces to manage things like the URL catalog, error reporting, and debugging.

So the following is the very first piece of work I did for the project. The document was put together before the project was completely sold to management and definitely helped seal the deal. I also had the requirement to teach the rest of the team the fundamentals of OO programming and MVC frameworks. So my idea here was that each member of the team would get a character from the MOTU world, which represented a module within the framework, and they would have to become that character and learn everything about the purpose of that character, and understand it well enough to present it to the rest of the team, and eventually develop-out their module. In the end it was only two of us that were assigned to developing the framework, which we did and we did well, and that same framework now serves up over a half a dozen websites with over five million page impressions a month. So this is just a mock-up for something that never really paned out as planed, in the end we never really fleshed out and finished what I was attempting here, but even still I think I came up with a really fresh approach to teaching the concepts of OO development, or teaching anything for that matter, and to this day I still look back and try to match that same vision I had then with the work I do now. Enjoy!




The web systems suite comprises of everything involved in the website process:

• Framework
• Framework Objects
• CMS Application Interface

SKELETOR – The Framework

The framework for the web applications. All applications live within an instance of the framework. It consists of libraries, classes and run-time infrastructure.

• Logical and concise directory structure
• Extends PEAR

I HAVE THE POWER – Master File

The master file for the SKELETOR framework. Mod rewrite points to this.

• Controls environment and global settings
• Initializes common global objects
• Routes, dispatches and renders the browser call

QUEEN MARLENA – The Model

The model defines the properties of an object.


ETERNIA – The View

The view contains all the output for the page call, with defined placeholders for logical driven content. An object may have multiple views.


KING RANDOR – The Controller

The controller contains the default behaviour and helper classes of an object. All Skeletor objects extend the Skeletor controller.


EVIL-LYN – The Error Handler

The error handler takes care of where to log, and how to react to an error.


TRAP JAW – The Database Abstraction Layer

The database abstraction layer sits between the framework and the databases and handles all queries and results.


MAN-AT-ARMS – The Security Layer

The security layer controls access and permissions for the user.


BATTLE CAT – The Content Catalog

The content catalog is both a CMS interface and a stored representation the its data. It defines what view and model a URL should dispatch.


RAM MAN – The Forms Catalog

The forms catalog is a CMS interface used to build the web forms and define how the captured data is stored.


CASTLE GRAYSKULL – The Session Handler

The session handler controls how session data is stored (e.g. serializing objects) and where it is stored to (e.g. written to the file system or a database).


STRATOS – Redirect Handler

The redirect object handles how all the various possible redirect types are handled. It will consult with the content catalog to know how to handle a URL redirect (301 moved permanently, 302 temporarily redirected, etc.)


TEELA – Form Handler

The form handler consults with the Forms Catalog


PANTHOR – The Request Dispatcher

Consults the catalogue hash map and calls the appropriate object.


SORCERESS – The AJAX Handler

Enables a page to speak telepathically with the server.


SNAKE MOUNTAIN – The Skeletor Control Center

GUI to configure and control many core aspects of the framework.

• Generates new applications
• Control user access
• Control error handling

TRI-KLOPS – The Search API

The search appliance interface.


ORKO – Documentation System

This represents the importance of both automatically generated code documents (PHPDocs), and manually generated user-friendly documentation (HOWTOs).

Step 1
Just as the tutorial says, the first step is to open the image.

<?php
$imgName="beard.jpg";
$imgSource = imagecreatefromjpeg($imgName);
?>

Step 2
The second step is to create the black and white canvas, using getimagesize() to size it to the original photo.

<?php
list($w,$h)=getimagesize($imgName);
$imgK=imagecreatetruecolor($w,$h);
?>

Step 3
The third step is the most complicated. Unlike the application used in the tutorial which has a nice interface, we have to create the code to do this ourselves. We loop through every pixel of the source image and compare its tone. This was the only variable in the code I had to tweak to match the example image in the tutorial. The RGB sum image can add up to a total of 765 (255*3). I played around and found that 300 was pretty much an exact match to the “Threshold Level” of 104 called out in the tutorial, this value may change depending on the contrast of the source image. So in the code if the sum of the RGB value is above 300 we allocate a white pixel to the coordinate, otherwise we allocate to it a black pixel.

<?php
for($y=0;$y<$h;$y++){
  for($x=0;$x<$w;$x++){
    $rgb = imagecolorat($imgSource, $x, $y);
    $r = ($rgb >> 16) & 0xFF;
    $g = ($rgb >> 8) & 0xFF;
    $b = $rgb & 0xFF;
    $bw=$r+$g+$b>300?imagecolorallocate($imgK,255,255,255):imagecolorallocate($imgK,0,0,0);
    imagesetpixel($imgK,$x,$y,$bw);
  }
}
?>

Step 4
Just like in the tutorial, in step 4 we merge the black and white image over the original with an opacity of 40%. We’ll also use this step to write out the image to the browser (sending the correct headers also).

<?php
imagecopymerge($imgSource,$imgK,0,0,0,0,$w,$h,40);
header("Content-type: image/png");
imagepng($imgSource);
?>

The dark shadows help give the image more shading, and the white layer helps smudge and tone down the number of colors that the original photo had, both of which contribute to a more comic-ish effect. It’s worked out quite well with this image when using the exact same settings as created replicating the tutorial, but testing it out on other images it’s obvious it all needs to be adjusted on a case by case basis, and as the tutorial points out, this technique only really works well with faces.

Anyways this has been a taste at something I’ve never tried before. For a long time I’ve thought about what makes up an image, where the light and colors come from and how they all work together to make or break and image. It’s all very interesting and I am eager to pickup Photoshop and really start learning how to do some usefull effects, and install imageMagick and replicate what I’ve learnt in my code.

So geonames.org offers a free webservice, but I was already using the google API which is also free so I didn’t see any benefit to switch. But they did offer for free all the zip codes with the geographical coordinates so I decided to import this into my database and cut out the 3rd party google Geocode API. It would mean quicker response time and not having to worry about if the service is unavailable or returning errors, I was actually planning to cache the results locally anyway. And perhaps the zip code table might have to be updated on an annual basis to maintain its accuracy (like do zip codes really change that much anyways?), but the web service API is subject to change and it would be less maintainable to monitor it and react to the changes.

So I downloaded the tab delimited US Zip Codes file and imported it into a table in my database called “tbl_Zipcodes_Spatial”, with the following fields (from the included readme):

Country_code : iso country code, 2 characters
Postal_code : varchar(10)
Place_name : varchar(180)
Admin_name1 : 1. order subdivision (state) varchar(100)
Admin_code1 : 1. order subdivision (state) varchar(20)
Admin_name2 : 2. order subdivision (county/province) varchar(100)
Admin_code2 : 2. order subdivision (county/province) varchar(20)
Admin_name3 : 3. order subdivision (community) varchar(100)
Latitude : estimated latitude (wgs84) float(10,6)
Longitude : estimated longitude (wgs84) float(10,6)
Accuracy : accuracy of lat/lng from 1=estimated to 6=centroid

I created an index on the postal_code field and updated my GeoPos:: prepareGetByDistanceSQL() method to get the zip code from the new table. I actually created a new method so that the class still has the ability to pass in the coordinates to the old method when necessary:

<?php
function prepareGetByDistanceWithZipcodeSQL($zip_code,$distance,$table_name,$fields,$units="miles"){
  $cUnit=self::convertMeasuringUnit($units);
  $sql="
    SELECT ".$table_name.".".implode($fields,",".$table_name.".").",
      tbl_zipcodes_spatial.Latitude AS Zipcode_Latitude,
      tbl_zipcodes_spatial.Longitude AS Zipcode_Longitude,
      ACOS(SIN( PI()* tbl_zipcodes_spatial.Latitude /180 )*SIN( PI()*".$table_name.".Latitude/180 ))+(COS(PI()* tbl_zipcodes_spatial.Latitude /180)*COS( PI()*".$table_name.".Latitude/180) *COS(PI()*".$table_name.".Longitude/180-PI()* tbl_zipcodes_spatial.Longitude /180))* ".$cUnit." AS Distance
    FROM tbl_zipcodes_spatial,".$table_name."
    WHERE
      tbl_zipcodes_spatial.postal_code='".$zip_code."'
      AND ".$cUnit." * ACOS( (SIN(PI()* tbl_zipcodes_spatial.Latitude /180)*SIN(PI() * ".$table_name.".Latitude/180)) +
        (COS(PI()* tbl_zipcodes_spatial.Latitude /180)*COS(PI()*".$table_name.".Latitude/180)*COS(PI() * ".$table_name.".Longitude/180-PI()* tbl_zipcodes_spatial.Longitude /180))
        ) <= ".$distance."
    ORDER BY ".$cUnit." * ACOS(
      (SIN(PI()* tbl_zipcodes_spatial.Latitude /180)*SIN(PI()*".$table_name.".Latitude/180)) +
        (COS(PI()* tbl_zipcodes_spatial.Latitude /180)*COS(PI()*".$table_name.".Latitude/180)*COS(PI() * ".$table_name.".Longitude/180-PI()* tbl_zipcodes_spatial.Longitude /180))
      )
  ";
  return $sql;
}
?>

And it worked! Barely increased the query execution time, and I’ve completely cut out the google API middle man so the overall execution time of the page is greatly increased. Now I feel like I’ve put together something pretty damn robust (the final touch would be to create a stored procedure in the database, and this is something I’ll come back to at a future point). Behold the final script:

<?php
/*
Geographical Location functions
ALL CREDIT GOES TO http://blog.peoplesdns.com/
Thanks to these two blog posts:

http://blog.peoplesdns.com/archives/24

http://blog.peoplesdns.com/archives/34

This API:

http://code.google.com/apis/maps/documentation/geocoding/

And the zipcode database found here:

http://www.geonames.org/

*/

class GeoLoc{

	const GOOGLE_API_KEY="yourgooglekeygoeshere";
	const GOOGLE_API_URL="http://maps.google.com/maps/geo";

	/*
	queries the google api for zip code
	returns long and lat coordinates
	*/
	public function getZipcodeCoordinates($zip_code){
		$result=file_get_contents(self::GOOGLE_API_URL."?q=".$zip_code."&sensor=false&gl=us&output=xml&key=".self::GOOGLE_API_KEY);
		$data=simplexml_load_string($result);
		$coord=$data->Response->Placemark->Point->coordinates;
		$coord=explode(",",$coord);
		$r->longitude=$coord[0];
		$r->latitude=$coord[1];
		return $r;
	}

	/*
	returns the radius
	*/
	public function rad($v){
		return ($v*M_PI/180);
	}

	/*
	degree,minute,seconds to decimal degrees
	note: this could also be done in a single line using ternary
	*/
	public function dms2deg($D,$M,$S,$dir){
		if(strpos(' WsSs', $dir)>0){
			return(-1 * ($D + ($M + $S/60)/60));
		}else{
			return($D + ($M + $S/60)/60);
		}
	}

	/*
	degree,minute,seconds
	*/
	public function dms($rad) {
		$d = abs($rad * 180 / M_PI);
		$d += 1/7200; // add ½ second for rounding
		$deg = floor($d);
		$min = floor(($d-$deg)*60);
		$sec = floor(($d-$deg-$min/60)*3600);
		// add leading zeros if required
		if ($deg< 100) $deg = '0' + $deg;
		if ($deg< 10) $deg = '0' + $deg;
		if ($min< 10) $min = '0' + $min;
		if ($sec< 10) $sec = '0' + $sec;
		return $deg + '\u00B0' + $min + '\u2032' + $sec + '\u2033';
	}

	/*
	gets the measuring unit
	*/
	public function convertMeasuringUnit($units){
		switch ($units){
			case "miles": $r = 3963.191; break;;
			case "nmiles": $r = 3441.596; break;;
			case "kilo": $r = 6378.137; break;;
		}
		return $r;
	}

	/*
	distance between two points using sherical law of cosines
	cos c = cos a cos b + sin a sin b cos C
	*/
	public function distance($lat1, $lon1, $lat2, $lon2, $units = 'miles'){
		$lat1 = self::rad($lat1); $lon1 = self::rad($lon1);
		$lat2 = self::rad($lat2); $lon2 = self::rad($lon2);
		$r=self::convertMeasuringUnit($units);

		return acos(sin($lat1)*sin($lat2) + cos($lat1)*cos($lat2)*cos($lon2-$lon1)) * $r;
	}

	/*
	initial bearing from point 1 to point 2
	*/
	public function bearing($lat1,$lon1, $lat2, $lon2) {
		$y = sin($lon2-$lon1) * cos($lat2);
		$x = cos($lat1)*sin($lat2) - sin($lat1)*cos($lat2)*cos($lon2-$lon1);
		return atan2($y, $x);
	}

	/*
	find out what the midpoint between two points is
	*/
	public function midpoint($lat1, $lon1, $lat2, $lon2) {
		$lat1 = self::rad($lat1); $lon1 = self::rad($lon1);
		$lat2 = self::rad($lat2); $lon2 = self::rad($lon2);
		$dLon = $lon2 - $lon1;
		$Bx = (cos($lat2) * cos($dLon));
		$By = (cos($lat2) * sin($dLon));
		$lat3 = atan2( sin($lat1) + sin($lat2), sqrt( (cos($lat1)+$Bx) * (cos($lat1)+$Bx) + ($By * $By)) );
		$lon3 = $lon1 + atan2($By, cos($lat1) + $Bx);

		if (!$lat3 || !$lon3) return false;
		return array($lat3 * 180 / M_PI, $lon3 * 180 / M_PI);
	}

	/*
	returns sql to query a table for rows by distance (miles,nmiles,kilo)
	table must contain fields named latitude and longitude
	*/
	public function prepareGetByDistanceSQL($long,$lat,$distance,$table_name,$fields,$units="miles"){
		$cUnit=self::convertMeasuringUnit($units);
		$sql="
			SELECT ".implode($fields,",").",
				acos(SIN( PI()* ".$lat." /180 )*SIN( PI()*latitude/180 ))+(cos(PI()* ".$lat." /180)*COS( PI()*latitude/180) *COS(PI()*longitude/180-PI()* ".$long." /180))* ".$cUnit." AS distance
			FROM ".$table_name."
			WHERE active=1
				AND ".$cUnit." * ACOS( (SIN(PI()* ".$lat." /180)*SIN(PI() * latitude/180)) +
				(COS(PI()* ".$lat." /180)*cos(PI()*latitude/180)*COS(PI() * longitude/180-PI()* ".$long." /180))
				) <= ".$distance."
			ORDER BY ".$cUnit." * ACOS(
				(SIN(PI()* ".$lat." /180)*SIN(PI()*latitude/180)) +
				(COS(PI()* ".$lat." /180)*cos(PI()*latitude/180)*COS(PI() * longitude/180-PI()* ".$long." /180))
			)
		";
		return $sql;
	}

	/*
	returns sql to query a table for rows by distance (miles,nmiles,kilo)
	table must contain fields named latitude and longitude
	requires you have the tbl_zipcodes_spatial table http://download.geonames.org/export/zip/
	*/
	public function prepareGetByDistanceWithZipcodeSQL($zip_code,$distance,$table_name,$fields,$units="miles"){
		$cUnit=self::convertMeasuringUnit($units);
		$sql="
			SELECT ".$table_name.".".implode($fields,",".$table_name.".").",
				tbl_zipcodes_spatial.Latitude AS Zipcode_Latitude,
				tbl_zipcodes_spatial.Longitude AS Zipcode_Longitude,
				ACOS(SIN( PI()* tbl_zipcodes_spatial.Latitude /180 )*SIN( PI()*".$table_name.".Latitude/180 ))+(COS(PI()* tbl_zipcodes_spatial.Latitude /180)*COS( PI()*".$table_name.".Latitude/180) *COS(PI()*".$table_name.".Longitude/180-PI()* tbl_zipcodes_spatial.Longitude /180))* ".$cUnit." AS Distance
			FROM tbl_zipcodes_spatial,".$table_name."
			WHERE
				tbl_zipcodes_spatial.postal_code='".$zip_code."'
				AND ".$cUnit." * ACOS( (SIN(PI()* tbl_zipcodes_spatial.Latitude /180)*SIN(PI() * ".$table_name.".Latitude/180)) +
				(COS(PI()* tbl_zipcodes_spatial.Latitude /180)*COS(PI()*".$table_name.".Latitude/180)*COS(PI() * ".$table_name.".Longitude/180-PI()* tbl_zipcodes_spatial.Longitude /180))
				) <= ".$distance."
			ORDER BY ".$cUnit." * ACOS(
				(SIN(PI()* tbl_zipcodes_spatial.Latitude /180)*SIN(PI()*".$table_name.".Latitude/180)) +
				(COS(PI()* tbl_zipcodes_spatial.Latitude /180)*COS(PI()*".$table_name.".Latitude/180)*COS(PI() * ".$table_name.".Longitude/180-PI()* tbl_zipcodes_spatial.Longitude /180))
			)
		";
		return $sql;
	}
}
?>

Well first of I need to get the latitude and longitude for a zip code. For that I very quickly found the Google Geocode API and threw together the following:

<?php
$result=file_get_contents("http://maps.google.com/maps/geo?48220&sensor=false&gl=us&output=xml&key=yourgooglekey);
$data=simplexml_load_string($result);
$coord=$data->Response->Placemark->Point->coordinates;
$coord=explode(",",$coord);
$longitude=$coord[1];
$latitude=$coord[0];
?>

It took like 10 minutes, and that included signing up for the API key and reading the documentation, shit this geocoding stuff is easy, I should be done by lunch…

Yeah okay so I have two sets of coordinates, great but errr now what? So I find the Haversine formula, but alas not really being any good at math I don’t understand it, but it doesn’t really matter because I know how to convert it to do the math in PHP. Cool so I got the Haversine function in PHP now but how do I query it against the data in my database? I’d read some stuff about geographical libraries for databases and it seemed super complicated, like the GIS and Spatial extensions for MySQL. So I figure I’ll use a two step approach and do a simple query to pull out a square block of locations and then apply the math. i.e. if I am searching for within a 10 mile radius of a location I’ll do a search on -10 miles and +10 miles, but as the distance is circular I would be getting results in the four corners of that square block that are greater than the 10 miles, and I would then apply the Haversine function and be left only with those results that where truly within the 10 mile radius.

By sheer luck I found this post. It was insane, I didn’t realize you could apply the Haversine formula directly in SQL, I ran that query in my db and bam it worked instantly (well actually there’s a typo syntax error ‘< =’ -blank space between the less than and equals character - in the where clause). Obviously I had to switch out a couple of things so it played nice with my database, but it was instant success, I tried out some different latitude and longitude coordinates and it worked every time:

SELECT Name,Address,Address2,City,State,Zip,Phone,URL,Latitude,Longitude,
acos(SIN( PI()* 42.4584036 /180 )*SIN( PI()*latitude/180 ))+(cos(PI()* 42.4584036 /180)*COS( PI()*latitude/180) *COS(PI()*longitude/180-PI()* -83.1380955 /180))* 3963.191 AS distance
FROM tbl_retailers
WHERE active=1
AND 3963.191 * ACOS( (SIN(PI()* 42.4584036 /180)*SIN(PI() * latitude/180)) +
(COS(PI()* 42.4584036 /180)*cos(PI()*latitude/180)*COS(PI() * longitude/180-PI()* -83.1380955 /180))
) <= 100 ORDER BY 3963.191 * ACOS( (SIN(PI()* 42.4584036 /180)*SIN(PI()*latitude/180)) + (COS(PI()* 42.4584036 /180)*cos(PI()*latitude/180)*COS(PI() * longitude/180-PI()* -83.1380955 /180)) )

Wow so this was it, everything I needed. Oh wait, except that I needed to display the distance in miles. But the guy who blogged this was some kind of superman and he talks about this on another post. Really I only needed the rad() and distance() functions (because distance is dependent on rad), but I decided that they’ll probably all come in useful one day, so I took them wrapped them in a class called GeoLoc. The class doesn’t need to be instantiated into an object so all methods can be called as follows

<?php
GeoLoc::distance($lat1, $lon1, $lat2, $lon2, $units);
?>

Then decided I could abstract in the SQL statement by passing in all necessary variables, and I added it to the class:

<?php
GeoLoc::prepareGetByDistanceSQL($lat,$long,$distance_in_miles,$table_name,$fields);
?>

I then understood that the measuring unit the query is using is the same as in the distance() method so I abstracted it out into its own method. At which point I noticed that the numbers didn’t match exactly – for miles the SQL had 3963.191 whereas the distance function only had 3963.1. I decided that the SQL query had the more granular number and when I reviewed its original blog post it was across the board for all three measuring units so I updated all the numbers. I then figured I might as well abstract in the Google Geocode zip code lookup.

This is what I was left with (functions I’m not using removed); I give all credit to joeldg:

<?php
/*
Geographical Location functions
ALL CREDIT GOES TO http://blog.peoplesdns.com/
Thanks to these two blog posts:

http://blog.peoplesdns.com/archives/24

http://blog.peoplesdns.com/archives/34

This API:

http://code.google.com/apis/maps/documentation/geocoding/

*/
class GeoLoc{

const GOOGLE_API_KEY="yourkeygoeshere";
const GOOGLE_API_URL="http://maps.google.com/maps/geo";

/*
queries the google api for zip code
returns long and lat coordinates
*/
function getZipcodeCoordinates($zip_code){
  $result=file_get_contents(self::GOOGLE_API_URL."?q=".$zip_code."&sensor=false&gl=us&output=xml&key=".self::GOOGLE_API_KEY);
  $data=simplexml_load_string($result);
  $coord=$data->Response->Placemark->Point->coordinates;
  $coord=explode(",",$coord);
  $r->longitude=$coord[0];
  $r->latitude=$coord[1];
  return $r;
}
function rad($v){
  return ($v*M_PI/180);
}
/*
distance between two points using sherical law of cosines
cos c = cos a cos b + sin a sin b cos C
*/
function distance($lat1, $lon1, $lat2, $lon2, $units = 'miles'){
  $lat1 = self::rad($lat1); $lon1 = self::rad($lon1);
  $lat2 = self::rad($lat2); $lon2 = self::rad($lon2);
  $r=self::convertMeasuringUnit($units);
  return acos(sin($lat1)*sin($lat2) + cos($lat1)*cos($lat2)*cos($lon2-$lon1)) * $r;
}
/*
gets the measuring unit
*/
function convertMeasuringUnit($units){
  switch ($units){
    case "miles": $r = 3963.191; break;;
    case "nmiles": $r = 3441.596; break;;
    case "kilo": $r = 6378.137; break;;
  }
  return $r;
}
/*
returns sql to query a table for rows by distance (miles,nmiles,kilo)
table must contain fields named latitude and longitude
*/
function prepareGetByDistanceSQL($long,$lat,$distance,$table_name,$fields,$units="miles"){
  $cUnit=self::convertMeasuringUnit($units);
  $sql="
    SELECT ".implode($fields,",").",
    acos(SIN( PI()* ".$lat." /180 )*SIN( PI()*latitude/180 ))+(cos(PI()* ".$lat." /180)*COS( PI()*latitude/180) *COS(PI()*longitude/180-PI()* ".$long." /180))* ".$cUnit." AS distance
    FROM ".$table_name."
    WHERE active=1
      AND ".$cUnit." * ACOS( (SIN(PI()* ".$lat." /180)*SIN(PI() * latitude/180)) +
    (COS(PI()* ".$lat." /180)*cos(PI()*latitude/180)*COS(PI() * longitude/180-PI()* ".$long." /180))
    ) <= ".$distance."
    ORDER BY ".$cUnit." * ACOS(
    (SIN(PI()* ".$lat." /180)*SIN(PI()*latitude/180)) +
    (COS(PI()* ".$lat." /180)*Cos(PI()*latitude/180)*COS(PI() * longitude/180-PI()* ".$long." /180))
   )
  ";
  return $sql;
}
}
?>

Custom Permalinks
By default all pages are created as something like ‘http://www.mysite.com/?p=14′. But WordPress has it’s own built-in URL parser and router allowing us to make pretty URLs. Click ‘Settings->Permalinks’ in the left sidebar and select the ‘Month and name’ radio button and hit save (don’t worry about the other options, they really only affect the “posts” URL structure and we’re only concentrating on “pages” here).

It creates an ‘.htaccess’ file in the web root, if Apache doesn’t have permission to create this file then you can create it yourself with the following:

# BEGIN WordPress

RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]

# END WordPress

Basically every file that doesn’t exist (media, css, js, etc. files that physically exist bypass the rule) gets sent to the index.php file which does a URL lookup and routes to the correct template.

You can now go and look at a custom page you’ve made and see it has a beautified URL as a Permalink.

Custom Header and Footer
The default WordPress header and footer does a lot of automatic work. In order to free your code from this I recommend creating you own header and footer. Any functionality that the header and footer contains that you want to keep can be ported over as you need it.

In your theme folder create your own header.php and footer.php files. It’s probably a good idea to save a backup first (even though you’ll probably already have the whole thing backed-up from when you created your own theme, and then get rid of everything in the files you don’t want. For example when I first started experimenting I kept all the boiler plate stuff and ditched the automatic navigation generation and sidebar code. Start with the minimum and work things back in from your template as you need them, if you feel you need them, personally I rewrote everything back in.

Once you understand what you’re doing here you can drop the whole header and footer approach and use a templating engine such as Sigma (which I’ve favored for some time).

Custom Homepage
The final move is to set the homepage as something other that the blog. This is the final key in freeing up WordPress from being a blog tool dependent on the default code to becoming, well anything you want from a website, backed by a powerful CMS. Of course you will also always have the option to quickly and easily implement a powerful blogging system into your site, but the point is the blog doesn’t actually have to be your site.

In your admin panel create a new page with the title ‘HOMEPAGE’, I recommend to first create a homepage template because a homepage is never like anything else. Once you have that page published navigate to ‘Settings->Reading’ and under the first option ‘Front page displays’ select the second radio button ‘A static page (select below)’, and in the drop-down find the ‘HOMEPAGE’ page you just created, and save your changes.

That’s it, you’re now free to go crazy with your website design and code yet still harness the power that the WordPress CMS yields! And don’t forget if you want to have a blog in your website, now or in the future, you already have all the tools you could want.

This is part of an ongoing series of posts I am publishing talking about how to use WordPress as a custom CMS.

<?php
/*
Template Name: My Template
*/
?>

2. Save the file in your theme folder with the name of your new template, the filename doesn’t have to be an exact match for the template name, e.g. ‘mytemplate.php’.

3. In the admin panel create a new page. Give it a title, type in some content, and then in the right sidebar under ‘Attributes’, find your new template in the drop down and select it, and publish the page.

4. When you view your new page on your sites front-end you’ll see a totally blank page. This is good and means it’s worked as we’ve not told the template to do anything yet.

5. Go back to your template file and update it to match the following:

<?php
/*
Template Name: My Template
*/
get_header();

get_footer();
?>

6. Now when you refresh your new page you’ll see the header and footer are now incorporated:

7. That’s great but the content from the CMS is still missing. Add the following into the template file between the get_header() and get_footer() calls, save it and refresh the page:

$thisPage=query_posts("pagename=".$_SERVER["PATH_INFO"]);
echo $thisPage[0]->post_content;

That’s it, you’ve just created your own template! You can now continue to develop out your new template and create more pages using that template, and create more templates.

This is part of an ongoing series of posts I am publishing talking about how to use WordPress as a custom CMS.

Now lets use SimpleXML to loop through the returned xml and create an array of my friends:

<?php
$friendsArr=array();
$feed = simplexml_load_string($result);
foreach($feed->user AS $userXML){
   $user = simplexml_import_dom($userXML);
   $friendsArr[]=(string)$user->screen_name;
}
?>

Lets assume we have done the same thing to create an array of my followers, now we can find everyone that I am friends with but doesn’t follow me:

<?php
$badfriendsArr=array_diff($friendsArr,$followersArr);
?>

And finally lets display, the lists are returned from Twitter in the order the relationship began from newest to oldest, so lets order alphabetically and print:

<?php
natcasesort($badfriendsArr);
foreach($badfriendsArr AS $badfriend){
   echo "<a href="http://www.twitter.com/$badfriend">$badfriend</a><br>";
}
?>

What I realized pretty quickly were two things:-

1. The Administration Panel is kick-ass, it’s beautiful to look at and use and takes care of all the administration dirty work you’d have to do if you were writing from scratch.
2. I pretty much hate the core WordPress PHP code, no disrespect to the people that dedicated so much time to it over the years, but to me and for my purposes it’s a cluster-fuck of a headache.

Look I’m not saying I’m right in this approach, but I’m pretty sure that this approach is right for me. I follow a school of thought which basically says that if you can’t figure it out in less than an hour it’s broken (something I took away from a mesmerizing Rasmus Lerdorf keynote speech at a conference many years ago). And that’s how I felt about much of the “automagic” internals of WordPress, I couldn’t figure them out for shit and I got more and more frustrated as I started to realize that I could be writing this myself from scratch, not just in a clean manner that I would obviously intimately understand, but also in less time that it is taking me to figure out the spaghetti code. I felt the same way with the plugins, that by the time I’d searched through the thousands of plugins and actually found the one that does what I need, and installed it and played around with it, only to find that it doesn’t do exactly what I need at which point I’d have to jump back into the pool of plugins looking for another suitor. Even if I did eventually find exactly what I needed, which lets face it is rarely the case, I could have already written a more suitable and stable plugin myself.

But on the other hand the administration panel WordPress has to offer is truly something of beauty. It takes care of all the user security, roles and permissions, pages and posts with vanity URLs, WYSIWYG editors, media uploads, and comment moderating, just to mention a few of it’s highlights. Basically all the rudimentary crud we have to worry about when building a CMS from scratch, shit in my line of work the admin panel is often more complex than the front-end. And not only is it solid in it’s task, so that you can feel comfortable that it’ll do its job without having to peek under the hood, but it has some sprinkles of scriptaculous and ajax so it also does it sexy. And couple that with the fact that it’s extremely easy to implement your own custom menu items and modules to the panel makes for a great application.

So I basically ended up writing my own front-end. I got familar with WordPress and found all the functions I needed to pull in the information I was generating with the admin panel. I’d like to write about how you can get setup up with all the basics you need to get up to speed with where I am at with all of this. I’ll hopefully accomplish this by exploring the following topics over a number of entries:-

• Create your own theme
• Custom homepage
• Making plugins
• Understanding pages
• Meta tags and custom fields
• Custom RSS file

By the way the WordPress site I built is www.thefordstory.com