In a recent entry to his blog, Neil Garb shows his method for creating compound elements in a Zend_Form object in your Zend Framework website.

Zend_Form can save you a lot of time. It almost completely abstracts away the most boring and error-prone aspects of developing secure and standards-compliant HTML forms. But one thing it doesn't do out of the box is compound elements, such as three-field dates. In this post I'll show you the easiest way to do this ZF-style.

He goes through the creation of the sample controller, an example of a custom element (the multiple date drop-downs he mentioned) and how to handle the validation in a "Zend Framework way" via an isValid call.

Tim Koschutzki has five quick tips for the CakePHP users out there to help make your lives just a bit easier:

• The prd() convenience function
• How to debug your CakePHP emails?
• Use elements where possible and make them belong to the controller
• Combine your h1 titles with Cake's page title
• Avoid long parameter lists

Each tip comes complete with code and a brief explanation of its use.

Michael has posted a simple script today that takes in XML data and spits back out an array on the other side:

The function takes the specified XML data (which must be in valid XML format) and converts into an array. Any attributes in the XML elements are dropped an only the element values are placed in the array.

The code uses a combination of XPath, DOM, and regular expressions to parse the given XML content.

Tiffany Brown shares a quick function she whipped up to create dropdown menus from the contents of a newline separated text file (or files).

I developed this PHP function for a project I'm working on. I'm posting it here in case I need it again, or in case you find it handy.

The function turns each line into an option tag making defining custom menus based on the contents of dynamically-given text files easy.

This could also be easily adapted to create navigations menus at the top of your pages with a few modifications to the HTML tags being used and some CSS to change the look of the list.

On the Tilllate Blog, there's a new post discussing the use of caching in applications, specifically for dynamic data.

Consider you have a set of data that is changing dynamically for each page request and you need to cache that data the fastest way possible. You can't cache dynamic and unpredictable data as a whole, can you? Hence, we would put each data entry into cache separately to be able to fetch it separately and dynamically. But this means bombing your cache infrastructure with with requests.

They break it up into a few different topics - caching text elements on the page, two-tiered caching (grouping cached items), incremental caching and cache versioning. They don't share an example of their code unfortunately, but they do mention something about a possible contribution to the Zend_Cache component of the Zend Framework.

Derick Rethans has pointed out a "gotcha" that was passed along to him (somewhat incorrectly) about the "name" attribute being deprecated in XHTML 1.0.

Just now somebody on IRC was claiming that the "name" attribute in HTML - the one that is used to give form input fields a name to be used in $_GET and _$POST in PHP is in fact deprecated. [...] But if you read correctly, it's only for the elements: a, applet, form, frame, iframe, img, and map.

For the official information, check out the section of the new spec dealing with this transition.

DevShed concludes their look at the Flyweight pattern with this new tutorial - the second part focusing on building an actual application with the pattern implemented.

In this final part of the series, I'm going to teach you in a step-by-step format how to create in PHP 5 a flyweight class to balance the instantiation of objects that will be used to generate web documents on the fly. Hopefully, by the end of this article, you should have acquired a considerable background in how to apply the flyweight pattern in a real-world situation.

They create a simple application that generates dynamic HTML elements - DIV tags - with a simple interface to define things like content, name, and ID. Their Flyweight factory class creates and manages the number of DIVs that are created, blocking requests for any more. Finally, they apply it, showing the creation of a simple web page with multiple DIVs in it.

DevShed charges right ahead with its emphasis on design patterns in PHP with a new start of a new series today that looks at the Flyweight pattern.

Among the considerable variety of structural design patterns that can be implemented with PHP 4 (and PHP 5, by the way), there's one in particular that deserves special attention. It's easy to apply in the context of a given web application, and it offers remarkable functionality when it comes to preventing the unnecessary instantiation of different classes. This two-part series covers that pattern.

As they explain, the Flyweight pattern helps to keep your code light and simple by preventing the instantiation of unneeded objects and resources. They go with a HTML form example, illustrating how to prevent a submit button or an input button's class to be reinitialized every time a new form field is needed.

In the continuing series on RSS files, DevShed has posted this new part with a focus on the "theoretical aspects" of developing an RSS file.

These aspects include things like examples of the elements it can contain, elements that are required for it to be a compliant RSS document, a look at the enhanced RSS functionality and structure (more information about the creator of the RSS embedded in the data), and even a look at what an aggregator is and what they would do with your RSS file.

Keep an eye out for the last installment in the series - a look at actually creating the RSS file from your data (probably from a database) and displaying it for the world to see.

As mentioned over on Ajaxian.com, there's a new Ajax framework in town that's looking to "ease the development of rich Ajax applications, by generating the appropriate JavaScript code" - AjaxCore.

AjaxCore takes all the dirty work of JavaScript code generation and provides a solid foundation. The concept is to extend a Generic AjaxCore class and defining methods that handle the Ajax driven events and binding them to HTML objects.

It uses Prototype to work with the DOM and Ajax connections and to help you with binding the scripts to the different elements on the page. Code can be linked to certain elements and have that (server-side) code automatically executed when an element is referenced. You can find out more from the AjaxCore homepage and the Ajaxian post also includes a simple inline example to get you started.