Austin PHP Monthly Meetup, held on Feb 09, 2012, was my first major PHP event I attended this year. At the meetup, I had the privilege to meet an excellent group of PHP enthusiasts and programmers. The group had more than 50 attendees came from a wide range of background to share their knowledge and ideas.

The main agenda of this meetup was PHPCloud/DevCloud, Zend Studio where the participation of Zend was the major attraction. Kevin Schroeder, Technology Evangelist for Zend Technologies, gave some great demos on Zend Studio deploying apps on the PHPCloud. Kevin had spoken at several conferences (including ZendCON of course) and is also the co-author of “The IBM i Programmer’s Guide to PHP” and author of “You want to do WHAT with PHP?”

He also illustrated the debugging capabilities of Zend Studio 9.0 through demos. I took it as a great opportunity to take a more in-depth look at PHPCloud, Zend Studio 9 and more!

The conversations carried were interesting, each individual seems to have a good story/background, and I even learned a thing or two!

It was a nice experience meeting with good mix of bright and experienced people and sharing dialog with them. I thoroughly enjoyed meeting with great group of PHP programmers. The response of attendees was awesome and overall this is an excellently run and organized meetup.  

T-shirts and stickers were also given away to attendees and I really had good time with enthusiasts folks and great topics !!!

To those who are not familiar with this group, here is a quick brief

Austin PHP Meetup is a great group of folks interested in developing with PHP in the Austin, Texas area. For last 8 years, this meetup has been organized to provide PHP users an opportunity to teach and learn. Austin PHP is now the fifth largest PHP Group in the world.

This meetup is a great platform for PHP users new and old where they can gain insights on PHP and network with their peers.
Visit this link http://www.meetup.com/austinphp/ to stay updated on upcoming Austin PHP meetups.

Last time we looked at the scope possibilities for class a properties. In part 3 of our OOP PHP blog series, we will be looking at inheritance. Inheritance is an approach in PHP programming that allows for the extension of a class in order to add more functionality to an existing class. There is also the option to override existing functionality and replace portions of the class if so desired.

In our example code for creating HTML tags we are going to extend our basic class that only has three methods, we will be adding three more methods, we will be using the existing constructor method from the parent class (html), and we will override the pageFooter method.

In order to inherit a class you need to use the “extends” keyword. Note that a single class can only extend one other class at a time, there is no limit to the inheritance chain, practicality however suggests no more than five inheritances in a chain, otherwise the length of the chain becomes hard to navigate and manage. Also note that all of the public and protected methods (this will be covered in part four of our blog series) are inherited in the subclass and unless they are overridden they retain their original functionality as if the code for those methods were actually in the subclass.

So we are first going to extend the HTML class to a new class called moreHTML. We can do this in the same class code file if we want or we can do it in its own file. Just make sure the “require” statements are in the right order; here's our new code (our original html.php.inc file has not changed so I am not re-listing it here):

// filename: more_html.php.inc

class moreHTML extends html {

private $tag;

private $textString ;
   
function pageFooter() {
        $textString = '\n<hr/>';

        $textString .= html::pageFooter();       

        return $textString;
    }
    function Anchor($url, $link, $name="", $class="", $id="", $title="", $style="", $onTypesActions="") {

        $this->tag = '<a ' ;

        if ($url) { $this->tag .= 'href="' . $url . '" ' ; } else { $this->tag .= 'href="" ' ; }

        if ($name)         $this->tag .= 'name="' . $name . '" ' ;

        if ($class)     $this->tag .= 'class="' . $class . '" ' ;

        if ($id)         $this->tag .= 'id="' . $id . '" ' ;

        if ($title)     $this->tag .= 'title="' . $title . '" ' ;

        if ($style)     $this->tag .= 'style="' . $style . '" ' ;

        if (!Empty($onTypesActions)){

            foreach($onTypesActions AS $type => $actoin) {

            $this->tag .= $type . '="' . $actoin . '" ' ;
            }
        }       
        $this->tag .= ">" ;

        $this->tag .=  $link ;

        $this->tag .=  "</a>" ;

        return $this->tag ;
    }
    function Spacer($spaces = 1) {

        $this->tag = "";

        for ($i=1 ; $i <= $spaces ; $i++) {

            $this->tag .= "&nbsp;" ;
        }
        return $this->tag;
    }
    function NewLine($number = 1) {

        $this->tag = '';

        for ($i=1 ; $i <= $number ; $i++) {

             $this->tag .= "\n<br/>" ;
        }
        return $this->tag;
    }

} // end moreHTML class definition

Notice that our newly extended class does not have a __constructor method at all, it merely inherits that from the parent; this is equally true for the image method. Also notice that we are over-riding the pageFooter method by adding in an <hr> tag to signify the bottom of the page and then we are calling the parent method with the :: notation, to leverage that existing code. Our code to use these classes would look something like this:

require_once("html.php.inc");

require_once("more_html.php.inc");

$myHTML = NEW moreHTML("Testing page build 3");

$output = $myHTML->Anchor("http://php.osscube.com", $myHTML->image("images/clock.jpg")) ;

echo $myHTML->NewLine() ;

echo "the current value of label: " . $myHTML->Spacer(3) . $myHTML->label . $myHTML->NewLine(2) . "\n";

$output .= $myHTML->NewLine(2) ;

$output .= $myHTML->pageFooter();

echo $output;

Notice here that I am using a method call as the 2nd parameter to the anchor method; this is a neat technique that can be used when attempting to use methods that are inter-related. As well, I have the choice (depending on how the methods are actually written) to either build the $output variable and then echo that out when I want, or to echo method calls directly to the browser. See too that I am using our two new methods in the inherited class called NewLine and Spacer. When the above code is executed you will see the following content on a browser:

And you should see the following in your revealed source code:

<HTML>

<HEAD>

<TITLE>Testing page build 3</TITlE>

</HEAD>

<BODY>

<br/>the current value of label: &nbsp;&nbsp;&nbsp;this is my label

<br/>

<br/>

<a href="http://php.osscube.com" ><img src="images/clock.jpg"  /></a>

<br/>

<br/>

<hr />

</body>

</html>

In our fourth blog segment we will be looking at the scope attributes that can be added to methods, this will be similar in concept to scope attributes that can be added to properties of a class.

Last time we looked at a basic class definition that produced some HTML tags for us. In this second part we will take you further into some definitions of OOP as it stands in PHP; then we will build out our code example to prove our theories in practice.

The first thing to look at this time is the topic of scope in the sense of properties (defined variables) in a class. There are 4 basic scope levels, and they are:

So with these definitions let’s look at how we can make our html class a little better. Here we will build out our constructor method (refer to part one for explanation) that will allow every HTML class that we instantiate to have a basic web page structure. As well, we will add a pageFooter method that will allow us to close the generated web page with grace. There will be some sample properties defined here additionally to show you the differences between the scopes as described above.

<?php
// filename: html.php.inc
class html {
private $tag;
public $label = "this is my label:" ;
    function __construct ($title) {
        echo "<HTML>\n<HEAD>\n<TITLE>$title</TITlE>\n</HEAD>\n<BODY>\n" ;
    }
    function pageFooter() {
        return "\n</body>\n</html>";
    }
    function Image($source, $id='', $class='', $title="", $style = '', $onTypesActions="") {
        //Open an img tag and set it's image source        
        $this->tag = '<img src="' . $source . '" ' ;                                
        //Set the class attribute
        if ($class) $this->tag .= 'class="' . $class . '" ' ;                                
        //Set the id attribute
        if ($id) $this->tag .= 'id="' . $id . '" ' ;
        //Set the title and alt attributes
        if ($title)     $this->tag .= 'title="' . $title . '" alt="' . $title . '" ' ;    
        if ($style)    $this->tag .= 'style="' . $style .'" ';
        if (!Empty($onTypesActions)){
            foreach($onTypesActions AS $type => $actoin) {
                    // The following sets ON listeners and actions    
                    $this->tag .= $type . '="' . $actoin . '" ' ;
            }
        }
        // close the img tag 
        $this->tag .= " />" ;
        return $this->tag ;                                        
    }
} 
// end html class definition
?>

Notice here, too, that we are using a variable called “$this”. That particular variable is a pre-defined entity in every class that is used to reference the class itself. It would be the equivalent to coding $html->tag except that we can’t use $html in the class definition because we can’t be sure of what variable will be used when the class is eventually instantiated.

NewPage.php

<?PHP
require_once("html.php.inc");
$myHTML = NEW html("Testing page build 2");
$output = $myHTML->image("images/clock.jpg");
echo "the current value of label: " . $myHTML->label ;
echo "<br /><br />";
echo "the current value of tag: " . $myHTML->tag ;
echo "<br /><br />";
$output .= $myHTML->pageFooter();
echo $output;
?>

Notice here that we were able to access the publicly defined property of $label, but when we tried the same approach to $tag (the private class property) we got an error message like this if you have display_errors turned on:

Next time we will look more deeply into class definitions and how they can be extended with inheritance.

The recently held OSCON 2011 Convention in Portland, OR was a fantastic experience for the OSSCube team. This conference gave me the opportunity to meet and speak with many technology evangelists around the world. I delivered a major presentation on SmartWorks Project (a federal level use system that OSSCube has helped design and roll out) during day two of the event while the, President Lavanya Rastogi and Head of Business Development & Customer Advocacy Vivek Agrawal alternated booth staffing duty and new business prospect meetings throughout the event. Our presentation was accepted so well by the audience and received some concrete feedback.

We had a well thought out and well designed booth Setup where our international team with mix of sales focus and technical expertise was present to support us. Our Partners ZEND backed us at the booth. Our case studies were quite a success and attracted the clients to visit us at the booth.

The Tuesday evening reception and two full days of exhibits on Wednesday and Thursday saw some 185 of the show’s delegates, almost 8% of the total, visit the OSSCube booth and interact with both our staff and our two guest authors, Kevin Schroeder and Peter MacIntyre, both of whom signed copies of their respective books and assisted us in educating delegates on the interrelationship of PHP, Zend and OSSCube. Several solid new and continuing business leads were developed at the show and are already being followed up.

We’re very likely to see some of these same delegates at our next stop, ZendCon, in mid October in Santa Clara, CA. We’ll share new opportunities from this show as they materialize.