Ben Ramsey

Introducing array_column() in PHP 5.5

2013-03-20T16:48:00-05:00

Earlier today, David Soria Parra declared a feature freeze on PHP 5.5 and tagged php-5.5.0beta1, but not before merging in pull request #257, which includes my humble addition to the PHP programming language: array_column().

The story of array_column() begins at PHP Tek in 2008. As I recall, it was Spooons who suggested it to me. It is functionality that nearly every developer has to implement in user-land code at some point in their careers, so I felt it only natural that it be built into the language, so I did just that.

My original patch for array_column() was written for PHP 5.2, but it sat around collecting dust for many years, until April of last year, when PHP moved to git and GitHub. That’s when it became easy enough to apply the patch and send a pull request, which I did. It wasn’t quite that simple, though, since I had to follow the official PHP project RFC process, but it wasn’t a pain either.

My goal for array_column() was simplicity. Many implement the functionality in different ways, and many call the function by other names (such as “pluck”), but I wanted to keep it simple and recognizable. It follows this function signature:

array array_column(array $input, mixed $columnKey[, mixed $indexKey])

Given a multi-dimensional array of data, array_column() returns the values from a single column of the input array, identified by the $columnKey. Optionally, you may provide an $indexKey to index the values in the returned array by the values from the $indexKey column in the input array.

For example, using the following array of data, we tell array_column() to return an array of just the last names, indexed by their record IDs.

<?php
$records = array(
    array(
        'id' => 2135,
        'first_name' => 'John',
        'last_name' => 'Doe'
    ),
    array(
        'id' => 3245,
        'first_name' => 'Sally',
        'last_name' => 'Smith'
    ),
    array(
        'id' => 5342,
        'first_name' => 'Jane',
        'last_name' => 'Jones'
    ),
    array(
        'id' => 5623,
        'first_name' => 'Peter',
        'last_name' => 'Doe'
    )
);

$lastNames = array_column($records, 'last_name', 'id');

If we call print_r() on $lastNames, you’ll see a resulting array that looks a bit like this:

Array
(
    [2135] => Doe
    [3245] => Smith
    [5342] => Jones
    [5623] => Doe
)

And that’s all there is to it. I hope you find my little addition to the PHP language helpful. I had a lot of fun writing it, and following the PHP RFC process was a great learning experience.

Ideas of March

2013-03-16T13:58:00-05:00

Twitter pretty much killed blogging for me. When I signed up for the service six years ago, I was blogging quite a bit, but Twitter’s rapid-fire, ultra-short status updates have given me a 140-character attention span. Not only did I stop blogging, but I stopped reading blogs, too. Reading and writing became a chore. While I could fire off a message on Twitter within minutes or seconds of crafting it, blogging was an endeavor that took much longer—hours or even days, at times.

You see, the thing is: I care about the words I write. Probably too much. But with Twitter, I stopped caring. Its ephemeral nature means I don’t have to care. Until recently, even searching for posts on Twitter only went back so far. When I blog, I have to read and re-read the words I have written, over and over. This doesn’t stop after I finally decide to publish a post. Instead, I continue to pore over my post, reading it in its published form and eagerly awaiting potential comments. I’m doing it even as I write this. It can be stressful.

When Google announced this week their decision to shut down Google Reader, it stirred up unresolved emotions in me. I know that sounds silly, but while I haven’t been reading or writing blog posts very much over the last six years, the concept of the blog still holds a dear place in my heart. Blogs are important communication and knowledge-sharing tools. They have revolutionized the way we spread information (or mis-information). I believe they are still important and have a continuing part to play in how we communicate with each other. Without the concept of the blog, it would have been impossible for many of the folks we consider leaders in our various technology communities to have had a platform to share their voices and ideas.

Earlier this year, I made a resolution to myself to begin reading blogs again. I returned to the Google Reader account I had set up long ago and connected it to NetNewsWire on my desktop and phone. I have been pretty good about reading things, and I have tried to treat it a bit like I treat Twitter; if I get behind on reading, I just “mark as read” and continue on, without stressing over it. Some of the things I’m reading have been inspiring me to write again, and I felt it was only a matter of time before this incessant writer’s block was broken and the words began flowing freely again. I believe that time is now.

This isn’t a post to discuss the ramifications of Google’s decision to pull the plug on Google Reader. Nor do I want to consider whether blogs are dying. Those are thoughts better left to other bloggers. What I do want you to think about, however, is how blogging has affected you, whether through your own blog or the blogs of others. Has it helped you be more successful? The answer for me is “yes,” and for this reason, I resolve to read even more, be liberal with my comments on others’ blogs, and write without fear.

Thanks goes to Chris Shiflett for inspiring this post. Be sure to take time and read his original Ideas of March post from 2011, as well as his most recent one.

Writing an Effective Talk Proposal

2012-11-30T15:16:00-06:00

Earlier today, I was asked “Any tips on how to write a proposal for a major conf?” I’ve never shared tips on this, and since the calls for proposals for Sunshine PHP and Midwest PHP both end tomorrow, I thought it would be a good idea to share my approach to writing conference proposals.

Remember those standard, five-paragraph essays you used to write in high school? Remember how you thought they sucked and wouldn’t provide any practical benefit to your life? Well, it turns out they do have some redeeming qualities.

In case you’ve forgotten, a standard, five-paragraph essay comprises three main parts:

The first paragraph is the introduction, where you introduce your topic and state the thesis or central argument.
The next three paragraphs provide support and development of the argument.
The final paragraph concludes the argument by summarizing the points and linking the individual points to the overall thesis.

When I write talk proposals, I typically follow the pattern of the introductory paragraph of this essay structure. Usually, the introduction begins with a narrative hook, something to grab the reader’s attention. This is usually a single, punchy sentence. Sometimes it’s a shocking but true statement. On the other hand, it may be hyperbolic. This is often the most difficult part of the proposal to write, but it’s also the most important, so you may want to write the rest of the proposal first and come back to this.

Following the hook, you need to introduce the topic and identify the problem you want to discuss. This usually involves several sentences, starting out broadly and narrowing the focus. Finally, end the proposal by making a claim or expressing an opinion that will form the basis of your talk. This is your thesis. You may also include an organizational sentence linked to this thesis, which provides a general outline of your topic.

Here’s a contrived example I’ve written that uses this structure with the ubiquitous concept of widgets:

Last year alone, over 498,000 servers were deployed with broken widgets. Widgets, long a staple of secure server deployments for the past decade, have recently come under fire for not being as secure as once thought. Running secure servers is crucial, so finding a better alternative for these faulty widgets is critical. Gadgets provide a stable, more secure alternative to widgets, and in this talk, Ben Ramsey introduces gadgets, shows where to find trustworthy gadget repositories, and explains how to set up and maintain server gadgets.

A final word of advice: don’t talk down to your audience. Steer clear of negative language. Statements that demean or vilify members of the audience or products/practices they use are not well-received and can hurt your chances of being accepted. I also like to stay away from absolutes or groupings that I can’t back up with real data. After writing my proposals, if I have phrases that begin with “most people” or similar inclusive statements, I try to reword them.

So, that’s my general approach to writing talk proposals for conferences. I hope this helps, but keep in mind that this isn’t the only way to write an effective talk proposal. It’s just one way. What are some of your tips for writing effective talk proposals?

The Era of PHP Testing

2012-11-21T13:29:00-06:00

Over the past decade, the PHP community has progressed through a handful of distinct eras that have each been marked by a focus on specific best practices. This is most evident in the types of talks presented at conferences and user groups and in the articles published by php|architect magazine, PHPDeveloper.org, and the blogs of those whose feeds are distributed through Planet PHP.

In thinking through this, I’ve come up with the following eras I think we, the PHP community, have had over the last ten years. These are in a general order, but eras overlap, and some have lasted longer than others, so there’s not a distinct beginning or end to each.

Object-oriented programming and design patterns
Web application security
Frameworks
Coding standards and code organization
Testing and continuous integration

OOP and Design Patterns

PHP 5.0.0 Beta 1 was released on June 29, 2003. The GA release came out on July 13, 2004. While PHP 4 had support for objects, inheritance, encapsulation, etc., it was during this time that the community began promoting best practices for object-oriented programming and the use of design patterns. Jason Sweat’s php|architect’s Guide to PHP Design Patterns was published in 2005, and there were many talks and articles published on good OOP practices and design.

Security

It was also during this time that lots of folks began talking about web application security. Most notably, Chris Shiflett launched the PHP Security Consortium and later published Essential PHP Security, while Stefan Esser pushed for greater visibility and focus on fixing security issues deep in the PHP core, contributing the Suhosin extension, part of the Hardened-PHP Project. Other books were published, and we saw many talks on security at conferences. Recently, Chris Cornutt has raised the PHP security banner once again with websec.io.

Frameworks

OOP and design patterns best practices led to increased awareness and focus on the MVC design pattern. Many frameworks following this pattern—or variations on it—sprung up. Early frameworks Prado and CakePHP preceded Symfony and Zend Framework. There are too many others to name here, but all have contributed to where we are today. We’ve learned a lot from this proliferation of frameworks. It has allowed the community to try many different approaches, rather than settling on one particular way of doing things.

Coding Standards and Code Organization

The proliferation of frameworks brought us to where we are today with the PHP Framework Interoperability Group and the community standards PSR-0, PSR-1, and PSR-2. The frameworks are all working together, many following some of the same patterns, allowing components of frameworks to be used together. Componentization has taken hold, with Ed Finkler’s Micro PHP Manifesto being a rally cry for the use of smaller libraries that focus on doing one thing well, a variation on the single responsibility principle. Composer has arisen from the Symfony community, providing PHP libraries and applications a way to specify and manage external dependencies. PHP code is looking a lot better—just take a look at some of the repositories on GitHub.

Testing

This brings us to the era of testing. This is where we are today, but it’s not the first time anyone has ever talked or written about testing. Sebastian Bergmann has been doing this for years, but I think the community and ecosystem around PHP is now at a level of maturity where it’s become a major focus of developers and development shops. We not only care about what we build and getting the job done. We also care about the code we write and are treating it more and more as a craft. Testing goes hand-in-hand with treating code as craft. Chris Hartjes’s grumpy persona is leading the charge from his blog, Twitter account, and books, Guide to Building Testable PHP Applications and PHPUnit Cookbook, as well as his recent talks and keynotes at PHP conferences.

With the coming of the testing era, I’m seeing a lot of maturity in our community. The code we write is getting better. We’re following standards and best practices. We’re implementing a lot of good design principles. Many folks can explain what XSS, CSRF, and SQL injection are, and they can tell you how to protect against them. We’re writing libraries and components that work well together. And we’re starting to test—and automating those tests.

I think the decade since PHP 5 was released has brought us to a great place as a community. We’ve seen a lot of trends, and these have helped us mature as developers and have helped us establish community-supported best practices. With each new era, we can’t forget what we’ve learned, though. We must continue teaching and revising these best practices as we learn more.

I wonder what the next era of PHP development best practices will be.

On the Rise of Community Conferences

2012-10-05T04:02:00-05:00

The PHP world is exploding with community conferences. In fact, web development technologies in general are seeing a wide range of community-driven conferences springing up around the world. I think there are many reasons for the proliferation of these conferences, and in this post, I present my opinion on how this trend came to be, along with a definition of what I think constitutes a technology-focused community conference.

What is a Community Conference?

In the technology world, a community conference is organized by members of the technology community for which the conference is themed, rather than a corporation that organizes the conference as a product offered to its customers. This appears to be a distinction that is common among community conferences. Many community conferences do have a corporation formed to run the conference. Some of these are set up as non-profit organizations. This is not a requirement for a community conference, however.

There’s nothing wrong with the conference-as-a-product approach, though. In fact, many corporations with conference products run their conferences much like community conferences. The organizers, while usually employees of the corporation, are often active members of the technology community. So, what else puts the “community” in community conferences?

The Unconference Phenomenon

At this point, I think it’s important to mention the unconference phenomenon. “An unconference is a participant-driven meeting” (Wikipedia). According to Wikipedia, the term can be applied to any number of conferences that attempt to “avoid one or more aspects of a conventional conference, such as high fees, sponsored presentations, and top-down organization.” I believe the community conference is the marriage of the attitude of the unconference to the professionalism and structure of the traditional conference.

Unconferences became popular by the middle of the last decade, allowing conference participants the power to drive the agenda of the conference while giving the finger to more traditional conference establishments. While the unconference movement was reactionary and subversive to traditional conferences, community conferences have embraced both the openness of the unconference and the structure of the traditional conference, to varying degrees.

A few years back, traditional conferences took note and began adopting traits of the unconference, including tracks dedicated to open discussion and ad hoc presentations. These alternate tracks were often referred to as “camps” or “unconferences,” and they were implemented at a number of popular technology conferences. OSCON, the largest open source technology conference in the US, hosted OSCamp, while in the PHP world, ZendCon and php|tek both hosted unconference tracks, all run by members of the technology community. I believe it is this trend that led to the birth of the modern community conference.

Putting the “Community” in Community Conferences

So, what puts the “community” in community conferences? I submit that there are three essential elements to a community conference:

Community organizers
Focus on developers
Proper attitude

I think it’s important that the organizers of a community conference be members of the technology community for which they are organizing the conference. While there are many different ways to organize a community conference, its organizers must be from the community. If the conference doesn’t have this, then it will fail to meet the needs of the community for which it is designed. The good news is that most conferences, traditional and community alike, are organized by members of the community.

A focus on developers is also important. A prevalent conception of traditional conferences is that they are too focused on companies. The good news is that this is often resolved by having community organizers. Recently, friends of mine organized CoderFaire, a local developer conference in Nashville, and required that their sponsors send programmers and developer evangelists instead of sales people to meet with attendees and show off their tech. Their focus was on developers, and to enhance the experience of their attendees, they wanted their sponsors to also focus on developers.

Attitude matters. It is crucial. I think this is primarily what sets apart a community conference. It’s also the hardest element to pin down and define. Every community conference is different, but the attitude is a little bit “punk rock” for each one. Attitude encompasses focus, intent, and passion. My friends at Brooklyn Beta have crafted a conference that has a particular attitude, setting them apart from other conferences. It’s embodied in their tagline, “Make Something You Love,” and permeates their talks, events, and even the name badges. Every community conference has a particular attitude that sets it apart from traditional conferences, and it makes all the difference.

What Do You Think?

Defining what it means to be a community conference is not easy. I wrote this post out of my own thoughts and experiences running and organizing the PHP Community Conference. I also have many friends within various technology communities who run community conferences for their favored technologies/regions. As a result, I am no unbiased bystander, and these thoughts are wholly subjective.

How do you define “community conference?” What do you think are important elements of a community conference? Can a corporation run a community conference? (Based on my definition, I think it can.) I welcome your comments.

Finally, I’d be remiss if I didn’t point out two upcoming community conferences you should check out: CodeConnexx in Indianapolis and True North PHP in Toronto. They’re both going to be awesome!

Build PHP 5.4 on CentOS 6.2

2012-03-05T13:30:00-06:00

In case you haven’t heard the news, the PHP project released version 5.4.0 last Thursday. Naturally, I decided it was time to install and give it a try. I chose to install to a clean and bare-bones CentOS 6.2 virtual machine using VirtualBox. I did this for two reasons: 1) I wanted a clean environment for the build, and 2) I wanted to play with CentOS. At the time of this writing, there are not yet any official CentOS RPMs for PHP 5.4, so I had to build PHP from source. What follows are the notes I took during the installation and build process. I hope you find them helpful.

Set up a CentOS virtual machine

First of all, go grab the CentOS 6.2 netinstall ISO. Depending on the mirror, it will likely be located somewhere like centos/6.2/isos/x86_64/CentOS-6.2-x86_64-netinstall.iso (note that I’m using the 64-bit version). Following that, create a new basic VirtualBox VM (512 MB RAM, 8 GB HDD, 12 MB video RAM) for your CentOS installation (use “Red Hat (64 bit)” as the Version) and follow these instructions for a CentOS 6.2 netinstall. I chose the 64-bit version, using the netinstall URL of http://mirror.centos.org/centos/6.2/os/x86_64/.

Since the VirtualBox video RAM selected is only 12 MB, it won’t boot into the graphical mode shown in the netinstall installation guide. Don’t worry about this. Also, it will make some assumptions (e.g. it won’t install Gnome or KDE), since you aren’t in graphical mode. What you’ll have at the end is a very bare-bones server installation.

After installation, I like to power down the VM and adjust my settings to set up port forwarding so that I can shell into my VM from my Mac terminal. Feel free to configure things as you like. See the screenshot for an example of forwarding ports in Virtual Box. Once set up, you can boot the VM and then use your favorite local terminal to SSH to the instance:

ssh -p 2222 root@localhost

You’ll probably want to create a user for yourself, so that you’re not using root all the time, but since this is a VM on your local machine, it’s not a huge deal. If this was a box out in the open, I’d recommend locking it down and creating a user with much more restricted permissions.

Install packages needed for PHP

Once logged in to the VM, you’ll need to install some basic build stuff, like gcc, etc.

yum install man wget
yum groupinstall "Development Tools"

Next, update iptables to allow connections to the VM over ports 80 and 8000.

sed -i '/22/ i -A INPUT -m state --state NEW -m tcp -p tcp --dport 80 -j ACCEPT' /etc/sysconfig/iptables
sed -i '/22/ i -A INPUT -m state --state NEW -m tcp -p tcp --dport 8000 -j ACCEPT' /etc/sysconfig/iptables
/etc/init.d/iptables restart

For the PHP configuration that I’m using, install the following packages. There will be a bunch of dependencies it will ask you to install. Just say yes to them all.

yum install \
libxml2-devel \
httpd-devel \
libXpm-devel \
gmp-devel \
libicu-devel \
t1lib-devel \
aspell-devel \
openssl-devel \
bzip2-devel \
libcurl-devel \
libjpeg-devel \
libvpx-devel \
libpng-devel \
freetype-devel \
readline-devel \
libtidy-devel \
libxslt-devel

For some reason, libmcrypt isn’t available in the main CentOS repositories, so add the RPMForge repo to install it.

wget http://packages.sw.be/rpmforge-release/rpmforge-release-0.5.2-2.el6.rf.x86_64.rpm
rpm --import http://apt.sw.be/RPM-GPG-KEY.dag.txt
rpm -K rpmforge-release-0.5.2-2.el6.rf.*.rpm # Verifies the package
rpm -i rpmforge-release-0.5.2-2.el6.rf.*.rpm
yum install libmcrypt-devel

Now, the environment is all ready for building PHP 5.4!

Build PHP 5.4.0

All that’s left is to get the PHP 5.4.0 release package and build it. Choose a mirror closest to you and run the following commands to configure, make, and install PHP.

wget http://www.php.net/get/php-5.4.0.tar.bz2/from/this/mirror
tar jxf php-5.4.0.tar.bz2
cd php-5.4.0/

What you want to enable and build into your PHP installation will vary, but here’s the configure line that I used for this build:

./configure \
--with-libdir=lib64 \
--prefix=/usr/local \
--with-layout=PHP \
--with-pear \
--with-apxs2 \
--enable-calendar \
--enable-bcmath \
--with-gmp \
--enable-exif \
--with-mcrypt \
--with-mhash \
--with-zlib \
--with-bz2 \
--enable-zip \
--enable-ftp \
--enable-mbstring \
--with-iconv \
--enable-intl \
--with-icu-dir=/usr \
--with-gettext \
--with-pspell \
--enable-sockets \
--with-openssl \
--with-curl \
--with-curlwrappers \
--with-gd \
--enable-gd-native-ttf \
--with-jpeg-dir=/usr \
--with-png-dir=/usr \
--with-zlib-dir=/usr \
--with-xpm-dir=/usr \
--with-vpx-dir=/usr \
--with-freetype-dir=/usr \
--with-t1lib=/usr \
--with-libxml-dir=/usr \
--with-mysql=mysqlnd \
--with-mysqli=mysqlnd \
--with-pdo-mysql=mysqlnd \
--enable-soap \
--with-xmlrpc \
--with-xsl \
--with-tidy=/usr \
--with-readline \
--enable-pcntl \
--enable-sysvshm \
--enable-sysvmsg \
--enable-shmop

Assuming the configure script ran perfectly, you’re ready to make and install PHP.

make && make install

Now, you’ve got a fully-functioning build of PHP 5.4.0 on CentOS 6.2!

Trying out the build

Now, that PHP is installed, it’s time to try out a few things. Create a simple phpinfo() script, make sure Apache knows to parse .php files as PHP, and start Apache.

echo "<?php phpinfo();" > /var/www/html/phpinfo.php
echo -e "<FilesMatch \\.php$>\nSetHandler application/x-httpd-php\n</FilesMatch>" > /etc/httpd/conf.d/php.conf
/etc/init.d/httpd start

Now, assuming your VM port forwarding is set up correctly, from your local machine visit http://localhost:8080/phpinfo.php. You should see the output of phpinfo().

One cool new PHP 5.4 feature is the built-in web server for development testing. You can try it out with this build. The following commands tell PHP to run the built-in web server using the current directory as the web root, while listening on port 8000 to all interfaces (not recommended on a public machine, but necessary for the request to the VM to work).

cd /var/www/html
php -S 0.0.0.0:8000

From your local machine, visit http://localhost:8000/phpinfo.php. Note that the Server API line will say “Built-in HTTP server.” Of course, we’ve also set up Apache, so using the built-in HTTP server may not be of much value now, but in the future, if developing locally, the built-in web server can be a handy way to quickly try out things that typically need a web server.

Wrapping up

There you have it, and it only takes about an hour to work through these installation and build steps, most of which is taken up by waiting on things to finish installing, configuring, or building. I hope these steps have been helpful. Feel free to let me know of your own experiences installing PHP 5.4 and leave any tips or tricks in the comments.

Thanks for reading!

Revamping my development toolchain

2012-02-06T01:42:00-06:00

It used to be that once a year I would take a good, hard look at the tools I used and endeavor to learn something new or change my workflow with those tools. However, I’ve been living the #startuplife for the past two years, so it’s been about three years since I last addressed my development toolchain. I decided to come up for air and take some time this weekend to rectify that by addressing five main areas: my terminal emulator, my shell, my terminal multiplexer, my IRC client, and my color scheme—yes, even my color scheme! In addition, I decided to push out my updated Octopress-powered blog, even though things are still a little rough around the edges.

Switching to iTerm2

I’ve been a long-time user of Terminal.app, but I had been hearing good things about iTerm2. I actually used iTerm (version 1) years ago, but I switched back to Terminal.app for reasons I cannot recall. Nevertheless, iTerm2 has come a long way, and I wanted to take advantage of some of its functionality like split panes, better full-screen support, etc. So, that was the first major change I made to my tools.

Ditching bash for zsh

Bash has been my favored shell since I began using Linux about fourteen years ago. I’d never given much thought to using a different shell, and to be honest, switching shells always seemed a daunting task. I thought I’d have to relearn my way around the shell, and everything I took for granted with Bash would be non-existent in a different shell. Fortunately, this is not true. As it turns out, zsh “can be thought of as an extended Bourne shell with a large number of improvements, including some features of bash, ksh, and tcsh” (Wikipedia).

I was able to switch to zsh without ditching my knowledge of bash. As a result, I’ve gained all the advantages of zsh, which include advanced customization and scripting capabilities, while continuing to provide most (if not all) the same functionality and commands I’m used to in bash. I have much more to learn, though, so if you have tips and tricks, please share.

If you’re interested in switching to zsh, I recommend checking out oh-my-zsh. It’s a framework for managing your zsh configuration, and it contains lots of goodies. In addition, there are great posts by Mark Nichols and Jon Kinney that will get you quickly up-to-speed with oh-my-zsh. The latter post has the awesome title “It’s not enough to bash in heads, you’ve got to bash in minds…with ZSH”.

Using tmux instead of screen

Generally, I’ve really only used screen when I started noticing that my connection to a remote development machine was getting sluggish or I wanted to keep a constant connection to IRC, but tmux has opened my eyes to so many more possibilities that a multiplexer can offer. I’ve just only started using it, so I can’t say much about it, but I encourage you to read Hawk Host’s two-part post on tmux.

Moving back to irssi

I used irssi in a screen session for years. Then, I decided I needed Growl notifications from my IRC client. I quit using irssi in favor of Linkinus. I’ve used Linkinus for about two years—together with the IRC bouncer znc for some of that time—but I’ve continued to miss the flexibility and functionality of irssi. On a whim, I decided to switch back to irssi, but it wasn’t without some searching. I needed to find a way to make irssi work with growl, as well as a way to make irssi send notifications to my phone when I was marked as “away.” Finding solutions to both of these—as well as the switch to tmux—helped make the transition back to irssi much easier.

Using the Solarized color scheme

Finding the perfect, universal color scheme doesn’t sound so important until you’ve found it. Somehow, I stumble upon the Solarized project. This project has a color scheme designed for gui and terminal applications. It has been tested in a variety of lighting conditions, and it’s very clear and easy to read. Using the fixed-width Menlo font face, I quickly fell in love with Solarized. They have color schemes for iTerm2, TextMate, vim, tmux, irssi, GNU ls, and many more.

Wrapping up

I’ve put all my configuration into a dotfiles repository on GitHub to help me keep track of things. Feel free to play with my configuration and suggest improvements to it. You’ll need to install zsh, rubygems, and rake first. Then, clone my repo and run rake install. If you’re not already running zsh, change your shell to zsh with chsh -s zsh. You’ll probably want to install the Solarized theme for your terminal emulator first, too.

I know I haven’t provided a very deep dive into these tools, but I hope I’ve skimmed the surface just enough to provide you with the information you need to find out what works best for you.

Thanks for reading!

A Different Kind of Conference: the PHP Community Conference

2011-01-18T16:46:13-06:00

For those who have been following along, you’ll know that I helped organize a mini-conference for PHP, along with Elizabeth Naramore, in the Fall of 2006. It was little more than an excuse for a small group of people to get together, kamp, talk shop, and have fun—and it was a lot of fun. It was so much fun, in fact, that Elizabeth and Keith organized it again in 2008. That was PHP Appalachia. It was the stuff of legends.

I’ve long wanted to organize a community-driven PHP conference, as far back as 2004, when I helped form the Atlanta PHP user group. Back then, I think my conference dreams were loftier, but I’ve since attended twenty-something conferences and given nearly sixty talks. I’ve seen conferences as both a speaker and an attendee, and from conversations with many other speakers and attendees, I knew it was time for something different. Unfortunately, I didn’t know exactly what “different” should mean.

Then, just over a year ago, I received an email from Elizabeth. She wrote:

OSBridge showed that a community-driven conference can be successful and readily accepted. I know the economy is tight, but I think there is room for a conference that has no other purpose than to be an educational and fun experience for attendees. […] We’ve had a ton of people asking about PHP Appalachia, so maybe that kind of “retreat” versus “conference” idea holds merit as well.

Thus began a long thread of messages back-and-forth with a small group: Elizabeth, Paul, Chris, Sean, Ed, and myself; each one wholly committed to the idea of a community-driven conference. But I was still unsure. My uncertainty had nothing to do with whether we could run a PHP conference but, rather, what it would be that makes our conference different. I was tapped by the group to lead the effort, so I started some planning, but everything I did looked like the same ol’ conference. I was talking to hotels, looking at traditional venues, and thinking too much inside the box. All of that was about to change, though, with Brooklyn Beta on the horizon.

With its simple narrative of “make something you love,” Brooklyn Beta showed it was possible to craft a friendly web conference that was as intimate as it was inspiring. Chris himself is an inspiration to me because he views just about everything he does as a craft, something to hone and perfect. He takes great care and pride with everything he touches. The “make something you love” narrative was not just the theme of the conference, but Chris and Cameron put it into practice with the care they put into organizing Brooklyn Beta. They made a conference they loved, and it showed—boy, did it show!

At last, I had the inspiration I needed, and with the catalyst provided by Elizabeth, Paul, Chris, Sean, and Ed, I was ready to start … but not quite. Left to myself, I would fail, and by myself, I was failing. Working for a start-up does not leave much time to craft a conference. That’s not a complaint; it’s just a reality. Help would come in the form of two other Brooklyn Beta attendees, members of the PHP community, and friends of mine: Lisa Denlinger and Nicholas Sloan.

As I recall, Lisa and Nick were both interested in helping create a community-driven PHP conference, so Chris put them in touch with me back in October. The rest, as they say, is history. Things began to move fast, now that we had a small team to accomplish the work needed. Lisa visited venues and put together our budget. Nick began working with a designer to create our website and branding. It’s been a lot of hard work, and we still have more hard work ahead of us, but we’re making something we love, and I think that’s the important part.

During one of our many planning conversations, Nick voiced what would become, for me, the narrative of our conference: PHP Community Conference is a conference for people who care about PHP and the code they write with it. That’s really what I want this conference to be about, and I’ll keep coming back to that theme repeatedly over the next few months and throughout the course of the conference itself. You, the PHP community, care about PHP and the code you write with it. I want to hear your stories!

The PHP Community Conference exists for you to share your stories. Tell us about an inspiring project you’re working on and why it’s important. We don’t want to focus on the details of the code itself, but rather on how your project solves a problem or fills a need.

There are a lot of speakers out there. I know many of you, and we all know the drill. We reuse a lot of the same talks at many different conferences. Use this opportunity, though, to stretch yourself. Craft a new talk. Craft a different talk. This time, don’t just tell us how to do something with PHP, tell us what you’re working on with PHP. What does it do? Why is it important? These are the things that matter to the community, and this is part of what makes the PHP Community Conference a different kind of conference.

There are other reasons the PHP Community Conference is different, but I’ve given you quite a bit to chew on for one blog post, so I’ll leave the rest for later and for others to share. Still, since this conference is community-driven, I need your help. Even though our tickets haven’t gone on sale yet, I want you to save the dates! Put them on your calendar and commit to attend. (Ticket prices will be very reasonable, but we’re still working out those details at the moment.) Write a blog post about your decision to attend and why you’re looking forward to the conference. Tweet about it (#phpcomcon). Follow @phpcomcon on Twitter. Talk about it on IRC. Submit a proposal for a talk. Please spread the word, anyway you can.

Finally, if you have ideas for other ways you can help, feel free to let me know.

I’m looking forward to seeing you at the PHP Community Conference!

Moontoast Is Hiring Senior PHP Developers

2010-04-28T00:16:51-05:00

Moontoast, the company where I now work, is looking for senior PHP developers. This is an on-site (Nashville, TN), contract position that could potentially develop into a full-time position. If you’re interested, let me know, and send your resume to hr [at] moontoast.com.

Moontoast is a social commerce network for people to pursue and promote their passions through personal relationships. Moontoast simply connects those who know, with those who want to know.

Moontoast is seeking passionate, senior PHP developers—who want to pursue and promote their passion for writing high quality code—to enhance the Moontoast social commerce platform. We are looking for self-motivated individuals with the right attitude and excellent skills who can hit the ground running in a fast-paced web startup. Ideal candidates will thrive in a tight-knit team environment, promoting their passion for software design by leading product teams and mentoring our growing development team.

The main responsibilities of a senior PHP developer include:

Working with the senior developers and architects to provide leadership in technical design and architecture of the Moontoast platform
Setting estimates and expectations for new product development and implementing new features, tracking on target deadlines
Mentoring and leading developers by example through writing clean, well-documented, maintainable code and enforcing standards and best practices
Participating as an active Moontoast Guide in the Moontoast Developer Community

Requirements

We are looking for:

5+ years of experience with PHP
8+ years of experience with web development
Deep understanding of browsers and HTTP
Experts at object-oriented programming concepts and design patterns
Demonstrated ability to design and develop complex web services
Extensive experience with the Symfony framework and Doctrine
Working knowledge of version control systems (Subversion, Git, etc.)
BS in Computer Science/Engineering or equivalent experience

We would like to see:

A passion for web development and an interest in sharing that with others
Independent thinkers with strong leadership qualities
Demonstrated ability to develop large-scale websites
Experience with service-oriented architectures, web services, and Cloud technologies
Knowledge of advanced data organization concepts, such as sharding
Experience with other PHP frameworks utilizing the MVC design pattern
Expert Linux development skills, from the command prompt to the web server
Open source project development experience
Developer community involvement (blogging, speaking, articles, Twitter, etc.)
Zend PHP 5 Certification
MS in Computer Science

We invite interested candidates to send resumes to hr [at] moontoast.com.

Rebooting Nashville PHP

2010-04-26T22:29:41-05:00

I recently moved to Nashville, and as part of that transition, I’ve taken the helm as the new organizer for the Nashville PHP user group. I posted what follows to the Nashville PHP mailing list, but I thought it would be a good blog post. Enjoy!

Six years ago, I founded the Atlanta PHP user group (along with a few others), and I’ve been organizing it since then. It’s been a lot of hard work to grow and develop the PHP community in the Atlanta area, but it’s also been rewarding to meet so many great people and to see them take interest in and become invested in the continued success of their PHP user group. I’m proud to have been a part of building that community to the point where it can sustain itself without my involvement.

Now, I’m in Nashville. A few months ago, I moved here to pursue a job with a local web start-up. I never had any intention of running the local PHP user group, but Will Fitch, the former Nashville PHP organizer, contacted me to see if I would be interested in taking over the reins. He had moved out of the area and was no longer able to devote the time necessary to keep the group growing. I humbly accepted the torch, and that’s why I’m now the Nashville PHP organizer.

There have been several incarnations of PHP user groups in the Nashville area over the past ten years, all with varied success. It is my hope to build on those successes and to grow a sustained community of members who are personally invested in seeing a vibrant and active PHP community in the Middle Tennessee area.

That’s a lofty goal that will require a lot of hard work, so I’ll need your help. Nevertheless, I’m up for the challenge, and I hope you’ll join me in growing this community.

First of all, a few matters of business:

Nashville PHP will hold regular monthly meetings on the second Tuesday of every month at 7pm at the same location each month. I am currently solidifying this location, and I’ll let you know when details are finalized.
June 8 at 7pm will be our first meeting. Location and topic TBA.
Nashville PHP will continue to use Meetup.com as our central place for membership and meeting announcements and RSVPs.
I’m dropping the discussion forums on Meetup.com in favor of a Google Group for discussions and job postings. Please join the Nashville PHP Google Group.
Follow @NashvillePHP on Twitter for community status updates. Also, if you have a Twitter account and you want to be listed on the nashvillephp-devs list, let me know. I’ll add you.
Join me on Freenode IRC in the #nashvillephp channel. If you’re new to IRC, read this basic IRC tutorial to get started.
Employers and recruiters are welcome to post job opportunities to our discussion list. Before posting, please read the rules.

Welcome to the new Nashville PHP! I hope you’ll join me in making this community a success.

Blasting Off with Moontoast

2010-04-26T03:58:25-05:00

Since I announced on Twitter that January 15 would be my last day at Schematic, I’ve received many positive responses and much encouragement. The biggest question, though, was where I would be going next.

My decision not to be very public about where I was going had nothing to do with being secretive or stealthy. Instead, I wanted to make sure I could effectively communicate the business when I finally did announce where I was going. However, as time wore on, I put off blogging, over and over, to the point where it has been four months since I joined my new company, and I’ve yet to blog about anything.

It’s time to break my silence.

Let me introduce you to Moontoast, the Social Commerce Network.

Moontoast is a social commerce network. A social commerce network is a marketplace where businesses and people come together to pursue and promote their passions through personal relationships.

Moontoast has three kinds of users:

Explorers use Moontoast to pursue their passions and learn more by interacting with real-life people who have the knowledge, experience, and products Explorers are looking for. Moontoast allows Explorers to find, connect with, and create relationships with Guides, other Explorers, and Branded Communities.

Guides use Moontoast to build a business and personal brand around their particular area(s) of expertise. Moontoast provides tools and resources to help Guides connect with their customers and market their ideas, skills, and products to the Moontoast Social Commerce Network and beyond.

Businesses use Moontoast to build branded communities. A Moontoast Branded Community generates new leads and creates new selling environments for businesses, and businesses can turn their employees, affiliates, fans, and members into revenue-generating branded Guides.

That’s Moontoast in a nutshell. While all of this might sound like boilerplate marketing verbiage, it’s actually my own words about what Moontoast is.

Moontoast is a startup, and we’re still in the early stages. As with all startups, there are risks and considerations that must be made prior to joining one, as Keith has outlined. As such, I didn’t take my decision to join lightly, but I firmly believe this is the right opportunity at the right time and place. I’ve moved to Nashville, TN to make this possible. My family is still behind in Atlanta, but they’ll be moving to join me later this year.

I’ve joined Moontoast as the Senior Software Architect, joining the team at a crucial stage in its development. Moontoast is built on top of a LAMP stack, a tried-and-true platform for scalable websites, but we still have a lot of hard work ahead of us to ensure that we remain stable as our traffic increases, and that’s part of my job. I’ll also be focused on all the things that most software architects do: team leadership, mentoring, code quality, standards and practices, task management, performance tuning, security and hardening, data modeling, UML diagraming, lots of white-boarding, etc., etc.

After just four months with Moontoast, I’m still very excited to be a part of the team, and I believe we have a bright future ahead. I’m also very fortunate to have the opportunity to work with Marcus Whitney, our CTO and co-founder—and fellow PHP community member. Marcus is a dynamic and charismatic individual who is dedicated to the advancement of a strong technology community in the Nashville and Middle Tennessee region. He’s the primary reason I’m here and the reason I’m excited about the future of web technology in Nashville.

You’ll be hearing more from me in the days ahead, blogging and tweeting about things I’m doing and learning as software architect at Moontoast. I hope you’ll check out Moontoast and see what we’re doing. I think many of you would make excellent Moontoast Guides and will find it very helpful in advancing your consulting offerings. We still have a lot of work ahead of us to make things painless, effortless, and full-featured for all users, but you can help by being an early-adopter and testing the platform and offering your suggestions for improvement and new features.

Finally, I hope you’ll also check out Nashville, TN. It’s a great place to live and work!

PHP Advent 2009

2009-12-18T05:34:39-06:00

Six years ago, I became aware of the PHP community. I joined it three years prior to that.

I’m privileged to be a part of the 2009 edition of PHP Advent. This year, my post is about the PHP community. If you have any comments, feel free to leave them here.

Microsoft Web Dev Summit 2009

2009-12-01T06:30:23-06:00

For the past three years, Microsoft has hosted the Microsoft Web Development Technology Summit, inviting a small group of community leaders, project developers, and prominent members of the PHP community, primarily for the purpose of eliciting feedback on how to better support PHP on Windows. I’m privileged and honored to be invited back for a third year to the fourth annual edition of this summit.

This is the first time I’ve ever blogged about the event, though I’ve taken “live” notes during the 2007 and 2008 summits. I’ll be taking notes again this year, if you’d like to follow along, but I’ll also be devoting several blog posts this week to the event because I think it’s important.

As I said, this is the Microsoft Web Development Technology Summit, but perhaps it’s not very aptly named, since it could best be termed as the Microsoft PHP Summit. Then again, one could argue that PHP really is the server-side technology of the Web, so calling this a web development summit is appropriate, and I think Microsoft understands that. This is the first reason I think this summit is important: Microsoft recognizes the importance of PHP to web development.

The second reason it’s important follows closely on the heels of the first. Because PHP is important, Microsoft wants PHP to work as best as it possibly can in a Windows Server environment, eliminating all performance arguments in comparisons between Windows/IIS and Linux/Apache. This reduces the platform choice argument to one of subjective preference with no basis in objective analysis. This is good for Microsoft because many PHP developers continue to use Windows as their local development platform, while deploying to *NIX systems. All performance arguments out of the way, if developers can deploy to the same platform they use for development, would they?

Other barriers for developers include cost and even open source philosophy (but mostly cost). Microsoft is eliminating this obstacle with their WebSite Spark and BizSpark programs. The philosophy argument is addressed by licensing some Microsoft tools and libraries under Microsoft open source licenses (which include BSD-like and GPL-like licenses).

There are many other reasons why this summit is good for Microsoft, but I’ll end with a third one for this post. In the spirit of openness and transparency, open source communities tend to be very vocal and honest, often brutally honest. So, why would Microsoft invite a room full of PHP developers, where the common laptop present will be running Mac OS X, with a few Linux laptops sprinkled in the room, and even fewer Windows laptops? Our community doesn’t hold back with our opinions. That’s why. Each person in the room has ideas of how Microsoft can be better community citizens, provide better and easier to use products for developers, and improve support for PHP on Windows. We may not use that platform, but we all have ideas for how it can be better. I don’t think Microsoft is kidding itself that it will convert us to its platform, but I do think they value our opinions and presence because our feedback will make their products better and we’ll communicate the experience back to the greater PHP community (i.e. through blog posts such as this), improving their image.

Do I think Microsoft has done anything positive with our feedback? You bet. In the years since the Web Dev Summit was first held in 2006, we’ve seen improvements to FastCGI in IIS and the introduction of the open source SQL Server native driver for PHP. I believe these improvements are direct results of the Web Dev Summit. And there are others. This year, the focus appears to be on developer tools, so we’ll be having in-depth discussions on typical workflow and processes for developing a PHP project from start to finish. If you have suggestions for how Microsoft can improve their tools for PHP developers, let me know, and I’ll pass them along.

Finally, I’ll leave you with this thought. Microsoft has seen many changes over the years. They are a behemoth of a company, and my perspective now is that there are two types of people in the company: the big company corporate types who are still convinced that closed and proprietary is the way to protect their products, brand, and customers and, on the other hand, the newer generation of product managers and developer evangelists who are making genuine attempts to be more open and transparent and finding ways to interact with the open source community to promote Microsoft as a good community citizen. Both are real faces of Microsoft. Don’t discount one for the other.

CodeWorks Wrap-up

2009-12-01T00:36:42-06:00

I never wrote about days 13 & 14 of CodeWorks, nor did I post the slides on October 7, like I promised to attendees of my talks. After CodeWorks, my website underwent weird spikes in traffic, causing it to be extremely slow. I thought the problem was DreamHost, so I moved everything to a slice at Slicehost. Long story short, my slice kept crashing, so I moved everything back to DreamHost after several weeks of intermittent uptime to let them deal with the problems. That’s what delayed my posting, and I apologize to those who have been looking for the slides.

To sum up CodeWorks New York, I would have to say that the energy and enthusiasm at the New York conference was, by far, the best of all seven cities. The turn out was great, and the hallway track was the best yet, with myriad discussions extending from the talks. I’m not sure what made the difference, but it was definitely the best stop.

Seven cities in fourteen days. CodeWorks was a whirlwind tour, and I was privileged to be a part of it. It was a pleasure to meet PHP developers in each city and to talk with those who lead user groups, are starting a group, or are thinking of starting one. And the talks were excellent, presented by some of the best and brightest in the PHP community. It was an awesome experience, and I’m glad we were able to take the conference to developers rather than expecting the developers to come to the conference. Though some cities had low attendance, the quality of each event was never lessened. If the conference continues next year, I think we’ll see more attendees in each city.

Yes, I would do it all again. So, I hope Marco sees fit to organize it next year, or at least, every other year.

I blogged every city we visited. If you’re interested, here are those posts:

As promised, here are the slides for my presentations (finally):

I hope to see you next year!

POST vs. PUT

2009-11-09T16:07:24-06:00

This morning, Matthew writes about building RESTful services with the Zend Framework. I have a lot of thoughts on his post, and I might blog more about it later, but right now, I want to focus on David’s comment:

I think the next thing you should cover is how to retrieve put parameters and maybe even attempt to start a discussion on the different school of thoughts about POST vs PUT (Especially in the PHP world).

I know I’m even guilty of mentioning different schools of thought on POST vs. PUT in my talks, but the truth is that REST doesn’t specify what to use for what actions. These are defined by HTTP and not by REST.

Roy Fielding has this to say about the use of HTTP verbs in RESTful applications:

Some people think that REST suggests not to use POST for updates. Search my dissertation and you won’t find any mention of CRUD or POST. The only mention of PUT is in regard to HTTP’s lack of write-back caching. The main reason for my lack of specificity is because the methods defined by HTTP are part of the Web’s architecture definition, not the REST architectural style. Specific method definitions (aside from the retrieval:resource duality of GET) simply don’t matter to the REST architectural style, so it is difficult to have a style discussion about them. The only thing REST requires of methods is that they be uniformly defined for all resources (i.e., so that intermediaries don’t have to know the resource type in order to understand the meaning of the request). As long as the method is being used according to its own definition, REST doesn’t have much to say about it.

The POST vs. PUT debate, however, does rage on in different communities, and some protocols have defined their usage. For example, the Atom Publishing Protocol (RFC 5023) explicitly states in section 4.3 that “POST is used to create” and “PUT is used to edit.”

The important thing to note is that REST doesn’t care how the HTTP verbs are used, as long as they are used properly according to how they are defined in the protocol you are using.

For those interested, HTTP (RFC 2616) defines POST by saying:

The POST method is used to request that the origin server accept the entity enclosed in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line. […] The actual function performed by the POST method is determined by the server and is usually dependent on the Request-URI. The posted entity is subordinate to that URI in the same way that a file is subordinate to a directory containing it, a news article is subordinate to a newsgroup to which it is posted, or a record is subordinate to a database.

PUT is defined as:

The PUT method requests that the enclosed entity be stored under the supplied Request-URI. If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a modified version of the one residing on the origin server. If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new resource by the requesting user agent, the origin server can create the resource with that URI.

With this line of thinking, you might come to the conclusion that POST is used for creation of a subordinate resource, while PUT could be used for both creation or modification of a resource. The important distinction is that POST identifies the resource for which the entity should be considered a subordinate; PUT does not.

Building Titanium with PHP

2009-10-05T19:48:41-05:00

Several months ago, I started the process of embedding PHP into the Titanium platform. After several sprints of work, the Appcelerator team was finally ready to merge my work into their master branch, and Martin Robinson worked to bring the implementation to maturity. The current release of Titanium Developer does not yet have the PHP support built in to the bundled SDK, and I’m not sure when it will be released, so I thought I’d share how to get a development version built with PHP support so you can start playing with it and even help the Appcelerator team by catching bugs in the implementation.

If you’re not familiar with Titanium, it’s a development platform that allows you to build native desktop applications for Windows, Mac OS X, and Linux using the Web technologies we use on a daily basis: HTML, JavaScript, CSS, Python, Ruby, and now PHP. Titanium is built on top of WebKit, and it includes a micro-kernel called Kroll that does all of the pre-processing and runtime processing of the code. Languages are modules in Kroll and are first-class citizens in the runtime environment. So, when using the runtime, you can pass objects back and forth between JavaScript, PHP, Python, and Ruby. This, however, can’t be done when using pre-processing mode, but in that case, your PHP scripts will work just like you’re used to them working on a web server.

Since it may still be a while before the next release of Titanium that includes PHP, I’ve decided to provide instructions here on how to build the SDK from the master branch and connect it to the Titanium Developer application. Sorry, but I don’t have instructions for Windows; these work on Mac or Linux.

Download (and install) Titanium Developer from http://www.appcelerator.com/products/download/
Launch Titanium Developer and let it do its thing (you’ll have to create an acct)
Now you may close it
You should now have a Titanium directory with the SDK in it at either:
- /Library/Application\ Support/Titanium/ (Mac)
- ~/.titanium/ or /opt/titanium/ (Linux)

Now, build the development SDK to use with Titanium Developer. You’ll need Python, scons, a compiler, and possibly other prerequisites.

$> git clone git://github.com/appcelerator/titanium_desktop.git
$> cd titanium_desktop/
$> git submodule update --init
$> scons dist

Unzip the built SDK to some location. I like to use ~/.titanium-dev/
1
$> unzip build/osx/dist/sdk-0.7.0.zip -d ~/.titanium-dev/

Move Titanium Developer SDK out of the way and point to your build SDK

$> cd /Library/Application\ Support/Titanium/
$> mv modules/ modules-old/
$> mv runtime/ runtime-old/
$> mv sdk/ sdk-old/
$> ln -s ~/.titanium-dev/modules modules
$> ln -s ~/.titanium-dev/runtime runtime
$> ln -s ~/.titanium-dev/sdk sdk

Now relaunch Titanium Developer.

You’re now ready to build a project with PHP!

Click Create to generate a stub project. I’ll cover more about development with PHP in Titanium in the future, but let’s get started by showing a phpinfo() page.

Open the index.html file in the Resources directory of your project and add the following anywhere in the page:

<p><a href="phpinfo.php" style="color:gray;">See the phpinfo()</a></p>

In the Resources folder, create the phpinfo.php script and add the following to that script:

<?php phpinfo(); ?>

Now, go back to Titanium Developer, click the Test & Package tab for your project, then click the Launch tab. To build and run your application for testing, click the Launch App button.

You should now see a dark gray test page with the “See the phpinfo()” link you created. Click that link, and it should take you to the phpinfo.php script you created with the proper phpinfo() output. Congratulations!

Visit the Appcelerator Codestrong developer center for more information on building Titanium applications. Visit #titanium_app on Freenode IRC to ask questions about application development. If you want to help develop the project and contribute PHP tests to it, join #titanium_dev.

CodeWorks Days 11 & 12 (Washington)

2009-10-03T21:51:07-05:00

Departing Miami, I gazed upon the Atlantic Ocean as we cut through the clouds, making our way farther from the shore, and the thought occurred to me that this tour — these two weeks — has taken me from sea to shining sea across this great country. What a fitting thought to have as this next leg of the tour took us to Washington, DC.

I have traveled the country and have engaged the PHP community face-to-face all across it. It has been a great experience and an excellent opportunity to connect with the PHP community at all ends of the United States. Perhaps a tour to other parts of the world is in order, to connect with the community on a global scale. If I’m ever afforded that opportunity and privilege, then I will be certain to evangelize the PHP Community in each location, hoping to grow our community, bringing in new faces and new ideas.

As I mentioned, our next stop was Washington, DC. Some of us took advantage of free time we had on the afternoon and evening of the tutorial day to visit the city and walk the Mall of the United States capitol. We walked from the Washington Monument to the World War II Memorial, along the Reflection Pool to the Lincoln Memorial, along the Viet Nam Wall, around the Ellipse, and to the White House. Andrei remarked that he was using this opportunity to “consumate his ”https://twitter.com/a/status/3115337537">citizenship." Finally, we had dinner at the Old Ebbitt Grill, apparently the oldest saloon in Washington.

After dinner, our small group met up with some of the other speakers and conference attendees at The Brickskeller, where we enjoyed each other’s company and some great beer — they have other 1000 beers.

The session day went well. After some technical difficulties with my HTTP presentation, I managed to get started, and one of the attendees even remarked that he thinks my talk is perhaps the most important one at the conference. That’s the best compliment I’ve ever received. Everyone stayed for the end of my talk, which ran fifteen minutes late, eating into the lunch period. My AtomPub talk later in the day was much smoother in delivery.

As I wrap up in Washington, I’m left wishing that I had more time to explore the capitol, but now it’s time to move on to New York and the last leg of our tour. I’m one step closer to going home, and while I’ve had a great time on the tour meeting new people, giving presentations, and hanging out with old friends, I’m ready to go home to my family.

I hope to see you at New York CodeWorks!

CodeWorks Days 9 & 10 (Miami)

2009-10-03T19:49:52-05:00

Miami CodeWorks, so far, was the smallest conference but I still think some important connections were made, especially with regard to user group contacts.

At the Microsoft happy hour on the second day of the conference in Miami, I was able to meet Brendon Van Heyzen, who is interested in starting up a PHP user group in Boca Raton. It seems that the Miami PHP user group has quietened down and gone silent, and he’s interested in starting up a group for the Boca Raton PHP community. We had a great discussion, and I offered him some points of advice on how to start a group, and this reminded me of the user group starter package I’ve discussed with Rafael and Michelangelo. I really need to push the PHP Groups initiative to get started on this.

The two main pieces of advice I offered were to start a mailing list and then to find adequate meeting space. The mailing list is important to get discussion going and to see what kind of group the people in your area want to have. It will inform your search for meeting space so you can find the kind of space that will work best for the type of meetings you want to have.

So, CodeWorks has been an excellent way to reach out to local leaders and people who want to start groups in their areas. If you’re interested in starting a group, join the PHP Groups mailing list and introduce yourself.

Rounding out our visit to Miami, I enjoyed some great Cuban food at Puerto Sagua, and we actually managed to find some good beer at The Room in Miami Beach. It was a beer oasis in the midst of a desert filled with mojito sand.

CodeWorks Days 7 & 8 (Atlanta)

2009-10-01T15:48:18-05:00

Atlanta was the mid-point stop on the CodeWorks tour, and since it’s my home, I decided to use it as an opportunity to spend time with my family before heading off on the second half of the tour. As such, there was very little hallway track activity for me, but I did get a chance to make it to a few events.

I’m told that Atlanta has had the largest CodeWorks crowd yet. I took a quick look around at each of the rooms, and I believe it. Each presentation was well-attended, and I’m proud to say that the Atlanta PHP user group was well-represented this year; I saw lots of familiar faces.

Speaking of Atlanta PHP, we had a good crowd at the Meet the Speakers dinner on Monday night. Many of the speakers attended, as well as attendees and Atlanta PHP members. I want to thank Glen Gordon and Microsoft for sponsoring the dinner. I think it was a great success, and we couldn’t have done it without Glen’s help. The only problem I have is that many people apparently treat meetup.com “yes” RSVPs as mere suggestions. If there’s a chance you’re not going to make it, please RSVP “maybe” or “no.”

I also want to thank Jeff Jones for hosting an after party as his place for many of the speakers. It was a lot of fun, and the beer was great.

Now we’re in Miami, and I’m a bit behind on blogging, but I’ll post about the Miami CodeWorks stop later today.

CodeWorks Days 5 & 6 (Dallas)

2009-09-27T19:13:49-05:00

Yesterday, the CodeWorks B-Team (the session day team, a.k.a. Team Awesome) ran into a bit of a travel snafu that actually worked out better for us. On the way to the airport in Los Angeles, we got stuck in traffic caused by an overturned cement mixer truck. And by overturned, I literally mean the cement mixer was lying flat on its back across the barrier separating the north bound from the south bound lanes. I’m not sure how it was even possible, but there it was. Derick took some video of the accident that he may or may not post later.

The traffic caused our team to be late to the airport, missing our flight. However, we were able to quickly book standby tickets for the following flight, giving us extra time at the airport to eat, placing us on a plane that had WiFi access (our original flight did not), and giving many of us exit row seats. So, it all worked out in the end.

The evening was short, due to our late arrival, but we still made it out to La Hacienda Ranch, apparently the home of the original frozen margarita. A highlight of the evening was being able to meet some of the gang from Dallas PHP, including Tim Stiles, whom I’ve conversed with online but have never met. Afterwards, a few of us ventured into Fort Worth to have a few beers at The Flying Saucer. Special thanks to Josh Holmes of Microsoft for driving us around.

As an aside, we — “we” being the speakers and community leaders attending CodeWorks — have been making lots of new friends with the Microsoft developer evangelists who have been in attendance. It seems that Microsoft has a new breed or new generation of dev evangelists who are genuinely interested in the PHP community, listening to us, and hanging out and having fun with us. For me, it’s a welcome improvement, and I’m not saying this as a surprise change I’ve only observed this week; it’s something I’ve been seeing over the last few years.

There have been a lot of great talks in Dallas. In addition to the set of CodeWorks touring speakers, the local speakers from Dallas PHP have provided some excellent presentations. I was able to enjoy Chris Cornutt’s B.S.T, Easy as 1-2-3 presentation, and now I’m sitting in Vance Lucas’s Object Oriented Apologetics.

The venue in Dallas is also excellent. We’re staying at the American Airlines Training & Conference Center, and while it’s not the fanciest of hotels, I think it has been the best hotel experience we’ve had, with some of the best food and best WiFi we have seen yet. But we’re not even half-way through the tour, so there is plenty of opportunity for this to change and for me to be wowed even more.

I’m heading home this evening. My home is Atlanta, and Atlanta is the next stop on our tour, so I’ve scheduled a little family time during the tour, but I’ll be joining the CodeWorks crew each day, tomorrow for the Atlanta PHP Meet the Speakers Happy Hour and on Tuesday for my presentation.

I hope to see you in Atlanta!