If MySQL is not your DB of choice, there are other applications out there for interfacing the various other database platforms (such as phpMyAdmin’s relative for PostgreSQL, phpPgAdmin), but MySQL is the most widely used and phpMyAdmin is often included or offered as a part of many basic hosting plans.

As of this writing, 2.11.3 is the most current version of phpMyAdmin. It can be downloaded at the main phpMyAdmin download page. Please follow the installation instructions found in the phpMyAdmin documentation. I’m going to show you how to use phpMyAdmin to create a new database, create tables, insert records, backup your data, and import data into your database. There are many, many other things you can do with this wonderful application, but I’ll keep it simple.

Creating a new database

Now that we have phpMyAdmin installed and set up, the first thing we need to do is create a new database. Point your browser to your new phpMyAdmin install and log in using your MySQL username and password. The resulting screen should give you a dashboard overview of MySQL. Some of you using shared hosting may need to skip this step as you might only be allowed a single database that has already been created for you. To create a new database, find the “Create new database” option, type in the name of your new database in the text field below it, and click the “Create” button. You can ignore the dropdown with the value of “Collation” showing unless you have a specific character encoding you’d like to use.

Creating a table

Now that we have our database, we need to create some tables. This is where I find phpMyAdmin saves me the most time. Since I use PostgreSQL a lot as well, I often get some of the CREATE TABLE syntax differences mixed up. Using an interface to create tables saves me a lot of grief.

On the resulting screen after creating the database, there is a small form for creating a new table, with options for the table name and number of fields. If you are coming from the main dashboard page, just click on the name of your database in the left column. In this example, I’m going to create an ‘entries’ table for my blog database. I’m going to need to store an ID number, a title, the body of the entry, and a timestamp, so I need four fields.

After entering the name and number of fields, click the ‘Go’ button, and you’ll be presented with a very large form with four rows. Enter the name of the field in first column, select the field type in second column, and enter the field length (if needed) into the third column. At a bare minimum, that is all you need. In my example, I want my ID field to automatically increment each time I save an entry and I want to use it as the primary key in my table, so I select ‘auto_increment’ in the ‘Extra’ dropdown and click the ‘Primary Key’ radio button.

Once the form is completed to your satisfaction, click the ‘Save’ button to create your new table. Complete information about table creation option can be found in the MySQL manual.

Inserting Records

Now that we have some tables, let’s stick some data in there. To insert records into a table, you can either click on the name of your database in the left column, then click on the “Insert” icon corresponding to the table you wish to insert into, or click the table name in the left column and then click the “Insert” tab. Doing either will bring up a form where you can enter data.

In my example, I want to create some categories for my blog, but entering them in one at a time would be a pain. Luckily, phpMyAdmin has a second form so I can enter two records at once. It also gives me the option to save and insert again so I don’t have to navigate back to the insert form.

Backing up your data (exporting)

Another great feature of phpMyAdmin is that it easily lets you back up an entire database with only a couple clicks. Click on the name of the database you want to back up in the left column, then click the ‘Export’ tab. The resulting screen will give you all kinds of different options, but the defaults should suffice. Make sure you check the “Save as File” checkbox, otherwise it will output all the data to your browser. If you have a fairly large database, you may want to select a “Compression” option (“zipped” will create a ZIP file). Click “Go” to generate and download your backed up data.

Importing data

A number of web applications may come with a SQL data file that you’ll need to load into your database. A very easy way to do this in phpMyAdmin is to use the “Import” feature. Click the name of the database you want to import into in the left column, then click the “Import” tab.

All you have to do is find the SQL file on your local disk and use the Import interface to upload the file. phpMyAdmin will report any errors it encounters. You can also use the import feature to restore your database from one of the backups you’ve created.

I’ve only scratched the surface of what phpMyAdmin is capable of, but using it for even the simplest of tasks can save you time and effort in dealing with MySQL. phpMyAdmin is a great tool for both the database newbie and master DBA alike.

So let's get started!

Questions 12 - 22

12. What is the difference between include, include_once? and require?

    All three allow the script to include another file, be it internal or external depending on if allow_url_fopen is enabled. However, they do have slight differences, which are denoted below.

    1. include()
       The include() function allows you to include a file multiple times within your application and if the file does not exist it will throw a Warning and continue on with your PHP script.
    2. include_once()
       include_once() is like include() except as the name suggests, it will only include the file once during the script execution.
    3. require()
       Like include(), you can request to require a file multiple times, however, if the file does not exist it will throw a Warning that will result in a Fatal Error stopping the PHP script execution.

13. What function would you use to redirect the browser to a new page?

    1. redir()
       This is not a function in PHP, so it will fail with an error.
    2. header()
       This is the correct function, it allows you to write header data to direct the page to a new location. For example:
       PLAIN TEXT
       PHP:

       1. header("Location: http://www.search-this.com/");

    3. location()
       This is not a function in PHP, so it will fail with an error.
    4. redirect()
       This is not a function in PHP, so it will fail with an error.

14. What function can you use to open a file for reading and writing?

    1. fget()
       This is not a function in PHP, so it will fail with an error.
    2. file_open()
       This is not a function in PHP, so it will fail with an error.
    3. fopen()
       This is the correct function, it allows you to open a file for reading and/or writing. In fact, you have a lot of options, check out php.net for more information.
    4. open_file()
       This is not a function in PHP, so it will fail with an error.

15. What's the difference between mysql_fetch_row() and mysql_fetch_array()?

    mysql_fetch_row() returns all of the columns in an array using a 0 based index. The first row would have the index of 0, the second would be 1, and so on. Now another MySQL function in PHP is mysql_fetch_assoc(), which is an associative array. Its' indexes are the column names. For example, if my query was returning 'first_name', 'last_name', 'email', my indexes in the array would be 'first_name', 'last_name', and 'email'. mysql_fetch_array() provides the output of mysql_fetch_assoc and mysql_fetch_row().

16. What does the following code do? Explain what's going on there.

    PLAIN TEXT
    PHP:

    1. $date='08/26/2003';
    2. print ereg_replace("([0-9]+)/([0-9]+)/([0-9]+)","\\2/\\1/\\3",$date);

    This code is reformatting the date from MM/DD/YYYY to DD/MM/YYYY. A good friend got me hooked on writing regular expressions like below, so it could be commented much better, granted this is a bit excessive for such a simple regular expression.

    PLAIN TEXT
    PHP:

    1. // Match 0-9 one or more times then a forward slash
    2. $regExpression = "([0-9]+)/";
    3. // Match 0-9 one or more times then another forward slash
    4. $regExpression .= "([0-9]+)/";
    5. // Match 0-9 one or more times yet again.
    6. $regExpression .= "([0-9]+)";

    Now the \\2/\\1/\\3 denotes the parentheses matches. The first parenthesis matches the month, the second the day, and the third the year.

17. Given a line of text $string, how would you write a regular expression to strip all the HTML tags from it?

    First of all why would you write a regular expression when a PHP function already exists? See php.net's strip_tags function. However, considering this is an interview question, I would write it like so:

    PLAIN TEXT
    PHP:

    1. $stringOfText = "<p>This is a test</p>";
    2. $expression = "/<(.*?)>(.*?)<\/(.*?)>/";
    3. echo preg_replace($expression, "\\2", $stringOfText);
    4.  
    5. // It was suggested (by Fred) that /(<[^>]*>)/ would work too.
    6. $expression = "/(<[^>]*>)/";
    7. echo preg_replace($expression, "", $stringOfText);

18. What's the difference between the way PHP and Perl distinguish between arrays and hashes?

    This is why I tell everyone to, "pick the language for the job!" If you only write code in a single language how will you ever answer this question? The question is quite simple. In Perl, you are required to use the @ sign to start all array variable names, for example, @myArray. In PHP, you just continue to use the $ (dollar sign), for example, $myArray.

    Now for hashes in Perl you must start the variable name with the % (percent sign), as in, %myHash. Whereas, in PHP you still use the $ (dollar sign), as in, $myHash.

19. How can you get round the stateless nature of HTTP using PHP?

    The top two options that are used are sessions and cookies. To access a session, you will need to have session_start() at the top of each page, and then you will use the $_SESSION hash to access and store your session variables. For cookies, you only have to remember one rule. You must use the set_cookie function before any output is started in your PHP script. From then on you can use the $_COOKIE has to access your cookie variables and values.

    There are other methods, but they are not as fool proof and most often than not depend on the IP address of the visitor, which is a very dangerous thing to do.

20. What does the GD library do?

    This is probably one of my favorite libraries, as it is built into PHP as of version 4.3.0 (I am very happy with myself, I didn't have to look up the version of PHP this was introduced on php.net). This library allows you to manipulate and display images of various extensions. More often than not, it is used to create thumbnail images. An alternative to GD is ImageMagick, however, unlike GD, this does not come built in to PHP and must be installed on the server by an Administrator.

21. Name a few ways to output (print) a block of HTML code in PHP?

    Well you can use any of the output statments in PHP, such as, print, echo, and printf. Most individuals use the echo statement as in:

    PLAIN TEXT
    PHP:

    1. echo "My string $variable";

    However, you can also use it like so:

    PLAIN TEXT
    PHP:

    1. echo <<<OUTPUT
    2. This text is written to the screen as output and this $variable is parsed too.  If you wanted you can have &lt;span&gt; HTML tags in here as well.&lt;/span&gt; The END; remarks must be on a line of its own, and can't contain any extra white space.
    3. END;

22. Is PHP better than Perl? - Discuss.

    Come on, let's not start a flame over such a trivial question. As I have stated many times before,

    "Pick the language for the job, do not fit the job into a particular language."

    Perl in my opinion is great for command line utilities, yes it can be used for the web as well, but its' real power can be really demonstrated through the command line. Likewise, PHP can be used on the command line too, but I personally feel it's more powerful on the web. It has a lot more functions built with the web in mind, whereas, Perl seems to have the console in mind.

    Personally, I love both languages. I used Perl a lot in college and I used PHP and Java a lot in college. Unfortunately, my job requires me to use C#, but I spend countless hours at home working in PHP, Perl, Ruby (currently learning), and Java to keep my skills up to date. Many have asked me what happened to C and C++ and do they still fit into my applications from time to time. The answer is primarily 'No'. Lately all of my development work has been for the web and though C and C++ could be written for the web, they are hardly the language to use for such tasks. Pick the language for the job. If I needed a console application that was meant to show off the performance differences between a quick sort, bubble sort, and a merge sort, give me C/C++! If you want a Photo Gallery, give me PHP or C# (though I personally find .NET languages better for quick GUI applications than web).

I would like to take this time to challenge other companies to post their interview questions or feel free to email them to me at search-this [at] cpradio [dot] org. I will be glad to read through them, and write an article about them revealing their answers for everyone to learn.

Updated: 08/27/2007
Changed # to % for Perl Hashes - Thanks to MrSpooky for pointing that out, can't believe I forgot that!

Well at another blog they shared some pre-interview questions from Yahoo for a PHP job. The only problem is they never provided the answers. So that's what I'm going to do now.

Yahoo, if you're watching, please check my answers and if they are right, I can start next week!

Questions 1 - 11

1. Which of the following will NOT add john to the users array?

   1. $users[] = 'john';
      Successfully adds john to the array
   2. array_add($users,’john’);
      Fails stating Undefined Function array_add()
   3. array_push($users,‘john’);
      Successfully adds john to the array
   4. $users ||= 'john';
      Fails stating Syntax Error

2. What’s the difference between sort(), assort() and ksort? Under what circumstances would you use each of these?

   1. sort()
      Sorts an array in alphabetical order based on the value of each element. The index keys will also be renumbered 0 to length - 1. This is used primarily on arrays where the indexes/keys do not matter.
   2. assort()
      The assort function does not exist, so I am going to assume it should have been typed asort().

      asort()
      Like the sort() function, this sorts the array in alphabetical order based on the value of each element, however, unlike the sort() function, all indexes are maintained, thus it will not renumber them, but rather keep them. This is particularly useful with associate arrays.

   3. ksort()
      Sorts an array in alphabetical order by index/key. This is typically used for associate arrays where you want the keys/indexes to be in alphabetical order.

3. What would the following code print to the browser? Why?

   PLAIN TEXT
   PHP:

   1. $num = 10;
   2. function multiply(){
   3.     $num = $num * 10;
   4. }
   5. multiply();
   6. echo $num; // prints 10 to the screen

   Since the function does not specify to use $num globally either by using global $num; or by $_GLOBALS['num'] instead of $num, the value remains 10.

4. What is the difference between a reference and a regular variable? How do you pass by reference and why would you want to?

   Reference variables pass the address location of the variable instead of the value. So when the variable is changed in the function, it is also changed in the whole application, as now the address points to the new value.

   Now a regular variable passes by value, so when the value is changed in the function, it has no affect outside the function.

   PLAIN TEXT
   PHP:

   1. $myVariable = "its' value";
   2. Myfunction(&$myVariable); // Pass by Reference Example

   So why would you want to pass by reference? The simple reason, is you want the function to update the value of your variable so even after you are done with the function, the value has been updated accordingly.

5. What functions can you use to add library code to the currently running script?

   This is another question where the interpretation could completely hit or miss the question. My first thought was class libraries written in PHP, so include(), include_once(), require(), and require_once() came to mind. However, you can also include COM objects and .NET libraries. By utilizing the com_load and the dotnet_load respectively you can incorporate COM objects and .NET libraries into your PHP code, thus anytime you see "library code" in a question, make sure you remember these two functions.

6. What is the difference between foo() & @foo()?

   foo() executes the function and any parse/syntax/thrown errors will be displayed on the page.

   @foo() will mask any parse/syntax/thrown errors as it executes.

   You will commonly find most applications use @mysql_connect() to hide mysql errors or @mysql_query. However, I feel that approach is significantly flawed as you should never hide errors, rather you should manage them accordingly and if you can, fix them.

7. How do you debug a PHP application?

   This isn't something I do often, as it is a pain in the butt to setup in Linux and I have tried numerous debuggers. However, I will point out one that has been getting quite a bit of attention lately.

   PHP - Advanced PHP Debugger or PHP-APD. First you have to install it by running:
   pear install apd

   Once installed, start the trace by placing the following code at the beginning of your script:
   apd_set_pprof_trace();

   Then once you have executed your script, look at the log in apd.dumpdir.
   You can even use the pprofp command to format the data as in:
   pprofp -R /tmp/pprof.22141.0

   For more information see http://us.php.net/manual/en/ref.apd.php

8. What does === do? What’s an example of something that will give true for ‘==’, but not ‘===’?

   The === operator is used for functions that can return a Boolean false and that may also return a non-Boolean value which evaluates to false. Such functions would be strpos and strrpos.

   I am having a hard time with the second portion, as I am able to come up with scenarios where '==' will be false and '===' would come out true, but it's hard to think of the opposite. So here is the example I came up with:

   PLAIN TEXT
   PHP:

   1. if (strpos("abc", "a") == true)
   2. {
   3.     // this does not get hit, since "a" is in the 0 index position, it returns false.
   4. }
   5.            
   6. if (strpos("abc", "a") === true)
   7. {
   8.     // this does get hit as the === ensures this is treated as non-boolean.
   9. }

9. How would you declare a class named “myclass” with no methods or properties?

   PLAIN TEXT
   PHP:

   1. class myclass
   2. {
   3. }

10. How would you create an object, which is an instance of “myclass”?

    PLAIN TEXT
    PHP:

    1. $obj = new myclass();

    It doesn't get any easier than this.

11. How do you access and set properties of a class from within the class?

    You use the $this->PropertyName syntax.

    PLAIN TEXT
    PHP:

    1. class myclass
    2. {
    3.     private $propertyName;
    4.              
    5.     public function __construct()
    6.     {
    7.         $this->propertyName = "value";
    8.     }
    9. }

There you have it! The answers to questions 1 through 11. Stay tuned for Part 2 where I tackle 12 through 22. If you have any questions, need further explanation, or just want to contribute to any of the above questions, comments are always welcome.

I would like to talk about my personal favorite method of caching: memcached. I'll show you how memcached works, how to install it, and how to use it to help your site/application run faster and scale better. According to the memcached site, "memcached is a high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load." In plain English, this means memcached is an application that you can use to take advantage of spare free memory on any number of machines to cache pretty much anything you want (with a few exceptions) and retrieve it very quickly. Memcached was originally developed by Danga Interactive to help speed up LiveJournal. Some of memcached's great features are that in runs on a number of platforms (Linux, BSD, Windows), is VERY fast, and has a number of client APIs already written so you'll more than likely find libraries for any type of project you're working on. We'll focus on the PHP API in this article.

Before I get too far, I want to mention a couple of alternatives that may fit your particular situation.

Local Database Query Cache: Your database may have it's own native query caching, which you don't have to do much to use. The only drawback is that if a table is updated, its entire cache is thrown out.

The PHP APC extension: The APC extension is an opcode cache for your PHP scripts, but also provides a similar function to that of memcache. The biggest problem with APC is that you can only access the local APC cache. There are other distributed caching systems, such a MCache, but I have no personal experience with any of these, so I cannot opine on any advantages or disadvantages of using another tool.

Installation

First thing we need is an instance of memcached to store our data in. Unix/Linux folks can download the source from here and follow the instructions for installation on this page. Some distributions (like Ubuntu and CentOS) have memcached in their repositories, so you can use the native package installer like apt or yum to install memcache. Windows users can find binaries and installation instructions at http://jehiah.cz/projects/memcached-win32/. Any other questions you may have about memcached can possibly be answered on their excellent FAQ.

Now that we have memcached up and running, we need a way to talk to it. This is where the client APIs come in. We'll be using the PHP API, so I'll show you how to install the PHP memcached extenstion. The easiest way to do this is using the 'pecl' command: [pecl install memcache] this will download, compile, and install the extension. All you will need to do is add the line 'extension=memcache.so' to your php.ini file. You may also need to find and move the memcache.so file into the extensions/ directory (usually located at /usr/local/lib/php/extensions) by hand. Other options for installing PHP extensions and instructions for windows users can be found at http://us2.php.net/manual/en/install.pecl.php.

Implementation

Now that all the pieces are in place, let's integrate memcached into our application. First thing we need to do is to connect to our memcached server:

This is assuming that memcached is running on the local machine and it's using the default settings. You would usually do this connection when you open a database connection at the beginning of your application. If you want to connect to more than one memcached server, simply call $memcache->connect() again and pass in the name and port number of the additional server(s). Now that we've got a connection, let's look at this section of code:

This fetches the 'content' field from our pages table. Now, if the data in the content field does not change very often, it is a good candidate for caching. Here's one possible way how we would integrate memcached into our little section of code:

A bit more involved, but we are now using memcached! The above code first checks to see if we can find whatever it is we are looking for in memcache, and if we can't find it, we fetch it from the database and use the result to populate the cache. In this example, I stored the entire $result object in cache and set its expiration to 3600 seconds (1 hour). The third flag in the set() function deals with whether to compress the data or not. Depending on your needs, you can store strings, numbers, objects, and arrays in memcache. Anything that is serializable in PHP can be cached, so database connections and file handles won't work.

Now that we're pulling data from memcache, what happens if the data in the database is updated? We can compensate for this in two ways. The easiest is to pass an expiration on the data that is fairly low, but you'll have to deal with a little lag from the time you updated the database to when it will appear in the cache. The other way is to update the cache on the fly any time an update or delete occurs. This involves a bit more work as you may have to update many places in the cache depending on how many queries could possibly touch the data, but this is only necessary when doing query caching as in my example rather than just straight content caching.

Memcached affords us endless possibilities (query caching, content caching, session storage) and great flexibility. It's an excellent option for increasing performance and scalability on any website without requiring a lot of additional resources.

<pearl jam rif> Jeremy spoke in class today... </pearl jam rif>

sorry, had to get my Pearl Jam on...

<pearl jam rif> Ooh, but we unleashed a lion... </pearl jam rif>

No, but really, we did unleash a lion, Jeremy joins the team with a strong website development and administration background.

Hopefully you've already read Jeremy's first two articles: Simple Tips to Help Survive The Digg Effect and The Lazy Programmer - Open Source and You. And his next article will be out tomorrow!

Here's a bit more about Jeremy:

User Name: MrSpooky

• childhood ambition: to be an astronaut, of course
• fondest memory: my son being born
• favorite music: metal! \m/
• retreat: my front porch with a book
• proudest moment: winning the pole vault at the 1999 Outdoor Big Ten Championships
• biggest challenge: managing my time
• alarm clock: 6:30 AM or my son, whichever comes first
• perfect day: doing absolutely nothing
• first job: bailing hay on a farm in rural Indiana
• indulgence: Taco Bell
• favorite movie: Fight Club
• inspiration: knowing that there is someone out there that is better than me at what I do

What is the difference between a struct and a class? When should you use a struct versus a class? How do you know?

What is the difference between a struct and a class?
It is simple, structs cannot be inherited from or extended. They can have properties, private variables, methods, and even constructors and deconstructors. Unfortunately, that is where they end in their likeness to classes. Classes on the other hand are extensible and can be inherited.

Finally, it should be mentioned that structs are stored on the stack as a by value type and classes are stored on the heap as a by reference type. What you do need to know is if you copy a struct to another variable, you will now have two copies of the entire struct in the stack, causing a performance hit (depending on the size). For a class, this is not true, the second variable gets stores the address to the original heap location, thus no performance hit.

So when should you use a struct versus a class?
Whenever you do not need extensibility or inheritance. As for the "How do you know?", you are the architect; during your analysis take into consideration what you might be able to re-use in the future.

The nice thing about classes are their advance functionality. You can extend upon them creating large webs of functional objects and you can use them as a refactoring foothold to make smaller chunks of reusable code (modularization). For example, let's say you have a class called "Person". This class contains information such as "First Name", "Last Name", "Middle Initial", "Birth Date", and "Gender".

Now let's say you want to extend that class to have "Customers" and "Employees". You would inherit the "Person" class and extend it with the additional information you want to store. Let's say the "Customers" class should have an "Account Number", "Credit Card Number", "Credit Card Expiration Date", and "Credit Card Type". The "Employees" class would have an "Employee ID", "Email Address", "Title", and "Department". Now if we didn't use inheritance, all of this extra data would all be in the "Person" class, and that would just look busy.

So here is the Employees and Customers classes:

Now that we have covered inheritance to show how to extend a class, let's tackle abstraction. Abstraction provides a mechanism to define methods that MUST be created by anything extending it. For example, let's say the "Person" class wanted to abstract the method to display the "Full Name". This way the "Customers" class must write it's own "Full Name" method and so must the "Employees" class.

Due to the abstraction, our "Person" class needs a few changes:

Now keep in mind that abstract classes can have non-abstract methods, however, you cannot create an instance of this class, it must be inherited.

Finally, interfaces solve the biggest problem with objects. In C# and PHP, you are only allowed to inherit from a single class, however, you can implement an infinite number of interfaces. Interfaces like abstract classes cannot be instantiated, they can only define the method definitions; they cannot actually implement the methods.

There you have it, in this article we learned how to use classes to extend, abstract, and interface your code to make smaller chunks re-usable and extensible.

History:
07/13/2007 11:44 AM
Added information denoting that structs are stored on the stack and classes are stored on the heap -- hat tip to Ramjee.

He goes on to talk about coding and documenting in such a way so as to not create more work for yourself down the road, but he never addresses how to make the initial effort easier. I want to give a few pointers as to how you might get off on a good start.

Let's say you've got a great idea for a new feature on your website and are ready to get started. You can do one of the three B's: build, buy, or borrow. Building from scratch offers the most flexibility, but will likely take the longest. If you're like me and don't always have time to roll your own a good choice is to buy a 3rd party application. A 3rd party application (in most cases) is the quickest option, but can cost you a pretty penny depending on what you're looking for. Borrowing is a nice middle ground between the two. There's a good chance that someone else has already done what you want to do so why reinvent the wheel if you don't have to? You get all the benefits of a pre-built solution (minus the price tag) with the flexibility of a do-it-yourself project.

The best place to do our "borrowing" from is Free and Open Source Software (FOSS). "Open Source" means that when you get a copy of an application, you have full access to its underlying source code; what you can do with it greatly depends on the license under which it was distributed. The most widely used open source license is the GNU General Public License (GPL). The basic gist of this license is that you can take the source code and do whatever you want with it, with a few caveats. You can make any kind of changes you want, but if you distribute your application, you must distribute it under the GPL and make your source available as well. More details can be found in the GPL Wikipedia entry.

There are many places on the web to find and download open source applications. Here are a few of my favorites:

• Google - You can never go wrong with Google. Just search for exactly what you are looking for. Be careful, because Google doesn't distinguish between open source and proprietary, so be sure to review any licensing and costs before downloading anything.
• SourceForge - SourceForge provides free hosting and development tools to over 100,000 open source projects. This is always one of my first stops in looking for code. I recommend using the advanced search instead of the front page search, as its search algorithm isn't very sophisticated.
• FreshMeat - The self-proclaimed "web's largest index of preferably open source licensed projects". This is a great backup to SourceForge for finding those obscure projects.
• ohloh - A relative newcomer on the scene. This is the Web 2.0 version of an open source directory. Each project shows a lot of detail about the code and contributors as well as a lot of other statistics.

A couple of years ago, a site I was working on needed to integrate an event calendar. The requirements were very specific: allow users to have a calendar on their pages where they can add events. A fairly simple project from the outside looking in, but once I started to hash out all the details, it became a fairly involved project. I was given a pretty tight deadline, so my only real choice was to go out and find a pre-existing application that could meet my requirements yet be easy on the budget. A quick trip to SourceForge netted a few options, and I finally settled on an application called phpEventCalendar. It didn't quite fit all the requirements, but did have the user authentication and basic calendaring/event handling functionality we were looking for. The code was clean and easy enough to understand, so extending it to have a mini-calendar view and upcoming event list was very simple. It's a great example of open source software saving me and my business time and money.

If you want to have the programmer's "great virtue" of being lazy, you can ease your initial effort by borrowing someone else's source code. So save yourself time, energy and money!

Before we get into this, you will need to have PHP 5 installed and MySQL 3.23 or higher. PHP 5 allows for greater implementation of OOP (Object Oriented Programming) than its predecessors.

Step 1: Analyze the Project
The first step is always the most crucial, so it should take some thought: What do we want to achieve, and how detailed do we want to get? All of these are questions that should be asked prior to any coding or any development work.

What do we want to achieve and how detailed should we get?
In this project, we want to use Paul's CSS technique to build a fully functional rating system. Ideally, one that does not require any administration. Everything is automated by pasting a segment of code written in PHP onto a page.

Secondly, we want to ensure that only one IP Address can rate each unique item. Therefore one person isn't repeatedly clicking on '5 Stars' to throw off the rating average. Now granted, ensuring a single IP Address is used in rating isn't fool proof. As those with dial-up connections will likely have a different IP address every time they reconnect, we have to remember our first goal, "does not require any administration!" No administration means no username and passwords to be assigned.

What about cookies? Glad you asked; I did think of using cookies to do the tracking, but I figured that would be much easier to overcome than basing it on IP address. It has become easier to clear the privately stored data in our modern browsers and thus cookies could easily be foiled.

Our third goal is to adequately show the new average rating when clicked without reloading the entire page. To do this requires the use of AJAX (Asynchronous JavaScript and XML). In our situation, we will be using more of AJANVP (Asynchronous JavaScript and Name/Value Pairs). XML can become very bloated and in something like this it's simply unnecessary. I also considered JSON (JavaScript Object Notation), but again, that has too many dependencies and further complicates the system requirements for this task. Remember, we are going for no administration and fully automated.

Finally, we want each user to be able to add new ratings without having to insert anything into a database table. Simply put, the HTML components built should derive the rating data for us. I'll clear this up later, but you should be excited to know that when we are done you will only need to copy and paste code and the new rating entry will be ready for use. Nothing more is required.

Step 1 Recap:
In step 1, we answered the questions "What do I want to achieve and how detailed do I want to get?" The answer can be summarized in these points.

1. Use Paul's CSS Star Matrix technique.
2. Log the Ratings by IP address to ensure no IP address can rate the same item twice.
3. Update the Rating seamlessly for the user to see the new average rating.
4. Make it easy to add new items to rate.

Step 2: Designing the Database and Table
Step 2 is designing the storage facility to keep our information. There are a few questions to ask yourself when designing a table like this. What information do you plan to hold in it? How do you plan on using the data?

What information do I plan to hold in the table?

Below is the list of the data we plan to keep track of:

• Item Name
• IP Address
• Rating
• Date Rated

There won't be much use immediately for Date Rated, however, it could be used in the future to build any reports on when each item was rated.

How do you plan on using the data?

Each item you plan to keep track of should ALWAYS have a use, whether it be immediate or in the future. For example, Item Name, IP address, and Rating will all be used immediately within this application. The Item Name will describe the item being rated, the IP address is the IP address of the person rating the item, and Rating, is course their rating for the specific item.

Date Rated is there for a future use. It has no immediate use, primarily because it is outside the scope of this project, but as I mentioned before, it could be used to generate reports in the future.

Step 2 Recap:

Here we defined what we will be tracking, how it will be used, and whether it has immediate or future use. Item Name, IP address, and Rating all have immediate use -- only Date Rated is considered future use.

Step 3: Building the Database and Table
You can opt to create a new Database or use an existing Database; the option is yours and will have no impact on this application. For those wanting to create a new Database, you can use the following MySQL query (replacing the word 'ratings' with your database name):

CREATE DATABASE 'ratings' DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Nothing special about the Database creation, as all of the little details are found in the table. The table will hold all of the information we described in Step 2 above.


CREATE TABLE `rating` (
`item_name` VARCHAR( 20 ) NOT NULL ,
`ip_address` VARCHAR( 15 ) NOT NULL ,
`rating` TINYINT( 1 ) NOT NULL ,
`date_rated` DATE NOT NULL ,
PRIMARY KEY ( `item_name` , `ip_address` )
) ENGINE = MYISAM ;


Notice that the primary keys are "item_name" and "ip_address". This is to help ensure that no "ip_address" can be used to rate the same "item_name". Also notice the lengths of each item. Item Names are not allowed to be more than 20 characters. If you want to have Item Names that are longer than 20 characters, you will need to alter the above statement with the length you want to use (up to 255).

Step 3 Recap:
We defined our Database and table so the rating information can be stored. We set the "item_name" and the "ip_address" columns as our Primary Keys to ensure only one IP address can rate each Item Name. We also defined the max name length for Item Name as 20.

Step 4: Writing our Rating Class
Strong OOP skills are something to never overlook, as they provide you with clever ways of extending your work in the future, plus they focus entirely on being reusable. With that said, you may remember my previous articles "OOP in PHP from a .NET OOP Perspective: The Error Class" and "OOP in PHP from a .NET OOP Perspective: The Database Class." These two articles are going to be used in this project as well. The Error Class will handle any Database errors we might have, and the Database class will handle the Database connection, Query Execution, etc.

To go any further, you will need to download the following file: RatingSystem.zip

After it has downloaded, extract the contents to your computer. You should see a 'RatingSystem' folder. This folder is our example application, go ahead and browse to the RatingSystem > classes folder.

Open the rating.class.php file in any editor. This is the class that will be used to output the rating information to the page and record a rating by a user.

Now I won't get into all of the code here (you'll have to read those other articles), but I will point out a few things.

1. The first thing you should notice is the OutputRating method. This method is what loads the CSS technique written by Paul. If you look at lines 31 and 44, you will see his technique used. I also made a few modifications to it (of which I hope he does not mind, but I will describe those later).
2. Next find the RateItem method (approximately line number 66). This method writes the user's rating to the table. So if you changed the table name, you will want to update the table name in this method as well.
3. On line number 111 is the CalculateAverageRating, this method calculates the average rating of an item within the MySQL statement. Again, if you choose a different table name than described in this article, you will want to update this statement to reflect that change.
4. Finally, I want to point out line number 170, the CheckRatingsByIp method. This is the last place you may have to update the table name if you did not use 'rating'.

Step 4 Recap:
I provided you with the files to run this rating system and gave key pointers on where the table names may need updated if you opted to use a different name.

Step 5: Setting the Database Connection

To set the database connection open the "include.all.php" file in the "classes" folder. Notice the line:

Replace "ratings" with your database name, username with your database username, and password with your database password.

Once finished, save the file.

Step 6: How to output the Rating information to your page
To display the rating information on your page, you will need to do four things.

1. Place the following snippet at the top of your file (for an example, look at 'rating-example.php' in the RatingSystem folder).
   PLAIN TEXT
   PHP:

   1. require_once("classes/include.all.php");

2. Next you need to have the following in your <head> tags:
   
<link type="text/css" href="styles/rating.css" rel="stylesheet" media="all" />
<script type="text/javascript" src="scripts/prototype.js"></script>
<script type="text/javascript" src="scripts/rating.js"></script>


   This code is what sets the stylesheets, AJAX calls, etc. within your page.

3. Next, find the location you want to output your Rating Stars and paste this code:
   PLAIN TEXT
   PHP:

   1. $ratingData = Rating::OutputRating('demo');
   2.  
   3.   if (Error::HasErrors())
   4.   {
   5.     echo Error::ShowErrorMessages();
   6.     Error::ClearErrors();
   7.   }
   8.   else
   9.   {
   10.     echo $ratingData;
   11.   }

4. Finally, end the page with the following code:
   PLAIN TEXT
   PHP:

   1. Database::DeInitialize();

Replace the word 'demo' with the name of your Item. If no errors occur, you should see the 5 stars not lit up when you run the page, otherwise, you will see the error messages that occurred.

Step 5 and 6 Recap:
In Step 5 and 6 we entered the Database connection information, and we pasted our code to show the Rating System for a specific item.

That's it! There isn't anything else needed to get this working. All you have to do is copy the same snippet of code wherever you want it to appear on your page. You can have one item to rate on a page, or you can have 10. Just give them all unique IDs and they can all be on the same page.

Even though you now have a working Rating System, allow me to give you one last walk through of this system.

Crash Course Walk-Through
This walk-through will be based on the "rating-example.php" file from the top-down, not necessarily in processing order.

When your page is loaded, the "classes/include.all.php" file is loaded which establishes your Database connection, initializes the Error class, and allows the Rating class to be used.

Following this, the StyleSheets and JavaScript files are loaded to ensure the Rating System outputs properly and the AJAX capability is setup.

Next the Rating::OutputRating is called to show the rating details of 'demo'. If an error occurred our error messages are shown, otherwise, it will display the stars lighting up the current rating.

Once the processing is finished, the user will see the page generated.

When the user hovers over a rating that they have not rated before, the stars light up appropriately.

Finally, when the user clicks a star, it is recorded and the average rating is shown to the user with green stars. Note that even if the user hovers over the stars, they will not light up because they have already cast their vote and rated that item.

Now this is where I altered Paul's code. I created a new class called 'rated' (found in the "styles/rating.css") that does not contain the hover effect. This way if the user already rated an item, they do not the see the hover effect for the item they rated.

When the user clicks on a star, an AJAX event is sent, the rating is calculated, and then the information is returned in a Name/Value pair. For example, it might return: "item=demo&classes=rated threestar". Simply put, it means the user clicked on the 'demo' item, and the new classes to use on that item are 'rated' and 'threestar'. The class "rated" defines the user has rated that item, and no longer provides the hover effect, and the class "threestar" is the average rating for the item, so it is to light up three green stars.

Conclusion:
That ends the task of providing a functional Rating System using Paul's CSS Star Matrix Pre-Loaded technique. I want to thank Paul for the excellent CSS work, and hopefully I have done it a bit more justice by adding the back-end functionality.

Feel free to leave any comments, remarks, questions, etc. as I will be happy to answer them.

What language should I use to program my next project?

As someone who has been on a few of said forums, mailing lists, and chatrooms for a while now, I hate seeing this question. Yes, it comes around a lot, but repetitiveness isn't what bugs me about it. What bothers me is that there's usually very little background information attached to that question, which makes it as open-ended as asking what mode of transportation you should take to get to the store. I can tell you anything from a skateboard to a jet and either vehicle can get you to the store, but to give you the best answer I need to know how far you have to travel, what you plan on buying, and how much money you have, among other things. The same holds true for the programming language question, so let's look at some factors that can help you choose which language to use on your next project.

What do you want to build?

This should be the first question you ask yourself when choosing a language, because some languages are better at some things over others, and some language just plain can't work in certain contexts. Are you building a desktop application? If so, you might want to look at a language like C++ or Visual Basic over say, PHP. Conversely, for a web application, PHP or Ruby (optionally with a nice framework like Rails or Symfony) will get you up and running much faster than trying to write your own CGI handler in C.

Some languages, like C# or Java, try to do it all, so this question may not lead to one clear answer for you if those are among your options. Keep them in mind, and try to filter your selection down with the following questions.

What platform(s) am I going to be running on?

This is almost as big of a decision-maker as the kind of program you're writing. Some languages only work well on one platform, so if you're on another platform the choice gets limited pretty quickly. For example, if you're writing a Windows program you might not want to learn Objective-C and Cocoa, which is a programming framework for Mac applications. Conversely, if you're building a website that is intended to run on a Linux server, PHP is a much better option than C#. Many languages, like Python and Java, are cross-platform, so at first it may not look like it matters, but look closer. Some server-side languages might "work" on Windows, but with Apache and not IIS, or may not perform well on Windows relative to Linux/OS X. Yes, it might still be possible to work in a language on a second-class platform, but it might be more painful than it's worth.

What do I already know? Do I like it?

Prior experience is also a good way to gauge which language you should use. If you like a C-style syntax, the style of a language like Ruby or Visual Basic might make you scream and run back to the safety of curly braces and semicolons. On the other hand, if you've been writing Java code for the last 7 years and are TiredOfTheVerbosityOfItAll, then maybe a more terse language like Python would be a nice change of pace.

Does the language have features for my project?

Look at your project and see what your needs are. Is it a simple frontend to a database with a couple of forms? Well, just about any language is capable of handling something like that nowadays. Do you have to deal with processing large amounts of text? Well, Perl was built just for that so maybe it's worth a look. Different project requirements may make you decide to switch it up.

To conclude...

I'm not here to tell you which language you should choose. You and I may look at the same project and end up with two completely different ideas about which language is best to go with. I don't expect people to run through this process every time they come across a new project, but hopefully this article gives you something to think about when you decide you want to start playing with another programming language.

This time I am going to talk about the Database class, as every project now-a-days typically stores their information in a database. A good database class can save you time and memory in retrieving results. It should be able to cache previous queries, to recall them later, and it should clear out the results from memory when they are no longer needed.

As with previous articles, it should be stated that the below code will only work using PHP 5.

In this article, I am going to post my code first and then give a break down of the important segments. Again, this is my take on solving a problem for my applications and I am sure there are other approaches, but this is the one I am most pleased with.

That is the Database class I use in my primary applications, note that it currently only has support for MySQL and MySQLi, but it could be extended to use Postgres and ODBC easily. Considering you never know what applications or platforms you may be writing for, let this be the first lesson. Always, write your classes to work on any platform. If your first project targets only a single platform, that is fine, but make it so it can be extended to fit another platform without having to rewrite significant portions of your original code. Let's face it, if you had to rewrite significant portions, you would create a new file for each platform because you would not want to go back into previous projects and update the implementation of your classes.

Let's start out with the constant variable being used.

This is where the extensibility starts. Each different platform will be separated by a comma. Below the constants are the private variables for the class, and I will describe those as they are used. Now like the Error class, the Database class has an 'Initialize()' method too.

One difference between the Error class's 'Initialize()' method and the Database class's, is that the Database class requires parameters to be sent. This class needs to know a few things, which is why the parameters are required. It needs to know the type of platform being used, the server name/ip address, the port number, the database name, the username to connect, and the password for the username.

Notice, that I use the Database's 'Initialize()' method to initialize the Error class. Since I know all of my applications will be using a Database, this is a good approach for me, however, if you wish to use the Error class in applications that do not have a Database, then I strongly suggest taking the Error::Initialize() out of the above code and into a more global area.

Next, the Database Type needed to be validated. To do that, we call a private method named 'ValidDatabaseTypes' and pass it the type of database (or platform). In this case, it should be either 'mysql' or 'mysqli'.

This code is very basic, it simply looks to find the Database type passed to 'Initialize()' inside the constant string 'DB_TYPES'. If it finds the type, then it will return "true", otherwise, it will return "false". If it returns "false", it will then log an error, using the Error class, stating such.

After the database type the "Initialize" method then stores the information passed into the class variables. The last variable stores the connection reference using the "ConnectToDatabase".

The "ConnectToDatabase" method takes the type of database, which was stored in the "Initialize" method into the self::$type variable, and then runs the appropriate connection function in PHP returning the resource identifier to be stored back into the variable.

You may be wondering why I am returning the connection information, instead of just setting it in the "ConnectToDatabase" method. I prefer to have any private methods I write return back the information to my public methods so I am not second guessing where a variable got set. So it is strictly a readability reasoning and definitely a personal preference.

Back to the Database class, I finished off the "Initialize" method by running the "SelectTheDatabse" to select the Database to use.

Again, this takes the self::$type variable to define which function to run. Notice that the "mysqli" type is not listed in here. This is because with "mysqli" you have the ability to specify the database name in the mysqli_connect function.

Now that the "Initialize" method is out of the way and the private methods associated with it, we can start to focus on executing a query, fetching the results of an executed query, freeing the results of a query, and removing the cached results.

The "ExecuteQuery" which receives two parameters (the query, and a name/identifier for the query). The name/identifier will be used later for fetching the results. In short, it will also help cache the results to be retrieved later.

Before the query can be executed, it needs to ensure the connection to the database succeeded. Following that, there needs to be a name/identifier to store the query resource in. Each query resource will be stored in the self::$savedQueries array. This will save memory resources. Let's say you wrote a modular application and two modules need to run the same query. No matter which order they run in, when the first module runs the query, it will save the resource identifier of the query into self::$savedQueries and then the second module using the same identifier for the query execution will find that it was already executed and reuse the same query data. Thus, there was only one hit on the database for the query instead of two.

A similar approached was used in the "FetchResults" method too. Notice that only the identifier is passed to this method, as it will pull the query resource out of the self::$savedQueries and build a results array or it will pull the results from self::$savedResults and reuse what it retrieved earlier.

Just like the "ExecuteQuery" method, you can reuse any previous identifiers so long as they still exist in self::$savedResults. All of the information from each query will be stored in this variable until it is cleared out using "RemoveSavedResults" which will be discussed a bit later. Before we discuss that, I want to point out the necessity of the "FreeResults" method.

MySQL keeps results in memory until requested to free them. This is where the "FreeResults" method comes into play. It is a VERY good idea to clean out the memory space as soon as you can, hence why we are caching the results into an array to be reused. Note, that once you free the results, they will be unretrieveable using the Query Identifier returned by mysql_query and mysqli_query so the only way to reuse the previous information is to get it from "FetchResults". The "FetchResults" will grab it from self::$savedResults instead of self::$savedQueries.

Notice that it ensures the identifier exists in self::$savedQueries and if it does, it clears out the result information from MySQL and it removes itself from self::$savedQueries.

Now that takes care of the memory allocations by MySQL, but what if you are done with the results you fetched from MySQL and no longer want them cached for other pieces of your application? Well, I arranged a method for that purpose too. Enter "RemoveSavedResults".

This method is short and sweet. It checks that the identifier exists in self::$savedResults and then it removes the information stored under that identifier so it is no longer cached for the rest of the application's execution.

Wrapping it up...
There are a few other public methods in this class, but they are not very important to an application's design. They are there because I have found use for them within my own applications, and so you can keep them or remove them, it's up to you. Oh, and one of the MOST important pieces, the "DeInitialize" method. This should be executed at the end of your application's execution. This way, if you have multiple developers working on your project and one of them forgets to run "RemoveSavedResults" or "FreeResults", the "DeInitialize" method will ensure the information is cleared out and it ensures the Database connection is closed.

Well this concludes Part 3 of my series, and Part 4 will be focusing on a Design class. The idea behind a Design class, is to give your application a template based structure, so you can support multiple designs. Plus it will allow you to create a modular application, so you are programming pieces of the application rather than the whole. I realize that may sound confusing, but you will have to read my next part to get a firmer understanding.

Update: Sample of Use

With that said, I am going to outline the base classes that I referred to in the first article. To start out I will talk about the Error class, as if you do not have a good error handling setup, your application is doomed from the beginning.

It should also be stated that the below code will only work using PHP 5.

The Error class is probably the most important class you will ever write, as any error your application needs to throw should have a standard way of taking care of it. So the basic things you will need is a way to report the error, a way to view the error(s), and a way to determine if there is an error. Likewise, I designed the Error class to also accept Warnings. Items that are not errors but should be noted as a potential hazard or caution.

First I will start with the variables. Note that everything is marked "private static". This simply means, all of the variables can only be accessed within the class and that their values will be kept between all instances of the class.

Now let's discuss the variables.
$title = This is going to be an array for each Error's Title that is thrown.
$type = This is going to be either 'Error' or 'Warning' so it designates which was thrown.
$description = This will be an array for each Error's Description that is thrown.
$datetime = This is the error/warning date and time of when the error or warning was thrown.

These four arrays must keep in sync with each other, so every time an error/warning is logged, an element is added to each array.

$numErrors = Stores the number of errors currently logged.
$numWarnings = Stores the number of warnings currently logged.

Since the variables are now defined, lets work on the methods for the class. The first method is written to initialize all of the static variables. In layman's terms, it's to ensure all of the arrays start as empty and the counters start at zero.

To call your method you would use Error::Initialize();. Notice that there are no variables, just the class name followed by :: and the method name. This is due to the method being static and therefore you do not have to set a variable to interact with the class.

Like any good programmer, I also write a method to clear out the variables at the end of the execution.

Simply put, this ensures all of the variables are back to the values they started with in PHP. Hence why we wrote an "Initialize" method. Error::DeInitialize(); should ONLY be called when you are through with the errors/warnings generated by your application, otherwise, you will be wiping out all of the errors/warnings caught during execution.

Now you need ways of logging the Errors and Warnings, so those methods are as follows:

Just like the prior methods, calling these is no different other than you are to pass two parameters. For example, Error::LogError("Title", "Description");. Now the Error class is shaping up to take on its role, however, it needs a few more methods to put it into practice. As right now, what if we want to know if any errors/warnings have occurred? How about displaying all of the errors/warnings that have occurred? Finally, what if you only want to retrieve the last error thrown or what if you want to clear out the errors and warnings? Well, that is what the below does, and of course, feel free to extend it to your heart's content.

As stated at the beginning, your application will need a way to handle errors, and maybe even warnings. The above class, is one approach and the one I use in my applications. It definitely is not the only approach, so feel free to comment on error classes you have used in your applications.

I'm a programmer (PHP and C#), but am really average at best. You aren't going to get some life-changing "aha" code examples from me. I do try hard and I'm always trying to learn better practices. I am a firm believer in knowledge is power and the more knowledge I have on a certain topic, say OOP in PHP for example, the better armed I am for battle! What I love about programming is solving problems and of course just the ability to make things happen. My favorite part of the lifecycle is the application and database design. So, there is a good chance you will see some examples of design documents from me.

I'm a blogger and am completely fascinated with how blogging and other forms of social media are changing the way businesses, well, do business. I have several places I blog at, both personally and professionally, so you may say I'm a bit of an addict. When Mark waved the needle in my face, it was hard to resist . You are likely to see me write about topics like this and I will try to illustrate how businesses can integrate blogging and social networking sites into their marketing plans.

I'm a business-woman. I am a partner in a Web development company, brainyminds. I started the business 4 years ago and we provide web development services to businesses and individuals. We were recently recognized as an Authorize.net Certified Developer, which is pretty cool as there are currently only 12 other companies who we share that title with. I may talk about working with clients, bidding on projects, and documentation.

I'm a life-long learner. A big reason I got into this field is because it will always be changing, providing me ample opportunity to continue learning. I may write reviews of industry-related books that I'm reading or share some great info that I have found that has helped me. I like to learn, but I also like to share what I've learned. From the search engine perspective, the most frequent terms that lead people to my personal site, ilovecode are error codes from people who have encountered an error in their code. I have posted examples of errors I have encountered and their solutions. It makes me happy if I can save other people of going through the frustration that I've encountered. I may share those here as well.

I'm a wannabe website publisher. This statement may be confusing as I already own websites that I've built, but what I really want to do is launch some websites that can earn decent recurring revenue. There are so many topics that I could talk about related to this field. SEO is something I am continually trying to improve on. I know the basics and I employ them, but there will ALWAYS be room for improvement. Ad networks is another area that could be discussed. I am a complete novice when it comes to making money from your websites using advertisements. I will talk in general about my experiences and also seek advice from you! There are several other topics that I will hit on too. I have a content website in the works currently so be prepared for me to talk about that, successes and failures both.

Hopefully that gives you a glimpse of what to expect from me. I look forward to starting a conversation with you.. after all, that is what blogging is about, the conversation. So, don't be afraid to comment!

Having Sara join the team will most certainly benefit the Search-This readers. It's nice to get the female perspective on things and Sara isn't one to hold back her opinion. Just look at her new WordPress plugin simply titled "Ask Me" which allows users to forgo the typical "About Me" page of their blog and replace it with a "Ask Me" section that allows readers to get a more intimate view into the blogs author.

Enjoy Sara's bio below:

User Name: ses5909

• childhood ambition: so many but mainly an astronaut and a forensic investigator (I was addicted to serial killer books)
• fondest memory: my kids being born
• favorite music: I like rock/alternative mainly but am open to other music
• retreat: kayaking in Monterey bay
• proudest moment: I have lots. Im most proud when I see my kids. Sounds cliché I know, but its true. Kids really change your life
• biggest challenge: staying focused
• alarm clock: my dogs
• perfect day: being outside and enjoying the fresh air with my best friend
• first job: sold admittance to a softball field when I was 14
• indulgence: ice cream
• favorite movie: What about bob
• inspiration: life

See in PHP 4, everything was fairly easy to organize so long as you created functions for the tasks you did repeatedly, which is also known as "refactoring". You can say the same concept holds true in an OOP environment, but it is also different. It is different in the sense you have to classify the functionality enough to associate it with a class. One could argue you could still write a function, but I decided to go 100% OOP and stray away from functions just for the shear challenge, be it right or wrong.

The first challenge I found myself occupied with was the number of classes I would potentially need. For my projects I came up with a few obvious ones, such as, a Session class, Database class, Design class, and an Error class. The next challenge I had to think about was how to setup each class. Should they be made of static properties/functions/methods (take your pick), or should it be an object that requires being Instantiated (meaning, you have to create an instance of the object before you can call any of its properties/functions/methods)?

This posed a serious question regarding PHP and how it handles static objects. See at work we use .NET and primarily code in C#. .NET is considered to be extremely OOP, and that is primarily because of how you are to develop in it. Every page you make is a class, and all refactoring you do will be in another class. However, when you work with static objects in .NET only ONE of those objects exist on each server your application is running. This can become havoc in a multi-threaded environment. If your static method isn't fast enough, you may lock out another process because the prior one isn't finished yet. So it is no wonder I came to the question of whether or not this holds true to PHP.

The answer is 'Yes' and 'No', I think. See in .NET this issue holds true because the code is already compiled and the ASP.NET handler caches the compiled version and keeps the static object in memory until the Garbage Collector deems it unworthy and tosses it out. In PHP, the code is compiled when requested, so would this mean each thread has its own static methods? Why yes it would, so how can the answer be both 'Yes' and 'No'? Well, I answered 'Yes' as well as you have to take into account the other aspects of the server. Whose to say that PHP like .NET after compiling the static object decides to keep it in memory instead of destroying it with the non-static objects? No one. And I have yet to find any documentation that provides me with a solid answer one way or another. So, I answer the question as 'Yes' and 'No', but how did this help my decision process? It didn't.

My decision was still tough and I just decided I would take the approach of using both static and non-static objects. The Database, Design, and Error classes would be static, as I could careless if the object is shared across all threads (requests) or just each individual thread. Think of it this way, if it is shared across all threads then the Design will be caught in memory and load that much faster for User #2-#5 as the hard work was done by User #1. The Database connection is not going to change between each request either, so I lose nothing by that being shared either, and as for the Error class, this is for server errors, such as, failure to connect to the database or maybe an outside resource the application is using is not being responsive and will cause the application to not function properly. All of these can work in an environment where the information is shared across each request (like .NET) or if each request had its' own individual static object.

So why leave the Session class as non-static? The session class is supposed to be unique for each request. Each user will have his/her own Session object. It is a collection of information, such as, the User Account they used to login, or their Checkout Details if used for a Store. This information should NEVER be shared across requests. Hence, it is a instantiated object.

I have received several questions as to why I created a Session class to begin with, and it again goes back to wanting to write a fully OOP application based on my .NET experience. See PHP 5, PHP 4, and PHP 3 have this nice function called "serialize" and its' opposite "unserialize". This allows me to create an object of any type with however number of variables I want and turn it into a string representation. Likewise, after it has been serialized, you can return it back to the object type using the "unserialize" function.

A part of me has to attribute this to what I have learned at work, as that is where this initial idea came about. Why force the language to have to read the header three or four times to get three or four session variables individually, if you can request the entire set of data once and unserialize it back into an instantiated object? Speed wise, depending how much information you keep in session, you could be saving a lot of system resources. Likewise, you could be wasting a lot of your time as I speculate PHP does this for you. The $_SESSION variable is an array of information and I am certain it serializes that array into the browser header for you and unserializes it back out, so is there a reason to do it again? Probably not, but if PHP does not automatically do this, then the benefits are of great value to serialize an object and store it in a single $_SESSION variable.

After defining my base classes, I quickly noted that these could be used in any project, so it would be AWESOME if I could reuse them in every project I make, but not have to copy them. For this I do not have a solution yet. Partially because every application you deploy, or allow others to download, will need these files and thus it makes more sense to store them with each project. The point here, is if your project is for internal use only (meaning your own application and will not be distributed), then by all means, store the shareable files in a directory that your other projects can take advantage of. Therefore you do not have to create copies of your database connection class, or similar classes you may need. Since my project is distributed freely, I have to make copies of these files to use in this particular application.

In Conclusion...
So as you can see, designing an OOP application, be it in PHP or .NET, requires making important decisions right at the beginning. Determining the right time to use static methods vs non-static is crucial and there are right and wrong times for both. Likewise, keeping in mind the deployment process of your application will determine where you store your files that can be reused. If it is for internal only, then by all means, do not store them with a particular project, make them more accessible at a root level, however, if your application will be downloaded freely over the Internet, then your best choice is to store a copy of each file with each project you make.

Keep an eye out for my next writing as I will go into more detail on each of my four primary classes and how I made them so they would work with any project I design in the future.

Matt's passion has always been as a coder. Now that Matt has graduated college and become a full time software engineer there's not many languages he hasn't worked with.

Look for Matt's, or rather cpradio's first article this Monday titled: "OOP in PHP from a .NET OOP Perspective" - should be a good read.

I can't really welcome cpradio as a new member to the team, because he has always been part of the team. So just enjoy his bio below.

User Name: cpradio

• childhood ambition: to be a software developer, seriously, it was...
• fondest memory: looking at my old code and just realizing what an idiot I was back then
• favorite music: anything but elevator music, seriously, how do you not fall asleep to elevator music?
• retreat: hiking in the smokies
• proudest moment: three weeks of hammering an application, countless thankful users
• biggest challenge: writing quote engines for an insurance company and making it easy to maintain
• alarm clock: 6:30 AM on a good day, 4:30 AM on implementation day (project going to production)
• perfect day: my wife told me it was her wedding day, err... our wedding day.
• first job: PetsMart stocker/fork-lift driver
• indulgence: hard drives, I have 10 (in one PC) equaling 1.8 TB but that is not enough
• favorite movie: geez, I can't just pick one, that would be unfair to the rest of them
• inspiration: knowing knowledge has no limits other than a person's refusal to continue learning