On the PHP::Impact blog today Federico takes a look at the history of using models in components within the Zend Framework:

More and more users are finding it difficult to load models within Zend Framework modules. This is strange, considering that modularity is an important design principle and its goal is to design systems that are easier to extend, understand, design and manage.

He brings in quotes and examples from different developers' blogs talking about their use and brings it up to the present day with an example of using a Zend_Module_Front controller with a Zend_Module_Action in a simple example of a module-specifc method for using a model.

On the PHP::Impact blog, there's a new post mentioning some of the problems that he (Federico) has run into when his Zend_Form forms got larger and larger - performance.

If you are using Zend_Form and your site increases in complexity and attracts more traffic, you are most likely to run into performance problems. Of course, bigger and more complex projects result in more load on your servers. [...] In this post I'll explain the problems I faced when using Zend_Form and how I managed to optimize it and improve the performance of my application.

He ran a few tests against his code and found out that one of the biggest causes of overhead was the many calls to other components in the framework to handle different parts of the output. His solution was to modify the Zend_Form_Elements component to check for dependencies before the form is executed. Pre-loading like this prevents the high-overhead (and repetitive) dynamic loading later on.

On the KillerPHP blog today, Stefan Mischook comments on whether or not WordPress version 2.5.1 "sucks".

I just recently installed the this latest version of Wordpress (2.5.1) and quickly found it hanging (while trying to load a page) for as long as 40-50 seconds! I then proceeded to isolate the potential causes (database, custom fields, custom theme) and have since found out that something stinks in 2.5.1's core.

He details some of the steps he took to try to track down the bug - installing on another server, searching the web for others with the same issue. His suggestion?

Before you upgrade your old working installation of Wordpress, I would suggest that you test 2.5.1 in some other directory just to be sure it works with your server.

Michael Girouard has posted his 10,00 foot view of the typical structure of an Model/View/Controller application (and framework) and how a page request is handled:

In my previous article, I announced that I would be documenting the process of developing a simple MVC framework. In this post I will go into a little more detail about each of the specific components of our MVC and will discuss the series of events which occur each time a page loads, otherwise known as the page load scenario.

He talks about how URIs work, the role of mod_rewrite, several of the objects involved (like the Front Controller, Request, Route and View) and how they all fit in with the custom Models, Views and Controllers the user could define.

DevShed has posted the fourth part of their series looking at working with the DOM functionality of PHP5, this time with a focus on working with multiple document nodes inside of an XML document.

It's time to learn a few other methods included with the DOM XML extension. Based upon this premise, in this fourth tutorial I'm going to show you how to get access to multiple nodes of an XML document, either for internal processing or simply for echoing to the browser.

They show you how to grab the collection of nodes to work with and how to grab data from an XML text file with load() and loadXML().

Leon Chevalier has posted about a class he's developed (you can download it here) that can help to speed up the load times for your site.

There are 4 relatively easy ways by which you can speed up the time it takes a browser to download a page. Following on from my post on joining CSS and JavaScript files, I have written a PHP script which will automatically do all of the above.

He gives example code of the class in action and includes some screenshots of the benchmarks from the YSlow Firefox extension showing the improvements.

Chris Merrill has written up a case study measuring the load handling abilities of the Zend Optimizer with a default application - in this case, SugarCRM.

This article measures the performance impact of the Zend Optimizer on a real-world processor-bound PHP application (SugarCRM) under load. Our measure of performance is user capacity. We define that as the number of simultaneous users that the system can support while meeting the specified performance criteria. The performance criteria for this test require that all pages load within 6 seconds and no errors are encountered in the application.

The process is broken out into a few different sections including the methodology he used (including the software list, hardware used and configurations of both) and the results/analysis from running the test requests (such as page duration and server process use).

Felix Geisendorfer has a reminder from developers out there - "PHP 5.2.1 was an evil release":

While I was at php|works I heard a lot of people say how bad of a release 5.2.1 was and that I should stay away from it. Well I didn't take it to seriously at this point, but when I checked what version of PHP we are running on my client project recently it turns out it was 5.2.1.

They were seeing performance issues (database related) so they upgraded to the latest version, 5.2.4, and immediately saw a performance jump of forty to sixty percent and a much lower amount of CPU usage. Upon some further research, he found a certain bug in 5.2.1 that could have been the culprit.

This new entry on Ryan Grove's blog today points out a handy little tool written in PHP that can be used to (somewhat) reduce the time it takes for your pages to download.

Minify is a PHP library that attempts to fix this problem by combining multiple CSS or JavaScript files into one download. By default, it also removes comments and unnecessary whitespace to decrease the amount of data that must be sent to the browser. Most importantly, it does all of this on the fly and requires only a few simple changes to your existing web pages.

He gives a before and after example of the things it can do - mainly combining multiple tags (like link and script) and their information into one. Check out its page on the Google Code site for more information.

On the Stubbles blog, there's a new post that describes how to load in classes from the XP-Framework into the Stubbles framework.

The following little example uses a so called foreign class loader that is responsible for a given namespace, in this case net.xp_framework. This class loader is registered within the default Stubbles class loader. After that, all classes that reside in the namespace where the foreign class loader is responsible for will be loaded via this class loader.

The method they use is simple - seven lines of code simple. It loads in the class file using the load() functionality of the Stubbles framework making it so it can be called natively after creating an object for it.