In his latest post Hannes Magnusson describes his "dream" about a future for PHP where things like upgrading and working with extensions would be simpler, faster and more manageable.

Today we will revolutionize PHP. We will make it easier to upgrade the things you care about. We will make it easier to not upgrade things you don't want to upgrade. We will make it easier to distribute your extensions. We will make it easier to release according to your own schedule. We will make it easier to add functionality. We will make it easier to work. Ok, today is a white lie here maybe... I haven't actually implemented this, but bare with me here for a second.

With the introduction and huge growth of Composer, the PEAR package manager is fading in popularity and is slowly being abandoned. Unfortunately, it's still the primary mechanism for deploying and installing PHP extensions (PECL packages). He talks about some of his recent experience reviving a package and issues he had around the use of the packaging manager. He proposes the creation of a new "pecl install" tool - a package manager dedicated to PHP extensions, decoupled from PEAR.

The manager would just install basic PHP then leave it up to you to pick which features you need from there. The idea is still in its early stages, but the idea has taken roots and plans are being worked through to see if this idea will work for the future of the language.

There are quite a few things still missing and only binary protocol is supported at the moment, but the code seems to work reasonably well in small-scale testing. I am not sure whether this is useful for anyone, but at least it allows things such as quick prototyping of network servers, exposing sqlite database over memcached protocol etc.

An example of code using this new functionality is included in the post showing how to create both a simple sever with attached "get" and "set" handlers and a client to connect to it and enable the binary protocol.

For those that have made the switch to OSX Mavericks and are wondering how to get PHP and MySQL into a working state, Rob Allen has posted a quick guide to getting it all set up.

With OS X 10.9 Mavericks, Apple chose to ship PHP 5.4.17. This is how to set it up from a clean install of Mavericks. Note: If you don't want to use the built-in PHP or want to use version 5.5, then these are [other] alternatives: a binary package from Liip, Zend Server and a Homebrew install.

He provides all the commands you'll need to get things up and running including checking file/directory permissions, installing MySQL and using the command line to work with Apache (no more "Web Sharing"). He also includes the configuration changes to be made to the php.ini including how to enable Xdebug. There's lots of other good things included in the guide as well like setting up Composer, PHPUnit and how to compile a few handy extensions.

Hasin Hayder has posted a complete guide to getting Gearman and PHP playing nicely together. The guide gives you a step by step (and command by command) list to follow so you don't have the same pains he did trying to get it working.

I had a pretty rough evening today. No, not because the waiter forgot to add sugar in my tea, but because it was so boring to go through the trial and errors of installing gearman daemon and pecl gearman extension for php.

He walks though the whole process, starting with the failures, that he took getting it installed. Unfortunately it wasn't just as easy as installing a package and using PECL to drop in the extension. There was other software packages that needed to be installed as well and were a bit harder to figure out - libboost, gperf, libevent, uuid-dev and libcloog-ppl-dev. With these installed, the PECL install command was finally able to build and he got the shared module he needed.

Scott Arciszewski has posted a new tutorial to his site helping you get scrypt installed as an alternative to some of the other cryptographic functionality that's already supported by PHP (like bcrypt).

Most newbie PHP developers suck at developing user authentication systems. When not storing passwords in plaintext, they just wing it with a simple hash function and hope it's good enough. Instead of md5(), sha1(), or hash(), you should consider using scrypt, pbkdf2, or bcrypt. Today, I'll go through the steps required to start using scrypt in your web applications.

He walks you through the exact steps you'll need to get scrypt installed and working happily with PHP (provided you have root on the machine). Thankfully, it's pretty easy thanks to the scrypt extension provided through PECL. He gives a brief introduction to using the scrypt function and links to an updated version of a scrypt wrapper you can use in your applications.

The pecl_http extension has a little gem that can be handy at times - HttpRequestPool. Using this, you can send concurrent HTTP requests and can gain efficiency in fetching non-related data at once. For example, from an external source if your application needs to retrieve an user's profile, their order history and current balance, you can send parallel requests to the API and get everything together.

His code shows three example connections to a made up URL on three different endpoints. With the HttpRequestPool functionality, all three can be requested at once and tracked to extract the response body.

Despite the misleading title, this post on Reddit talks some about a switch that some Linux distributions are making when it comes to JSON support in PHP. They're moving away from the built-in support in favor of including this one.

In a quote from Nikita Popov (a comment on the post) he notes that:

It is true that some Linux distribution switched from json to json-c, but this should be transparent to the user. The standard PHP distribution still ships the JSON extension as it always did. [...] You should all take this chance to switch to PHP 5.5, so you can see that everything works fine and that PHP 5.5 is awesome

He also includes comments from the Remi (Fedora) project about the switch, noting that the end user shouldn't notice any kind of issues. The reasoning behind the switch has to do with licensing and usage issues of the previously built-in extension. You can find out more about that issue in this bug report.

In a new post to their site, the PHP.cc (well, Sebastian Bergmann) takes a look at the bytecode caching feature that's included in the latest release of PHP, version 5.5.

PHP is an interpreted language. The default PHP runtime, the one that can be obtained from php.net, compiles PHP sourcecode to an intermediate representation called PHP bytecode which is then executed. A bytecode cache stores this compiled representation of PHP sourcecode in shared memory. This eliminates the need to load and compile sourcecode on each request which leads to a significant increase in performance (up to 70% more requests per second).

He looks some at "the past" of PHP and how it made it up from the world of PHP 4.x to PHP 5.4 and the de-facto bytecode cache before now, APC. With the introduction of PHP 5.5, though, developers have access to an integrated version of the ZendOptimizer+ cache built right into the language. They include a little bit of documentation about how to enable it and how to install it via PECL if it's not already built in.

Brandon Savage has posted a quick overview of working with PHP and RabbitMQ for queuing. This is the first part of a three-part series about using these two technologies together effectively.

There are many times that you want to write background processes and queue up the tasks so that they can be handled in sequential order. There are any number of queues available for software developers, and one that I've really taken a liking to is RabbitMQ. Besides the fact that the queue is designed to requeue messages that are unsuccessfully delivered, RabbitMQ is fast and efficient.

He introduces some of the basic concepts behind working with RabbitMQ (like connections and channels) and an "exchange" - the method by which messages are routed. He talks about pushing messages to the exchange to be handled and how you consume the queue for updates. He also links to the various things you'll need to install to start combining these two tools including the AMPQ PECL extension.

Chris Jones has a new post to his Oracle blog today talking about the new "opcode" opcode caching that's going to be built into future PHP versions This is the implementation of the Zend Optimizer+ opcode caching in a native language interface. The latest PHP 5.5 snapshots have it included.

The new "opcache" can be seen as substitute for the venerable APC cache, the maintenance of which had become an issue. Note: although opcache is now readily available, there is currently nothing preventing you from using any available (working!) opcode cache in PHP 5.5.

He gives you a quick guide to getting this new opcode caching enabled and compiled into a shiny new download of the PHP 5.5.x branch. You'll need a special command line flag on the compile and to update your php.ini to load the needed shares module. You can also use it if you're on PHP 5.2 or higher either by compiling this source or using this PECL extension.

On the "System Architect" site there's a recent post showing you how to integrate PHP and Solr, the searching tool from the Apache project.

So why do you need a search engine, is database not enough? If you create a small website it might not matter. With medium or big size applications it's often wiser to go for a search engine. Saying that, even a small websites can benefit from Solr if you desire a high level of relevance in search results.

Their example involves an ecommerce website and a search for a term (iPhones) and how difficult it could be to match against the possible multiple variations on the models. Solr makes this kind of searching easier. He shows you how to get a Solr instance all set up and configured as well as the PHP PECL extension from here. A sample PHP script is also included showing connecting to Solr, inserting a new document and searching for a simple query of "hello".

Lorna Mitchell has a new post today showing you how to install XHGui to help with profiling your application for performance and processing issues.

If you're not familiar with XHGui it's a fabulously easy and friendly way to profile your application; to understand which method calls in a page take the time and how many times they are made, so you can improve the performance of your application. All these instructions are for my 32-bit Ubuntu 12.10 system, hopefully they will work for you or you'll be able to adapt them as appropriate.

She lists the dependencies you'll need to have installed before you can get XHGui working correctly including a MongoDB instance and the PECL xhprof extension. With those all set to go, you can go grab the latest XHGui from github and drop it into place.

Lukas Smith has a new post today about what he sees as an important part of PHP (or really most open source projects) - a predictable release cycle. It centers around the recent proposal to introduce the Zend Optimizer+ into the core and how it seems to be causing a delay with 5.5 (maybe up to 2 months).

What troubles me though is that its being proposed very late in the game for PHP 5.5, therefore causing a likely delay of 5.5 of at least about 2 months in the best case scenario if it were included. The other option of including it in 5.6 does not seem to be as popular at this point. This saddens me quite a bit since I believe that predictable release cycles would carry several advantages

He points out some things that come along with having predicability around the software releases like developers knowing when/if their changes will make it into the next release. It also makes it easier for end users to plan their releases of their own software, knowing when they'll be getting a feature. In this particular case, though, he doesn't quite understand the delay as the Zend Optimizer+ isn't a change to core, it's an addition:

What is even stranger for this case is that we are just talking about an extension here. Its not a language feature, there is no engine level integration. So even if its not added to core, people can easily get Optimizer+ via PECL. So in this case we are not talking about people having to wait another 10-11 months. Don't get me wrong I think getting an opcode cache into core is awesome, but the reality is that shared host users will probably still not have access to it [...] and the rest can still get it, albeit with a bit more effort.

I upgraded PHP and related pecl modules on my development machine today, and ran into a problem with Gearman. Actually I ran into more than one! Firstly the challenge of getting the newest pecl version working with a gearman version. Then an error where my existing PHP application couldn't connect to gearman after upgrade.

Running on Ubuntu, she found this tutorial helpful in getting Gearman back into a working state and installed (version 1.1.1). The "unable to connect" error turned out to be a change in how the Gearman connection needed to be made - the addition of a port to the connection string made things work again.

On PHPMaster.com today there's a quick tutorial showing you how to use SSH and SFTP from inside your PHP applications (requiring the ssh2 package).

In today's world with so many third-party integrations and content-sharing, it's important to understand and make use of protocols like SCP and SFTP. PHP's SSH2 extension, a wrapper for libssh2 which implements the SSH2 protocol, provides several functions you can use to securely transfer files.

Sample code is included showing how to make a SSH request to a remote server, define the key files to use and execute a remote command (like scp). They also mention the use of wrapper functions like mkdir that also work with SSH/SFTP connections. The post finishes up with an example class or two you can use to wrap your connection handling and make it a bit more OOP-friendly.

Now this blog entry is tagged a s PHP. Hs is that coming into play? - Well, on the one side we have this fast memcache interface, which allows to access almost arbitrarry data from the database. On the other side we have our PHP mysqlnd plugin interface where we can add special features, like query caching or load balancing, transparently to any PHP application. Why not combine those two things? - Good question. That's what we have done in the PECL mysqlnd_memcache PHP extension.

He includes some sample PHP code showing it in action - two examples: one using the "mysqlnd_memcache_set" method to set a memcache server on the MySQL connection and another showing two queries and how they're handled behind the scenes by this driver plugin.

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

He's broken it up into a few sections including the MySQL setup, Apache configuration
, updating the main php.ini and setting up PHPUnit ("and friends") for your testing. He also includes setup instructions for the mcrypt and the PECL OAuth extensions.

Anthony Ferrara has shared some thoughts in his latest post about some of the PHP frameworks that have come up lately - ones based in PECL extensions, not in userland code.

In recent months, a number of new frameworks have cropped up for PHP as PECL extensions (Including YAF and PhalconPHP). They promise to provide huge performance gains and lower resource usage for PHP applications. On the surface, they appear to be incredible tools for improving development. But they aren't all they are cracked up to be. In fact, I would argue that they are actually not necessary at all.

He breaks the arguments down into two sections - what you gain by having the framework based in an extension (like performance) and some of the things you give up (like readability, portability and maintainability).

My argument here would be that if you have a site where you can measure meaningful money savings by putting the framework into C (with taking the additional maintenance costs into account), you likely shouldn't be using a framework anyway.

Lorna Mitchell has a new post to her blog today showing how to use the functionality provided by the pecl_http extension to make an OAuth2 connection to Google.

I've written about Google and OAuth before, but that was OAuth v1.0, and they are introducing OAuth2 for their newer APIs; in this example I was identifying myself in order to use the Google Plus API. [...] OAuth 2 doesn't need an extension or any particular library as it doesn't have the signing component that OAuth 1 had, and OAuth 2 also has fewer round trips. It does require SSL however, because the requests are in the clear.

She includes some code snippets with an example of a connection - making a request to the remote HTTPS resource, adding some parameters to the URL (including the response type, your client ID and a redirect url). The response then contains the "code" value you'll need to make the second request to fetch the access token you'll need on future requests. You can find out more about the interface she's accessing in these docs about the Google Plus API.

In this recent post to her blog, Lorna Mitchell shows how to use the Jira REST API (provided as a part of some of the newer versions of the tool) to create a "dashboard" of the latest items added to the tracker.

Today what you get is an example of integrating with JIRA's REST API, because their recent "upgrade" locked me out of the issue listings pages completely and I really do need to be able to see a list of bugs! Their bug editing screen is quite usable, so it's just the list that I need here, but you could easily call their other API methods as you need to. These examples are PHP and use the Joind.in Jira tracker), parsing the JSON results and displaying the results as a simple list, looping with a foreach and outputting some HTML.

Artur Ejsmont has a recent post to his blog showing how to get a MongoDB PECL extension to compile in a 32bit OSX environment (Snow Leopard).

Here is a quick step by step guide on how to get mongodb and PHP5.2 mongo pecl extension going on your MacOSX in 32bit mode! NOTE: 32 bit mongodb binaries have 2GB address space limit so you wont be able to process too much on your laptop. You will still be able to code and connect to remote instances just fine.

His process includes five steps - well, eight if you count the optional "install MongoDB" ones too - complete with the commands you'll need to get things compiled, ready for copy and paste. You can find the MongoDB PECL package here.

In this recent post to his blog Stefan Koopmanschap shares some of the troubles (and a solution) when he was dealing with getting the Geoip PECL extension installed on his Zend Server setup in OSX.

Today I needed to get a client application up and running on my local system. This application uses the Geoip PECL package, so I needed to get this up and running. This turned out to be slightly more difficult than just a PECL install, as you're missing some libraries by default, so here is my log of things to do to get it up and running.

He gives the complete list of steps his followed including downloading the source and his way around this "System could not load this extension" issue. The trick was to recompile the source with the correct architecture. By default his extension was built with i386 instead of 64-bit but updating some of the CFLAGS settings (and a few other environment variables) got things compiling correctly.

Robert Basic has continued his series looking at using Dbus in PHP with this latest post to his blog - using the foundation he's createdbefore to make a chat bot that will listen and respond to commands on a Jabber network.

His new code listens for an incoming message on the "PurpleInterface", grabs the name of the sender and calls a "PurpleConvImSend" method with the conversation object and the message to send. You can find the complete source for the project on his github account.

Earlier this week I got an idea of trying to communicate with Pidgin, a chat client, via the terminal. [...] Surely I wasn't the first one to come up with this idea and after a bit of a googling found out that Pidgin's libpurple has a nice API for that, exposed via D-Bus. I first planned to write some scripts for this in Python or C, but when I finally sat down over the weekend to hack on this, realized there is a PHP D-Bus extension, thanks to Derick Rethans!

He goes through the whole process you'll need to get it up and working on your system - installing the extension via PECL, creating a DBus proxy to the Pigdin interface and getting a list of the currently connected users. You can find the first versions of this code in his account on github.

One thing I can say is that, even though I use a convenient app like MAMP PRO to set up my local development environment, I'm glad my sysadmin-fu is up to snuff enough to fly without the conveniences because after this ordeal, I feel like I might as well have made my MAMP stack from scratch with all the hoops I jumped tonight.

He shares a few of the things he discovered along the way like: the location of MAMP's "pecl" command, an error caused by a bad pear.conf file, doing custom compiles of PHP and libssh as a fallback and getting the extension to work in the CLI PHP version too.

Ulf Wendel has a new post that compares the performance of a classic method for using the mysqlnd plugin in MySQL replication to mysqlnd_ms, the replication and load balancing plugin for the mysqlnd driver (that works with the mysql and mysqli functionality and is, as of this beta of PHP, the default driver for MySQL connections).

Recently I was asked if PECL/mysqlnd_ms should be used to add MySQL replication support to a yet to be developed PHP application. The mysqlnd plugin, which supports all PHP MySQL extensions (PDO, mysqli, mysql), stood up against a classical, simple, proven and fast approach: one connection for reads, one connection for writes. Let's compare. This is a bit of an unfair challenge, because PECL/mysqlnd_ms was designed as a drop-in for existing applications, not optimized for those starting from scratch, *yell*... The plugin stands up quite well, anyway!

He starts with a look at the "classical pattern" of using a factory or singleton to make a database object instance that gives back different connections for reads versus writes (slave vs master). The mysqlnd_ms plugin allows you to define configuration settings to tell the queries to automatically go to certain places for different actions. For example, you could use "master_on_write" to tell it to use a master node if you're doing an INSERT or UPDATE versus a SELECT. He also shows a more complex example using a SQL hint and one issue that might come from the "human element" - not paying attention to database character sets.

In a new post today C. Sadeesh Kumar has a quick tip to help your script detect file types without having to rely on the extension to be correct.

In most web applications today, there is a need to allow users to upload images, audio and video files. Sometimes, we also need to restrict certain types of files from being uploaded - an executable file being an obvious example. Security aside, one might also want to prevent users from misusing the upload facility, e.g. uploading copyrighted music files illegally and using the service to promote piracy! In this article, we'll look into a few ways in which we can achieve this.

The trick to his example is in using the Fileinfo PECL extension. With the help of this extension you can look inside the file and pick out the "magic bytes" (the first few bytes of a file) and see what MIME type the file really is. He includes a simple example of using the extension on a file and a file upload script that checks the type and handles the file accordingly.

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:

In a new post Bradley Holt looks at some of his exploration into the combination of RabbitMQ and PHP as a possible platform for messaging between process (or applications).

I'm exploring the possibility of using RabbitMQ for an upcoming project. RabbitMQ is a free/open source message broker platform. It uses the open Advanced Message Queuing Protocol (AMQP) standard and is written in Erlang using the Open Telecom Platform (OTP). It promises a high level of availability, throughput, scalability, and portability. Since it is built using open standards, it is interoperable with other messaging systems and can be accessed from any platform.

He goes through the full process - installing RabbitMQ via MacPorts, grabbing the latest copy of the librabbitmq library and installing it and finally installing the AMQP extension for PHP so they can communicate. He includes some simple code that connects to the queue and sends a "hello world" message out to the connection bound to "routeA".

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.

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.

Most of the time you spend using PECL modules, you'll either be upgrading or installing new ones. Occasionally, though, you might need to move the other direction and roll back to a previous version. This handy tip from Lorna Mitchell shows you the handy single-command method.

Recently I saw some weirdness in an existing application when I upgraded a PECL module that the application depended on. To figure out if that really was the problem, I wanted to downgrade the module to its previous version. There is no opposite command to "upgrade" but you can instruct pecl to install a specific version of a module, using the -f switch to force pecl to overwrite newer modules.

In her case, she needed to downgrade the pecl_oauth package to 1.0.0 from 1.1.0. The trick lies in the "-f" switch for the "pecl install" allowing you to specify the version to install.

Lorna Mitchell has a new post today about using a popular backend processing tool, Gearman, from inside of PHP. Her example gives a full overview of how to add a new job and write the worker for it to make things happen.

Basically, this application generates some PDFs from a variety of data sources, makes images, and emails it. Since the whole data processing, image handling, PDF generation process is fairly heavy, I'm putting the requests to generate these onto a gearman queue and having some workers process the jobs.

You'll need to have the Gearman server and extension installed (sample instructions here for Ubuntu) to use the sample code she gives using the Gearman_Client and GearmanWorker objects to create the pieces of the puzzle. You can find out more about the Gearman PECL extension here.

Lorna Mitchell has a (very) quick post on getting Gearman installed for PHP on an Ubuntu linux system - as easy as a few package install calls, really.

I've been using Gearman lately in a project that I'm working on, and of course a month later when I came to deploy the code, I had to look up all over again what was required for a gearman server in order to put it on the new platform. Here is the short version for my future reference (and yours, if you like)

It's an easy two-step process - one to install the Gearman packages (binaries and development) via aptitude and the other using the pecl command to install the gearman-beta package and compile it. All goes well, you should be up and running with Gearman in just a few minutes.

Sam Holman has written up a new post on the Label Media blog today about installing Sphinx and PECL/sphinx on a Mac OS X system. No sample code is provided, but this will definitely help with the setup.

I've got a fairly vanilla install of Snow Leopard (10.6) and use the default installations of PHP, MySQL, Apache, et al. Installing the Sphinx open source search engine and the PECL extension wasn't too much of a pain, but would have been easier had i had the following notes to hand.

His first try was with Macports, but dependency issues shot that down quickly. Instead he opted for the more conventional path of: download the binaries of Sphinx and using the "pecl" command line too to install the PECL module. All that's left is adding the line to load the share object (sphinx.so) into the php.ini's config. You can find out more about the PECL sphinx package here

PECL OCI8 1.4.4 has just been released. It fixes a potential memory corruption using oci_set_* functions seen on 64 bit machines. This release can be used to update OCI8 on earlier PHP versions.

He talks about an error he's come across many times - "Warning: oci_connect() [function.oci-connect]: OCIEnvNlsCreate() failed" - and how it can be fixed with an environment setting. He updated the error message in this new version to be a bit more descriptive and help lead others to the problem more quickly.

On Elijaa.org there's an interesting post (from back in May 2010) about using the "cas()" command in the memcached PECL extension to update the cached value of an object while preventing collisions with other scripts that might be updating the same value.

A series of commands is not atomic. If you issue a 'get' against an item, operate on the data, then wish to 'set' it back into memcached, you are not guaranteed to be the only process working on that value. In parallel, you could end up overwriting a value set by something else. [...] But PECL Memcached come with a useful function : cas().

The "cas()" function uses a checksum pulled out when the data is uplled using "get()". This token along with the updated data is passed into the "cas()" method that does the additional checking for you. A code snippet is included to show you its use.

If you've ever come up against an error when trying to compile the pecl_oauth package (from the PECL repository), you might take a look at this new post from Lorna Mitchell on how she solved the issue and got the compile running smoothly again.

When I tried to install from PECL, it grabbed the files, ran the configure step but stopped with an error status during make. [...] Closer inspection showed this line around the point things started to go wrong: Error [...] pcre.h: No such file or directory. I didn't have the header files for pcre installed - in ubuntu the headers are in the -dev packages.

A quick call to "aptitude" to grab and install those development libraries and she was back up and running. She's running Ubuntu, but this tip is cross-distribution - you'll just have to use the package manager (and package name) of your distribution's choice.

On his OTN blog today Chris Jonesannounces the release of the latest Oracle database and Instant Client libraries (11.2.0.2) for the linux OS:

The Oracle 11.2.0.2 Instant Client libraries are now available on Linux x86 and x86_64 platforms from the Instant Client home page. And they'll soon be uploaded on ULN for customers with Oracle Linux support to install via the update server. If you are one of the (not so?) few users of command line PHP then you might want to grab the new client because it has Oracle bug 9891199 fixed. You'll also need OCI8 1.4.3 from PECL.

The bug this corrected caused a shutdown delay that caused issues with command-line users and their scripts. Unfortunately, the details of the bug are only available to those with an Oracle subscription. This update will not prevent you from connecting to older versions of the Oracle databases.

If you've been using (or will be using) the uuid and imagick extensions for PHP, you might be able to save yourself a lot of headache by reading this new post from Lars Strojny about his segfault woes.

After trying to trace it down with a backtrace and cachegrind results, he (and Mikko & Pierre) found that both extensions were built against the libuuid.so.1 file. While that wasn't the issue directly, they did find a work-around that helped the issue - renaming some ini files so uuid was loaded first.

Why the two releases so close in time? The OCI8 extension is one of the few extensions that has a dual identity, being in both the PHP bundle and in the PECL repository. OCI8 1.4.2 contains the same code as in the recent PHP 5.3.3 release. The PECL bundle was made for anyone who wants a PHP 5.5.3-identical version of OCI8 when installing via PECL.

He describes some of the bugfixes that comes with this release (and what specific circumstances if effects) as well as the requirements you'll need to be able to upgrade to this new version.

In a new post to his blog Brian Moon takes a look at two of the memcache PHP libraries (memcache/memcached) and looks at some of the issues that might trip you up in using them.

Memcached is the de facto standard for caching in dynamic web sites. PHP is the one of the most widely used languages on the web. So, naturally there is lots of interest in using the two together. There are two choices for using memcached with PHP: PECL/memcache and PECL/memcached. Great names huh? But as of this writing there are issues with the two most popular Memcached libraries for PHP.

On the "memcache" side of things, he talks about the age of the code (not much recent development), a timeout-related parameter to the delete method and the 3.0 beta release that, in his words, "just needs to die". For the "memcached" extension things look a little brighter but there still hasn't been a stable release in over a year, at least not on the PECL side. The github repo, however, has seen quite a bit of change. The most major bug he found with this extension has to do with persistent connection leakage.

So, what should you do as a PHP developer? If you are deploying memcached today, I would use the 2.2.x branch of PECL/memcache. It is the most stable. Just avoid the delete bug. It is not as fast and does not have the features. But, it is very reliable for set, get, add.... the basics of memcached.

Last year I showed how to use pecl/oauth to write a Twitter OAuth Consumer. But what about writing the other end of that? What if you need to provide OAuth access to an API for your site? How do you do it? Luckily John Jawed and Tjerk have put quite a bit of work into pecl/oauth lately and we now have full provider support in the extension. It's not documented yet at php.net/oauth, but there are some examples in svn.

He walks you through creating the consumer key registration page (so others can signup for access to your provider), making the OAuth endpoints, how to authorize the request token and send back out the access token. He also includes an actual API call to show it working.

Zend Server CE for Mac (as of this writing), comes compiled as an i386 executable only. This includes the PHP binary, php library, and apache binaries that come shipped with ZSCE. While ZSCE works great out the box with all the provided extensions, you might find that you want some additional 3rd party PHP extensions compiled/linked into this stack. That's where things get a little confusing, and in this post, we'll look at how to install the gearman extension.

Ralph gives you all of the commands and changes you'll need to make to get gearman compiled and ready for use on your Zend Server instance. The end result is a PECL extension that can be used as you might need.

Gennady Feldman recently spent some time doing some upgrades on his Oracle servers and, in doing so had a chance to work with the latest release of their Instant Client and how it interacts with the OCI8 extension's API.

I was recently involved in upgrading our Application servers to the latest Oracle Instant Client 11.g (11.2.0.1) including installing the latest PHP OCI8 module (1.4.1). Currently Oracle provides binaries for Linux in RPM and ZIP(?) format. (Side note: It still puzzles me as to why Oracle uses ZIP files for Linux binaries as ZIP is common to Windows and is not always available or generally used on Linux.)

He had everything prepared for the move and thought things would go smoothly during the upgrade but was surprised by a few things - the RPMs that Oracle gives are broken, an issue on the pecl update for the oci8 extension and a problem that came up with dependencies and packages for the Instant Client.

In a recent post to his site Alex Bilbie shows how to integrate CouchDB and CodeIgniter to make a simple NoSQL-based application. He helps you through each step of the way - from installation down to working code.

So I've decided that I want to properly document my MongoDB exploration and I may as well help others to learn with me. [...] What I'm going to do here in part 1 is install MongoDB, install the PECL PHP extension and just play around a bit.

He installs the latest version of MongoDB from packages and the latest version of the PECL extension to get PHP connected to it. He sets up a basic CodeIgniter install and creates the basic structure of the application. He creates the simple "blog" application (quickly becoming the "hello world" for framework examples) that can take in a title, content and author and add/view the information in the locally running database.

I explain how to manage Zip archive files in PHP using a number of demo PHP applications. You'll learn how to create Zip archives, add files and folders inside the archive from a string and from a given path, delete and rename files using their indexes and names and list the ZipArchive object details (number of files, filenames, comments, statusSys, etc.).

Complete code for the examples (along with a few screenshots) are included in the tutorial as well as a link to download the source to get you started even faster.

Hasin Hayder has posted a few simple files that you can use to make an oAuth connection from your application. In his cases it's been tested with Twitter and LinkedIn.

I've found that lots of people are posting in their forum for the code samples. And only very few obscure code examples are available. I've found phplinkedin script but that is just too bulky for a simple oAuth dance So here are two files to perform 3 step oAuth Dance for both twitter and linkedin.

The code (either cut-and-paste-able in the post or downloadable here) gives you three files - a configuration and one for the Twitter API and the other for the LinkedIn API. They both rely on the oAuth extension in the PECL library.

Derick Rethans, realizing that he wasn't ready to jump back into a full-time position just yet has decided to refocus his efforts on helping make PHP a better place with work on PECL extensions and on internals-related issues.

Instead I will be available to work on (custom) PHP extensions and internals related issues. Extensions are a great way around PHP's limitations and performance issues.

His first project is a QuickHash extension to interface with the popular StumbleUpon and works more efficiently by using more clearly defined data structures. There's no stable release yet, but keep an eye on the subversion repository for the latest enhancements.

Lorna Mitchell has a new post to her blog looking at three different ways you can make a POST request to a server - cURL, Pecl_Http non-OOP and Pecl_Http with the OOP interface.

I've been doing a lot of work with services and working with them in various ways from PHP. There are a few different ways to do this, PHP has a curl extension which is useful, and if you can add PECL extensions then pecl_http is a better bet but there are a couple of different ways of using it. This post shows all these side-by-side.

Code snippets are included for each showing a request to the Flickr API. Be sure to check out the post's comments for more great ideas (like streams, the PEAR HTTP_Client package, Zend_Http_Client and other request types without cURL).

Hasin Hayder has a new post talking about the new memcached extension for PHP (memcached from PECL) and how it can be used to store sessions data.

Many of you already know that managing session is a critical task for web applications, specially when you want to avoid I/O hop and also a significant load over your database by writing a custom session handler. [...] This is why a central session manager is very important for your application to scale.

He walks you through the whole process - installation, setting up memcached instances and getting the extension installed and working with your PHP installation. By adding two lines to your php.ini file, the sessions can quickly and easily be stored in memcache instead of on the local server.

In a new post to his blog Alexey Zakhlestin talks about the "rebirth" of the XSLCache extension for PHP, this time as a PECL module.

XSLCache extension for PHP, originally developed by NYTimes started its second life in PECL's repository and I am proud to announce first PECL-release. The XSL Cache extension is a modification of PHP's standard XSL extension that caches the parsed XSL stylesheet representation between sessions for 2.5x boost in performance for sites that repeatedly apply the same transform.

It works with the normal XSL extension with some small differences around which classname to use and a change to the importStylesheet function.

It's been stable for a while actually, but some people were hesitant to use it in production while it still had the beta designation. Well, no more, go forth and use it.

Future plans include the addition of memcached_dump and auto-ejection support. The memcached extension is a PHP library that allows your application to interface directly with a memcached server. Memcached is a high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load.

In this new post to his blog about the release of a new version of the OCI8 PECL extension - 1.3.5.

Last week Christopher Jones from Oracle pinged me about a patch I submitted a while back. The patch enables basic Oracle Instant Client detection during configure stage. The patch was meant to simplify install/upgrade of Pecl OCI8 module. After a number of revisions and improvements we have a working test version that will become OCI8 1.3.5.

Not too long ago, it seemed like there was a pretty clear distinction between client-side technologies and server-side technologies. [...] Things aren't that clear any longer. [...] And in this article, I'm going to show you how to add a JavaScript engine to your PHP build, with a little help from PECL's SpiderMonkey extension.

The PHP extension lets you use the libraries (with your PHP 5.3+ installation) to directly create new objects and work with the Javascript like it was PHP. The end result is then passed out to the browser via a "evaluateScript" call. He illustrates how you can use objects and generate XML quickly and easily.

So tonight I ran into an interesting issue this evening in configuring PECL memcache to run on my Macintosh. To give you a bit of background, I use the built-in copy of Apache, but with PHP (current 5.2.8) compiled from source since the version in Leopard is old and I needed some things that it didn't provide.

After finding out the problem (from a log file), he tracked down a similar issue and its solution. Trying it out, he found it worked - adding in an environment variable to tell the compiler with environment to use.

As a part of his work for the WinPHP Challenge Juozas Kaziukenas looks at some of the external library types that you can use with your (Windows) PHP applications.

External libraries are useful for performance demanding tasks where PHP is simply too slow. Also PHP can work as front-end system for various back-end systems (where server doesn't provide any PHP supported communication types). I have written some posts about using .Net libraries in PHP so far, but there are some other choices available too.

He looks at the three types of library choices - PHP extensions, exec call. For what he wants to do, though, the COM objects are the best fit for the job.

In a recent postHasin Hayder has taken a look at using the OAuth PECL extension (this one I assume) to connect your application's login system with Twitter's authentication backend.

if you are interested in developing twitter applications, you must have read about twitter API and it's authentication protocol. your application can fetch user's private data but it has to authenticate itself as the user for that. so there are two ways to do it: asking user to provide his twitter username and password [...] or let twitter handle the authentication on behalf of you.

This second option is where OAuth comes in. Once you've registered your application on Twitter, you can create a token and send it over to their site for validation. The idea is that, since the user has already authenticated on the Twitter site, they can allow an external application to "share" that login information/process and let the remote application fetch information about the user from he Twitter API.

The Zend Developer Zone has posted the latest podcast in their "ZendCon Sessions" series - a talk given by Elizabeth Smith at the Zend/PHP Conference & Expo 2008 called "PECL Picks - Extensions to make your life better".

The ZendCon Sessions are live recordings of sessions that have been given at previous Zend Conferences. Combined with the slides, they can be the next best thing to having attended the conference itself.

A Bloom filter is a probabilistic data structure that can be used to answer a simple question, is the given element a member of a set? Now, this question can be answered via other means, such as hash table or binary search trees. But the thing about Bloom filters is that they are incredibly space-efficient when the number of potential elements in the set is large.

The filters allow false positives with a defined error rate - it gives the "yes" or "no" answer based on the content and you, the developer, decide if that answer falls within a rate that's okay for you and your app. The filters also take the same amount of time to look up items no matter how many are in the set.

He includes an example of the extension in use - defining the number of elements, the false positive allowance and adding/searching data and how the responses would come back from the checks.

There's two versions - the short one that runs through a basic install, grabbing the package and change up your config and the other that talks about how to pull down and configure a certain version of the need comes up.

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!

After being tasked with some code that was filled with the suppression character (@) all over, Johannes Schluter decided to take matters into his own hands and write an extension to disable it.

That's annoying. So I wrote a simple extension disabling this operator. That helped. I then proposed that extension to pecl, while doing that I found out that Gopal has written a similar extension before. After short discussions we added that extension, using the name scream to pecl and released the extension there.

Documentation for the extension has already been added to the PHP manual for the "Break the Silence" operator. By enabling the setting (either in your php.ini or via an ini_set) turning on "scream_enabled", any use of the suppression operator (@) will be nulled out and all according error messages will be displayed.

Andrei Zmievski has posted about updates that have been made to the memcached extension for PHP:

The first project the I've been working on since joining Digg has seen the light of day. It's a new PHP extension for interfacing with memcache servers and it is based on the libmemcached library, which is becoming the standard client library for this task. [...] There is another memcache PECL extension, but this one offloads the intricacies of communicating with memcache onto libmemcached and instead concentrates on exposing a sensible API and some cool features like asynchronous requests and read-through caching callbacks.

Sometimes finding that one spot in your code that's geting bloated and consuming at majority of your memory can be a bit difficult. Antony Dovgal has proposed one solution in a new post to his blog - the memtrack extension for from PECL.

We needed to locate where most of the memory is allocated in our scripts (as some of them became too memory hungry), so I've created memtrack extension. This extension helps us to see unusually big memory allocations in production code.

The extension logs memory usage information out to the standard error log file (however that'd defined on your system) and comes with a few configuration options. These let you control things like a "soft limit" at which to report the usage problems, the ability to ignore certain functions that you might know will cause a high load and and "vm_limit" setting that can help if your script is leaking memory at the end of its run.

Ant Phillips has a brief comparison of PHP and the Project Zero methods for using PHP/PECL extensions (largely written in C) in each environment.

The Zend Engine provides an extension API. This allows anyone to write classes, functions, constants and much more that plug in to the php.net runtime. Taking a peek at the php.net source code in CVS reveals just how many extensions there are.

[...] Zero has a very similar architecture that separates engine and extension. The main difference is that the core PHP language engine is written in Java. Zero also has a comprehensive API called XAPI-J that allows Java extensions to be written for the Zero PHP runtime.

The main difference between the two is the obvious recompile that the Project Zero extensions will have to go through (via JNI) to work correctly with their version of the core. This allows it to be able to use just about any PHP extension out there and saves a lot of work on recoding the great functionality already there.

Christian Stocker has released the latest version of the uploadprogress extension to the PECL repository (0.9.2). The package allows the code to track the progress of an upload automatically.

The main new function since 0.9.1 is uploadprogress_get_contents($id), which allows you to analyse the content of an uploading file during the upload and do appropriate measure (for example warn the user, that he doesn't upload a supported video format). You have to enable this feature in php.ini to make it work. This feature was provided by Ben Ramsey, so you have to poke him, if something's wrong with it.

A simple example of it in action is also included (in the /examples subdirectory off of the PECL page) showing how to upload a file, get the progress and - most importantly - how to get useful error messages out of it.

Due to unfortunate circumstances Windows binaries for PECL extensions will no longer be available on http://pecl4win.php.net. Work is being done to incorporate Windows binaries for PECL extensions into pecl.php.net and will hopefully be ready early 2009.

The Zend Developer Zone has a new tutorial posted today from Vikram Vaswani about accessing a database with the help of the MDBTools PECL extension to read from a Microsoft Access datbase.

In this article, I'll introduce you to PHP's MDBTools extension, which provides an API to programmatically read data from Microsoft Access database files. If your project involves working with such files, extracting database records either for calculations or for conversion to other formats, you'll find this extension invaluable.

He steps through the installation of the extension (via the pecl command line tool) and some sample code that grabs the tables, all of their attributes and how to select the data out from them.

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.

New on the Zend Developer Zone there's a tutorial written up by Wil Sinclair looking at building dynamic PDF files in PHP with help from Haru.

This incredible versatility also applies to the topic of today's article: the PDF, or Portable Document Format. Not content with just one, PHP actually comes with two different extensions that allow developers to dynamically generate PDF documents: the PDFlib extension, and the libHaru extension. Over the next few pages, I'm going to take a quick look at the Haru extension, providing you with a brief overview of its functions and demonstrating how you can use it in your PHP development.

The tutorial walks you through the installation of the extension and several examples of it in use - everything from simple text input out to text transformations, drawing shapes and adding annotations.

The Zend Developer Zone has a new tutorial from Vikram Vaswani looking at the reading and writing of metadata for mp3s and images with two handy PECL extensions.

It's just that every time I sit down to have a go at [finding something in my photo or mp3 library], the sheer volume of data overwhelms me and I take the command decision to deal with something easier instead. Sounds familiar? If it does, help is at hand, in the form of PHP's ID3 and EXIF extensions. These extensions can help you organize and catalog your digital media collection so that it's easier to navigate and search. Keep reading, and I'll show you how.

He installs the ID3 package first (via the pecl command line tool) and gives a few sample scripts to pull the metadata information out of a mp3 file as well as update/remove the information that's already there. He even sets up a simple SQLite database to store the information he's retrieved.

The second part of the tutorial looks at grabbing the image metadata via the EXIF extension. This can yield all sorts of information including date/time the photo was taken, the resolution, the model of the camera and various camera settings at the time. He includes a sample script that automatically makes thumbnails for the images via the exif_thumbnail function.

The Zend Developer Zone has posted this new tutorial from Vikram Vaswani covering the use of different archive formats (like RAR, LZF and BZ2 compression methods) from inside PHP.

When it comes to dealing with different file formats, it's hard to faze PHP. XML documents, PDF files, JPEG images, MP3 media...you name it and, chances are, there's a PHP extension to handle it. And so it is with compression formats like RAR, LZF and Bzip2 - although these archive formats are far less common today than the ubiquitous TAR and ZIP formats, they are still actively used by many applications and projects, and continue to be supported in PHP via PECL extensions.

He pulls in a few PECL extensions to give PHP the power it needs, both for unix-based systems and Windows DLL files. He includes some sample code showing how to open up a rar file and list the contents inside as well as extract the files themselves. And, of course, code examples for compressing files into a new archive is included too.

Originally we were only going to support the latest (1.6), but then the new 1.8 version was released and I started adding support to that as well. Then we noticed that dreadfully slow/out of date RHEL and derivatives still have 1.4 versions of Cairo floating around (yuck). So the extension will support 1.4+ However the cairo docs are incorrect in a couple of places regarding new symbols. After some header diffing here is a complete list for 1.8 and 1.6 (to make life easier for anyone else writing language wrappers).

Her list includes forty new symbols for the 1.8 release of the extension and twenty-two for version 1.6.

The Zend Developer Zone has a new tutorial posted today (from Vikram Vaswani) that focuses on making charts and graphs with the help of the GDChart extension for PHP.

This extension, which is freely available from PECL, can significantly reduce the amount of work involved in dynamically generating graphical representations of numerical data at run-time. Over the next few pages, I'll introduce you to this extension, illustrating its important features and showing you just how easy it is to get your Friday evening back.

The tutorial shows how to get and install the extension as well as including a few usage examples - a simple charting of values (with the different chart types defined), comparing more than one set of data, changing the aesthetics of the output and a detailed look at a few of the chart types' output.

William Candillon passed along a note about a new PECL extension that's been released that adds the power of XQuery to the PHP world.

PHP developers beware: Zorba now has a language binding for PHP 5!
Most PHP developments have to deal with XML and since PHP version 5, the support for XML has been greatly improved and developers can use various extensions that speak XML. We strongly believe that XQuery was the missing piece in this set of tools and therefore we are very excited by this release.

You can get the full details from this post to his blog including installation instructions and usage examples for everything from a simple query to a more complex XML insertion.

Antony Dovgal has a quick post today about a PECL extension that makes for quick and easy full-text searching on standard SQL databases.

As some of you might have noticed, I've been a bit busy lately creating new PECL extension - sphinx. The extension provides an interface to a feature-rich fulltext search engine Sphinx written by Andrew Aksyonoff. We (Andrew and me) made our best to keep the extension as compatible to the pure-PHP API (shipped with Sphinx) as possible in order to make the transition easier.

The PECL page has already been created as well as a page in the manual for how it works. He also briefly mentions the installation (including teh required libraries).

In a new blog postChristopher Jones mentions the feature freeze that's happened for the PHP 5.3 series including the Oracle support through the OCI8 extension.

The volume of commits has recently increased in anticipation of today's feature freeze deadline. I expect the Alpha release time frame will also see high activity. Eventually, increased tightening of criteria for patch acceptance will bring us to Beta and then Production releases.

Features included in this most recent extension version include an allowance for external authentication, a change to let Reflection correctly show function/method arguments, an increase on the oci8.default_prefetch setting and correctly defining the SQLT_BDOUBLE and SQLT_BFLOAT constants.

On his blog todayMichael Kimsal asks a question that hasn't come up much in recent months - with all of the advancements browsers are adding in, why aren't there better hooks for measuring file downloads?

This current tirade stems from implementing a file upload progress meter in PHP5. Yes, PHP5.2 has some hook, and there's a PECL extension. [...] I realize this is partially a PHP issue I'm ranting about, but it's ultimately a hacky workaround to a basic piece of functionality that browsers should support.

He mentions an example where he basically directly asked a member of the IE team about it. It wasn't greeted seriously and still hasn't managed to be included in most of the popular browsers of today.

Christopher Jones has noted that the latest version of the OCI8 drivers for PHP (in the PECL extension) have been pushed to the current stable package.

HP's OCI8 1.3.3 has support for Oracle's DRCP connection pooling and Fast Application Notification technologies giving it improved scalability and high availability. Overall, the re-architecture of the connection code is more stable. It fixes some obscure edge case issues and lets it handle re-started DB's better. Basic functionality is unchanged.

You can find out more about the package and download this latest edition from its PECL page or check out the whitepaper they recent;y wrote up about PHP and Oracle scalability.

Brian Shire has posted a new tutorial talking about some of the benefits of caching the functionality of your website (with things like APC, not file or database caching):

Opcode caches save energy, expenses, improve overall user experience on web sites, and it's often one of the simplest optimizations to implement. This article will explain the basics of installing, configuring, and tuning an opcode cache for PHP, the Alternative PHP Cache (APC).

The article focuses on how the APC works and how to get it up and working on your installation (as pulled from the pecl repositories). They look at some of the functions the extension's API includes (like ap_cache_info or ap_store for manual caching) as well as some more advanced topics like locking performance, working with TTL, cache priming and filtering.

Christopher Jones has a (very) quick post today about the release of the latest version of the PECL OCI drivers - 1.2.5.

Hang on, weren't we up to OCI8 version 1.3? Well, yes, but that's Beta bordering on Production. In the meantime, I wanted to make the OCI8 bug fixes from PHP 5.2.6 available in a "Production" release and keep PECL OCI8 1.2 in sync with PHP 5.2. The changelog is here.

Updates include bug fixes for cursor leaking, a LOB leak, a problem with collection creation and an update to the compile option for the Instant Client to look for RPMs.

Hasin Hayder has a new post to his blog today about trying to set up the PHP extension for interaction between his scripts and the subversion version control libraries on his Ubuntu linux system.

I was trying to interact with my subversion repositories using PHP yesterday and I knew that PECL has a extension named "SVN" for PHP users. So I tried to install in in my machine by when I tried to install it with the [following] command it always failed.

The trick to his hint is to install the libsvn-dev package (found via a search with apt-get) and installed and compiled in to the PHP installation with the extension. Sample code is included.

I've released PECL OCI8 1.3.2 Beta - the latest release of PHP's OCI8 extension with support for Connection Pooling and Fast Application Notification. The release is based on the current PHP 5.3 development branch.

He notes another change in this release - a "session release" bit of functionality persistent connections will do when nothing is referencing them anymore, mking them work a bit more like normal connections. Issues that could be caused by this can be corrected with a new setting (oci8.old_oci_close_semantics) in your php.ini.

Matthew Turland set out a while back to develop a bot in PHP. The result of it is Phergie an "an IRC bot written in PHP 5 with an OO API" that can be extended with components for a wide variety of features. Another pleasant offshoot from his project is this first part of two articles on the C7Y community site detailing its creation.

The PHP Community channel on the Freenode IRC network, #phpc, had a longstanding bot called "Ai". Like many bots at the time of her creation, she was based on PHP 4. [...] With the coming end-of-life of PHP 4 and at the encouragement of channel users, I decided to start a project to develop a new bot based on PHP 5 that would fully utilize its new object model and offer users a chance to contribute to the bot they used in their channel.

Matthewtalks about the initial stages of development (planning, research) and some of the development process of the bootstrap file, configuration file, and driver as well as the event handling.

Derick Rethans has posted about new versions of two PHP extensions with "very distinctive purposes" - VLD and translit.

VLD is for the "hardcore hackers" out there to see what's happening behind the scenes for each request made to PHP and the translit extension makes it easier to "transliterate" information into other formats (with filters like "normalize_numbers" and converting text to Chinese).

You can grab the updated version through the standard pecl interface or from theirpages on the PECL site.

In a new post, Greg Beaver talks about a few things, the main one being a new release of the phar extension he's made - phar version 2.0.0a1 - a reworking of the previous functionality with loads of new features including:

Phar now supports tar and zip archives with the same API that is supports phar archives.

Phar has a front controller for web applications that fully handles MIME types, supports mod_rewrite-like functionality with far more flexibility

Elizabeth Smith has set out on something she calls the Great Compile Project - her effort to get all dependencies for PHP and PECL compiled on (at the least) Visual Studio 2005 transparently and provided openly.

Anyone crazy enough to help out is more than welcome. I'm currently working on the GTK dependency stack, which will hit quite a few PHP dependencies and PECL extension dependencies in the process. And yes I'd love to submit my hacks/fixes upstream, if someone could find me some information (where do you send libiconv patches?)

Her post mentions some of the things she's already been working on to help further the cause - compiling various Open Source libraries, figuring out issues surrounding MiniGW and some examples of more complex dependency issues she's come across.

Matthew Turland has been working on a project based on an idea he and Ben Ramsey thought up - a wrapper around the libircclient libraries to make IRC interface simple. As a result, Matthew turned it into a more practical application - you can call her Phergie.

I had toyed with some previous iterations of Phergie, some Python-based and later some PHP-based, before I finally got an API design I was happy with.

Of course, it's still in beta, so any testing and feedback is more than welcome. This bundle also includes several other "non-DRCP related bug fixes" including an issue that caused constant pinging for persistent connections.

Hasin Hayder has provided some instructions he's created to install the Imagick extension for PHP on a Ubuntu linux system (7.10) in a new blog entry.

I already have ImageMagick installed in my machine and I tried to install the Imagick extension for PHP but I was stuck with strange errors. I have spent couple of hours today to figure out what I did wrong and Why I cant build that extension. Finally I've figured out that I must install ImageMagick from source first to build that extension. Heres how to.

He walks through the install, talking about where to get the package from, where to get the PECL extension for PHP and the compile process (with the result of a .so file PHP's extension can use).

In filtering through the mass of projects that he's collected around him, Padraic Brady has decided to cut one loose - the Zend Framework package he'd been developing to introduce YAML parsing and functionality to the framework.

I've been going through all those open source projects and cutting the dead weight. [...] One of the victims of this review has been Zend_Yaml. Earlier this morning I found an odd comment on the Zend_Translate_Yaml proposal by Thomas Weidner that he was erasing his proposal on the basis that there had been no progress on Zend_Yaml.

He's removed the proposal from the Zend Framework proposal pages after receiving an email noting that the package would not comply fully to the YAML 1.1 specification and couldn't be included. With the introduction of the Syck extension into PECL, it could support it but Padraic opted to just tell the ZF group about this functionality rather than working on the build himself.

In a post a little while back, Padraic Brady wrote about an extension he whipped up to act as an interface between PHP and the Snarl notification tool (inspired by Growl from OS X).

My intention for the API is to facilitate Window's use of a soon to be announced tool for autotesting in PHP using PHPSpec.

He wants to use it in an automated testing environment that, when tests are detected in the current tests, runs the changed items and reports back the results via the Windows notification service. You can grab the code from the Google Code repository for it and test it our for yourself.

Mike Naberezny has posted about the latest release he's made - a 1.0 released too - of the Horde/Yaml library for working with YAML files/information inside of PHP.

This is the package's first stable release. Chuck Hagenbuch started the library as an adaptation of Spyc around six months ago. Since then, he and I have been quietly using and improving it. Along the way, we fixed many issues, added support for pecl/syck, and wrote a test suite with PHPUnit.

You can find the latest download of the package over on the Horde PEAR channel and you can find out more about the YAML (YAML Ain't Markup Language) spec over on the Yaml.org website.

Gennady Feldman has posted the second part of his install instructions for setting up the Oracle Instant Client (11g) and the Oracle OCI8 drivers in PHP.

This is part 2 of my installation instructions. This is my attempt to provide an updated and simplified reference. I am leaving Part 1 as is, because that part can also be useful.

This updated tutorial shows the steps to installing 11g (versus 10g in the previous example) including the packages you'll need, the commands to make it work and a PEAR version of the install if you choose to go that route.

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.

His goal is to have it all ready and waiting (and included) for when PHP 5.3 is set to roll off the line. The extensions consists of four major parts that do the work for you - the collator, number formatter, normalizer and a locale component.

The Zend Developer Zone has posted the latest episode of their PHP Abstract podcast series. This time they have Elizabeth Smith talking some about PECL.

Todays special guest is Elizabeth Marie Smith. I quote now from her "About Me" page of her blog, a link to which can be found in the show notes. Elizabeth has been using PHP since time immemorial but has used PHP 5 for so long now she's forgotten how she ever got by without SPL and a real object model. [...] Today Elizabeth is going to share with us about PECL, the PHP Extension Community Library.

On the PHP Addiction blog today, there's a new post where Doug Hill asks a question of his fellow developers - are there advantages to having a standard container library for PHP?

Most compiled languages that I have used have some kind of container implementation, Lists, Maps, Trees, Stacks and all their many variations. PHP has arrays and the SPL.

The only problem he's noted so far is that containers made in userland would be slower than ones created natively. A comment from Antony Dovgal points out a project similar to what he's looking for that's already in the works.

The Zend Developer Zone has posted their latest podcast episode in their PHP Abstract series - this time it's an interview with Sara Golemon (the "PECL princess" herself).

Sara is one of the core contributors to PHP and when she's not coding for PHP, speaking at conferences or writing books she fills her time working at Yahoo. I had the privledge of sitting down with Sara at php|works earlier this year in Atlanta GA and talk with her about her background, why she likes PHP and anything else that came to mind.

You can just grab the mp3 if you want to or you can get in on all of the fun and subscribe to the podcast feed and get this and lots of other great episodes, both PHP related and not.

Sebastian Bergmannpoints out that he will be speaking at the upcoming PHP Conference in Quebec (2008). He will be presenting three talks/tutorials:

Test-Driven Object-Oriented Programming - Learning and Understanding (with Marcus Borger): This PHPLab is an in-depth introduction to object-oriented and pattern-based programming using PHP 5. You will learn everything necessary to write your own cutting-edge components and applications - and of course how to use and extend components from other people or companies.

PECL: The PHP Language Workbench: A look into PECL shows how flexible the language core of PHP, the Zend Engine, is.

Graph-Oriented Programming with PHP: This session presents the eZ Components' workflow engine, its possible applications and the underlying principles and techniques.

You can find out more about the conference from their main website (including other speakers that will be presenting) as well as registering to reserve your space for the March 12th-14th conference.

In a new postGennady Feldman has listed out some beginner resources to help those just getting into PHP:

I know that some of my last blog entries were a bit too technical for the web designers who are just starting out and curious about using PHP for their website. I thought I'd do a blog post with links for the newbies who are just starting out and making their first steps in PHP.

The Zend Developer Zone has a new article today by Vikrim Vaswani covering the use of YAML (Yet Another Markup Language) with PHP via the PECL packages that support it.

If you've ever encountered the same need, or if you're just curious about the YAML format and how it can be used with PHP, then today is your lucky day. Over the next few pages, I'm going to give you a crash course in YAML and in PHP's ext/syck extension, showing you how it can be used to efficiently translate data structures from PHP to YAML, and vice-versa. Come on in, and let's get started!

The tutorial starts with an example of a YAML file before getting into the application portion. He shows how to grab the Syck extension, install it, create a simple YAML file and create a configuration file (and parser) for a simple form application.

Mike Wallner has announced the release of the first beta of the pecl_http PECL package, an extension that "aims to provide a convenient and powerful
set of functionality for one of PHPs major applications."

In a new post, Matthew Turland looks at one thing that he feels is missing from a lot of the PHP functionality currently available in the community today - log analysis features.

Log analysis is a fairly common task in the field of web development, most often analysis of web server traffic logs or what Wikipedia refers to as web analytics. PHP has no officially supported extensions designed specifically for log analysis. There are no related extensions in PECL. The only remotely related extension in PEAR is PEAR_Log, which for generating logs rather than parsing or analyzing them. In short, there is no common solution here.

He looks at the options that developers do have - make their own solution or go with a third party option. He believes, though, that a PECL extension would be more the way to go, integrating with PHP more closely and allow for easier parsing and manipulating of the data in their own log files.

Greg Beaver has blogged about an enhancement in the latest release of phar (1.2.1) - a major speed boost:

A few minutes ago, I released phar version 1.2.1. phar is a PHP extension that allows the creation of complete filesystems within a single physical file. In addition, a bootstrap stub written in PHP can be used to run a phar archive as if it were an executable file or shell script. Documentation on its usage and how to create phars is at http://php.net/phar in the PHP manual.

Greg mentions some other issues that were fixed and a refactoring of some of the stream operations to cut the speed in half.

On his blog today, Christopher Jonesmentions some updates that are going to be included in upcoming PHP versions as pertains to the Oracle functionality that comes bundled in.

What is happening with PHP 5 is that some bigger enhancements will be merged into a planned PHP 5.3 release. [...] Even if you are still using PHP 4, or PHP 5.1, any testing you do on 5.2.4 right now will benefit you when you get around to upgrading. PHP 5.2.4 includes OCI8 (and PDO_OCI) of course, as the code base is picked up from PHP's CVS system.

There's also a list included of bugs that have been fixed in this latest version of the PECL OCI8 connectivity including a problem with a memory limit, a segfault issue when rebinding a re-executing a statement with LOB and an allowance for the statement cache size for non-persistent connections.

The Zend Developer Zone has posted the latest episode of their PHP Abstract podcast series - an introduction to Service Component Architecture.

Today's special guest is Graham Charters. Graham works at IBM's development lab in Hursley, England. His past roles have included WebSphere Application Server development, and architecture responsibilities in WebSphere Business Integration, and Adapters. [...] Today Graham is going to talk to us today about the Service Component Architecture, or SCA.

Graham talks about what SCA is and includes a mention of the PECL package that enables PHP applications to work with multiple data sources seamlessly.

Alexey Zakhlestinhas announced on his blog today the fact that his PECL package - Syck - has officially gone beta.

This is an extension for reading and writing YAML-files. YAML (rhymes with "camel") is a straightforward machine parsable data serialization format designed for human readability and interaction with scripting languages. YAML is optimized for data serialization, configuration settings, log files, Internet messaging and filtering.

WebReference.com has posted part two in their series looking at security techniques in PHP. This time they focus on the use of a few things - the PECL filter, the PEAR Auth module and mcrypt.

For each of the three topics covered, they include a few code examples on their use - an HTML form with the filter extension, user authentication with the PEAR Auth, and encrypting data to be used in a more secure cookie.

In a new post on her blog today, Elizabeth Smith talks about her "PECL Windows nut project" of wanting to get every single PECL extension she can get her hands on to compile under Windows.

Now there will be some that are just frankly impossible (but there are some extensions that are impossible on *nix as well - you're not going to see me messing with xmms) What does this mean? Playing with lots of open source libraries, fixing simple errors, creating config.w32 files for extensions. Basically just looking at what is broken and fixing it.

She's already started on the project, fixing several of the base extensions and moving on to try to correct one to five extensions a day. These changes are getting committed into CVS so anyone can get at them and try them out for themselves. She's also trying to get them over into the PECL4WIN packages to make things more "official".

Mike Wallnertalks today about a much deliberated topic in the community currently - the inclusion of the phar extension into the core distribution of PHP and how, because of not having a good addition process, things will get a little nuts:

How many people are really reading through all mails of 100+ message threads? It's going to be a chaos. Always. Once a developer has got his new, shiny and soon-to-be-world-dominating extension into the core, he'll be a even stronger advocate of the "no-new-extensions" camp. Not to disrespect any work, but this is pure rivalism, masculine - really!

When asked it the phar extension will make it into the core, Mike usually responds with "Never" simply because of the issues surrounding the personal feelings of those that would be involved with the merge.

In an effort to provide as much information and code about the PHP builds as possible, Edin Kadribasic (with some help from John Mertic) has created some new abilities for the snapshot build process:

Up till now we provided only the debug pack for the latest snap but several people have asked if it was possible to make one available for each snap that was provided on the site. The PECL bundle and the installer were not provided at all (although pecl4win site provides a build of PECL extensions).

As a result, he's generated and posted these packages for the latest PHP releases:

From Irakli Nadareishvili's blog today, there's a new post that shows exactly how to get the PECL memcache client up and working with a default XAMPP installation in PHP4.

XAMPP is an absolutely wonderful, packaged, self-contained distribution of apache, mysql, php and tons of hard-to-install php extensions. [...] However, even with a long list of packaged extensions, obviously there may be a need to install an additional one. PECL Memcache client of memcached distributed cache server, is a very probable candidate for high-load systems.

Unfortunately, he notes, the default installation of XAMPP has a broken version of PECL installed and doesn't quite work like it should when new packages are installed. Thankfully, though, he found a workaround for the problem in the form of fourteen (well, really thirteen) easy steps involving things as simple as copying files, running a "make", and changing configuration settings to get things up and working.

He also includes a common error he had to figure out when making his install too - an issue where the installation might not be able to find the right libraries.

The first releases of the new 0.8.x have published earlier this week (0.8.1 is the latest). The main change is the full support of PHP4. I will support it as long as PHP.net maintains it. The ability to keep htscanner loaded while using PHP CLI is now possible without having to tweak the configuration (useful if you use a single php.ini for both cli and cgi).

You can find out more about the htscanner extension on its PECL homepage and more about the sponsor helping Pierre make this support possible - widexs.nl

Pierre-Alain Joye has posted about the release of the latest version of his Zip PECL extension - version 1.8.7 - including what it fixes.

Zip-1.8.7 fixes two problems related to open_basedir and safe mode. One was discovered by Stefan Esser (#20 in his mopb) and affects the zip:// stream wrapper. The other is in the open method of the ZipArchive class. I I forgot these two places while applying the php6+ changes and cleaning the code base. I recommend to upgrade as soon as possible.

He notes that, thanks to information from Stefan Esser, this issue was fixed the same day it was posted (the zip:// flaw he mentioned). You can get more information on this package from its PECL homepage or just grab the latest update here.

Pierre-Alain Joye has three different posts to his blog about the releases of new versions (or new software) he (and others) have posted recently - a new release candidate for GD, the new Hidef extension in PECL, and a bug release for the zip extension.

The first post concerns the Zip extension release and which of the provided libraries you should use with your PHP installation (he recommends the latest PECL version over the included version). There's also a link to the new release - 1.8.6

The second post is an announcement about the publishing of the Hidef extension into the PECL library (by Gopal Vijayaraghavan). It can be used to do a "one time declare" of constants in your application, working with a configuration file to only load them the first time the browser hits the site/application.

On his blog today, Greg Beaver has introduced a new pecl extension to add the phar functionality into any PHP installation as easily as adding any other pecl functionality.

After 14 months and nearly 200 commits, Marcus Borger and I have finished the first release of the phar extension in PECL. Phar provides both a stream wrapper (phar://) and a Phar class which can be used to access the contents of a phar archive. What is a phar archive? Think of it as a virtual filesystem that is customized for use with PHP, sort of like a Java .jar archive. Incidentally, the phar extension is a C implementation of the principles behind the PHP_Archive PEAR package.

A beginners guide to installation and usage is included, showing how to configure your installation and create two simple packages - one with a simple "Hello world" PHP script inside and the other grabbing the entire contents of a directory (and subdirectories) and pushing them in.

I just released Xdebug 2.0.0RC3 through the web site and also through PECL. This hopefully last release candidate of Xdebug 2.0.0 addresses a number of segfaults and other small bugs that crept in in Xdebug 2.0.0RC2.

The Xdebug extension helps you debugging your script by providing a lot of valuable debug information. The debug information that Xdebug can provide includes the following: stack and function traces in error messages, memory allocation, protection for infinite recursions.

Pierre-Alain Joye has posted about the latest update to his Zip PECL package today:

This release fixes two small issues, a leak happening on error and a bug in extractTo. Empty directories were not created recursively, for example an entry like "test/emptydir", only the "test" directory was created.

This latest download is here and the homepage for the project is over on this PECL page (as well as details on what the package can do and documentation of all of its features).

On his blog, Pierre-Alain Joyetalks about the ext/filter extension and how several developers just choose to "work around" it instead of using its features right out.

On the other hand, the same persons worked around ext/filter with ugly hacks. Edin pointed me to one of these horrible codes in Serendipity, as I saw this code in other applications like flyspray, I think it is time to raise your attention about what to do not do.

The code he's referencing is a snippet that manually filters each of the superglobals to get rid of any problems that might have been put in. He points out two security problems with the code too: only use PHP functions as a fallback when filter isn't available and never use the superglobals directly outside of the filtering.

Stefan Esser has his own comments on the topic too. He votes for the other way around (own functions over filter's methods) and expresses the opinion that the ext/filter extension is a bad idea similar to the impropper use of magic_quotes_gpc.

Giving it a second shot, Edin Kadribasic has posted another build using the new compiler from Microsoft because of some issues with the first one.

Well the first build proved to be somewhat less that a full success. It worked only on one computer: the one that was build on. Since this limits PHP use on the Windows platform I went ahead and read about Microsoft manifest files, SxS (side by side) assemblies and other wonderful stuff that Microsoft has provided for us in version 2005 of their development package.

The new build should be installable without any libraries from Microsoft and you can grab both of them directly from his site:

On the PHP Security Blog, there's two new posts concerning their Suhosin patch for PHP - one talking about a remote code execution vulnerability found in the uploadprogressmeter extension (which as already been corrected) and the other dealing with the "stealth mode" of the patch to find compatibility problems.

As mentioned, the issue with the uploadprogress extension has been fixed and as been introduced into the PECL repository. The other post just mentions what the patch is doing to try to keep compatibility problems from happening due to back extensions and/or modules being loaded in an application.

According to this note from Christian Stocker on the BitFlux blog, the upload progress meter (using the new file upload hooks introduced in recent PHP versions) has finally been included, officially, into PECL.

Pierre-Alain Joye has posted several new updates concerning the packages he works on - Zip and a new offering, htscanner.

The first two concern the htscanner package - first, the initial release of the extension that works to emulate htaccess support for non-Apache web servers (like FastCGI or lighttpd). The second related post notes that that Windows binaries for the functionality are also posted on the pecl4win website.

Next on his list were some update to the Zip PECL package, a fix to correct issues found when using PHP versions 5.1.0, 5.1.1, and 5.1.2 (due to an internal function name issue).

On the IBM developerWorks site, there's a new post talking about a new Service Component Architecture module that's been released over on the PECL site - SCA_SDO.

We've just made our first release of SCA on the PECL repository. The code has been added into what was the SDO project and which has now been imaginatively renamed to SCA_SDO (you won't believe how much thought went into that...).

Main features include:

inclusion of the Service Component Architecture (SCA) component

new PEAR packaging to install SCA and SDO as peer directories (PEAR/SCA and PEAR/SDO)

new function in SDO_DAS_Relational to support multiple root data objects

new function in SDO_DAS_XML to support CDATA sections (not yet complete)

Damien Seguy has continued his series looking at PHP configurations around the web and is sharing the results in the form of two newreports over on Nexen.net.

I just published the second part of the serie about PHP configurations.
This part focuses on three aspects of PHP: PHP extensions, PHP streams, and disabled functions.

You can find the statistics themselves here and the latest configuration statistics here. It's interesting to see the drop-off when it comes to the various modules that are installed ("php, ftp and http are the most common. Besides them, tough luck.") and to see the somewhat more gradual curve of which functions are disabled - with system() topping out the list (with good reason).

Pierre-Alain Joye talks in his latest blog post about the latest incarnation of his Zip PECL extension (version 1.8.0) and some of it's newest features.

Zip 1.8.0 has just been released. It is now possible to create empty directory in an archive using the addEmptyDIr method.

He talks about some of the bug fixes he made to the latest distribution including an update to setComment, statName, included unicode support, and sme work being down with Zip archives with non-ascii filenames.

For those using the Zip pecl pakcage, Pierre has a quick update you'll need to download to resolve some pathing issues that were found.

A little release to help windows users to work with broken zip entries named like "a/b//c.txt". PHP 5.1+ mkdir does not support such path on windows and simply refuses to create the base dir. The """bug""" has been fixed in php 5.2 or earlier and a work around exists in zip itself for earlier versions.

Today, Pierre-Alain Joye has fomally announced his "retirement" from working with the PEAR project as a lead developer. He's making a shift to work mainly towards other graphics/imaging work he's been developing and to continue work with his current extensions (and a few new ones on the way).

I spoke with him on some of the things that had lead up to making this decision and he mentioned it as a two-fold reason: one was some personal conflict between other PEAR developers and himself and the other an issue of time and interest in the project. He still wants to see it succeed, but just doesn't see the time in his life right now to do his part. Pierre will continue to work with the PECL extensions and on the PHP internals groups to help improve and develope them towards future versions. Some of the extensions he lists as the ones currently in his development are things like GD, xmlwriter, Zip (of course), and filter.

It is just a normal process, things and people change. I would have preferred a slower switch, as I was working on my leave (giving lead for many of my packages to other friends).

Pierre's PEAR work can be seen on this page of his blog and includes all of his PEAR and PECL work as well as PHP internals and Pimp/Cairo/GD development work.

You can also check out the decision in his own words over on his blog.

Zip is stable since two releases. I lacked the time to report it :) Three bugs were important. Once PHP 5.2.0 is out, I will focus on the new features. Write stream support, unicode (php6+ support), pattern based addition/extraction and crypting functions.

The three bugs he mentions were a problem with zipArchive::addFile, comment/cdir problems with new archives, and setting properties in extended classes.

Looking to get every ounce of performance from your Web server? If you're using PHP scripts, you can easily accomplish this using PHP's APC module, which caches php opcode instead of forcing php to reinterpret every script every time it is executed.

The install is simple (on PHP5) and they show some configuration options you can use to fine-tune the performance of the module to fit your needs. There's also a brief look at what the module actually does to the scripts as they get interpreted and passed out of PHP and into the web server.

On Pierre's blog today, there's a release announcement about the "long awaited for" version of his Filter extension - version 0.1.0.0.

This release will be included in the upcoming PHP 5.2.0RC3, which is likely to be the last RC. Please report any trouble you find, and post your feedback (here, on the pecl-dev mailing list or in the issue tracker), it will help provide the best possible extension in the 5.2.0 release. A stable filter release should still hit the road this year.

Feature additons for this release include an input_get_args method, support for PHP's pcre expressions, JIT support, and support for custom decimal spacers. Several behaviors were changed as well, including when a value is FALSE or NULL, updates to the integer/float parser, and the default filter now being set to "raw".

You can get the complete listing of updates on the project from the Changelog and check out the project and all of its documentation on it's PECL homepage.

Mike Wallner has posted his own roundup of some of the happenings going on in his PHP world behind the scenes.

He talks about the work he's been doing with PHP6 (rewriting an output control layer), with PHP 5.2 (fixes for an Apache issue and the error_get_last function), as well as with pecl/http (new documentation and new updates).

He lists out some of these updates, including improved response preformance, the addition of ArrayAccess to interfaces, and bug fixes on http_parse_cookie, http_build_url, and HttpQueryString failures.

Pierre-Alain Joye updates us on the new release of his MnoGoSearch package, reborn into the life of a PECL package:

This release is only a maintenance release. It brings the MnoGoSearch PHP binding back to life. This package is still present in our php 4.4 branche but has not been really tested with any other PHP versions. That's why I choosed to release it as 1.0.0-alpha (development release).

On Pierre-Alain Joye's blog today, there's a quick release note about the latest version of his PECL package, Zip, being released - 1.4.0.

I just release Zip-1.4.0. This release adds support for all kind of comments, read or write. One bug has been fixed, Windows users may had problems to add files to an existing archives. Thanks to Irokez (pear's OpenDocument project for SoC) to have catched it.

He also includes a brief code example of the commenting functionality.

On his blog today, Greg Beaver has a release note about the latest version of the PECL extension for working with docblock - version 0.2.0 has been posted.

Just a few moments ago, I uploaded a new release of the docblock lexer extension for PECL at http://pecl.php.net/docblock. This release fixes two edge case bugs that I discovered while writing a docblock parser using the docblock extension. Otherwise, it's the same as the initial release.

He demonstrates how the extension works through two different examples - one with a simplely formatted comment block, and the other with something a bit more complex (an include).

Mike Wallner shares with us today a method for getting pecl_http installed and correctly configured for your system.

As pecl/http 1.0 has finally been released and I had noticed that it's been packaged already by several projects like PLD, Gentoo and FreeBSD, I wanted to explain what one is going to gain respectively lose by using the different build/configure options for the extension.

He goes through and explains each of the conifgure options - enable-http, with-http-curl-requests, with-http-zlib-compression, with-http-magic-mime, and with-htt-shared-deps - giving about a paragraph worth of information of what it is and what it does for the package.

One struggle seems to come up over and over again for several PHP developers out there - Oracle issues. Newsgroups and message boards are filled with questions and, sometimes, a few answers. bshensky is one such user - but one that found a way to get the PEAR DB package to connect to Oracle simply and without the usual recompile it would take to get the Oracle drivers successfully installed.

I have spent a dog's age researching how to get my local PHP install to talk to Oracle using PEAR and the OCI8 client stack on my Fedora Core 4 server. I eventually came to the conclusion that it was just not possible to get OCI8 to work with a RPM(binary)-install of PHP, and I looked toward other means of getting "Web access" to Oracle using different means.

Today, I found an interesting document on the Oracle Web site that allegedly details how to get the new PECL PDO database drivers for Oracle running on PHP 5 (luckily, I run PHP 5 on my FC4 box).

The document claimed that you could use PDO to load a database driver on the fly without the need for a recompile. All bshensky saw left to do was getting PDO installed (via PEAR) and getting it to pick up on the Oracle libraryes to help make the connection. A few quick commands and environment variables later, he had a complete and working PHP install with Oracle functionality called on the fly.

Mike Wallner is sharing a quick note in this new blog post about some "weirdance" he noticed while working with libcurl and cookies.

I had to implement some changes which are only in CVS for now. Beware that all this does not affect custom cookies set with HttpRequest::setCookies() and HttpRequest::addCookies(). Custom cookies can always be unset by calling HttpRequest::setCookies().

He's made these adjustments in the CVS for the library, and mentions an implementation of the cookiestore option with these new changes as well.

Wez Furlong has posted some information today on his blog hot on the heels of the PHP 5.1.3 release about the inclusion of the latest PDO/PDO drivers in the release.

PHP 5.1.3 was just released, including the latest PDO and PDO drivers. If you're still running older releases of PHP you should probably upgrade. If you don't want to upgrade the PHP core then you'll be pleased to know that I've also released the PHP 5.1.3 versions of PDO, PDO::MYSQL, PDO::PGSQL, PDO::SQLITE and PDO::ODBC to PECL--these are the versions that I've had time to personally test.

These are identical to the code in PHP 5.1.3, with the exception of PDO::ODBC, which includes two additional bug fixes that didn't make it in time.

He also shares a note for those out there trying to build PDO drivers off of the older PECL drivers to work in PHP 5.1.2. Unfortunately, they were also filing bug reports when things broke - a thing that "doesn't make sense" when the bundled PDO should work just fine.

Via this digg.com post today, there's information about a new PECL extension that's been committed allowing developers to create wave forms for strings of text.

Yahoo developer Jeremy Johnstone just added a new extension to the PECL PHP library that will allow you to send a string of text and have the extensions spit back out a wave form. This is huge news for those running public sites with the "please enter the text you see here" dialogs. Now you can offer a new alternative to image captcha.

According to its PECL page, it wraps around the Flite voice synthesis library, and can take in text and quickly generate both RIFF and raw wav formats. For more info, check out his new blog entry.

According to this new post from Ilia Alshanetsky's blog, he's wrapped up new versions of his PECL extensions, Fileinfo and GDChart.

Just finished packaging Fileinfo 1.0.3 that finally builds on both PHP 5.1 and 5.0 properly. You can download the new version by running "pecl install fileinfo" or download the tgz file from here.

I've also made the release of GDChart 0.2 that is nearly a complete rewrite of the extension, originally written by Rasmus that allows it to work with PHP 5.1. This extension wraps around the bundled gdchart library and allows you with just a few lines of code draw 20 different graphs types.

The GDChart package looks especially useful, making it a simple matter of feeding in the data you want to render and out popps a graph. Previously, there's been this functionality via other scripts, but it's nice to see something native...

From Mike's blog today, he has this post that looks at the PECL::HTTP extension and a "nasty bug" he's fixed.

I just fixed a nasty bug which caused GZIP encoded files (speak tgz etc.) to be decoded. While it'll just eat some memory on a 200 response (besides that the body is not what one would expect), it'll eat all memory on 206 (partial content) responses because the part is fed through zlib. I'll just need to revisit the HTTP RFC to check if checking for the "Vary" response header is the best bet before I drop the new release.

Also included in the post is an example script covering how one can download large files with the same, corrected extension...

I just released pecl at pecl.php.net, my first PHP extension. docblock is to phpDocumentor docblocks what the tokenizer extension is to PHP itself. It takes a docblock as an argument, and returns an array of tokens. Parsing docblocks in PHP has always been a major pain, and also very difficult to do correctly, because certain kinds of code simply won't parse correctly without a proper scanner (such as docblocks containing and @fopen - phpDocumentor 1.3.x will try to parse the "@fopen" tag).

He notes it's only really been tested with PHP 5.1, but has shown some promising results so far. And, for users of phpDocumentor, he also provides a quick update on the status of that project as well...

In Ben Ramsey's latest post today, he talks about filtering user input and some of the wealth of discussions that have come up about it on the php-general mailing list.

Richard Lynch even tossed out a few of his ideas concerning the use of a $_CLEAN superglobal variable that would merely serve as a reminder to programmers (through its constant use in the PHP manual) to filter input as a "best practice" (see here and here). Furthermore, on Chris Shiflett's blog, Richard comments that "[s]urely our base solution for minimal Security should be a fundamental part of the PHP language, not some add-on second thought."

Benstarts from the beginning, talking about the Input Filter's roots (from Derick and Rasmus), and Richard's point about security tools being a "fundamental part of the PHP language". He gives an example of a form and how an integrated PHP extension might look to handle the filtering, and his personal opinion on the matter:

It should be noted that it is just as easy to filter input without these built-in functions, but, perhaps, with the inclusion of these functions, it will encourage others to start properly filtering data.