I. Codebase

“One codebase tracked in revision control, many deploys”

There’s really not much here that would be different in PHP versus any other language. Who isn’t using some form of revision control these days?

II. Dependencies

“Explicitly declare and isolate dependencies”

There are a few tools available to PHP developers to help manage dependencies. The PEAR package manager may help here, but has its flaws. Pyrus, the PEAR2 package manager, looks promising. There’s also Composer. I’ve heard of people using their operating system’s package manager (e.g. RPM) to deploy their PHP applications and manage dependencies. I’m not sure if there any tools in PHP to enforce dependency isolation.

III. Config

“Store config in the environment”

The simplest option here is to use environment variables. Many frameworks, including Zend Framework, allow you to have environment-specific configuration such as development, test, and production. This is not recommended for twelve-factor apps as it doesn’t scale as new environments are added.

IV. Backing Services

“Treat backing services as attached resources”

There’s not really anything to say here that’s specific to PHP.

V. Build, release, run

“Strictly separate build and run stages”

Phing or the more general-purpose Ant could work here. Even though it’s not written in PHP, there’s no reason why you couldn’t use Capistrano for this. I don’t think the run stage typically applies to PHP, as it happens implicitly as part of the release stage. However, there are tasks such as flushing the APC cache (if apc.stat=0) that might be considered part of the run stage.

VI. Processes

“Execute the app as one or more stateless processes”

PHP processes are already stateless and shared-nothing. This makes PHP a great fit for twelve-factor apps. Memory space or the filesystem should be used as a short-lived, single-process cache. If you’re using an asset manager, such as Assetic, then any assets should be compiled and cached during the build stage.

VII. Port binding

“Export services via port binding”

I don’t think port binding applies to PHP applications—at least not in the way it’s meant in twelve-factor. PHP relies on a web server and uses something like FastCGI or PHP-FPM to communicate with the web server. PHP 5.4 will have its own built-in web server, but this is intended for development use only. It’s really the combination of PHP and its web server that will be bound to a port. This brings up challenges when it comes to dependency management, as the web server itself is now a dependency.

VIII. Concurrency

“Scale out via the process model”

I’m not sure how processes would become first-class citizens in a PHP web application. However, each individual request/response cycle is handled by its own process. In that regard, PHP already uses the process model.

IX. Disposability

“Maximize robustness with fast startup and graceful shutdown”

PHP processes are very disposable. Again, this is just part of how PHP works.

X. Dev/prod parity

“Keep development, staging, and production as similar as possible”

Nothing specific to PHP here. Although, it’s not uncommon for PHP developers to use SQLite in development and MySQL or PostgreSQL in production. This is not recommended for a twelve-factor app—use the same software and versions of backing services in all environments.

XI. Logs

“Treat logs as event streams”

There are tons of logging options in PHP. Zend_Log_Writer_Stream lets you send log data to a PHP stream. Alternatively, StatsD and the PHP StatsD library look pretty good.

XII. Admin processes

“Run admin/management tasks as one-off processes”

This is easy enough in PHP. If you want an interactive shell with readline history, tab completion, and quick access to documentation then check out phpsh.

The Web still trumps the Mobile Web. If you’re making a web app, don’t let “mobile first” lead you astray.

Luke’s original premise is not wrong, but I think many web developers have interpreted “mobile first” as “mobile only”—often intentionally, sometimes by accident. As Chris pointed out, it’s easy to let “mobile first” lead you astray. My response to Chris was that the goal should be One Web, even if “mobile first”. “Mobile only” should rarely, if ever, be the goal. The concept of One Web is described in the W3C’s Mobile Web Best Practices 1.0 Basic Guidelines. From the original document:

The recommendations in this document are intended to improve the experience of the Web on mobile devices. While the recommendations are not specifically addressed at the desktop browsing experience, it must be understood that they are made in the context of wishing to work towards “One Web”.

As discussed in the Scope document [Scope], One Web means making, as far as is reasonable, the same information and services available to users irrespective of the device they are using. However, it does not mean that exactly the same information is available in exactly the same representation across all devices. The context of mobile use, device capability variations, bandwidth issues and mobile network capabilities all affect the representation. Furthermore, some services and information are more suitable for and targeted at particular user contexts (see 5.1.1 Thematic Consistency of Resource Identified by a URI).

Let’s not let the web fragment into a “mobile web”, a “desktop web”, and a “whatever comes next” web—there’s no reason for this. The underlying technology is designed to allow for One Web, as Ben Ramsey added:

@BradleyHolt @shiflett This is why we have content types, accept headers, user agent strings, and content negotiation.

If you’re considering taking a mobile first approach, please consider taking the One Web approach instead. Your main focus can be on mobile to start, but at least deliver something of value that is not dependent on the client being a mobile device. As Ben suggested, use content types, accept headers, user agent strings, and content negotiation to deliver the best experience based on your user’s device or browser.

• It will not handle deployment. This particular web application is deployed by the client’s IT department.
• It will create a ZIP file (it could just as easily create a tar.gz file) that the client’s IT department can extract and deploy.
• It will rename the document root since the document root is a different directory name in the client’s production environment then it is in our development and testing environments.

Next, an outline of what the build does:

1. Prompt for Subversion credentials (I’d rather not store these in a file).
2. Prompt for the Subversion tag to build from.
3. Delete the source directory if it exists.
4. Export the given tag to the source directory.
5. Rename the document root.
6. Create a ZIP file, named after the version, of the source directory’s contents.
7. Clean up after itself by deleting the source directory.

Both of the build files are in the project’s root directory (in my project, this is one directory above the document root). The build.properties file defines three properties: document root (so we can rename it to this new name), the source directory (the place to export to and then manipulate folders/files), and the URL to the repository’s tags directory.

The build.xml file is the actual build script, performing the actions outlined above. I’ve obfuscated the project name to be “acme”. I could not find a way to create a prompt that hides the Subversion password as it is entered (anyone?). For renaming the document root, I used the exec task to execute a move (mv) command since the move task failed for me (so this script will not work as-is on Windows).

Executing this script is as easy as running phing build-tag (once Phing is installed) from within the project’s root directory. Please let me know if you have any questions or see any room for improvement.

Real web designers write code. Always have, always will. #aea

This sparked many conversations including these two tweets from Chris Shiflett:

According to @zeldman, real web designers write code. (I think he means HTML and CSS, not PHP, Perl, and Python.) What do you think?

I’ve now asked, separately, whether developers and designers should know HTML and CSS. In both cases, most think they should. Interesting.

To which I responded (brackets added):

@shiflett IMHO, the demarcation between web developers and web designers should be POSH [Plain Old Semantic HTML]. That’s what both need to know.

I have a pretty strong opinion about this. You could say that I have the luxury of working with an excellent designer who implements all of his own CSS—even tackling much of the JavaScript coding on websites we build. To be clear: he is a designer, not a developer—working in both print (which is more technical than you might think) and web.

The typical process is summarized well in Marco Tabini’s PHP Advent 2009 post on CSS and Other People:

From a developer’s perspective, “design work” means having to deal with the often hated, sometimes impossible, and always challenging task of translating a designer’s comp into a combination of HTML and CSS that will render properly on browsers that are often at complete odds with one another.

In my opinion, that process is broken. Why is it assumed that because HTML and CSS are “code” it should be a developer’s job to implement these? Any decent designer is already familiar with the concept of separating presentation and content with style sheets (which are supported in Adobe InDesign, QuarkXPress, and even PageMaker and Microsoft Word). Is learning HTML and CSS, both declarative languages, considered too hard for designers?

Let’s take a look at comps and the dreaded “s” word—slicing. As Marco pointed out, trying to “slice” a comp into HTML and CSS is “sometimes impossible” and “always challenging.” If a designer is only providing a comp, and not the HTML and CSS, it is very likely that the designer does not have a solid understanding of things like progressive enhancement, browser compatibility, and even what is possible on the web.

The use of a comp generally assumes that design is purely visual and that all representations of the web page should look exactly like the comp. How should the content be presented to screen readers, to mobile devices, and in print? Sure, you could provide comps for each of these scenarios but this is not scalable and you quickly risk violating the “One Web” concept. Thinking of a web page through the lens of only one specific visual representation of that page is very limiting.

Do you agree that the typical process is broken? If so, what are the barriers to fixing this process? Do we need better trained web designers? Do organizations need to be educated on how to better structure their web teams? This problem will eventually self-correct. My prediction is that teams with web designers that know HTML and CSS will create better websites and web applications and be more successful than teams using the old process.

My administration worked closely with the Open Government Committee formed by resolution of the City Council. In response to committee recommendations, we’ve included more information about public meetings on the City web-site and the Planning Department added a new section about proposed and pending zoning amendments. During the campaign it was clear that people want to know more about the activities of each city department. Over the next year we’ll look closely at how to finance and build a more uniform, responsive and user-friendly City website that will keep you better informed about public meetings and how you can participate in the process of government.

I’m all for open government and the City of Burlington, Vermont could certainly use a better website. I’d like to give the city some advice on its priorities in building a better website. This blog post is my first round of advice, but I’d like to hear reactions from other web people in and around Burlington — or anyone else who has an interest in our city having a better website! This advice is based on the goals outlined by Mayor Bob Kiss: that the website is inline with the spirit of Open Government, is responsive, and is user-friendly.

First, the website must be accessible and use open standards. I put these two together because by using open standards the website can be accessible. Specifically, the website should use strictly semantic XHTML. This allows for its use in the widest range of user agents (browsers) by the widest range of user abilities (as opposed to disabilities). Its presentation should be progressively enriched through CSS and its behavior should be progressively enhanced through unobtrusive JavaScript. Progressive enhancement means that the website is useful, at its core, without any CSS or JavaScript. It becomes more useful through the use of CSS and then, perhaps, even more useful through the use of JavaScript. However, neither CSS nor JavaScript should be required to access the website’s content.

Second, the website should be built using free (as in freedom, not cost) and open source software. It is our government’s responsibility to use non-proprietary software wherever possible. When it comes to building websites and web applications, there are no excuses for not using free and open source software. The capabilities of the open web platforms available equal, or exceed, the capabilities of proprietary web platforms. Any custom software developed for the city’s website must be licensed to the city under a free and open source license (this does not mean that the city shouldn’t pay for this software to be developed).

Third, the city should embrace the concept of open linked data. This means that the city should publish data, not just content. This data should be both human and machine readable. This allows third parties to access raw data and repurpose this data in new and interesting ways. To this end, data and content should be either put in the public domain (which is probably the case already) or use a Creative Commons license. Where possible, the city’s website should consume open data published by others rather than duplicating effort. There are several technical approaches to publishing and consuming open linked data including Microformats and the Semantic Web.

I hope these recommendations are useful. Once I’ve heard some feedback from other web people, I’ll forward these recommendations to my city councilors and the mayor. Hopefully they’ll find it helpful in improving the city’s website!

There’s one catch. There are many web sites and web applications built on the incorrect assumption that the web is a visual medium. The web designers and web developers who build these web sites and web applications break the web. In order to not break the web, web designers and web developers need to use open standards starting with plain old semantic (X)HTML. This semantic (X)HTML can then be progressively enriched/enhanced using CSS (for presentation) and JavaScript (for behavior). This approach works well with the concept of One Web which “means making, as far as is reasonable, the same information and services available to users irrespective of the device they are using.”

Craig Cook has a good article about How to Grok Web Standards in which he addresses many of these ideas and more. If you still think I’m crazy, hopefully it’s not because you think I’m wrong about the web not being a visual medium. If you don’t think I’m crazy then maybe in another blog post I’ll talk about why I think that content management systems (CMSs) in general, and WYSIWYG editors specifically, break the web.

Most web developers don’t consider themselves designers—and shouldn’t. The reality of working on a website or web app, however, is that developers must either wear the designer hat or must interface with a designer/design team. Having a solid understanding of design best practices makes for a more efficient process and a higher quality product. Come hear more about web design and CSS from a designer’s perspective. We’ll cover semantic markup and its influence on CSS implementation, reset and debug stylesheets, tools for creating and debugging CSS, coding standards, and maybe even microformats if time allows. The goal isn’t to convert developers into design experts, but rather to give an overview of an effective design process that works for designers and developers alike.

Jason Pelletier is Creative Director and Web Designer for Found Line. The Burlington-based creative firm develops standards-based websites, product packaging and marketing strategies for growing businesses. Clients include Seventh Generation, Vermont Public Radio, EatingWell and True Body Products. Prior to co-founding Found Line, he managed creative resources for Seventh Generation, and was a designer for Stonyfield Farm.

More details here. Please pass this on to others you think might be interested. Pizza will be provided and we will be giving away a “please don’t hurt the web – use open standards” t-shirt as well as a copy of Jeffrey Zeldman’s book “Designing With Web Standards“. Hope to see you there!

My first thought was, since the application is being built in Zend Framework, just ship them the Zend Framework unit tests. It turns out there are a lot of unit tests and they have some heavy memory requirements. So, I decided on a simpler approach. I would run unit tests that simply tested for the requirements outlined in the Zend Framework documentation. Here are the tests:

/**
 * The Requirements test case.
 *
 * @category   Requirements
 * @package    Requirements
 * @copyright  Copyright (c) 2005-2008 Found Line, Inc. (http://www.foundline.com/)
 * @license    http://www.foundline.com/legal/software-license/ New BSD License
 */
class Requirements extends PHPUnit_Framework_TestCase
{

    public function testVersionOfPhpIs5Dot1Dot4OrLater()
    {
        $this->assertTrue(version_compare(PHP_VERSION, '5.1.4', '>='));
    }

    public function testVersionOfPhpIs5Dot2Dot3OrLater()
    {
        $this->assertTrue(version_compare(PHP_VERSION, '5.2.3', '>='));    }

    /**
     * @dataProvider requiredExtensions
     * @param string $extensionName the name of the extension for which to test
     */
    public function testExtensionLoaded($extensionName)
    {
        $this->assertTrue(extension_loaded($extensionName));
    }

    public static function requiredExtensions()
    {
        return array(
            'apc'           => array('apc'),
            'bcmath'        => array('bcmath'),
            'bitset'        => array('bitset'),
            'ctype'         => array('ctype'),
            'curl'          => array('curl'),
            'dom'           => array('dom'),
            'gd'            => array('gd'),
            'hash'          => array('hash'),
            'ibm_db2'       => array('ibm_db2'),
            'iconv'         => array('iconv'),
            'interbase'     => array('interbase'),
            'json'          => array('json'),
            'libxml'        => array('libxml'),
            'mbstring'      => array('mbstring'),
            'memcache'      => array('memcache'),
            'mime_magic'    => array('mime_magic'),
            'mysqli'        => array('mysqli'),
            'oci8'          => array('oci8'),
            'pcre'          => array('pcre'),
            'pdo'           => array('pdo'),
            'pdo_mssql'     => array('pdo_mssql'),
            'pdo_mysql'     => array('pdo_mysql'),
            'pdo_oci'       => array('pdo_oci'),
            'pdo_pgsql'     => array('pdo_pgsql'),
            'pdo_sqlite'    => array('pdo_sqlite'),
            'posix'         => array('posix'),
            'reflection'    => array('Reflection'),
            'session'       => array('session'),
            'simpleXml'     => array('SimpleXML'),
            'soap'          => array('soap'),
            'spl'           => array('SPL'),
            'sqlite'        => array('SQLite'),
            'standard'      => array('standard'),
            'xml'           => array('xml'),
            'zlib'          => array('zlib'),
        );
    }

}

Note that I’ve checked for both the recommended PHP version 5.2.3 and the required PHP version 5.1.4. Also, I’ve tested for both hard and soft dependencies for all components. This means that many of these tests could fail and my application could still be OK. I wanted as much information as possible so that I can detect any potential problems before I write too much code. As the specific requirements for this application become clearer, I will update the test to add or remove requirements. Of course, once there is real code and unit tests these requirements tests will become irrelevant. The point is to test for the presence of these requirements before I write the code.

Running these tests with the command phpunit --testdox Requirements.php (I’ve actually wrapped this into a bigger test suite, but that’s outside the scope of this blog post) gives me the following output on one of my development machines:

PHPUnit 3.3.1 by Sebastian Bergmann.

Requirements
 [x] Version of php is 5 dot 1 dot 4 or later
 [x] Version of php is 5 dot 2 dot 3 or later
 [x] Extension loaded with data set "apc"
 [x] Extension loaded with data set "bcmath"
 [x] Extension loaded with data set "bitset"
 [x] Extension loaded with data set "ctype"
 [x] Extension loaded with data set "curl"
 [x] Extension loaded with data set "dom"
 [x] Extension loaded with data set "gd"
 [x] Extension loaded with data set "hash"
 [ ] Extension loaded with data set "ibm_db 2"
 [x] Extension loaded with data set "iconv"
 [x] Extension loaded with data set "interbase"
 [x] Extension loaded with data set "json"
 [x] Extension loaded with data set "libxml"
 [x] Extension loaded with data set "mbstring"
 [x] Extension loaded with data set "memcache"
 [x] Extension loaded with data set "mime_magic"
 [x] Extension loaded with data set "mysqli"
 [ ] Extension loaded with data set "oci 8"
 [x] Extension loaded with data set "pcre"
 [x] Extension loaded with data set "pdo"
 [ ] Extension loaded with data set "pdo_mssql"
 [x] Extension loaded with data set "pdo_mysql"
 [ ] Extension loaded with data set "pdo_oci"
 [ ] Extension loaded with data set "pdo_pgsql"
 [x] Extension loaded with data set "pdo_sqlite"
 [x] Extension loaded with data set "posix"
 [x] Extension loaded with data set "reflection"
 [x] Extension loaded with data set "session"
 [x] Extension loaded with data set "simple xml"
 [x] Extension loaded with data set "soap"
 [x] Extension loaded with data set "spl"
 [x] Extension loaded with data set "sqlite"
 [x] Extension loaded with data set "standard"
 [x] Extension loaded with data set "xml"
 [x] Extension loaded with data set "zlib"

There are a couple of potential problems to be aware of. First, PHPUnit will have to be installed on the machine that this will be tested on. This should probably only be done on the staging machine, not the production machine. Second, the CLI version of PHP often uses a different php.ini file then the CGI or ISAPI version. This means that some requirements may actually be available to your web application but they will fail the test when run at the command line.

Last Tuesday during the opening keynote Zend announced the new Zend Framework certification. I was fortunate enough to get a testing slot on Thursday morning. After reading the 214 page study guide on Wednesday I passed the test, so am now a Zend Certified Engineer (ZCE) in Zend Framework! If you plan on taking the test, I definitely recommend reading the study guide. I’ve been using Zend Framework since 1.0 and I’m not sure I would have passed if I hadn’t read the study guide.