Nate Klaiber

My Experience with the CakePHP Framework

I have always been on the lookout for a lightweight framework that I could use for different projects. Using PHP for the majority of my projects, I looked into CakePHP, Zend Framework, Code Igniter, and Symfony. Now, to be fair, I did not learn each of these to their full potential. One of the deciding factors to me was how easy it was to get setup and running. I had looked at these around 8 months ago, but a recent discussion with Nathan Smith inspired me to check them out again. I downloaded each of the packages and set them up on my server — simply to take a look at their code, support, and documentation. I found CakePHP to be the easiest to get up and running (not that the others were hard). I found Zend to offer much of what I was looking for at its core (clean OOP code, PHP5, nice feature set) — but getting up and running was not a simple task.

CakePHP makes this a breeze by literally walking you through the steps. It lets you know if it can connect to your database, write to your /tmp folder, and then progressively lets you know if you are missing a controller, model, or view. If you were missing any of the following — it lets you know exactly what you needed to do to solve the problem (this is with the default debug set to 2). I was familiar with the CakePHP structure — and preferred it to some of the others in it’s flexibility. The directory structure is very straightforward, but allowed me to move pieces as I needed. For instance: I wanted the core cake folder to exist at the root of our server, so I could share it with several CakePHP apps. This was a breeze to implement, and helps with future updates and upgrades. One thing I liked about Cake versus Zend was how it handled things automagically — versus always having to hit the registry to retrieve and initialize an object, array, or variable. Last week I ported a previous website, primarily database driven, to a Cake application to hand over to a client. I must say, I enjoyed my time doing this. Here are a few other things I have noted about Cake:

• When I checked out Cake 8 months ago, I felt like I was locked into their naming conventions in regards to database structure. This was a big turn off due to an already existing database structure. I like the way the models are setup, and creating relationships is easy (hasone, hasmany, belongsto, and hasandbelongstomany). Once the model is setup, creating forms and running the validation (you can specify built in rules or regex) is a breeze. This was key for rapid development.

• A Very small config file and you are instantly setup and running. With just a few config options, you can handle things like ACL, sessions, security, output, and debugging. This was an advantage, because I didn’t want to really have to spend time configuring something before I could use it.

• Limited need for mod_rewrite. You could use the Apache’s lookback functionality to have URL’s like index.php/controller/action/params/ if you didn’t have mod_rewrite. I was initially worried about this because I like to use mod_rewrite for custom routing and mapping multiple URL’s to one base. I was very pleased to see the easy implementation of custom routing inside of Cake. When I recently ported an application to Cake, I wanted to keep the existing URL’s — and I was able to do this without a problem thanks to the custom routing. The only issue (and this is minor to some) was that the custom routing doesn’t work exactly like it would with mod_rewrite. For instance, I like to make sure all URL’s have one point of entry. So http://www.domain.com/page/ would be the main page, and if someone type in http://www.domain.com/page it would redirect them to the previous page). Doing this helps keep things neat and tidy in logs and in analytics and reporting. Having pages available at both page and page/ results in 2 different pages to logs and search engines.

• Having the option to override the core, without touching the cake core. I initially had a little block, but was quickly guided by Jonathan Snook on how to achieve the task. I felt stupid at how easy the answer to my question was. The ability to extend the app_controller, app_model, app_helper was a very nice aspect. Also, having the ability to create custom tags with an INI file was very nice. This made it easy to create custom helpers. My only complaint with using the default helpers is the doctype. I wish that you could declare a doctype for your page (HTML/XHTML) via the HTML helper, and then the rest of the helpers would build their tags in line with the current doctype. (If this is possible and I am not aware — please point me in the right direction).

• Handling of sessions and caching was a breeze. Granted, it is only view caching — it is still a nice option. One of the config options is to set how to handle sessions (PHP, Cake, or Database) — and again, a very nice feature to manage sessions.

These are just a few reasons why I really like the CakePHP Framework — and it is not to say that some of these might not be available in the other frameworks. I just happened to stick with CakePHP due to it’s ease of setup and documentation (API). Though documentation could be greatly improved, it was rare that I hit a problem that couldn’t easily be fixed. I like the code, I like the documentation, and I like the community (I can’t leave out Felix — who has a vast amount of resources on his site).

A small disclaimer: I have used the RoR framework and absolutely love it. This is partly why I chose to use Cake due to many of its similarities. I haven’t migrated to RoR for several reasons:

1. I am not, admittedly, fluent in Ruby — and I like to know what is going on at the core so I can fix or modify things if necessary.

2. I recently moved to a server that supports RoR, but other servers I have worked on do not have RoR available.

3. I like to completely know what I am doing before I jump into something. I have read several Rails books — but I like to know the inner workings and the language. Yes, there is always Stephen to help me out and point me in the right direction (and to tell me why PHP sucks) — but this is something I need to learn personally before I begin using it on a larger scale.