1
2
3
4
5
6
7
8
9
10
11
12

class BobUser
{
	public $name = 'bob';
	public $publicFlag = true;
	protected $internalFlag = true;
 
	public function getFields()
	{
		$getFields = create_function('$obj', 'return get_object_vars($obj);');
		return $getFields($this); // Returns only 'name' and 'publicFlag'
	}
}

We can also do this the PHP 5.3 way with a much nicer-looking closure:

1
2
3
4
5
6
7
8
9

class BobUser
{
	// ...
	public function getFields()
	{
		$getFields = function($obj) { return get_object_vars($obj); };
		return $getFields($this);
	}
}

“… So a blogging platform won the content management system award? How sad is that?”

My knee-jerk “how sad is that?” reaction comes not because I don’t think WordPress is worthy, but because of what it implies about the state of other open source CMS projects. The reaction comes from the fact that a blogging platform is kicking your CMS’s ass in its own category.

WordPress bridges both the blogging and CMS categories due to the ‘Pages’ feature, and is extremely useful for managing a blog-focused website. Mostly. That is, until you want to do something that a CMS should be good at, like have an event calendar, custom form, photo gallery, etc. – which is why WordPress is not focused on being a CMS in the first place. Yet it does such a better job at the basic things like creating new pages, tagging, categorizing, comments, and having custom SEO-friendly URLs out of the box that it edged out other software projects like Drupal MODx and Joomla! SilverStripe whose sole focus is content management. Sad indeed.

The fact that I can go through literally hundreds of open source content management systems and still end up settling on WordPress because I know it’s the only one that won’t totally confuse my client is what’s sad. Usability and ease of use matter. They are the number one feature to the end user. If you’re involved in a CMS project, you need to do better. A lot better. Right now.

UPDATE: Some commenters have pointed out that the awards website has a specific rule:

Previous winners of the Overall category are not eligible for the Overall category in 2009. Previous winners compete amongst one another in a separate Hall of Fame category designed specifically for them.

Since both Drupal and Joomla! have won the award previously and thus were automatically excluded, I replaced their names with the CMS projects that were 2nd and 3rd behind WordPress (MODx and SilverStripe) instead. The premise of the post still holds true.

Object Oriented Apologetics

In defense of object-oriented programming – How and why you should use object oriented programming for your next project.This talk is for PHP programmers who are just learning about object oriented code, who cling to old excuses(“object oriented code is slower”), or who are otherwise unconvinced of its usefulness. Concrete real-world examples of commonscenarios and challenges that programmers face will be presented, and how taking an object oriented approach is better than a proceduralone in most cases. Copious code examples in both object oriented and procedural approaches will be provided throughout, and thedifferences and benefits of the object oriented approach will be explained.

Download Object Oriented Apologetics on SlideShare

If you were in the talk, please rate it on Joind.in

The CodeWorks Experience

All in all, the CodeWorks roadshow Dallas stop was much smaller than I expected. There were about 20 people in the talk I gave. I suppose it was both a good a bad thing. On one hand, I had a lot of fun connecting with the other speakers and attendees on a more personal level than I would have had the opportunity to do otherwise. I met a lot of new people in the PHP community that I will probably stay connected with on some level, even if it is just Twitter and IRC. We had a lot of fun the night before the presentation day eating together and hanging out.

On the other hand, I know that as a business, the relatively low attendance levels coupled with the high travel expenses could mean that something like this can’t happen again, which is a shame. This was one of the best efforts I have seen in a while to really lower the price of the conference for attendees by bringing the speakers directly to their cities or at least ones that are close by. Going to ZendCon, for instance, could easily cost up to $2,500 for the whole trip with airfare, hotel stays, and food, if not more.

The bottom line here is that CodeWorks was a good conference that offered a great value for your money. I had a great time meeting and connecting with new people and finally meeting people in real life that I had been communicating with for years. I learned some new things and finally got the kick in the pants I needed to jump into Test Driven Development, thanks to Jason Sweat’s TDD tutorial and hand-holding.

Now I’m just looking forward to php|tek in May 2010.

I was able to arrive at this solution by combining the one-line comment with the comment block in a way that takes advantage of the rules the different types of comments have to follow.

The One-Line Comment

One-line comment rules dictate that everything after the comment characters must be ignored for the rest of that line. They look like this:

1
2
3
4
5

// My code below
$someVar = array("foo", "bar", "blah");
echo "<code>";
print_r($someVar);
echo "</code>";

The Block Comment

Block comment rules dictate that once the beginning characters are started, everything up until the ending characters is ignored. They look like this:

1
2
3
4
5
6

/* My code below
$someVar = array("foo", "bar", "blah");
echo "<code>";
print_r($someVar);
echo "</code>";
*/

Combining The Two: The Best of Both Worlds

Using both those comment style rules, we can combine the two comment styles in a way that will allow us to comment and un-comment a block of code with by adding or deleting a single character. The trick is to make both the beginning and ending lines both single-line AND block style comments, like so:

1
2
3
4
5
6

//* My code below
$someVar = array("foo", "bar", "blah");
echo "<code>";
print_r($someVar);
echo "</code>";
// */

In the above example, you notice that the code will still run – it’s not commented out because the first line is following the rules of the single-line comment – ignoring the block comment declaration on the same line. By removing the first backslash at the beginning of the block, we can comment out the entire code block by enabling the block comment style instead of the single-line style. The last single-comment line is ignored because the block comment rules ignore everything up until the end block comment declaration at the end of the line:

1
2
3
4
5
6

/* My code below
$someVar = array("foo", "bar", "blah");
echo "<code>";
print_r($someVar);
echo "</code>";
// */

So a single character – a backslash at the very beginning of the block declaration can now comment or un-comment the entire block by switching the comment rules back and forth between single-line and block style. The code examples provided are in PHP, but this trick will work with any language that supports both single-line and block style comments.

I will be presenting my talk on Building a Data Mapper with PHP5 and the Standard PHP Library, followed by a discussion on ORMs and whatever else comes up. The presentation will cover all the thought processes, goals, theories, and actual code that goes into building an ORM (or really any other larger project that requires more advance planning). The project that was the basis of this presentation is phpDataMapper – an open-source PHP5 data mapper ORM layer that I started in the fall of 2008. It now powers the model layer of InvoiceMore, a live web application I launched in March 2009.

This is a presentation I have given before at Tulsa TechFest.

Watch the video of this presentation online

The project itself hasn’t changed too much recently, but I decided to finally formally introduce this project because I finally got some time to write some decent documentation on how to use PHP DataMapper in in your own application.  Head on over to the PHP DataMapper page to check it out, or just get right into the good stuff with the Getting Started tutorial or the Usage – Finders example.

More updates and documentation will be coming soon.  If you’re interested in learning more about the project or contributing, please join the Google Group.

UPDATE: Links have been updated to the new home for the project – phpdatamapper.com

Any PHP developer who’s been in the community for a while has heard preposterous claims like “use single quotes (‘) for strings instead of double quotes (“), because it’s faster”.  That is, faster over the 100,000 or so iterations it took the tester to generate a number sufficiently large enough to justify the claim, with a particular version of PHP, in a particular development environment in which it was tested.

These articles are then followed up with other posts that only serve to perpetuate and solidify the original and invalid performance claims.  Articles like these are like a plague to the PHP community, spreading around and steering novice developers in the wrong direction, concerning them with the wrong things.  Chris Vincent recently released PHPBench.com – a website that benchmarks chunks of related PHP code against each other to compare the speeds.  His goal was just a simple discovery of what code is actually fastest, and although it does yield a few interesting results, I have to wonder if it even matters.  If the tests prove anything at all, it’s that the specific syntax you choose doesn’t matter.  Why? Because it shows that newer PHP versions (he runs it on PHP 5.2+ where most of the previous articles were based on PHP 4.x) have been corrected and optimized to fix any performance discrepencies that there may have been in the past.  In the “double (“) vs. single (‘) quotes” test, Chris concludes:

“In today’s versions of PHP it looks like this argument has been satisfied on both sides of the line. Lets all join together in harmony in this one!”

Similarly, the differences in the “echo vs. print” and “for vs. while” tests are so close in speed (and again remember, this is over 1,000 iterations) that you’re just better off using which ever one is a better fit the for job you’re doing.

Optimize for Performance AFTER You Code

The true way to optimize your code to run faster is to worry about optimization after you code.  This is, of course, because the real bottlenecks in your code can only be identified after the code is already written.  When put into simplified steps, the development and optimization process would then look something like this:

1. Write code
2. Run it for a while until you (or your users) start to experience noticeable slowdowns or you begin to reach the capacity of the hardware you’re running on
3. Profile your code to identify where the real bottlenecks are
4. Re-factor and make adjustments to your code to fix those bottlenecks
5. Go back to step 2

Now that’s not to say that performance concerns should be completely discarded when writing your code – experienced developers will automatically make code and design decisions based on their experience that will have a beneficial impact on performance while they’re writing the code.  This just means that it should never be your primary focus when developing your application, and that you should never be overly concerned about it until it’s actually a problem.

The Impact on Your Code

So the real difference here is that when you listen to benchmarks and have performance as a high priority immediately, you end up making bad design decisions and waste time worrying and doing things that may not even affect performance at all in the end.  So instead, focus on your users, and do what you can to make their lives easier, no matter what you think ahead of time the performance impact may be.  If it becomes a problem in the future, you can turn your focus to the specific problem and fix your code where the problems actually are.

Conclusion

Put aside your worries about performance and just build it.  Would you rather have 10,000 users using a website with performance problems that you have to fix or 100 users using a website that is half as useful but runs 10% faster because you spent all your time focusing on performance “tips” when they may not even have an impact on performance at all?

Procedural to Object-Oriented: The Benefits of Using Object-Oriented PHP

The first presentation of mine was about object-oriented PHP programming, focusing on the many benefits it offers over a more procedural style of programming that seems to be very common in the PHP community.

Building a Data Mapper with PHP5 and the Standard PHP Library

And my second “surprise” presentation was on my PHP DataMapper project, and the steps and thought processes I went through while building it. I say “surprise” here because another presenter had dropped out due to a scheduling conflict, and I found out I was going to be doing a second presentation in his time slot the day before the conference. Surprise!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

<?php
// URL location of your feed
$feedUrl = "http://feeds.feedburner.com/VanceLucas?format=xml";
$feedContent = "";
 
// Fetch feed from URL
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $feedUrl);
curl_setopt($curl, CURLOPT_TIMEOUT, 3);
curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_HEADER, false);
 
// FeedBurner requires a proper USER-AGENT...
curl_setopt($curl, CURL_HTTP_VERSION_1_1, true);
curl_setopt($curl, CURLOPT_ENCODING, "gzip, deflate");
curl_setopt($curl, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3");
 
$feedContent = curl_exec($curl);
curl_close($curl);
 
// Did we get feed content?
if($feedContent && !empty($feedContent)):
	$feedXml = @simplexml_load_string($feedContent);
	if($feedXml):
?>
	<h2>From The Blog...</h2>
	<ul>
	  <?php foreach($feedXml->channel->item as $item): ?>
		<li style="padding:4px 0;"><a href="<?php echo $item->link; ?>"><?php echo $item->title; ?></a></li>
	  <?php endforeach; ?>
	</ul>
	<?php endif; ?>
<?php endif; ?>

The code above gets the feed contents and then displays a nice summary of all the headlines in an unordered list with links using SimpleXML. Feel free to replace the USER-AGENT string with your own, or simply leave it as-is. The current one is for Windows XP and Firefox 3.03. You can get your own USER-AGENT string from a phpinfo() call towards the bottom of the page in the environment variables section.