1. Add the following to your /etc/postfix/sasl_passwd file:

   smtp.gmail.com:587 username@gmail.com:password

   (Of course, you don’t have to use GMail or port 587, but you get the idea.)

2. Configure postfix:

   sudo postmap /etc/postfix/sasl_passwd

3. Backup and edit your postfix configuration:

   sudo cp /etc/postfix/main.cf /etc/postfix/main.cf.orig
   sudo vim /etc/postfix/main.cf

   If you use TLS, then you will need to add the TLS settings but the other settings should already be there as a result of running the postmap command. You should have these options set in /etc/postfix/main.cf:

   mydomain_fallback = localhost
   mail_owner = _postfix
   setgid_group = _postdrop
   relayhost=smtp.gmail.com:587
   smtp_sasl_auth_enable=yes
   smtp_sasl_password_maps=hash:/etc/postfix/sasl_passwd
   smtp_sasl_security_options=
   smtp_use_tls=yes
   smtp_tls_security_level=encrypt
   tls_random_source=dev:/dev/urandom

4. Start postfix:

   sudo postfix start

   If there are errors, you may need to edit your /etc/postfix/main.cf and restart postfix:

   sudo postfix reload

5. Send a test message:

   date | mail -s test youremailaddress@yourdomain.com

6. Make postfix start automatically on boot by opening your /System/Library/LaunchDaemons/org.postfix.master.plist file and adding:

   <key>RunAtLoad</key>
   <true/>

   Add this at the bottom just before the closing </dict> tag.

7. Edit your /etc/php.ini file and configure the sendmail_path option:

   sendmail_path = "sendmail -t -i"

You should now be able to send email using PHP’s mail() function. If you continue to have issues, watch the contents of your postfix mail log:

tail -f /var/log/mail.log

Write tests, you might learn something…faster

I’m working on an API integration that requires a bit of AES-256 encryption. Getting that worked out in PHP took some surprising turns, so just to be sure that I was getting all the details right (such as initialization vector size) I decided to write a unit test for my mcrypt wrapper library.

Since this library had worked well in other projects, imagine my surprise when the first AES-256 encrypt-decrypt test failed:

$ phpunit *
PHPUnit 3.7.8 by Sebastian Bergmann.

.F..

Time: 0 seconds, Memory: 2.50Mb

There was 1 failure:

1) EncryptionAes256Test::testEncryptDecrypt with data set #0 ('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefhijklmnopqrstuvwxyz')
Failed asserting that two strings are equal.
--- Expected
+++ Actual
@@ @@
-'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefhijklmnopqrstuvwxyz'
+Binary String: 0x4142434445464748494a4b4c4d4e4f505152535455565758595a61626364656668696a6b6c6d6e6f707172737475767778797a00000000000000000000000000

/Users/jhill/Sites/mrtz_010/Source/tests/EncryptionTest.php:53

FAILURES!
Tests: 4, Assertions: 7, Failures: 1.

Echoing out the decrypted string proved just as bizarre:

string(51) "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefhijklmnopqrstuvwxyz"
string(64) "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefhijklmnopqrstuvwxyz"

It seems that mcrypt pads the string with enough null characters (\0) to match the block size, and unlike strings in C, PHP strings do not necessarily end with the first null character.

The fix was obvious:

$decrypted = rtrim($decrypted, "\0");

Guess what? By investing time in a simple unit test, I unexpectedly learned something new about PHP, AND saved myself quite a bit of time debugging an API call that would not have worked.

I’d say it was worth it.

Genuine software engineers

This is extremely important to companies looking to hire talent. Ability to engineer software and build solutions that solve problems in a maintainable and scalable way are in high demand.

• Problem-solving ability
• Clean code
• Design patterns

Broader skill sets

While core specialties such as PHP are still as important as ever, employers these days are looking for candidates with more diversity than they have in the past.

• Higher demand for Javascript and Python
• NoSQL – has surpassed old-school relational database technologies such as Oracle
• Mobile development experience – less allowance for lack of actual experience in mobile development
• DevOps is a huge field
• Functional programming

Where do you want to go today?

Ari shared the “TLC3″ formula for evaluating both potential employers, and potential employees. There is no right or wrong answer, but these are important questions to ask:

• Technology – what tools/technologies are or will be used?
• Leadership – don’t like, or don’t trust current leadership? Do you want to lead, or would you rather follow?
• Compensation – is this firm, or are you willing to make trade-offs in exchange for other types of benefits (such as telecommute)?
• Career Path – what is your dream job? Will this help you get there?
• Culture – what goals, management styles, and ideals appeal to you? Is this a good fit?

My Multi-tasking in PHP talk at the Atlanta PHP User Group December 2012 meetup. Hope you can join us sometime!

Presentation link bundle (includes slides): http://bitly.com/atlphpm

Here I will describe the three early stages commonly encountered when scaling a new website or startup application. Each one builds off the previous ones, starting with the lowest-hanging fruit and working up.

Achieving each level requires significant amounts of work, testing, and benchmarking. Consider the economics and do not scale more than is necessary. As you grow, you will, if successful, have the revenue to scale with the demand.

At each stage you should benchmark to test the capacity you can handle, and monitor your load with respect to this benchmark so that you can scale proactively, before your site breaks rather than after.

Stage 1: (1) application server, (1) database server

1. Use an opcode cache such as APC to speed up PHP execution.
2. Move the database onto its own server.
3. Run Percona Server 5.5 instead of MySQL 5.5.
4. Tune your database server configuration (my.ini).
5. Swap out Apache for Nginx, it is a lot more efficient.
6. Store your user session data in the database (but watch out for this problem).
7. Store static assets in the cloud and server them using a CDN (I recommend Amazon S3 + Amazon CloudFront, but there are others). This will take a large portion of the load off your application server.
8. Store file uploads in the cloud (Amazon S3).
9. Audit the database queries and table structures for inefficiencies (missing indexes, poorly optimized joins, excessive queries).

Both servers should be running at least 512MB to 1GB of RAM. Properly configured, this simple setup will handle quite a beating. With fewer moving parts, you will have more time to develop and enhance your offering. As traffic grows, add RAM until it is more economical to move to Stage 2.

Stage 2: (1-2) load balancers, (2-5) application servers, (1) database server

1. Add 1 or 2 dedicated servers with load-balancing software running.
2. Add 2 or more identical copies of your application server.
3. Scale up your database server to at least 2GB RAM and re-tune your database server configuration.
4. Change your domain DNS to point to the IP address of the load balancer.
5. Use a deployment method that supports server clusters, such as Capistrano.

Cloud-hosted load balancing

Rackspace and Amazon provide load balancing as a service. You get redundancy, and you can use smaller web servers (256-512MB RAM) for cost savings. Amazon provides more datacenters and more flexibility. The cost of rolling your own load balancer is unlikely to be justified at this stage, and I highly recommend using one of these unless you have skilled system administrators on staff and have done a cost analysis that favors self-hosting.

When combined with Amazon’s Route 53 DNS service, you can configure multiple load balancers in multiple regions to provide an even greater level of redundancy.

Rolling your own load balancer

There are several open-source load balancing applications available, evaluate and choose the best one for your needs:

• Squid Cache, configured as a reverse proxy. Note that Squid can handle SSL (https) if needed, allowing your application servers to communicate with the load balancer more quickly over normal HTTP.
• HAProxy
• Nginx, configured as a reverse proxy
• Pound

If you are running more than one load balancer, use keepalived to handle failover.

Code deployments

When multiple application servers are involved, you will need an automated way to push out code deployments. There are several ways to do this:

• Create a tool using the Capistrano Ruby gem
• Roll your own tool using your preferred scripting language and rsync
• Configure a protected git server with your code, and set up a cronjob to perform a `git pull`
• Use a hosted code repository service like Beanstalk which supports code deployment via SFTP

Stage 3: (2+) load balancers, (5-10) application servers, (1) master database server, (2+) slave database servers

1. Scale your primary (master) database server to a sufficiently large size. Use Amazon RDS for a cloud-based solution, or get a high-performance dedicated server with 4-8 CPU cores, at least 3 SSD hard drives in RAID 5, and 8-32GB RAM (use at least as much RAM as your database size). All database inserts, updates, and deletes will be done on this server.
2. Add two or more dedicated database servers to function as read replicas. The server specifications will need to match that of your master database server, despite the fact they will be doing nothing but handling database read requests. Configure MySQL master-slave replication or DRBD to keep your read replicas in sync with the master database.
3. Update your application code to connect to the master database for writes and to the replicas for reads. Using a random or round robin scheme for choosing a read replica to connect to, or some other method based on your needs.

Beyond Stage 3

Beyond this point, scaling your site and keeping it running smoothly will require a dedicated team of system administrators, architects, developers, and testers. This is the situation that large-scale websites like Facebook, Twitter, Pinterest, and Etsy currently have and it requires lots of innovation, time, and cash.

Specialized Tools/Techniques

These could be selectively intermingled anywhere along the way, as needed.

• Search – use a dedicated search server, such as Sphinx.
• Use memcached on dedicated servers (or Amazon ElastiCache) to cache parts of your application, and/or your user session data.
• Migrate part or all of your database to a non-relational database, such as MongoDB (or Amazon DynamoDB).
• Partition or shard very large databases to get less-frequently-accessed data out of the way (and out of your database cache).
• Implement load balanced work queues using Gearman or similar to do background processing in an asynchronous fashion.
• Run reporting database queries on a separate database. Either run your reports on a dedicated read replica, or use one of the specialized data warehouse solutions that are on the market (such as Infobright).

Conclusion

Evaluate how much you really need to scale. The decision needs to be based on the data, of how much traffic you actually have now, how much you can afford to spend on scaling, and how much traffic you reasonably anticipate in the short term future–not on technological fads or overly optimistic dreams of grandeur. Remember that premature optimization will get you in trouble.

Should you do this yourself, or hire consultants? That depends on how fast you anticipate growing and what you can afford to pay. In light of the cost of hiring and retaining really competent developers and system administrators, you may find using consultants in the early stages to be more cost effective.

sem_release() releases the semaphore if it is currently acquired by the calling process, otherwise a warning is generated.
http://php.net/manual/en/function.sem-release.php

By far the worst, this limitation makes a whole class of problems much more difficult to solve, and in fact means that PHP’s Semaphore extension, despite the name, is really a mutex (a semaphore with ownership, i.e., only the acquirer may release). Furthermore, it is inconsistent with the behavior of equivalent functions in other languages such as C and Python.

Please see phm\Lock\Semaphore for a kludgy workaround using mutexes, shared memory, and a message queue.

Undefined error handling

What happens if you sem_get() using a key that is already in use by a different type of resource, say, a System V shared memory segment? This is an issue because ftok() (the normal way of generating IPC keys for this stuff) is collision-prone, given a large enough filesystem.

Undefined behavior of sem_get()

[T]he documentation does not stipulate what will happen if the max_acquire paramter is varied upon successive invocations of the sem_get method. [S]o setting it to 100, then to 1 on 2 successive calls will have an undefined behavior.
http://php.net/manual/en/function.sem-get.php#76793

This is avoidable, but it would be nice if this were fixed.

Cannot disable semaphore auto-releasing

If I write a program with a sem_get and auto_release=0, in case of shutdown, an other program should not be available to take the semaphore.
Bug #52701

A semaphore may be deleted when other processes are waiting to acquire it

sem_remove() should take the SYSVSEM_USAGE (see sysvsem.c) count into consideration when it is called. Only if this count is == 1 should the semaphore be removed. This will allow the last process that is using the semaphore to remove it from the system.
Bug #44109

Conclusion

The mantra among the PHP community seems to be “less bitchin’, more fixin’”, which is admirable. I do not wish to criticize or complain, but rather to document the need and hopefully encourage someone who has the background in C development to fix this (alas, I do not have this).

Presentation link bundle: http://bitly.com/atlphpm

Any task that needs to be done more than once is worth automating.
The Grumpy Programmer

Enjoy!

Except when they don’t.

I’ve learned from experience that these packages have ways of making you pay for the convenience you enjoyed up front. If you have ever needed to:

• Install a PHP extension that wasn’t already provided in your stack
• Run a specific version of PHP or MySQL
• Install PEAR packages
• Install SSL certificates
• Run command-line PHP scripts

…you may have encountered some ugly, time-wasting surprises along the way.

It pays to know your environment inside and out. Today, it is quite easy to roll your own Apache-MySQL-PHP stack on Windows, Linux, or even Mac OS X.

Getting started

This tutorial will show you how to roll your own MAMP stack with Mac OS X 10.7+ (Lion), Apache 2, MySQL 5.5, and PHP 5.4. If you wish to use different versions, a similar procedure should work but the specifics will probably vary.

For reference, I have provided a reference script which was the basis for this blog post: build-mamp-osx.sh.

We will perform the following steps:

1. Install dependencies needed for PHP
2. Compile PHP from scratch
3. Install MySQL
4. Configure PHP, MySQL, and Apache to run virtual hosts

1. Install PHP dependencies

1. Verify that you have the latest Apple XCode from the App Store. If you do not already have XCode, you may need to upgrade to the latest OS X.
2. Download and install XQuartz from http://xquartz.macosforge.org/. After installing XQuartz, run the following:

   sudo xcode-select -switch /Applications/Xcode.app/Contents/Developer
   ln -s /opt/X11 /usr/X11

3. Install Homebrew and run brew doctor to verify that it is working correctly.
4. Using Homebrew, install the following libraries:

   brew install libpng
   brew install libjpeg
   brew install gd
   brew install pcre
   brew install libxml2
   brew install mcrypt
   brew install icu4c
   brew install wget

5. Install the IMAP-2007f library:

   wget ftp://ftp.cac.washington.edu/imap/imap-2007f.tar.gz
   tar zxvf imap-2007f.tar.gz
   cd imap-2007f
   make osx EXTRACFLAGS="-arch i386 -arch x86_64 -g -Os -pipe -no-cpp-precomp"
   sudo cp c-client/*.h /usr/local/include/
   sudo cp c-client/*.c /usr/local/lib
   sudo cp c-client/c-client.a /usr/local/lib/libc-client.a
   cd ..

2. Compile PHP

1. Download and extract the latest PHP 5.4 source tarball from http://php.net/downloads.php:

   wget http://us3.php.net/get/php-5.4.9.tar.gz/from/this/mirror
   tar xzvf php-5.4.9.tar.gz
   cd php-5.4.9

2. Configure the makefile:

   ./configure \
   --prefix=/usr \
   --mandir=/usr/share/man \
   --infodir=/usr/share/info \
   --sysconfdir=/private/etc \
   --with-apxs2=/usr/sbin/apxs \
   --enable-cli \
   --with-config-file-path=/etc \
   --with-libxml-dir=/usr \
   --with-openssl=/usr \
   --with-kerberos=/usr \
   --with-zlib=/usr \
   --enable-bcmath \
   --with-bz2=/usr \
   --enable-calendar \
   --with-curl=/usr \
   --enable-dba \
   --enable-exif \
   --enable-ftp \
   --with-gd \
   --enable-gd-native-ttf \
   --with-icu-dir=/usr/local \
   --with-iodbc=/usr \
   --with-ldap=/usr \
   --with-ldap-sasl=/usr \
   --with-libedit=/usr \
   --enable-mbstring \
   --enable-mbregex \
   --with-mysql=mysqlnd \
   --with-mysqli=mysqlnd \
   --without-pear \
   --with-pdo-mysql=mysqlnd \
   --with-mysql-sock=/var/mysql/mysql.sock \
   --with-readline=/usr \
   --enable-shmop \
   --with-snmp=/usr \
   --enable-soap \
   --enable-pcntl \
   --enable-sockets \
   --enable-sysvmsg \
   --enable-sysvsem \
   --enable-sysvshm \
   --with-tidy \
   --enable-wddx \
   --with-xmlrpc \
   --with-iconv-dir=/usr \
   --with-xsl=/usr \
   --enable-zip \
   --with-imap=/usr/local/imap-2007 \
   --with-kerberos \
   --with-imap-ssl \
   --enable-intl \
   --with-pcre-regex \
   --with-pgsql=/usr \
   --with-pdo-pgsql=/usr \
   --with-freetype-dir=/usr/X11 \
   --with-jpeg-dir=/usr \
   --with-png-dir=/usr/X11

   Verify that this completed without errors before proceeding. If you have installed the dependencies listed in the previous step, there should be none.

3. Compile and install the PHP binary:

   make
   sudo make install

3. Install MySQL

1. Download and install the latest MySQL 5.5 Community Server binary (DMG package). Within the DMG archive, be sure to install all three components: the MySQL package, the MySQL.prefPane, and the MySQLStartupItem package.
2. Create your MySQL configuration file:

   sudo cp /usr/local/mysql/support-files/my-small.cnf /etc/my.cnf

3. Edit your ./profile and add the /usr/local/mysql/bin directory to the path.You will need to restart Terminal for this to take effect.
4. Restart MySQL using the System Preferences MySQL pane.
5. Verify that MySQL is running on localhost:

   mysql -u root

   It is recommended that you set a root password at this point.

4. Configure PHP, MySQL, and Apache to run virtual hosts

1. Enable mod_php and virtual hosts in your Apache configuration by adding the following lines to your /etc/apache2/httpd.conf file:
2. Configure the MySQL socket settings in your /etc/php.ini file:
3. Restart apache:

Adding Virtual Hosts

Once your MAMP stack in set up, here is how to create virtual hosts:

1. Add your virtual host domain name to the /etc/hosts file (requires Administrator or sudo access):

   127.0.0.1 helloworld.dev

2. Add a virtual host block to your /private/etc/apache2/extra/httpd-vhosts.conf file (requires Administrator or sudo access):

   <VirtualHost *:80>
   	ServerName helloworld.dev
   	DocumentRoot "/Users/jhill/Sites/helloworld.dev"
   	<Directory "/Users/jhill/Sites/helloworld.dev">
   		Options Includes FollowSymLinks  
   		AllowOverride All
   		Order allow,deny
    		Allow from all
   	</Directory>
   </VirtualHost>

3. Restart Apache:

   sudo apachectl restart

4. Add an index.php file in your virtual host document root, ~/Sites/helloworld.dev/:

   <?php echo 'Hello, world!';

5. Browse to http://helloworld.dev/ in your web browser.

Conclusion

Building your own MAMP stack with Mac OS X 10.7+, MySQL 5.5, and PHP 5.4 is easier than you think, and offers the advantages of total flexibility, less “magic”, better reliability, and a greater understanding of where things are and how to fix them if they break.

Did you try it? How did it go?

While writing a simple command-line utility in PHP I wanted to use the full block (█) and light shade (░) characters to create a simple progress bar that is a bit nicer than the typical =========....................

Like this:

█████████████████░░░░░░░░░░░░░░░░░░░░░░░ 42.5%

Instinctively, I turned to PHP’s chr() function and looked up the extended ASCII codes for the characters I needed. Boy, was I disappointed when my progress bar was nothing but a series of un-useful question marks. Surely PHP can render simple ASCII characters, I thought.

It might have gone differently if I had been using a PC, but I do 100% of my development these days on a Macbook Pro. It so happens that the bash shell in UNIX, Linux, and Mac OS X all use UTF-8 encoding by default, not CP437. (Of course, your terminal font will need to support UTF-8 characters for this to work.)

So, I just needed to find the UTF-8 codes for the characters I needed and use those instead of the old familiar CP437 ones. However, the results weren’t much better.

After an hour or more of Googling and experimentation, I finally realized that chr() doesn’t do UTF-8. I found various suggestions on how to produce the desired characters using custom functions and the like, but the best way turned out to just use a good ‘ol HTML entity and run it through html_entity_decode:

$block = html_entity_decode('█', ENT_NOQUOTES, 'UTF-8'); // full block
$shade = html_entity_decode('░', ENT_NOQUOTES, 'UTF-8'); // light shade

Now, a progress bar isn’t exactly a box, so let’s demonstrate:

$tl = html_entity_decode('╔', ENT_NOQUOTES, 'UTF-8'); // top left corner
$tr = html_entity_decode('╗', ENT_NOQUOTES, 'UTF-8'); // top right corner
$bl = html_entity_decode('╚', ENT_NOQUOTES, 'UTF-8'); // bottom left corner
$br = html_entity_decode('╝', ENT_NOQUOTES, 'UTF-8'); // bottom right corner
$v = html_entity_decode('║', ENT_NOQUOTES, 'UTF-8');  // vertical wall
$h = html_entity_decode('═', ENT_NOQUOTES, 'UTF-8');  // horizontal wall

echo $tl . str_repeat($h, 15)  . $tr . "\n" .
     $v  . ' Hello, World! '   . $v  . "\n" .
     $bl . str_repeat($h, 15)  . $br . "\n";

Voilà!

UTF-8, once you get used to it, actually provides many more possibilities than CP437 did back in the MS-DOS days. Enjoy!

This is not a bug. It is a documented optimization feature. See http://php.net/manual/en/ini.core.php and look for the section on auto_globals_jit with the big pink warning which says, “Usage of SERVER and ENV variables is checked during compile time so using them through e.g. variable variables will not cause their initialization.”

I encountered an odd bug in PHP 5.3.10 while attempting to loop through all the major superglobals ($_SERVER, $_GET, $_POST, etc). Here is what I found, if you can shed any light on why this happens, or if you can confirm that it isn’t just me, I would greatly appreciate it!

Test Case

<?php
var_dump($GLOBALS['_SERVER']);
// These behave the same way:
// $var = '_SERVER'; var_dump($$var);
// var_dump(${$var});

Expected Behavior

$GLOBALS["_SERVER"]: array(27) {
...
}

Actual Behavior

NULL

Workaround

What makes this so strange is that if you access $_SERVER (or ${'_SERVER'}) directly in the code anywhere—even if it doesn’t actually get executed—this bug does not manifest itself! In other words, this works just fine:

<?php
var_dump($GLOBALS['_SERVER']);
exit;
$var = $_SERVER;

Day 1

!Normal===Awesome!

Cal Evans inspired us all to go out and build awesome stuff, and that we owe a debt to the giants who came before us and gave, to give to those coming after.

• “This stuff is hard. If it looks easy, it’s because I’m good at it.”
• Get involved somewhere.
• Be a builder, a speaker, a teacher.

Building Testable PHP Applications

Chris Hartjes delivered a really helpful talk on testing applications. One of the big obstacles of unit testing for me was mock objects. Chris did a good job explaining how they are used in the context of PHPUnit. Key takeaways for me:

• Automate test execution.
• Following the law of demeter will make your applications easier to test.
• Code in a framework-agnostic and environment-agnostic way.
• PHPUnit provides methods for setting up mock objects, so you don’t have to actually define those classes.
• Test private/protected methods and properties by using a Reflection hack. Etsy’s PHPUnit extensions can automate this.
• Don’t access the database in Unit tests, use mock objects instead. Filesystem access can be mocked using vfsStream.
• Some applications resist testing, no matter what. If you cannot refactor, you can still automate tests with Behat.
• If you don’t test, Chris will cut you!

See his slides at SpeakerDeck.com.

PHP Extensions for Dummies

Elizabeth Smith laid bare the innards of PHP in her intro to PHP extension development. Much of it was unintelligible to me since I don’t (yet) know C. However, now I know who to go to if I need help compiling an extension! If I can navigate the dependencies, I’d like to try compiling a non-thread-safe Windows build of php_wkhtmltox for a future blog post.

Pixel Punching with PHP

Bob Majdak‘s presentation compared the usage and performance of GD2 and IMagick across a number of common image manipulation tasks. IMagick is better in almost every way.

See his slides at SpeakerDeck.com.

Day 2

It Was Like That When I Got Here: Steps Toward Modernizing a Legacy Codebase

Paul Jones‘ keynote did not disappoint. With insight and humor, Paul dismantled the problems with legacy codebases and presented a logical methodology to improving your life when you are forced to inherit a big stinkin’ pile of spagetti code.

• No matter how bad you want to, resist the urge to throw it out and rewrite.
• You’ve nothing to lose. Either bear the pain of bad code, or bear the pain of refactoring bad code. May as well put the suffering to some use.
• Move class files to a common base directory and autoload, removing require/include calls as you go.
• Change class names as you go, if needed.
• Wrap procedural functions in a class, so that it can be autoloaded.
• Replace globals incrementally, moving them first to the constructor, then replacing them with dependency injection

SOLID – Not Just a State Of Matter, It’s Principles for OO Propriety

Chris Weldon laid out five principles to get the most out of object oriented development.

• Single responsibility: each class should do one and only one thing.
• Open/Closed principle: each class is open to extension, but closed for modification. Don’t break stuff.
• Liskov Substitution principle: replace if…else constructs and prevent exceptions by using typed collections.
• Interface segregation: each interface should be as focused as possible, so that it can be used by as many classes as need it. Similar to the Open/Closed principle, applied to interfaces.
• Dependency Inversion: injection dependencies from the outside, don’t couple on the inside.

Fast, Not Furious: Performance Tuning that Works

Davey Shafik demonstrated how to use xhprof/xh-gui and Memcache to optimize your PHP application.

• 1. Benchmark. 2. Profile. 3. Change.
• Profiling affects performance, similar to quantum observation.
• Benchmarking tests actual runtime, from start to end.
• Namespacing Memcache keys can help overcome the 1MB size limit
• Create new namespaces, don’t clear the cache. Garbage collection will clean up the old unused namespaces.
• “Hardware is cheap, programmers are expensive” only holds when you take care of your hardware.
• Don’t make assumptions, test everything sequentially.

openssl genrsa -des3 -out server.key 1024
Generating RSA private key, 1024 bit long modulus
.....................++++++
.................++++++
unable to write 'random state'
e is 65537 (0x10001)
Enter pass phrase for server.key:

openssl rsa -in server.key -out server.key.insecure
mv server.key server.key.secure
mv server.key.insecure server.key

openssl req -new -key server.key -out server.csr

/etc/apache2/ssl/domain.com.key
/etc/apache2/ssl/domain.com.crt
/etc/apache2/ssl/domain.com.bundle

<VirtualHost {ip_address}:443>
    DocumentRoot /var/www/vhosts/domain.com

    SSLEngine on
    SSLVerifyClient none
    SSLCertificateFile /etc/apache2/ssl/domain.com.crt
    SSLCertificateKeyFile /etc/apache2/ssl/domain.com.key
    SSLCertificateChainFile /etc/apache2/ssl/domain.com.bundle

    <Directory /var/www/vhosts/domain.com>
        AllowOverride All
        order allow,deny
        allow from all
        Options -Includes -ExecCGI
        AddOutputFilterByType DEFLATE text/html text/plain text/css text/xml application/x-javascript
    </Directory>
</VirtualHost>

/etc/init.d/apache2 restart

That’s all!

dyld: Symbol not found: __cg_jpeg_resync_to_restart
Referenced from: /System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/ImageIO.framework/Versions/A/Resources/libTIFF.dylib
Expected in: /Applications/MAMP/Library/lib/libJPEG.dylib
in /System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/ImageIO.framework/Versions/A/Resources/libTIFF.dylib

Oddly, other commands execute fine from PHP using shell_exec(). Even more strangely, the external program ran fine when executed from a PHP command-line script, just not from MAMP’s bundled version of Apache!

Thanks to this tidbit from the PrinceXML forums, the solution was easy:

MAMP changes the environment variable $DYLD_LIBRARY_PATH. Check the file:

/Applications/MAMP/Library/bin/envvars

and try out if commenting out the two uncommented lines will work for you.

After a little experimenting, I discovered that cURL makes it super easy to un-shorten a URL that has been shortened, without depending on a third-party service.

Improving slightly on this function, here’s how I did it in PHP:

function unshorten_url($url) {
    $ch = curl_init($url);
    curl_setopt_array($ch, array(
        CURLOPT_FOLLOWLOCATION => TRUE,  // the magic sauce
        CURLOPT_RETURNTRANSFER => TRUE,
        CURLOPT_SSL_VERIFYHOST => FALSE, // suppress certain SSL errors
        CURLOPT_SSL_VERIFYPEER => FALSE, 
    ));
    curl_exec($ch);
    $url = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL);
    curl_close($ch);
    return $url;
}

That’s all you have to do. This works even if multiple URL shorteners are used in sequence on the same link, and in the event of an error, you’ll just get the same link back that you started with.

This seems to be a bit more robust than some of the other solutions floating around the ‘net, since it doesn’t try to hack the response headers or body (which could change without notice), and it will recurse as many times as it needs to up to the value of the CURLOPT_MAXREDIRS setting.

Enjoy!