The "Introduction to CodeIgniter" series continues on DevShed with this new article, a look at nested views in their sample application.

In this third chapter of the series I'm going to discuss one that bases its functionality on the loader class that comes bundled with CI. [...] By means of this method, it is very simple to replace in one single step all the variables included into multiple views with actual data. Therefore, in the next few lines I'm going to discuss how to use it to generate a dynamic web document, which will display some database contents.

After a quick review of loading views sequentially, they look at the new stuff - a "master view" that can load multiple other views inside. To pass information into this master view, they use the "$this->load->vars()" method included in the framework.

Felix Geisendorfer shares another helpful tip for CakePHP users out there - this time dealing with controller variables and Javascript.

If your application requires JavaScript in order to work than you have probably been looking for an efficient way to pass CakePHP controller variables to your scripts. I already mentioned this technique in my talk at CakeFest this year, but here is the full explanation.

His method sets up a new function in the controller that automatically pushes PHP arrays out to a Javascript block in your application's layout. The widget system makes it a simple process.

WebReference.com has posted part two in a series looking at the "building blocks" that make up PHP and its use. This time, it's a look at the containers for your data - the data types, literals, variables, and constants.

They go through each, explaining what they are, how they're used and when you'd want to use them in your code. They explain the data types and how those fit with each "container" and some basic things like valid names and how to assign things correctly.

They even get get into working with variables from GET and POST requests as well as working with the scope of variables and getting the metadata about them (is it an integer? is it empty?)

In his latest post, Brian Moon talks about a method to help you and your code fit into an E_STRICT style of coding - the settype function.

These days, the way to develop is to have E_ALL and maybe even throw in E_STRICT if you are really hard core. That of course means having all your variables initialized before they are used.

In his view, defining them is good, but it's more "elegant" to use the settype function to make it more clear where they are defined. He also includes a function, using settype, that ensures that the entered values are what they should be (i.e. and int is an int).

The International PHP Magazine has posted the results of the question asked in their latest poll - "What is the Top Criterion for Scaling PHP?"

Of the six options they provided:

• Object code caching
• Template systems
• Distributed object-caching systems
• PHP variables that can be set
• Output Compression
• Other things that may help

one stood out as a clear winner - "Object code caching". Bringing up second place was "Distributed object-caching systems" and the other options coming in pretty close behind.

Be sure to cast your vote for their latest poll question - "Which is the Most Common Database Problem?"

In a continuing series of introductory video tutorials they offer, KillerPHP has posted to new ones - one covering associative arrays and the other covering indexed arrays.

The videos, seven in all now are done with a voice-over talking about what the feature is and includes bits of code to help explain the discussion.

Topics so far include:

• Includes
• Configuring WAMP
• PHP Variables, Part 1 and Part 2

You can get complete information on these screencasts from the KillerPHP site.

In a new post from her blog today, Sara Golemon seeks to dispell any FUD that might come up surrounding compiled variables (as there's already some issues raised in this interview).

Last month at php|tek I gave a presentation on "How PHP Ticks" where I covered, among other things the process of compiling source code into opcodes (an intermediate psuedo-language similar to what java calls "bytecode" or what .NET calls "MSIL"). As part of this section of the presentation, I showed one of the more interresting changes between ZE 2.0 (PHP 5.0) and ZE 2.1 (PHP 5.1), namely: How variables are retreived and used in an operation. More specifically, how they provide a small, yet cumulative, speedup to applications in a way that's transparent to the end-user -- One more reason to like PHP 5.1 right?

After listening to Marcus Whitney's interview with Brion Vibber of WikiMedia in which he mentions my presentation and makes reference to this engine change, I realized that I should clarify what this feature is (and more importantly, what it isn't) before any FUD spreads.

She describes what they are with an illustration using a simple PHP script and breaking it out into the compiled version's parts - both in PHP4 and the PHP5 versions. Of course, representing what they are needs a flipside, so she presents a look at what they are *not* as well. There's also a brief mention of the special status that globals and static variables get outside the norm.

On Byster.net today, there's this new post detailing some benchmarks they've done with some of the functionality in PHP5.

Included in the list of tests were:

• Reading an integer array
• Parsing variable names
• Splitting out text
• working with a random number generator.

For each of the tests, they have a few different methods of doing the same thing and the results (in milliseconds) plotted out in bar graphs. Some of the results are surprising, but most are expected (if you work with optimizing PHP much at all). It's a good amount of coverage of functionality, though - most aspects of everyday programming are here.

Justin Silverton has posted this brief overview of the patTemplate system - what it is and how it can be used in your site.

patTemplate is a set of classes that allow you to separate your php code from design/output, making your code easier to maintain. To identify a certain part of the page as a template, patTemplate uses XML tags to assign a template a unique name and a various attributes (see patTemplate Tags and attributes for a list of all tags and attributes). When parsing a template, the parser divides the page in several chunks and treats them as separate templates. By using patTemplate's API you can hide, display or repeat a certain template.

He describes the different template types (OddEven, Condition, SimpleCondition) and how to use variables inside the templates. He wraps it up with a quick installation overview, both using PEAR and the manual installation.

On his blog, phpcult.com, today, Vidyut Luther has posted an update to his previous post asking where people usually define their settings.

My last post created a lot of conversation about how one should go about setting configuration options for your code. I realized, no one mentioned the use of PHP's built in parse_ini_file.

function. This seems to address my problems with one large monolothic file pretty easily. I can still have a globals.conf.php which handles global settings, but I can also use this ini file, to load specific things that are only necessary for modules on an as needed basis. The global scope would be aware of the CONFIG_FILE constant, and I can parse specific sections of it whenever I need to.

He notes that he'll try it in the next few days, but I imagine he'll like what he sees - especially if he's looking for a simple, external way to change information in a file and have it affect the entire app (without changing code).