I’ve mentioned phpSprockets already — you did read the post and watch the screencast, right? — and that’s an excellent first step. But that won’t get you very far. You’re still stuck in a land of writing a bunch mysql_connect() and include 'header.php' lines at the top of every file, right?

Hell no, this isn’t 1997!

MVC Makes Everything OK Again

Everyone loves MVC frameworks nowadays. Sure, plenty of MVC frameworks existed before Rails, but that was the one — if you were a web developer, and you somehow hadn’t heard of MVC, Rails made you pay attention.

If you’re still not familiar, then you suck. But for your benefit, MVC basically breaks down your gigantic PHP file into three parts: a Model, which handles database connections and calls; a Controller, which handles requests for pages and any business logic not in your Model; and a View, which actually shows a page to a user.

For PHP there are a few MVC frameworks, and we’ll be discussing two: CakePHP and Zend Framework. We won’t go into a lot of detail, just the quick basics. And these aren’t the only two, just the two that I’m familiar with off the top of my head that I know are full of quality. I’ll have links to their websites, and since everyone loves screencasts nowadays, I’ll link straight to those. Watching someone who’s really familiar with a technology really gives you a feel for whether you’ll like it or not.

Without further ado:

CakePHP

Now, I’ll be honest — my CakePHP knowledge is several revisions out of date. Their website has changed, they’ve added some excellent screencasts, and they seem to be doing very well. That said…

If you’re secretly wishing you could develop against Rails but you can’t, CakePHP is for you. It comes with a code generation tool called bake which can generate basic code for you, a scaffolding feature that will get you up and running quickly, and a Rails-inspired API.

I’m not certain if you can override this, but Cake’s code examples and screencasts all show people coding in a PHP4 OO style — no private $mvar, instead var $mvar, and no public function foo(), just function foo(), things like that. Personally, I’m a stickler for PHP5’s OO system, which isn’t perfect but is worlds ahead of PHP4, so this threw me off. In its defense, it is less verbose, and I’m fairly sure there’s no functional difference for the end user, so it’s just a matter of style.

• Official site
• Screencasts

Zend Framework

I’m a little biased towards ZF, not because I think it’s superior, but because it’s what we use at Innova. So if I have more detail here, don’t take this as a slam towards CakePHP.

Zend Framework is a more traditional PHP framework — it requires PHP5 for all of the new Object Orientation features (face it, PHP4’s OO sucked anyway). You can’t expect less from Zend, the guys that make PHP. Zend comes with a slew of library functionality, from Zend_Mail to Zend_Auth and Zend_ACL. If you’ve ever thought, “I wish I had a library for X”, ZF probably has it.

On the downside, Zend doesn’t come with a code-generation utility (as of 1.0.3 — I haven’t checked out the 1.5 preview yet), and this means that tedious tasks are tedious. For example, in Cake (and Rails), you can have the autogeneration tool create you a basic Model, View, and Controller based on input you give it. This may not seem like much, but having the files created, placed in the right place, and named correctly automatically really saves time. And (again, as of 1.0.3) we don’t have a nice console we can use to peek in on things. Rails has that, and it seems CakePHP has a similar feature.

• Official Site
• Screencasts

So, Yeah

If you aren’t using a framework then you’re doing yourself a disservice. Check out one of the two I’ve advocated here, or Google around for the handful I didn’t mention. If you’re familiar with one I skipped, please feel free to plug it in the coomments.

So, Eddie at Innova has been touting the awesomeness of C# and the Common Language Runtime for a while — how it’s so awesome that he can write code under Mono and run it under Windows using Microsoft’s .NET runtime. And, he can take advantage of all of the .NET libraries! And if C# is the problem (which he explains is a fantastic language) then why not use IronPython or IronRuby or some such?

On the surface, this sounds like the panacea the industry’s been looking for since Sun adopted the “Write Once, Run Anywhere” slogan for Java. Certainly seems enticing — writing in whatever language you want from the set of languages that can compile down to IL, running on any platform that’s got a compatible runtime.

Except I just don’t like it.

Before we go further, understand that I’m not saying .NET isn’t the best way to go if you’re writing software that’s only ever going to run on Windows. I personally don’t like Windows, and have no desire to write software for that platform, but that has nothing to do with this debate. One more time, with emphasis: .NET is an excellent tool for writing Windows-only software.

If writing Windows software is a solution best solved by .NET, and if there’s a free-software implementation of the .NET CLR in Mono, then why doesn’t it follow that .NET is a fine solution for cross-platform software development?

I’ve got several complaints, first being that unless you’re using the common subset of features between Mono and .NET you can’t write cross-platform code. If I write a Windows Forms application, then that’s the end of it right there. You absolutely cannot run that under Mono. Now, if we start with something like GTK#, then we avoid this problem, but there are similar pitfalls for things like ADO.NET and ASP.NET.

Somewhat related to that is my second worry: Mono is always going to lag behind Microsoft’s .NET implementation. Sure, the whole thing is a published standard, but there’s still going to be a period of “This works in .NET latest but not Mono.” Again, I’m not too familiar with Mono’s past, so I can’t say with absolute certainty that this has happened or will happen, but I’d be shocked if there wasn’t a level of disconnect.

Finally, I’m just not enthused about promoting technology that Microsoft made popular. Look what happened to the browser market when IE6 was the best browser on the market — Microsoft disbanded the IE team and failed to keep up with standards. IE6 is still used by the majority of web surfers and it’s the bane of every reasonable web developer. Look at the state of operating systems. Microsoft made Windows the de-facto PC operating system and through a lack of innovation and anticompetitive business practices has set the mainstream PC OS industry back a decade.

If any of my reasons are off, feel free to let me know in the comments.

…today I uncovered a long forgotten beloved project of mine, and I dove in to get it into some kind of working shape, now that I had the experience to actually do it right. Of course, there were no comments anywhere, and there were some mysterious things going on, so it took me a while to figure out what it was all about. But this time, every time I figured something out about the old piece of code I put a comment there, explaining what it was all about. By the time I was happily hacking away at it, I realized this was the best documented piece of code I had ever written

This is an excellent way to get your code documented, and I’ve had to do this a few times myself. But imagine if you didn’t write the code in question, and you had to pick up someone else’s project from six months ago? Now the original author’s forgot all about it, and you have to figure everything out on your own.

Commenting your code beforehand saves time, energy, and lives. Leaving it until later is almost a guarantee it won’t get done. But poor commenting can make a file unreadable. Here’s a few good rules:

1. Do comment particularly tricky blocks or lines of code. Anything that’s likely to trip up someone reading the code in a few months. If you’re having trouble, check for these problem areas:
   • regular expressions
   • ternary operations (x = (expr) ? true : false)
   • bit twiddling
   • global variables
2. Do comment variables that aren’t defined in the current scope. PHP with register_globals on practically demands it. (Or, y’know, just turn it off.) Global variables, or variables that are unexpectedly modified inside subroutines, are also good areas.
3. Do keep the comments short and to the point. For example, nobody needs an introduction to finite state machines or role-based ACLs in the middle of the code.
4. Do update the comments when the code changes. If you’re following the previous rule and keeping things short and succinct this isn’t as much of a chore.
5. Don’t comment the obvious. Flooding the file with comments like # declaring age as an int or // incrementing loop variable actually have the reverse effect and make the code extremely difficult to read. If the code doesn’t need commenting don’t force it.

For the sake of your fellow coders, or your sanity when maintenance time comes, take a few seconds to put a quick # This regex validates a phone number in the format (xxx) xxx-xxxx, with or without the parenthesis.

Note: this is good natured. The guy that wrote the original article — why can I never find names on these things? — makes a few good points. And, for full disclosure, I work with PHP full-time right now, and it’s still my go-to language for knocking out a web application because I’m so familiar with it. (And even then, only with Zend Framework and phpSprockets.)

But seriously, PHP is sickening. I’ve started using Ruby and Python for any tasks I can get away with and they’re really worlds apart. PHP’s got some good in it but it’s all buried under deep layers of hate. That’s right, PHP hates you.

PHP is terrible

Need proof? Here it is, broken down by category:

Language Features

• So many things evaluate to boolean false or boolean true that there had to be a new operator introduced (=== and !==) to do strict comparisons.
• You can’t differentiate between a hash or a list or anything. They’re all the same. Even if you know you’ll never need a keyed index, you can’t turn it off.
• It’s Object Orientation is broken in places (late static binding).
• It doesn’t support lambas. create_function() is not a lambda.
• You never know if short_open_tags is on, or if safe_mode is on, or if (ugh) register_globals is on.

Built-in Functionalty

• It comes with a standard library that has no naming convention. You never know in what order the words will come in or if they’re separated by underscores or not:
  • str_replace()
  • strlen()
  • parse_str()
• You never know what order the arguments are in:
  • in_array($needle, $haystack)
  • strpos($haystack, $needle)
  • You constantly have to check your output thanks to type restrictions:
  • strpos(’abcd’, ‘a’) will return 0. Don’t test this with if (strpos(’abcd’, ‘a’)) { … } because 0 is secretly false! You’ve got to use if (strpos(’abcd’, ‘a’) !== false).

Common use

A lot of open source projects are written in it, such as Joomla, Wordpress, and MediaWiki. All of their code is hideous, and half of the time there’s random HTML in the middle of their scripts because, of course, we’re working with webpages and why would you ever want to abstract the output from the logic?

Irrelevant praise

Here are some common praises of PHP and why they don’t matter:

PHP is great because it allows the new user to pick it up quickly!

Sure. And if the introductory material available covered good programming style we might not have a problem. In reality, every example PHP script is riddled with SQL Injection vulnerabilities, XSS vulnerabilities, and terrible programming. Most newbs never learn a better way of doing things because this gets them results that look good very quickly.

PHP has classes, it doesn’t need namespaces.

Fail. Use a language with namespaces for a few months and come back to PHP. I did. It’s sickening.

Globals are okay!

Whoever taught you that needs to be shot. Globals are not okay. They are tolerable in certain situations, but if you make blanket statements like “Globals pierce through all the layers of code and get right to the heart of the matter.” then you’re clearly using them too much.

I thought I’d come out with the big guns for our inaugural post. If you’ve ever written a PHP-powered site, you’ll know that the mix of PHP and HTML in the same document can quickly become hideous to read and a nightmare to maintain.

The usual solution is o use a template engine like Smarty, but these are hard to learn and are overkill for smaller projects.

What’s a developer to do?

Enter phpSprockets, a library written at Innova Partners in Columbus OH. Take a normal PHP document that loops over database records and outputs a table:

<table>
	<tr>
		<th>Name</th>
		<th>Address</th>
	</tr>
<?php
// assume $rows has been fetched from the database
$class = 'alt';
 
foreach ($rows as $row) {
	if ($class == '') {
		$class = 'alt';
	} else {
		$class = '';
	}
 
	?>
	<tr class="<?php echo $alt ?>">
	<td><?php echo ucwords($row['name']) ?></td>
	<td><?php echo $row['address'] ?> </td>
	</tr>
	<?php
}
 
echo "</table>";
?>

That’s a lot of code for a simple task, and it’s already a mess. We’re applying a different class to alternating rows, we’re jumping into PHP from HTML, and if we need to do anything complex to this or add more rows this will quickly become unmaintainable. If you had to work with code like this, you’d hate your job eventually.

Let’s see the same code in phpSprockets:

<?php
 
$table = new Sprocket('table');
 
$headers = $table->tr();
$headers->th('Name');
$headers->th('Address');
 
$class = 'alt';
 
foreach ($rows as $row) {
 
	if ($class == '') {
		$class = 'alt';
	} else {
		$class = '';
	}
 
	$tr = $table->tr();
 
	if ($class != '') {
		$tr->class = $class;
	}
 
	$tr->td($row['name']);
	$tr->td($row['address']);
}
 
?>

Okay, the phpSprockets code is longer, but you never leave PHP-mode, and everything’s very readable. I didn’t comment either chunk of code, but once you’ve learned the simple phpSprockets syntax you’ll find that it’s much easier to go back in five months and make changes, which isn’t something you can say about stock PHP without being very rigorous about coding style. Since starting with Innova Partners I’ve switched to using phpSprockets for every PHP project I work on, and the benefits are remarkable.

This is an intentionally brief introduction. For a more in-depth look watch the introductory screencast (by me!), and for full documentation and to download, visit our downloads page.