On his blog today, Mike Willbanks has started up a new series that will look at various caching techniques that are available to PHP developers now:
Welcome to the first edition of the PHP performance series, a new series that I will be explaining ways to gain efficiencies and squeezing more performance out of your applications. This first edition, caching techniques, focuses on ways to cache data to optimize your current sites. Some of the concepts here are fairly easy to implement while others may take strategic design in the architecture of your application.
From The Bakery, there's a new tutorial looking to help make pagination (more than just the basic stuff) simple on your site.
This tutorial will attempt to cover some advanced techniques of pagination. In large this will cover Ajax pagination. Hopefully we can also uncover some of the better practices and techniques to use with pagination.
Continuing on from this previous post, DevShed has this new tutorial posted. Another excerpt from O'Reilly's "Programming PHP, Second Edition" (by Kevin Tatroe, Rasmus Lerdorf, and Peter MacIntyre), this section gets more into connecting to the database, making a query and returning some information.
They start off looking at the DSNs mentioned previously and include a bit of error checking around it to handle anything that might come up. The next step is, of course, to make a query against the information in your database. They also include an example of the fetchRow method to push the returned results into a variable.
The variable is built out as an array, so they show what that array looks like "on the inside" and how you can reference the different values that make it up.
WebReference.com has posted part two in their series looking at security techniques in PHP. This time they focus on the use of a few things - the PECL filter, the PEAR Auth module and mcrypt.
For each of the three topics covered, they include a few code examples on their use - an HTML form with the filter extension, user authentication with the PEAR Auth, and encrypting data to be used in a more secure cookie.
Filed under their "Advanced Topics" sections today is a new article from WebReference.com that looks at some security techniques developers can use in their apps to help keep their and their user's information safe from prying eyes. It's an excerpt from Larry Ullman's book "PHP 5 Advanced: Visual QuickPro Guide".
This chapter will begin by rehashing the fundamentals of secure PHP programming. These are the basic things that I hope/assume you're already doing. After that a quick example shows ways to validate different kinds of data that might come from an HTML form.
The third topic is the new-to-PHP 5 PECL library called Filter. Its usage isn't very programmer-friendly, but the way it wraps all of the customary data filtering and sanitizing methods into one interface makes it worth knowing. After that, two different uses of the PEAR Auth package show an alternative way to implement authorization in your Web applications. The chapter will conclude with coverage of the MCrypt library, demonstrating how to encrypt and decrypt data.
The security tips in this part of the series range from turning off register_globals (you do have it off, don't you?) to form validation with things like regular expressions and the ctype functions.
In a new tutorial on PHPBuilder.com today, they walk you through the use of the use of the mysqli interface in PHP.
This article will illustrate some basic techniques for using the mysqli interface. This is a great tool to use in php5 because it doesn't need any include libraries like PEAR, etc; it is compiled right into the distribution.
They start things simple, showing how to make the mysqli connection in your script, including how to set up the connection parameters. They move quickly into making queries on the database - first a simple one with a loop and then a more complex example with a prepared query. They wrap things up by helping you create a simple class that works as a bit of an abstraction layer to query and report on the results returned.
In his travels as a PHP developer, Jamie Wong has gathered some helpful debugging tips that are shared in this latest post to his blog.
Here are some bugfixing rules and tips I've learned working all these years with PHP. I emphasize mostly on fixing bugs than preventing them, which is another subject worth of its own article. I've moved to Rails, but I wanted to finish this post as a farewell and thanks to every article and documentation that was useful to me. Hope this is useful to you too.
Topics covered include:
Assume nothing
Turn Error Reporting to show all errors
Read the error message
Understand the bug
"Scooby-Bug, where are you?"
Get as much information as possible
Each has some explanation below it and, in some places, a bit of code to clarify the point.
In his latest entry to the Synutx blog, Ammar Ibrahimtalks about an advanced chaching technique - block randomization.
I'm currenlty working on a site where I want to improve performance of dynamic pages. One of the greatest techniques to do is to cache dynamic content and serve the generated output (HTML). It's not as easy as we all want it to be when you have all sorts of weird blocks on the page: User login area, random content, ..etc
As I had a very pleasent experience with eZ components last week, I decided to take a look at the components, but then i remembered it works on PHP5. This project is on PHP4, I had to look for an alternative and decided to use PEAR::Cache_Lite.
He gives a visual example of what he's working towards and includes some sample code (using Cache_Lite) to create the blocks of content for his site. It took a few tries to get right, but apparently, third time's the charm.
In his latest blog post today, Felix Geisendörfer shares his "ultimate bootstrap technique" for CakePHP without having to render a page.
Ok, I shouldn't use such a buzz-headline, but I was very happy today, when I discovered a new way to bootsrap CakePHP wihout having to render a page. This is especially useful when you try to embed CakePHP in existing php apps (drupal, wordpress, ..., ?), or when you try to write unit tests for highly coupled classes such as Controllers or Models.
Basically, the technique involves tricking the Dispatcher into not rendering based on the $_GET values by making it think that it's being asked for the favicon.ico file.
