• Top Parent 1
• Child 1-1
• Child 1-2
• Sub-Child 1-2-1
• Sub-Child 1-2-2
• Child 1-3
• Top Parent 2
• Child 2-1
• …

Each element is it’s own entry in the one dimensional array. This makes outputting that data in any kind of readable form very difficult, where keeping track of parents and branches are required in order to make sense of it. This gets pretty messy, pretty quickly. And the deeper the tree, the more complicated the process.

To make this easier to deal with, the array should be built in a tree format as follows:

• Top Parent 1
  • Child 1-1
  • Child 1-2
    • Sub-Child 1-2-1
    • Sub-Child 1-2-2
  • Child 1-3
• Top Parent 2
  • Child 2-1
  • …

Where the children of the elements in the tree are actually children of the elements in the array.

In order to do this quickly and painlessly, we are going to parse through this array twice… no iterations, just a couple of foreach loops and we’ll get our tree exactly how we want it.

In order to do this, we must first make sure our array indexes are the same as the IDs of the items we are sorting (because we are pulling this from a database, right?).

To do this in CakePHP we run it through the Set::combine function like so:
Set::combine($tree_data, '/Model/id', '/.');

If you are not using CakePHP, you can create a new array, and as you foreach through your original array, set elements in the new array accordingly:

$old_tree_data = $tree_data;
$tree_data = array( );
foreach ($old_tree_data as $node) {
	$tree_data[$node['Model']['id']] = $node;
}

Now that we have our array indexes set to our model ID, we can proceed.

The trick to this method is not to move the nodes around, because if we did that, we’d still have to keep track of what went where, and that’s exactly what we’re trying to avoid. Instead, we’re going to use references to keep track of our data as it gets moved around. That way we still have our original base array element that we can play with without having to know where it actually is in the tree.

Here is the code, and then we’ll go through it and explain.

foreach ($tree_data as $key => $node) {
	if ( ! $node['Model']['parent_id']) {
		continue;
	}

	if ( ! isset($tree_data[$node['Model']['parent_id']]['Child'])) {
		$tree_data[$node['Model']['parent_id']]['Child'] = array( );
	}

	$tree_data[$node['Model']['parent_id']]['Child'][] =& $tree_data[$key];
}

Now to explain… We parse through the array and for each element, we first test the element to see if it has a parent, if it does not, we just skip it, there’s no need to go further.

We then check and see if the parent element has an index called ‘Child’ and if it does not, we create one and set it as an array.

Then we do the magic. We set the next item in the parent node’s Child element to the reference of the current node. We don’t actually move the node. So now if you look at the array, you’ll see two entries for the current node, one inside the parent element, and one that was the original in the flat array.

WARNING: One thing to note here, is that we are not setting it to the reference of $node, but to the reference of $tree_data[$key]. The reason for this is because if the element is referenced to $node, the next time through the loop, all of the referenced elements will also be set to the new value of $node, and we certainly don’t want that.

The magical part of this, is that no matter where the references end up, the original is still there to be modified. So for instance if I have a branch path with IDs as follows: 12, 5, 13, 14… it doesn’t matter what that path is, I can still access the element with ID 14 by modifying $tree_data[14]. So if element 14 has child nodes, I can place them in the tree by modifying $tree_data[14]['Child'], and wherever that node is actually supposed to be, it will get modified there as well. That’s the beauty of references.

Now to clean up the array, we just parse through it once more, and clear out the original reference nodes (the ones that have parents):

foreach ($tree_data as $key => $node) {
	if ( ! empty($tree_data['Model']['parent_id']) {
		unset($tree_data[$key]);
	}
}

And that’s it! No messing around with paths… no iterative functions… just twice through an array (maybe three times), and it’s all sorted, compartmentalized, and pretty.

If you have other methods of getting your trees into a usable form, please let us know in the comments. We love seeing how other people do things.

Coding to me is like creating art, and there’s a great quote that backs me up on this:

Programming is an art form that fights back. —Unknown

Because code is like art, I get very attached to my code, as well as my style of coding. My code is like my baby, my something from nothing that wouldn’t be there if it weren’t for me. It’s just a bunch of characters on the screen that, from somewhere in the blue smoke, creates a function, or a game, or a website. I have received criticism on my code (as everyone has), as well as given criticism on other’s code (as everyone has), and those times when I’ve received criticism on my code, depending on how it was delivered, or what was said, it was almost like a personal attack on me. And I’ve noticed a few other coders react the same way to criticisms on their code. It’s like the person who called your code ugly or inelegant was saying that your child was ugly (and those of you who have kids know… that’s a huge no-no, punishable by any means available).

It may be because I think that my coding style is the best, it’s what I’m used to, and it’s the format I use because it’s the easiest for me to get at the information I need as fast as possible. I know this because I’ve tried other styles (sometimes flipping back and forth in the same day), and looking at someone else’s code that uses a different style from me, is often times hard to peruse easily. It’s what I like, and sometimes I have to hold myself back from reformatting code I come across into my own style.

So maybe we should stop thinking of code and coding styles as being “right” or “wrong”, and think of them more like the tool that they are, a means to an end. And the way you react to someone else’s means should be a little more like a suggestion for a different method of painting. Not a matter of fact, but just another tool for the tool box.

To continue the art analogy, it’s like everybody is given all the art supplies in the world, and told to make/paint/draw/create a box. Everyone will come up with a different way of doing it, some will be huge and bright red; others will be small and drawn in pencil; others still might be made of clay or brick. No matter what, it’s the way you chose to do it, and it’s no better or worse than the person’s next to you. You might think so because yours was faster, fancier, more elegant, or more “boxy”; but they might think the opposite. In the end, you still have a box, and so do they.

I know that may seem a bit confusing, but let me give an example. Say I have an “About” page, and that “About” page has three child pages; “Who I Am”, “What I Do”, and “Why I Do It”. Now let’s also say that my “About” page doesn’t have any actual content, it’s just a container for the other three pages, and I just want to redirect my visitors to the “About | Who I Am” page without ever hitting the “About” page. Well, here’s how I do that.

First we need a page template that we can use for the “About” page that will do all the magic for us:

In a new file in your theme folder called redirect_down.php (you can really call it anything you want, this is what I used), put the following:

<?php

/*
Template Name: Redirect Down
*/

// grab the direct children pages of this page
// (both child_of and parent are needed)
$sub_pages = get_pages(array('child_of' => $post->ID, 'parent' => $post->ID, 'sort_column' => 'menu_order', 'number' => 1));

$URI = get_permalink($sub_pages[0]->ID);

// redirect the user down one level in the tree
header('Location: '.$URI);

How this works is it finds the first child of the page you are on, grabs the URI for it, and redirects you to that page.

Now when I create my “About” page (the one with no content), I set my page template to “Redirect Down” in the template drop down, and voilà, when a visitor clicks on the “About” link, they automatically get redirected to the “About | Who I Am” page, no questions asked. If I had pages under the “Who I Am” page, and it was just a container for those, I could also set my template for the “Who I Am” page to “Redirect Down”, and when my visitor clicked the “About” link, it would redirect to the “Who I Am” page, which would then redirect to the first child page.

To complete the collection… in one of the projects I worked on recently, we had a situation where if a child page link was clicked, we needed to redirect up the tree to the parent page. This is basically the same thing, just the other direction, but also a bit easier to code. Here is how it is achieved:

In a new file in your theme folder called redirect_up.php (again, you can call it anything you want, this is just what I used), put the following:

<?php

/*
Template Name: Redirect Up
*/

// redirect the user up one level in the tree
$URI = rtrim($_SERVER['REQUEST_URI'], ' /');

$URI = substr($URI, 0, strrpos($URI, '/') + 1);

if ( ! in_array($URI, array('', '/'))) {
	header('Location: '.$URI);
}

The way this works, is it grabs the URI given, and simply removes the last directory from the URI. (You could also find the parent ID from the $post data and use that to find the permalink, much like the previous template, but this works for what I needed it to do.) If you have your permalinks set up properly, this should work beautifully. And again, with this one, you can set it on as many pages as you want, redirecting all the way up the tree if you wish.

Hope this helps someone. Let me know if it helped you in the comments below.

First is the Set::extract method. When I first started using Cake, I was using the dot notation in my extract and combine calls, that is until I discovered the XPath notation that was also allowed which offers more control over your returned values. One gotcha that I discovered early on, was that to emulate the dot notation {n}.Foo, you can’t just use /Foo, you have to add a /. to the end to make it work properly. So you end up with /Foo/.. One other thing I noticed while poking around in the source, was that the argument order for extract is opposite from that of combine. With combine, you put $data, then $path[12]. With extract, you put in $path first, then $data. I was doing it wrong for a long time, but the Cake developers thought of this, and silently flip them in extract if you get them backwards.

Another method in Set that I never knew about, is enum. With enum, you give it a value, and then a list to select from. The cool thing is, if you don’t give it a select list, it defaults to yes/no. I have used this many times since I discovered it. I often use an active field in my models, and when outputting to my index pages, I would like to see Yes/No, instead of 1/0. So I just wrap the output in Set::enum($value), and it’s good to go.

Set has many methods that are really useful. One that I haven’t used yet, but would if I needed it, is normalize. I have a similar function in my little bag of tricks that I use in my own code. What it does is takes a separated string, or an array, and converts them both to an array that has been trimmed. One gotcha with this one is the $assoc argument (defaults to true). If this is on and you feed it something like:

Set::normalize('This, is, my, list');

What you’ll get back is the following:

array(
	'This' => null,
	'is' => null,
	'my' => null,
	'list' => null
);

which is not what I was expecting the first time I ran this function. What I was expecting was:

array(
	0 => 'This',
	1 => 'is',
	2 => 'my',
	3 => 'list'
);

and to get that, just set $assoc to false:

Set::normalize('This, is, my, list', false);

A helper that I discovered recently is the number helper. It doesn’t have many methods, but I’ve already used currency on more than one occasion, which adds commas and decimals as well as the dollar sign to the output. It also has toReadableSize, which converts a raw file size in bytes to one in kB, MB, GB, etc. based on the size given. There is a toPercentage method, which while it sounds like it might convert decimal numbers to a percentage (e.g.- 0.75 to 75%), all it does is round to the place you give it, and add a percentage sign on the end. It would make more sense if it did the conversion to percentage as well, instead of just adding a percentage sign, but I digress.

A class that I hadn’t heard of until a colleague of mine cleaned up some of my code with it, is the HttpSocket class. This class is really cool, it takes all that cURL type stuff, and then some, and wraps it all up in a nice little package. The methods here that interest me the most are get, and post. Both of which do pretty much what you would imagine them to do.

So there are a few of my new favorite unknown functions, what are some that you’ve discovered and now can’t live without?

If you don’t wish to update your blog software, then please continue reading.

I was writing a post on my personal blog recently and wanted to show a gallery of pictures, but I also wanted to show one of those pictures near the top of the post, but not in the gallery, and if you’ve ever tried to do this with [gallery], you know it can’t be done.

Well, now it can, and I’ll show you how.

First we take a look at the original WP function that creates the gallery. The function is called gallery_shortcode( ) and it’s located in the /wp-includes/media.php file. Make a copy of this function and paste it in your /wp-content/themes/[your_theme]/functions.php file, or create a plugin and paste it there.

Now that that’s pasted, lets take a look at it.

Near the top of the function, you’ll find the hook we’ll be using to modify the gallery function and output. It looks like the following:

	// Allow plugins/themes to override the default gallery template.
	$output = apply_filters('post_gallery', '', $attr);
	if ( $output != '' )
		return $output;

So the first thing we need to do is remove that portion from our function, because it doesn’t make any sense to hook a callback to itself.

The next thing we need to do is edit the function attributes to match the attributes in the hook. Here is the new function definition:

function my_gallery_shortcode($null, $attr = array( )) {

The $null attribute takes the empty string that gets passed and then just ignores it, we don’t need it here. The $args attribute takes the $attr variable that gets passed. you’ll also note that we renamed the function so we don’t get naming conflicts. Just under the function, right after the closing brace ( } ), add the following:

add_filter('post_gallery', 'my_gallery_shortcode', 10, 2);

This hooks the function we’re creating into the original function and overrides it.

Now that we have that, we take a look at where the function is pulling it’s data from, so we can edit that data and filter the output to exclude certain images from the gallery. Just under where the shortcode attributes are extracted, you’ll see a call to get_children( ). This is the function that pulls the gallery image data from the database. After looking through the source, I noticed there was an exclude attribute that was available to this function, but it wasn’t being used here. This will be the key to fixing this function.

Add the exclude attribute to the get_children( ) function call, and add it to the shortcode attribute extract portion of our function as well, so we get what we need out of the shortcode and don’t discard it along the way. Here is the new portion of the function, with a little bit of code before and after for orientation:

	// We're trusting author input, so let's at least make sure it looks like a valid orderby statement
	if ( isset( $attr['orderby'] ) ) {
		$attr['orderby'] = sanitize_sql_orderby( $attr['orderby'] );
		if ( !$attr['orderby'] )
			unset( $attr['orderby'] );
	}

	extract(shortcode_atts(array(
		'order'      => 'ASC',
		'orderby'    => 'menu_order ID',
		'id'         => $post->ID,
		'itemtag'    => 'dl',
		'icontag'    => 'dt',
		'captiontag' => 'dd',
		'columns'    => 3,
		'size'       => 'thumbnail',
		'exclude'    => '' //  $id, 'post_status' => 'inherit',
		'post_type' => 'attachment', 'post_mime_type' => 'image', 'order' => $order,
		'orderby' => $orderby, 'exclude' => $exclude) );
		// the 'exclude' portion at the end was added

	if ( empty($attachments) )
		return '';

Now we have a function that pulls only the gallery images we want, excluding the ones we don’t want. To use, switch your editor to HTML mode and insert the image you wish to exclude from the gallery (I apologize, but there is no other quick way that I know of to get the post id of the image besides inserting it into the post and reading from there, but I want to exclude images from the gallery because I’ve used them elsewhere in the post, so it wasn’t a big deal for me), in the image tag class attribute, you’ll see something like “wp-image-1822″, where the number is different for every image, this is the post id and that’s what you need to insert in your gallery shortcode to exclude as follows (remove the leading dot):

[.gallery exclude="1822,1845,1236"]

And there you have it, images excluded from your gallery.

Here is my complete function and hook. Note I also made some CSS changes to fit the gallery in with my floated right sidebar, which was breaking due to the floated gallery images and the clears that were on them. You can use this as is, or edit to suit your needs.

/**
 * The Gallery shortcode.
 *
 * This alters the functionality of the Gallery Shortcode for displaying
 * WordPress images on a post.
 * This function also adds an aditional option to the gallery shortcode:
 *   exclude = excludes the list of post (image) ids from the gallery
 *
 * @since 2.5.0
 *
 * @param mixed $null space filler to take up empty string argument passed by WP
 * @param array $attr Attributes attributed to the shortcode.
 * @return string HTML content to display gallery.
 */
function my_gallery_shortcode($null, $attr = array( )) {
	global $post;

	// We're trusting author input, so let's at least make sure it looks like a valid orderby statement
	if ( isset( $attr['orderby'] ) ) {
		$attr['orderby'] = sanitize_sql_orderby( $attr['orderby'] );
		if ( !$attr['orderby'] )
			unset( $attr['orderby'] );
	}

	extract(shortcode_atts(array(
		'order'      => 'ASC',
		'orderby'    => 'menu_order ID',
		'id'         => $post->ID,
		'itemtag'    => 'dl',
		'icontag'    => 'dt',
		'captiontag' => 'dd',
		'columns'    => 3,
		'size'       => 'thumbnail',
		'exclude'    => ''
	), $attr));

	$id = intval($id);
	$attachments = get_children( array('post_parent' => $id, 'post_status' => 'inherit',
	'post_type' => 'attachment', 'post_mime_type' => 'image', 'order' => $order,
	'orderby' => $orderby, 'exclude' => $exclude) );

	if ( empty($attachments) )
		return '';

	if ( is_feed( ) ) {
		$output = "\n";
		foreach ( $attachments as $id => $attachment )
			$output .= wp_get_attachment_link($id, $size, true) . "\n";
		return $output;
	}

	$itemtag = tag_escape($itemtag);
	$captiontag = tag_escape($captiontag);
	$columns = intval($columns);
	$itemwidth = $columns > 0 ? floor(100/$columns) : 100;

	$output = apply_filters('gallery_style', "

	.gallery {
		margin: auto;
	}
	.gallery:after {
		content: '.';
		display: block;
		height: 0;
		clear: left;
		visibility: hidden;
	}
	.gallery-item {
		float: left;
		margin-top: 10px;
		text-align: center;
		width: {$itemwidth}%;
	}
	.gallery-caption {
		margin-left: 0;
	}

	<!-- see my_gallery_shortcode( ) in {theme_dir}/functions.php -->
	<div class='gallery'>");

	$i = 0;
	foreach ( $attachments as $id =&gt; $attachment ) {
		$link = isset($attr['link']) &amp;&amp; 'file' == $attr['link']
			? wp_get_attachment_link($id, $size, false, false)
			: wp_get_attachment_link($id, $size, true, false);

		$output .= "";
		$output .= "

		$link
		";
		if ( $captiontag &amp;&amp; trim($attachment-&gt;post_excerpt) ) {
			$output .= "

			{$attachment-&gt;post_excerpt}
			";
		}
		$output .= "";
	}

	$output .= "
	</div>\n";

	return $output;
}
add_filter('post_gallery', 'my_gallery_shortcode', 10, 2);

I hope this helps somebody, and please leave any questions or comments below.

On my personal website, I have a single static page, my home page. This page does nothing but provide links to the rest of my site, and as such, it does not need to be PHP driven with all the bells and whistles that go with it. Just some clean code, and some clean CSS to make it pretty. Recently I found a small JavaScript snippet that I wanted on my home page, so I added it, and it looked good. The trouble is that it’s a seasonal script, and it makes no sense to leave it on all year. So instead of editing my page twice a year to add and remove this script, I figured I could go one better and dynamically add the script to my page via JavaScript. After a quick search I found Dynamically Loading External JavaScript Files which has a couple of methods listed to do this. After looking them over, I decided the DHTML method would suit my needs better.

Here is that method:

function load_script(url) {
   var e = document.createElement("script");
   e.src = url;
   e.type = "text/javascript";
   document.getElementsByTagName("head")[0].appendChild(e);
}

All this does is create a <script> tag, populate it with our data, and insert it into the head of the page. This works beautifully, but only after some of the page has been loaded already. And what better way to make sure that some of the page has been loaded than with the window.onload event?

window.onload = function( ) {
	var date = new Date;
	var month = date.getMonth( ) + 1; // +1 due to index 0

	// we only want this run between october and march
	if ((10 <= month) || (3 >= month)) {
		load_script("scripts/winter/seasonal_script.js");
	}
}

So now I have my seasonal script running only during the winter months.

But I’ve done something horrible, and you may have caught it… I just killed any previously set window.onload function. To remedy this, you can choose from a couple of different approaches:

1. Use JavaScript’s addEventListener function to append your function to the window.onload event
2. Store any previous window.onload event in a variable and then re-insert it into the function

I chose to use the latter for this because for some reason or another, I couldn’t get the addEventListener function to work properly. Here is my modified code to reflect this change:

var prevLoad = window.onload; // store any previous window.onload event
window.onload = function( ) {
	// test and make sure it was a valid function, and if so, run it here
	if ("function" == typeof prevLoad) {
		prevLoad( );
	}

	var date = new Date;
	var month = date.getMonth( ) + 1; // +1 due to index 0

	// we only want this run between october and march
	if ((10 <= month) || (3 >= month)) {
		load_script("scripts/winter/seasonal_script.js");
	}
}

That solves that problem.

One other thing that this script needs, is it uses a CSS file to style some of the effects that it’s running, and that style sheet is in my <head> tag with the rest of my style sheets. But I now only need it during the winter months, and the rest of the year, it’s just moldy bandwitch.

To remedy this, I took a look at the load_script function and it hit me… it’s basically the same thing, a tag loaded in the head of the page. So I modified the function:

function load_css(url) {
   var e = document.createElement("link");
   e.href = url;
   e.type = "text/css";
   e.rel = "stylesheet";
   e.media = "screen";
   document.getElementsByTagName("head")[0].appendChild(e);
}

Now I have two functions that supplement each other quite nicely, and a snippet of code to place them in to make the whole shebang work and download the stuff I need, only when I need it.

Now we just add the new function into the script and we get the following:

var prevLoad = window.onload;
window.onload = function( ) {
	if ("function" == typeof prevLoad) {
		prevLoad( );
	}

	var date = new Date;
	var month = date.getMonth( ) + 1; // +1 due to index 0

	// we only want this run between october and march
	if ((10 <= month) || (3 >= month)) {
		load_css("scripts/winter/seasonal_style.css");
		load_script("scripts/winter/seasonal_script.js");
	}
}

And there you have it, dynamically loaded JavaScript and CSS and not a drop of PHP to be found. The great part is, because this is all run only when we need it, it degrades gracefully as well (provided you’re not using it to load something required all the time).

A couple of gotcha’s I discovered while using this method: I was trying to dynamically load a script that had some required HTML to go with it, and I thought, what better way to dynamically load HTML than with jQuery. Well… it turns out that if you load jQuery with this method, you can’t actually use jQuery from within the window.onload function itself, you need to pull in another JavaScript file and use it there. I’m not exactly sure why, but my hunch is that it doesn’t load up jQuery until after the window.onload function is done running, and by that time, it’s too late. My solution was the following:

var prevLoad = window.onload;
window.onload = function( ) {
	if ("function" == typeof prevLoad) {
		prevLoad( );
	}

	load_css("scripts/style.css");
	load_script("http://ajax.googleapis.com/ajax/libs/jquery/1.3/jquery.min.js");
	load_script("scripts/build_html.js");
	load_script("scripts/run_script.js");
}

This way, the CSS is loaded and ready for the script, then we pull in jQuery, build our required HTML, and then run the script. Nothing gets left out, and we can run any kind of logic before hand to determine if we want to run this script or not. And if not, there is nothing left behind in our code to take up bandwidth, or otherwise make it ugly.

While the background magic is actually pretty simple (look for any properties using a variable, which are wrapped in [ ], and if found, look for the related selector, and insert the properties defined in that selector into the variable instance), the implications are great. What this means is that you can create various pieces of style that can be reused anywhere and when it comes time to edit those styles, you simply edit the one instance and they all work. Here is an example style sheet:

text_box { /* this becomes a variable */
	width: 100px;
	height: 100px;
}

notice { /* this becomes a variable */
	color: #F00;
	font-weight: bold;
}

p {
	[text_box] /* a variable in use */
}

h2 {
	[notice] /* another variable in use */
}

h3 {
	[h2] /* normal selectors can be variables as well */
	font-size: smaller;
}

p.alert {
	[text_box]
	[notice]
	/* normal properties can be used as well */
	border: 2px solid #000;
}

As you can surmise, changing the details of the [notice] variable (or any of the other variables) would be extremely easy. Simply change the color, or font-weight, in the selector where it gets defined and it propagates through to all the other instances. This, to me, is what got me intrigued by this plugin. It has far reaching implications, and can be a very powerful thing. But as with all great power comes great responsibility (and confusion.) With this, it becomes increasingly difficult to say what properties are applied to what selector, or even where they come from. Say for instance I have a variable that sets a border style and I use it in a property that also sets a border style, which one gets used? I would imagine the one that is set explicitly in that selector gets used, but then what if I am using two variable styles that both try to apply conflicting styles, one floated left, and the other floated right… what then? Which one is the intended style?

This could get ugly.

One more thing that you may or may not have thought of… What if JavaScript is turned off?

This little question is a deal breaker for me on this plugin. Not only is it a deal breaker, but it completely turns the tables on my recommendation of this plugin. Not only is the CSS completely invalid, but in the (not so) rare case that the user has JavaScript turned off, they are going to see, in the best case scenario, a completely unstyled page, and in the worst case scenario, a page that looks like it was rendered with IE (yes, that’s bad.)

It is for this reason that I recommend that, while this plugin has it’s intriguing ideas, and is certainly fun to play with, should not be used in a production environment, because it has a poor execution (through no fault of the developer, but due to the possibility of broken pages due to invalid CSS and disabled JavaScript.) But CSS spec writers take notice, this would be a great and powerful addition to CSS. But it would take a lot of thought to get some of the caveats I’ve mentioned here (and more that I didn’t) working together as the designer intended.

As I progressed in my PHP career (and hobbies), I noticed that I was building the same things over and over again, but only slightly different every time.  This was an issue that I had noticed but never really put some serious thought into… until I started at Code Greene.  My first day there, I was told to take a look at CakePHP and learn it, because it was to be the defacto PHP framework for the office.  I took a quick glance at the code base and was instantly overwhelmed.  There is so much stuff going on behind the scenes in Cake that it boggles the mind a bit.  I went through a few online tutorials, and still felt that I knew nothing about it, let alone how to use it, but I could tell that it would either make or break my new job.

My first Cake project with CG was not an easy one–it was huge.  It was the largest project I had worked on to date, and to top it off, I was forced to code it in Cake, which is almost a whole new language in itself.  As I worked on the project, I felt very frustrated at times, and wanted to just slip outside of the Cake bubble and code things the way I knew how, with some straight PHP. But I didn’t, and I’m glad.  I’m sure I made a ton of rookie mistakes. There is an extremely steep learning curve, but I was progressing with my Cake experience, and it’s well worth it once you get the hang of it.

As I work on projects now, I can pretty much get the whole back-end of the site, and all the inner workings and relationships between the data in the database and everything the administrator needs to CRUD that data set up in less than a day, even for fairly large projects.  All the magic in the background is provided by Cake. All I have to do is give it some details and let it do it’s thing.  It truly is cake.  Today, I can turn a small project around in a day or two, when it used to take me a week just to get the relationships and administration stuff built, not including the front end portion of the site.

I’m by no means a Cake expert, but I have cut my build times down to less than half, and in some cases you can count the percentage decrease on two hands.  I am also no longer overwhelmed by requests for gigantic monolithic sites, and requests to change things that would normally make me cringe.  I look at some of the sites that we build at the office, and I wonder how we could ever possibly build these sites in the time that we do if we didn’t use Cake. It’s a win-win situation for both the office and our clients. We don’t have to sweat the little things, and the client gets a fully-functional site in much less time.

My opinion of Cake may be a bit biased, as I have no basis for comparison.  Other frameworks may be better suited for some of our smaller sites that we build, but I have no doubt that for our larger sites, Cake is the right choice.  In the future, I would also love to try some other frameworks, if only to compare them with Cake, but I’m pretty sure that CakePHP will always be my framework of choice.

What’s your framework of choice?  Leave a comment below.