The question
Anywho…that’s when my benchmarking and optimizing curiosity kicked in.  It wasn’t until yet another talk at work concerning the benefits of an MVC framework (Symfony) that I started to think about Zend Framework and its performance out of the box (without caching).   So I sat down today and started to benchmark the framework with a simple question in mind, “How does a simple ZF application compare to an application not using it?”

The applications
To answer the question I created 3 web projects. The first web project was a static-HTML only application which displayed “hello world” on the screen, very simple.  (For those who just want to see the ab results click here as well as the Xdebug cachegrind output file.)

The second web project was a single PHP file with the below PHP code.

Listing 1.1 – Simple Hello world PHP
<?php echo "hello world"; ?>

The above 2 projects acted as my baselines. it would allow me to determine the overhead ZF introduced into the application.

Finally, the third web project was created using ZF’s Zend Tool and executing the below command.

Listing 1.2 – Zf Project Creation.
> zf create project helloworld_zf

Finally, I replaced the default index.phtml HTML with the simple PHP code shown in Listing 1.1. 

Yes some may say that these examples are far too simple, but I wanted to test the Framework’s process to load and what better way to do this than with a very simple example.  I also based it off the talk that was given comparing Symfony.

The Hardware & ab command
Here is the set-up.
1.  Windows machine running Apache 2.2
2.  PHP 5.2.9
3.  Zend Framework 1.8.4
4.  Pentium 4 3.20 GHz
5.  1Gbs of RAM

I used the Apache Benchmark, ‘ab’, tool which comes included with all Apache installation and ran the below command 3 times.

Listing 1.3
> ab -n 1000 -c 5 http://localhost/index.[html|php]

The results, for me, were very surprising. I have included all the ab outputs.

Observations
HTML ONLY – Reading 1
Concurrency Level:      5
Time taken for tests:   2.344 seconds
Complete requests:     1000
Failed requests:        0
Write errors:           0
Total transferred:      352000 bytes
HTML transferred:       83000 bytes
Requests per second:  426.67 [#/sec] (mean)
Time per request:       11.719 [ms] (mean)
Time per request:       2.344 [ms] (mean, across all concurrent requests)
Transfer rate:          146.67 [Kbytes/sec] received

HTML ONLY – Reading 2
Concurrency Level:      5
Time taken for tests:   2.375 seconds
Complete requests:     1000
Failed requests:        0
Write errors:           0
Total transferred:      352000 bytes
HTML transferred:       83000 bytes
Requests per second:  421.05 [#/sec] (mean)
Time per request:       11.875 [ms] (mean)
Time per request:       2.375 [ms] (mean, across all concurrent requests)
Transfer rate:          144.74 [Kbytes/sec] received

HTML ONLY – Reading 3
Concurrency Level:      5
Time taken for tests:   2.344 seconds
Complete requests:     1000
Failed requests:        0
Write errors:           0
Total transferred:      352000 bytes
HTML transferred:       83000 bytes
Requests per second:  426.67 [#/sec] (mean)
Time per request:       11.719 [ms] (mean)
Time per request:       2.344 [ms] (mean, across all concurrent requests)
Transfer rate:          146.67 [Kbytes/sec] received

Observations:
1.  Roughly 0.0117 seconds per request.
2.  Up to 424.79 requests satisfied per second.

Basic PHP – Reading 1
Concurrency Level:      5
Time taken for tests:   2.609 seconds
Complete requests:     1000
Failed requests:        0
Write errors:           0
Total transferred:      267000 bytes
HTML transferred:       81000 bytes
Requests per second:  383.23 [#/sec] (mean)
Time per request:       13.047 [ms] (mean)
Time per request:       2.609 [ms] (mean, across all concurrent requests)
Transfer rate:          99.93 [Kbytes/sec] received

Basic PHP – Reading 2
Concurrency Level:      5
Time taken for tests:   2.609 seconds
Complete requests:     1000
Failed requests:        0
Write errors:           0
Total transferred:      267000 bytes
HTML transferred:       81000 bytes
Requests per second:  383.23 [#/sec] (mean)
Time per request:       13.047 [ms] (mean)
Time per request:       2.609 [ms] (mean, across all concurrent requests)
Transfer rate:          99.93 [Kbytes/sec] received

Basic PHP – Reading 3
Concurrency Level: 5
Time taken for tests: 2.625 seconds
Complete requests: 1000
Failed requests:        0
Write errors:           0
Total transferred:      267000 bytes
HTML transferred:       81000 bytes
Requests per second:    380.95 [#/sec] (mean)
Time per request:       13.125 [ms] (mean)
Time per request:       2.625 [ms] (mean, across all concurrent requests)
Transfer rate:          99.33 [Kbytes/sec] received

Observations:
1. There seems to be a 100 request (roughly) drop when supporting PHP.
2. Requests per second satisfied =  382.47 (a drop of 42.32 requests or 9% drop)
3. Time per request = 13.073 or 0.0130 seconds per request (Increase of 11%)

Out of the box ZF 1.8.4 – Reading 1
Concurrency Level:      5
Time taken for tests:   68.297 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      197000 bytes
HTML transferred:       11000 bytes
Requests per second:    14.64 [#/sec] (mean)
Time per request:       341.484 [ms] (mean)
Time per request:       68.297 [ms] (mean, across a
Transfer rate:          2.82 [Kbytes/sec] received

Out of the box ZF 1.8.4 – Reading 2
Concurrency Level:      5
Time taken for tests:   70.281 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      197000 bytes
HTML transferred:       11000 bytes
Requests per second:    14.23 [#/sec] (mean)
Time per request:       351.406 [ms] (mean)
Time per request:       70.281 [ms] (mean, across all c
Transfer rate:          2.74 [Kbytes/sec] received

Out of the box ZF 1.8.4 – Reading 3
Concurrency Level:      5
Time taken for tests:   69.656 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Total transferred:      197000 bytes
HTML transferred:       11000 bytes
Requests per second:    14.36 [#/sec] (mean)
Time per request:       348.281 [ms] (mean)
Time per request:       69.656 [ms] (mean, across all c
Transfer rate:          2.76 [Kbytes/sec] received

Observations:
Framework not only has a slower response time but also satisfies less requests per second. Am I doing something wrong???? This cant be correct.

1. Request per second = 15.24 a change of 367.23 requests per second or a drop of 96% between trivial PHP and a ZF power app.
2. Time per request (time taken to satisfy 1 request) = 328.49 ms or 0.328 seconds a change of .315 seconds or an increase of 23%

Conclusion
Even though my benchmarking techniques might be flawed, taking a base line reading with no HTML as well as a very simple PHP script web project allowed me to at least compare. 

Based on these figures (if correct) Zend Framework has a HUGE overheard.  But this should not discourage any would be ZF coder because there are caching techniques which were not used such as using APC and the benefits of a good network admin  

Also the benefits of using any framework far outweigh the drawbacks in my personal opinion.  Where else can you get code which has been tested by the best and packed to contain methods for many of our typical coding requests.

Armando Padilla.

Step one Installing PHP (if you havent yet)
If you have PHP already installed skip this section and head over to “An overview of the installation”.  Eeryone else, head over to the PHP site,  php.net and download the latest and greatest. As of this writing the latest Windows installer is php-5.2.9-2 msi.  Download the executable.  Yea so what I use executable and you should too its easier to install and configure on Windows.
Once the file downloads, double click the installer, click “next” a few times, and stop when you reach the “Choose Items to Install”.

Choose Items to Install
Once you reach this point your going to check off which extensions you want installed.  By default the installer has a few modules turned off but you can easily turn them on by checking off the items to install.  Make sure that the “CLI Executable” has no red x marks next to it as shown in the neat picture to the left.   If it does click on the “X” and select,  “Will be installed on local hard drive”.  By doing this your going to installed the php.exe file as well as allow the executable to automatically update and create System Variables. Click “Next”, then “Install” and watch it go.

An overview of the Installation and Required System Variables
When the installation is done you should have a new directory, C:\Program Files\PHP (if you didnt change the default location).  This contains the php.exe file along with a number of other things.   You should also have some updates to your environment variables.  Open the Environment Variables window by right clicking on “My Computer” , “Properties”,  “Advanced”, “Environment Variables” .  At the bottom of the window you should have 2 System Variables, “Path” and “PHPRC”.  Make sure “Path” contains the “C:\Program Files\PHP\;”  (Replace with the location of your PHP directory) and make sure PHPRC contains, “C:\Program Files\PHP\” (Location to your php.ini file) .    If all the variables are set click “Ok” and head onto the next section.

Verifying Installation.
Now to check that the installation went smoothly.  Open a command line window.  You do this by going to “Start”, “Run”, and then typing in “cmd”, then click “Ok”.  Once the command line window appears type in:  php –version

You should see:

If you do great!  Your done with PHP. Let’s install Zend Framework now.

Installing Zend_Tool
If all went well,  now its time to install Zend_Tool. Download the latest Zend Framework (latest is 1.8.1)  and extract the files somewhere onto your system.   Move the files

• bin/zf.php
• bin/zf.bat

into the directory C:\Program Files\PHP and place all the content of the library folder into the C:\zf directory.  Many tutorials recommend installing the library in your PHP includes directory but I decided to install it under C:\zf to demonstrate how to use ZEND_TOOL_INCLUDE_PATH environment variable since the library can practically live anywhere when your developing sites.    The full path to your Zend Framework instillation is now, C:\zf\library\Zend.

Setting up ZEND_TOOL_INCLUDE_PATH
Open the Environment Variable window again and create a new environment variables under the “System Variables”  section.   In the “Variable Name”  text field enter, “ZEND_TOOL_INCLUDE_PATH”  and in the “Variable Value” text field enter “C:\Program Files\PHP\includes\library\”  (path to the Zend Library minus the Zend portion).   Click ok to close out the “New System Variable” window and then click “ok” once again to close the “Environment Variable” wndow.  Time to check if Zend_Tool works.

Verify Installation
If you have any command line windows open, close them and then reopen one.   Type in zf show version you should see the below:

Useful commands.
Your set to create your projects , controller, actions now. Below I added a few commands I tend to use.

Create Project
zf create project helloworld

Create a new controller (below commands must be issued within project directory)
zf create controller controller1
zf create controller controller2

Create a few actions
zf create action action1 controller1
zf create action action2 controller2

Thats it!
Armando Padilla

1. Zend_Tool
2. Zend_Tag
3. The Cloud computing components

For more information heres the complete list of features released.  I also had a questions for the Zend folks regarding Zend Tool on the page.

Coming up I plan to take a stab at Zend_Tool_Framework_Provider and create a simple example on how use and implement.

Armando Padilla

The .htaccess file will send all incoming traffic to your Front Controller which handles routing and dispatching etc.

Removing .htaccess from the process.
For this im going use Apache 2.2. Start off by opening up the httpd.conf file located in the the conf folder of your Apache installation. Somewhere near the bottom add the following lines.

#Application Specific Include file
Include conf/extra/httpd-zf.conf

This will allow Apache to add addition configuration settings once Apache is restarted and its a great place to isolate application specific Apache settings.

Now, go ahead an create the include file, “httpd-zf.conf” inside the APACHE_HOME/conf/extra/ directory and place the ReWrite rules which were originally in your .htaccess file into
it.  Hit save, remove the .htaccess file, and restart Apache.  You should see your Zend Framework application running.

Why do this?
Speed. Your application must always read the .htaccess file when someone visits the site. Removing this extra layer and placing it into the Web Server itself will reduce the amount of time a page loads.

Hope that helps someone out there

With the release I started to dig into my current projects and started to update my forms.  Adding widgets here and there.   In the process I learned  thing or two and just wanted to share.

Outline
What are we going to cover?

• All required Files and packages.
• Installation of these files and packages
• Examples – Dialog, DatePicker Widgets as well as their API.
• Links to helpful readings

Required Files
If you havent download the latest release, 1.7.3, do so now (click her).  Once your done downloading unzip the filea nd open the directory extras/library.  This is the directory which contains  the ZendX folder.

The latest Zend Framework release comes with an additional library, ZendX. These are extensions which are not part of the Core of the framework.  Currently the library contains 2 componenets;  the JQuery and the Console components.

Copy the ZendX folder into the folder which contains your current installation of the Zend library. On my webserver the directory structure looks like this after I copy ZenX into the directory . (Yes

You now need the JQuery UI library. To take advantage of the latest and greatest your going to need the release candidate (jquery 1.6rc6), download it and unzip it.

Place the files

• themes
• ui
• external
• jquery-1.3.1.js

inside your public directory. Your final directory structure should look something similar to this:

Required Files are now installed.
Identifying ZendX_JQuery to your Zend Application
Since the ZendX_JQuery is a View_Helper extension and not part of the main library we need to register it as a plugin using the Zend_View addHelperPath() method.

Open your bootstrap file. public/index.php and copy the below script into it.

$view = new Zend_View();
$view->addHelperPath('ZendX/JQuery/View/Helper', 'ZendX_JQuery_View_Helper');
$viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer();
$viewRenderer->setView($view);
Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);

Adding the information to the bootstrap file will allow you to use the ZendX_JQuery throughout your application. From now on the only item you need to include in your View are the styleSheet to implement using the jQuery() addStylesheet()
method and the jQuery() setUriLocalPath() method in your View.

The addStylesheet method will add the stylesheet.  If your setup is identical to one shown above you can use the string  “/js/themes/base/ui.all.css”  to refernce the css file required. (ZF reference manual mentions flora css, i could not find it)

The setURiLocalPath() will add the js library to use.  Set it to “/js/ui/jquery.ui.all.js”.

Well get to see how to use these jQuery methods now.

Putting the pieces together – Examples
Were going to implement 2 quick examples which will get us started on the right foot by implementing a Date-Picker and a Dialog.

Date Picker
The first example demonstrates the use of the View Helper DatePicker.
The full method accepts 4 parameters with the third parameter accepting an array containing options shown here.

datePicker(id, default_value_to_display_in_text_field, params, attributes)

Lets take a look at our View.

jQuery()->addStylesheet(’/js/themes/base/ui.all.css’);?>

Birth Day:
datePicker(”startDate”,
‘Select Your Birth Day’,
array(’defaultDate’ => ‘+7′,
‘minDate’ => ‘+7′,
‘dateFormat’ => ‘mm-dd-yy’)); ?>

jQuery()->setUiLocalPath(”/js/ui/jquery.ui.all.js”);?>

The example shown above adds the stylesheet between the head node and places the js file at the very end of our HTML.  Placing the js at the very end of the body is critical to do.  Placing it anywhere else will  cause mixed results when executing Ajax features.

The example above also demonstrates how to format the date for the specific field using one of the parameters.   Go ahead and give it a try, you should see something like the below figure.

Dialog Boxes
A dialog box is the Web 2.0 equivalent of the alert() javascript popup. Using the dialogContainer method we can add a dialog box to our page. Below is an example of a dialog box which uses parameters.

If you tried the example in the ZF Reference manual and didn’t have this work for you. Dont worry, change ‘dialog’ to ‘dialogContainer’ and you should be able to get it working.

jQuery()->addStylesheet(’/js/themes/base/ui.all.css’);?>

dialogContainer(”dialog1″,
‘Welcome to the ZendX_JQuery World!’, array(’draggable’ => true,
‘modal’ => true,
‘resizable’ => true,
‘title’ => ‘Welcome message’,
‘closeOnEscape’ => true)); ?>

jQuery()->setUiLocalPath(”/js/ui/jquery.ui.all.js”);?>
For additional parameters available for the dialogContainer take a look at the JQuery API for the UI widget here.  Try out the View, you should see the Dialog window shown below.

Thats it. Set up is done, you know the requirements for the JQuery UI Widgets, and you created 2 widgets.  Take a look at some of the links below that helped me get started.

There are a few quarcks i havent figured out yet such as the inability to move the dialog box using FF 3 and currently playnig around with the other widgets so Ill update as I go.  Next on the docket.  Progress bar and File Uploading using Jquery extension.

Helpful Links

• ZendX_JQuery – Full Refrence Page.
  
• JQuery UI Home Page
• JQuery Widget API (used for the $param parameter for each JQuery View_Helper Widget)

What is the issue?
Well if you installed a fresh copy of PHP or if you prefer to code with <?php ?> open and close tags appose to <? ?> you might be affected. Since a fresh copy of PHP contains the PHP.ini flag short_open_tags = Off this causes some chaos and doesnt allow the Zend_Paginator::paginationControl function for example as well as $this->next $this->previous attributes to not work in a View.

The Fix
Open your php.ini file. You can check which php.ini your using by using phpinfo(); and check the Currently Loaded php.ini path. open the file up and set the short_open_tags flag to On then restart Apache.

You should see it work. TADA!

Armando Padilla – Time to get some dinner.

What’s included in the release?
Like I mentioned before i created 2 releases.  One release contains only the catalog functionality.  It allows developers to use title search, title auto complete which can be used in conjunction with AJAX to create a autocomplete search box, retrieve detailed title information, and search actors/directors.  This package is intended for developers that want to use the extensive Netflix catalog on their own web site without the added functionality found in the full version of the release.

The second release, the FULL release, contains not only the catalog functionality but also allows developers to manage user queues, manage user ratings, retrieve user reviews, and most importantly create the request access url, the URL which users NEED to click that allows their app to retrieve restricted content.  So if the developer wanted to create a Zend Framework powered app that allowed users to add, delete, and update their “Watch Queue” or “Instant Watch Queue” they can do this by calling a simple method within this package.

Where can i get the release?
I committed the releases to the Google Code site Located here, Zend Framework Netflix.  The packages are properly named so you wont have trouble distinguishing which one you need.

Whats next?
The next steps for this project is to have the Zend Framework team review some of the code, my submitted outline, and hopefully approve it.  On my end I will continue to work on the code.  There are 2 items which i need to iron out, Updating Ratings, Deleting an Item from the users Queue, and updating the code to support the SIGNITURE METHOD HMAC-SHA1.  I will place these items and other “gotchas” on the google code twiki to continue to track my progress.  I will also clean up my PHPUnit tests.

I would like to also create a small set of examples for the user to refer to, as well as a small application users can see the code in use. Again i will provide the details on the google code twiki and here as well.

I’m anxious to hear back from anyone that’s using it how i can improve on it and what they think is a better approach.

Armando Padilla

Links of interest?  Maybe?

• Zend Proposal – has examples you can use to run the code under “Use cases”.
• Zend Framework Netflix Service Google Code Twiki.
• Zend Framework Netflix Service Download Page.

For those interested in the netflix api check this page out.  It’s basically the netflix documentation. Its pretty straight-forward and should be an easy and fun read.  I was surprised they opened up their ‘predicted rating’ api. Nice touch I can see A LOT of things developers can do with just the prediction REST api.

And for those that want to check out the Zend_Service_Netflix code i currently have, here is the Google Code Project Page link.  

I plan to finish the package by Sunday evening.  Here is my attack plan.

Attack Plan:

1. Finish the concrete classes. (ETA Friday evening) 
2. Finish Up the remaining REST calls (ETA Saturday Evening)
3. Create test using PHPUnit. (ETA. as I go)
4. Documentation.  (ETA Sunday evening) 

What is the Pagination?  
A bit of an intro. What’s Pagination.  Pagination is simply a way in which developers allow users visiting a site to scroll through a long list of records be it 10 at at time, 100 at a time, or <your arbitrary number here> at a time.  Im sure you’ve seen it around the web but might not have called it by the fancy-smancy “Pagination” name.  Hell I call it, “that next and previous button thinggie”, or “that 1 2 3 4 5 page selector stuff”.  Lets continue. 

Pagination used to be an tedious but necessary task for developers.  I wont go into al the steps to create your own custom pagination code base but let me just tell you it sucked. Thank you Zend_Paginator for less stress in my life.

Zend_Paginator a public service announcement.
In its newest installment, Zend Framework 1.6, the developers at Zend added in a pagination component, Zend_Paginator.  This allowed developers like you and me to create Pagination features on the fly (it took me 1 minute to implement when i timed it)  Lets take a quick example.

<?php
require_once “Zend/Loader.php”;
Zend_Loader::loadClass(”Zend_Paginator”);

//Intialize records. This is what th user will paginate through.
$myRecords = array(”Armando Padilla”,
“Monica R.”,
“Elisa P.”,
“Francisca P.”,
“Guillermo P.”,
“Some awesome person in my family”);

//Create Paginator Object
$Paginator = Zend_Paginator::factory($myRecords);

//Set the current page were on.
$Paginator->setCurrentPageNumber($currentPage);

//Set the number of records to show per page
$Paginator->setItemCountPerPage(3);

//Save Paginator as View var.
$this->view->paginator = $Paginator;
?>

Going through the code above, we initialize our array of records which will be paginated by the user in the variable $myRecords.  I then create a Zend_Paginator object and pass in $myRecords into the factory method.  The Zend Framework then hooks everything else up for us behind the scenes and all we have to do is make sure we pass in the $currentPage the user is currently on and display the pagination links on our page.  

The Problem
So wheres the problem?  Well the problem lies in how users of the Zend_Paginator object are using it.  Many developers are using the Zend_Paginator object with database records errounously.  They hit the database, return ALL the records, store them into memory, and then allow Zend_Paginator to handle these potential HUGE record sets in the backend. Bleh  

Wrong way of doing it Example:

<?php
require_once “Zend/Loader.php”;
Zend_Loader::loadClass(”Zend_Paginator”);

//Initialize of DB object
$db = new Zend_Db::factory() //Paraphrasing here.
$statement = “SELECT * FROM Player”;
$myRecords = $db->fetchAll($statement);

//Create Paginator Object
$Paginator = Zend_Paginator::factory($myRecords);

//Set the current page were on.
$Paginator->setCurrentPageNumber($currentPage);

//Set the number of records to show per page
$Paginator->setItemCountPerPage(3);

//Save Paginator as View var.
$this->view->paginator = $Paginator; 
?>

Very inefficient.  

The Solution
We don’t have to select ALL the records in the Db but allow Zend_Paginator to select and use small manageable pieces at a time for us.  How?  If we had a table with 1000000 records we dont have to select all records but construct a Zend_Db_Select object with the appropriate criteria, and then pass that into the factory instead of the array.  Lets take a look how this is done using the same Players table.

The right way of doing it

<?php
require_once “Zend/Loader.php”;
Zend_Loader::loadClass(”Zend_Paginator”);

//Initialize of DB object
Zend_Loader::loadClass(”Zend_Db”);
$db = new Zend_Db::factory() //Paraphrasing here. 

//Create Select Object
Zend_Loader::loadClass(”Zend_Db_Select”);
$selectStatement = $db->select()->from(”Players”);

//Create Paginator Object
$Paginator = Zend_Paginator::factory($selectStatement);

//Set the current page were on.
$Paginator->setCurrentPageNumber($currentPage);

//Set the number of records to show per page
$Paginator->setItemCountPerPage(3);

//Save Paginator as View var.
$this->view->paginator = $Paginator;
?>

Thats all there is too it.  Less memory consumption because we dont have fetch ALL our records at a time and allows the Zend Framework to do the heavy lifting for us. Hope this helps a few people looking for the answer to this.

The Zend_Form component allows developers to use helpers to create forms. This is much like the form helpers for Ruby on Rails. It has a selector helper, password helper and all the form types that someone might eventually use in a form. With all these positive tools what on earth might be my grip with the Zend_Form? Easy, html/xhtml shouldn’t be handled why a backend developer. With this component we basically take a step back from keeping html/designers away from the backend and backend developers away from taking on another responsibility, creating dynamic forms.

Smarty, Savant, and the basic mvc pattern was set up to facilitate the need to keep such separations intact. HTML coders wouldn’t want to deal with PHP code, so nice looking template libraries such as Smarty and Savant were created to hide these tags from HTML. Now with the introduction of Zend_Form, this idea goes out the window. I’m not implying that Zend_Form isnt a good thing, but is it a necessary component? As developers, we have already crossed this delimma in the architect web road. The outcome? We realized that separation is best.

Could the Zend_Form library have been created to compete with Ruby on Rails?

Armando Padilla