The DPC Radio site has posted their latest recoding from last year's Dutch PHP Conference (2012) with Thijs Feryn's talk Scalability Issues: Cure First, Prevent Later.

The "it works on my machine" mentality has resulted in numerous face palm moments. This is even more painful when a your app is under heavy load due to a marketing campaign. With some minimal code changes and some smart utilities, you can maximize your scalability and performance. Keywords: Varnish, PHP-FPM, Nginx, APC, CDN, Gearman, Memcached and a proper server setup. I'll show you how you can make a slow app with a crappy code base go mighty fast on one and even multiple servers. The focus of this talk is to cure first and eventually learn and prevent.

You can listen to this latest episode either through the in-page player or by downloading the full mp3. You can also subscribe to their feed to get the latest podcasts episodes as they're released.

Hugh Williams has a new post with his recap of the "PHP at Scale" panel from this year's PHP UK Conference.

The good news was that Rasmus and Nikolay couldn't see any reasons why PHP was particularly challenging. What we saw were general challenges in scaling applications to large traffic volumes - and that's pretty much where the panel discussion went. Here's a few key points from the discussion.

Highlighted points included: removing bottlenecks to help performance (simple in theory, hard in practice), the fact that PHP should never be the bottleneck, the "odd direction" of HipHop, challenges/growing pains in moving from startup to a large web property. There was also a less technical discussion about "scaling teams" and finding the right (motivated) people to do the job.

On the PHPFog blog there's a recent post explaining their service in a bit more detail and how it provides the PHP applications out there with a huge amount of scalability that a traditional virtual server can't.

PHP Fog is a new type of hosting provider for PHP applications developers to build applications the good old-fashioned way but with easy scaling, reliability, speed, and easy deployment/management compared to traditional shared/dedicated hosting.

They look at a few situations where scalability can play a key role - traffic surge, growth leads to performance degradation and underutilized servers - and how the answers to these issues are best described as "scaling up", "scaling out" or scaling down", all things that more traditional hosting doesn't do well. Cloud-based platforms, like PHPFog (or Orchestra) can give you that high availability you need, so no matter the situation.

On StackOverflow a question was asked about how to tweak and tune the performance of a Kohana-powered website. The result was a detailed answer from Pascal Martin that can be applied to just about any kind of web application out there, not just ones written in PHP.

Here are some points that come to my mind when talking about performances, scalability, PHP, ...First of all, there are many aspects/questions that are to consider : configuration of the server (both PHP, MySQL, and system) ; you might get more help about that on serverfault, I suppose, PHP code, database queries, using or not your webserver? Can you use any kind of caching mechanism ? Or do you need always more that up to date data on the website ?

He goes on to give tips about using a reverse proxy (like Varnish), using an opcode cache, caching data as well, profiling and optimizing SQL queries. He finishes it off with a more specific look at Kohana and how you can use some of its built in tools to accomplish these same goals.

On the Ibuildings techPortal today there's a new post by Sam de Freyssinet about a slight modification to a well-known pattern (MVC) by adding some scalability - the Hierarchical-Model-View-Controller pattern.

It can also be very costly in time and resources to re-architect software that not scaled well. Ideally applications should grow organically as required and without large sums of money being exchanged in the process. [...] The Hierarchical-Model-View-Controller (HMVC) pattern is a direct extension to the MVC pattern that manages to solve many of the scalability issues already mentioned [in this post].

He talks about the benefits of the HMVC style and how its multiple parts work together and how it promotes code reuse more than the traditional MVC pattern. Some sample code is included so you can get your hands dirty with more than just the concepts behind the pattern including a more real-world example, their service (Gazouillement) that works similarly to twitter.

Those of you out there that work with PHP and Oracle might want to check out the new article that Alison Halloway mentions in her blog today - a reprint of a fellow Oracler - Richard Rendell's article, "The Oracle PHP Connection" [pdf].

In this article we take a look the connection methods used for PHP and Oracle database using the PHP OCI8 extension. Specifically we cover non-persistent and persistent connections while offering some suggestions for choosing the right approach. In addition we will cover some upcoming features in the next major release of the Oracle database to significantly improve scalability of PHP applications.

He talks about [pdf] the types of Oracle->PHP connections, what the database name connection strings are (with examples) the environment variables for connections, closing the connections, a look at connection pooling, and an overview of using DRCP (Database Resident Connection Pooling) to accomplish it.

In his latest blog entry, Jeff Moore tries to dispel a rumor about PHP code that's been floating around for years now - that it's considered hard to maintain.

The technocrat, heavily invested in his own technical prowess, faced with successful yet technically inferior code experiences cognitive dissonance. The only thing to do is to belittle the successful, but surely offensive code. "I could write better code than this," he says, or "this code sucks," or "this is unmaintainable."

Unfortunately, what Jeff says about many programmer's first introduction to PHP is right - that they download a popular application to check it out. This code is not always, shall we say, stellar. Jeff also brings up the point that the "PHP doesn't scale" myth goes hand in hand with this. After all, the larger the application, the larger the code, right? And the larger the code, the less maintainable it is, right?

Of course not - there are wonderful large PHP applications that are as easy to jump into and add/modify functionality to and keep up to date as there are small. PHP has one major thing going for it - it's simple nature lets developers keep things simple, and simple is good.

John Coggeshall has linked to the download of the slides from his latest (and very popular) conference talk - Top 30 Scalability Mistakes.

For those of you who are interested, you can download my slide from the tutorial I gave at ApacheCon this year. This is a very popular talk that I've been giving all year -- and this is by far the most extensive version of the talk yet.

The slides cover topics like system scalability, PHP scalability, database scalability, web server scalability, and using these tips to optimize your application.

On his blog today, Chris Shiflett an article mentioned in this previous post from the O'Reilly ONLamp.com site about PHP and scalability.

There's an interesting blog entry on O'Reilly's web site discussing Digg's PHP Scalability and Performance. As part of his research, the author (Brian Fioca, a Java developer) interviewed Owen Byrne, cofounder and Senior Software Engineer at Digg, and built his own PHP application, Jobby.

Chris also points out some of the interesting comments made in the entry, including mentions of Digg's stats and some great comments testifying to the light, powerful nature of PHP.

When someone talks about PHP and drags up the old "but it doesn't scale well" argument, drop them an email with this new article from the O'Reilly ONLamp.com site that might change their minds. In it, they share some information they gathered (spurred on by James Gosling's comments on PHP a bit back) on how one large site, digg.com, has dealt with their huge popularity and scaling their PHP-based system.

They focus mainly on the cost of scalability - whether that be in hardware costs or simply in manhours. He interviews Owen Byrne, Senior Software Engineer for digg.com about some of his decisions on how to handle the explosive growth. They look at what "performance" and "scalability" really are, and some of Byrne's concerns on the matters as it pertains to PHP. They touch briefly on a few topics, including the hardware cost, the database cost, and the actual PHP coding cost of applications.

It turns out that it really is fast and cheap to develop applications in PHP. Most scaling and performance challenges are almost always related to the data layer, and are common across all language platforms. Even as a self-proclaimed PHP evangelist, I was very startled to find out that all of the theories I was subscribing to were true. There is simply no truth to the idea that Java is better than scripting languages at writing scalable web applications. I won't go as far as to say that PHP is better than Java, because it is never that simple. However it just isn't true to say that PHP doesn't scale.

Pass it on...