Stuart Herbert has a new post today showing how to get the well-established PEAR package management system working on Windows 7 so you can easily call "pear install" on whatever your needs might be.

So that I don't forget how to do this next time around. Worked for me, your mileage may vary. First step is to get a working install of PHP. [...] At this point, you should be able to open up a Command Prompt, and type 'php -v', and see the response 'PHP v5.4.latest …' appear as expected. Now for PEAR itself.

He gives step-by-step instructions on how to get PEAR up and running - downloading and configuring it with the correct Windows-based paths and using the PEAR_ENV.reg file to update your registry.

In this new post to the GotoTech.com blog Eric Burns talks about a way he's "tamed Doctrine's 2000 flushes" with a wrapper around the EntityManager to make controlling the database flushes simpler.

For my project I decided to use the Doctrine 2 ORM to manage my data layer. We also use this at work, so the biggest reason I chose this was to be able to learn more about Doctrine to help me in my job. But this decision also makes sense for my project because my entity relationships will likely be fairly straightforward for the most part and using an ORM will allow me to make a lot of progress very quickly without (I hope) causing me lots of trouble later on.

His handy wrapper (Data Manager) makes it simpler to perform the flush and still take transactions into consideration. His simple class includes "flush", "commit" and "startTransaction" methods that don't actually perform the flush until the commit is called.

On the Liip blog there's a recent post looking at table inheritance with Doctrine, the popular PHP ORM tool. In the post, Daniel Barsotti talks about a database model that needed some updating due to their searching needs.

Our first idea, and it was not that bad, Drupal does just the same, was to have a database table with the common fields, a field containing the type of item (it's either an event or a blog post) and a data field where we serialized the corresponding PHP object. This approach was ok until we had to filter or search LabLog items based on fields that were contained in the serialized data.

To resolve the issue they turned to multiple table inheritance, relating the LabLogItem to both a BlogPost and Event. They also show how it could be modeled with a single table, but opt for the multiple method. Included in the post is the Doctrine-based code showing how to create the parent entity for the LabLogItem and the two child entities for the blog post and event. There's also a brief snippet showing how to use them with the EntityManager.

On DZone.com today Giorgio Sironi has a new post showing how you can use Doctrine with MongoDB to work with Document objects from the database.

In the PHP world, probably the Doctrine ODM for MongoDB is the most successful. This followes to the opularity of Mongo, which is a transitional product between SQL and NoSQL, still based on some relational concepts like queries. [...] The case for an ODM over a plain Mongo connection object is easy to make: you will still be able to use objects with proper encapsulation (like private fields and associations) and behavior (many methods) instead of extracting just a JSON package from your database.

He briefly mentions that the PECL extension for Mongo needs to be installed prior to trying out any of the examples. His first example shows how to create a DocumentManager (similar to the normal EntityManager for those familiar with Doctrine). He also shows an integration with the ORM and shares some of the findings he's made when it comes to versioning the resources (hint: annotations are your friend).

In this new post to his blog Phil Sturgeon talks about what he (and apparently several others) think is the "way forward for PHP" to make it a better language and ecosystem - packages.

What is a package? A package is a piece of reusable code that can be dropped into any application and be used without any tinkering to add functionality to that code. [...] Most package systems also allow for something called dependencies. [...] This is how most modern programming languages work, but to make a generalisation: PHP developers hate packages. Why? Well while other languages have great systems like CPAN for Perl, Gems for Ruby, PIP, PHP has had a terrible history with package management going back years.

He talks about one of the main current packaging systems, PEAR, and how, despite its attempts, it just hasn't seen the adoption the package management of other languages has. Phil makes a recommendation that is slowly becoming more and more popular in the PHP community - building "unframeworks". These sets of reusable components (similar to the ideas behind Aura, Symfony and Zend Framework 2) are designed to be dropped in and used without the dependencies of the frameworks they live in. He points to the Composer/Packagist dynamic duo as a way through all of the current packaging issues - a simple way to make any project an installable package just by adding a configuration file.

Jeremy Cook has put together a new post showing how he got PUPUnit, Doctrine and MySQL to "play nicely" together when he was writing up some of his tests in a current application.

One of the pain points for me though has been in getting Doctrine setup with PHPUnit for testing. One of the main Doctrine contributors, Benjamin Beberlei, has written a package called DoctrineExtensions which amongst other things adds a class called DoctrineExtensionsPHPUnitOrmTestCase which extends PHPUnit's DbUnit database test case class. This all works well in principle but hits a major snag in reality: MySQL doesn't allow InnoDb tables with foreign keys to be truncated. PHUnit's database extension truncates the database tables before each test run and inserts a fresh set of data to work with.

To work around this issue Jeremy by porting over a method posted by Mike Lively over to Doctrine as a custom "MySQLTruncate" class (code included in the post). He also includes some sample code showing it in use - a basic ORM test case that calls the truncate method when its set up.

In a new post to his site Till Klampaeckel shows how to use PEAR and composer resources (two popular PHP package management tools) from inside of a chef deployment script.

This is something experimental I have been working on for our chef deployments. So the objective was/is to find a sane way to install PEAR packages and install dependencies with composer.

He shows how to set up the configuration script to discover a new PEAR channel, make the chef script not "fail hard" if a command returns a failed response code (as PEAR will do if the channel is already discovered). The "ignore_failure" configuration directive comes in handy for this. He also shows how to implement a LWRP in chef for both a PEAR and Composer resource.

You can find the code for this and other cookbook examples on his github account.

Building on the graphing tutorial in his last post Sameer continues on looking at graphs in PHP with this new post showing how to create an "agency matrix" of a currently built graph.

Building a graph is not enough; we also need the ability to search through it. To make it easier to build search algorithms, it is useful if we can represent the graph and its connections in a different way; adjacency matrix being one such representation. An adjacency matrix is a means of representing which vertices (or nodes) of a graph are adjacent to which other vertices.

He includes some sample code to extract the data from a graph (built with the PEAR Structures_Graph package) and create a basic "table" of information about each nodes' connections.

In the latest post to his blog Sameer Borate takes a look at using the Structures_Graph package from PEAR to create data structures in PHP with linked nodes for directed and undirected graphs.

The Pear Structures_Graph package allows creating and manipulating graph data structures. It allows building of either directed or undirected graphs, with data and metadata stored in nodes. The library provides functions for graph traversing as well as for characteristic extraction from the graph topology.

After sharing the one-line install, he shows how to create some instances of the package's Nodes and how to connect them to a graph and link them to other nodes. He includes a few examples - a simpler one with multiple nodes joined in a directed graph, another showing how to associate data with a node and how to query the graph for node connections and testing to see if the graph is acyclic.

In a recent post Marcelo Gornstein takes a look at using dependency injection with Doctrine2 using his Ding container.

This article will show how we can develop software in php with a nifty design and architecture, and very much like other languages like java, using an ORM and an AOP, DI, Events container. I will assume you've read (or at least took a quick look) at this article that explains the tree layout used throughout the code, and that you have some basic knowledge of Doctrine2 and used it before on your own.

He starts with the result - an easy to use, self-contained (and decoupled) system for accessing the Doctrine2 instance. It's event-driven and uses Aspect-oriented programming to mange interactions between components (or as he calls them "beans"). Code is included for the entire process for a logger, the User entity, entity manager, user repository and transactional aspect. You can find the complete source for his example on his github account.

Mike Wallner has shared a quick and easy HTTP caching technique in a new post to his blog today. The key is in using the PEAR HTTP_Header package.

Ever watched youself browsing e.g. a web forum? Noticed that you viewed the same page several times? Well, this means extraordinary and useless load for your server if there's no caching mechanism implemented in the web application. Even if there is some file or db cache you can still improve performance with implementing some http cache.

With a few simple lines of code using HTTP_Header, you can tell your scripts how long to set the "expires" header to on your requests. This increment (in seconds) is relayed to the browser to tell it when to next fetch the page and not reload from cache.

Mike Purcell has a new post to his blog showing a method he's followed to be able to use the popular PHPUnit unit testing software without having to go through the PEAR installer to get there.

PHPUnit is a great tool to protect us developers from introducing new defects when adding new features or re-factoring code. However there is one HUGE downside to PHPUnit; it must be installed using PEAR. Personally, I don't like 'auto-installers', I'd prefer to know what exactly is happening behind the scenes with regards to which libraries are required and how they are being called. [...] After breaking down the PHPUnit source code, I realized it could be installed without going through PEAR, and without too much headache.

He walks you through the directories you'll need to set up (test/vendor), the commands you'll need to get the latest version and unpack it, changes to set up some symlinks and updating the PHPUnit source to modify the autoloader, bootstrap and phpunit executable.

On the PEAR blog today there's an update about the migration over to github that 5 million lines of code has already made:

Since October 2011, 5 million lines of the PEAR codebase has shifted to github. Hand in hand with this shift has been the tireless work of Daniel C - someone who brazenly said "I will fix the failing packages!" in the tail end of last year.

As a result of his efforts a list has been created of known good packages to use with PHP 5.4. Other results include:

• All test infrastructure upgrading to PHP 5.4 release candidates
• All database driven test suites executing properly, catching a variety of simple bugs
• Hitting a point of "near zero" patches to be applied to unmaintained packages
• Increasingly, the PEAR QA team is delivering PHP 5.3+ friendly forks of existing packages

In this new post to his blog Ade Slade shows how to integrate the Pimple lightweight dependency injection container with a Zend Framework application.

This post will describe a way to integrate Zend Framework 1 and Pimple. A complete working version of the code is available on github. Thankfully, Zend Framework 2 features its own Dependency Injection Container. Happy days. Still, if you're not prepared to wait, you may find this useful.

He shows how to add a resource plugin into the Pimple container - an entity manager that's part of Doctrine. He creates his controller, pulling the manager from the Pimple container and includes a unit test for the controller too (using PHPUnit, but he also suggests Mockery).

NetTuts.com has posted a second tutorial in their series focusing on the Zend Framework today. In this latest article they focus on integrating the powerful Doctrine ORM with a Zend Framework application.

Ready to take your PHP skills to the next level? In this new "From Scratch" series, we'll focus exclusively on Zend Framework, a full-stack PHP framework created by Zend Technologies. This second tutorial on our series is entitled "Models and Integrating Doctrine ORM".

They continue on from their previous tutorial to talk about what models are (with an example involving "bankers"). They also show how to use the Zend Framework "zf" command line tool to configure your database settings, set up the tables and download/bootstrap the Doctrine code. The include the code to create some simple models and how to use them to create and update records in your database. You can grab all of the sample code for their examples from The Next Social's github repository.

On the PEAR Group blog there's a new post welcoming all new contributors to the project and pointing out that the PEAR account on Github has officially passed the 200 repository mark in the move from SVN to Git.

PEAR is about providing the PHP community with reusable, effective components - this has been our mission since day 1. If there is anything we can do to make that goal happen, to assist you as an individual or company, I would strongly encourage you to let us know - we're here to help.

They mention the work of two individuals that have done good work on a specific package, meldra and Gemorroj - perfect examples of how the move to Github has made it simpler to implement changes that have been "waiting in the wings" on the XML_Feed_Parser and Image_Barcode2 packages.

If you've had changes you've wanted to make to a PEAR package in the past but haven't ever gotten them submitted, there's not a better time than now.

If you missed out on the Future of PEAR/Pyrus webcast event put on by Engine Yard, you're in luck - they've posted a recording of the event.

In this panel discussion, we tackle topics including the direction PEAR and Pyrus will be going in the next few years, obstacles that may be on the horizon, and more.

PEAR is the package library of standardized packages for a variety of common development tasks. Pyrus is a new package manager to make installing and maintaining PEAR packages simpler. Engine Yard's next webcast will cover the Lithium framework with core contributors Nate Abele, Garrett Woodworth, and John Anderson on December 1st.

On the php|architect site Jeremy Kendall has a new article looking at geolocation in PHP and how, despite some comments in the past about its difficulty, some more recent tools make it relatively simple.

Have you ever wanted to add location-aware content to your web applications? Would you believe me if I told you it was dead easy, and you could be up and running in about 10 minutes? The first thing you want to do is use someone else's work. Geolocation is a solved problem; there's no need to roll your own. I went searching for free Geolocation APIs and found two I wanted to try: MaxMind's GeoLite API and Quova.

He briefly introduces each data source - GeoLite as a downloadable database and Quova as an API. Sample code is included for using the data from both of these services to find a location based on an IP address. He does include one caveat though - be careful about accuracy, they usually only promise things to be within 25 miles of the spot you're actually looking for.

EngineYard, a company that recently merged with the PHP platform as a service provider Orchestra.io, has a new live panel podcast about the Future of PHP, specifically involving PEAR and Pyrus.

If you are a PHP developer using PEAR and Pyrus, we invite you to join us this week as we explore the future of PEAR and Pyrus. We'll be discussing issues such as where PEAR/Pyrus will be going in the next few years, what obstacles may be on the horizon, and how they're going to get where they're going.

The live panel, hosted by Elizabeth Naramore, will include experts from the two projects: David Coallier (President), Helgi Þormar Þorbjörnsson, Brett Bieber, and Till Klampäckel. There's still time to sign up to attend - the show happens on November 17th. To put your name in to be a part of the event, fill in the info here and you'll be sent more information about attending.

On the PEAR blog today it's been pointed out that many PEAR packages are moving to github as their standard place for development and repositories under the pear and pear2 accounts are available for anyone wanting to make the move.

While the existing PEAR packages will continue to use the pear.php.net distribution and bug tracking capabilities; it's never been easier to contribute to a PEAR package - simply fork; add your changes and send us a pull request. If your preferred packages aren't yet on github, please feel free to drop us a line on the pear-dev mailing list.

Here's more about the process to get the repository set up and how to migrate your package's current code from SVN over to github. The transition's pretty painless and can make the social development and improvement of your package a lot simpler.

On PHPBuilder.com Jason Gilmore has posted a first peek at Zend Framework 2, an upcoming reworking of the popular framework with PHP 5.3-centric features.

Version 2.0 seeks to improve upon the current release in a number of ways, focusing on making it easier to get started using the framework, improving performance, and fully embracing the latest PHP language enhancements made available to version 5.3. [...] Although the official release won't be out for several more months, it never hurts to take an early look at what the future holds for a technology used by countless PHP developers around the globe. In this article I'll present a meandering introduction to the key version 2.0 features that I find particularly compelling.

He starts with a brief tutorial on getting the latest version of ZF2 from the git repository and creating basic project. The changes in the framework have fallen into a "rewrite only where it makes sense" mentality and changes have really only been made transparently to the backend or as new features/components like module management and Doctrine 2 integration. He also points out a few resources you can use to keep up to date on the latest from the framework including the changelog, mailing list and the ZF2 blog.

The PEAR blog has a recommendation for those that might not have updated their package udage in a while - there's been major changes in many packages, but two in particular.

We've had 60 releases since July. While most are often minor improvements or bug fixes; a number of packages really stand out. Net_DNS2, and HTTP_Request2. Each of these packages represents the second edition of their respective APIs; each having been honed over time to a point of stability.

Net_DNS2 gives you the ability to communicate and resolve host names/domain names inside of a PHP application. HTTP_Request2 gives you a simple way to perform HTTP requests.

Ken Guest has a new post today talking about a PEAR package he's been developing, Services_Openstreetmap, to interact with the OpenStreetMap service to make it simpler to work with OSM data, adding new locations and working with users.

So over the last while, I've been working on a PHP package imaginatively named Services_Openstreetmap, for interacting with the openstreetmap API. I initially needed it so I could search for certain POIs and tabulate the results; it's now also capable of adding data to the openstreetmap database - nodes and other elements can be created, updated and so on. It will even access the details of the user that is being used to modify that data, which is one difference between it and the other single purpose OSM frameworks.

He's submitted it to PEAR for official inclusion. Until then, you can download the package from github. The OpenStreetMap project is a community-driven mapping tool that allows users to provide new map information or make updates in an effort to keep things more up to date.

On PHPMaster.com today there's a new tutorial showing you how to integrate Amazon's S3 service with your application via the Services_Amazon_S3 PEAR package.

In the process of reviewing documentation for Orchestra.io, I found that it doesn't allow file uploads. Instead, it's recommended that Amazon S3 be used for file hosting. If you aren't familiar with it, S3 is an online storage web service that is part of Amazon Web Services (AWS). It provides access to fairly cheap storage through a variety of web service interfaces. This article will demonstrate how to sign up for an Amazon S3 account and use PEAR's Services_Amazon_S3 package to interact with S3 in your own application.

They walk you through the whole process - getting signed up at the AWS site, creating credentials, installing the Services_Amazon_S3 package (via the PEAR installer) and using it in some sample scripts.

Stuart Herbert has put together a series of posts detailing how to get the Phix component creation and management tool installed on various operating systems.

Phix makes it extremely easy to create and maintain your own PEAR-installer compatible components for reuse in your PHP applications. Installation takes just seconds, and it's both open-source and framework-agnostic!

The OS guides help you get it installed for:

• OSX
• Fedora
• Ubuntu
• Debian
• CentOS

For more information about Phix (including helpful "getting started" details) check out the project's website.

On PHPBuilder.com today there's a new tutorial helping you integrate weather data into your site with the help of the Services_Weather PEAR package.

Regardless of whether you consider the weather to be an obsession or nuisance, there are plenty of opportunities to incorporate weather-related data into your Web application. The Services_Weather PEAR Package offers what is perhaps the easiest way to begin retrieving weather-related data.

Included in the post are the commands you'll need to get the package installed (via the PEAR installer) and sample code to set up the connection - in this case to Weather.com - to fetch the results for a search location. The "search" method will return the best guesses for your input and give you the unique code to use for fetching other values, like the current forecast.

In a new post Bertrand Mansion shows how he combined the versatility of the PEAR QuickForm2 package and the Bootstrap project from Twitter to quickly make a form using the project's styling (CSS).

I don't know about you, but for me building HTML Forms and styling HTML Forms are maybe the most boring things in web development. It's repetitive and takes a lot of time to do things correctly. That's why tools like Twitter's Bootstrap and PEAR's HTML_QuickForm2 can help with this part of our job. Wouldn't it be nice to have QuickForm2 generate a markup compatible with Bootstrap CSS, so that you could get a nice looking form without to much efforts? Well, that's what I plan to do here.

He starts by creating a simple QuickForm2 form with no renderers attached (no pre-defined styles) and a custom render callback that wraps the items in "div" tags with the correct styles. There's also a custom renderer included for grouping items with additional styling attached.

In his latest post to his Web Species blog Juozas Kaziukenas looks at dependency management in PHP applications and offers a few suggestions of how you can make them easier to track.

Rarely a project lives by itself, especially in the days of frameworks. Furthermore, there are a lot of great open source libraries you might want to use to save time. But all of this raises a new problem - how could we manage all those dependencies. Here are some thoughts on this problem and how you might want to solve it; without shooting yourself in a foot.

He mentions svn:externals and git's submodule as options in version control systems, PEAR for package management, Apache Maven and the deps file in the Symfony framework.

Stuart Herbert's latest post in his "PHP Components" series looks at an optional but handy thing you can include in your component's package - web pages (be they a manual or other kind of information). This new post talks about where they should lie in the component's package structure.

I'm now going under the bonnet of our components, and looking at the different file roles that the PEAR installer expects to find when we distribute our component as a PEAR-compatible package. It isn't very often that a component needs to ship web pages too, but should the need arise, here's how to do it.

He starts by defining what a "web page" could be (HTML, Javascript, CSS, etc) and gives the place in the hierarchy they should fit. When you use the PEAR client to install the package, these files are placed in the "www" folder of your PEAR installation.

On DZone.com today there's a new post from Krzysztof Kotowicz sharing a presentation of his about protecting your application from SQL injection.

The materials teach how to use prepared statements, how to escape and write secure stored procedures. Many PHP projects are covered - PDO, Propel, Doctrine, Zend Framework and MDB2. Multiple gotchas and caveats are included. I discuss why escaping is usually the wrong choice, which practices to avoid or follow and how stored procedures sometimes offer no protection at all.

The presentation (as posted to Slideshare) starts with some of the basics - what SQL injection is and an example of how it could be used to bypass security. He covers how to use prepared statements in each of the technologies (with code snippets), methods for escaping data and how to create stored procedures that are protected from the same threats.

Bertrand Mansion has a recent post to his blog looking at repairing missing functionality in the latest OS X update (Lion) with the intl extension and gettext (not installed by default).

Mac OSX Lion ships with PHP 5.3.6. [...] These are all very good solutions, but since I prefer to travel light and the version in Lion already comes with a lot of useful extensions, I preferred to go with it.

He shows how to update the default Lion PHP install to include some of the things he needed for his development including:

• setting up the php.ini file
• installing PEAR/PECL
• installing the intl extension
• and a hack to get gettext working (renaming a base function)

On the Leaseweb Labs blog there's a recent post looking and some of the things you can do to optimize Zend Framework and Doctrine when used together for database access.

In principle, the combination of Zend Framework with Doctrine is not too difficult. But first let's talk about the preparations. According to the author of Zend Framework, the default file structure of project can be a bit more optimal.

They start by describing this optimized file structure (moving the models out of the modules and into the library) and what you'll need to change in Doctrine's configuration to make this work. The post also includes examples of what the larger config should look like when the changes are made. They show how to extend the default Doctrine CLI tool to make a custom "sandbox" instance and show some tuning you can do on the Zend Framework side so it can optimally work with the new models.

Pim Elshoff has a recent post to his blog looking at a "kickass development environment" he's gotten working on Windows that includes PEAR, some type of version control (git or svn - take your pick), Ant for builds and Jenkins for continuous integration.

Recently I have become quite interested in quality assurance. Not that many things are going wrong for me, but I'd really like to be more certain about the quality of my work. I've used some tools to help me achieve just that. In less than two hours you can set up your workspace and have the living daylights automated out of you!

He provides a full guide to getting the full stack set up including the command-line calls you'll need to make, creating a new build file for Ant and setting up the PHP tools (like Phpmd, DocBlox and Pdepend). In the end, you should see something similar to this setup in your Jenkins build.

Rob Allen has posted his own guide to getting PHP 5.3 set up on OS X 10.7 Lion, the just-released update for Apple's operating system. It comes with a bundled set of PHP-related tools but you might want to set them up your own way. This is where the guide comes in.

With OS X 10.7, Apple continues to ship PHP 5.3 with PEAR, GD and PDO_MYSQL out of the box. This is how to set it up from a clean install of 10.7.

He goes through each of the pieces of software and talks about where to download the latest from and what configuration steps are needed:

• MySQL
• Apache
• the php.ini
• Xdebug
• PEAR
• PHPUnit (and friends)
• PECL OAuth
• mcrypt

Christian Weiske has a new post to his blog today on how to get PHP extensions installed for phpfarm, the tool that lets you switch between multiple PHP versions on the same machine.

When using several PHP installations with phpfarm, installing PHP extensions is not always easy - mostly because Pyrus is very strict about package files - and many of the packages in PECL unfortunately have invalid non-validating package.xmls.

The installation follows most of the normal process with one exception - you use the phpfarm phpize and point the configure to use the phpfarm ini configuration file then enable it as usual.

In a new post to his blog Jigal Sanders shares some of his experience in working with Doctrine 2.1 in a Zend Framework-based (1.11.9) application for his database interface needs.

I hadn't been using Doctrine for a while and decided to pick it up two weeks ago, as we wanted to see if we can implement it for our CMS at our office. So I setup a clean installation of the zend framework (1.11.9) and tried tried to implement Doctrine. The main goal was to see if we can reverse engineer existing databases and then start doing some queries.

There were three things he found in the process that caused a few issues:

• A confusing set of terms and features that weren't explained well enough to know their use
• Getting things like autoloaders working with the Zend Framework to make things work well together
• A potential bug with the "name" property on an object and some automatic namespacing Doctrine tries to do

There are already a lot of resources available on the Internet. I have looked at various configurations, like for example the 'bisna' project from Guilhere Blanco. But I keep saying that it's really difficult and has a steep learning curve. Doctrine 1.2 was really simple. Doctrine 2.x is a lot more difficult to get into.

As the first part of a series, Tom Jowitt has posted this introduction to setting up a brand new development environment with some of the basic tools any PHP developer should need.

I dunno about anyone else but my development environment is usually in some form of barely-controlled chaos. It's one command away from collapse with folders full of test software, symlinks that lead to long-forgotten libraries and ancient VCS repos that only a mother could love, all held together with sticky-tape shell scripts. [...] This series of posts will look at the tools available to PHP developers who want to be liberated from the mundane and the frustrating tasks that plague our lives.

He doesn't describe the installation of the basic platform - Apache, PHP and MySQL on Ubuntu - but jumps right into the details of the settings. He shows how to:

• configure the VirtualHosts in Apache,
• installing and updating PEAR,
• Install/configure XDebug,
• Set up PHPUnit,
• and install git for version control

In the next post he'll show how to set up Phing for building/testing out the code.

On the PEAR blog there's a new post talking about some of the things coming up in July that you might want to take note of.

There's nothing quite like having your blogging system go MIA for a while to give your community an overwhelming impression that no one is home. Thankfully; despite the radio silence between updates there's quite a lot to talk about!

The updates include mentions of several new PEPr proposals for packages related to Mercurial support, Twitter and holiday date validation. There's also a mention of the large amount of PEAR channels that are popping up and the future of PEAR in PHP 5.3+ with Pyrus.

On the PHP on Windows section of DZone.com today Giorgio Sironi has posted about a different sort of object mapping than is usually thought of with databases - object-document mapping.

The Data Mapper pattern is a mechanism for persistence where the application model and the data source have no dependencies between each other. [...] But everytime we talk about the Data Mapper pattern, we assume there is a relational database on the other side of the persistence boundary. We always save objects; we always map them to MySQL or Postgres tables; but it's not mandatory.

He talks about two projects, MongoDb_ODM and CouchDb_ODM, that the Doctrine project is working on to help make working with document-driven databases as simple as the usual ORMs. He includes a brief code snippet showing how the feature will work (hint: a namespace of Document instead of Entity). He lists some of the features - including the usual ORM capabilities, support for collections, cascade of persistence - and where you can get the latest code for it (from github and PEAR

Fabien Potencier has a new post to the Symfony blog today - an announcement about the setup of a PEAR channel to make it easier to grab the various Symfony components individually.

One of the strengths of Symfony2 lies in its components; they define the building blocks of the framework and they can be used as standalone libraries. [...] The Symfony2 components have been available on Git for quite some time now, and as of today, I'm really excited to announce that they are also installable via the brand new Symfony2 PEAR channel, powered by Pirum of course.

Packages included in the list installable on the PEAR channel include:

• BrowserKit
• DependencyInjection
• HttpKernel
• Serializer
• Validator

Padraic Brady has a new post to his blog asking you, the reader, for your suggestions on how to architect a distribution system for the PEAR2/Pyrus components.

With the idea of PEAR2 and Pyrus, I had hoped to see a renewal - the advancement of a PEAR architecture for the 21st Century. Instead, and this is just my opinion, PEAR2/Pyrus were a relatively simple iteration on a very old theme. [...] If the PEAR ecosystem has a failing, it is one of staggered evolution. Over time it has picked up additional features tacked on top of a base model.

He breaks up his thoughts on the future of PEAR2/Pyrus distribution into a few different topics - the issues he sees surrounding packaging (like static packaging definitions), suggestions for a dynamic channel aggregation system and overall usage of the PEAR system.

On the Test.ical.ly blog there's a new post looking ahead to the next release of PHP, 5.4, and what it could mean for some of the popular tools out there - specifically Symfony and Doctrine.

It shouldn't be long until the first alpha version of PHP 5.4 will be released and with it there will be a lot of new features such as array dereferencing and traits to name but a few. What does that mean to the roadmaps of Doctrine and Symfony?

He mentions the experiments that are proposed on the Doctrine project that could be one of the major driving forces behind Doctrine 3. He points out that, as long as Symfony stays non-PHP 5.4-only, users will still have the choice of Doctrine 2 or 3. There are two issues he points out, though, that could cause problems for both projects - the choices Symfony makes in things like its quickstart guide and the DoctrinBundle vs Doctrine3Bundle situation that could come up.

Sebastian Bergmann has a new post to his blog talking about some of the future plans for better code coverage metrics for PHP applications (not just the statistics that we have now as generated from PHPUnit runs combined with Code_Coverage PEAR package and Xdebug).

Xdebug currently only supports what is usually referred to as Line Coverage. This software metric measures whether each executable line was executed. Based on the line coverage information provided by Xdebug, PHP_CodeCoverage also calculates the Function / Method Coverage software metric that measures whether each function or method has been invoked.

The various kinds of coverage they're planning the in future include statement coverage, branch coverage (boolean evaluation), call coverage, path coverage with an alternative of linear code sequence and jump coverage (LCSAJ).

On PHPBuilder.com today Jason Gilmore has posted a tutorial showing you how to use the PEAR HTML_Table component to quickly and easily display tabular information on your site.

Because the task [of building tables] is so commonplace, personally I prefer to treat it like stamping out a widget, and rely on a drop in solution. While several such standardized solutions are available, I generally prefer to use HTML_Table, a great PEAR package which makes tabular data presentation a breeze. In this tutorial I'll walk you through several of HTML_Table's key features, additionally showing you how to integrate CSS and jQuery to create an eye-appealing and interactive tabular layout in no-time flat.

He helps you through the install (using the PEAR installer) and starts you down the right path with some sample code creating a table based off some example data from an array. He shows how to add headers, put in some CSS for styling them and for making the rows highlight on mouseover. He finishes it with the jQuery bit that uses the tablesorter feature to dynamically allow sorting of the table based on the values in each column.

Ryan Mauger has written up a new post about an integration he's done using the Twig templating engine (from be Symfony community) with his Zend Framework application to make view handling simpler.

Mostly I thought [what Twig offered] were silly things that were not really needed unless you had a team of designers to work with, however, during my exploration, a couple of things occurred to me that I had not considered about templating systems before. One being the enforced separation of concerns they provide; you simply cannot do anything from inside them which you shouldn't be, keeping your presentation very very clean. The second, being that they're not all as terrible as Smarty.

He helps you get Twig installed (via PEAR chnnel) and includes the code for an application resource and the changes you'll need to make to your application.ini to get things working. He uses a base controller setup, so he shows how to introduce a "twig()" method into that to help with rendering. Finally, there's a sample class included that includes two actions, both using this "twig()" method to pas the output data through the twig interpreter and out to the view.

On the Symfony blog there's a new post about how Symfony2 is "getting easier" thanks to some recent changes with improved error handling and simpler configuration options.

With the release of the first beta approaching fast, our main focus has switched from adding new features to polishing existing ones. [...] Recently, Ryan and I have spent our time tweaking error messages, simplifying the code and the configuration, adding more documentation, and making things more consistent throughout the framework. The goal is to ease the learning curve and make things that people will need on a day to day basis simpler.

The changes they've made include three updates - better Twig error messaging, better configuration error messaging and some helpful changes to the Doctrine configuration to allow for auto-mapping of connections when the traditional one-database setup is used.

If you're still interested in contributing your ideas and feature requests for a PEAR channel aggregator, Stuart Herbert wants to know (last call before the development starts).

There's already been a sizeable response so far, but if you haven't had your say yet, please head on over and leave a comment soon. I'll write up a summary of the suggested requirements on Monday.

The idea behind the aggregator is to provide a single place for developers to look (besides the PEAR site, of course) for PEAR packages they might find useful. The key here is that the aggregator would be bringing together the independent channels out there and making them simpler to find. Feature suggestions so far include: showing where the library lives (like github or bitbucket), creating a proxy channel for a "single install" location and customized lists of a user's "in use" and "tracked" packages.

In his latest post Padraic Brady talks about an effort that's been put out there (by Stuart Herbert) to come up with a PEAR channel aggregator - something he fully supports.

Since we seem to like blaming the PEAR Group, and getting that ball kicked back to us, it's time we did something useful. We've spent too much time ignoring PEAR as we grew apart from it with our frameworks, standalone libraries and custom plugin architectures. We're making life harder for ourselves in doing so. Stuart Herbert has posted a short article to gather requirements for a Pear Channel Aggregator. I strongly suggest that interested PHP programmers drop by and add a comment with some suggestions/feedback.

Stuart's suggestion has already gathered some good comments and suggestions from all around the community including some mentions of efforts from the Symfony project to do something similar.

On PHPBuilder.com today there's a new tutorial about using the PEAR Pager package to paginate through results from a MySQL query. The package makes it easy to pass in a data set and handle the pagination requests and interface.

Fortunately a great solution [for paginating data] is at your disposal which has been created expressly for this purchase. The PEAR Pager package will not only handle all of the gory tracking details for you, but it can also create a linked navigation list which you can embed into the page as a navigational aide for the user. In this article I'll show you how to use Pager to easily paginate your database results in a structured and coherent way.

He walks you through installing the packaged (thankfully easy with the PEAR installer) and how to use it on a simple array dataset of college names. From there he moves into the database realm, creating a simple table that stores the same information and pulling the results out and into the Pager functionality.

Inspired by some of the recent discussions in the PHP community about the future of the language and the software that uses it, Till Klampaeckel has posted some of his own thoughts on the matter.

Last week the usual round of PEAR-bashing on Twitter took place, then this morning Marco Tabini asked if PHP (core) was running out of scratches to itch. He also suggests he got this idea from Cal Evan's blog post about Drupal forking PHP.

Till talks about a few different points others have made in their comments and tries to clear a few things up - the state of PECL, Drupal and PHP (and forking), PEAR and how some of this infighting might be doing more harm than good for the community.

In a new post to his blog Marco Tabini poses an interesting question - is PHP running out of itches to scratch in the evolution of the language?

think it's fair to say that the pace at which PHP core is being developed has slowed down considerably over the past couple of years, while the development of many projects based on it, like programming and application frameworks, has sped up and continues to grow at a fast pace. But this doesn't mean that we're running out of steam. The PHP ecosystem is simply refocusing outside of core, where it has a lot more freedom of action.

He suggests two reasons as to why this slowdown might be happening - first that there's not a sense of strong leadership in the core development group (a feature of the project done on purpose) and the change to move new library support out to PECL and PEAR instead of directly into the core of the language.

The risk facing us, as I see it, is not that Drupal, or WordPress, or whoever may decide to fork PHP or abandon it altogether. Rather, the problem is that there is no real way for these projects to provide upstream positive feedback to PHP core.

Stuart Herbert has a new post to his blog today that shares some helpful hints about dependency quirks that can come with using PEAR packages and the PEAR installer.

To save myself a bit of effort, I thought it would make sense to make my API client reuse PEAR's existing HTTP_Request2 component. No sense in re-inventing the wheel, I thought. But that's where my troubles began. [...] There are a few quirks in the way that the PEAR installer handles version numbers, and you need to know how to deal with them if you're going to re-use PEAR project components in your own apps.

He shows how a dependency can be set up for the HTTP_Request2 package as a part of the update to his project. He talks about changes to the project's package.xml file and the trick with version numbering to get the latest. In this case, the latest is a non-stable alpha/beta component and the package.xml file needs some special handling to cooperate there (version, stability, release, api and min/max).

Dan Scott has posted an example of how to create a MARC record (machine-readable cataloging, more details here) from scratch with the help of the File_MARC PEAR package.

In the past couple of days, two people have written me email essentially saying: "Dan, this File_MARC library sounds great - but I can't figure out how to create a record from scratch with it! Can you please help me? Yes, when you're dealing with MARC, you'll quickly get all weepy and get help from anyone you can.

His example code is pretty simple - load the PEAR package into the script, create the record object and start adding fields to it. He shows various output methods ("pretty print", writing the raw data to a file, etc.) and the output to various other data structures like JSON and XML.

Ken Guest has a recent post talking about some recent updates that have been made surrounding the PEAR support for finding holiday dates in various parts of the world.

In the space of just under a month Date_Holidays_Croatia and Date_Holidays_Australia were released - many thanks to the guys who did the actual hard work to be fair as all I did was package them up and release them!

You can find more of these Date packages on the PEAR site that could help you and your application get things a bit more localized. He also reminds you that, if you'd like to help out and pick up support for some of the older, unmaintained packages, you can follow this guide and get started easily.

Till Klampaeckel has posted a few suggestions for you if you'd like the take the reigns of a PEAR package when it's not maintained.

One of the more frequent questions I see on the mailing lists and IRC is, "How do I take over a package?". Very often people start to use a PEAR package and then at some point encounter either a bug or they miss a certain feature. The package's state however is inactive or flat unmaintained.

He recommends a few different courses of action - first asking if there's a way to help out, then stepping it up and pushing the fixes in yourself and, finally, deciding if you really do want to maintain the package (and show it by contributing).

In a new post to his blog Mike Willbanks shows you how to build and maintain a PEAR server with Phirum.

Pirum is a simple PEAR channel server manager that was built by Fabien Potencier. The Pirum project allows you to easily setup a PEAR channel and publish your own packages quickly. This quick blog post / article will get you going with it in no time.

He shows you how to install Phirum (ironicly from a PEAR channel) and how to create the XML to define the PEAR service. Running Phirum will generate a few other files based off the XML configuration and adding in a package is as simple as a "phirum add" call. He also mentions adding support for cloning packages with the help of his updated fork on github.

New on the ZendCasts.com site there's a screencast showing you how to unit test Doctrine 2 entities.

His example came from a webinar recently presented by Zend to integrate unit testing with the help of the Symfony console. He shows how to set up a configuration (sans yaml) in your Zend Framework application's setup and a bootstrap to get them all working together.

This screencast is about 45 minutes long and, if you'd like more information on unit testing with the Zend Framework, check out the side bar for looks at testing with Zend_Form and action helpers.

The Zend Developer Zone has posted the second part of a series from Vikram Vaswani about using the Stack Exchange API to pull questions and comments users have posted to the site. In this second part of the series he shows how to get more information about those users and their activities.

The thing to remember about questions, answers and comments, though, is that they don't exist in a vacuum. They're created by users, and it's the users that make the site tick. That's why the Stack Exchange API includes a large number of methods designed to let developers access user profiles and timelines, and unearth the relationships between users and their posts. This article will focus primarily on this dimension of the Stack Exchange API, illustrating how to search for users, obtain user profiles and timelines, and retrieve information on a user's questions, answers, comments, badges and tags.

You'll need to get the StackPHP PEAR package to follow along with the code examples (it does some of the hard work for you). He shows how to:

• Grab a list of users ordered by reputation
• Search for usernames matching a string
• Get badge information (in general and for a user)
• Finding a user's activity timeline

Near the end he also includes an example of using the Zend_Paginator component of the Zend Framework to filter down the results to a more manageable size.

Chris Hartjes, after finally figuring out an issue with database migrations with Doctrine on a Zend Framework application, has posted about the process to his blog today. As he notes:

This posting is a lesson on the value of actually looking at the source code of a third-party library when you are trying to figure something out...

His problem wasn't with the features of Doctrine and how easy it made to automate things in his environments (continuous integration). His issue was that Doctrine wanted to run all of the migrations every time it was executed. Upon closer inspection, he found the key - a migration_version table in his database that held current migration information. He includes a simple Zend Framework-based script he's now using get the latest value from that table and execute only the migrations after that. The migrations are executed in order - he recommends using a timestamp or formatted date on the filename to set the order.

On the Ibuildings techPortal today Harrie Verveer has a new post looking at database version control - one of the more difficult topics for development groups - and some of the technology that can be used to help make it a bit simpler.

Database version control is something that most developers have to deal with regularly, yet only a few have actually thought about what solution might be best for them. Most people have a solution that sort of works for them, but when you ask them about the subject they are pretty convinced that there must be some better way to manage database changes, they're just not entirely sure what that solution is - but the silver bullet must be out there somewhere, right?

He starts where most developers start - their own custom script. It usually will take in a series of patch files and apply them one by one. In this case a "patch level" is stored somewhere (file/database) and is checked when the deployment is done. He points out a few issues with this method including patch naming issues and branching. Taking a step up the technology tree, he looks at other solutions like Phing+DBDeploy, Liquibase, and Doctrine migrations to try to help you find your project's "silver bullet".

Mike Lively has a new post about a PEAR channel he's set up for his Phake mocking tool on his digitalsandwich.com domain.

For those that may not have caught my first post on the subject, Phake is a mock framework that I announced a couple of days ago in Introducing Phake Mocking Framework. It was recommended in the comments that I get it on a pear channel somewhere, which is something I have wanted to do but hadn't had a reason to do until this week. Well, now there is an official Digital Sandwich Pear Channel that is hosting Phake.

Discover the channel with the PEAR installer and run the install with the path provided. He notes that the release is alpha because of the lack of documentation but, despite this, the API is stable. Also, you'll need to be using PHP 5.2+ to use the tool.

On the Zend Developer Zone today the first part of a series from Vikram Vaswani has been posted. This new set of articles will look at how to use the Stack Exchange API from your PHP applications.

The thing about Stack Overflow, though, is that it has a geeky secret of its own. Like many Web 2.0 applications, it exposes its data to the public via the Stack Exchange Web service API, making it possible to develop customized applications that run on top of the base service. This API allows access to a number of important functions, including searching for questions, retrieving answers and comments, accessing user profiles, and working with tags and badges. It's also pretty easy to integrate this API into a PHP application - and this two-part article will show you how!

In part one he introduces you to some of the conventions and tips you'll need to know when reading through the article. He shows how to get and parse a sample response (with json_decode). He also uses the proposed StackPHP PEAR package to make requests for general question information, specific details, tags, comments and search results.

Flyn San has a new post to his blog today about a better Doctrine 2 module he's created for use with Kohana framework-based applications.

Since releasing my original Doctrine 2 module for Kohana 3 (found here), I've done a bit of reshuffling of folders and added some additional features from my old Doctrine 1.2 module. Due to the extent of modifications, I decided to put up a new post with some added information on how to use the new module. For the impatient ones out there, here's the download link: Doctrine 2 Module for Kohana 3

He spends the rest of the post explaining the structure of the module, how to get it installed and working and some sample schema files (for Product and Serial tables in yaml) you can import and test with.

In this new post to his blog Robert Basic takes a look at what he calls a "real gem" in defining the requirements of his application - PHP_CompatInfo.

Last night I was pondering how nice would it be to have a tool of some sort, that would simply spit out what version of PHP does my app require. Something like: here are my .php files, what PHP version and/or extensions do I need for it? First I thought about jumping right in and writing it myself, but hey, this kind of a tool sounds way to useful not to be written already! After a bit of a googling there it was: PHP_CompatInfo. A nice PEAR package that can tell me everything I want about my code and even a bit more.

He includes a code snippet showing it in action. It's a basic example that defines the driver type to use, options and the directory to parse through (using parseDir() naturally). Other output formats are available too like CSV and HTML.

On his blog today Sameer Borate has a new post looking at using Doctrine DBAL to make schemas rather than having to make them by hand each time (can be very useful for reloads with fixtures).

A tedious task during web development is that of database schema creation. A schema containing a few tables comprising of a small set of rows is quick, while that containing dozens of tables and large numbers of columns is a tedious process. I usually resort to a small php script with some regular expression tossed in to automatically create a schema from a text file definition. But that is a little buggy as I've to manually add the indexes and other small things. Now that Doctrine has released a DBAL library, this will provide a nice ability to automatically create sql schemas.

He introduces the DBAL abstraction layer and includes a basic script to create a schema for a MySQL database, manually adding the columns and setting up things like primary keys and foreign key constraints. He also includes the SQL statements that it will generate and execute on your Doctrine-based connection.

According to this new post on the Mayflower blog, the PHP_CodeBrowser PEAR package has finally reached a stable state.

We already wrote about CodeBrowser 0.9 in August and after fixing a few minor bugs the Mayflower Open Source Labs Team is very happy to present PHP_CodeBrowser 1.0.0.

The PHP_CodeBrowser package allows quality assurance tools (like PHPUnit) to create enhanced output including syntax highlighting and colored error sections. It comes with some basic template, CSS, Javascript and image files as well as a plugin system to allow for custom handling of certain error types. You can install it from the pear.phpunit.de PEAR channel or you can check out the source on github.

On PHPBuilder.com there's a new tutorial from Jason Gilmore about how to create a PHP-based witter client with the help of the Services_Twitter package from the PEAR repository.

Entirely reinventing the wheel seems foolhardy, and so I wanted to base the project on a solid foundation, including a quality PHP-based Twitter library. That library turned out to be PEAR's Services_Twitter package. In this article I'll introduce you to this powerful package, which although still in beta already offers all of the features you'll need whether you want to build your own Twitter client or simply add Twitter-specific functionality to an existing application.

He includes instructions on how to install the package, register the application as a service and connect it via OAuth. There's also a full code listing included showing how to make the authentication from the PHP app and how to grab the latest tweets from a user.

Jani Hartikainen has posted his technique for making the Doctrine version 1 style "soft delete" in your Doctrine 2 powered application.

Doctrine 1 has the concept of behaviors which you could add to your models. One of these was the soft-delete behavior, which allowed you to "delete" records without really deleting them. Doctrine 2 does not have behaviors due to various reasons. However, I needed a way to have a model which worked like soft-delete. Let's see one approach to creating such behavior in Doctrine 2.

He introduces the idea of a "soft delete" - essentially a flag that gets set to let the rest of the application think that row is essentially deleted. He shows you how to create the similar functionality via a repository that filters the data for you. He includes code to help you along, defining the find/findOneBy/findBy and the example repository that lets you set an "is deleted" property on the object.

On Developer.com there's a new article with what they think are the top ten PEAR packages that every developer should know and use in their applications.

PHP developers also have another community-driven treasure trove at their disposal, one which is host to almost 600 high-quality libraries yet never seems to garner the attention it deserves. I'm referring to the PHP Extension and Application Repository, better known as PEAR, and in this article I'll try to shine the spotlight just a bit brighter on this fantastic community resource by highlighting 10 useful PEAR libraries (better known as packages) that have become an indispensable part of my programming toolkit.

Included in their list of "Top Ten" are things like:

• Authenticating Users with Auth
• Cleaning Up Your Code with PHP_Beautifier
• Downloading Files with HTTP_Download
• Enforcing Coding Standards with CodeSniffer
• Managing Git Repositories with VersionControl_Git

Ruslan Yakushev has a recent post about installing the PEAR tools and installing an example package, phploc.

PEAR (short for PHP Extension and Application Repository) is a framework and distribution system for reusable PHP components. In includes many useful tools and components that can be easily downloaded and installed by using PEAR package manager. This post describes how to install and configure PEAR package manager and then how to use it to install a PEAR package. An example PEAR package used in this post is phploc, which is a tool for measuring the size of PHP projects.

He recommends installing PHP via the Web Platform Installer and use the PHP 5.3 VC9 non-thread-safe package with the PHP Manager. All of the commands needed are included as well as some of the sample output that results. Once you get PEAR installed, then they show how to discover the PEAR channel and "pear install" the right packages for phploc (including the dependencies it might need).

In this new post to his blog Henri Bergius takes a step back and wonders if PHP is finally getting an ecosystem of its own (and not leaning of those of PHP-based projects.

One of my main concerns with PHP has been the lack of ecosystem. Almost all libraries and tools are written with a specific framework in mind, creating separate ecosystems around Drupal, Zend Framework, Midgard and others instead of an ecosystem benefiting all users of the language. There have been efforts at this, like PEAR before, but they have mostly stagnated.

These thoughts were spurred on by a post about the changes happening with eZ components (into Zeta Components) and how they can help reinforce the strength of the language rather than the efforts of one specific project's ecosystem.

Ruslan Yakushev has a new post about a major update to the latest beta release of the Microsoft WebMatrix tool - the update of the PHP version to support 5.3 and the inclusion of PEAR.

WebMatrix Beta 3 release has been announced recently. This release includes many new cool features that are described in release announcement and in the Web Deploy team blog. In addition to all those improvements, WebMatrix Beta 3 has much better support for PHP.

The updates make it possible to use 5.3 (prior versions only supported 5.2.x), an update to allow PHP to be enabled on a new empty site and the inclusion of PEAR whenever PHP is installed. He includes a few screenshots and instructions to help guide you through the process of getting 5.3 set up. PEAR is automatically installed when you install this latest PHP update.

In a new post to his blog Jose de Silva takes a look at how using the Cache_Lite PEAR package can help to speed up your application by reducing overhead caused by data fetching.

Cache_Lite is one of the fast, light and reliable cache system for PHP. It's an extremely easy and small learning curve system to work with. This post will try to make you a light introduction to PHP Cache_Lite.

He starts from the beginning - installing the package through the PEAR installer and setting up a basic configuration for a new Cache_Lite object in a script. Using this object you can test for the existence of a cached value or set a new one. The configuration allows you to define the "time to live" before the records expire.

On DZone.com today there's a new article from Giorgio Sironi about making the switch from Doctrine 1 to Doctrine 2 and some of what might be involved.

Doctrine 2 is an implementation of the Data Mapper pattern, and does not force your model classes to extend an Active Record, nor to contain details about the relational model like foreign keys. [...] Note that you will have to run your application of PHP 5.3 for Doctrine 2 to work, mainly because of the use of namespaces in it.

He talks about some of the other differences including maintaining PHP classes and the metadata in them rather than just a YAML schema to map to your database. There's also a difference in how to interact directly with the Doctrine engine. Direct access has been replaced with a dependency injection approach.

Amit Singh has a recent post to his blog with step-by-step instructions on how to get PEAR, PHPUnit and a WAMP installed and working on Windows 7.

In the project that i am currently working on, we decided to use PHPUnit for doing our unit testing, and i found that it was not a straight forward thing to install that I had thought it would be. I had to start by installing Pear, and as soon as i type 'go-pear' in command prompt and pressed enter key I got my first error. So here are the steps needed to install PEAR and PHPUnit error free on WAMP.

Since the steps to install the WAMP server are pretty easy, he focuses on the other two technologies. He breaks up the install into the steps for PEAR and then the steps for installing and configuring PHPUnit. Obviously you'll need to change some paths for your system, but it's a pretty simple process and you should be up and running in no time.

On the Zend Developer Zone there's a recent article about using APIs, specifically on how to use the Digg API with the Services_Digg2 PEAR package.

A few weeks ago, a client asked me to add a feed of interesting news stories to his Web application. Naturally, my thoughts turned immediately to Digg, which invariably has something interesting to read and which also offers a Web service API [...] A little Googling, and I found the PEAR Services_Digg2 class, which exposes a neat little PHP interface to the Digg API. As you might imagine, with all these tools to hand, it didn't take long to quickly integrate a feed of Digg stories into the application.

He walks you through the installation of the package (a one command step) and a secondary package you'll need due to Digg's authentication, HTTP_OAuth. He includes a request and response example (returned in JSON) as well as several code examples for sample requests, searching, working with comments on posts, post comments, "digg" stories and follow other users.

Developing applications has become simpler and simpler these days and the multitude of IDEs out there can help you keep all of your files organized and linked together so you know everything is in its place. There's one thing that only a handful out there can do, though - enforce coding standards. Thankfully, there's a tool that can help you keep your code following down the right path and PHPBuilder.com has a new tutorial about using it - PHP_CodeSniffer.

Although defined according to formal grammar and syntax, programming languages -- like their spoken counterparts -- often leave their users with a great deal of leeway for creative expression. [...] It can even be singularly counterproductive if you do not maintain stylistic consistency across projects, as you'll need to continuously re-acclimate to differing syntactical variations.

The PHP_CodeSniffer tool runs your code through a validation process and checks its structure against a coding standard (like the PEAR standard) and ensure it's formatted correctly. The tutorial shows you how to use the "phpcs" executable to test PHP, Javascript and CSSS files (using the Squiz standard).

If you've been having issues upgrading to the latest version of PHPUnit (v3.5), Sebastian Bergmann might have the answer to your problems that's related to the PEAR installer and this bug.

The new dependencies of the PHPUnit package, such as PHPUnit_MockObject for instance, are installed first. The PHPUnit package itself is installed last. And herein lies the problem: PHPUnit_MockObject installs the new version of MockObject/Generator.php before the PHPUnit package is upgraded. This upgrade deletes the MockObject/Generator.php file as it previously belonged to the PHPUnit package.

He includes two complete file listings showing the difference in the structure before and after the upgrade. The PEAR installer is at fault due to a misunderstanding it has about where the MockObject/Generator.php file belongs. The only way to fix this, currently, is to force install the new subpackages instead of just an update - DbUnit, PHPUnit_MockObject and PHPUnit_Selenium. Instructions and a resulting files tree are included so you can insure your install is correct.

New on the ServerGrove blog today is a quick post talking about how you can enforce key constraints on a MongoDb with Doctrine in Symfony.

Of course you can define unique indexes to prevent duplicate values and there are a couple of different syntax options to do so, which are clearly defined in the official documentation. But defining and creating the indexes is not enough. You must specify when you want to enforce the constrain, this is due to the fact that the PHP driver needs to tell MongoDB to throw an error when a duplicate key is found.

The fix is as simple as adding a "safe" option to the "flush()" call on your database object. If you give it a value of "true", the ORM is smart enough to handle things on its own.

From the UncleCode.com blog there's a recent post showing you how to install PHPUnit manually without PEAR if you either don't have the access or just want to install it yourself.

This tutorial is an easy start to test your PHP source code which is build using classes i.e. OOP's with/without wamp/xamp doesn't really matter. The key to PHPUnit installation is set correct include path of your PHPUnit directory and extend correct phpUnit class in test case file.

They give you a quick eight step process that'll have you up and running in no time (including the download of the latest PHPUnit version). He shows how to set the paths in a sample unit test file to point to the right location for PHPUnit based on the root directory of your application. The runner can then find the correct files and classes when you run your tests.

On the ServerGrove blog there's a new post showing you how to create indexes for your Doctrine ODM documents in a Symfony 2 application.

Creating indexes in NoSQL / Document-based databases is quite different compared to traditional relational databases. Since the former are schema-less (there is no table creation), indexes do not get created when the collection or the document is created or inserted. Here is a quick tip that will create all the indexes defined in your documents when using Symfony 2 and Doctrine ODM for MongoDB. Indexes are a great way to speed up your queries, in fact, it is a crime not to include them in your documents.

Adding the index is as easy as putting a new annotation on the property in its document class (for @Index) and run a bit of code in Symfony to build it out. The two lines you'll need to execute are included in the post.

Nurul Ferdous has posted his "two cents" on Doctrine - his thoughts on the good and bad things about the popular ORM tool.

What is Doctrine? Doctrine is a popular ORM for PHP which works with RDBMS via PHP objects. This is built inspired by Hibernate from JAVA. This acts as an abstraction layer between PHP and RDBMS.

In his list of good things about Doctrine are things like its hiding of business logic, automatic CRUD, automatic modification of DQL queries, migrations and unit testing interfaces. On his "bad list" are things like not being able to use foreign keys as an identifier, heavy emphasis on an "id" column, not all data types are in DBAL and the SQL constructs missing in DQL. He also includes a scenario where he definitely not use Doctrine - a specific example from a project he just worked on that pushed the limits of the tool.

Daniel Cousineau has a new post to his blog today looking at an alternative that can be used for pagination in your MSSQL queries than the trick with TOP and reversing the ORDER BY in Doctrine.

As ugly as this technique is, it works. The problem is it requires an extreme amount of intelligence or an extreme amount of simplicity in the query in order for an automated system like Doctrine to be usable. The biggest caveat with this technique is good goddamned luck paging your query if it doesn't have an ORDER BY. And sometimes queries that are complex enough break the modified Zend_Db code. There exists an easier MSSQL paging technique. Using features first available in SQL Server 2005, with only 1 subquery you can mimic MySQL's LIMIT clause with ease.

He includes the query that will make it happen (the SQL for it) and then the implementation as an adapter you can use to get it to cooperate in your Doctrine queries.

In this new post to his blog Gonzalo Ayuso looks at building an ORM (don't worry, he recommends something like Doctrine first) as an exercise to understand how they're constructed and how one could fit his goals.

What's the motivation for me to build this ORM? The answer is a bit ambiguous. I like SQL. It allows us to speak with the database in a very easy way. [...] So the idea I figured out was to create a set of classes based on my tables, in a similar way than traditional ORMs to help me to autocomplete the fields and table names.

He creates a simple example with a "test" table with three columns with a mapped class (in the "Orm" namespace) that will allow IDEs to follow down the path to fetch the data from the "id", "field1" and "field3" columns. The complete code listing for his example is at the end of the post - PHP 5.3 friendly, of course. Some trigger and scaffolding examples are also included.

On his blog today Jonathan Wage has posted a tip on getting MongoDB connections and queries to work through the Doctrine ORM layer:

Since the start of the Doctrine MongoDB Object Document Mapper project people have asked how it can be integrated with the ORM. This blog post demonstrates how you can integrate the two transparently, maintaining a clean domain model. This example will have a Product that is stored in MongoDB and the Order stored in a MySQL database.

His code shows how to define the document and entity for the connection (a Product and Order) and creating an event subscriber to lazy load the product. He creates a sample Product and an Order for it and save them to the database. He also includes code to pull an order back out by its ID number and get an Order object back out (with Product data inside).

Matthew Weier O'Phinney has a new post to his blog (following this post on directory iteration for autoloading) with some of the benchmarks of different methods he tried for automatically loading the libraries his scripts needed on demand.

During the past week, I've been looking at different strategies for autoloading in Zend Framework. I've suspected for some time that our class loading strategy might be one source of performance degradation, and wanted to research some different approaches, and compare performance. In this post, I'll outline the approaches I've tried, the benchmarking strategy I applied, and the results of benchmarking each approach.

His testing included a baseline of the Zend Framework 1.x series loading, a naming/class standard following the PEAR standards and class mapping with file/class name pairs. He includes his benchmarking strategy and the scripts he used to run the tests (on github here). He ran them both with and without opcode caching to give a better overall performance view.

On the PEAR blog there's a new post updating you on some of the happenings with the PHP packaging tool recently.

We've been fairly quiet, launching pear2 and pyrus into the line up, welcoming new faces to the QA team, Jesus Espino, and getting ready to call an election for the new pear group.

They also mention several package releases (including updates to Net_DNS and Services_Twitter) and a call for contributions from anyone out there by working on deprecated code, unit tests or even just bug reports.

On the Solar framework blog today there's a quick new post about a change they've made to their distribution method:

I just switched the solarphp.com PEAR server over from the old Chiara_PEAR_ServerPirum, then plan and execute the conversion and server update. The presentation is not as slick as I'd like, but it's dead-stupid simple to set up, and I can tweak the CSS etc. later.

Pirum is a simpler alternative for a PEAR channel server manager that aims to make it simpler than some of the more complex options offered in the past. You can install Pirum from its PEAR server.

If you're interested in the deployment of PHP applications, you'd do well to check out a series of articles Kevin Schroeder has posted to his blog talking about different methods for moving your site out when it's ready for the world to see.

His articles cover:

• Things to take into consideration when creating a deployment process
• Using rsync
• Integration of source code management
• Creating PEAR packages
• Making installable packages (like yum, RPM, etc)

This last option, while a bit more difficult than some of the others, seems to becoming more and more popular as a self-contained, easy to deploy method that's very controllable.

New on Developer.com today there's a new article looking at one of the more powerful ORM tools available for PHP - Doctrine.

Because of the relational database's pivotal role in driving Web applications, a great deal of time and effort has been put into creating tools that not only simplify the task of mapping database tables to a programming language's object-oriented class structure, but also facilitate the management of your data and schemas over the project lifecycle. [...] The PHP community also has a powerful database integration tool at their disposal: a project known as Doctrine.

They help you get started with this powerful tool by showing you how to get it installed, create a sample schema and loading some fixtures (base data). There's also a quick snippet of code showing you how to grab information from a sample user table and display the name of the user.

Michael Kimsal has put together a Zend Framework starter kit currently posted over on github here.

Feel free to fork it and send me pull requests. There's a load of things I'd like to do to/with it, including a default basic authentication and user mgt system, a basic forms generator, some menu stuff on the side, and some other small stuff. It's got Doctrine built-in, and ready to go with a sample book/author object set, although no sample *data* yet, nor any examples of how to use the code specifically. Maybe I'll add some of that soon.

The ZFKit brings helps you get started quickly by giving you an example of a site that combines Doctrine, PHPUnit and the Zend Framework into one "ready to go" bundle.

New on Developer.com today there's a tutorial looking at creating complex, secure forms with the HTML_QuicForm2 PEAR package. This package will give you more control over the form, the validation it performs and the overall security it automatically handles.

For PHP developers, HTML_QuickForm2 PEAR package provides a programmatic interface for rigorously defining form controls, value requirements, and user notifications. Using HTML_QuickForm2 helps these developers create usable and secure Web forms without sacrificing visual appeal. This solution takes much of the guesswork out of secure forms development, allowing you to create robust forms with minimal time investment. In this article, I show you how to take advantage of HTML_QuickForm2 to streamline the creation and validation of complex HTML forms.

They help you get the package installed (if all goes well, it's just a call with the "pear" command-line tool) and how to create a simple form for accepting a user's name and email address. They modify it a bit to create another example - one that takes in a preferred format for the email that would be sent over to the user. They also work in the concept of required fields and how to show the error messages that might result from those being empty.

In a recent post to his blog Court Ewing talks about what he sees as one of the most important parts of any framework-based application - good, easy models that are simple to use and well structured.

By treating your models as nothing more than a place to dump your data, you are doing yourself and your application a severe disservice; your business logic is going to be scattered throughout the rest of your application, and you will have a progressively more difficult time as you try to maintain and build upon your existing system. Do not fall into the anemic model trap.

He gives examples of good models (based on how Doctrine 2 handles them) to work with the data for a sample blogging application. His main "Article" model pulls from an abstract one to help define some relationships and magic methods to handle class properties in a protected and private way, depending on the context. He finishes the post with an example of how to use these new model classes to interact with his blog data.

In a recent post to his blog Anna Filina looks at internationalization in Doctrine and how Symfony auto-builds things to take care of it for you.

If you use Doctrine, then you probably know how lazy loading can hurt your performance. I carefully craft every query to everything that I need in one shot, but only what I need. One thing that evaded me at first was the i18n part. I am pleased with the way Doctrine + symfony magically creates all my models and database tables with i18n support.

She talks a bit about the internationalization (i18n) support is put into the schema.yml file and the bit of confusion she had over how to handle a left join using its structure. The key lies in the Translation relationships.

On the echolibre blog David Coallier has written up a post talking about their CRM tool of choice, Capsule CRM, and some of the things they're doing to create an API interface to interact with it (including a proposed PEAR package).

we realized that we needed to integrate Capsule with some online services we have and so we built a PHP wrapper for their API to give developers the ability to place requests and use the web service as they wish using PHP. Services_Capsule is now being proposed to PEAR however you can already get the code from http://github.com/davidcoallier/Services_Capsule and start using it.

He also includes an example of how it can be used to create a new person, search the party information, update the user's information and add them to a pre-existing opportunity. There's not a lot of documentation for the package, so be ready to search through the source for some of the parameters and functionality.

On the PEAR blog there's a recent post looking at the month of March so far and some of the PEAR-related happenings that have already popped up.

After a quiet holiday season, the PEAR community has started rumbling again. [...] If this level of activity is anything to judge by, the future of PEAR looks bright for 2010!

Updates this month include a mention of the PEAR project on digg.com, the release of several new package versions for things like Facebook and the Mail package. They've also set up a continuous integration environment to help make the maintenance and testing of the code in the new releases simpler. There's also mentions of Phirum and PEARFarm and how they're lowering the barrier for PEAR installation everywhere.

Michael Kimsal has a new post today looking at using Doctrine models in a Zend Framework application and how to get them to autoload when you need them with the help of Zend's Zend_Loader_Autoloader.

I would have expected there to be some explicit reference to how to set this up, but the best I can find are general examples where the Doctrine models directories are appended to the include_path in a ZF index file. Shouldn't there be a way to explicitly have the Doctrine subsystem react to requests for models as well?

He works through the process he followed, including the possibilities of extending the Doctrine Core and accessing the $_modelsDirectory property, but didn't have much luck because of how Doctrine forces the autoloading. He asks for help and gets some good suggestions in the comments on where to look fro documentation and a possibility of skipping the Doctrine loader all together.

The ZendCasts.com site has recently posted a quick video covering logging and Doctrine event listeners in a Zend Framework application.

This short video is going to be the last in my 2009-2010 series on Doctrine 1.2. I'm wrapping it up with a little example of adding timestamps, logging and using Doctrine's event listener architecture.

The tutorial shows you how to pull in the features of Doctrine to make it easier to create a more complex logging system. He shows how to set up the schema file, add in controller functionality and backend models to make things all work together happily. You can get a copy of the project he's building from his subversion repository.

Doctrine allows you to set up relationships to link data in various tables together. Unfortunately, those aren't always in the order they need to be in. In a new post to his blog Chris Hartjes shows you how to sort these relationship results just by adding a simple line to your request.

I started digging around via search engine. Took me about an hour to find the solution. First, it took me half the time to dive deep enough to find out WHERE I can define the default sort order. Surprisingly, it was in an area that made total sense but I could not find before.

You can see an example of it in the "hasMany" call in his code snippet - the addition of the "orderBy" option and the value showing the sorting order. Here's the StackOverflow page that gave him the answer he needed.

Till Klampaeckel has a recent post about PEAR versus PEAR Farm on his blog detailing what each is and how to use the PEAR Farm to get your software out there.

With the release of Pirum, I'm really excited to see two public PEAR channels that aim to make PEAR a standard to deploy and manage your applications and libraries. One is PEARhub and the other is PEAR Farm. I think I'm gonna stick with PEAR Farm for a while, so this blog entry focuses on things I noticed when I first played with it. [...] A lot of people mistake these new channels for the wrong thing. They think that this will eventually replace PEAR. I don't think it will - ever.

He shows how to get the PEAR Farm libraries installed (via the PEAR installer) and how to set up your project with the pearfarm command-line tool. He also offers a few "gotchas" and tips to help you with a few of the issues he saw along the way. You can get an idea of the end result by looking at Till's PEAR Farm page.

The next ZendCast in the user authentication with the Zend Framework's Zend_Auth has been posted to the ZendCasts.com site today. In this new screencast, they look at how to integrate it with Doctrine to automatically validate users against the information in your databases (following up on this first part of the series).

Here's the second part of my Doctrine / Zend_Auth example. In 15 minutes, we create a logout, login and protected area that's reliant on the ZC_Auth_Adapter adapter we created in last week's video. Notice how there's no code in the IndexController exposing the authentication implementation,

You can grab the code to follow along or build it as he goes. You'll need a copy of Doctrine up and working to keep up, though.

New from the ZendCasts.com site today there's this new screencast looking at the integration of the Zend_Auth_Adapter component of the Zend Framework and the Doctrine ORM library to split out the authentication from the persistence layer.

I've been using Doctrine a lot in my own work, and recently found myself itching to have tighter integration between Zend and Doctrine when it comes to user logins. Luckily, Zend provides a very simple interface with regards to Zend_Auth. This way, it's easy to decouple your persistence layer (in my case Doctrine) from the authentication layer.

He also recommends checking out Palo Verede's look at the same topic. You can watch the screencast here and grab the code for it here.

In a new post on the Rdavid.net blog there's some discussion about Zend Framework models, the best approach and a "Service Class" idea.

After some more thought and lots of research on the subject, I've come to a solid point where I actually have something to try out which seems semantic aside from the naming of the class (Service Class) '" but this is derived from what some people are talking about in ZF circles starting from Matthew Weier O'Phinney who was coining it as the "Gateway to the Domain" from early on, then later changing it to "Service Class".

He defines what his service class idea is - a layer between the database and each of the models that allows them to be agnostic about what kind of service they're using. He also breaks down some of the key points around his approach including the fact that the Model Service can create Forms and that the Model Service can use the Zend_Cache component directly for improving performance. Be sure to check out the comments for thought from other Zend Framework developers.

On Rdavid.net there's a post with the results from some tests run on hos much memory the Zend Framework and Doctrine used both with and without the APC caching.

I have decided to run with Doctrine as my Domain Model in Zend Framework projects. The thing is, if I'm going to commit to this, I need to know that applications I build in the future with the Zend Framework while using Doctrine as an integral part of the Model layer will not take performance hits from things like memory usage. With Doctrine doing a _lot_ of magic, I thought that this would be something that I wanted to see for myself. 4MB Memory to execute a simple Query?!?! Ffffff#$#!!!!

He includes the code for his testing procedure - creating a basic Doctrine object and running a "fetchOne" query and measuring the memory consumption with the memory_get_usage function. His results with the APC caching came out faster by about 60-70 percent.

Rob Morgan has submtted a recent post from his blog that shows how to create and deploy a PEAR package for your application onto the new Pearhub repository.

You might be wondering what is Pearhub? From Pearhub.org - 'Pearhub is a pear channel and a pear package publishing platform. As a user, you can install packages. As a developer, you can publish packages'. You can read Troels Knak-Nielsen's introductory blog post here: http://www.sitepoint.com/blogs/2010/01/08/introducing-pearhub.

You'll need an OpenID, an account on github and know how to use git on your system to get everything packaged up and ready to go. You create your app locally, make a github repository for it and set up a pearhub account to point to it. With all of that set up, it's as easy as doing a channel-discover on the pearhub server and running the "pear install" on the package. The rest is done for you!

In a recent post to his blog Benjamin Eberlei looks at how PEAR and PHAR can affect the lifecycle of the development of your application following some of the feedback he got from a previous article on the same topic. In this revised version he talks about the open source project he's started, Pearanha, to bundle all of these ideas together.

First of all, yes the presented solution was somewhat complex, partly because it is still a proposed idea and definitely up for optimizations. However I am still very convinced of my approach, something I should discuss in more detail.

He mentions some of the downfalls that PHP applications have had up until now as far as ease of deployment and the maintaining of dependencies. Most of the suggested solutions aren't optimal, so a system using the PEAR installer would have to overcome some of them and keep it simple to use. Benjamin has taken the PEAR installer and laid his new Pearanha tool on top of it to help you create custom PEAR installer scripts.

New on the ZendCasts.com site is this recent screencast about the best approach for integration of the popular Doctrine ORM and the Zend Framework.

his video is my humble approach of combining some of the learning brought about over the last few weeks on Zendcasts, as well as suggestions from Doctrine developers. The goal of this video is to show how you leverage the existing resource loading tools in Zend to have a model structure that reflects Zend's best practices.

The code is provided if you'd like to follow along with this (about) twenty-five minute presentation.

In this new post to the SitePoint PHP blog Troels Knak-Nielsen looking at a new PHP-centric service for creating a resource like the Ruby on Rails "gems" but for PHP software - pearhub.org.

I think services like these are an important reason why gems are so popular amongst Ruby developers, and I figured that PHP really needs something similar. So over the Christmas, I have been brewing on a service, which is now stable enough that I'll make it available to the community at large. pearhub.org provides a place where you can register a project, that is hosted on Github, Google code or similar (Currently only git and subversion is supported). The service will generate a PEAR package and put it on a PEAR channel.

PEAR channels have been difficult to set up in the past but the pearhub.org service makes it simple and you get the added benefit of being able to use the PEAR installer application to do installations and upgrades. You can find out more about the service on their FAQ.

Hannes Magnusson has a new post today about an interesting feature of the PHP documentation some might not have known existed - manual pages (man) for PHP functions/methods for unix systems.

For a while I had vim configured to run reflection when I hit "K", but after the PHP documentation team released unix manual pages for PHP I now get the manual page in all its glory; function description, parameter descriptions, return values, examples, notes, see also and everything you are used to see from the online manual. Its awesome.

These manual pages aren't installed by default, so you'll have to grab the download from the PEAR channel for the PHP documentation (doc.php.net/pman). If you're wanting to use it in VIM, you'll also need to change the keywordprg setting to "pman".

The Zend Developer Zone has posted the second part of their look at pagination with the combination of the Zend Framework, Doctrine and PEAR and how the Zend_Paginator component compares to the PEAR and Doctrine alternatives.

In the previous segment of this article, I introduced you to the Zend_Paginator class, which provides a flexible API for paginating any data collection, whether it is expressed as an array or a database result set. [...] This article will explore two such alternatives, the PEAR Pager class and the Doctrine Pager class, and give you a crash course in how you can use them to quickly add paging and sorting features to your PHP application.

The article gives examples for both of the other methods - a simple pagination of database information with the PEAR pager component (and other packages that can make the results more effective) and the creation of a Doctrine instance where the results are handled via a series of built-in method calls.

New from the ZendCasts.com site there's a new screencast looking at the relations you can create between Doctrine and your Zend Framework applications.

This short podcast covers how you can easily build a form using Zend's MVC model via Zend_Controller and using Doctrine for persistence. You can download the source code or browse it online. Enjoy!

This screencast is part of a series they've been doing on Doctrine including Doctrine Relations and Data Fixtures and Writing Doctrine Unit Tests with Zend_Test.

On the Zend Developer Zone there's a new tutorial on how to use the combination of Doctrine and more PHP to connect with Flash Builder to create a simple classified ad system.

This article shows how to set up Doctrine and use it in PHP code. Then, it exposes PHP services to Adobe Flash Platform applications using Zend_Amf. You'll then call the Doctrine-enabled services from a Flex client. Finally, I'll show you how to switch your database from MySQL to SQLite with four lines of code. And I won't write a single SQL statement.

He shows how to set up a full Apache/MySQL/PHP installation with Doctrine, Flash Builder Alpha and the latest edition of the Zend Framework. He shows how to set up the models, connect Flash Builder to the app via the Zend_Amf component and how to build the frontend for the app inside Flash Builder.

Benjamin Eberlei has a new post today about a deployment technique he's trying out - using PEAR and PHAR to create deployable packages.

With PHP 5.3 the PHAR extension is a pretty powerful concept for all your deployment needs, however it does not tell the complete story. [...] With Pirum being a simple PEAR channel server there is also momentum for projects to distribute their code via PEAR. However PEAR is mostly used in the server-wide configuration use-case, which is not very useful if you plan to distribute your complete application in one PHAR file.

He shows how to create a sample package from a Zend Framework application, set it up in a PEAR channel complete with the ability to run a "pear upgrade" to get the latest version of the package. He also includes a bit of sample code to work with the PHAR archive and load the libraries inside.

On PHPBuilder.com today there's a new tutorial that walks you through the process of creating a simple MVC framework in PHP based on Smarty, PostgreSQL and the PEAR XML_Serializer package.

PHP now enables you to build robust, manageable, and beautiful enterprise web applications. The best way to do that is to divide the application into three components: model, view, and controller. In other words, you need to separate the presentation, the database, and the business logic from each other. The most common approach for achieving this design goal is to adhere to a strict Model-View-Controller (MVC) framework.

He uses the example of creating an application (a feed reader) to show how the parts of the MVC will fit together as a whole. You won't find any code examples in the article, just an explanation of how everything works together. You can, however, dowload the source and follow along.

In response to a different post he read on a postal/zip code validation topic, Ken Guest has points out other resources that can be used to accomplish the same sort of thing and already exist.

I drew attention to two things. The first is that there are Validation packages in PEAR, including the main Validate class and all the Validate_xx subclasses such as Validate_US, Validate_CA and some 22 others). The second item I drew Jamie's attention to is that his validation code counts a zip code of "00000' as valid, when the USPS zip code look up tool correctly (and they should know!) identifies that code as invalid.

He wholeheartedly opposes the "Not Invented Here" syndrome that developers (with a hefty dose of framework developers included) seem to have.

On the Zend Developer Zone there's the first part of a series looking at pagination and sorting of data with the combination of the Zend Framework, Doctrine and PEAR.

When building database-backed applications, one of the important problems for a developer or user interface engineer involves making large data sets more manageable by, and therefore more useful to, application users. [...] Back in the good old days, adding pagination to a PHP application was mostly a manual task, involving offset calculations and custom query generation. In recent years, the task has become significantly simpler, mostly due to the presence of ready-made pagination components in most common frameworks.

His tutorial uses the Zend Framework, Doctrine and the Pager, MDB2 and Structures_Datagrid PEAR packages. He starts with a basic select and format kind of example to show a few lines per page. To improve it (for larger data sets) he shows how to use the Zend_Paginator to only grab the rows needed for the page. Finally, he adds in code to allow for column sorting, making it easy to reorganize the results how you'd like.

Since the Symfony framework project has such tight integration with both the Propel and Doctrine ORM layers, they thought they'd share some statistics on the usage of both as mapped through the stats from their Jobeet tutorial.

As for any Open-Source community, it's not easy to find metrics that tell you what people use and how they use it. You can measure the number of tickets for a specific feature, count the number of people asking for help on Propel or Doctrine. But for the Propel vs Doctrine question, we have two more reliable metrics.

As is shown in this graph of the total Jobeet traffic in 2009, Doctrine is winning by a long shot. That's not to say that you can't still use Propel is that's what you and your application are using, this is just showing the overall popularity of each of the ORMs.

On WebReference.com there's a recent article looking at the PEAR internationalization (i18n) packages and how they can be used to internationalize your application.

For many of us, the realization of the extent of countries' interdependence was driven home by the recent global economic meltdown. So what does all this have to do with us Web developers? It's a resounding wake up call that we have to think of other nationalities when we develop our websites and applications. In most cases, developing a web app in English alienates much of the world's population and greatly reduces potential profits! With that in mind, this article is the kickoff for a series that discusses the ramifications of globalization on our websites and applications.

The look at some of the local identifiers (like LC_ALL, LC_TIME, LC_ADDRESS and LANG), how to access the values for them on the different OSes and how to use the I18N_Country and I18N_Language packages from the PEAR I18N package to handle some simple multi-language support.

Juozas Kaziukenas has posted the third part of his series looking at the powerful combination of Zend Framework and the Doctrine ORM layer.

During last two months I spent massive amount of time tweaking Doctrine ORM framework and making it to perform as fast as possible (as you might have noticed from my never ending tweets). This post is devoted to performance and efficiency, with practical tips & tricks how to reduce memory usage, make it work faster and save resources.

He's broken it up into two main parts with points underneath:

• Speed including a look at hydrators, DQL and optimization
• Memory usage and how you can optimize things that seem simple and some recommendations of tools you can use to resolve some of the trouble spots.

Fabien Potencier has written up a post detailing a PEAR channel server manager he's developed, Pirum.

Pirum lets you setup PEAR channel servers in a matter of minutes. Pirum is best suited when you want to create small PEAR channels for a few packages written by a few developers. Pirum consists of just one file, a command line tool, written in PHP. There is no external dependencies, no not need for a database, no need to setup credentials, and nothing need to be installed or configured.

All you need to do to get the tool is download the pirum file and go. It includes features like per-channel HTML pages and Atmos feed release tracking along with several other standard PEAR channel features.

There's already been one project that's made the swtich - PHP_Depend.

Adam Jensen has written up a quick tutorial about using Doctrine record listeners to link a Zend_Acl component with your database.

In previous Zend Framework apps I've written, I often handled access control at the level of the controller action. Each action was represented in the ACL as a resource, and the ACL logic was applied by a custom plugin just prior to any action dispatch. [...] As a result of these concerns, I decided on a lower-level, model-centric approach for this blog: my models are my resources. Each model class implements Zend_Acl_Resource_Interface, and the ACL specifies "create," "read," "update" and "destroy" privileges for each class (more or less).

Checking for the permissions with a setup like this can be time consuming, though, so he found an ally in the record listeners Doctrine allows you to set. He combines a Doctrine_Record_Listener object with a Zend_Acl one in a preInsert method with a getCurrentRole to add the user handling all in one place.

Juozas Kaziukenas has posted the second part of his series looking at the combination of the Zend Framework and Doctrine (part one is here). In the previous part he explained the technologies some. In this second part of the series he focuses more in getting Doctrine set up and working.

Today we start actual development with Doctrine and Zend Framework. Base of this post is my code which I have been using for quite a few projects and it worked really well.

He walks you through the steps to getting Doctrine set up - creating the database, downloading and unpacking the latest version of Doctrine, setting up your application.ini file and creating the models from the database. Add in a sample query and things should be working perfectly.

Juozas Kaziukenas has started a new series of posts to his blog today with this first part of his look at combining the Doctrine ORM with Zend Framework applications.

It was quite common to use Zend_Db_Table as base models class, but it was simply not practical. When you start dealing with relations and hierarchical data types it starts to get really tricky, because simply Zend_Db_Table doesn't provide an extensive enough functionality. So half a year ago Zend Framework developers started to look for better solutions.

An alternative (and a very powerful one at that) was found in Doctrine - an object relational mapper tool that sits on a database layer. Doctrine 2 will even be the first ORM with seamless integration between the Zend Framework (and Symfony). He briefly touches on what some sample code might look like and the command to build out your model classes from predefined YAML files.

An advisory has been issued on the PEAR blog about two packages - Net_Traceroute and Net_Ping - that could expose your site to a security issue, a remote arbitrary command injection.

Net_Ping is an OS independent wrapper class for executing ping calls from PHP. Net_Traceroute is an OS independent wrapper class for executing traceroute calls from PHP. When input from forms are used directly, the attacker could pass variables that would allow him to execute remote arbitrary command injections.

You can use filtering as a workaround until your packages are updated on your server. You can upgrade to the latest packages here: Net_Ping, Net_Traceroute.

On his codediesel.com blog today Sameer Borate has a quick post looking at URL manipulation with the help of the Net_URL2 PEAR package.

Whether you are dynamically creating urls or changing existing ones, manipulation of urls is a frequent coding requirement during development; doing the same on short urls is easy, but quickly becomes complex for urls which have larger query parameters.

He shows how to use the package to parse the current URL into its respective parts (host, port, path, etc) and how to automatically change certain parameters in the current URL and push the updated version back out the other side. There's also a bit there at the end on normalizing URLs.

The PEAR blog has pointed out some issues that the latest Ubuntu release (Karmic) can cause with a typical PEAR installation:

Be aware that the initial release of Ubuntu Karmic contains a bug that affects PHP and PEAR, whose fix came a tad too late to make the initial release. The bug is fixed, and will be included in upcoming updates from Ubuntu. [...] The bug causes some zlib functions to be unavailable to PHP, and the Archive_Tar code will silently fail due to this.

Until the update gets pushed out into the updated releases, you can use the "-Z" option on any package installs or upgrades you might do in your PEAR installation.

Daniel Cousineau has posted a quick guide to migrating database information with Doctrine:

I was talking with someone [...] here at ZendCon and discovered that they were having trouble with migrations in Doctrine. Having gone through the same issues of Doctrine seemingly not being able to figure out your changes and generate migration classes, I thought I'd post the solution here for future reference.

It's four quick steps that'll get Doctrine to automatically generate the differences (deltas) and upgrade your models to reflect these changes.

On the Symfony blog there's a recent post showing how to integrate the framework with Doctrine 2 via the sfDoctrinePlugin:

Today I am happy to tell you that this version of sfDoctrinePlugin is now available and ready for you to use. This article will give you a little information about how you can get started using it today!

Installing and enabling the plugin is as easy as a svn checkout and changing a few settings in your project's configuration files. You can then define your database connection and schema information settings so that the rebuild ("symfony doctrine:build") will build out correctly. They include a simple example, a repository class, to let you be sure everything is up and working correctly. You can find more information about Doctrine 2 from its online manual.

On the IBuildings techPortal site today there's a new article from Lorna Mitchell about the use of the PHP_CodeSniffer PEAR package to run formatting checks on your code.

PHP Code Sniffer (PHPCS) is a package for syntax checking, available from PEAR. It can check code against defined rules covering anything from whitespace through doc comments to variable naming conventions and beyond. In this article we'll look at getting started with PHPCS, using it to syntax check our files, and go further to look at how the rules are create and the standards defined.

She goes through the installation (a simple call with the pear installer) and a few examples of code and the matching output for a few of the syntax formats included with the tool. She also has a section on the structure of some of the rules and looks at the sniff for defining functions for the PEAR standard.

In a new post to his blog today Sameer looks at a trick or two about detecting the type of browser/client a visitor is using to view your website - one method with the superglobal and another with a helpful PEAR package.

Every time you use your browser to access a website a User-Agent header is sent to the respective server. Detecting user agents on the server can be useful for many reasons: browser quirks, personalize content, preventing illegal access.

He talks about the get_browser function that's included in PHP but that requires a browscap.ini file to work. His other option is the Net_UserAgent_Detect PEAR package. It grabs the user agent and breaks it up into the browser type, operating system information and any Javascript-related headers that come along with it. There's also useful tests like "isIE()" and "isNetscape()" built into the package.

In this new post to his blog till argues his case for PEAR and why support for PHP4 is a good thing when it comes to making things "just work."

Every once in someone likes to argue that PEAR is all fugly PHP4 code and why you should not use it, and instead go and use another framework or component library. Most of those people also say that they looked at or used PEAR x years ago and then act all surprised when someone else disagrees.

He talks about some of the rules around the major/minor PEAR releases and backwards compatibility breaks which, thankfully, a lot of other projects seem to adhere to. He points out that some packages have been started for different PHP generations (Mail_Queue2 vs Mail_Queue) and a few reasons why the PHP4 EON doesn't automatically mean PEAR should follow suit.

In a new post to his blog today, Brandon Savage talks about the "fade time" for PHP4 and how, really, it's gone on long enough.

Sadly, developing for PHP 4 backwards compatibility is something that companies and individuals are still doing. Wordpress released a new Widget API in version 2.8 that relies on the old-style PHP 4 constructor. Apparently, for Wordpress and many other developers, wide adoption is more important than language improvements.

This all came about because he noticed the Log PEAR package still supported PHP4. He's been making updates, though, to bring it out of the shadows and into the light of PHP5-only support.

Still, I look forward to the day when PHP 4 finally does go away forever, leaving us with a much better code base and happier developers.

Sudheer Satyanarayana has this new post on his blog today talking about a simple way (via a PEAR package) to make an XML-RPC connection to ping technorati about updates to your blog.

In a previous blog post we discussed how to consume the Technorati ping web service using XML-RPC. The PEAR package XML_RPC2 provides convenient client and server objects. You can call the remote methods as if they were the methods of the client object. In this post, let us accomplish the same using a PEAR package XML_RPC2. We will write a client script to update Technorati when there is new post in your blog site.

You'll need to grab the XML_RPC2 PEAR package to make this all work, but once that's installed, you're a quick few lines of code away from a client to update Technorati with the ping information for your site.

On his Code Diesel blog Sameer takes a look at creating and using barcodes in your PHP applications:

Brought into the mainstream by supermarket checkout systems, bar codes have become a ubiquitous element in our daily lives. Rarely will one come across any product that doesn't have a barcode. The idea of a barcode originated in 1932 from the thesis of Wallace Flint at Harvard.

He touches on a two types of barcodes - standard UPC and the matrix codes (like ShotCode and Semacode) - before looking at how you can create them with the PEAR Image_Barcode package. It supports multiple code types including Code 39, EAN 13, INT 25 and PostNet. Output examples are included.

Following some issues with the Phing and Propel subversion repositories for Symfony, Fabien Potencier has made a few changes to aid in their future stability.

The Phing and Propel Subversion repositories have suffered from long downtime periods quite often recently (last one was today). It is quite annoying as when it happens, you cannot easily update your symfony repositories, let alone the checkout of a symfony branch. To make things worse, the Doctrine repository also had some problems recently. A lot of symfony users are quite upset by the situation, myself being the first one.

The solution - create some mirrors to provide more than one source to fetch the latest checkouts from. Here's the list of the new resources: Phing mirror, Propel mirror, Doctrine mirror.

If you've had issues with an "unsupported protocol" message when working with the PEAR installation on your PHP instance, you should check out this quick post from the PEAR blog with a tip on how to fix it.

When trying to install something, you will get the error: pear.php.net is using a unsupported protocal '" This should never happen. install failed. This problem comes from corrupted channel files. Go into your PEAR php directory and backup .channels directory.

If you go into your PEAR installation and move the .channels directory out of the way then run an "update-channels" the issue should be corrected. Unfortunately, this also means you loose all channels you'd subscribed to, but does save you from having to reinstall PEAR completely.

New on his blog today Pablo Viquez has this post looking at code that will let your Zend Framework applications export to Microsoft Excel spreadsheets (via the Spreadsheet Excel Writer PEAR component).

Last week, I had to allow the user to export a given report into an MS Excel file format. The application uses Zend Framework 1.9.1 and so far ZF does not support for "Office" formats, so after searching for a nice implementation, I found a PEAR module called Spreadsheet Excel Writter, which looked pretty good, it had very good documentation and the code was clean and well structured so I wanted I give it a shot.

He lays out the structure of the sample application and, using a context switch on the request, he creates a controller that responds to the "/report" by calling a special model/view combination that uses the PEAR package to push out the custom "report.xls" file.

Matthew Weier O'Phinney has a new post on something he's been asked about a lot - autoloading Doctrine into a Zend Framework application.

A number of people on the mailing list and twitter recently have asked how to autoload Doctrine using Zend Framework's autoloader, as well as how to autoload Doctrine models you've created. Having done a few projects using Doctrine recently, I can actually give an answer.

His short answer - "attach it to the Zend_Loader_Autoloader". For those needing the long answer, he goes through a simple example of creating the loader object, registering a new namespace and pushing in the Doctrine functionality as an autoloader. The bootstrap class can then be modified with an "_initDoctrine" method to pull in just what scripts your app might need.

According to this new post on the PEAR blog, the new PEAR Group has been officially elected:

I am more than glad to announce the arrival, the announcement of the new PEAR Group for 2009 and 2010. With a few fresh faces in the Group, this year looks very promising with the mix of both new blood and experienced PEAR Group members.

Those selected include Chuck Burgess, Ken Guest, Christian Weiske and Brett Bieber. The PEAR Group helps to guide the PEAR project as a while and push out initiatives like the updated package manager - Pyrus.

As is mentioned in this new post to Giorgio Sironi's blog, the latest version of Doctrine now includes lazy loading functionality.

Lazy loading is the capability of performing a expensive operation on demand, only when it reveals necessary from a client request. [...] In Doctrine 2 I made some architectural choices implementing the proxy approach, which substitute a subclassing object to every association which is not eager-loaded.

There's two main places you can see these differences - in the one/many to one associations dynamic proxies and collection interface.

The PEAR blog has a quick note about this year's elections - specifically that they have been extended due to some communication issues.

As every year, the elections for the PEAR Group and PEAR President are happening. This year due to a few factors and messages lost in translation, we decided to extend the elections period by 10 days so more people would have time to vote! So remember to cast your vote at http://pear.php.net/election/ and you have until the the 5th of August 2009.

There's both group elections and an an election for president that all PEAR developers can vote on. Hurry! The deadline is Wednesday, August 15th!

The second part of the IBM developerWorks series looking at the Agavi PHP framework has been posted. In it Vikram Vaswani loks at adding forms and database support to his example via Doctrine.

While Agavi can certainly be used to serve up static content, it really shines when you use it for something more complex. And in this second part, you'll do just that - over the next few pages, you'll learn how to receive, validate, and process input from Web forms, as well as connect your Agavi application to a MySQL database.

He returns to his simple templated example site and shows how to use the command line agavi tool to create the routing and controller to handle the "contact us" requests. He includes form validation examples, how to use the population filter, and how to generate the Doctrine models to connect with the form directly.

The PEAR blog has posted some handy instructions for those out there that want to get PEAR and PEAR2 checkouts working from the new Subversion repository (recently moved from CVS).

Now that pear2 is in svn.php.net, it is possible to do commits with multiple packages using a feature of subversion called "sparse checkouts." [...] Here is the version I used to set up pear and pear2 in a way that will allow committing to both pear and pear2 packages in a single commit.

Rasmus Lerdorf has written about the same thing for the main PHP side of things. All the commands you'll need are there to get things set up and working more efficiently.

Cal Evans had an issue - it involved XAMPP, PHP 5.3, PEAR and phar:

If you are installing PHP 5.3 and when you run go-pear.bat you get this: phar "C:xamppphpPEARgo-pear.phar" does not have a signature.

The short method to getting it working correctly is to update your php.ini file with a few small changes to the require_hash setting. Cal goes through the long method he took to finally get to that point - decision on the platform (XAMPP), version of PHP to use and some googling around that lead him to this and this to help resolve his problem.

It turns out that, if that's on, for security purposes it can't be overridden. Since the default is on, I had to open up my php.ini, find it and set it to off. Once it's off, everything works just fine.

The PEAR blog has a quick note for users of PHP 5.3 and Windows:

Some users have reported that the windows builds of PHP 5.3 are not able to open the shipped go-pear.phar file.

If this is your situation, you can use their workaround (run the distributed phar version) or grab the non-pharred version.

The Zend Developer Zone has a new post from Vikram Vaswani about accepting credit card payments through Authorize.net in the OXID eShop CE (e-commerce platform).

Now, if you're planning to start an online store, it should be pretty clear that accepting electronic payments isn't an option - it's a necessity for you to compete effectively. And that's where this article comes in. Over the next couple of pages, I'll show you how to begin accepting credit card payments for your products using the open source OXID shopping cart and the Authorize.Net payment gateway...with, of course, a little bit of PHP to make things interesting!

The glue between the OXID install and Authorize.net is created with the PEAR HTTP_Request2 package. This combined with a little extra PHP code can be installed and used as a component directly inside the application. He gives full code and screenshots to help you get it up and running on your install.

As is mentioned on the PEAR blog today, there's some new advancements that are being made to make submitting proposals simpler.

Thanks to the efforts of Daniel O'Connor, the PEAR website is getting nicer and better. Bug RSS feeds support Baetle now, the PEAR proposal system - PEPr - works again and many small improvements and fixes found their way on the site.

Baetle is a "bug and enhancement tracking language" project that describes the information in things like the BugZilla and Jira tracking applications.

Feel like getting involved with a PHP-based Open Source project, but don't know where to start you might consider getting involved with the Doctrine project - they're currently looking for a few good programmers.

Many of you probably know Jonathan, Guilherme and Roman as being the core developers of the Doctrine project over the past 2 years. While this constancy is a good thing it's also problematic. [...] So we are left wondering. What can we do differently to get more people involved? Given the amount of users and noise about Doctrine around the PHP scene, we find the absence of new contributors quite strange

The Doctrine project is looking for developers (on both the 1.x and 2.x release series) to either get involved of to help them out with suggestions on how to get others interested in working with the project. To get in contact with the team, you can just send an email to any one of the three: jonwage [at] gmail [dot] com (Jonathan), r.borschel [at] gmx [dot] net (Roman) or guilhermeblanco [at] gmail [dot] com (Guilherme).

Jani Hartikainen takes a look at two of the major PHP ORM libraries in this new post - Propel and Doctrine.

The best PHP ORM libraries, Doctrine and Propel. Last year I compared them to each other, and now it's time to get a fresh look at how they have advanced in about a year - Is Doctrine still the better of the two? This time, I'll also look at the features of each in more depth.

He goes through some of the features (basic and advanced), how easy they are to use and their connections to the database. His personal preference? Doctrine works better for his needs.

On the Content with Style blog today Pascal Opitz has made a (very) quick post about how to get PHPUnit up nd running in your MAMP installation.

In order to run my unit tests, I needed to get phpunit running with MAMP. Thanks to the helpful post of Mark Kirby on this, I figured it out.

The key is in changing the interpreter path in one file and removing a bit of code from another to point to the new PHP binary's path. You'll also need to update your PEAR include path to add in the new pear.conf location.

On his blog today Sameer Borate has posted a quick tutorial on how to use a PEAR package to do search and replace on your files from inside of PHP.

Searching and replacing content in files is a common task all of us do regularly. [...] Search/replace is easier from a shell prompt or an editor, but what if you have to do the same programatically in php. File_SearchReplace is a pear package that helps you search/replace in files through a nice object oriented interface.

Installation is simple (via the "pear" command line tool) and using it is just as easy. He gives a few examples of how it can be used - everything from a simple find and replace out to a more complicated regular expression search to be replaced with a string.

On the Zend Developer Zone today a new tutorial has been posted about multi-language translation for your site with PHP and the Translation2 PEAR package.

If you're using PHP, adding multi-language support to a Web application is quite easy, especially since the PHP Extension and Application Repository (PEAR) includes some ready-made code to help you get started. And that's where this article comes in. Over the next few pages, I'll introduce you to PEAR's Translation2 package, and show you how you can use it to add multi-language support to your application.

You'll need to have everything up and running (including an install of the PEAR package) before getting started. The tutorial shows how to set up database tables and sample data to reference with a basic "Hello World" script as well as a few more complex examples involving user input and creating a cross-language menu for a sample site.

On the Zend Developer Zone a new article has been posted (by Vikram Vaswani) about how you can use the Services_Twitter PEAR package to connect your applications with Twitter.

Unless you've been living in a cave for the last few years, you know what Twitter is - a free online service that allows users to send out concise, real-time updates on what they're doing at any given moment.

[...] The really good stuff, though, is hidden behind the scenes. Like many Web 2.0 applications, Twitter exposes its innards to the public via a REST API, making it possible to develop customized applications that run on top of the base service. [...] This article focuses on one such library, the PEAR Services_Twitter library, which provides a full-featured API for interacting with the Twitter service through a PHP application.

Once the package is fetched (via the "pear" command on the command line) he shows how to make some example connections like grabbing the most recent status for a user, updating that status, grabbing recent posts from a user's timeline, finding followers/friends and much more. The package makes it so simple that any one of these examples isn't much more that seven or eight lines long.

Greg Beaver has a new post reporting on his latest efforts to improve the Pyrus PEAR installer and to make it a more strong, stable and robust end result.

One of the problems I found when designing the new code for PEAR 1.4.0 (back in the day) was that it was very difficult to determine whether changes would break things. The main problem revolves around the colossal size of the test suite. [...] This is a real problem when trying to develop with any kind of flow. If, after every change, one needs to sit through 35 minutes of tests, one will never develop anything of substance.

What he wanted was an application that could detect only the files modified and tests those with the results put into the code coverage report. To fill the need, he created test-modified.php to run just the phpt tests needed.

On his blog today Sameer looks at a method for finding duplicate code in your applications with the help of PHPCPD.

Duplicated code in projects is a frequent thing and also the one ripe for factoring out in a new class or function. Cut/Paste coding is a common development practice among programmers, a lot of which can lead to code size increase and maintenance nightmares. PHPCPD (php copy paste detector) is a PEAR tool that makes it easier to detect duplicate code in php projects. Below is a short tutorial on the PHPCPD package.

You can either install the tool via a PEAR channel or directly from the github site. Once its downloaded and extracted you can immediately run it on the subdirectory of your choice. He also includes a more extended example - a search on a minimum of 5 lines of 70 tokens found to trip the filter in finding cloned functionality.

Zend recently released one of their latest offerings to the PHP development community - Zend Server. Using the Community Edition of the platform, Christoph Dorn has integrated a popular debugging tool - FirePHP - into his local installation.

This PHP environment bundle is backed by Zend which means it will stay maintained and likely make it into many corporate environments. It also ships with Zend Framework and PEAR which means it has full native FirePHP support right from the start! [...] I am going to walk you through how you can get FirePHP setup for ZendServer with the help of some glue code. The glue is available from the FirePHP PEAR channel and will be maintained along with FirePHP going forward.

Before getting into the installation/configuration of FirePHP, he stops to talk a bit about PEAR and what it can do for you and your applications (and a few places it could improve). Following that, he gets to the good stuff and walks through the install of Zend Server, including the FirePHP PEAR package and doing a little debugging to ensure you're set up correctly.

A little while back, this interview was posted to the echolibre blog where David Coallier got a chance to talk with Iarfhlaith Kelly (of webstrong) about their use of PEAR.

This web app has a huge potential (internationally) and is developed following a solid architecture. Being strong PEAR contributors we are of course happy to take a look at what helped the footprintapp.com team achieve such a great product. So I went ahead and asked a few questions to Iarfhlaith Kelly from webstrong.

They talk about time spent using the PEAR libraries, how its helped reduce coding and development time and what sort of packages webstrong makes use of (Auth_HTTP, XML_Parser, etc).

Over on the Blue Parabola blog Matthew Turland recently posted a new tutorial on using the PHP_CodeSniffer PEAR package to check out how well your code adheres to the coding standard of your choice.

For the sake of consistency [on a client project], the development team had stuff with the coding standard used by the framework itself. However, evaluating the code manually is tedious and time-consuming. There's a solution to this type of problem: the PHP_CodeSniffer package from PEAR, which builds an infrastructure around tokenizers for PHP, CSS, and JavaScript and utilities to detect coding standard violations within code in any of those languages.

He includes an example token output (the codesniffer package is based on the Tokenizer) from a script and walks you through the initial setup of the package, how to create "sniffs" for the code you want to analyze and how to run them using the popular unit testing tool PHPUnit.

Its about that time again and David Coallier has pointed it out - the Google Summer of Code is not far off and PHP will be right in the middle again!

Once again we are happy to announce that PHP will be taking part in the Google Summer of Code. Already with a list of more than interesting and intelligent ideas, we are looking to get more ideas. This of course means that PEAR Developers, PECL Developers and PHP(Core) Developers now have to cook some ideas up and submit them to the GSoC 2009 PHP Wiki so we can have more good ideas for students to apply to!

There's already a few things about this year's GSoC that have been posted - the page on the PHP.net wiki, a mailing list announcement on the PEAR dev list and, of course, the official GSoC page.

Guilherme Blanco passed along a note about the latest releases from the Doctrine project, Doctrine 1.0.8 and 1.1.0-RC2:

Today I am happy to tell you that we have two new versions of Doctrine available for you to use. The first is the monthly maintenance release for Doctrine 1.0 and the second is another release candidate for the newest major version of Doctrine, 1.1. As always you can grab them from the downloads page.

Updates in these two versions include a few backported fixes from 1.1, updates to the Doctrine_Query::count() method for optimization, and several fixes in the Release Candidate in preparation for the next release. You can see the full Changelogs here: 1.0.8 and 1.1.0-RC2.

In a new post to his blog today Asvin Balloo has posted ten useful PEAR packages (just some out of a long list) that can help you with everything from database access to creating Excel spreadsheets.

His list of ten is made up of:

• MDB2 (database access)
• Text_CAPTCHA
• Log
• LiveUser
• Translation2
• Validate
• Spreadsheet_Excel_Writer
• Net_GeoIP
• File_Archive
• XML_Serializer

For most of them he also includes links to tutorials showing how to use them and with more info about them.

Kevin van Zonneveld has posted seven steps that you can follow to help the documentation for your PEAR class come out better and be more useful in the end.

If you've written a PEAR package, it's probably a good idea to submit some end user documentation. Here's how to do it.

He explains what it is (XML in CVS, easily convertible with phpd) and how the process flows - save the current docs, add your own, build locally and submit to CVS. Here's his tips to help things go smoothly/turn out better:

• Gather the prerequisites
• Save current documentation
• Try building the docs
• Write your own XML docs
• ReBuild peardoc
• Commit your XML
• (There is no seventh step - you're done!)

Juozas Kaziukenas has a new blog post that looks at creating Excel documents on the fly with the Spreadsheet_Excel_Writer PEAR package.

In one of my projects, we need to send emails to our suppliers with new orders as Excel spreadsheets. We used to do it by hand, but when you have 10 suppliers and you make 200 products orders per week, after some time you are just tired of creating Excel spreadsheets, mailing them and so on. So, my task was to implement automatic spreadsheets creation with PHP.

His example creates a basic file with a set of "Items", some formatting and a set of code/title items to fill out each row. The end result can then be packaged up and sent out as a complete Excel XLS file.

Greg Beaver has posted an update one some of the things he's been working on in the realm of his projects - Pyrus, PEAR2 and code coverage for phpt-based tests.

In any case, now that work on ext/phar has shifted primarily to maintenance mode, and namespaces are finally ancient history, I've shifted all of my coding energy to getting Pyrus, PEAR's next-generation installer, ready to ship.

Pyrus is the PEAR installer as rewritten for the next major PHP release (5.3) and uses a lot of the new features it offers (including full archive support, SQLite 3, combined configuration files and several new developer-centric additions). He also includes a sample bit of code that he worked up to run code coverage reports against the PEAR packages. He includes links to three different examples of the report's output.

Chuck Burgess has posted a guide for developers out there wanting to get their PEAR packages working with phpUnderControl for builds.

there were some things that I had to discover via trial-and-error with regard to the build files, though possibly they are covered in other pUC docs that I didn't check. The "Getting Started" build example is based on a project sandbox pulling code from a Subversion repository, whereas all my PEAR code comes from CVS.

He talks about his config.xml file (how it turned out that the basic one was all he really needed) and configuring the build.xml to run the tests from the correct location. He also mentions some future ideas like making the builds run the install/upgrade commands before running the tests.

The Zend Developer Zone has a new tutorial posted (from Vikram Vaswani) about adding in an auto-complete input field to your site. His example uses a PEAR class, Dojo and some components of the YUI libraries.

Fortunately, modern programming toolkits like Dojo provide ready-made widgets that have the necessary client-side functions for autocomplete. Add a little bit of server-side glue, in the form of a PHP script that talks to a database to generate valid suggestions, and enabling this functionality in a Web application now becomes a matter of hours, rather than days. In this article, I'll show you how to do this using three different libraries: PEAR HTML_QuickForm, YUI, and Dojo. Come on in, and find out more!

He shows how to combine Dojo, YUI and the HTML_QuickForm PEAR package to create a field that, based on what they enter into the input field, searches a database to find values in that table.

In a recent post to the Zend Developer Zone Vikram Vaswani takes a look at using AJAX quickly and easily in your applications with the help of the HTML_AJAX PEAR package.

Well, PHP is commonly used on the server end of the connection, to handle AJAX requests and send back responses. But that isn't all it can do - with a little PEAR package called HTML_AJAX, you can use PHP to significantly simplify the work that goes into building and deploying an AJAX application. That's where this article comes in. Over the next few pages, I'm going to give you a quick run-down on the PEAR HTML_AJAX class, together with a few examples of how you can use it to AJAX-ify various Web applications.

He goes through the whole process - installing the package and five example scripts to show it in action:

• Pulling from a simple database table of book and author information
• Calculating simple interest
• Creating a simple calendar
• Evaluating an inputted number
• Simple login validation

In a quick post Jani Hartikainen take a look at some optimization tricks you can do to help get the most out of your Zend Framework/Doctrine application.

I decided to try profiling my quiz application to see if I could speed it up. Not surprisingly, biggest performance penalties came from loading classes and Doctrine's ORM magic. [...] As you may have heard, optimizing without profiling first is a bad idea, as you may think something is slow when something completely different would be better to optimize.

some of his suggestions include:

• Removing all require_once calls from the Zend Framework library
• Change the include_once_override setting if you're using APC
• Using the query cache in Doctrine
• Using the Doctrine_Table find functions rather than the Doctrine_Query objects

The symfony blog has posted an update on the status of their "Practical symfony" book - the Doctrine version has officially been released!

Last week, we released the "Practical symfony" paper book (380 pages). The "Practical symfony" book is based on the Jobeet tutorial, and is the best book to read to get you started on symfony 1.2. It describes everything you need to know to develop professional web applications with the symfony framework.

As for the Propel edition, we have worked hard to update the Doctrine edition as fast as possible. The Doctrine version is now up to date and thanks to Jon work, you can even enjoy a tagged repository for each day of the tutorial.

The book works through the Jobeet tutorial series they posted at the end of 2008 to create a complete job posting website with the symfony framework.

On the Symfony blog today there's a new post from Fabien Potencier about a new book that's just been released and might be of interest to those wanting to get into the framework - Practical Symfony.

Two years after the publishing of "The Definitive Guide to symfony" book, I am happy to announce that the Jobeet tutorial is now available as a printed book: "Practical symfony". During the last two weeks, I have updated and enhanced the Jobeet tutorial based on the feedback from the community. I have also updated the screenshots to reflect the new Jobeet design. The "Practical symfony" book is the printed version of this tutorial and as such covers the symfony 1.2 version.

The Jobeet tutorial was their 2008 "advent" piece that created a job posting website from scratch with each day focusing on a different aspect of the application. There are two versions of the book (Propel and Doctrine) but for now, only the Propel version can be purchased over on lulu.com.

Looking for a good templating engine for your next PHP application? Be sure to check out this great list on the WebResourcesDepot site for a pretty comprehensive list.

PHP template engines are used widely to seperate the code & the layout. PHP makes a website easier to maintain/update & creates a better development environment by enabling developers & designers to work together easier. It sure has some drawbacks which is generally the performance (most libraries offer great solutions there) & need to learn a new syntax (not always).

Some of the engines included in the list are:

• Smarty
• Savant
• TinyButStrong
• PHPTAL
• the template engines under PEAR (like HTML_Template_Flexy)

In a new post to his blog Kevin van Zonneveld talks about making daemons, backend scripts that run independent of a web server.

Everyone knows PHP can be used to create websites. But it can also be used to create desktop applications and commandline tools. And now with a class called System_Daemon, you can even create daemons using nothing but PHP. And did I mention it was easy?

He starts with a definition ("a linux program that runs in the background") and why PHP makes a good language choice for creating them. His example uses the System_Daemon PEAR class to do most of the heavy lifting. To use it, you only need to include it at the top of the script and make two calls to the setOption and start methods to have the rest of the code all set to run as a daemon.

The example code sets up a daemon complete with support for command-line arguments and the ability to be run from init.d on the local system.

Ralph Schinder has posted about a new development in the world of Zend Framwork distribution - a PEAR channel.

For the past few months, the ZF team has been playing with the idea of releasing ZF from a PEAR channel. Over the past 2 years, we have seen a few channels distributing ZF that have pop up here and there.. so that lead us to believe there is an itch that needs scratching. The compelling reason against a PEAR channel is that, with ZF, there is nothing to "install". Just pop ZF in your include_path and off you go.

With the introduction of the next release (1.8) and the Zend_Tool component that comes with it, the framework is graduating from a "component library" into a more holistic framework with a more advanced distribution system. For those interested, he also includes the details of the channel (from pear.zfcampus.org) and the organizational plan of how the channel is laid out.

In this new post to his blog Jani Hartikainen looks at implementing the Data Access Object pattern in your PHP applications.

The advantage of this is that you can easily implement different methods to persist objects without having to rewrite parts of your code. I'm again going to use the programming language quiz game I wrote as an example. Since I initially wrote it to use Doctrine ORM directly, and both the old and new code are available, you can easily see how the code was improved.

He starts off with a look at the pattern itself (including a diagram of how an example would work with Doctrine) followed by the creation of the models for his Questions example. Add in the factory to create an instance and an exmaple of it in action and you're there.

On the GitHub Support forums Kastner has proposed an idea - making something similar to gethub gems but for PHP:

Just like ruby/gems, PHP has a packaging/distribution system called PEAR. I think that running a pear channel would help the PHP community with things like GPL extensions, as well as increasing participation in the community. Thoughts?

There's already thirteen comments on the post, all supportive of the idea including interest from the GitHub folks themselves.

In this new post to till's blog, he looks at a method for setting up PEAR on a Plesk system.

Now running any config interface is a blog entry by itself and when I say Plesk, I should also mention confixx and cpanel. And while I have a strong dislike for all them, let me focus on Plesk for now. This is not a copy'n'paste howto, so make sure you double-check all steps involved. With little knowledge, you should be able to to apply all instructions to any other control panel, all you need is SSH access to the server.

The process includes two different sections - why your PEAR installation may not be working and how to install the PEAR packages (on any system supporting a package manager). Command line calls and configuration options are also included.

DevShed has posted a new tutorial today looking at one of the more useful tools a developer can add into an application - logging.

If there is no logging mechanism, then if there's a goof-up in a production environment, you have absolutely no idea what went wrong. The only thing which a support developer can do in this case is to reproduce the issue at the developer end, which sometimes work and sometimes don't.

The look at the types of logging (trace logs, audit logs and user logging/history) and create a simple class that allows flexibility for file location, priority and timstamping. Their script contains a writelog method that does all the work (including pushing it through the PEAR logging class).

Matthew Turland has this new blog post looking at some benchmarks he's generated for a group of mainstream PHP HTTP clients:

One of the interesting bits of research that I've done is benchmarking various mainstream PHP HTTP clients. Of course, we all know that there are lies, damned lies, statistics, and benchmarks, so take these with a grain of salt.

He ran them on his Sony Viao on Ubuntu with a stock PHP5 package. The tested packages were the pecl_http extension, the streams http wrapper, curl integration into PHP 5, PEAR::HTTP Client class and the Zend_Http_Client component. He includes the code he used for both a basic request and for something slightly more complex (posting form data). He used the XDebug and KCachegrind combination to produce the results.

The symfony blog has a new post spotlighting one of the new features of their 1.2 release - updates to its Doctrine functionality.

A lot of awesome stuff has been added recently to the next major symfony release, 1.2. Fabien has worked very hard to add without a doubt the most sophisticated features of any PHP framework that exists today. Not only are they nice features but he has implemented them in a OO way so that it is easy for me to implement the same features with another ORM, Doctrine. All this is done with very little work by me. So, give a big thanks to him if you enjoy this.

Included in the post is a real-world example showing how to use the symfony command line to build out an environment and create connections to the articles, categories and authors tables.

On the Developer.com website today, Jason Gilmore has a new tutorial covering a important feature of any based PHP install (unless disabled, of course) that is widely taken advantage of - sending emails.

Email plays a crucial role in website development, whether you'd like to confirm a new registrant's email address, recover a lost password, or provide prospective clients with a convenient means to contact you. [...] In this tutorial, I'll introduce you to several solutions for sending email using PHP, including PHP's native mail() function, PEAR's Mail package, and the Zend Framework.

He starts with some of the fundamentals of mail - the difference between POP3 and SMTP, Sendmail, etc - before moving on to an example of the mail function's usage. He does the same with the PEAR Mail package and the Zend_Mail component of the Zend Framework.

Sameer has posted a new tutorial to his blog recently, a look at a drop-in solution for pagination in your application - the PEAR Pager package.

Pagination is a frequent requirement in web development projects. Most PHP developers must have already implemented paging in one form or other in their projects. In this post we will see how to add pagination the easy way using PEAR's Pager class. Note that in all the posts I use PHP 5.x.x, so if you are still stuck at version 4.x.x, its already time to upgrade.

He includes a simple example (just the page links), how to install the Pager package and a larger example where the results are pulled from a database table and paginated correctly based on an offset ID. There's even some CSS thrown in to make it a bit more pleasing to the eye.

The ProDevTips site continues their look at using Doctrine in PHP with this latest article in the series that adds in a simple, automatic CRUD system to the application.

I just found myself wishing for automatic CRUD, for quick and simple administrative tasks, as it turned out a very easy thing to add.

They create a model for their Company table and a new controller to handle the admin requests. Throw in some fetching functions, a bit of form handling and a bit of Smarty login and you have a simple admin form that automatically creates itself based on the columns in the table.

Jani Hartikainen talks about some updates he's made to the ModelForm class for the Zend Framework and how its been reworked a bit to take advantage of Zend_Db_Table.

I've been reworking the ModelForm class for ZF a bit. Earlier this year, I discussed porting it to use Zend_Db_Table with Matthew Weier O'Phinney, for using it with Zend Framework. I initially had done some checking on Zend_Db_Table, and some small code changes to modify the class to use it instead of Doctrine, but I ran into some issues. Now, I've had some time to think about it, I've reworked the class slightly and added basic Zend_Db_Table support, too...

He talks about the two sides - the issues that came up (including relation support and differences between Zend_Db_Table and Doctrine) and how they were overcome (creating an adapter setup to accommodate for the relations issues).

Christian Weiske set out on a project - no small thing - to convert the current PEAR documentation info over to the PhD DocBook rendering system. In a new post he talks about the conversion process and some of the technology involved.

The reason for PhD to exist was that the previously used DSSSL based system was slow: a full build (all formats and all languages) took 24 hours to complete. Further, the tools the system based on were old, rusty and nobody understood why they broke on some machines, but also why they worked on other ones. Having a php-based system for PHP ensures that there is always someone around who can fix it if it's broken. This wasn't the case with the old documentation build system.

The conversion was spurred on by the fact that the PEAR documentation stopped building and more and more people were finding it hard to build on their machines too. He walks through the steps he took - installing PhD, converting over the docs to the DocBook 5 format and the first builds with the new system.

Now that at the XML was shiny, too, it was time to actually use PhD on it. The numbers were amazing: While a build for one format and one language took around 40 minutes on my system (dual core Macbook with 2GHz and 2GiB RAM), building the same with PhD takes 45 seconds!

As announced on the symfony blog today, Doctrine now has "citizenship" in the framework with the release of the sfDoctrinePlugin:

Today, Doctrine gained its citizenship in symfony 1.2. The sfDoctrinePlugin was linked via externals and is now officially bundled with symfony. If you've been around for a while, you'll know that this was highly anticipated and is a long time coming. To celebrate, I'll give a short little tutorial on how you can get started using Doctrine in symfony. Read below if you're interested.

The post gives you a brief introduction to how to load and use the Doctrine plugin, including how to build out an application automatically via the symfony binary.

On Devollo.com the first part of a series looking at something every PHP developer (or any other for that matter) should include in their application - data filtering.

Filtering data. We all have to do it. Most, if not all of us, despise doing it. However, unbeknown to most are PHP's filter_* functions, that allow us to do all sorts of filtering and validation. Using PHP's filter_* functions, we can validate and sanitize data types, URLs, e-mail addresses, IP addresses, strip bad characters, and more, all with relative ease. This is part one of two, covering filter_var() and the different constants and flags that can be set.

This method, using the filter extension, takes a lot of the work out of making sure that user-submitted data is what it should be. They include examples of how to filter numeric types, URLs, email addresses and how to sanitize the data to be sure there's no cross-site scripting or SQL injections to be found. This is a great reference if you're looking to get started with the filter extension.

In a new tutorial from DevShed today, they take a look at some of the "networking" functions that PHP has to offer - basically anything that can make a network connection.

PHP has a great many tools for interacting with a network and also with the Internet. In this article we will look at some of those tools and functions to see how we can use them to make our scripts more useful in a network environment.

They look at the fopen, gethostbyname, gethostbynamel, getservbyport and the Net_Whois PEAR package (among others).

The ProDevTips blog continues their series on using Doctrine in a sample application in this new part, a look at paginating the results from your database query.

Things are starting to become more and more feature complete. Let's look at how to implement general search and pagination.

They define the search to perform ($searchConf) and the pagination parameters ($pageConf) and apply them to their current Doctrine setup applying a simple layout to make the numbered links for switching between pages. They also define the search() method that pulls the results from the table to push into the pagination component.

On his CodeUtopia blog Jani Hartikainen gives an inside look at a feature of Doctrine, nested sets.

The Doctrine library comes with a feature called nested set, which makes saving trees in a database easy. However, it's quite easy to accidentally cause a lot of extra unneeded queries if not being careful. Here are some pointers to keep in mind while working with the nested set, and some example queries to make understanding it easier.

He gives an example, showing how to get rows from the database - parent and child - and some optimization tips to keep things light. There's also some pros and cons included for doing it either way (the standard fetching or using the more optimized versions).

The ProDevTips blog has posted the fifth part of their look at using Doctrine with PHP. This time they focus on file uploads.

It's time to take a look at how file uploads can be integrated into the Doctrine validation and CRUD process. We will have a product in the form of a digital download as an example, it will have a screenshot image that can be maximum 250 pixels wide and high. The download itself will be a zipped file.

They set up their table definitions first and set up a few validation functions (update, insert and for the file data) to work on top of that. Custom upload/uploadImage and save methods handle the user's submission while a simple delete method makes removing images easy.

In a fourth part of their series looking at using Doctrine in PHP, the ProDevTips blog moves on to implementing it in a typical CRUD interface.

They create the links between the tables (two hasOne relationships), a search() method to find the destinations for a user, a sorting method to multisort based on the subkeys of the value passed in and the methods for updating the information already in the database.

That's it for now, feel free to download this tiny Smarty and Doctrine framework. Note that for this to work you have to put Smarty and Doctrine in the lib folder. There is a login interface involved, just click submit there without entering anything. There is also an SQL file in the trip_selector folder if you want to try this out with some test data (same as in the picture above).

In this new post to the symfony blog, there's an update on the framework's latest version, Propel integration and the addition of the sfDoctrinePlugin.

After more that two years of development, the Propel team has released Propel 1.3 yesterday. This is a great achievement as Propel 1.3 sports a lot a new exciting features.

These features include PDO integration, object instance pooling, improvements to the date handling features and the addition of more default values for database schemas. There's also the updates with Doctrine:

As announced in the symfony 1.2 roadmap, Doctrine 1.0 will be officially supported and the sfDoctrinePlugin will be bundled with symfony 1.2. Doctrine 1.0 beta1 has been released two weeks ago and the Doctrine team will release Doctrine 1.0 final on September 1st.

In this new post to his blog Stefan Koopmanschap looks at a plugin for the symfony framework that has him impressed.

Using this plugin, it is not necessary anymore to really care about which ORM you pick for your project. It's the thought behind symfony 1.1 taken into the symfony ORM-selection.

He points to the DbFinderPlugin as an alternative to rewriting up the ORM code for your application by hand (or in something like Propel or Doctrine). It makes switching between ORM layers simple - just a configuration change to point to the new system.

In the third part of the series dealing with using Doctrine in your PHP applications, ProDevTips has this third part looking at a method for extending the tool's current functionality.

I simply knew we would need the extension capability that the Mdl class allows for sooner or later, I didn't expect it to be this soon though. The main problem here is saving a many to many relationship straight to the database from the $_POST array, to do that we can extend Doctrine Record with a new function I have named fromArrayExt which adds something extra to the normal fromArray method.

He shows how to extend the classes to create custom handlers for a grouping of checkboxes. The new code automatically handles their submitted values and pushes them directly into the database (with a simple save() call).

Helgi has posted about an update to the next alpha release of PEAR to remove support for certain versions of PHP:

For the next alpha release of PEAR that will happen in 2 - 4 weeks we'll have a min dep of PHP 4.4 and 5.1.6, so basically excluding 5.0.0 - 5.1.5 Now why am I going to do that?

This pushes more people up from the PHP 4.3.x series (to the 4.4.x that was the last PHP4 release) and up to a more recent PHP5 version for the future. Eventually, PHP4 support will be dropped all together, but for now there's a bit of a hold out.

Henrik has posted the second part of his look at using Doctrine, this time in combining it with Smarty. (Check out part one here).

We are creating an MVC setup where M is Doctrine, V is Smarty and C is our own stuff we do here. The Zend Framework has been reduced to just another component library for me now, I will pick goodies when I need them.

He shows how to be "empowered, not stifled" by the framework and to combine the two technologies in a flexible, lightweight platform. His example is a simple signup form that, on submit, saves the information to the database via the Doctrine layer.

In a recent post to his blog Dhiraj Patra looks at the caching functionality that PEAR has to offer via the PEAR Cache package.

Caching is currently a hot topic in the PHP world. Because PHP produces dynamic web pages, scripts must be run and results must be calculated each time a web page is requested, regardless if the results are the same each time. In addition, PHP compiles the script every time it is requested. [...] PEAR's Cache package offers a framework for the caching of dynamic content, database queries, and PHP function calls.

He talks a bit about what kind of methods are included with the package and shows examples of how it works for function call caching, caching the output from the script execution and how to implement your own custom caching extension of the main code to make it even more flexible.

Henrik waves goodbye to the Zend_Db component of the Zend Framework in this new post to the ProDevTips blog - his new favorite is Doctrine.

It was long overdue but finally I've taken a look at Doctrine. And I'm blown away, bye bye Zend DB. [...] It's time to try and convey how awesome I think Doctrine is.

His example sets up a table definition and defines the associations between the columns for a "members" table. He defines a "city" table too and shows how Doctrine can easily combine the two and make selecting from and inserting into the tables simple.

Jacques Marneweck has a quick reminder for those trying to get the latest PEAR installer - you can always get it from CVS.

Quick note that the PEAR installer is missing (go-pear.org has expired and has been snapped up by some cybersquatters) and http://pear.php.net/go-pear renders a 404. So the current solution is to grab the go-pear install from CVS.

A quick curl call to a url on the cvs.php.net site (in the /pearweb directory) is all it takes to grab the latest. The page it's pulling is the source for the go-pear.php installer that can be run either from a web browser or from the command line (with a PHP binary).

Chuck Burgess has a quick post pointing out the next "PEAR triage days":

PEAR's next Bug Triage days are this weekend: Saturday 4 PM - 9 PM UTC and Sunday 4 PM - 10 PM UTC.

You can find the schedule and more information about joining in at this page on the PEAR wiki. You can find others working on the triage on the EFNet's IRC network in the #pear-bugs channel.

Amir Saied recently posted a handy little tool for the PEAR users out there - a bash script that handles tab completion for you.

Lately I've been playing alot with the PEAR CLI. The one annoying thing I noticed the most was its lack of tab completion that I'm used to from the shell. It turns out that this feature is very easy to add, in the bash at least.

It will finish off the PEAR commands for you and expand out the PEAR package names and discovered channels when it finds a match. You can download the package here.

On his blog today Asvin Balloo has posted the first part of his look at his method for geolocating the visitors to your website using the PEAR GeoIP package and the MaxMind GeoLite Country information.

In this first part, he just makes sure that you have what you need installed before really getting started. Brief installation instructions are provided and example code is included to make sure things are up and working correctly (a lookup for whatever IP you're coming from).

It uses the lookupCountryName method to translate the information based on the MaxMind data.

A new entry has been posted to the PEAR blog with the latest minutes for the group's July 13th meeting.

Some highlights from the meeting include new/upcoming RFCs for package naming schemes, exception handling in PHP 5.3, and a vote on extending the current PEAR2 Policies. Heavy stuff, check it out!

You can check out the full notes here on the PEAR portion of the PHP.net wiki.

Francois Zeninotto has posted a comparison of three different ORM (Object Relational Mapping) layers for PHP - Propel, Doctrine and sfPropelFinder (the last being a plugin of the symfony framework).

When it comes to ORMs, it's all a matter of preference. Is it, really? This post compares side-by-side the code required to perform some simple operations with three OO database requesting API. The purpose is to demonstrate that productivity, and not only style, can vary a lot depending on the ORM you choose.

He's worked up a long list of examples including methods to:

• Retrieving an article by its primary key
• Retrieving the latest 5 articles
• Retrieving articles based on a complex AND/OR clause
• Retrieving articles authored by people of a certain group
• Retrieving an article and its category by the article primary key
• Retrieving articles and hydrating their author object and the author group

Each one comes with their own (usually simple) code. His conclusions point out different "bests" of each - like sfPropelFinder being the "most magic" and that some of the limits of Propel are very frustrating.

On the SaniSoft blog Tarique Sani has posted about (and made available for download) some code sniffs for the CakePHP framework. Some problems arose with some of the naming that the framework uses, but with some "tinkering around"...

[It became] apparent that I had to have my own set of Cake sniffs to manage this but a separate standard just for this seemed an over kill and the simplicity of code made it kind of fun to add more standards which I liked but were in different set of sniffs.

You can grab the whole list of sniffs from their downloads. They implemented them as a pre-commit hook on their SVN server even so that developers could not violate the coding standards when they submit their code.

Padraic Brady has posted about a new inclusion that Google has announced will be included in the authentication methods for their APIs - OAuth.

The Google Data API support comes with a few gotchas. Its documentation show a clear preference for using GET instead of POST, though the Google OAuth server does appear to natively support POST requests for everything with the exception that it has a small bug which interprets an empty POST request body as a sort of phantom empty parameter.

He notes that the library he's been working on (and submitted to both the Zend Framework and PEAR) it up to the 0.0.3 release including functionality marked as beta for the Consumer portion.

In a new entry to his blog, Jonathan Street talks about a new wrapper class he's built up around the Windows Live Contacts service.

It was a shame really as it was a really exciting project with Microsoft leading the way in the area. It's been only recently that Google and Yahoo have caught up and released their own APIs for accessing their users data. [...] With the possibility of actually using the code myself creeping up on the horizon I decided to put the time in to write wrappers for PHP. It can be broken down into two components.

These two components are the delegated authentication, used to get permission from the user to grab the data, and the actual interface to the Windows Live Contacts data. Both packages have been submitted to PEAR.

The DevX site has posted a new tutorial talking about their method for creating reports and generating statistics based off of data from your PHP application.

Statistics and reports analyze the change over time of any kind of phenomena. [...] For the software industry, statistics and reports provide both an ongoing challenge and an ongoing market. At present, programming languages such as PHP and Java come with built-in packages for developing applications around statistical problems.

They use two PEAR packages for the statistics - Text_Statistics and XML_Statistics to pull in different kinds of data and extract results from it. The next step is to make a meaningful report out of these numbers - that's where PHPReports comes in. It's a simple tool that makes simple reports for you that can then be styled with CSS however you'd like.

Padraic Brady has a new post today mentioning both the PEAR::Encryption package and the Zend_Crypt component of the Zend Framework.

It's been a while since I did some active ZF/PEAR component development. It's been one of those 6 month periods where time to commit was a rarity for a few reasons. So now that I'm back on the road, where to?

He sets his sights on the Zend_Crypt component and details some of the encryption methods it contains - HMAC, the Diffie-Hellman Key Agreement Protocol, a hashing wrapper and proposed support for a RSA public key cryptography. He mentions that a lot of this support is already in a beta package for PEAR.

David Coallier has posted both a congratulations and thank you about the PEAR group elections. Congrats to those who were voted in including Joshua Eichorn, Christian Weiske and Travis Swicegood and his many thanks for being voted in as President:

My place as I consider it and as Greg mentioned on the mailing list yesterday is much more "ambassadorial" than "presidential" and being the PEAR ambassador around the world, I'll be glad to discuss, argue, improve the general idea of PEAR to anyone. I'll also be happy to discuss PEAR2 if anyone is interested but first and foremost I'll be happy to help our new PEAR Group (which I am pretty sure won't need help ) and the community.

You can find out more about the results of this year's elections on the PEAR election pages from pear.php.net.

Daniel O'Connor has posted a quick guide to customizing your installation of the PHP_CodeSniffer PEAR package to match the coding standard you'd like.

PHP_CodeSniffer is a PEAR package which detects potential coding problems and enforces your style guide. The default is the PEAR coding standard, but you can easily change that.

His method requires the creation of a custom "FooCodingStandard.php" (named whatever you'd like, of course) that contains a class/method defining the "sniffs" you'd like to use for your standard. Use "pfm" to make it into a package and install it to your system - you'll be all set.

Vikram Vaswani has a new tutorial posted to the Zend Developer Zone today about integrating PHP with an OpenID system via a few helpful packages.

OpenID, a free, open-source framework for "single sign-on" across different Web sites and applications. The even better news? There already exist a bunch of PHP widgets that allow developers to easily integrate OpenID into a PHP application, and this article is going to show you how to use them. So what are you waiting for? Flip the page, and let's get going!

For those not familiar with the authentication method, he defines OpenID and shows how it can help with the "too many passwords, too many accounts" problem many users face. He uses the PHP OpenID Library and the Authentication::OpenID_Consumer PEAR package (as well as several other PEAR packages to help with the connections and message formatting). He builds two simple forms to use the service - one to authenticate a user and another to create a new account.

It's that time of year again - time to gather the votes for this year's PEAR elections for the role of President and others to be inducted into the group.

As every year it is the time of the election for the PEAR Group and PEAR President for the year 2008 and 2009. If you haven't casted your vote just yet, NOW is the perfect time to do it so go to the election page and place your vote.

You can find out more about the elections from the page for the Presidental election and for the Group elections. You must be a PEAR developer in order to vote.

Ken Guest has posted a review of yet another PHP-related book from APress publishing, "PHP Objects, Patterns and Practice (Second Edition)".

While being an easy read, this is a well written, serious book and is aimed squarely at enterprise-level developers and software engineers who make their living through the development and architecture of solutions developed in PHP.

He breaks down the book into the three sections its title mentions - working with objects, design patterns and a healthy dose of PEAR, phpDocumentor, PHPUnit, CVS and phing.

Ken Guest, in a response to another post from a different blogger, has posted some of his own validation replacements for the regular expression method the other blogger chose.

I've noticed that Richard Heyes, who professes himself to be a php guru, deleted my comment on his "Some common regular expressions" posting which simply pointed out his expressions didn't quite do the job and suggested a few PEAR packages that should be used instead of the expressions that he proffered

His examples have the benefit of what he calls "defense in depth" - the functionality to catch a bit more than just a regular expression can alone. His examples include PEAR_Validate for email addresses, Net_CheckIP2 for IP addresses and the Validate_UK package for the sort code and telephone numbers.

Gennady Feldman has posted two comments/suggestions about things he thinks could be done to improve the PEAR and PECL websites:

So I attended the PEAR2 presentation and had a chance to bug the guys behind PEAR/PECL. There's definitely exciting stuff happening and they are pushing forward with many exciting ideas.

His suggestions include updates to documentation, crrection broken parts of the API and a "Package News" feature with the ability to leave comments on them.

He's also posted another suggestion - the ability of the authors of the project to provide other links besides the ones just for the project (external documentation, tutorials, etc)

Matthew Turland has posted about some of his experience with PHPT tests with PHPUnit.

Recently, I wrote some for a project and realized that I wasn't aware of how to generate code coverage reports. Many thanks to the very helpful patrons in the #pear channel on EFNet for helping me to get this working.

He show his setup process (on Kubuntu) - grabbing the PEAR package, installing it and how to get a runner script to integrate the PHPT testing into PHPUnit.

In a new post to his blog today, Ken Guest talks about the split that's been made in a PEAR package for calculating the dates of holidays (Date_Holidays) for localization reasons.

We decided that this one package should be split into subpackages: one subpackage per region/country. Some advantages of this approach are that each driver / filter / subpackage gets it's own stability and version number - we wouldn't have to keep increasing the version number of Date_Holidays each time a new driver is added or when an existing driver gets a significant number of fixes.

To replace your current version of the package (with all of the regions built in) with a new version that still contains all versions, uninstall the Date_Holidays and grab the "Date_Holidays#all" package. Otherwise, you can check out the PEAR page for the main package and see the subpackage list if you only need one for your area.

Time has come back around for the 2008-2009 PEAR group elections and David Coallier has posted some details about this year's elections.

It is now this time of the year again where the PEAR Group throws in the PEAR Group Nominations. The nominated people will then be called for votes by the community and 7 lucky (even though luck has nothing to do with it) will be elected as the new PEAR Group member for the year 2008-2009.

The entire PHP community is requested to nominate who they think would make the best addition to the group, regardless of how they're related to the PEAR project. Nominations should be sent to Martin Jansen by midnight (UTC) May 31st.

In a new article from PHPBuilder.com.au today, they talk about the "powerhouse of web services", SOAP, and how to get started working with it in PHP.

You've tried your hand at building mashups, experimented with a few RESTful Web services, maybe even started your own. Sure, you've got data sharing working. But how do you make your Web applications really talk to each other? In this tutorial, I'll show you how to take your Web applications to the next level with SOAP.

They opt to go with the NuSOAP method to consume another service and create your own simple one. They include a few code examples for either side and a (very) brief look at doing some debugging with what NuSOAP has to offer. One thing to note - if you have PHP5's SOAP extension compiled in and working, NuSOAP will throw an error about redeclaring a class name. This is because of a conflict between the naming of the SOAP extension's methods and NuSOAP.

code:diesl has posted their list of the top six books that can help you master the PHP language:

If you are new to PHP or are thinking of moving to PHP form other language then the following list of books will provide you with the required knowledge to become a seasoned PHP programmer. Of course, the list is subjective and you may have a different list of books in mind.

Their list is made up of:

• Zend PHP5 Certification
• PHP in Action
• PHP and MySQL Web Development
• PEAR
• PHP Cookbook
• SQL for MySQL Developers

The Zend Developer Zone has linked to a tutorial from Ruben Vermeersch about how to get the Zend Framework and the Doctrine ORM library working together.

This article will guide you through the steps needed to set up a project using both the Zend Framework and Doctrine. In a step-by-step way, we will set up a simple message board application.

He includes introductory things like the folder structure and an example of having Doctrine installed inside of it. Its all code from there on out - the bootstrap file, setting up a global handler, and how to integrate it all into their simple ZF application.

The New Earth Online has a quick look at one easy method for speeding up your site in a few different ways - caching pages and information with things like Cache_Lite and APC.

As your site traffic grows it takes longer and longer to generate a dynamic page from sending multiple queries to a database. One possible solution to limit queries is to cache the result of each query that is needed, or to have a complete full page cache for your site.

They look at the two ways I mentioned - the Cache_Lite PEAR package and the APC extension (that will soon be included by default in the stable PHP releases). Bits of code are provided for each showing how to get them set up and get them working inside of your application.

On his blog, Michael Kimsal talks about a presentation he sat in on at this year's MySQL Conference given by Joe Stump from Digg.com:

One key thing he's repeating is using a service layer to access data asynchronously. His advice right now is to group data requests at the top of a user request, do them asynchronously, and then use the data in the rendering when it comes back.

They've published a PEAR package as an example of this asynchronous method that interfaces with Digg's API (http://services.digg.com). You can read more about the subject of his talk on the MySQL Conference website.

According to this post on the PEAR blog, the first PEAR bug triage is now over:

PEAR's bug tracker hit the 600+ open bugs mark a month ago. [...] So with 600+ open bugs (not including the feature requests), we had to do something. [...] The logical step was to hold our own bug smashing event and see how it works for PEAR.

Back on March 22nd and 23rd (Easter weekend) they hunted for bugs. Several developers showed to help out and many bugs were fixed and they managed to bring the number of open bugs for PEAR down to 547 with the two days of work. There were some milestones reached too:

Thanks to the triage, we are close to reaching two important milestones: Closing bug reports with lower bug ID than 1000 (1 bug left!) and 2000 (5 left).

On the Zend Developer Zone, Vikram Vaswani has posted a tutorial that shows hos to "break the language barrier" between PHP and Microsoft's Excel to allow for the reading and writing of spreadsheet data directly from one to the other.

When it comes to playing nice with data in different formats, PHP's pedigree is hard to beat. Not only does the language make it a breeze to deal with SQL result sets and XML files, but it comes with extensions to deal with formats as diverse as Ogg/Vorbis audio files, ZIP archives and EXIF headers. So it should come as no surprise that PHP can also read and write Microsoft Excel spreadsheets, albeit with a little help from PEAR.

After grabbing the different parts needed (the PHP-ExcelReader package and the Spreadsheet_Excel_Writer PEAR package, he shows how to create a simple spreadsheet with just numeric information in it. For something a bit more interesting, he goes the other way and shows spreadsheet data as an HTML table.

Other examples included as well are things like: pushing spreadsheet data into a database, working with formulas and styling it to your liking.

Lukas Smith got a chance to catch up with Rasmus Lerdorf (and others in #php.pecl) and "talk shop" about topics including handling large libraries and maxclients settings.

In this first post I will provide a link and some commentary on Rasmus's points regarding Doctrine (note I left independent chatter in the log in order to not have any chance of me filtering the content, but there is very little of that so I hope the discussion is still easy enough to follow).

Jacques Marneweck points out a tutorial he came across showing how to perform an installation of the PEAR library system on a shared host.

This is quite useful when you are forced into using a clueless shared host who only have the bare PEAR installation on their servers, and have not ever considered installing DB, Mail, Net_SMTP, etc. which lots of people use instead of reinventing the wheel with each project.

The steps of the tutorial are pretty simple and they include two different ways - installing it to your docroot directory if the web host already has the pear binary set up or using ftp/ftps/sftp to upload and install the needed files.

The Symfony project is recommending you upgrade your plugins to the latest editions - an issue with the PEAR channel caused it to load the wrong ones:

A problem in the symfony project PEAR channel made the plugin-install task always install the oldest version of the plugins, instead of the latest. If you recently installed plugins with the symfony command line, you probably installed an outdated version. Plugins installed via SVN are not affected.

You'll need to run a plugin-upgrade command for each of the plugins installed on your system to ensure that you're completely up to date. The post has complete info on how to tell which plugins you have and the exact commands to issue to being them up to date.

On his blog today, Johnathan Street poses a question - is PHP "good enough" to be used in the scientific community?

There is an accelerating trend in Biology to make data and tools available via web interfaces. In my opinion this is an environment where PHP excels and yet all the literature I've seen discussing the development of these services uses Perl or occasionally Java.

He came across two science-related PEAR packages that were created back in 2003, but not too much since then. He wonders if there's anyone else out there that might feel like PHP is a perfect fit for some of the sort of applications the scientific community could need.

So my question is this. Is anyone out there using PHP in a scientific environment? Are there resources available which I've missed?

Akash Mehta has pointed out five "PEAR gems" that can help you get your code up and running faster - some helpful bits of code to help you deal with some common issues.

Sifting through the repository is also a challenge; a basic category system is in place, but it's hard to tell what you want when you don't know what's available. Here are some gems from the PEAR repository that you could really find useful.

The five that made his list are:

• Service_Akismet
• HTTP_Request
• Archive_Tar
• Spreadsheet_Excel_Writer
• XML_Parser

On his blog today, Stefan Mischook compares two of the popular component libraries out there - PEAR and the Zend Framework (yes, it can be considered a grouping of components too).

Now that the Zend Framework is ready for 'prime time', I've been considering the Pear framework with regards to how it now fits in the PHP world.

He suggests that not could both be considered component libraries, but might also both be frameworks (based on a definition that a framework is a "consistent set of components that are designed to work together in a unified manner"). He also asks about the need for something like PEAR now that the Zend Framework has come along, getting Jonathan Lebensold's opinion too.

Following on the heels of this post to the SitePoint blog (about "roughtime"), Akash Mehta has posted his own version of providing users with something a little different - relative time.

I understood the merits of the approach, but it struck me that a relative time might be a little more useful for many situations. For example, in a fast moving discussion, a short timestamp (e.g. 8:30 AM) as well as a verbal summary of how long ago the time was (e.g. "4 hours ago", "20 minutes ago") are most useful to the user. [...] Now, I figured this could be achieved very easily in PHP - and it could.

His code is included showing a series of if/else comparisons that change the values to their hour/minute/second counterparts. He also recommends the PEAR Numbers_Words package to help with readability.

• Validate_IT 1.0.1
• Validate_IT 0.1.0
• Validate_IT 0.2.0
• File_PDF 0.3.2
• HTML_Template_Flexy 1.3.3
• Net_LDAP 1.1.0
• Services_Akismet 0.5.0
• Crypt_GPG 0.5.0

• HTTP_Session2 0.7.1
• PHP_CompatInfo 1.7.0a1
• Services_Akismet 0.4.0
• File_Infopath 0.1.0
• MDB2_Schema 0.8.2
• Services_Akismet 0.4.1
• Validate_HU 0.1.0
• Console_CommandLine 1.0.0RC2
• Pager 2.4.5
• Translation2 2.0.0RC4
• Validate_IT 1.0.0RC1

Mike Gauthier has created a PEAR-based implementation for the popular Akismet spam filtering system that he's added to the site:

I'd like to let you know about a new PHP 5 implementation of the Akismet REST API. The package, Services_Akismet is MIT licensed and distributed through the official PEAR channel at http://pear.php.net/package/Services_Akismet.

Hopefully this will make it even easier for third-party PHP projects to use Akismet spam tools. The code is well documented and should "just work" on any PHP 5.2.1+ system.

It's currently in its alpha stage and was derived from the miPHP Akismet class written by Bret Kuhns.

• File_Cabinet 0.1.0
• Validate_IE 1.0.0
• Net_SMTP 1.2.11
• pearweb_phars 1.4.1
• PHP_CompatInfo 1.6.0
• PHP_CompatInfo 1.6.1
• VFS 0.2.0
• Structures_DataGrid_DataSource_Array 0.1.4
• Services_OpenSearch 0.2.0

In this new post to his blog today, Tony Bibbs asks a question that pops up every once and a while surrounding the Zend Framework - why don't they use the PEAR package distribution methods to handle the releases of the framework? (Specifically as pertains to PEAR channels)

Why hasn't Zend provided an official PEAR channel? In my search for an answer I found this response from "bkarwin": No, we have no plans to offer ZF under a PEAR channel or other piece-by-piece distribution method. Assuming bkarwin was working in some half-official capacity at Zend I'd simply ask "Why not?".

Tony wonders why, if the PEAR group (and project) has such a good thing already in place, it can't just be adapted to make releases of the various components of the framework simpler than having to wait for a whole new release to get the fixes the users need.

• Image_GraphViz 1.3.0RC3
• Services_SharedBook 0.2.4
• HTTP_Session2 0.7.0
• Net_UserAgent_Mobile 0.31.0
• Log 1.10.0
• FSM 1.3.0

• LiveUser 0.16.13
• pearweb_gopear 1.1.0
• pearweb_phars 1.4.0RC1
• Services_Digg 0.4.2
• DB_DataObject 1.8.8
• HTML_Template_Flexy 1.3.0
• HTML_Template_Flexy 1.3.1
• File_Ogg 0.3.0
• HTML_Template_Flexy 1.3.2
• Text_Diff 1.0.0
• pearweb_phars 1.4.0
• PEAR 1.7.0
• pearweb_gopear 1.1.1
• Net_CheckIP2 1.0.0RC2
• PEAR 1.7.1
• PHP_CodeSniffer 1.0.1

On the Zend Developer Zone, jonwage has posted about an ORM (Object-Relational mapping) he came across that can help abstract out your interface with your backend database - Doctrine.

One of its key features is the ability to optionally write database queries in an OO (object oriented) SQL-dialect called DQL inspired by Hibernates HQL. This provides developers with a powerful alternative to SQL that maintains a maximum of flexibility without requiring needless code duplication.

The project's page gives the full details on the features it offers and has links to the latest downloads so you can try it out for yourself. There's even a blog you can subscribe to to keep up to date.

Cal Evans has posted a tutorial on the Zend Developer Zone (posted today) about using the PEAR Structures_DataGrid package to create quick and easy data tables.

In this article, I'll be introducing you to the Structures_DataGrid package, showing you how it can be used to display structured data in tabular form. I'll be showing you how to hook it up to various data sources (including a CSV file, an RSS feed and an Excel spreadsheet), and how to format the resulting output so it's as pretty (or as ugly) as you want it to be.

They talk about what you'll need to get started (the different packages for different kinds of data) and some sample code to help you down the path to more attractive tables. There's even a bit touching on some of the more advanced features like exporting to Excel, pagination and data sorting.

The Developer Tutorials blog has a new article that talks about their method for creating simple geotargeting for your visitors.

In this tutorial, we'll take a look at the technique of geotargeting, or serving content to users based on their physical location. The technology is invaluable; with simple techniques, you can target advertising to specific users, collect more accurate usage statistics, serve content in different languages for different regions and provide local information like weather reports to your visitors.

They use the GeoIP services offered by Maxmind to perform the IP to location translation and the PEAR package already created to make the integration as painless as possible.

• Net_LDAP 1.1.0a2
• pearweb_gopear 1.0.3
• HTML_TagCloud 0.1.3
• Console_GetoptPlus 1.0.0RC1
• Crypt_GPG 0.4.0
• LiveUser 0.16.13

The Zend Developer Zone has released part two of a series (here's part one posted back in November) looking at making forms for your website with the help of the PEAR HTML_QuickForm class.

I'll be discussing some of the package's non-standard form elements, teaching you how to combine elements into groups, showing you how to apply templates to control a form's appearance, and guiding you through the process of writing and registering your own custom validation rules.

There's plenty of sample code and screenshots to go around in this second part including examples of form auto-completion, multi-select elements and and example of its integration with Smarty.

• Net_LDAP 1.1.0a1
• Date_Holidays 0.17.3
• Date_Holidays 0.17.4
• HTML_CSS 1.5.0
• Structures_DataGrid_Renderer_HTMLTable 0.1.5
• PEAR_Info 1.7.1
• Console_CommandLine 1.0.0RC1
• Crypt_GPG 0.3.11
• Log 1.9.15
• Log 1.9.16
• PEAR_Frontend_Web 0.7.2
• Net_LDAP 1.1.0a2

• HTTP_WebDAV_Client 1.0.0
• Console_Table 1.0.8
• Console_CommandLine 0.2.1
• File_Bittorrent2 1.1.0
• MDB_QueryTool 1.2.1
• DB_QueryTool 1.1.1
• MDB_QueryTool 1.2.2
• DB_QueryTool 1.1.2
• Net_FTP 1.3.5
• Crypt_GPG 0.3.10
• Net_LDAP 1.1.0a1

Helgi has posted about the updates that have recently been made to the PEAR website (pear.php.net) to help correct some issues and bring in some new features.

I just did a new release of pear.php.net which has a bunch of new features and bug fixes, most of which you can see here.

Some of the updates include:

• One column design instead of the 2 column design
• Usage of the YUI CSS reset + fonts
• The package list on http://pear.php.net/packages.php doesn't highlight deprecated packages anymore
• Now developers can see bug reports by unconfirmed accounts
• The RSS feeds now contain new line breaks!
• Patch uploading during ticket creation now works

He also specifically mentions some of the feedback he's gotten on certain things (like the new layout, the CSS of the site and the DES passwords) and explains some of the rationale behind their update/use.

• Console_CommandLine 0.2.0
• PHP_Debug 1.0.0
• Text_Highlighter 0.7.1
• Log 1.9.14
• XML_Query2XML 1.6.0RC1
• pearweb 1.17.0
• pearweb_index 1.16.12
• PEAR 1.7.0RC2
• Text_Diff 0.3.2
• Date_Holidays 0.17.2
• pearweb_index 1.16.13
• XML_Query2XML 1.6.0
• pearweb 1.17.1

Stoyan Stefanov has posted about some updates he's been making to his Text_Highlighter PEAR package and to the hiliteme.com website.

In today's busy schedules there's less and less time to give love to our favorite open source projects. [...] Anyway, today I found the time to fix two bugs in Text_Highlighter and also include the patch from Daniel Fruzynski that adds support for highlighting VBScript. Wo-hoo!

The update to hiliteme.com uses the newly updated package, so you can try it out before you go and install it.

• Net_Ping 2.4.3
• Structures_DataGrid_Renderer_XLS 0.1.3
• Console_CommandLine 0.2.0

• Console_CommandLine 0.1.0
• Services_Amazon 0.7.1
• Testing_Selenium 0.4.2
• HTML_Table 1.8.2
• Structures_DataGrid_Renderer_Pager 0.1.3
• Structures_DataGrid_Renderer_HTMLTable 0.1.4
• Structures_DataGrid_DataSource_MDB2 0.1.11
• Structures_DataGrid_DataSource_DBQuery 0.1.11
• Structures_DataGrid_DataSource_XML 0.2.0
• Structures_DataGrid_DataSource_DBTable 0.1.7
• Structures_DataGrid_DataSource_CSV 0.1.6
• Structures_DataGrid_DataSource_Array 0.1.3
• Structures_DataGrid 0.9.0
• Structures_DataGrid_Renderer_XUL 0.1.3
• Structures_DataGrid_Renderer_Smarty 0.1.4
• Structures_DataGrid_Renderer_HTMLSortForm 0.1.3
• Structures_DataGrid_DataSource_DataObject 0.2.1
• OLE 0.6.1
• PHP_CodeSniffer 1.0.0
• Console_CommandLine 0.1.1
• Structures_DataGrid_DataSource_PDO 0.1.0
• Net_FTP 1.4.0a1

On the RegDeveloper website, there's a new tutorial posted that covers the creation of both PDF files and Excel reports from inside of PHP (with the help of the Spreadsheet_Excel_Writer PEAR component and the ClibPDF PHP Library (bundled with PHP 5.3).

Given the prevelance of PHP, Excel and PDF it's fortunate there exists class libraries for the generation of PDF documents and Excel spreadsheets using PHP.

They start with the PDF generation and show the installation process for ClibPDF and an example of creating a document on the fly. Their example sets up a title, some content text and a table of information. Creating the Excel spreadsheet is even simpler with the Spreadsheet_Excel_Writer - installation via a PEAR channel and defining the worksheet, fonts and content are quick and easy function calls.

• PEAR 1.7.0RC1
• Net_FTP 1.3.4
• Validate 0.8.0
• Log 1.9.12
• Validate 0.8.1
• Validate_US 0.5.3
• HTTP_Session2 0.6.1
• Log 1.9.13
• HTML_CSS 1.4.0
• Testing_Selenium 0.4.1
• PhpDocumentor 1.4.1
• Console_CommandLine 0.1.0

David Coallier has posted about the release ("THE release") of the latest version of the PEAR Validate package - version 0.8.0.

I am happy to announce the release of Validate to it's version 0.8.0 (In my opinion the last one before the next (and first) RC of this package towards a stable state). [...] The team has had a hard year loosing one of it's greatest member and the whole project has been literally on neutral since then.

This new release includes nearly thirty bugfixes including resolutions for issues dealing with iTLD validation, date extra validation, better ISSN/ISBN validation and includes some new unit tests as well. There's plans in the works to add features that would validate country codes and to make the move to PHP5.

• Services_Digg 0.4.0
• Net_CheckIP2 1.0.0RC1
• Services_Digg 0.4.1
• Translation2 2.0.0RC3
• Services_TinyURL 0.1.2
• Net_FTP 1.3.3
• MDB2_Driver_sqlite 1.5.0a2
• MDB2_Driver_pgsql 1.5.0a2
• MDB2_Driver_oci8 1.5.0a2
• MDB2_Driver_mysqli 1.5.0a2
• MDB2_Driver_mysql 1.5.0a2
• MDB2_Driver_mssql 1.3.0a2
• MDB2_Driver_ibase 1.5.0a2
• MDB2 2.5.0a2
• OLE 0.6.0
• FSM 1.2.5

• Net_Vpopmaild 0.1.0
• Image_GraphViz 1.3.0RC2
• DB 1.7.14RC1
• PHP_CodeSniffer 1.0.0RC3
• XML_HTMLSax3 3.0.0
• HTTP_Session2 0.6.0
• File_Gettext 0.4.1