I’ve been using CodeIgniter for a couple years now. It’s small, it’s simple, it’s powerful. Admittedly, it’s not perfect (what framework is?) but it’s a wonderful way to slap together a website using MVC design principles and PHP. I do have one big complaint, however.

The Hated $_GET global

The CodeIgniter developers have some strange obsession with killing all GET data. It appears, from the manual at least, that they strongly discourage you from using query strings. For example, the following manual entry states:

By default, URLs in CodeIgniter are designed to be search-engine and human friendly. Rather than using the standard “query string” approach to URLs that is synonymous with dynamic systems, CodeIgniter uses a segment-based approach:

You’ll notice that I have highlighted the words, “By default,…” because you can, in fact, turn on query strings in CodeIgniter, however there is an important trade-off to note (besides saying goodbye to those pretty URL’s:)

Please note: If you are using query strings you will have to build your own URLs, rather than utilizing the URL helpers (and other helpers that generate URLs, like some of the form helpers) as these are designed to work with segment based URLs.

Okay, admittedly, it’s not a big deal to build your own URL’s. I mean we used to do that all the time, right? However, what if you have used the “default method” of the segment-based approach and suddenly you need to pass GET values to your CodeIgniter application? Let’s also say that you’ve used many of those helpful URL functions, etc. Now, for the cost of enabling query strings, in the manner indicated by the manual, for that one page, you’ve got plenty of re-factoring to do! Not cool.

I know this sounds like a fantasy scenario, but it’s real. It happened to me. On two different occasions, working with two different payment gateway API’s, I suddenly had to provide postback URL’s. In both instances, the postback URL’s that were directed to my website, attached query-string variables to the URL in order to provide the relevant data (receipt number, etc.) Obviously, this is something I had no control over because I had to adhere to the API convention and they didn’t offer alternatives for “segment-based” Web frameworks!  I realize that I could have used a standalone script to handle these requests, but that could be potentially confusing for future developers (including myself after a few months) because the standalone script would reside outside of the framework. Also, I have based the entire application on the framework. The framework keeps my code organized in a way. I don’t want to have to use scripts that do not adhere to my conventions. I want to use the framework for all my code! More importantly, what about my models, libraries, helpers, etc? The framework shouldn’t force you to make the decision not to use it. It should, at least, provide a way to use a long-establish standard without compromising one of the best benefits of the framework.

I can understand disabling the $_GET super global (and query-string usage) by default when the whole framework is geared towards segment-based URL’s. What I can’t understand is why they make it so hard to enable query strings for situations when you might actually need them. There is no simple configuration Boolean variable you can flip on and off!

So, why can’t we just specify a controller/method URI and tack on a query string? Admittedly, this gets a little complex to depend on with mod_rewrite and other factors outside of the control of the CodeIgniter developers. However, no attempt has been made to allow for the possibility. For an explanation, let’s go back to the manual:

The security filtering function is called automatically when a new controller is invoked. It does the following:

• Destroys the global GET array. Since CodeIgniter does not utilize GET strings, there is no reason to allow it.
• Destroys all global variables in the event register_globals is turned on.

Okay, clearly there is a reason to allow it! I think we can tally up the real reasons behind destroying query string data to a matter of programmer laziness! I know that sounds harsh, but the manual clearly states (to paraphrase,) “Let’s not bother with storing GET data anywhere in the CodeIgniter super object because we don’t use it anyway. Phew, don’t have to worry about that anymore!”

Let’s put it back! Methods for enabling $_GET in CodeIgniter

Luckily, there are a few ways we can use GET variables without having to give up the segment-based approach (and all those nice URL functions!)

Method 1: Extend The Input Class

If you want to enable codeigniter to get query string variables globally, you can do it with a few easy steps:

1. Create a MY_Input class in application/libraries
2. Update your application/config/config.php file: Change $config['uri_protocol']  to  “PATH_INFO”
3. If you are using mod_rewrite to hide index.php, make sure you have a slash in your rule after index.php: RewriteRule ^(.*)$ index.php/$1 [L]

application/libraries/MY_Input.php

<?php
// this class extension allows for $_GET access
class MY_Input extends CI_input {
 
    function _sanitize_globals()
    {
        // setting allow_get_array to true is
	// the only real modification
        $this->allow_get_array = TRUE;
 
        parent::_sanitize_globals();
    }
 
}
/* End of file MY_Input.php */
/* Location: .application/libraries/MY_Input.php */

Changes to application/config/config.php

/*
|--------------------------------------------------------------------------
| URI PROTOCOL
|--------------------------------------------------------------------------
|
| This item determines which server global should be used to retrieve the
| URI string. The default setting of "AUTO" works for most servers.
| If your links do not seem to work, try one of the other delicious flavors:
|
| 'AUTO' Default - auto detects
| 'PATH_INFO' Uses the PATH_INFO
| 'QUERY_STRING' Uses the QUERY_STRING
| 'REQUEST_URI' Uses the REQUEST_URI
| 'ORIG_PATH_INFO' Uses the ORIG_PATH_INFO
|
*/
$config['uri_protocol'] = "PATH_INFO";

When using mod_rewrite

If you’re hiding index.php with mod_rewrite, make sure you use a slash after index.php. I could never make this work with PATH_INFO configured until I pulled out the question mark (?) in my RewriteRule.

Slash only. Change ?/ to / if there.

RewriteRule ^(.*)$ index.php/$1 [L]

Using the get method of the Input class

The nice part about this method is that you can refer to get variables using the input class. This has the advantage of easily utilizing the cross-site-scripting tools in the Input class (and keeping with the “CodeIgniter way” of doing things.)

Use the get method of the Input class

<?php echo 'Using Input class with XSS protection: ' .
	$this->input->get('foo', TRUE);?>

Conclusion

I had to do some “tinkering” to get this method to work; but in the end, it’s a fairly simple hack that requires minimal changes.

Our next method requires no configuration changes nor extended libraries whatsoever.

Method 2: Use parse_str to Grab GET data out of REQUEST_URI

This method should, perhaps, be subtitled, “The Quick and Dirty Method” as it’s extremely easy to implement: one line of code.

Despite what the manual states, CodeIgniter fails to destroy all global variables. For example, $_SERVER['REQUEST_URI']   shows what was given from the browser as the URL path. (Example: /controller/method?foo=bar.)

Having this data, we can use PHP’s parse_str function to parse $_SERVER['REQUEST_URI'] and rebuild the $_GET array. We also have to utilize substr to strip away the /controller/method part. Otherwise, we’ll end up with a $_GET key similar to “/controller/method?foo” when we just want our associative array key to be “foo.” It’s important to note that we can still use the fabulous Input class to filter our query-string data (it’s just not quite as pretty) against cross-site-scripting attacks.

Use parse_str to rebuild $_GET

<?php
//Remove everything before (and including)
//the question mark and then parse into $_GET array.
parse_str(substr(strrchr($_SERVER['REQUEST_URI'], "?"), 1), $_GET);
echo ' Using rebuilt $_GET array with xss protection: ' .
	$this->input->xss_clean($_GET['foo']);
?>

My preference because it’s a “genuine hack”

I should note that this is the method I used for my payment gateway postbacks. In my particular situation, this was the best fit because I needed query-string variables for a single URL in the entire site. I really didn’t want to have to extend CodeIgniter or change my Apache settings for one URL (I’m fine with segment-based URL’s as long as they’re in my control.) I just put this one line of code in my controller method where it was needed.

If you don’t want the bother of dropping this code into each one of your controller methods, you can easily incorporate this into a helper function and make a simple function call any time you need $_GET. If you want to enable rebuilding $_GET globally, you can also take advantage of setting this code up in a pre_controller hook.

The best part of this method is that it works with CodeIgniter out-of-the-box. No configuration changes or extended libraries should be necessary. Always a “plus” in my book.

To pull this off, you’ll need to slightly modify two configuration files (config.php and hooks.php) and then create another with a “hook” function (google_analytics.php.)

First, create a file named google_analytics.php and place it inside your application/hooks folder. We’ll reference this file later when we do our hooks configuration from within application/config/hooks.php.

google_analytics.php

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 
if ( !function_exists('insert_ga_script') ) {
    function insert_ga_script($account_id) {
        /***NOTE: This hook replaces the _display
        * method in the Output Class. I have
        * not made provisions for caching nor compression!
        */
 
        $CI =& get_instance();
        $output = $CI->output->get_output();
 
        //keep performance templates in...
        $elapsed = $CI->benchmark->elapsed_time('total_execution_time_start', 'total_execution_time_end');
        $output = str_replace('{elapsed_time}', $elapsed, $output);
 
        $memory	 = ( ! function_exists('memory_get_usage')) ? '0' : round(memory_get_usage()/1024/1024, 2).'MB';
        $output = str_replace('{memory_usage}', $memory, $output);
 
        // keep profiler working
        if ($CI->output->enable_profiler == TRUE) {
            $CI->load->library('profiler');
            // If the output data contains closing </body> and </html> tags
            // we will remove them and add them back after we insert the profile data
            if (preg_match("|</body>.*?</html>|is", $output)){
                $output  = preg_replace("|</body>.*?</html>|is", '', $output);
                $output .= $CI->profiler->run();
                $output .= '</body></html>';
            } else  {
                $output .= $CI->profiler->run();
            }
        }
 
        // if no account information just return the output
        if ( empty ($account_id) ) {
            // keep _output methods working...
            if (method_exists($CI, '_output')) {
                $CI->_output($output);
            } else {
                echo $output;  // Send it to the browser!
            }
            return ;
        }
        ob_start();
        ?>
    <!--Begin Google Analytics Site Code-->
    <script type="text/javascript">
    var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
    document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
    </script>
    <script type="text/javascript">
    try {
      var pageTracker = _gat._getTracker("<?=$account_id?>");
      pageTracker._initData();
      pageTracker._trackPageview();
    } catch(err) {}
    </script>
    <!--End Google Analytics Site Code-->
        <?php
        $script = ob_get_clean();
        //insert the script
        $output = str_replace('</html>', $script . "\n</html>", $output);
 
        // keep _output methods working...
        if (method_exists($CI, '_output')) {
            $CI->_output($output);
        } else {
            echo $output;  // Send it to the browser!
        }
    }
}
?>

The function above slips Analytics javsacript code into the CodeIgniter output buffer. It finds the closing html tag in CodeIgniter’s output and replaces it with our script. It then puts the closing html tag back into the output string. Simple and effective; because your views generally output html, and this method will only insert Analytics code if a closing html tag is found (your rss feeds, etc. are safe.)

Now, how do we intercept CodeIgniter’s output before rendering it to the browser? This is where hooks come into play. CodeIgniter hooks provide a way to extend the framework without messing with the CodeIgniter core code (which has many advantages I won’t go into during this post.) CodeIgniter defines “hook points” to allow you to specify where you want to throw your “monkey wrench.” Our “gilded wrench” is going to be thrown into CodeIgniter’s display or output proccess.

To demonstrate, let’s edit our application/config/hooks.php file. We leave ‘class’ empty because we only need a function (in case you wondered.) We specify ‘googlea.php’ under ‘filename.’ We specify our ‘function’ (in our case ‘insert_track_js.’) Finally, we have one parameter to send to our function: the value of the google analytics account number (yours will vary of course.) We hook into the ‘display_override’ hook point to override CodeIgniter’s default output (display) process. When you are done, your application/config/hooks.php should look similar to:

hooks.php

<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
/*
| -------------------------------------------------------------------------
| Hooks
| -------------------------------------------------------------------------
| This file lets you define "hooks" to extend CI without hacking the core
| files.  Please see the user guide for info:
|
|	http://codeigniter.com/user_guide/general/hooks.html
|
*/
 
// google analytics insertion
$hook['display_override'] = array(
    'class'    => '',
    'function' => 'insert_ga_script',
    'filename' => 'google_analytics.php',
    'filepath' => 'hooks',
    'params'   => 'UA-*******-**'
);
 
/* End of file hooks.php */
/* Location: ./system/application/config/hooks.php */

Finally, we just need to enable hooks in application/config/config.php. Look for the ‘enable_hooks’ line:

Source code

$config['enable_hooks'] = TRUE;

Set the value to TRUE as shown above. You’re done!

For more information on hooks, see the CodeIgniter Manual or this recent tutorial from Net Tuts.

Lately, when attempting to install extensions for MAMP, I’ve had a difficult time making my extensions work properly because my Darwin ports settings seem to override. Fortunately, I recently found a blog post with instructions that worked. There are a few steps that are different, however, for getting this to work with version 1.9. Therefore, I decided to post the original instructions with those modifications here.

Acknowledgments

The following instructions are modified for MAMP version 1.9 and originally posted by Saverio at http://developers.enormego.com.

Instructions

1. Download MAMP’s “Source” package, located here. If the link doesn’t work, look for and download the MAMP_components_1.9.dmg file located on this page: http://sourceforge.net/projects/mamp/files
2. Mount the DMG image and look for the PHP version that you’re using (php-5.2.13 or php-5.3.2) and unzip that archive. (Use the Archive Utility. Mine gets extracted to my Downloads folder.)
3. Open terminal and cd to the PHP directory that you just unzipped (/Users/you/Downloads most likely.)
4. Run the following command in terminal:
   ./configure –prefix=/tmp/php
5. Wait for the configure script to finish and then run:
   export PATH=/tmp/php/bin:$PATH
6. Now, cd to the zip extension directory:
   cd ext/zip
7. Run:
   phpize
8. Run:
   ./configure
9. Wait for it to finish and then run:
   make
10. Wait for it to finish and then run:
    sudo make install — (You’ll need to type your administrative password.)
11. After it’s done running, you’ll see something like this:
    Installing shared extensions:     /usr/lib/php/extensions/no-debug-non-zts-20060613/
12. Copy the zip.so extension file from that directory to your PHP installation’s extension directory:
    cp /usr/lib/php/extensions/no-debug-non-zts-20060613/zip.so /Applications/MAMP/bin/php5.2/lib/php/extensions/no-debug-non-zts-20060613/

The Code

My only real criteria when I began writing is that I wanted to use method chaining so I could “stack up” rules on a given post variable. Here is what I ended up with:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284

<?php class FormValidator {
 
    private $messages = array();
    private $errors = array();
    private $rules = array();
    private $fields = array();
    private $functions = array();
    private $haspostdata = FALSE;
 
    public function  __construct() {
        $this->haspostdata = ( $_SERVER['REQUEST_METHOD'] === 'POST' ) ? TRUE : FALSE;
    }
 
 
    /*** ADD NEW RULE FUNCTIONS BELOW THIS LINE ***/
 
    /**
     * email
     * @param string $message
     * @return FormValidator
     */
 
    public function email($message='')
    {
        $message = ( empty ($message) ) ? '%s is an invalid email address.' : $message;
        $this->set_rule(__FUNCTION__, function($email) {
            return ( filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE ) ? FALSE : TRUE;
        }, $message);
        return $this;
    }
    /**
     * required
     * @param string $message
     * @return FormValidator
     */
 
    public function required($message='')
    {
        $message = ( empty ($message) ) ? '%s is required.' : $message;
        $this->set_rule(__FUNCTION__, function($string) {
            return ( empty ($string) ) ? FALSE : TRUE;
        }, $message);
        return $this;
    }
 
    /**
     * numbersonly
     * @param string $message
     * @return FormValidator
     */
    public function numeric($message='')
    {
        $message = ( empty ($message) ) ? '%s must consist of numbers only.' : $message;
        $this->set_rule(__FUNCTION__, function($string) {
            return ( preg_match('/^[-]?[0-9.]+$/', $string) ) ? TRUE : FALSE;
        }, $message);
        return $this;
    }
 
    /**
     *
     * @param int $len
     * @param string $message
     * @return FormValidator 
     */
    public function minlength($minlen, $message='')
    {
        $message = ( empty ($message) ) ? '%s must be at least ' . $minlen . ' characters or longer.' : $message;
        $this->set_rule(__FUNCTION__, function($string) use ($minlen) {
            return ( strlen(trim($string)) < $minlen ) ? FALSE : TRUE;
        }, $message);
        return $this;
    }
 
    /**
     *
     * @param int $len
     * @param string $message
     * @return FormValidator
     */
    public function maxlength($maxlen, $message='')
    {
        $message = ( empty ($message) ) ? '%s must be no longer than ' . $maxlen . ' characters.' : $message;
        $this->set_rule(__FUNCTION__, function($string) use ($maxlen) {
            return ( strlen(trim($string)) > $maxlen ) ? FALSE : TRUE;
        }, $message);
        return $this;
    }
 
    /**
     *
     * @param int $len
     * @param string $message
     * @return FormValidator
     */
    public function length($len, $message='')
    {
        $message = ( empty ($message) ) ? '%s must be exactly ' . $len . ' characters in length.' : $message;
        $this->set_rule(__FUNCTION__, function($string) use ($len) {
            return ( strlen(trim($string)) == $len ) ? TRUE : FALSE;
        }, $message);
        return $this;
    }
 
    /**
     *
     * @param string $field
     * @param string $label
     * @param string $message
     * @return FormValidator
     */
    public function matches($field, $label, $message='')
    {
        $message = ( empty ($message) ) ? '%s must match ' . $label . '.' : $message;
 
        $matchvalue = $this->getval($field);
 
        $this->set_rule(__FUNCTION__, function($string) use ($matchvalue) {
            return ( (string)$matchvalue == (string)$string ) ? TRUE : FALSE;
        }, $message);
        return $this;
    }
 
    /*** ADD NEW RULE FUNCTIONS ABOVE THIS LINE ***/
 
    /**
     * callback
     * @param string $name
     * @param mixed $function
     * @param string $message
     * @return FormValidator
     */
 
    public function callback($name, $function, $message='')
    {
        if ( is_callable($function) ) {
            // set rule and function
            $this->set_rule($name, $function, $message);
        } elseif ( is_string($function) && preg_match($function, 'callback') !== FALSE ) {
            // we can parse this as a regexp. set rule function accordingly.
            $this->set_rule($name, function($value) use ($function) {                
                return ( preg_match($function, $value) ) ? TRUE : FALSE;
            }, $message);
        } else {
            // just set a rule function to check equality.
            $this->set_rule($name, function($value) use ( $function) {
                return ( (string)$value === (string)$function ) ? TRUE : FALSE;
            }, $message);
        }
        return $this;
    }
 
    /**
     * validate
     * @param string $key
     * @param string $label
     * @return bool
     */
 
    public function validate($key, $label='')
    {
        // do not attempt to validate when no post data is present
        if ( $this->haspostdata ) {
            // set up field name for error message
            if ( !empty ($label) ) {
                $this->fields[$key] = $label;
            }
            // try each rule function
            foreach ($this->rules as $rule => $is_true) {
                if ( $is_true ) {
                    $function = $this->functions[$rule];
                    if ( is_callable($function) ) {
                        if ( $function($this->getval($key)) === FALSE ) {
                            $this->register_error($rule, $key);
                            // reset rules
                            $this->rules = array();
                            return FALSE;
                        }
                    }
                }
            }
            // reset rules
            $this->rules = array();
        }
    }
 
    /**
     * has_errors
     * @return bool
     */
 
    public function has_errors()
    {
        return ( count($this->errors) > 0 ) ? TRUE : FALSE;
    }
 
    /**
     * set_error_message
     * @param string $rule
     * @param string $message
     */
 
    public function set_error_message($rule, $message) {
        $this->messages[$rule] = $message;
    }
 
    /**
     * get_error
     * @param string $field
     * @return string
     */
 
    public function get_error($field)
    {
        return $this->errors[$field];
    }
 
    /**
     * get_all_errors
     * @return array
     */
 
    public function get_all_errors()
    {
        return $this->errors;
    }
 
 
    /**
     * getval
     * @param string $key
     * @return mixed
     */
 
    private function getval($key)
    {
        return ( isset ($_POST[$key]) ) ? $_POST[$key] : FALSE;
    }
 
    /**
     * register_error
     * @param string $rule
     * @param string $key
     */
 
    private function register_error($rule, $key)
    {
        $message = $this->messages[$rule];
        $field = $this->fields[$key];
 
        if ( empty ($message) )
            $message = '%s has an error.';
 
        if ( empty ($field) )
            $field = "Field with the name of '$key'";
 
        $this->errors[$key] = sprintf($message, $field);
    }
 
    /**
     * set_rule
     * @param string $rule
     * @param closure $function
     * @param string $message
     */
 
    private function set_rule($rule, $function, $message='')
    {
         // do not attempt to validate when no post data is present
        if ( $this->haspostdata ) {
            if ( ! array_key_exists($rule, $this->rules) ) {
                $this->rules[$rule] = TRUE;
                if ( ! array_key_exists($rule, $this->functions) && is_callable($function) ) {
                    $this->functions[$rule] = $function;
                }
                if ( !empty ($message) ) {
                    $this->messages[$rule] = $message;
                }
            }
        }
    }
 
}
?>

Please note: This only works for forms submitted with POST. However, it can be easily modified to work with GET also.

Usage

Now, let’s say that I have a form and I want to validate an email field and set up a password. The password must be at least 10 characters and the password confirmation field must match the password field. On top of that, I have a simple captcha where I just ask the user to add two integers that equal 10. With my class, I only need to write the following code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$formval = new FormValidator();
 
$formval->required()->email()->validate('email', 'Email Address');
$formval->required()->minlength(10)->validate('password', 'Password');
$formval->required()->matches('password', 'Password')->validate('password2', 'Password Confirmation');
 
$formval->required()->callback('captcha', function($value) {
    return ( preg_match('/^\d\s*\+\s*\d$/', trim($value)) && eval ($value) == 10 ) ? TRUE: FALSE;
}, '%s does not add up to 10!')->validate('captcha', 'Captcha');
 
if ( $formval->has_errors() ) {
   print_r($formval->get_all_errors());   
} else {
    // submit the form!
}

Pretty simple!

I have not started using this class heavily ( I just finished it) so let’s call it alpha code for now.

For many years prior to using a Mac for PHP development, I had been using Windows or Linux and Zend Studio 5.x. When I was looking several months back for the Mac version download for my Zend Studio license, I was presented, instead, with a free upgrade to version 6. Wow, that was nice Zend! Unfortunately, the version I paid for (the “perpetual” license) was no longer there to download.

UPDATE: As of my last login to Zend, the 5.5.1 download was available. I installed and everything worked well. Still using Netbeans but appreciated all the same.

But hey! I got the brand-new version. That’s great right? Wrong! Zend decided to drink the Eclipse Kool Aid and completely changed an IDE that I had grown accustomed to (I guess it’s only fair to point out that Zend Studio 5.x was so old at this point that it was getting increasingly more difficult to install on more modern operating systems and newer java platforms.) In spite of the seemingly “over-bloat” of Zend Studio 6.0, I decided to give it a try. I must say that everything just felt wrong. Now I’m sure there are many PHP developers out there that have been using Eclipse for years and can’t live without it, but I just couldn’t seem to make it work my voodoo. I didn’t have the patience to get my Eclipse PHD, so I went looking elsewhere. That led me to a surprising alternative: Netbeans. Although very similar to Eclipse, an IDE with modules/plug-ins for multiple computer language support, Netbeans (entirely free) impressed me right on the spot. I know Zend Studio has all the same features more or less, but the way Netbeans is put together just seemed more natural to me (things I wanted to do actually worked.) Let it suffice to say that I have been using Netbeans since then and I haven’t looked back!

In this post, we will discover how to go about debugging a specific page in your website through setting up debugging in your MAMP stack, the free Netbeans IDE and your Firefox browser.

Setting up Debugging with Xdebug and Firefox

In order to leverage the new-found versatility or MAMP, I needed a good debugger. I had had a pretty decent debugger with Zend Studio 5.x and that would be an essential requirement for netbeans. One of the cool features of Zend Studio was the integration of the Zend Toolbar with the debugger. Fortunately, this can be done with netbeans also, but you have to get a firefox plugin called Xdebug Helper easy Xdebug. When you get it, note that it has one configuration option you need to set: Xdebug.idekey needs to be set to netbeans-xdebug.

Since I was using MAMP, I needed to install the xdebug extension for PHP. I actually downloaded the source and built the extension (used Xcode tools to phpize the source and build it and then just copied it to the appropriate MAMP folder.) I wish I had taken the time to record the steps involved, but instead I’ll just refer you to the easy way. Now we just need a little change in our php.ini file and we are good to go:

Note: As of MAMP version 1.8.4, there is an xdebug extension that comes with MAMP (just be sure to disable Zend Optimizer since they don’t seem to play well together.)

; Xdebug config for Mac OS X and NetBeans IDE
zend_extension=/Applications/MAMP/bin/php5/lib/php/extensions/no-debug-non-zts-20050922/xdebug.so
xdebug.remote_enable=1
xdebug.remote_handler=dbgp
xdebug.remote_mode=req
xdebug.remote_host=127.0.0.1
xdebug.remote_port=9000

Xdebug in php.ini

Now, all we have to do in order to debug is evoke the debugger in netbeans. I do this by clicking on the debug project button in the netbeans toolbar:

netbeans debug button

Netbeans will open up your development website according to the URL you submitted when creating the project (make sure firefox is your default browser and that you have set the default page in your project.)

Tip! You can also force Netbeans to not open your browser when you debug:

In your project properties (right click on the project -> properties), click on Run Configuration, look for the “Advanced…” button and set “Do Not Open Web Browser“. Click OK.

A big thanks to Leonard Teo for this tip.

Often, just clicking the button will automatically activate the Xdebug Helper addon for me. But if you want to make sure that netbeans debugs the URL in your browser, be sure the click the X in your firefox footer bar so that it changes color from gray to green.

Xdebug Helper Toogle Icon

Netbeans will open your startup page to something like:

index.php?XDEBUG_SESSION_START=netbeans-xdebug

If you are using a PHP framework like Codeigniter, the URL can be a little annoying at first. I have found that I only need to press the continue button to let the start page run it’s path and then just close that tab. From that point I just leave the debugger running and toggle the Xdebug Helper “X” icon when I need to debug any page that I am working on. Couldn’t be easier!

Screencast Tutorials

The following screencasts cover making XDebug and Netbeans work together. It’s a recap of the text here with some added instruction on setting up an Apache virtual host for development from your computer. Please note, I do not have the ability to be concise when I speak and you may lose patience. My apologies up front. (If you want a condensed version, just watch Part 2 and than skip to Part 6. You might want to watch Part 5 if 6 leaves you scratching your head.) Also, as many people find when they listen to themselves recorded, I find that my voice and accent sounds kind of strange and annoying. That’s one part me and another part Southern Utah accent. Bear with me if you can.

Part 1: Prerequites for Xdebug and PHP on a Mac

Part 2: Setting up XDebug Helper

Part 3: Setting up an virtualhost apache environment in MAMP for codeigniter

Part 4: Starting to use XDebug in Netbeans

Part 5: Debugging with Netbeans and XDebug

Part 6: Wrapping up by showing a few features of debugging with xdebug in Netbeans

Two-thousand years ago, it was conquered soldiers and Christians. Since recently reading some blogs, and after hanging out in a few chat rooms with the “techno-elite”, I’m thinking  the newest group to be “thrown to the lions” are PHP developers!

It’s convincingly apparent if you search the “blogosphere” that many “techies” think that the phrase PHP programmer is an oxymoron. If you use PHP does that really earn you the despised title of newbie?

Why do you ask? Well, just the other day I was hanging out in an obscure chatroom on irc. The channel was the geographically-nearest enthusiast channel for Ubuntu (and I am an Ubuntu enthusiast.) As I was trying to drum up some conversation (mostly because I was bored) I mentioned that I was a PHP developer to stunning silence. Okay?

The next night I log on again, after all, these are supposed to be people that are promoting Ubuntu and usually that encompasses the ability to be friendly and non-condescending. (Please, don’t get me wrong, I feel that, typically, the Ubuntu community is probably the best community for helping everyone fit in.) So, this time no chat is going on (as usual) and I sit idly by until I see some chatter (pretty standard and I was in a few other channels at the moment also.) One of the users (a very prolific and well-known contributor to Ubuntu in my relative geographic domain) was commenting that he had decided to use a certain application. However, he quipped, “Too bad it’s PHP.” Okay, that got my attention. There’s a conversation starter. I write, “Now I see why when I mentioned that I was a PHP developer, the room got really quiet.” Ha ha. I think I got a LOL or two. More silence. I then express how I’m always a little surprised that the django and rails crowd seem to feel some contempt for PHP. Longer silence. Finally, the other fellow posts something along the lines that PHP sucks. Mr. “Ubuntu Loyal” agrees with a two-worder meant more as a textual “high five.” I promptly agree that there is a lot of spaghetti code written by “newbies” in PHP, but that it’s not impossible to write good code using it. To that, I get a very condescending and elitist remark from the other fellow. It was along the lines of, “If you still use PHP, you are still a newbie.” What?! Well, that really ticked me off! I have over 9 years of Web development experience. This means, in my relatively short time in life, I have invested a large portion of my career devoted to writing web software. I consider myself a professional. Who does this elitist punk think he is calling me a “newbie!?” when I express my outrage, Ubuntu-man proceeds to tell me, very non-specifically, why PHP sucks. Basically, he tells me nothing new. He later back-pedals somewhat to convey that it’s the developers preference that really matters. I suppose I’m still a “newbie” by his estimation though. Anyway, I was a bit stunned by this irrational behavior. Was it warranted? Is PHP a truly awful language? Yes, and no.

PHP Complaints

PHP was originally envisioned as more of a templating engine. It began its humble roots in this manner just like many other world-changing web technologies. As more time went on, more feature requests were proposed, and more were implemented, until a “c-like” (block structured, procedural) language emerged. Now, I will take some liberty to make an assumption or two…

Because PHP grew as a collection of functions that are useful for Web development, higher-language programming syntax was not incorporated (Okay, assuming done. Moving on…) One of the chief complaints from the “python-pretentious” and the “ruby-rousers” is that PHP has no notion of name space (update. PHP 5.3 and 6.0 now have namespace syntax.) Name space is the practice of enveloping related functions and properties under a common container. The idea is that you can have a save() function in two entirely different name spaces because you can refer to each function with a name-space prefix first. For example, to save a database record, I could call a function named database.save(). That function would not be confused with the whale.save() function by the compiler because “database” and “whale” are different code containers. PHP haters complain that this forces PHP extension makers to create overly-long names and makes PHP less modular (because every single function is in scope.)

Another complaint is that variables are loosely typed (implicit.) That is to say, if I set a variable to “hello world”, PHP automatically assumes a string and converts that variable to a string type. if I set a variable to the numeral 1, PHP assumes I meant an integer…you get the idea. So what’s the problem? Well, without going overboard here, let’s say that my first variable is named $a (PHP variables begin with the dollar sign) and my second varible is named $b. When you write the expression: $a + $b, because one of the variables is of the string type: $a, PHP converts $a to an integer (0) and the result is just “1″. If I change $a to the literal number 2, PHP now makes an integer assumption and adds the two integers to make the result: 3. Critics of PHP complain that implicit typing creates more opportunities for bugs.

I’m just going to bunch together a few of the most common complaints that remain. PHP has no default caching mechanism. PHP uses anonymous arrays, PHP only has UNIX dates (1970-2038.) There are many other “band-wagon” and “brain-stormed” reasons. Many of which are deservedly so. Admittedly, It’s not a perfect language, but does it really hold you back so effectively as to engender contempt?

So yes, PHP has it’s limitations. Those of us who embrace PHP and use it on a daily basis are aware of PHP’s short-comings. But, just like any other language with “snags” (no programming language is perfect) we have learned to get around them to get the job done. I cannot say at this point that any of the issues complained about has created any significant roadblocks for me. In fact, a significant number of popular free open source web software out there is written in–you guessed it–PHP! If it’s so bad, why do these developers not switch to python or ruby? A few examples are drupal and wordpress (this blog is powered by drupal wordpress.) So, according to the “rail-heads” and “django-divas” we are led to believe that PHP programmers, such as the coders for drupal and wordpress are basically ignorant and coding with one brain-lobe tied behind their backs!

Irrational and unwarranted nonsense!

It’s almost to the point of paranoia. It reminds me of the Apple ads trying to convince you that everybody hates Vista. So, don’t use it or you’ll be sorry! As much as I would love a mac, I actually have Vista, and I like it! Developers with a few years of good PHP programming behind them actually like it as well!

Again, I promise that clean, easily-refactorable, and intuitive code can be, and is, written in PHP! For example, name space really isn’t the issue that the rhetoric suggests. I mean, really, how much harder is it to write mysql_connect() as opposed to mysql.connect()? (yes, it’d just be connect() if name space were declared but still not that big of an issue.) You can emulate name spaces by writing PHP’s code into your own objects which can be written very clear and concise just like any other high-level language. It all depends on the developer. Certainly not a “show stopper.” Furthermore, PHP 5 fixes a lot of the issues that have been criticized in the past. For example, I mentioned implicit types. PHP 5 supports type hinting. The difference is that you can choose to use it. If you have something simple you’re working on, you can choose not too. Some people actually consider implicit types as a convenience. I think it’s very convenient to be able to choose. In the several years I have been developing with PHP, rarely has implicit typing been an issue. Maybe the critics are just lazy programmers that need the compiler to babysit them. On that note, I recently read a post from a developer who stated that one of the many reason he hated PHP so bad was the lack of op caching. Even though it’s not built into the core of PHP, there is a free caching extension called APC. The manual gives you easy steps on how to install it. Again, you have the choice to use it or not. And speaking of extensions, the new PDO database abstraction extension is simply awesome!

I have heard a famous purveyor of a popular web framework rail on PHP citing that “his way” is more natural for web development. What he was really saying is that his framework that is built on another language is easier and faster than developing PHP. Unfortunately, he gives the impression that his preferred language is better for Web development than PHP. In reality, he is comparing a framework for rapid web development to a language. Not a fair comparison. While, I agree that the MVC model for web development works well, I think he is being disingenuous in his notion that his framework is the only way to accomplish this “natural way.”  For example, there are numerous PHP frameworks that allow you to use the MVC model of development (my favorite is codeigniter.)

No Language is perfect. Even so, PHP is a great choice for beginners and pros alike.

I do admit that, because PHP doesn’t enforce a model for development (you can write procedural or object oriented code), programmers with little experience can write pretty awful and almost impossible-to-maintain code. But hey, you can write crappy code in any language!

PHP was designed to be a convenient language to learn and just knock stuff out (email forms, website authentication, etc.) And it performs this amazingly well!  Web applications are more frequently simple than not. I have never felt held back by what I could or could not perform using PHP. I can also note, from a perspective of enterprise, PHP scales up just fine. The large variety of Web applications available that are written in PHP is proof. It all comes down to how smartly they were built. Facebook works just fine folks! Yes, it’s true, compiled code will always outperform code compiled on-the-fly, but python and ruby aren’t compiled either (besides, compiled code makes web development a pain in the backside IMHO.)

So yes, PHP may not be a perfect and high-level language. But then again, you don’t need a nail gun to build a bird house, a hammer works just fine. Don’t believe the hype! PHP works amazingly well for what it was meant to do. I wear a badge of pride that I call myself a PHP developer, so should you. Stand up for yourself!