“With the advent of PHP 5.0 came a new collection of built in classes and interfaces known as the Standard PHP Library (SPL). The goal of this library is to “solve standard problems and implements some efficient data access interfaces and classes.” What gives this library an edge over other third-party offerings is its tight integration into the core of the PHP language and data structures. In this series of blog posts, I will attempt to showcase some of the more useful components of this library.

I. An Introduction

Before we start rifling through SPL’s various interfaces and classes, let’s start things of with a basic overview. The SPL consists of a number of classes and interfaces that are designed to enhance PHP’s ability to work with and iterate over data.

Object Iteration

The library really shines in cases where iteration over an object’s data is necessary. Some basic interfaces such as the Iterator and the SeekableIterator provide the basic tools to do so. There are also some classes that implement these interfaces that can provide the needed functionality right out of the box, and also offer some excellent examples of how these interfaces can be used (take a look at the EmptyIterator and RegexIterator classes for instance).

Walks like an array, talks like an array, looks like an object….

Being tightly woven into the PHP core, SPL also provides the ability to provide access to data stored within an object as if the object were an array. How the data is stored within the object is entirely up to the developer, and could range from referencing a single internal array to the execution of complex code.

There is plenty more that SPL can do, and the release of PHP 5.3 and 6 both promis even more functionality. Now that I have you all worked up over SPL, you’ll have to wait for my next post to get into the nitty gritty details. In the meantime, consider browsing the official documentation located here.

I just want to give a quick shout out for a pet project of mine that has launched today, called Bedrock Framework. It’s a new PHP framework that came from code that I’ve been using for personal projects over the years. I finally decided to package it up and release it as an open source project.

Check out the official website for more details:

Link: www.bedrockframework.com

Today marks the first day Stack Overflow opens its doors to the public. In case you’re not in the know, Stack Overflow is essentially a Q&A site geared towards developers of all kinds. It takes a language/technology agnostic approach and simply provides a framework within which the community can ask and answer techincal questions. Think of it as ExpertsExchange.com except free and much more community driven.

What I Like

One thing in particular that really impressed me was the way in which the system is designed to build trust with its users. When you first open an account, your level of access is somewhat limited. You start out only being able to ask questions, rate answers, etc. As your involvement in the community grows and users rate your contributions (questions, answers, comments, etc.), your user score will increase. As your score rises, you begin to build trust and the restrictions on what you can do are lifted. After some time you can even edit submitted questions wiki-style, re-tag questions, and essentially moderate user interactions.

Another handy addition adds an element of “fun” to using the site. Known as badges, users can earn them by meeting certain requirements (think Xbox achievements). These badges are visible to other users and help a user to build credibility in combination with their score. This type of formula has been proven to be addictive (think MMORPGs), as users basically “level up” the more they participate in the community. This creates the motivation to contribute to the site and ensure it continues to grow (rather than ExpertExchange’s paid model, where users are motivated by free membership to what would otherwise be a mothly charge).

What Could Improve

Overall the only areas for improvement that come to mind are the smaller details in how the system works. Some things are not quite intuitive yet, such as finding unanswered questions related to a specific topic (which is possible, but not immediately apparrent).

It would also be nice if the site would somehow encourage the growth of sub-communities. For example, one could borrow from the MMORPG concept of a guild and create user groups. Each group could be associated with a particular technology or language and could make tools available that would help facilitate communication between like-minded developers.

Conclusion

Joel and Jeff are definitely off to a great start with the site and judging from what they have produced so far, I’m optimistic about its future. Having been involved with the private beta, the team maintaining the site has bee fairly responsive and Jeff seems to be very receptive to user input. It will be interesting to see how the site evolves in the coming months.

Today I discovered a very powerful addition to the PHP world. Phar is an archive extension for PHP that allows an entire PHP application to be packaged into a single file. It’s basically PHP’s answer to Java’s .jar archive format. Don’t get excited yet, it gets better . . .

There are a few things that make this particularly handy. For one, it is being integrated into the next major PHP release (5.3) wich means that any standard PHP installation running the latest version will support .phar files right out of the box.

The other advantage is of course in deployment. Using a .phar file you can deploy an entire PHP application by working with just one file, rather than a buch of files and directories. This is where .phar really shines. Imagine deploying a popular web app like WordPress by simply copying a single .phar file to your web server’s root, rather than figuring out how to zip it up, upload it, and somehow unzip it remotely. Piece of cake!

The devlopment side is equally as simple, being able to access files within the .phar file as easily as if it were another directory in the filesystem. The .phar file itself can be included in a script using any of PHP’s standard import constructs (include, include_once, require, require_once). This also means external libraries can be more easily integrated, having just a single file to include in order to utilize a given library. A .phar archive can also be accessed as a stream using the same functions used to read/write other types of streams.

// Referencing a .phar archive or its contents:
include 'userlibrary.phar';
include 'phar://userlibrary.phar/internal/file.php';
 
// Utilizing the Phar Stream Wrapper:
header('Content-type: image/jpeg');
echo file_get_contents('phar://userlibrary.phar/img/image.jpg');

Certainly there are disadvantages as well, and this is not a one-size-fits-all solution. Using .phar files does result in a performance hit, meaning traffic-intensive sites and heavyweight applications are probably not the best place to use this tool. It also may not be ideal for a web app that is fairly modular, or other situations where source files might be added or removed on a regular basis. It does have its uses though, and for me it will be a welcome addition to the PHP core.

As mobile access to the web increases, it is becoming more and more important to ensure sites are usable on mobile devices. iPhoney attempts to address the iPhone camp with a desktop application that renders web pages within a virtual iPhone.

After playing around with the app, it is certainly not without its flaws. For one, it is not simulating a true iPhone client environment. This means there is still room for the possibility that pages will display differently on an actual device. The UI is also fairly limited, with the iPhone graphic surrounding the browser window being purely aesthetic with no functional purpose or clickable areas. It would also have been nice to be able to simulate different network speeds to see how pages loaded using typical 3G/HSDPA, EDGE, and GSM connnections.

The program does recreate an accurate pixel-for-pixel recreation of the browser window (320×240). It even lets you rotate the virtual phone sideways to view the page in “landscape” mode. It also does an excellent job of recreating the iPhone’s browser UI, which can be extremely useful for developers building sites that complement the iPhone’s UI appearence. Overall it makes aesthetic testing of a site extremely simple and straightforward, though is lacking in other areas like performance and browser testing. In the end it won’t replace the need for a real iPhone to properly test a site, but it is certainly a step in the right direction.

Link: iPhoney Product Page

Having recently discovered the plethora of coding fonts available online, it occurred to me that quite a bit of thought has been put into something I have always seen as rather trivial. The more I read about it, the more I have come to realize that using a font specifically designed for software development can be extremely beneficial.

My first thought was, “what on earth could require so much thought?” As I continued my browsing, the all the pieces started to fall into place. Some of the things coding fonts specifically try to emphasize/improve upon include:

• Appropriately styled for typically used sizes (~8pt - 10pt)
• Smaller line-height (means seeing more lines of code at once)
• More readable symbols (esp. brackets, parenthesis, etc.)
• Designed to be monospaced from the ground up (full-width/centered characters, etc.)
• Reasonable tab sizing.

I’m sure there are plenty of others, but these are some of the things I found valuable right off the bat.

If you’re interested in giving some programming fonts a whirl, I highly recommend you start your exploration with Proggy Programming Fonts. I particularly like (and currently use) the one called CodingFontTobi which really makes reading through large blocks of code a breeze. I discovered it wasn’t fully compatible with OS X (tabs would appear as funky symbols), so if you’ve got a Mac I recommend downloading my modified version.

That’s right, you heard me! It’s all thanks to a fantastic project called Phalanger, which adds a super-fast execution environment for a very large portion of the PHP scripting language. Certainly this was only a matter of time, combining one of the most popular open-source languages of the web with one of the most powerful enterprise-grade frameworks.

One of the coolest things about Phalanger is the way it allows you to decide how to implement PHP syntax. There is almost no barrier to entry, as it is designed to implement PHP the same way it is handled natively, but also allows you to use PHP syntax in an ASP.NET application just as though PHP was simply another option among VB.NET and C#.

I’ll admit I have yet to take a crack at it, but having worked with both .NET and LAMP technologies I can’t help but imagine the possiblities. SiteCrafting in particular could benefit from this tremendously, allowing our PHP devs to easily port PHP-based solutions into some of our existing .NET projects. It also means essentially all of our developers could make contributions to a .NET project if the need arose.

I should warn Phalanger is still in it’s beta phase, and has not yet fully implemented the entire PHP language and common libraries. Though it may not be enterprise-ready yet, I see good things ahead.

Link: Phalanger
Link: Tutorials

During my morning blog-scan I came across four videos that really set my day off on the right foot. And that song! Oh that song! As much as I can’t stand it, I’ll be humming it all afternoon today. If you’re familiar with the MVC model, then these videos were made for you.

So without further adue, enjoy:

PSA #1:

PSA #2:

PSA #3:

PSA #4:

I recently had the opportunity to work with one of Google’s latest search applances, the Mini. Having no previous experience with any of Google’s search hardware, this seems an excellent opportunity to offer a newcomer’s first impressions.

I. Setup & Configuration

Setting things up turned out to be more painless than I had expected. Upon opening the box, I found the contents to be only what was necessary. It consisted of 5 things: the Mini itself, a yellow Cat5 cable, an orange Cat5 crossover cable, a power cable, and the manual/quick-start guide (and a snazzy tshirt!). That’s it, nothing else! No product catalogs, no coupons, no massive collection of multilingual warranty booklets, and most importantly no unnecessary clutter.

II. User Interface

The UI of the administration panel is clean and to the point - very much what one would expect from Google, and consistent with Google’s overall style across the rest of their product line. All the administrative functions are organized categorically and only one menu-level deep, making virtually any administrative action no more than 2 clicks away.

III. API/Programmatic Usability

Accessing the mini’s search capabilities programmatically works very much as one might expect - executing search queries via GET or POST and returning the results in an easily parsable XML format. Additional options are also available, though I found the XML format to be the most flexible for the circumstances. It is so easy to use I actually had to debate whether or not writing a PHP wrapper class was actually necessary. In the end I decided it would make sense, though even then writing the class itself was a breeze.

IV. Thoughts

Overall I am very impressed with this little beast. It clearly isn’t over-engineered and for its intended scale of use it is not underpowered. I would have liked to see more flexibility in managing the crawling process and in how results were returned, but these things would have been icing on a cake that is already fantastic on its own.

For anyone considering the acquisition of one of these, I highly recommend it. For small to medium applications you can’t beat the price, especially when compared to the mini’s bigger brother. And its usability both through the UI and programatically are very intuitive and easy to dive into. Well done Google, well done!

gotAPI.com is one of the most useful online resources I’ve come across, primarily because it places resources spread all over the internet into one simple site. I’ve been using this for quite some time, and have for the most part I have taken its usefulness for granted. Then it occurred to me that I might not be the only one that could find this tool useful (I know, it was a big ‘DUH!’ moment). So now I will share this gem with others…

gotAPI acts as a portal to almost any API/language reference available on the internet. Wondering what that PHP string function is that splits a string into an array? Pour yourself a nice tall glass of gotAPI and find it in seconds. Or if JavaScript is more your thing, browse the DOM to find the function or property you need. The advantage is that it can all be accessed from here, no need to remember countless URLs or stumble through a poorly designed site to find the documentation page. Simply hit up the site and you’re set.

Customization is another advantage, with the tabbed interface allowing you to pull up multiple reference pages (all searchable with an expandable tree view to your left). Load up all the API’s related to your current project finding an obscure function is now seconds away. Fantastic!

The fact that I am still excited about this site after months of using it should tell you just how nifty it is. So stop wasting time reading blogs and go check it out!

Link: gotAPI