As we are now out of every of the 5 first generation of the elephpants, it is time to start a 6th. You'll find here all information to include yourself. [...] Fill in your elephpants wishes. We do not need any payement now. We will contact you directly before starting the generation for the actual payement.

Their schedule hopes to end the pre-order process on December 20th (just three days away) and to strat production on these pre-orders by January 10th. The end results would be shipped out for delivery in April 2011. If you'd like to lay claim to some of your own, go over to the order form and select the size (large/small) and the color (blue/pink) and fill in the contact info. Unfortunately, because of production restrictions, single elePHPants cannot be ordered, so consider getting together with a local user group and all chipping in for a box!

I'm currently looking for a good PHP framework to do a new project. I recently used Kohana 3 at on a project for a client but I needed something lighter and having used Sinatra and Padrino previously but needing it PHP based I did the next natural step - searched for PHP Sinatra clones.

There's four frameworks that made the list - all in varying states of development:

• Limonade
• Fat Free Framework
• Slim
• Fitzgerald

They look at five different frameworks:

• Kohana
• Rapyd
• Epicode
• ELF PHP
• BaseApp

A few other frameworks are also mentioned in the comments like the micro-framework limonade and Madeam.

Indeed, the quality of Rails, CakePHP, Django, and Catalyst notwithstanding, some developers have rebuffed the large frameworks, citing bulk and complexity, to create smaller and simpler alternatives. Dubbed micro-frameworks-think microcomputer versus mainframe-the tools shape incoming requests into something manageable and leave the rest up to you. Choose your design pattern, object-relational mapper (ORM), and rendering technology, and off you go. As you'll see, a working Web application can be composed in less than ten lines of code in a single source file.

He covers the Ruby framework first (Sinatra) and Limonade next. The framework takes incoming requests and maps them into the developed code. It works like a basic MVC-formatted framework - the request comes in with an action and is sent to a method by the same name. You can use wildcards in the URI, regular expression matching, views, templates and it includes error handling support and configuration option support.

Why "micro-"? Because changing logic of your application may give you much better performance boost then applying all these tips. But they still can make your code better. You always need to output something, why do not use "echo" instead of "print"?

He has a list of about thirty things you can do including:

• calling a function is faster then calling a static method
• accessing an initialized variable is faster then accessing an uninitialized variable
• avoid @ (error control operator)
• adding method parameter type hint increases calling time
• cache page output or result of resource-consuming functions
• pre-increment (++$i) is faster then post-increment ($i++)
• an array is a faster alternative to a class with several fields

These hints aren't going to make amazing differences in your code, but they could help get you out of a sticky place where your code just doesn't want to behave.

Symfony 1.2 already comes with a lot of great new features but smaller things also matter a lot. Here is yet another post about small things we have recently added to symfony 1.2.

The list includes the ability to generate a URL in an action using the routing object, new methods in the form object that make it simpler to use in templates and an update to the Phing/Propel interface to help with debugging.

As for every symfony version, we try to simplify the API and make it more intuitive and powerful. Here are some examples that you will soon enjoy in symfony 1.2.

There's four included in the post (and many more in the framework):

• Application name in CLI tasks
• Native PUT and DELETE support from the browser
• Shortcuts in the response
• sfValidatorSchemaCompare validator

If you have missed the boat of the first generation of elePHPants, now is the right time to catchup up and participate to the 2008 generation! As for the first generation, this project is open to every PHP User group and aficionados, that want to adopt elePHPants, small or big.

Pricing is 4 Euros per elephant (in a 50 count box only) or 50 Euro for one of the larger elephants. They're even open to having company logos ("your own brood") added to the other side of his back. You can find more details on getting your hands on one at this page on the Nexen.net website or just head right to the order form to get a little blue PHPer to call your own.

I was recently working on a command line PHP tool, and didn't have easy access to our normal PHP unit testing framework built around SimpleTest. [...] I didn't need support for mock objects or complicated assertions - just a bare basic assertTrue() would do the trick.

He includes the code (of course) and an example of it in action, three tests with their assertions. It's a simple little tool made of a simple purpose, a starting place for developers just learning unit testing to learn from.

PEAR::DB is all well and good if you want to connect to multiple databases (I assume, I've never actually used it with anything other than mysql) but it is somewhat hefty on the bad side of 60k. Not a good thing if you're not using some sort of accelerator and have a high traffic site. Here's a class which replicates the PEAR::DB API (the bits that I use anyhoo) and weighs in at a much nicer ~11k. Sweet.

The class is posted for download here as a simple PHP source file with functions and values named similar to those in the PEAR::DB package.