For the purpose of this post, the best of these is free. But not free in the sense you might think. Consider this quote:

Not free as in beer, but free as in freedom.

There’s a spirit behind Open Source. A free-spirit. I consider Open Source a philosophy. A philosophy to freely share with others. This philosophy creates an interdependence. Open Source could not exist without these free-spirits contributing back to the source.

But how do you contribute? Because of the strong link between Open Source and Open Source Software, many think you have to develop code. While this is one way to contribute, there are many others. My hope is you will find one that allows you to contribute to Open Source.

Open Source Software

As noted the most obvious way to contribute to Open Source is code. And most obvious way to do that is Github.

GitHub makes it incredibly easy to release (push), copy (fork), and contribute (pull request) code. They’ve also done an excellent job of abstracting this process, while still keeping good development practices - source control.

Github is built atop git. If you’re just getting started with Github or git, I suggest browsing Github’s Help and reading Pro Git.

Open Data

We’ve reached the data age. You’ve probably heard the latest buzzword Big Data. Data, big or small, drives the Internet. And there is a growing movement towards Open Data.

Many organizations have released their data to the public. Often in formats readily used by developers. A good example of this is U.S. Census Data.

You don’t have to have big data to contribute. You just need data. If so, contribute your data.

Open Service

Similar to Open Data, services also drive the Internet. API’s are everywhere. Twitter and Google have led the way by opening their services. In turn, these services created entire ecosystems.

If you provide a service, consider releasing it as an Open Service. If you can not open all your services, you could adopt a freemium model. Your service could help foster another.

Open Support

Releasing code, data, or services is the easy part. Out in the wild, it needs support. It needs your help. To me this is the lifeblood of Open Source - its community. Without you, these projects would not survive.

Open source projects need communities. People to help support the project by testing, reporting bugs, and promoting growth. You don’t need to be a guru to support a project. Jump in and get started by sharing your experiences.

Open Documentation

Often Open Source projects lack documentation. After all developers hate documenting. If you use an Open Source project that lacks documentation, contribute by writing or expanding the documentation. You can also write tutorials. If you know another language contribute by translating the documentation to help the project reach more people.

Open Design

Developers rarely design. An Open Source project often lacks color. As a designer, contribute your creativity by helping brand the project.

Open Sharing

Finally, you can contribute by simply spreading the word about the Open Source projects you use. The goal of any Open Source project is to reach people. You promoting the project helps accomplish that goal. Write a blog post, tweet, or email the author to say thanks.

Why Contribute

Why should you contribute? Well, sharing is caring. We all just want to help, right? As noted, the Open Source spirit is a free-spirit.

Let’s be honest, we live in a material world. Sometimes we follow more along the lines of show me the money. Contributing to Open Source is not without recognition.

Contributing can be a form of self-promotion. Employers often request Github accounts from potential candidates. Personally, my reputation on StackOverflow has led to many recruiter calls and talking points during interviews.

It’s also not uncommon for an author to earn money from their project. Organizations often use open source project, but will pay for consulting, installation, or support. In some cases, end-users pay to fix or improve projects.

Whatever your reason, start small. Any contribution helps. I know you’ll find the experience rewarding.

I recently moved to New York. So once Spring was here to stay, I broke out the trail map. A train stops right along the Appalachian Trail 86 miles north of New York City.

Unfortunately not all of my gear made the move. Several items were left behind. One of which was my hatchet. I needed a replacement.

I set out to the local Home Depot over lunch. You see I am from Kentucky. Where Home Depot has a whole aisle of axes and a guy who could tell you about each one. So I didn’t think anything of it.

I jumped on the subway to midtown. There was a Home Depot off 23rd Street and Fifth Avenue in the Flatiron District.

This happened to be the fanciest Home Depot ever. Storefront windows. Elegant displays. The look of a retail store, not the concrete and orange steel of a standard Home Depot.

I walked straight in and asked:

“Where are your axes and hatchets?”

The preppiest Home Depot worker ever answered awkwardly:

“Ahh. What are you doing?”

I did not respond. Only stared at him waiting for the answer. Which I now realize likely made things more awkward.

He quickly became helpful.

“Downstairs. In the back.”

Needless to say, their selection was not great. Then again, why would anyone in Manhattan buy a hatchet?

First, debugging is hard. Especially debugging database issues. Often times the best approach is to systematically rule out what cannot be the problem. This checklist adopts such an approach from a low to high level.

Can you connect to the database outside your application?

Verify you can connect to your database by logging into MySQL from the command line.

mysql -u dbuser -p -h localhost database

If you have a specific database user for your application, be sure to verify their credentials as well.

If you do not have command line access, you can use another database administration tool (e.g. PHPMyAdmin).

If you cannot connect to the database, you need to start at the beginning: Ensure MySQL is running, your database exists, and your credentials are correct.

Can you connect to the database insider your application?

Verify you can connect to the database from PHP. Test with a separate script to also rule out bugs in your codebase:

1
2
3
4
5
6
7
8
9

<?php
$link = mysqli_connect('localhost', 'my_user', 'my_password', 'my_db');

if (!$link) {
    die('Connect Error (' . mysqli_connect_errno() . ') '
            . mysqli_connect_error());
}

echo 'Connected... ' . mysqli_get_host_info($link) . "\n";

If this code connects, but your application code does not, debug your application code.

If this code does not connect use the output for clues. You can also check your PHP error logs. It’s likely your MySQL module is misconfigured. Use phpinfo() to review your MySQL configuration.

Does your query run successfully?

More often than not the query is the problem. Especially if the query is generated dynamically. The best way to verify your query it to output and run it yourself.

1
2
3
4
5

$sql = 'SELECT column FROM table WHERE column = $bad_var';
echo $sql;
if (!$mysqli->query($sql)) {
    echo 'Error: ', $mysqli->error;
}

In this case, we’d see that $bad_var is not set. As such, the query becomes:

SELECT column FROM table WHERE column = 

Note: This code above is a contrived example of a dynamic query. If you do not see what else is wrong with this query, please read about SQL injection.

You can debug in any order. Top down or bottom up. Just remember this is by no means exhaustive. Nonetheless, following this debugging checklist will help diagnose a majority of your database issues. Please share other common database debugging you use.

A single WordPress symlink

My original solution symlinked all-the-things. The entire top-level WordPress structure symlinked to the core WordPress install. While this works, it’s brittle. If the top-level WordPress structure changed in a new version the tenant install may break. Although I mitigated this with an install script, there was room for improvement.

Bastiaan pointed out that you could move WordPress into its own directory. After following the steps outlined in the WordPress Codex (carefully in order) you can use a single symlink. A much cleaner solution.

Having a single symlink also makes maintaining tenant installs easier. I can quietly install a new version of WordPress while tenant sites safely point to an old. Then update their symlink (thus updating WordPress) as needed.

WordPress Must Use Plugins

WordPress also introduced Must Use Plugins. A WordPress install must use these plugins - meaning they are automatically activated, and can not be deactivated. Using WPMU_PLUGIN_DIR and WPMU_PLUGIN_URL I can configure the location of mu-plugins just as I did for wp-content. Now the WordPress multitenant install can share even more between the tenants.

A note about security

Strebel left a comment that there were “significant security concerns” with my WordPress multitenant solution. Unfortunately he did not elaborate. Thanks Strebel…

I am not a sysadmin. Nonetheless, to mitigate any security concerns I set permissions of the core WordPress directories and files to 755 and 644 respectively. In addition, all of the core WordPress are owned by a non-tenant, non-web user. Note: This will not work in an suPHP environment.

In addition, I have moved some of the configuration settings related to the multitenant install to the core wp-config.php. This prevents tenants from changing their configuration. And as you can not redeclare PHP contants, they can not overwrite this configuration.

1
2
3
4
5
6

// set global configurations
define('WP_CONTENT_DIR', $_SERVER['DOCUMENT_ROOT'] . '/wp-content');
define('WP_CONTENT_URL', 'http://' . $_SERVER['SERVER_NAME'] . '/wp-content');

// load site-specific configurations
require_once dirname($_SERVER['DOCUMENT_ROOT']) . '/wp-config.php';

I also follow common WordPress secuity practices, such moving wp-config.php outside webroot for both the core and tenant installs.

WordPress multitenant structure

The web directory of a tenant using the updated WordPress multitenant install:

webroot$ ls -l
total 16
-rw-r--r--  1 jason  staff  200 Mar 30 13:35 .htaccess
-rw-r--r--  1 jason  staff  405 Mar 30 16:17 index.php
lrwxr-xr-x  1 jason  staff   20 Apr  6 14:30 wordpress -> /opt/wordpress/3.5.1
drwxr-xr-x  6 jason  staff  204 Mar 30 16:35 wp-content

A few notes:

• Core WordPress files live in a versioned subdirectory of /opt/wordpress/. Such a structure allows for multiple WordPress installs.
• wp-content lives at the top-level.
• mu-plugins is a symlink under wp-content.

As always, I welcome your feedback.

Oh, you want to know why? Fine. Keep reading.

Let’s review the fundamental aspects of PHP namespaces as stated in the PHP Docs Namespace Overview:

namespaces are designed to solve two problems that authors of libraries and applications encounter when creating re-usable code elements

So namespaces focus on re-usable code elements. Let’s look at the two problems:

1. Name collisions between code you create, and internal PHP classes/functions/constants or third-party classes/functions/constants.
2. Ability to alias (or shorten) Extra_Long_Names designed to alleviate the first problem, improving readability of source code.

namespace solves problem #1. use solves problem #2. But things can get circular. use can introduce name collisions and confusion. Which respectively reintroduces problem #1 and is the opposite of improving readability.

Consider the following namespaces and classes:

1
2
3
4
5
6
7

namespace MyApp;

class Service {
  public function method() {
      echo __NAMESPACE__ . '\Service';
  }
}

1
2
3
4
5
6
7

namespace MyApp\ComponentA;

class Service {
  public function method() {
      echo __NAMESPACE__ . '\Service';
  }
}

A Controller class with use:

1
2
3
4
5
6
7
8
9
10

namespace MyApp;

use MyApp\ComponentA\Service;

class Controller {
  public function output() {
      $service = new Service();
      $service->method();
  }
}

Which Service class is created? MyApp\Service or MyApp\ComponentA\Service?

It may be straightfoward with the entire codebase in front of you. But consider a larger codebase. What if you refactored output() into another class? It all depends on the use statement. Meaning the code is tightly coupled with use.

The same Controller class without use:

1
2
3
4
5
6
7
8

namespace MyApp;

class Controller {
  public function output() {
      $service = new MyApp\ComponentA\Service();
      $service->method();
  }
}

No question on which Service class is created and no coupling.

There are other problems with use, such as dynamic naming. But you don’t need more convincing. use breaks what namespaces solve.

Spend a few extra keystrokes typing absolute namespaces for code clarity and portability. Future developers will thank you.

So why did I leave? It’s unfair to look at any specific job. I liked the The New York Times. So the question isn’t why I left The New York Times, but instead why I leave a job.

This is something I’ve reflected on after leaving each of my former jobs. Actually, I first drafted this post after leaving Humana in 2010. Over the years, I reduced the citeria down to three.

Good Leader

There’s an entire article bouncing around the web recently dedicated to this topic. So I will not go into great detail on the importance of a good manager. We all want to work for someone we respect. A true leader. Someone in the chain of upper management must be a good leader.

Talented Coworkers

Good developers learn. I believe the best way to learn is to surround yourself with talented people. While I believe I am talented, I know I’m not the most talented. I want to be among peers not only so I improve, but we improve together. Anything else and you risk becoming a big fish in a little pond.

A Bright Future

Either personally or professionally, your job must offer growth. We’re human. We want to know that whatever we do, it’s done for the better. If your job isn’t going somewhere, you should go somewhere else.

Our society pushes a live to work mentality. I’ve never bought into that notion. In the words of Tyler Durden, “you’re not your fucking job”.

The average American spends a third of their adult life working. You should find a job you like. So I use these criterion to form my own mentality:

• Missing one - fine, nothing is perfect.
• Missing two - the grass looks greener at a new job.
• Missing all three - I give two-weeks notice.

Some day my work/life balance will shift, and these things may not matter as much. But today is not that day.

First, for those not familiar, Family Feud is a television game show. Two teams - typically families - compete against one another. They face-off to guess the top answers of a survey question. If you win the face-off, your family has three individual attempts to guess the rest of the top answers. If your family can not, the other family has the chance to steal if they guess one of the remaining answers. One family is awarded points from each round. The family with most points after a few rounds goes to the final round.

Now the common strategy is to play if you win the face-off. This is wrong. In fact, it’s ridiculous. Yes, I am saying everyone who has ever played Family Feud is wrong.

So what’s the secret to winning Family Feud… defer.

That’s right. It’s that simple. If you win the face-off, defer.

I’ve crunched the numbers on this (from my extensive viewership). You can flip the odds in your favor by defering. Put the pressure on the other family to guess all the answers. When they don’t (and they won’t) you steal.

Not convinced? Allow me to introduce something called Probability. Family Feud surveys 100 people. You have to guess the top most common answers of these 100 people. Seems easy enough. And it is for a few answers. The rest of the answers occur far less frequently. This is called a long tail distribution.

So, if you play, your family must guess all the top answers answers. That’s unlikely. Or shall I say improbable. Remember this survey is not from factual data. It’s from people. People who provide what I’ll call a subjective answer.

The probability of guessing the top answers in the face-off is very high. But the probability of guessing all the remaining long tail answers is low. So, instead, defer. Have the other family try, while your family has the time to think of one of the long tail answers together.

To this day, I have yet to see a family defer after winning the face-off. The desire to play is too great.

If you’re a contestent on Family Feud (or if Family Feud would like to put my family and I on the show) try this. You’ll make it to the finals. Just don’t forget to thank me when you win.

I recently had a task to update some legacy code. This code was high-profile. All of our stacks ran a version. So I needed to ensure that my updates were compatible.

Upon reviewing the code it contained a version variable (VER). Perfect! A version variable is perfect to use as a feature flag. I could wrap my updated code inside conditionals until the rest of the stacks were upgraded.

if (thisver == 101) {
    // new code
}

Done. Right? Well, yes and no. Yes, this code is backward-compatible. I safely wrapped my new code in featured flags. So I can rest assured it will only run when the feature flag is set. In this case, when thisversion equals 101. However, no because unit tests failed for old versions of the code.

After some debugging, I found the issue:

if (thisver > VER || thisver < 100) {
    return;
}

Although I incremented VER for my new version, the old version still had the previous version number. While my code was indeed backward-compatible, old versions always failed this little gem: thisver > VER. The old code was not forward-compatible. This logic prevented me from using an ideal version variable as a feature flag.

I will not speculate on the original developer’s intention. However, given the code’s high-profile and the existence of VER the logic above is odd and a good demonstration of code that is not forward-compatible.

Server Configuation

Last summer I migrated WordPress to Amazon EC2. I decided to stay on EC2 for Octopress for two reasons. First, a micro instance is, essentially, free. Second, if the micro instance can serve a WordPress blog, it can serve a static HTML blog.

I made a few optimizations to the Apache configuration. Namely decreased Timeout, KeepAlive enabled, and tweaked connection limits. I also disabled AllowOverride.

For PHP I installed and enabled APC.

WordPress used object-cache and Hyper Cache.

Benchmark Configurations

I benchmarked the following configurations using the Apache benchmarking tool (ab):

1. WordPress Page Request
2. WordPress Post Request
3. Octopress Page Request
4. Octopress Post Request

Each benchmark made 1000 requests for 50, 100, 150, and 200 concurrent connections using both close and keep-alive. I performed each benchmark 3 times to average the result.

Benchmark Results

I created two graphs from the benchmark results:

• Average request per second
• Average time per request (in milliseconds).

Request Per Second

Without surprise, Octopress is faster than WordPress. Roughly 3 times faster (300%). In some cases reaching an impressive 2,000 requests per second for close connections, and nearly 3,000 requests per second for keep-alive connections.

Octopress performed the same as WordPress for page requests with 200 concurrent close connections. However, this implicates the micro instance more than Octopress or WordPress.

Time Per Request

The time per request results are similar to the requests per second results. Even the page request anomaly appeared. Nevertheless, Octopress is still faster than WordPress.

For most of the benchmarks, Octopress response times were under 100 milliseconds. This not only improves user experience, but search engine optimization as well.

Sever Stats

The following are screenshots of memory and CPU usage graphs taken from my New Relic dashboard during the benchmarks.

With WordPress, the server spikes well above its physically memory and CPU limits.

With Octopress, the server has 60% of its physical memory available and vi shows up in the Top 5 processes — wow.

Benchmark Conclusion

It’s no surprise Octopress is faster than WordPress. Octopress uses static files whereas WordPress uses 10,000 lines of PHP code performing various database queries. While you can make WordPress faster, it’s worth nothing that without caching WordPress did not finish any of the benchmarks above. In fact, it crashed my server.

I plan to add another benchmark configuration for nginx and possibly Varnish. In addition, I’m monitoring the potential search engine optimizations from this migration. Look for posts on both in the coming months. In the meantime, I welcome your feedback.

Years ago, I created LastPlayed — an app around sharing your playlist with those around you. A social soundtrack to introduce you to new music. I’ve since let it die to the rise of giants like Pandora and Spotify.

Spotify spoke at our recent TimesOpen Hack Day. I learned more about their service. Things which made me think of Apple, and why Apple should buy Spotify.

Expanding iTunes

For years, Apple has tried to expand iTunes with services like Ping (#Fail) and iTunes Match. Clearly Apple wants to evolve iTunes into a social network.

Buying Spotify would give iTunes the boast it needs. By integrating Spotify with iTunes both sides benefit. Spotify can grow subscribers with the appeal of the larger music collection offered by iTunes. Apple can up-sell music downloads.

Expanding the App Store

Spotify has its own app ecosystem. But as far as I can tell, all these apps are free. While a great a value add for Spotify subscribers, they’re missing an opportunity for monetization.

If Apple buys Spotify, Apple can package the Spotify API with in the next iOS SDK release. Opening the door to a larger developer base to develop both free and paid apps. I know I’d be very interested in developing such apps.

The time to buy is now

Apple has the cash. I have to believe the revenue generated by expanding iTunes and the App Store alone would show a return on investment. Apple should buy Spotify — before Facebook does.

First, I am a fan of WordPress. I’ve written many posts on WordPress, spoken at WordCamps, and will continue to develop with WordPress. But WordPress is slow. And I had a need… a need for speed. Greasy, fast speed.

Enter Octopress:

Octopress is a framework designed for Jekyll - the blog aware static site generator powering Github Pages.

Github uses it — that’s reassuring. Static site — you don’t get much faster than serving a static resource. Look for a follow-up post with the performance showdown between Octopress and WordPress soon.

I also wanted something simple. I don’t use all the features of WordPress. I just write posts from time to time. From the beginning I’ve drafted my posts in Markdown. Jekyll uses Markdown in its templates. Simple.

You may be wondering the difference between Jekyll and Octopress. Jekyll is tool, Octopress is the packaging. Octopress nicely wraps some of the rough edges of Jekyll making it easier to manage. It also offers themes and plugins.

Now if, like me, you’re sold on Octopress read on. If not, thanks for reading this far. Long live WordPress!

Migrating from Octopress to WordPress

Here is an outline of the steps for migrating from WordPress to Octopress with more details below.

1. Installed Octopress
2. Migrated Content from WordPress
3. Previewed Site
4. Deploy Octopress

Installing OctoPress

For the most part, I followed the Octopress Setup. The only exception being Ruby. I’m on Mac OS X Mountain Lion. So my Ruby version was 1.8.7. I updated Ruby with RVM.

curl -L https://get.rvm.io | bash -s stable --ruby

Migrating Content from WordPress to Octopress/Jekyll

There were several migration options. I tried a few of them and found Export to Jekyll best as it ran content through the approriate WordPress filters. While Export to Jekyll was the best of the bunch, it wasn’t perfect.

• Encoding issues. After moving the files from Export to Jekyll rake generate erred about gsub. The issue was UTF-8. With some debugging, I found several UTF-8 characters in my posts. Mostly smart quotes and other artifacts like EM dashes from Mac OS X. Unfortunately I didn’t find a quick fix. I ended up replacing these with HTML entities using some sed commands. This was the worst part of the migration. And it wasn’t that bad.
• Missing meta data. Aside from the title, none of the WordPress SEO settings were exported. I wrote a PHP script to add the description and keywords to the Front Matter. I will likely fork Export to Jekyll soon. If you’re interested in these, please leave a comment.
• Misconfigured comments. The export did not set comment in the Front Matter. I fixed this with a quick sed command as all my posts allow comments. However, this is something Export to Jekyll could have done.
• Exporting comments. I migrated my WordPress comments to Disqus. Suprisingly simple. But Disqus took several hours to process the import (130 comments).
• Static resources. I needed to download the static resources in my content (images, PDFs, etc). This is not necessary if you use a static domain. But if you use WordPress uploads/, you’ll need to download them to Octopress source/. I wrote a curl script to do so.

Deploying Octopress

Octopress has a few automated deployment options. I used rsync. However, my blog runs on Amazon EC2. So I needed to configure my EC2 private key to deploy Octopress. After doing so, I deployed to Octopress to my Amazon EC2 instance by simply typing rake deploy.

Blogging with Octopress

Octopress is not without its own challenges. I found limited SEO out-of-the-box and I will need to learn the nuiances of Octopress themes. Look for future posts on both.

Nonetheless, with Octopress I can write like I always have. I don’t have to manage WordPress upgrades or plugins. I don’t have to make WordPress faster. I just write. This frees up my time for other things.

On a personal note, it bothers me to find such poor quality posts in a PHP newsletter. Posts like this confuse developers and in turn contribute to the poor code notorious in the PHP community. Adding fuel to the fire of the anti-PHP community for why PHP sucks.

I have no doubt the author had good intention. But at the least, he should have provided supporting evidence. After all, a good developer asks Why? I reviewed the recommended optimizations in the original post. Evaluating recommendations to be absolute truths and marking each true or false. Please read the full section before you segfault.

foreach vs. for

False.

foreach is faster when looping over an array for reading. If you need to write to the array the performance of foreach degrades significantly. So for has its place.

Another case for using for is when the block contains counting logic.

Consider:

for ($i = 0; …; ++$i) {
    // block
}

Versus the foreach equivalent:

$i = 0;
foreach (…) {
    // block
    ++$i;
}

Exception: When looping over a sequential numerically indexed array, the array key could serve as a counter.

for Truth

Two absolute truths when using a for loop.

1. Pre-calculate parts of the condition expression. The condition within for evaluations the condition on each iteration. Avoiding the overhead function calls which return value will not change during the loop will optimize your code.
2. Use pre-increment. By nature, pre-increment is a faster expression.

Code:

$count = count($arr);
for ($i = 0; $i < $count; ++$i) {
    // block
}

Double vs. Single Quotes

False.

Back in 2007 I emailed Ilia Alshanetsky about this very matter. He called it an Optimization Myth. However, that was PHP 4. Somewhere in PHP 5 double quotes were optimized (I heard PHP 5.1).

Double quotes performing better than single quotes is counter intuitive. Without the need for variable expansion, it stands to reason single quotes would be faster. Furthermore literal values (single quote) could be optimized in memory.

I’ve benchmarked double quotes versus single quotes several times without finding anything conclusive. Maybe double quotes are indeed faster. But to replace all single quotes with double quotes as the original post suggests is not worth the time. In the end, following your code style is more important.

UNION vs. OR

False.

I am currently reading High Performance MySQL. In fact, I just finished the chapter on query optimization. This recommendation actually put me on the path to writing this response post. Stating change all `OR` to `UNION` is just plain reckless.

First, the original example is bad. It suggests changing:

select username from users where company = ‘bbc’ or company = ‘itv’;

to:

select username from users where company = ‘bbd’
union
select username from users where company = ‘itv’;

When using the same column, the opposite of what the author suggests is more performant. That is you should change from a UNION to an OR when the WHERE clause operates on the same column.

Second, changing OR to UNION in your queries may not return the same result. While UNION may be an optimization, you need to understand when to use it. Do not sweepingly replace OR with UNION in you codebase.

As I am admittedly still learning MySQL Optimizations, I posted the topic to the StackOverflow community. I encourage you to read the answers for more details on why UNION vs OR is not always an optimization.

Additional PHP Optimizations

The original post did contain a few true optimizations.

• Use echo versus print. True.
• Use string functions over regular expressions. True, with the exception of complex pattern matching. The equivalent regular expressions code written using string functions will be more performant. This is noted in the PHP documentation for the regular expression functions.

The Performance 80/20 Rule

Performance follows the 80/20 Rule. If single quotes vs double quotes accounts for 80% – you’re optimized. Congratulations. You can go home. That is an absolute truth.

Remember

There is no silver bullet. Be skeptic of absolute statements. There are many moving parts in a system. What works for someone else may not work for you. When it doubt, benchmark it yourself.

References

If you are interested in PHP performance and optimizations, check out the following resources:

• The PHP Benchmark
• PHP Performance Metrics

Also, consult the PHP Documentation. The function definitions and user comments contain valuable information.

“[certain language] developers are better developers.”

I generalized the argument because I’ve heard it before. We all have. Fill in the blank with any fashionable language – Scala, Ruby, Go, Python…

This argument quickly degrades into a language debate. One filled with feature comparison and syntactical analysis to demonstrate superiority. Why? Well, let’s face it – developers can be elitist when it comes to their language.

I also generalized to keep the focus off [certain language] and focus on the developer. I want to evaluate this argument objectively. And if I said, “PHP developers are better developers” you would have dumped core. Which proves the point.

From this argument, I propose the following, implied premises:

• [certain language] is a fashionable language.
• The developer learned [certain language].

Applying the Law of Syllogism:

Developers that learn fashionable languages are better developers.

This becomes a much more acceptable argument.

As recommended in The Pragmatic Programmer, you should learn a new programming language every year. This being a routine of a good developer. One I personally follow. The purpose is to learn something new from each language. In turn making you a better developer.

So next time you hear, “[certain language] developers are better developers”*, consider the developer. It might just be valid.

This year we named our team the Kentucky Irregulars from the movie Reign of Fire. Each of us adopted a theme from the movie. My brother wore a Hard Rock London shirt. Joel grew his dense beard to resemble Quinn. As the most extreme, I honored Van Zan by buzzing my head, growing a rugged beard, and replicating his bomber jacket vest.

Similar to last year, the weather was overcast, windy, and in the 40s. We had an 8:00am start time. So limited sleep added to the challenge. But we prefer the early start for a fresh course. Free from obstacle lines and everything covered in mud.

Now the Tough Mudder is challenging all around. Beyond the obstacles. You’re running on uneven ground over rock, sand, mud, or tall grass. You’re constantly wet and often covered in mud. So you’re constantly carrying a few extra pounds. The weather, hot or cold, also drains your energy.

Most Dreaded Tough Mudder Obstacle

Arctic Enema.

Previously named Chernobyl Jacuzzi. This obstacle is a 30ft long pool of 5ft deep ice water. Literal ice water. You climb up one side and jump in. Instant shock. You struggle to breathe. A barrier divides the pool forcing you under the ice. You climb out the other side. The water, so cold, shrinks your clothes.

Most Fun Tough Mudder Obstacle

Everest.

Everest is a 12ft quarter pipe. You get a running start and leap for the rim. Typically mud covers the approach and ramp, adding to the challenge. This obstacle requires a helping hand from your fellow Mudder. And it’s that camaraderie which makes this obstacle fun. Headbands off to the Tough Mudders who tackle Everest solo.

Toughest Tough Mudder Obstacle

Berlin Walls.

The Berlin Walls are a set of wooded barriers ranging from 6-12ft high. Typically each course contains a few sets. The first few are easy. But when you get to the series of 10-12ft walls, the fun stops. By that point in the course, it takes everything you have and a fellow Mudder, to get over these walls.

Signature Tough Mudder Obstacle

Electroshock Therapy.

This is the signature obstacle of Tough Mudder. A 10-yard muddy gauntlet of dangling 10,000 volt hot wires. The finish line waits on the other side. My goal is always simple – don’t fall.

A Tough Mudder

While everyone loves the pictures, people always ask why. Why would you do that? It looks miserable. My brother tells me, “They wouldn’t understand”. I agree it is difficult to explain. Ultimately, you’re not going to understand Tough Mudder until you do Tough Mudder. I consider Tough Mudder hard fun. I respect the challenge.

There are signs placed along the Tough Mudder course. I noticed one this time to this very point. It read:

Be patient and tough. One day this pain will be useful to you.

Coding standards vary greatly among developers. Even when writing the same code. And therein lies the problem. This becomes most evident when reviewing code that is not your own.

My own coding standards have changed over the years. As team lead, I drafted coding standards documents. This time, I wanted something active and easily adopted.

PHP coding standards

The PEAR coding standard is arguably the most prevalent among the PHP community. However, it is exhaustive and therefore not easily adopted. When reading about PHP namespacing last year, I came across the PHP Standard Requirements (PSR).

The latest version of this standard is PSR-2, which expands PSR-1, is a straightforward document outlining basic coding standards. It leaves some flexibility for developer style. And while I may not agree with every standard – mainly the curly brace conventions – it passes the governance.

Stick to the coding standards

It is human nature to bend the rules. But there’s no point in adopting a standard only to break it. I wanted to follow PSR-2 strictly. Not just the parts I liked. So I needed something to keep me honest.

A while back I came across PHP CodeSniffer. I intended to use it for automated code validation with an svn post-hook. PHP CodeSniffer features pluggable coding standards you can validate against. In addition, one for PSR-2 exist.

You can download PHP CodeSniffer. If you have PEAR installed, it’s easier:

pear install PHP_CodeSniffer

Verify PHP CodeSniffer with:

phpcs --version

Note: If you receive warnings, your PHP include_path likely does not include the PEAR directory. Check your PEAR installation to resolve this issue.

You can run PHP CodeSniffer against an entire directory.

phpcs --standard=PSR2 api/

Format legacy code

Since I just adopted the PSR-2 coding standard, I had several violations in my current projects. However, as traditional lazy developer, I didn’t want to edit hundreds of lines of code.

I found PHP CS Fixer. It auto-formats code to meet PSR-2 (among others). While it doesn’t correct everything, it fixes the tedious ones.

php-cs-fixer fix api/ --level=psr2 --dry-run

Note: I added --dry-run for demonstration purposes. Remove it to update your files.

Go forth and be a better PHP developer

A good developer should follow a coding standard. While I am advocating PSR-2 here, it is really up to you. What matters is that you follow it strictly. Hopefully the tools above can help you do so.

This post is part of a series on How to be a Better PHP Developer.

PEAR is PHP’s Package Repository and makes it easy to download and install PHP tools like PHPUnit and XDebug. I specifically recommend these two for every PHP developer.

Download PEAR

curl -O http://pear.php.net/go-pear.phar
sudo php -d detect_unicode=0 go-pear.phar

Configure and Install PEAR

You should now be at a prompt to configure PEAR.

1. Type 1 and press return.

2. Enter:

   /usr/local/pear
   

3. Type 4 and press return.

4. Enter:

   /usr/local/bin
   

5. Press return

Verify PEAR

You should be able to type:

pear version

Eventually, if you use any extensions or applications from PEAR, you may need to update PHP’s include path.

In addition, I will be co-speaking with Nick Temple about WordPress Deployment. This talk includes open-discussion of the following:

Hosting WordPress

• Shared Hosting
• Tailored WordPress Hosting
• Cloud Hosting

Deploying WordPress

• Configuring for WordPress in Multiple Environments
• WordPress Skeleton
• WP Stack
• WordPress Multitenancy

I am aware of the several packages available, notably MAMP. These packages help get you started quickly. But they forego the learning experience and, as most developers report, eventually break. Personally, the choice to do it myself has proven invaluable.

It is important to remember Mac OS X runs atop UNIX. So all of these technologies install easily on Mac OS X. Furthermore, Apache and PHP are included by default. In the end, you only install MySQL then simply turn everything on.

First, open Terminal and switch to root to avoid permission issues while running these commands.

sudo su -

Enable Apache on Mac OS X

apachectl start

Note: Prior to Mountain Lion this was an option for Web Sharing in System Prefrences → Sharing.

Verify It works! by accessing http://localhost

Enable PHP for Apache

First, make a backup of the default Apache configuration. This is good practice and serves as a comparison against future versions of Mac OS X.

cd /etc/apache2/
cp httpd.conf httpd.conf.bak

Now edit the Apache configuration. Feel free to use TextEdit if you are not familiar with vi.

vi httpd.conf

Uncomment the following line (remove #):

LoadModule php5_module libexec/apache2/libphp5.so

Restart Apache:

apachectl restart

Install MySQL

1. Download the MySQL DMG for Mac OS X
2. Install MySQL
3. Install Preference Pane
4. Open System Preferences → MySQL
5. Ensure the MySQL Server is running
6. Optionally, you can enable MySQL to start automatically. I do.

The README also suggests creating aliases for mysql and mysqladmin. However there are other commands that are helpful such as mysqldump. Instead, I updated my path to include /usr/local/mysql/bin.

export PATH=/usr/local/mysql/bin:$PATH

Note: You will need to open a new Terminal window or run the command above for your path to update.

I also run mysql_secure_install. While this isn’t necessary, it’s good practice.

Connect PHP and MySQL

You need to ensure PHP and MySQL can communicate with one another. There are several options to do so. I do the following:

cd /var 
mkdir mysql
cd mysql
ln -s /tmp/mysql.sock mysql.sock

Creating VirtualHosts

You could stop here. PHP, MySQL, and Apache are all running. However, all of your sites would have URLs like http://localhost/somesite/ pointing to /Library/WebServer/Documents/somesite. Not ideal for a local development environment.

To run sites individually you need to enable VirtualHosts. To do so, we’ll edit the Apache Configuration again.

vi /etc/apache2/httpd.conf

Uncomment the following line:

Include /private/etc/apache2/extra/httpd-vhosts.conf

Now Apache will load httpd-vhosts.conf. Let’s edit this file.

vi /etc/apache2/extra/httpd-vhosts.conf

Here is an example of VirtualHosts I’ve created.

<VirtualHost *:80>
    DocumentRoot "/Library/WebServer/Documents"
</VirtualHost>

<VirtualHost *:80>
        DocumentRoot "/Users/Jason/Documents/workspace/dev"
        ServerName jason.local
        ErrorLog "/private/var/log/apache2/jason.local-error_log"
        CustomLog "/private/var/log/apache2/jason.local-access_log" common

        <Directory "/Users/Jason/Documents/workspace/dev">
                AllowOverride All
                Order allow,deny
                Allow from all
        </Directory>
</VirtualHost>

The first VirtualHost points to /Library/WebServer/Documents. The first VirtualHost is important as it behaves like the default Apache configuration and used when no others match.

The second VirtualHost points to my dev workspace and I can access it directly from http://jason.local. For ease of development, I also configured some custom logs.

Note: I use the extension local. This avoids conflicts with any real extensions and serves as a reminder I’m in my local environment.

Restart Apache:

apachectl restart

In order to access http://jason.local, you need to edit your hosts file.

vi /etc/hosts

Add the following line to the bottom:

127.0.0.1       jason.local

I run the following to clear the local DNS cache:

dscacheutil -flushcache

Now you can access http://jason.local.

Note: You will need to create a new VirtualHost and edit your hosts file each time you make a new local site.

A note about permissions

You may receive 403 Forbidden when you visit your local site. This is likely a permissions issue. Simply put, the Apache user (_www) needs to have access to read, and sometimes write, your web directory.

If you are not familiar with permissions, read more. For now though, the easiest thing to do is ensure your web directory has permissions of 755. You can change permissions with the command:

chmod 755 some_directory/

In my case, all my files were under my local ~/Documents directory. Which by default is only readable by me. So I had to change permissions for my web directory all the way up to ~/Documents to resolve the 403 Forbidden issue.

Note: There are many ways to solve permission issues. I have provided this as the easiest solution, not the best.

Install PHPMyAdmin

Unless you want to administer MySQL from the command line, I recommend installing PHPMyAdmin. I won’t go into the details. Read the installation guide for more information. I install utility applications in the default directory. That way I can access them under, in this case, http://localhost/phpmyadmin.

cd /Library/WebServer/Documents/
tar -xvf ~/Downloads/phpMyAdmin-3.5.2.2-english.tar.gz
mv phpMyAdmin-3.5.2.2-english/ phpmyadmin
cd phpmyadmin
mv config.sample.inc.php config.inc.php

Closing

A local development environment is a mandatory part of the Software Development Process. Given the ease at which you can install Apache, PHP, and MySQL on Mac OS X there really no excuse.

I could have downgraded Subclipse. However, I had already checked out several repositories. Furthermore, I liked the smaller footprint of SVN 1.7. In typical lazy developer fashion, I went with updating SVN to version 1.7 for Mac OS X.

To give due credit, the foundations of this post came from a post on Building SVN 1.7. Although I expanded on it, I encourage you to read the original post. For completeness, I outlined the full process below.

Note: To compile and install SVN 1.7 you need Xcode with the Command Line Tools installed.

Download the SVN Source

cd ~/Downloads/
curl -o subversion-latest.tar.gz http://apache.mirrors.tds.net/subversion/subversion-1.7.8.tar.gz
tar -xvf subversion-latest.tar.gz

Note: You may need to update the curl command to download the latest SVN 1.7 source.

Build and Install SVN

The default SVN install on Mac OS X uses neon. neon allows you to connect to remote SVN repositories via HTTP and HTTPS. Lines 2-7 installs neon. Line 8 builds SVN using the --with-neon configuration flag.

cd ~/Downloads/subversion-1.7.*
sh get-deps.sh neon
cd neon/
./configure --with-ssl
make
sudo make install
cd ..
./configure --prefix=/usr/local --with-neon
make
sudo make install

Using the New SVN

Your environment will still use SVN version installed with Mac OS X:

svn --version

To use the SVN version you just installed, you can update your PATH. Assuming you are using the bash shell, add or edit the following line in your ~/.bash_profile:

export PATH=/usr/local/bin:$PATH

You should now see the SVN version you installed:

svn --version

Upon returning to the dorm Liam noticed his roommate arrived. He was paired with a roommate from Sumatra. Liam, a good old boy from Pennsylvania, felt a little uneasy without having first met the foreigner. My roommate was gone for the weekend. So I told Liam he could sleep in his bed. We passed out.

Some hours later I woke up. Something was off. As my brain began to function I noticed things. These weren’t my sheets. I didn’t have a dehumidifier. And that sure wasn’t Liam in the bunk across from me. I got down from the loft. I’m in my boxers. Where the fuck am I? I unlock and open the door. I’m in my dorm hall. After stepping into the hallway, I realize I’m next door in Liam’s room.

I go to open my door, expecting it to be unlocked. It’s locked. I knock. I hear Liam scramble around. He opens the door, “Dude, what the hell?” I explain. He assures me we went to sleep in my room. We try to figure it out for a minute, laugh, and go back to sleep.

In the morning, we ask Liam’s roommate if he remembered anything. He didn’t let me in. I didn’t have keys. How did I get out of my bed, lock my door, and get into Liam’s room without a key?

To this day, it’s still a mystery…