I would love to take a good long look under the hood at just how PHP objects and classes do the work that they do, and hope that you could benefit from that knowledge. [There are] many questions that come across my desk, on a regular basis, from developers and beginner PHP enthusiasts that I've worked with over the years, and are some of the key points this article attempts to help you answer.

He talks about classes "giving birth" to objects, how they're stored internal to PHP and how they provide the "blueprints" for it to lay out the storage of the object's data. He talks about using identifiers for variable/property access, object handlers and how "$this" fits into all of it. He notes that OOP, while a major part of PHP now, wasn't in the initial versions (until around PHP4). He finishes off the post talking about lateral/vertical context switching, the lifecycle of an object and the "early binding problem" and class scope.

The perfect problem where the Reflection API appears to be the perfect solution. For me this came up a couple months ago while I was working on a European zip code radius project that had to be built using one of those obfuscated and ill documented 3rd party commercial programs (nothing worse than when the platform is forced on you). So, I had to use this program that was intentionally encoded to prevent me from doing what I wanted to do. I couldn't even look at the code; it was completely obfuscated.

To illustrate his point, he gives examples of two built-in classes that PHP has and the result of their reflected output - SimpleXMLElement and DateTime. He shows how to get the structure of the class in general and how to use some of the more specific functions to get things like properties, methods and constants for the class. This is perfect for those undocumented features and isn't too far of a jump away from building out your own documentation.

OK, here's the thing: [variable variables are] only the entrance of the rabbit hole. [...] The first thing to understand is what $ is. $ is actually a shorthand for ${} and means "return the value of the variable whose name is contained in this".

The response goes on to talk about variable names as strings, a few string handling tricks that can be used when referencing them and how this works with objects too. Things get a bit more complicated when they start adding in more levels of "variable" and evaluations based on random results. Not overly useful information for the casual developer, but interesting to know none the less.

In this new article he covers:

• Contact Us Form
• Feature-Rich Customer Accounts
• Order History with Status Updates
• Order Tracking from Account
• Forgot Password E-mail
• Order and Account Update E-mails
• Customizable Order E-mails
• Create and Edit Orders from the Admin Panel

Each item on the list comes with its own description and definition (as well as a few links to other resources where applicable).

So, dear readers, I'm doing the IDE reviews for all of you guys and there's two ways I can proceed: I can take each of the requirements and do a single post per requirement with a writeup about it in detail for each of the 4 IDEs - then I was thinking for each new IDE I try, I can hit those same points. Or I can write up specifically on a single editor at a time, covering all of the requirements and I will also then review anything else about the editor etc.

He's thinking of doing a comparison of the Eclipse-based IDEs in their own right, but wants to get feedback on what would be the most useful for other developers to learn from. Several comments have already been made suggesting approaches to the topic, other editors that might be missing from the list and some support for the Eclipse comparison idea.

PHP OCI8 can be built using libraries from a full Oracle Database (or Database "Client") install, created from running the GUI installer. This is often referred to as an "ORACLE_HOME" install, since an environment variable of that name is set to the installed Oracle software directory. [...] Another dimension to the install is that PHP extensions can be statically compiled into the PHP executable(s), or built as shared binaries. If OCI8 is built as a shared library it is loaded into PHP as a result of setting the php.ini option "extension=oci8.so".

There's eight different methods he mentions including building it as a shared module, using the normal Oracle libraries to build and using the Instant Client libraries to run the build.

• PHP 5 displays strong growth, almost at 30%
• PHP 5.2 will be more popular than PHP 4.3 before April
• PHP 5.2.5 is already the dominating version of PHP 5
• PHP 4.4.8 not so popular

You can get the full details on this month's statistics from the full list of the statistics and the evolution posted on Nexen.

Zend_Form gives you all the tools necessary to create forms and form elements via PHP code. Like everything in Zend Framework, almost everything is configurable; however the defaults are probably good for most uses.

They include some sample code that shows the creation of both a simple, sample form and something a little bit more advanced - including validation methods and making fields required.

Picking up from where we left off last week, we'll be discussing shortcuts, query responses, metadata, and more.

They start off looking at shortcuts, those handy things the PEAR DB package offers to make life simpler (like getRow and getAssoc) before moving on to how to get the details about the response itself (like affectedRows and tableInfo). Next up is working with the metadata (using getListOf) and, finally, a sample application to tie them all together.

Terry Chay made some remarks to my last blog entry about a solution for lazy class loading without using __autoload(). Some of his statements seem like I explained my implementation not good enough leading to wrong interpretations. In this blog entry I'll use some of his statements to take a deeper look into my implementation and show that he has drawed some conclusions which I want to disprove.

He goes back and corrects some of what Terry has said in his response, including showing a more detailed version of him implementation. Be sure to check out the comments for the post, though - Terry comes back and clarifies some of the comments he'd made including the framework talk and changes of perspective having seen the new code snippet/information.