The validation criterion was that a slider HAD to be selected: If the user wanted to indicate a zero value, the slider had to be dragged and brought back to zero.

Very soon, I realized that while the JQuery/php code worked well, it required increasing amounts of code in the controller and view to handle form validation. Also, maintaining the state across form submissions became a laborious process. Error highlighting/reporting became difficult, and all these mundane activities took up lots of space and time. Of course, the problems only grew worse with increasing number of sliders on the page.

I recently refactored my code and arrived at a much better solution: Create a custom zend form element named “slider”, and let the Zend framework handle the grunt work of state persistence and error management – things it was designed to do in the first place.

Requirements: The main requirements of the slider element are summarized below:

1. The ability to create and work with sliders in a way similar to other standard form controls (text/radio etc). For example:

$slider1 = $this->createElement('slider', 'clinical_experience');
$slider1->setLabel('How do you rate your clinical experience?');
$slider1->setRequired();
$this->addElement($slider1);

2. The setRequired() validation should be performed by the framework, and slider state should be retained between form postings.

3. It should be possible to customize left and right anchors of the sliders to reflect varying end points(default least-most).

4. It should be possible to customize the min and max values of each slider (default range from 0-100).

Now that our requirements are clearly defined, we move on to coding the form element. In order to work with the slider, we actually create a combination of a slider div AND a hidden form element. The hidden element will help us get the posted value easily and also help maintain state.

We establish a simple naming convention for associated hidden fields – give their name attribute a value of “controlname-text”

For instance the slider above named “clinical_experience” will have a hidden field named “clinical_experience-text” that holds the value of the slider selection (the numerical value of the slider is set via javascript)

The slider class extends Zend_From_Element_Xhtml. This gives our custom slider element access to all of Zend frameworks’ support for form elements. We also create setter methods for the left and right anchor and the min/max slider values. The init() method sets appropriate defaults (should the user choose not to use the setters while creating the form).

Note that the form helper element (bolded in the code below) is set to ‘SliderElement’ – This will be defined by us next. The framework takes care of passing the control name, value, attribs array and options array to the helper.

<?php
class ZF_Slider extends Zend_Form_Element_Xhtml
{
    public $helper = 'sliderElement';
    public $options = array();
    public function init()
    {
        $this->setMinValue(0);
        $this->setMaxValue(100);
        $this->setLeftAnchor('Least');
        $this->setRightAnchor('Most');
    }
    public function setLeftAnchor($left)
    {
        $this->options['left'] = $left;
    }
    public function setRightAnchor($right)
    {
        $this->options['right'] = $right;
    }
    public function setMinValue($min=0)
    {
        $this->options['min']=$min;
    }
    public function setMaxValue($max=100)
    {
        $this->options['max']=$max;
    }
    public function isValid($value, $context = null)
    {
        //We have named our hidden text field name-text.. get its value
        $field = $this->_name."-text";       
        
        $value = $context[$field];
        $this->setValue($value);
        if (($value === null) or ($value==-1))
        {
            $value=null;
        }
        return parent::isValid($value, $context);
    }

}
?>

The control name is available via $this->_name. Therefore the corresponding hidden element can be retrieved using $this->_name.”-text”

The isValid() method is overridden as shown in the code above. It gets passed a value and a context (which comprises all the posted form values). We extract the hidden field value (based on our naming convention) and assign it to the value of our control ($this->setValue()).

If the value is null or -1, we set the value to null. Finally we make a call to the parent’s isValid() method. This takes care of responding appropriately to missing/null values.

The view helper for our newly created form element is displayed below (SliderElement.php). The “Sliderelement” helper takes care of “visually” displaying our custom control. First, a set of div tags is established. The first div tag establishes the left anchor, followed by a placeholder for the slider (rendered by jquery), followed by the div for the right anchor (I use Blueprint css for positioning)

<?php
class Zend_View_Helper_SliderElement extends Zend_View_Helper_FormElement
{
    //all these input parameters are passed by the Zend_Form_Element
    public function SliderElement($name, $value=null, $attribs=null, $options=null)
    {
        $str ='<div class="box">
            <div class="span-3">' . $options['left'] . '</div>
            <div class="span-9" id="' . $name . '"></div>
            <div class="span-3">' . $options['right'] . '</div>
                <input type="hidden" value="' . $value . '" id="' .
                $name . '-text" name="' . $name . '-text"/>
            </div>';
        //$value is injected into the javascript.. passing null will result in js error!
        $value=($value == null)?-1:$value;
        $str.=$this->SliderGen($name, $value,$options['min'],$options['max']);
        return $str;
    }

    //return a javscript string that renders the slider using 
    //jquery ui..
    private function SliderGen($id, $value,$min,$max)
    {
        $str = '<script>
    $(document).ready(function(){';
        $str.="
            \$(\"#$id\").slider({
    animate: true ,
    range: \"min\",
    value: $value,
    min: $min,
    max: $max,
    slide: function(event, ui) {\$(\"#$id-text\").val(ui.value)}
    });";
        $str.= "\$(\"#$id\").css('cursor', 'pointer');";
        $str.='});
        </script>';
        return $str;
    }
}
?>

The internal (private) method SliderGen() emits javascript code to render the slider using JQuery. The “slide” function/callback populates the hidden text box with the slider selection.

Please look up the JQueryUI site if you need more information regarding the syntax for displaying the slider component on a web page.

Finally, we are ready to create our Zend form. The code is as shown below (forms/slider.php):

<?php
class Form_Slider extends Zend_Form
{
    public function init()
    {
        //tell this form where to find our slider element
        $this->addPrefixPath('ZF', 'ZF','element');
        
        $slider1 = $this->createElement('slider', 'clinical_experience');
        $slider1->setLabel('How do you rate your clinical experience?');
        $slider1->setRequired();
        $slider1->setLeftAnchor('Poor');
        $slider1->setRightAnchor('Excellent');
        $slider1->setMinValue(100);
        $slider1->setMaxValue(500);
        $this->addElement($slider1);
        
        $slider2 = $this->createElement('slider', 'teaching_experience');
        $slider2->setRequired();
        $slider2->setLabel('How do you rate your teaching experience?');
        $slider2->setLeftAnchor('Poor');
        $slider2->setRightAnchor('Excellent');
        $this->addElement($slider2);
            
        $submit = $this->createElement('submit', 'next');
        $submit->setIgnore(true);
        $submit->setLabel('Next');
        $this->addElement($submit);
    }
}
?>

The “addPrefixPath()” command is used to instruct set the actual location of our ‘slider’ component (plugin). This class is named “ZF_Slider” and is in the path /library/ZF/slider.php

We create two sliders using the “slider” component that we just created.. Set all the required values and add it to Form_Slider.

Finally, to tie it all together and generate some output, we create an indexController. It simply initiates our form class, passes it on to the view and dumps the response when the form is submitted:

<?php
class IndexController extends Zend_Controller_Action
{
    public function indexAction()
    {
       $form = new Form_Slider();
       $this->view->form = $form;
       if ($this->_request->isPost())
       {
           if ($form->isValid($_POST))
           {
               var_dump($form->getValues());
           }
       }
    }
}
?>

Since all the heavy weight lifting has been delegated to the Zend form, the view (index.phtml) is a simple one-liner:

<?php
echo $this->form;
?>

That’s it! No additional javascript coding and messing with posted values (Note that a reference to both JQuery and JQueryUI is necessary to make this function.. I setup all this in my bootstrap and render it on my layout.phtml)

This is what the rendered form looks like (note that I use blueprint css for positioning):

When the form is submitted without interacting with either of the sliders, the standard error messages (setRequired())are displayed underneath the appropriate controls.

When selections are made and the “Next” button is hit, the posted values are displayed as expected:

Note that when we initialized the “clinical_experience” slider, we had min and max set at 100 and 500 respectively. The posted value reflects that. Notice also how the state of the slider is maintained after post back.

If Apple has taught us anything, it is that the hardware and software go hand in hand towards a great user experience, and Asus definitely followed this. Out of the box, people want to surf the web, listen to music, watch movies, play games, buy apps, and read books – The transformer really excels in ALL these areas as an extremely user-friendly tablet.

If you are on the fence about buying a TF101, hopefully, this blog should help you make up your mind!

Android 3.0/Honeycomb is a glorious OS, and the Transformer has the right hardware to make everything extremely fluid and fast. Asus has also paid close attention to customizing the software for the Transformer. Oh.. and the screen on the Transformer is gorgeous! 10.1 inch, 1280*800 pixels of super-responsive real estate.

Most software that you require to be productive has already been included on the Transformer(or available as a free download). The Android market is literally littered with apps. Writing “good” software that plays well with the available hardware is hard.. So, I am extremely cautious about downloading stuff off the market. I always prefer apps that have been tried and tested.

Connecting the Transformer to a computer to transfer data is also a cinch.. Just use the USB cord shipped along with the unit. The transformer shows up as a drive (Windows 7 automatically recognizes and installs the required drivers).

Here’s what my home screen looks like – with my most commonly used apps lined up at the bottom:

Here is a list of apps that I use regularly (and I strongly recommend each one of them):

1. Browser : A version of Chrome. Very snappy and full featured (You will be prompted to download Flash on first use). There is really no reason to download another browser.

2. YouTube : Great app customized for tablets. Makes flipping through videos a joy!

3. File Manager : Folder manager app created by ASUS. I actually prefer this to the highly acclaimed “Astro” file manager.

4. Polaris Office: Included by Asus. Lets users easily read and edit various office document formats (.docx, .xlsx, .pdf etc). I prefer this to “Documents to go”. (Although this reads pdf files, the Adobe reader does a much better job of rendering pages)

5. Amazon Kindle: Enough said!

6. 2X Client : This is a free remote desktop client. 2X actually designs and develops load balancing servers (which we use for our terminal services at work).. So, I have absolutely no qualms in recommending their RDP client. Works flawlessly with minimal resources.

7. Repligo PDF Reader: The most feature rich PDF reader available for android (The feature that I absolutely love about Repligo is that it remembers the last page read. The Day/Night mode is also very helpful). The official PDF reader by Adobe is not yet there in terms of required features.. but is a close 2nd choice.

8. MX Video Player : An awesome media player for Android.. It uses custom codecs to take advantage of processor specific features(H/W acceleration). It allows me to play a wide variety of video files on my android (The full-featured free version displays ads only when you pause.. not at all obtrusive).

9. Due Today : A full featured task management/reminder system with a very good UI. It also syncs with ToodleDo when online.. so you have your tasks securely backed up. There is another highly acclaimed app named “Beautiful Notes” that competes in the same category. I personally chose “Due Today” because 1. it is more structured and captures data in numerous fields 2. It is much more light weight (500KB) vs Beautiful Notes (8.5 MB)

10. Windows 8 Notepad: A very functional notepad replacement. I love its clean and minimalistic design. Available for free from the Android market.

Configuring the Keyboard (Setting->Language & input)

The ASUS keyboard is vastly superior to the stock android keyboard.. But it can be further enhanced using the configuration options available:

I checked ALL available options on mine.. Note that the Swype style functionality is built into the ASUS keyboard app. This is really handy and works great (not to mention the ‘cool’ factor!).

Setting up VPN (Settings->Wireless & networks)

Honeycomb also has built in support for VPN -  Click on the “VPN Settings” option:

Next, select the type of VPN (L2TP is the easiest to set up)

Enter your values for VPN Name, Server, and pre-shared key.. Yes.. its that easy!

And for those of you curious about how I did these awesome screen captures – No.. it is not an app! The feature is built right into the Honeycomb OS (Settings->Screen->Screenshot). This takes a screenshot if you keep the “Recent apps” key pressed for about 3 seconds (this is the icon next to the “Home” icon at the bottom of the screen. The pictures are saved in the “Screenshot” folder of your main SD card  (you can get there using the File Manager app)

Regression analysis is one of the core tools of statistics that helps investigate relationships between variables. If there is only a single explanatory variable, it is termed “Simple Regression” (It is often difficult to come across such situations in real life). Computing a simple regression involves fitting a straight line through the scatter graph obtained from the sample. From coordinate geometry basics, recall that a straight line has the equation:

y=c + mx

where m = slope of the line, and c is the y intercept.

There can of course be many straight lines through a scatter plot.. Regression analysis picks ONE line in particular – The criteria used is to minimize the sum of squares of the errors (distance from the points in the scatter plot to the line constructed).

If there is more than one variable on which the prediction depends, it is called “Multiple Regression” – It accounts for multiple additional factors (separately) so that the effect of each (independent) variable on the dependent variable can be assessed.

The equation for a (linear) multiple regression can be expressed as:

y = a+bx1+cx2+…

Mathematically, it is identical to “Simple Regression”. For example, in solving a 2 parameter regression, we need 3 dimensions – so, instead of estimating a straight line, we select a single “plane” – again such that the sum of squares of errors is minimum.

We can in fact, extrapolate this to an arbitrarily large number of independent variables. Fortunately, Computers have no problems crunching the numbers using matrix algebra to solve numerous simultaneous equations to arrive at the results.

Using Matrix Algebra to Solve Multiple Regression:

Let X be the data matrix of the predictor (independent) variables.
Let Y be the data vector representing the criterion (dependent) variable.
and, Let ‘b’ be the data vector representing the regression coefficients.

The formula for computing b (coefficient matrix) using Matrix algebra is given by the following formula:

b = (X’X)^-1X’Y

The proof of this equation is quite simple:

1. The simplified equation for a (simple) linear regression in matrix terms is Y=Xb+e
2. Assume that the average error (e) will equal 0. The equation becomes Y=Xb and we need to find the value of ‘b’
3. Multiply both sides of the equation by X’ (transpose of X) : X’Y = X’Xb
4. We are trying to get rid of X’X on the RHS.. so multiply both sides of the equation with (X’X)^-1 – the inverse of X’X:
   (X’X)^-1X’Y = (X’X)^-1(X’X)b
5. Any matrix multiplied by its inverse is the identity matrix I:
   (X’X)^-1X’Y = Ib
6. Ib = b = (X’X)^-1X’Y

[Note: the above equation contains the Moore-Penrose pseudoinverse matrix which ensures that inverses take place on SQUARE matrices. A ^pseudo-1=(A'A)^-1 *A'

To solve equation Y = Xb, a naive approach would be to multiply both sides by X^-1 and immediately simplify the resulting equation like so:

X^-1Y = X^-1Xb, and thus
X^-1Y = b (because X^-1X =I)

However, recall that matrix inverses are only defined on Square matrices. We cannot guarantee that the matrix of independent variables will be a square matrix..in fact, it never is! the sample size needs to be reasonable to ensure correct results. The use of a pseudoinverse matrix solves this problem nicely.]

Example:

A typical workflow involving regression analysis goes like this:

1. Formulate a hypothesis about the relationship between variables of interest
2. Gather data from a representative sample
3. Compute regression parameters and prove (or disprove) the hypothesis

A common example of multiple regression analysis is in college Student Admissions. The admissions committee bases its decision on numerous factors that it believes will influence the students GPA.

For example, a college could hypothesize that the GPA that will be attained by the admitted student is dependent on his/her High school GPA, SAT score (V+Q) and Letters of recommendation (The strength of recommendation letters will of course need to be quantified)

A sample of students currently attending the college is then surveyed for their current college GPA, high school GPA, SAT scores and Recommendation letter strength.

The predictor equation for college GPA (dependent variable) is :

Y = a+b1X1+b2X2+b3X3

where Y = Predicted GPA
{b1, b2, b3} = Regression coefficients
a = Intercept
X1 = HS GPA, X2 = SAT Score and X3 = Strength of Recommendation letters

So, once the coefficients and intercept are determined, it is quite easy to plug in values for X1, X2, X3 and “predict” the future GPA of a student.

Implementation in PHP:

Although there are numerical statistical packages that can easily compute regression parameters, they are all geared towards “offline” computation. That is, data is collected first, and then the numbers are aggregated and crunched to arrive at the result. I was interested in using regression in an online survey – i.e., display the relevant regression parameters at the end of an online survey. I decided to write my own PHP library for this purpose (complete source code is attached at the end of this blog).

Each observation can be written as an algebraic equation as follows:

Our goal then, is to solve these simultaneous equations to find the value of b0..bk. For explanatory purposes, consider a simple linear regression (one independent variable). In matrix terms, the solution to this equation looks like:

We can then solve for {b0,b1}… Note how the X matrix needs to be filled with 1’s in the first column. The exact same approach works for multiple regression too – We just use larger matrices!

‘n’ is the sample size (number of observations)

The various formulae used/computed by the regression class are:

The heart of the library is the Lib_Matrix class. It handles all required matrix manipulation operations. A fluent interface has been provided where possible to make code more intuitive and readable. The Regression computation is performed in the “Lib_Regression” class. I have also attached the complete Unit test suite (100% code coverage) to help you better understand the API. The attached ZIP file contains the following files:

Click here to download the Regression library.

References:

http://marketing.byu.edu/htmlpages/books/pcmds/REGRESS.html
http://davidmlane.com/hyperstat/prediction.html
http://luna.cas.usf.edu/~mbrannic/files/regression/regma.htm
http://home.ubalt.edu/ntsbarsh/Business-stat/otherapplets/pvalues.htm#rtdist

1. Completely bypass the framework

The easiest solution is to move such content into a subfolder in the “public” directory. The default .htaccess file already setup to serve any physical file that is web-accessible. For example, http://localhost/ZFApp/public/static/myfile.html would display myfile.html contained in the “static” subfolder.

Advantage: minimum overhead imposed by the framework

Disadvantage: You lose out on all the great features provided by the framework such as Caching, Layouts, Error Handling and Security – This approach is therefore not recommended and is reserved for the simplest of apps.

2. Create a “custom route” specifically to handle static pages:

Add the following route definitions to your application.ini

resources.router.routes.staticpage.route = /statics/:filename
resources.router.routes.staticpage.defaults.controller =
staticcontent
resources.router.routes.staticpage.defaults.action = display

This staticpage custom route defined above will take a url of the form “/statics/about”, store “about” as a parameter named “filename”, open a controller named “staticcontentController” and execute an action named “displayAction” in it. The displayAction can then render the file about.phtml (stored in views/scripts/staticcontent)like so:

class StaticcontentController extends Zend_Controller_Action
{
// action to handle ALL static pages
public function displayAction()
{
$page = $this->getRequest()->getParam('filename');
$this->render($page);
}
}

3. Empty action stubs : The ViewRenderer (builtin) helper automatically renders foo/foo.phtml after executing “fooAction”. So just creating empty action blocks, and copying the static content into the desired .phtml file would accomplish what we want. On the downside, your code may get  peppered with empty actions over time (not that there is anything inherently wrong with this.. I resort to doing this for the occasional static file).

4. Overload the php magic function “__call” to intercept calls to non-extant actions and render them. This technique allows you to totally omit defining empty action stubs and relies on the php magic method to hande them.

class StaticcontentController extends Zend_Controller_Action 
{
public function __call($method, $args) 
{
if ('Action' == substr($method, -6)) 
{
$action = $this->getRequest()->getActionName();
return $this->render($actionName);
}
}
}

Now, your controllers (with lots of statics) should extend StaticcontentController (instead of Zend_Controlller_Action). When the framework tries to invoke aboutAction, it will fail to find the method, get trapped by the __call method and then render the about.phtml page.

Unzip to a folder on your computer (say d:\memcached)

Open an ADMINISTRATOR command window, and navigate to the memcached folder:

Typing “memcached –h” will display all the available options

1. Install memcached service on your system by typing

memcached.exe –d install

2. Tell memcached to start

memcached.exe –d start

You are done.. When you view your taskmanager, you will notice memcached service running:

This service is setup to autostart with windows so you will not need to repeat the above.

Now, if you want to access/use memcached via php (or Zend Framework), you need to install  php_memcache extension.

php_memcache.dll comes bundled in a zip file available here (Many thanks to Anindya for making this available). Extract and save the dll file in your php ext directory.

Edit your php.ini and add this line:

extension=php_memcache.dll

Restart Apache.. Navigate to your phpinfo and you should see a section for memcache.

Get the precompiled TS dll from here (In the comments posted on this page, you will find a link to php_apc.dll without memprotect). Save it in your php “ext” directory.

Add the following line to your php.ini file :

extension=php_apc.dll

Restart apache web server..browse your phpinfo page, and it should have a section for APC – The defaults work fine for a test server setup.

Next, setup the admin page – this will help you view/clear your variable cache(s):

• Download apc.php from here
• Save it in your webfolder as apc.php
• Edit apc.php. Change the admin password (from the default ‘password’ to any string of your liking):

defaults(‘ADMIN_USERNAME’,'apc’);             // Admin Username
defaults(‘ADMIN_PASSWORD’,'pAssW0rd’);      // Admin Password – CHANGE THIS TO ENABLE!!!

• Navigate to http://localhost/apc.php and you should see a nicely formatted page displaying the status of your cache.

Credit where it is due: The code has been inspired by a chapter from the book “Zend Framework in Action” by Rob Allen. Although coding a Lucene search solution that “works” is quite trivial to accomplish with the Zend_Search_Lucene API, this book/chapter looks at a “well-engineered” solution using the Observer design pattern that scales beautifully.

Note:

1. The PHP implementation of Lucene is slower than its pure Java counterpart. This is especially true when the size of data to be indexed increases. (Understandably so – PHP, an interpreted language, comes no where close to java in runtime efficiency)
2. The max size of a Lucene index on a 32 bit OS is 2GB. On a 64 bit server OS, there is no limit.
3. The binary index structure created by PHP and Java are identical and can be used interchangeably
4. The next step in scaling your search solution would be migrating to SOLR. SOLR is a pure java server-side indexing engine (built on Lucene) which does not have any of the bottlenecks of Lucene. It is truly enterprise-ready with the ability to scale to multiple servers, and index millions of documents. It runs in a Tomcat container and provides a web service which can be easily queried by PHP. So, once you migrate to SOLR, your search query will be submitted to SOLR via a web service call which in turn returns formatted HTML. The SOLR API provides similar mechanisms to add/modify/delete from your index.

The following framework is built on the Zend Framework and helps us to ‘instantaneously’ index fresh content so that it is available for search. This is a core requirement for dynamic websites (like facebook and twitter).

We will be building a search solution for a web app for the infamous ‘bugs’ database – although the example is quite contrived, you will see that the solution can easily be extended to any model type.

Our simple model has the following (self explanatory) fields: bug_id, bug_description, reported_by. In order to search, we must first have an “index” of terms in place. The index comprises one or more “documents” that are in turn made up of “field” objects. We will add to the index when new books are “inserted” into the system (to get reacquainted with the basics of Zend_Search_Lucene, please refer to my earlier blog).

The following describes the lucene field types that will be used in our index:

The code for creating an index is the same irrespective of the data model:

//open the index directory
$index = Zend_Search_Lucene::open(APPLICATION_PATH . "\searchindex");
//declare the search document structure
$doc = new Zend_Search_Lucene_Document(field1, field2, field3…);
//insert the document into the index
$index->addDocument($doc);

To a mind attuned to design patterns, hints of the “observer” pattern begin to emerge. The data/model rows in our case are the “subjects” and the SearchIndexer class is the “observer”. The SearchIndexer class registers with models to be notified of any updates – conveniently for us, the Zend_Db_Table_Row_Abstract class triggers  _postInsert(), _postUpdate() and _postDelete() function/events AFTER insert, update and delete respectively on the data model. This design pattern can be effectively used to decouple the model from the search.

Advantages of a “lightly coupled” search solution:

1. It is scalable. It can grow easily with our application and not require major work to make additions searchable
2. We could swap out our search solution tomorrow with another without impacting any other business logic code (you know this is coming!)

We create the interfaces required to implement the observer design pattern in our code (an in-depth treatment of the actual design pattern is beyond the scope of this article. If you are new to design patterns, Head First Design Patterns is an exceptional read):

We start off by creating the cornerstones of the Observer design pattern namely the Observer and Subject interfaces as shown below. The “Subject” raises the event and the “Observer” responds to it. In our case, the subject is the model row (that is inserted, updated or deleted) and the observer is the SearchIndexer that modifies the Lucene index files accordingly.

<?php
interface ZF_ISubject {
public static function  Register(ZF_IObserver $o);
public function Notify($flag);
}
?>

<?php
interface ZF_IObserver {
public function update($flag, $row);
}
?>

Looking at the target Use Cases will give you a high-level view of what we are aiming for:

1. Registering the Observer

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
public function _initSearchListeners()
{
	$search = new ZF_SearchIndexer(APPLICATION_PATH . '/index');
	ZF_SearchableRow::Register($search);
	Zend_Registry::set('search', $search);
}
}

The SearchIndexer object registers itself with SearchableRow using the static “Register” function. This is typically done in the Bootstrap process.

//retrieve search indexer from Zend Registry
$search = Zend_Registry::get('search');
//Use a plain old object to create a bug
$data = new Model_Bugs();
$data->bug_id=1;
$data->bug_description = "Button click does not work!";
$obj->update($data);    //this automatically indexes the data!
//search for the data in the index
$index = Zend_Search_Lucene::open($search->getIndexDirectory());
$hits = $index->find('Button');
Zend_Debug::dump($hits);

//retrieve search indexer from registry
$search = Zend_Registry::get('search');
//loop through all our model rows and index!
$obj = new Model_BugsDAL();
$rows = $obj->fetchAll();
foreach ($rows as $row)
{
$search->update('insert', $obj->getRow($row));
}

See how easy it is to extend the indexing to the whole site (and possibly all models) once we have the search infrastructure setup ?

The ZF_SearchableRow class is defined below. As you may notice from its definition, it extends the Zend_Db_Table_Row_Abstract class and implements the ISubject interface. Additionally, this class is defined as abstract (no instances can be created) further, it defines two abstract methods – ModelType() and getSearchFields() that its concrete class must implement.

The $_observers[] array, and the Register function are marked as static (so that they can be accessed from the bootstrapper without the need to instantiate an object). The _postInsert(), _postUpdate() and _postDelete() events are caught and the notify() function is triggered with the type of event and the entire row ($this) as parameter.

<?php
abstract class ZF_SearchableRow extends Zend_Db_Table_Row_Abstract implements ZF_ISubject
{
protected static $_observers = array();
//all classes that inherit this must provide implementation for
//the following:
//Return the name of the model.
abstract public function ModelType();
//Return the index fields. This is best known to the individual models.
abstract public function getSearchFields();

public static function Register(ZF_IObserver $o)
{
self::$_observers[] = $o;
}
public function Notify($flag)
{
foreach (self::$_observers as $observer)
{
$observer->update($flag, $this);
}
}
protected function  _postInsert()
{
$this->Notify("insert");
parent::_postInsert();
}
protected function  _postUpdate()
{
$this->Notify("update");
parent::_postUpdate();
}
protected function  _postDelete()
{
$this->Notify('delete');
parent::_postDelete();
}
}
?>

We next implement the model classes. I wont go into too much detail – I follow the Zend framework recommended documentation for creating models (If you are new to this, please also take time to view this informative presentation on data models by Matthew Weier O’Phinney: http://mtadata.s3.amazonaws.com/webcasts/20090724-playdoh.wmv)

We create three classes for the Bugs model layer

• Bugs: business logic
• BugsDAL: Data abstraction layer
• BugsDB: data source model; in our example we extend Zend_Db_Table_Abstract. Additionally, we create BugsRow.php that extends ZF_SearchableRow above (and set the _rowClass variable in BugsDB to refer to this class)

<?php
/*
* override the __get and __set magic methods to provide base functionality for models.
*/
class ZF_BaseGetSet
{
protected $_data=array();
/**
*Automatically invoked when a non existant property is read
* @param <type> $name
*/
public function __get($name)
{
if (array_key_exists($name, $this->_data))
return $this->_data[$name];
}
/**
*Automatically invoked when a non existant property is written
* @param <type> $name
* @param <type> $value
*/
public function  __set($name, $value)
{
$this->_data[$name]=$value;
}
}
?>

<?php
class Model_Bugs extends ZF_BaseGetSet
{
//this model now has default getter and setter
//inherited from ZF_BaseGetSet
}
?>

<?php
class Model_BugsDB extends Zend_Db_Table_Abstract
{
protected $_name="zfbugs";
protected $_rowClass = "Model_BugsRow";
}
?>

<?php
class Model_BugsRow extends ZF_SearchableRow
{
public function getSearchFields()
{
$fields=array();
$fields['class']=$this->ModelType();
$fields['key']=$this->bug_id;
$fields['description']=$this->bug_description;
$fields['reportedBy']=$this->reported_by;
return $fields;
}
/**
*Each model row exposes what type it is.. This helps make our search
* more generic.
* @return <type>
*/
public function ModelType()
{
return "Bugs";
}
}
?>

So far, we have handled the models and “Subjects”. Let us now move on to implementing the SearchIndexer class (the observer)

<?php
class ZF_SearchIndexer implements ZF_IObserver
{
protected $_indexDirectory;
public function __construct($indexDirectory)
{
$this->_indexDirectory = $indexDirectory;
try
{
$index = Zend_Search_Lucene::open($this->_indexDirectory);
} catch (Exception $e)
{
$index = Zend_Search_Lucene::create($this->_indexDirectory);
}
}
public function setIndexDirectory($directory)
{
$this->_indexDirectory = $directory;
}
public function getIndexDirectory()
{
return $this->_indexDirectory;
}
protected function getDocument($row)
{
//use factory design pattern to figure out the
//appropriate zend lucene document type and field structure
$doc = ZF_SearchIndexFactory::getDocument($row);
return $doc;
}
//this is the function invoked by the subject (Observer pattern)
public function update($flag, $row)
{
$doc = $this->getDocument($row);
$this->_modifyIndex($flag, $doc);
}
protected function _modifyIndex($flag, Zend_Search_Lucene_Document $doc)
{
$docRef = $doc->docRef;
$index = Zend_Search_Lucene::open($this->_indexDirectory);
if ($flag != 'insert')
{
$term = new Zend_Search_Lucene_Index_Term($docRef, 'docRef');
$query = new Zend_Search_Lucene_Search_Query_Term($term);
$hits = $index->find($query);
if (count($hits) > 0)
{
foreach ($hits as $hit)
{
$index->delete($hit->id);
}
}
}
if ($flag != "delete")
{
$index->addDocument($doc);
$index->optimize();
}
}
}
?>

The constructor checks if the index is present in the directory.. if not, it goes ahead and creates a new index.

Notice how the the above class handles “updates” (_modifyIndex() method) – The index is first searched for the ‘docRef’ –this is guaranteed to be unique in the index : If found, the document is first deleted (Unfortunately, this is the only way to handle updates in Lucene).

The “Factory” design pattern is used to create Zend_Search_Lucene_Document instances confirming to particular models:

<?php
class ZF_SearchIndexFactory
{
//returns a lucene document for indexing
public static function getDocument($row)
{
//return a Zend_Lucene_Document corresponding to the
//model passed in as parameter.
if ($row->modelType() == 'Bugs')
{
$fields = $row->getSearchFields();
$doc = new ZF_BugsLuceneDocument($fields['class'], $fields['key'],
$fields['description'], $fields['reportedBy']);
}
//if you have more types, add them here...
return $doc;
}
}
?>

And, finally here is the ZF_BugsLuceneDocument that simply extends Zend_Search_Lucene_Document and adds the fields that are passed to its constructor. The ‘docRef’ field is created as a concatenation of the class and key fields.

<?php
class ZF_BugsLuceneDocument extends Zend_Search_Lucene_Document
{

public function __construct($class, $key, $description, $reportedBy)
{
$this->addField(Zend_Search_Lucene_Field::Keyword(
'docRef', "$class:$key"));
$this->addField(Zend_Search_Lucene_Field::UnIndexed(
'class', $class));
$this->addField(Zend_Search_Lucene_Field::UnIndexed(
'key', $key));
$this->addField(Zend_Search_Lucene_Field::text(
'description', $description));
$this->addField(Zend_Search_Lucene_Field::Keyword(
'reportedBy', $reportedBy));
}
}
?>

Down the line, if we need ‘Blogs’ to be indexed, we create the appropriate models (inheriting and implementing the required classes), make sure that its ModelType returns “Blogs” , and its getSearchFields() returns an array containing appropriate fields to be indexed from the Blogs model, and finally tweak the ZF_SearchIndexFactory to return instances of ZF_BlogsLuceneDocument – See how elegant the code is?

PHPUnit is distributed via PEAR repositories. While installing the PEAR repository is a cinch on Linux, I am honestly surprised about how convoluted it is on a WAMP setup (actually, it is the lack of accurate documentation that is troubling. I tried the process some time ago and faced a similar problem. At the time, I wrote a blog about setting up PHPUnit manually).

So, here is my attempt at detailing the (fully working!) PEAR and PHPUnit install process step-by-step with all the gory details:

1. Right click on the following link: http://pear.php.net/go-pear.phar and save as go-pear.phar in your wamp/bin/php directory (C:\wamp\bin\php\php5.3.4 in my case)

(Note that there are many online resources pointing to download http://pear.php.net/go-pear, save the file as go-pear.php, and then execute it using php. However, that approach did not work for me)

2. Open an ADMIN command window, navigate to the folder where go-pear.phar was downloaded and type in

php go-pear.phar

3. You will be prompted for install locations.. Accept ALL defaults, and proceed with the setup:

4. When the install is complete, the pear installer creates a registry file to help us set the correct paths:

5. The PEAR_ENV.reg file is generated as shown in the explorer window below.. Double click to launch and update your registry (it merely sets up path variables and global constants so that the pear files are accessible from the command line)

6. Now, you should have PEAR installed on your computer. The next step is to register the channels that we require to download PHPUnit. Three repositories are required. Run the following commands in sequence:

(Make sure you have both openssl and curl support in your php installation. You may need to uncomment the corresponding .dll load commands in your php.ini… Remember the CLI’s php.ini NOT your apache’s)

C:\wamp\bin\php\php5.3.4>pear channel-discover pear.phpunit.de

C:\wamp\bin\php\php5.3.4>pear channel-discover pear.symfony-project.com

C:\wamp\bin\php\php5.3.4>pear channel-discover components.ez.no

7. Now that we have all sources established, issue the command to install the phpunit files. The ‘- – alldeps’ parameter is REQUIRED to install the command line tools for PHPUnit

pear install – -alldeps phpunit/PHPUnit

(NOTE: If you are copying and pasting the above line into your command window, the “alldeps” keyword is preceeded by TWO HYPHENS.. For some reason, wordpress is creating a weird character there)

You should now have all the required components for phpUnit to function normally. Happy testing!

Advantages of Recaptcha:

• Endorsed (and owned) by Google.
• It is a webservice.. No more expensive GDI operations performed on your webserver. The captcha generation is done on google servers and delivered to your webpage as Html.
• Provides Accessibility support.
• Has a lot of “fuzzy” logic going on.. Notice that you don’t have to type the “recaptcha” word verbatim. Missing an illegible word will not invalidate your response. Captcha generated by you will not be so forgiving.
• Why reinvent the wheel?

The first step towards getting started is to go on the Recaptcha website and create a key pair (You need a google account to log in).

I prefer creating a “global key”.. The keys can then be used on any website (and you can type in any domain in the provided space as shown below:

Click on the “Create Key” button at the bottom of the page. You will be presented with a public key and private key. You will require these when you make your webservice calls.

Ok.. onto our form class:

class Form_Recaptcha extends Zend_Form
{
    public function init()
    {
        $recaptcha = new Zend_Service_ReCaptcha("sdfgdsfgdfgzGsA5WwGrLW4dq",
                        "sdfgdfgsdfgsdfgsdfgfdfDT8lumPZ");
        $captcha = $this->createElement('Captcha', 'ReCaptcha',
                array('captcha'=>array('captcha'=>'ReCaptcha',
                                        'service'=>$recaptcha)));

        $captcha->setLabel('Enter CAPTCHA');
        $this->addElement($captcha);

        $submit = $this->createElement('submit', 'submit');
        $submit->setLabel('Submit');
        $this->addElement($submit);
    }
}

(Note that I have mangled my keys.. so please do not attempt to use the values in the code above!)

First, a Zend_Service_Recaptcha instance is created with our public and private key as parameters. This is passed in as an option to the “createElement” call.

One caveat though is that you MUST provide the options array when you create the captcha element.

For example, creating the captcha element like so:

$captcha = $this->createElement('Captcha', 'ReCaptcha');
$captcha->setOptions(
               array('captcha'=>array('captcha'=>'ReCaptcha',
                                      'service'=>$recaptcha)));

Although Syntactically and Semantically correct, will result in the following error message:

Message: Invalid validator provided to addValidator; must be string or Zend_Validate_Interface

The indexcontroller code that exercises the above form is shown below:

class IndexController extends Zend_Controller_Action
{
    public function indexAction()
    {
        // action body
        $form = new Form_Recaptcha();
        $this->view->form = $form;
        if ($this->_request->isPost())
        {
            if ($form->isValid($_POST))
            {
               //Checks Everything! Captcha included :-)
                echo "Valid!";

            }
        }
    }
}

As shown above, the isValid() call checks all form elements including the recaptcha. Could not be simpler!

1. Files are backed up
2. Files are easily accessible from any computer in my network

“Sync” and “Backup” are two commonly used (or misused) terms to describe the above. Here are the important differences between the two:

• A “Backup” file is not usually human readable.. it needs to be “Restored” using the software that created the backup
• Sync is 2-Way while Backup is 1-Way (although, depending on the software employed, you could set “master-slave” rules that mimic a backup plan)
• While both Sync and Backup are incremental in nature, Backup additionally employs some compression on your files in order to reduce storage space. Sync utilizes exactly the same space on the source and destination.

Having decided that “Sync” was the better option for me, I found that a tool named “SyncToy” from Microsoft satisfied my requirements exactly. I just love the simplicity of its user interface!  Whats more, it is FREE, works exactly as advertised,  has a small footprint (~1 MB), and works natively on 64 bit windows (As an aside, I really think Microsoft should have incorporated this into “Live Mesh” – another sync tool offered by MS that syncs with its cloud based storage).

One shortcoming (if you want to call it that), is that SyncToy does not offer “automatic or scheduled syncing”. It is however pretty trivial to set this up using the built in Task Scheduler in Windows 7 (described below).

Here’s how I setup SyncToy on my main desktop:

Note that I use the static IP address assigned to my NAS in the “Right Folder”. Please refer to my blog on how I setup my NAS for additional information.

Pay particular attention to the options presented on the next screen.. This forms the core of your sync strategy. “Echo” works nicely for my setup.. but you might want to select “Contribute” if you do not want to propagate deletes.

Repeat the process for all folders on your workstation that you want to sync to your NAS. You are done setting up the sync rules at this point. You can click on the “Preview button” to view all the files/actions.

Using Task Scheduler to schedule the sync:

Although SyncToy can be run on demand anytime, Automating the process gives you the confidence that your invaluble docs, pics etc are safely synced on a regular basis (I strongly recommend you check the logs the first couple of times just to ensure that all went well).

Click on the Start menu, then select All Programs –> Accessories > System Tools –>Task Scheduler

(Alternatively, you can simply search for “Scheduler” in the win 7 search box).

Click on “Create Basic Task”:

Enter a name for your job.. and a brief description:

Next up, the trigger event. I setup mine to sync every week. You may want to tweak this depending on your circumstance… You can get REALLY granular ..Feel free to explore the available options.

(Note that you SHOULD NOT select “When the computer starts” because it fires prior to login.. so neither your security credentials nor your LAN connection is ready at the time)

Under “Program/Script”, click on Browse button and locate the SyncToyCmd.exe – Note: Select SyncToyCmd (command line version) and NOT SyncToy(GUI). In the “Arguments” field, enter “-R” (for running all the sync folders setup).

Finish up.. and you are done with the scheduling process.

Hiding the command window:

When the scheduled process runs, it brings up a DOS command window (“taskeng.exe”) displaying the progress of the sync operation. This may not be acceptable to some. Here’s how you can suppress it:

1. Create a file named “Auto.vbs” (Ofcourse you can call it anything, I chose “Auto”) in your SyncToy folder with the following contents:

Set WshShell = CreateObject(“WScript.Shell”)
WshShell.Run Chr(34) & “C:\Program Files\SyncToy 2.1\SyncToyCmd” & Chr(34) & ” -R”, 0
Set WshShell = Nothing

2. Edit the scheduler script that was setup earlier to execute “Auto.vbs” instead of “SyncToyCmd.exe” (Remember to remove the –R switch from the arguments field as it is already included in the script)

Editing an existing scheduled operation using the task scheduler is actually a little convoluted.. You have to double click on the task.. then, select “Properties” from the right side action pane. This opens up the task for edits.

Note that once you have the basic scheduling in place, you can add any number of folders to SyncToy and it will be handled automatically during the next Sync!