CODE:

<?php
 
class ListNode
{
    /* Data to hold */
    public $data;
 
    /* Link to next node */
    public $next;
 
 
    /* Node constructor */
    function __construct($data)
    {
        $this->data = $data;
        $this->next = NULL;
    }
 
    function readNode()
    {
        return $this->data;
    }
}
 
 
class LinkList
{
    /* Link to the first node in the list */
    private $firstNode;
 
    /* Link to the last node in the list */
    private $lastNode;
 
    /* Total nodes in the list */
    private static $count;
 
 
 
    /* List constructor */
    function __construct()
    {
        $this->firstNode = NULL;
        $this->lastNode = NULL;
        self::$count = 0;
    }
 
    public function isEmpty()
    {
        return ($this->firstNode == NULL);
    }
 
    public function insertFirst($data)
    {
        $link = new ListNode($data);
        $link->next = $this->firstNode;
        $this->firstNode = &$link;
 
        /* If this is the first node inserted in the list
           then also set the lastNode pointer to it.
        */
        if($this->lastNode == NULL)
            $this->lastNode = &$link;
 
        self::$count++;
    }
 
    public function insertLast($data)
    {
        if($this->firstNode != NULL)
        {
            $link = new ListNode($data);
            $this->lastNode->next = $link;
            $link->next = NULL;
            $this->lastNode = &$link;
            self::$count++;
        }
        else
        {
            $this->insertFirst($data);
        }
    }
 
    public function deleteFirstNode()
    {
        $temp = $this->firstNode;
        $this->firstNode = $this->firstNode->next;
        if($this->firstNode != NULL)
            self::$count--;
 
        return $temp;
    }
 
    public function deleteLastNode()
    {
        if($this->firstNode != NULL)
        {
            if($this->firstNode->next == NULL)
            {
                $this->firstNode = NULL;
                self::$count--;
            }
            else
            {
                $previousNode = $this->firstNode;
                $currentNode = $this->firstNode->next;
 
                while($currentNode->next != NULL)
                {
                    $previousNode = $currentNode;
                    $currentNode = $currentNode->next;
                }
 
                $previousNode->next = NULL;
                self::$count--;
            }
        }
    }
 
    public function deleteNode($key)
    {
        $current = $this->firstNode;
        $previous = $this->firstNode;
 
        while($current->data != $key)
        {
            if($current->next == NULL)
                return NULL;
            else
            {
                $previous = $current;
                $current = $current->next;
            }
        }
 
        if($current == $this->firstNode)
            $this->firstNode = $this->firstNode->next;
        else
            $previous->next = $current->next;
 
        self::$count--;   
    }
 
    public function find($key)
    {
        $current = $this->firstNode;
        while($current->data != $key)
        {
            if($current->next == NULL)
                return NULL;
            else
                $current = $current->next;
        }
        return $current;
    }
 
    public function readNode($nodePos)
    {
        if($nodePos <= self::$count)
        {
            $current = $this->firstNode;
            $pos = 1;
            while($pos != $nodePos)
            {
                if($current->next == NULL)
                    return NULL;
                else
                    $current = $current->next;
 
                $pos++;
            }
            return $current->data;
        }
        else
            return NULL;
    }
 
    public function totalNodes()
    {
        return self::$count;
    }
 
    public function readList()
    {
        $listData = array();
        $current = $this->firstNode;
 
        while($current != NULL)
        {
            array_push($listData, $current->readNode());
            $current = $current->next;
        }
        return $listData;
    }
 
    public function reverseList()
    {
        if($this->firstNode != NULL)
        {
            if($this->firstNode->next != NULL)
            {
                $current = $this->firstNode;
                $new = NULL;
 
                while ($current != NULL)
                {
                    $temp = $current->next;
                    $current->next = $new;
                    $new = $current;
                    $current = $temp;
                }
                $this->firstNode = $new;
            }
        }
    }
}
 
?>

PHPUnit test :

<?php
 
require_once 'linklist.class.php';
require_once 'PHPUnit/Framework.php';
 
class LinkListTest extends PHPUnit_Framework_TestCase
{
    public function testLinkList()
    {
 
        $totalNodes = 100;
 
        $theList = new LinkList();
 
        for($i=1; $i <= $totalNodes; $i++)
        {
            $theList->insertLast($i);
        }
 
        $this->assertEquals($totalNodes, $theList->totalNodes());
 
        for($i=1; $i <= $totalNodes; $i++)
        {
            $theList->insertFirst($i);
        }
 
        $totalNodes = $totalNodes * 2;
        $this->assertEquals($totalNodes, $theList->totalNodes());
 
        $theList->reverseList();
        $this->assertEquals($totalNodes, $theList->totalNodes());
 
        $theList->deleteFirstNode();
        $this->assertEquals($totalNodes - 1, $theList->totalNodes());
 
        $theList->deleteLastNode();
        $this->assertEquals($totalNodes - 2, $theList->totalNodes());
 
        /* Delete node which has a value of '5' */
        $theList->deleteNode(5);
        $this->assertEquals($totalNodes - 3, $theList->totalNodes());
 
        /* Insert a node at the end of the list with a value of '22' */
        $theList->insertLast(22);
        $this->assertEquals($totalNodes - 2, $theList->totalNodes());
 
        /* Find a node with a value of '25' (is in the list) */
        $found = $theList->find(25);
        $this->assertEquals(25, $found->data);
 
        /* Find a node with a value of '125' (is not in the list) */
        $found = $theList->find(125);
        $this->assertNull($found);
 
        /* Return the data stored in the node at position '50'
           which is in the list */
        $data = $theList->readNode(50);
        $this->assertEquals(50, $data);
 
        /* Return the data stored in the node at position '450'
           which is not in the list */
        $data = $theList->readNode(450);
        $this->assertNull($data);
    }
}
 
?>

Download code

Many people confuse profiling with benchmarking. A profiler is a analysis tool that lets you measure the performance of code at runtime. Profiling an application lets you find bottlenecks in your application code. You can find which part of your code is taking most of the time, you can than optimize that part of code. For example if there are 4 functions in your application, profiling may report the following distribution:

function a: 68%
function b: 12%
function c: 1.3%
function d: 18.7%

i.e function ‘a’ accounts for about 70% of the execution time in your application; if you can optimize that function it will boost your application performance considerably. If you had executed the above code on a laptop, and than executed the same on a fast server the code may run in half the time, but the distribution will remain the same. The distribution is what is important in profiling.

Benchmarking is different. It lets you find exactly how long it takes to execute a piece of code. For example I have developed two versions of a sorting algorithm for a application : Sort1(), and Sort2(). If I’ve to find which is faster than I can use a benchmarking software for the same.

To take a contrived example, I recently implemented a Linked List class in PHP (brushing up on my data structure skills), with all the usual functions a linked-list requires - ‘deleteNode‘, ‘insertFirstNode‘, ‘insertLastNode‘, ‘reverseList‘ etc. I was quite happy with the outcome untill I ran a benchmark between two functions - ‘insertFirstNode‘ and ‘insertLastNode‘. Here is a benchmark report for the two functions for various amount of nodes, in table and graph format. The last column shows by how much the ‘insertLastNode‘ is slower than the ‘insertFirstNode‘ function.

As you can see from the report ‘insertLastNode‘ takes exponential time to insert nodes. For example, when inserting 3000 nodes, ‘insertLastNode‘ is 30 times slower then ‘insertFirstNode‘. The reason for this is that ‘insertLastNode‘ has to traverse the entire list to find the last node before adding a new node, while ‘insertFirstNode‘ always adds a new node at the beginning of the list. The simple solution as all you ‘data structure fans’ know is to add a pointer that points to the last node of the list; so every time you have to add a node to the end of the list you use the end node pointer. After making the necessary changes I ran the benchmark and here are the results.

As you can see now both the functions take an equal amount of time to insert a node. Before the code tuning ‘insertLastNode’ took more than 6 seconds to insert 3000 nodes, while after tuning less than quarter of a second.

The whole point of this exercise is to tell you that code tuning can make a tremendous difference to how your application performs.

Installation
You can download the Benchmark pacakage from here or use the pear installer like below:

c:\pear install Benchmark

Using the package:
Using the package for benchmarking is simple enough. A implementation is shown below.

<?php
 
    /* The following sample function is what we
       want to test */
 
    function someFunction()
    {
        for($i=1; $i < 1000; $i++)
            $d = sqrt($i);
    }
 
 
    /* include the PEAR::Benchmark package */
    require_once 'Benchmark/Iterate.php';
 
    $bench = new Benchmark_Iterate;
 
    /* Run the above function 100 times.
       If you want to pass parameters to the function,
       you can add it after the function name like this:
       $bench->run(100, 'someFunction', para1, para2, para n);
    */
    $bench->run(100, 'someFunction');
 
    /* Get the results */
    $result = $bench->get();
 
    /* Display the mean time the function 'someFunction'
       takes to execute */
    print $result['mean'];
 
?>

Output:

0.022045

A sample heatmap image is shown below. You can also use the clickheat class in your own PHP applications. The software doesn’t require any database, only GD graphics library must be enabled on the server, which in most cases already is.

You can view a heatmap for the index page for this site here. I’ve presently only added click log for the index page, so try clicking on the index page links to update the heatmap.

username : visitor
password: visitor

If you don’t see any changes in the heatmap, click on the “log my clicks” link in the right corner or try logging out and then logging in again.

PHP 5.2.5 now is the most popular version of PHP followed closely by PHP 4.4.8 and 4.4.7. This information can be helpful if you are planning on creating an Open source project or are thinking of moving past the version 4 mark in your professional career but are hesitant regarding the version 5 support on servers.

The below two graphs show the market share of various PHP versions for April 2007 and April 2008.

As you can see PHP version 5 has reached a market share of 36% from last years 17%, more then double in one year. As PHP version 6.0.0 is nearing the release date, you can expect PHP 5 to hopefully cross the 50% market share by this year end.

I’am very keen on knowing if any of you are planning on migrating to version 6 after release or have decided to wait a year or year-an-half prior to adoption. Most of the people I know, still stuck with version 4.x.x, have decided to move to PHP 6 directly rather then go through the 5.x.x route.

The data for this analysis was collected by Nexen from 28 million servers and you can find a more detailed analysis on their site.

The PHP mail() function on success returns a 1 or a 0 . This is not the same thing as the email successfully being sent or received. You cannot easily test for either using PHP.

Microsoft Live Mesh is a “software-plus-services” platform that enables PCs, mobiles and other devices to work with each other through the Internet, enabling individuals and organizations to manage, access, share and sync their files, data and applications seamlessly on the Web and across their world of devices. Live Mesh is a Software + Services platform rather then an application.

Main design goals:
1. To make various devices work together.
2. Your data and applications available from anywhere
3. Make sharing and collaborating with people easier.
4. The information you need to stay up-to-date is always available and in sync with other devices.

While many existing web solutions may appear similar in that they utilize hosted services for storage, sharing files, or peer-to-peer connections between PCs, most of those products fulfill only one specific need. What makes Live Mesh different is that it brings all this disparate technologies together seamlessly.

So what are the benefits for the end user?

Devices Working Together: You can share and synchronize your applications and documents across the web and devices.

Anywhere Access: The information you put in your mesh is available from any of your other devices, including your own personal Live Desktop that resides on the Web. The Live Desktop comes with a 5GB space when you signup. The Mesh also provides you with a remote desktop functionality in case you need to take full control of a PC remotely.

Simple to Share: With Live Mesh, you can simply invite a friend or colleague to share a folder, giving them access to view or edit only the files you put in the folder. Live Mesh keeps track of and synchronizes the changes across your mesh.

Stay Informed: Live Mesh has a feed system that allows you to keep track of all the activities you care about, including the online status of your friends or colleagues, comments they make, changes to files and folders in your mesh, and the status of your devices.

Where do developers fit in?

As said above, Live Mesh is a platform. So developers will be able to build applications using the Live Mesh SDK. For example you could create a Facebook application that syncs your photos with the mesh. The application thus build will be available on the users mesh, so the user could view it on their PCs, mobile devices, web or any future device that Microsoft adds support for. You can learn more about the Live Mesh architecture here and mesh application demo here.

Will it work?
In my humble opinion Microsoft is on the right path in making “cloud computing” a reality. Mesh is at present only in a preview mode, so expect more changes in the future as Microsoft gets user feedbacks. As a developer I’am waiting to get my hands on the SDK.

Collaborative filtering algorithms work by searching a large group of users or items and finding a smaller llist from it with tastes similar to yours.

In this post I’ll show you how to integrate a simple recommendation system. You can download the class file here.

We will work with the following book data as an example.

It shows a list of books purchased by various people and rated on a scale of 5 by them. The list can be any thing - books, jewelry, movies, blog posts; any items where ratings are possible. You have to create this array at runtime form the database.

Our job here will be to use this list to recommend books. The above list is converted into an array here.

$books =  array(
 
    "phil" => array("my girl" => 2.5, "the god delusion" => 3.5,
                    "tweak" => 3, "the shack" =>; 4,
                    "the birds in my life" => 2.5,
                    "new moon" => 3.5),
 
    "sameer" => array("the last lecture" => 2.5,
                      "the god delusion" => 3.5,
                      "the noble wilds" => 3, "the shack" => 3.5,
                      "the birds in my life" => 2.5, "new moon" => 1),
 
    "john" => array("a thousand splendid suns" => 5, "the secret" => 3.5,
                    "tweak" => 1),
 
    "peter" => array("chaos" => 5, "php in action" => 3.5),
 
    "jill" => array("the last lecture" => 1.5, "the secret" => 2.5,
                    "the noble wilds" => 4, "the host: a novel" => 3.5,
                    "the world without end" => 2.5, "new moon" => 3.5),
 
    "bruce" => array("the last lecture" => 3, "the hollow" => 1.5,
                     "the noble wilds" => 3, "the shack" => 3.5,
                     "the appeal" => 2, "new moon" => 3),
 
    "tom" => array("chaos" => 2.5)
 
);

Lets start by including the class file first.

require_once("recommend.php");

Lets say you are ‘John’ and the books you have purchased till now are ‘a thousand splendid suns’, ‘the secret’ and ‘tweak’ with appropriate rating given. If you come to the website again what books would the site recommend. Lets try!

$re = new Recommend();
 
print_r($re->getRecommendations($books, "john"));

It will output the following with appropriate ratings and sorted in descending order.

Array
(
    [the noble wilds] =>; 4
    [the shack] => 4
    [the host: a novel] => 3.5
    [new moon] => 3.5
    [the god delusion] => 3.5
    [the world without end] =>; 2.5
    [the birds in my life] =>; 2.5
    [my girl] => 2.5
    [the last lecture] => 1.5
)

Now lets try with ‘tom’.

$re = new Recommend();
 
print_r($re->getRecommendations($books, "tom"));

The recommended books will be…

Array
(
[php in action] => 3.5
)

Now how about recommending items based on book name rather then on the person. For that what we have to do is invert the array using the ‘transformPreferences’ function and then use the ‘matchItems’ function.

Inverting the array like this

$result = $re->transformPreferences($books);

will return an array as show below.

rray
(
    [my girl] => Array
        (
            [phil] => 2.5
        )
 
    [the god delusion] => Array
        (
            [phil] => 3.5
            [sameer] => 3.5
        )
 
    [tweak] => Array
        (
            [phil] => 3
            [john] => 1
        )
 
    [the shack] => Array
        (
            [phil] => 4
            [sameer] => 3.5
            [bruce] => 3.5
        )
 
    [the birds in my life] => Array
        (
            [phil] => 2.5
            [sameer] =>; 2.5
        )
 
    [new moon] => Array
        (
            [phil] => 3.5
            [sameer] => 1
            [jill] => 3.5
            [bruce] => 3
        )
 
    [the last lecture] => Array
        (
            [sameer] => 2.5
            [jill] => 1.5
            [bruce] => 3
        )
 
.
.
.
.

Lets try with the book ‘chaos’ and see what the system will recommend us.

$re = new Recommend();
 
$result = $re->transformPreferences($books);
 
print_r($re->matchItems($result, "chaos"));

The out will be.

Array
(
[php in action] => 0.4
)

But now the value on the right is not a rating but a match probability from a scale of 0 - 1, 1 being a perfect match. If you change the rating of the ‘php in action book’ in the above array to 5 and then run the above code again you will get the match probability as ‘1′.

You can also find how similar the choice of two persons is on a scale of 0-1.

$similarity =  $re->similarityDistance($books, "tom", "peter");
//Converted to percent.
echo sprintf("%.2f", $similarity * 100) . "%";

Will return

28.57%

This simplified filtering system can be used on a site with a few thousand items and members. But as the number of items grows it will be time consuming to calculate the recommendations every time someone purchases or browses an item. In that case it will be helpful to precalculate the array and store it in a database maybe once a day. But that is a different story altogether. For more information on the algorithms and variations you can refer to the wonderful Programming Collective Intelligence: Building Smart Web 2.0 Applications. The code examples in the book are in Python, though.

The above code may not work in each and every instance but you can tweak the code according to your requirements.

Download code

1. Zend PHP 5 Certification : If you are new to PHP, then you cannot get wrong with this book. This book will get you up and running in no time.; right from the basics to OOP, security, XML processing and more. A warning - the book doesn’t go into much detail, so you will have to refer to other books given below for a deeper understanding of the concepts.

2. PHP in Action : If you a beginner or intermediate PHP programmer, then this book will take you to the next level. Design Patterns, unit testing, advanced OOP.

3. PHP and MySQL Web Development : More pragmatic then the other books posted here. A little old compared to others. No information about MVC or design patterns, but this book you show you how to build real world applications like shopping carts, forums, mailing list managers, content management systems etc. It also has an excellent coverage of MySQL.

4. PEAR : PEAR is the PHP Extension and Application Repository, and is a framework and distribution system for reusable, high-quality PHP components. If you have been programming PHP for a while then you will surely have come across PEAR. PEAR provides classes for most of your daily programming needs. Whether you want to work with XML, create Excel documents, encryption, text processing; PEAR provides a class for the purpose and for many more then you can shake a stick at.

5. PHP Cookbook : The book to get you unstuck. Mostly for intermediate programmers; just the book to refer when you want a quick solution to a particular coding problem.

6. SQL for MySQL Developers : Most PHP programmers I have encountered have a very limited understanding of SQL. How many intermediate programmers are aware of the ‘HAVING’ clause in the SELECT statement or have used sub queries more then 2 level deep. The book provides excellent coverage of SQL as implemented in MySQL. The SELECT statement itself is given 9 chapters of coverage.
The book covers everything from MySQL installation, configuration, security to Stored Procedures in a friendly manner with many exercises at each chapter end.

The minimum classes required are ‘cacher.class.php‘ and ‘google_pagerank.class.php‘.

Sample code is shown below.

require_once("popstats/google_pagerank.class.php");
 
$rankObject = new GooglePageRank("http://www.someDomain.com");
 
$pageRank = $rankObject->pagerank;
 
echo $pageRank;

The class also supports result caching on the local machine, so if a second query arrives within the cache time limit the result saved in the local file is returned rather then going out and querying Google.

The ‘GooglePageRank’ class accepts cache time as a second parameter. So if you want to cache the result for 6 hours you set the second parameter for 21600 seconds (6 * 60 * 60):

$rankObject = new GooglePageRank("http://www.someDomain.com", 21600);

The default is set to 24 hours, which is more then adequate for most purposes.

The following image shows an example of a time series data representing the salary of software engineers for a particular duration.

Timeplot is a javascript widget which lets you visualize time series data in a colorful manner with many options to tweak the final output. In this post we will build a time series plot for visualizing yearly US immigrant population. You can download the raw data here.
Lets start with creating a time series plot.

Shown below is a sample excerpt from the data file.

STEP 1. Creating the basic container.
The basic setup is simple. A javascript library and a container to hold the plot as shown below.

STEP 2. The main display block.
The main display code is executed in the onLoad event. There are many options to tweak the display but the one shown below will get you started. You can save the below code in a separate file or embeded in a script tag.

The final output is show below.
<br /> Your browser does not support inline frames or is currently configured not to display inline frames.<br />

Download code