It should be noted that this setting DOES NOT suppress the error. Even if the directive is set to ‘Off’ (do not display errors) errors which occur in a script are still triggered and will be processed by the error handler.

</IMPORTANT>

 
PHP does not offer a special display_errors function, but by using the ini_set() function we can control the setting of this directive within our script. The function signature looks like this:

string ini_set ( string $varname , string $newvalue )

blah, blah

The configuration option I would like to address in this article is, of course, error_reporting.

Let’s start digging.

error_reporting

The error_reporting directive (within the PHP ini file) allows you to set the level of errors reported by PHP. By default this is set to ‘E_ALL & ~E_NOTICE’. This ‘tells’ PHP to report all errors, except Notices.

PHP provides a built-in function for getting and setting the error_reporting level: error_reporting(). The function signature looks like this:

int error_reporting ([ int $level ] )

The function accepts one optional argument, a new error reporting level, and returns the old error reporting level. Although the signiture shows that the function accepts an integer, the new level sent can be represented by a predefined constant. In fact it is recommended that you use the predefined constants to ensure future compatibility.

The available constants can be used in combination to build up a bitmask; the bitmask tells PHP which errors to report and which to suppress. Since these constants are actually bitmasks, you will need to use bitwise operators when combining them.

An example of the error reporting setting I use in development is:

$old_setting = error_reporting(E_ALL | E_STRICT);

From the predefined constants chart the setting E_ALL equates to the integer 30719 and means:

All errors and warnings, as supported, except of level E_STRICT in PHP < 6.

From the predefined constants chart the setting E_STRICT equates to the integer 2048 and means:

Enable to have PHP suggest changes to your code which will ensure the best interoperability and forward compatibility of your code.

So basically, this tell PHP to report all errors, notices, and messages generated at the E_STRICT level.

Back to the code…

The variable $old_setting will now be set to: 6135, the default setting for error reporting (using the predefined constants again that would be: E_ALL & ~E_NOTICE).

A small code example:

<?php
//get the current error reporting setting
$current_setting = error_reporting();

//check if error reporting is set to E_ALL | E_STRICT
if (8191 != $current_setting) {
    //not set to E_ALL | E_STRICT make it so
    error_reporting(E_ALL | E_STRICT);
}

//display new error reporting setting

echo error_reporting(); //displays 8191
?>

A more useful example would be to change the error_reporting setting based on the environment the script is being run in.

Let’s say you have a configuration file which defines the constant ‘ENV’, this can be set to ‘production’ (live site) or ‘development’. If the script is run in production then we want to use ‘E_ALL & ~E_NOTICE’ (default), but when running in development we want to use E_ALL | E_STRICT.

config.php:

<?php

//define enviroment
define('ENV', 'development');

Script File:

<?php

//load configuration file
require_once('config.php');

//check ENV constant to see if running in development
if ('development' == ENV) {
    //running in development so change default setting
    error_reporting(E_ALL | E_STRICT);
    //now all errors, notices, and suggestions will be reported
}

That’s it! I’m sure you can see how useful this function can be.

Side Note: If you are unsure what a bitmask is or are unfamiliar with bitwise operators, you may want to checkout this post from joestump.net.

When I first started learning about errors and error handling I found numerous tutorials on the topic, but none that provided a complete resource on the subject. This is understandable; since the topic is so broad one tutorial would not only be extremely long, it might also seem overwhelming to someone who just started learning about the topic. This is also the reason it would make a great topic to cover on a blog, where a series of posts can be created, each building on the information presented in the previous post ending with a comprehensive  resource. (OK, comprehensive maybe a little strong but hopefully it will be close.)

The intended outline for the series is:

Resource Information

• Error Messages Deciphered (Revised)
• Error Reporting
• Displaying Errors
• Error Logging
• Backtrace Functions
• Triggering Errors
• Understanding Exceptions

Implementation

• Creating A Custom Error Handler
• Utilizing Exceptions
• Creating an Exception Hierarchy

Putting it all together

• Error Handling Strategies

If your using twitter and are reading this blog I’m sure you are aware of hashphp. If not, it is a twitter account which grabs most of the tweets with the hashtag ‘#php’ and re-tweets the messages. Since this seemed like a fairly simple thing to do I decided to create my own twitter feeder. Again, I was just hacking together a script, so if you use the code presented you will want to make some enhancements before letting it into the wild. (Please see end of post.)

First, I decided to pick a hastag which was used in the range of 3 – 5 times every 15 minutes; ‘#mysql’ seemed to fit the bill.

Now I needed a twitter account to re-tweet the messages, and a bit.ly account to create short URLs to link back to the original account that posted the message. I created a ‘poundmysql’ account (The number sign ‘#’ is sometimes referred to as the ‘pound’ sign in the US), then I went to bit.ly and signed up for an account.

Continuing to gather the pieces of the puzzle, I looked through the published PHP libraries on twitter and found one which did exactly what I needed. There were other more robust scripts, but I only needed to update an account status so grabbed the package Twitter by Felix Oghina. The next piece came in the way of the Bitly class, written by Ruslanas Balciunas. (I apologize to Ruslanas Balciunas but my current character set in MySQL will not allow for a proper spelling of the last name.)

Next, I needed to be able to retrieve all the tweets which contained the string #mysql. Twitter offers a Search API which would do the job, but for my purposes search.twitter was the faster option. They offer an XML feed to any search so I only needed to search #mysql and grab the URL of the feed, which is:

http://search.twitter.com/search.atom?q=%23mysql

As you can see the search term is contained in the query string of the URL (URL encoded), which is useful since I could then setup the script to accept any search term.

OK, now with all the pieces of the puzzle at hand I only needed to write the code to fit the pieces together creating my own twitter feeder.

First I grabbed a function which I used in a long ago project [probably also swiped from the internet:)]. The function sends a HTTP request to a server and returns the response.

function url_get($domain, $uri, $referer='')
{
    $header = array();
    $header[] = 'GET '.$uri.' HTTP/1.1';
    $header[] = 'Host: '.$domain;
    $header[] = 'User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US;rv:1.8) Gecko/20051111 Firefox/1.5';
    $header[] = 'Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5';
    $header[] = 'Accept-Language: en-us,en;q=0.5';
    $header[] = 'Accept-Encoding: gzip,deflate';
    $header[] = 'Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7';

    $header[] = 'Keep-Alive: 300';
    $header[] = 'Connection: keep-alive';

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $domain.$uri);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_ENCODING, "");
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
    curl_setopt($ch, CURLOPT_REFERER, $referer);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $header);

    $result['exec'] = curl_exec ($ch);
    $result['info'] = curl_getinfo($ch);

    curl_close ($ch);

    return $result['exec'];
}

As you can see the function accepts three parameters, the domain to connect to ($domain), the path to the requested page ($uri) and the referrer ($referer). This function uses the cURL extension, if your PHP configuration has allow_url_fopen turned on you don’t even need this function (more on that in a minute).

Next I setup the $domain, $uri and $search_term variables, and made the call to the function to get the XML from search.twitter.

//ideally you would put this in a configuration file
$search_term = '#mysql';

//create variables to be sent to the function
$domain = 'search.twitter.com';
$uri    = '/search.atom?q='.urlencode($search_term);

//retrieve the xml response string from search.twitter
$feed = url_get($domain, $uri);
 

Now that the script has the information needed from twitter as an xml string, I can then create a SimpleXML object using the following:

$xml = new SimpleXMLElement($feed);

If allow_url_fopen is set to ‘on’ you could skip directly to creating the SimpleXML object by using the URL as the first parameter and setting the third parameter to TRUE:

$feed = 'http://search.twitter.com/search.atom?q='.urlencode($search_term);

$xml = new SimpleXMLElement($feed, NULL, TRUE);

The tweets in the feed are ordered by the time they were originally posted using the UTC timezone, since this is the case I needed PHP to use UTC when calling date time functions. To do this I used the date_default_timezone_set function.

date_default_timezone_set('UTC');

Next I included the Twitter class and the Bitly class into the script and created new instances of each:

//require the two files which define the classes used
require_once('Twitter.class.php');
require_once('bitly.class.php');

//setup log in information for twitter and bit.ly
//again these should really be kept in a separate config file
//outside the document root
$twit_uname = 'twitter_username';
$twit_pword = 'twitter_password';

$bit_uname = 'bit.ly_username';
$bit_api   = 'bit.ly_api_key';

//instantiate new objects
$twitter = new Twitter($twit_uname, $twit_pword);
$bitly   = new Bitly($bit_uname, $bit_api);

The idea is to loop through the messages received from the search and update the twitter account with any message that was posted within the last 15 minutes. I setup the last run time of the script outside the loop so that it only needs to be calculated once.

//define the number of minutes between each script run
//again this is a setting which should be in the config file
$time_interval = 15;

//get the number of seconds since the UNIX epoch
//and the last script run
$last_run_time = mktime()-($time_interval*60);

The messages can be found in $xml->entry. Within the loop the first check I needed to make was to determine if the twitter feeder account (poundmysql) had posted the message and if so, skip that message.

//setup messages loop
foreach ($xml->entry as $update) {
    //skip any messages set by poundmysql
    if ('poundmysql' == $update->author->name) {
        continue;
    }
...

Next I checked for the time the message was posted and if that time occurs later than 15 minutes ago, I could end the loop and the script itself, since any entries after this would also occur after the 15 minute cutoff point.

...
    //time format in xml string: 2009-07-25T20:32:13Z
    //split time from date
    list($pub_date, $pub_time) = explode('T', $update->published);
    //remove the ending 'Z' from time
    $pub_time = substr($pub_time, 0, -1);

    //get time segments for mktime() call
    list($hour, $minute, $second) = explode(':', $pub_time);
    list($year, $month, $day)     = explode('-', $pub_date);

    //get the number of seconds since the UNIX epoch
    //and the time the message was posted
    $publish_time  = mktime($hour,  $minute, $second,
                            $month, $day,    $year);

    //check if message was later than last run time,
    //if so end loop
    if ($publish_time < $last_run_time) {
        break;
    }

If the message passes these two checks, I know that it will be used in the feeder.

I then create a bit.ly link for the original message ($update->link[0]['href']), and store the character length of the link. Then I grab the content of the message ($update->title) and store that character length.

    //grab url of the original message, create short link, store length
    $link       = (string)$update->link[0]['href'];
    $short_link = ' ..'.$bitly->shortenSingle($link);
    $short_len  = strlen($short_link);

    //grab tweet content store length
    $content     = (string)$update->title;
    $content_len = strlen($content);

Since Twitter has a max character length of 140, I then needed to check what the character length of the new message was with the bit.ly link added, if it was longer than 140, I then needed to cutoff a section of the original message to accommodate the 140 maximum length.

    //total message length
    $len_total = $short_len+$content_len;

    if (140 < $len_total) {
        //determine how many characters over 140
        $over = $len_total-140;

        //remove that many characters from the original message
        $content = substr($content, 0, -$over);
    }

The only thing left to do was to actually update the twitter status.

    $new_status = $content.$short_link;
    //update twitter status
    $twitter->update($new_status);
}
//end loop

That ends the PHP code for my twitter feeder, now I setup a cron job to run every fifteen minutes and I have my own twitter feeder feeding the MySQL community.

Since I didn’t want to actually monitor this feed, I let it run for awhile and once I verified everything was working correctly I deleted the twitter account and stopped the script from running.

A copy of the code used in this post can be found here.

Enhancements

Some updates you will probably want to make before actually using this script for a real twitter account:

• Remove all the configuration options to their own file and store outside the document root.
• Error checking for unavailable third-party services
• Reverse tweets before running the loop. ATM: the script re-tweets in the reverse order the original messages were posted.
• Implement a filtering system so no unwanted messages are inserted into your stream.
• Update the script to use the twitter search API to guarantee that all tweets with your hashtag are captured.

As I’m sure you’re aware Pearsonvue administers the exam. The testing centers are usually apart of other organizations (colleges, tech centers, etc.)

First, I was asked to arrive 15 minutes early so that I could complete the registration process and start my exam ‘on time’. Registration basically consisted of showing two forms of ID and locking away all personal items; including wallets, bags, hats (if I had known this I would’ve combed my hair), and so on. I was then given a laminated piece of paper, a black dry erase marker, and an eraser which I was allowed to use during the exam. The exam ‘proctor’ then lead me to a computer, started the exam application, and wished me luck.

The exam was setup very similar to the practice tests. The screen displays the amount of time left, the current question number and the total number of questions. If you don’t already know, there are 70 questions to be completed in 90 minutes.

For each question you can check a box to mark for review, submit a comment to the test writers, and of course a place to answer the question. Answers range from: true/false, multiple choice, or fill in. Multiple choice can ask for more than one answer or ‘None of the above’ / ‘All of the above’, I hate that.

Since I cannot give you examples of actual questions, or any real detailed information about the questions asked, let just say you definitely need a good basis in the topics listed on the Zend Certification page (scroll to the bottom). You, of course, don’t need to know everything contained in the topics listed, but have the knowledge to make an educated guesses, when you run up against a question you don’t know.

After completing all the questions, a review screen is displayed which tells you the questions marked for review, and whether you answered the question. I get very apprehensive when taking exams, and have a tendency second guess all my answers, consequently my review screen showed that I had marked all but a few questions for review.

You then have options to ‘end the exam’, ‘review the questions marked’, or ‘review all questions’. Since I had about half the exam time left, I chose to review all questions.

On my second pass at the questions, I only left about 5 which I wanted to go over once more if I had the time, which I did.

Upon clicking ‘end exam’, it calculates your score, in about 5 (very long seconds), then displays whether you’ve passed or failed. Since I’m writing this post you should know that I passed, else I would have just never mentioned the exam again .

BTW – If you don’t already know, learn how to convert hexadecimal and octal, you may only have one question which asks, but it is one question you are guaranteed to get right, if you know how.

My first advice it to purchase the Practice tests, which are offered by Zend, and given by php|architect. I was originally just going to study for the exam from the multitude of books I currently own, but 10 tests for $22 USD, I figured WTF.

So far I have taken ( and passed:) ) 4 practice tests. What is most impressive is at the end of the exam, you get a break down of how you did on each section and what your final score would be if this were the real exam. Such as:

For each section (and the final grade) it is possible to receive: fail, pass, or excellent. I believe ‘fail’ and ‘excellent’ are fairly self explanatory. Pass means that you are within a narrow margin of the passing score and may want to refresh your knowledge of the material. As you can see, I need to do some studying on ‘streams and network programming’. Which is why you may have seen my request for a good tutorial about sockets, on twitter.

Another nice thing about the practice test is that you gives you a feel for the type of questions the exam will ask. I don’t want to say they are trick questions, but you really need to read the question and carefully review the code provided, because it is not always as simple as it seems. Let’s just say, if you saw the code in your everyday project you would be scratching your head wondering why the coder made the function so complicated, when it could be written so much more simply.

There is also a study guide published by php|architect. The study guide provides a nice overview of all the topics, divided into chapters corresponding to the sections of the exam. It should not be seen as a comprehensive resource of all the material on the exam, but is intended to provide a synopsis of the material and is sold as such.

You can purchase the study guide, practice tests, and an exam voucher in one bundle on zend.com, if you decide the study guide would be a benefit to you.

If you have already taken the exam, please comment and let everyone what the real exam is like.

Back Story

It seems forums have sort of lost their luster for many; I remember when having a website meant having a forum. At that time it seemed every contract I landed, some portion of the job consisted of integrating a forum into a site. I always hated this job, because at the time PHPBB was the forum of choice and it seemed that there was no ‘right’ way to do it, I had simply developed a bunch of hacks which needed to be scattered around the PHPBB code base and even when complete it was still just a bunch of hacks.

As time moved on, the demand for forums became less and less and I had not done a forum integration in many years. That was until I went to my local PHP users group and ended up with a contract to do a forum integration. I really was not looking forward to the project, but it was a part of a larger job and I’m not one to turn down work.

Luckily the other members of the group convinced the client to use FUDforum developed by Ilia Alshanetsky. I had looked into FUDforum before, had used it as a member of different sites, and assumed the code to be a higher quality simply because of who wrote it, but had never written any code to interact with it.

On Wednesday, the night before I was to do the forum integration I began reading the documentation and planning how I was going to accomplish this task as easily and painlessly as possible. Looking at the sidebar navigation on the documentation wiki, I was surprised to see the heading ‘Integration‘ two clicks later, a quick scan of two different pages, and I knew exactly what needed to be done.

After a few hours of work Thursday morning I had written a script which created accounts in the forums for existing members, I also altered the sign up, login, and logout code of the main site. With these changes the forums were basically integrated into the site, which brings me to the new tutorial series I will be posting over the next week.

Integrating FUDforum

Part 1: Introducing your site to FUD

As time moved on and I became more familiar with PHP I began to stop frequenting PHPBuilder and similar sites, preferring instead to go directly to the PHP documentation and figure out what needed to be done from there. This is both good and bad. I’m sure everyone has seen the comment ‘RTFM‘, but sometimes this is not the best option. The manual will tell you almost all you need to know about the technical specifications, but it will not tell you how different functionality relates and the best practices for using that functionality. This is why tutorials are sometimes a much better resource than the manual itself.

Back to the topic of PHPBuilder. At some point the site fell off my radar, and eventually lost its spot in my bookmarks. I had not visited in numerous years, but it recently appeared in some search results which brought it back to mind, so I decided to take a look around and see what happened to the site.

I am happy to report that the site has remained publishing complete and informative articles on many aspects of programming with PHP and has stayed true to being a resource for PHP developers.

A quick glance at the homepage gives the user a nice snap shot of what is going on in the PHP community as well as new additions to the articles section and the community forums.

There are a number of articles which were written as a series such as Peter Shaw‘s (1) “The ABC’s of PHP” which was written in ten different parts. If your new to PHP and looking for a good primer then I recommend this series. Of course many other topics are covered in the articles section which is broken down into different categories.

I casually browsed the community forums which are alive and well, and seem to have retained the friendly atmosphere I remember. Almost every post has at least one reply, which is always nice to see. One section of the boards that caught my eye was the Code Critique Forum. This is an extremely valuable resource for coders of all levels. I strongly believe this is one of (if not the) best way to become a better coder.

Another section which I do not recall PHPBuilder having is the Code Library. Here you can find code snippets (again broken down into categories) for many of the routine tasks which occur in projects. Even if you are not a fan of using code someone else wrote, reviewing code that others have written is a great way to learn.

Well that is about it, I encourage everyone to go to PHPBuilder and have a look around, I’m sure you will find something you’ve been looking for.

Just an FYI:

I have not and will never accept money for a review of any kind. All the opinions expressed here are mine.

I have been working with this client of a few years now and have a great rapport with them. For this most recent project they have no requirements about which JavaScript library to use just as long as it has the functionality which is required by the project. This left me in a little bit of a dilemma, which JavaScript library should I use?

I have tried many libraries in the past and had used the Yahoo! User Interface Library (YUI) extensively for a previous project. Although it’s a good library I have had the urge to try out Dojo. I first learned about the library when it came coupled with the Zend Framework. After a few small personal projects I never really used either again.

Doing a little research on Dojo‘s current capabilities and verifying that it has the functionality required for my project, I have decided to use Dojo and document my experience here. I’m hoping that even if you currently use a different JavaScript library that this set of posts will inspire you to try something new for a change.

My first task will be to build something similar to the ‘Suggest’ functionality on Google. This afternoon I attempted to find a good tutorial explaining how this is accomplished in Dojo, but could not locate exactly what I wanted. The problem seems to be that all the combo box / auto complete tutorials for dojo create a select menu rather than a simple text box and since this is going to be implemented for a search engine the select menu option is not actually an option. (Get it ‘select menu’, ‘option’…programming humor my wife loves it.)

Over the next few days I will be working on this project and will have one or two more posts detailing how I implement the functionality. If anyone has not heard of Dojo or has never used it here are a few links to get you started.

Dojo Links

• Homepage
• Download
• Documentation
• Hello World Tutorial

My next post will assume you already have Dojo installed and have worked through the ‘Hello World’ tutorial. Here are some brief notes about installing Dojo.

Dojo Installation

When installing Dojo you have three options

• Load the toolkit directly from AOL’s Content Distribution Network (CDN) or from the CDN of Google.
• Download and store the toolkit on your server
• Checkout a copy from the SVN repository (maybe not the greatest idea if your implementing on a live site)

I believe the first two options are completely viable for a live website and each have their pros and cons. I choose to download the toolkit and keep it on my server. The upside is that since I have the files locally I can open them up and browse through the code whenever I would like (you can learn a lot this way).

In my opinion…

When attempting to update an existing site with the newest gadgets available, it is best to take slowly. Implement a few updates at a time, without forcing the users to change the way they use the site. The response received from the users will tell you what is worth it and when you’ve gone too far.

One of my pet peeves is receiving email asking questions which were previously answered. Not only have I answered them before, but half the time the answer is contained in the email which the person decided to reply to.

Surprisingly this does not occur in personal emails between friends and family, it mostly occurs in business, where you would think the emails are actually be read. Not only is it annoying to have to answer questions which have already been answered, but it also takes time away from the current work to read the incoming email and reply, causing a delay (albeit slight) in getting the final product to the client.

My proposed solution is to create a standard reply, stolen from watching too many court shows. Reply:

OBJECTION! Asked and Answered.

Feel free to use this whenever the need should arise or let me know if you’ve come up with a better way to deal with this issue.