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.

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

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.

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

So without further adue, enjoy:

PSA #1:

PSA #2:

PSA #3:

PSA #4:

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 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

The class itself is incredibly simple and straightforward, and allows you to send notifications using only 5 lines of code. Consider this simple example:

// Setup
$growl = new Growl();
$growl->setAddress('127.0.0.1');
$growl->addNotification("Test");
$growl->register();
 
// Send Notification
$growl->notify("Test", "Test Alert", "The body of the test alert!");

 
Pretty nifty isn’t it? One could very easily integrate this into a logger to notify you immediately of any critical errors with your scripts, or even tell you every time a given page is viewed. So if you want to check out my modified version (a bit more standards-compliant with PHP 5) you can see it here, or view the original author’s site to see the original.

Download: Growl PHP Class

This release may be the most significant update PHP has seen since PHP 5. This is because many of the features planned for the first release of PHP 6 are being backported to 5.3. Anyone that has been folowing the development of PHP is likely aware that 6.0 will represent its entrance into what I like to call its adulthood. This milestone will mark the end of support for deprecated non compliant code, and will fully embrace an OO coding style. It’s not going to be the end-all be-all version of PHP, but it will no longer attempt to cling to its procedural roots.

Let’s take a look at some of the goodies in store for us in PHP 5.3:

I. Native MySQL Support

As of right now PHP has made use of the external library libmysql to access MySQL databases, which is fine - it works and it works well, so no complaints here. However, the relationship that has developed between PHP and MySQL is quite widespread, and I must admit it seems odd that MySQL has never truly been natively supported. All that will change in 5.3, when PHP will natively support MySQL resulting in a significant performance boost.

II. Variable Static Calls

You are probably already familiar with variable variables and variable function calls. Variable static calls are the next logical addition to this feature set. This concept is best illustrated with an example, so consider the following:

$className = 'StringUtils';
$functionName = 'FormatPhoneNumber';
 
$phoneNumber = '2535552552';
$newPhoneNumber = $className::$functionName($phoneNumber);
 
echo $newPhoneNumber;

 
If we assume that the function StringUtils::FormatPhoneNumber() formats the phone number into a friendly layout, we could expect the above script to output “(253) 555-2552″ or something similar. This adds a tremendous degree of flexibility to your code, as I’m sure you can already imagine.

III. Error Reporting

Error reporting has been expanded and has split E_STRICT into two separate reporting levels. E_STRICT now only reports on bad coding style and leaves deprecated code (code that will not be supported much longer) to the E_DEPRECATED level.

Additionally, E_ALL will actually include E_STRICT errors as well (which is what most of us expected to happen when it was first introduced).

IIV. Namespaces

I saved the best for last. Namespace support is hands-down the feature I am most excited about. This is some thing many developers with experience in other languages have been clamoring for since PHP first started supporting classes. Namespaces allow you to group related classes together and help to avoid naming conflicts in more complex applications.

Currently the only way to accomplish this is to simulate namespace funcionality by using very long class names. Consider the Zend Framework as an example, in which you end up with class names like “Zend_Auth_Adapter_Http_Resolver_File” or “Zend_Controller_Router_Route_Module” - just mildly inconvenient, isn’t it?

As of PHP 5.3 one could place these classes in namespaces, making them much more manageable:

namespace Zend::Auth::Adapter::Http::Resolver
 
class File {
    public function __construct() {
        // Do something here...
    }
 
    public function setFile($path) {
        // Do something else here...
    }
}

 
We could then instantiate the class like this:

use Zend::Auth::Adapter::Http::Resolver as HttpResolver;
 
$file = new HttpResolver::File();
$file->setFile('/home/testuser/file.tmp');

 
In the above case, we can now instantiate all classes within this namespace using a similar declaration. As you can see, the addition of namespaces allows you to declare the namespace in which a script will execute, greatly shortening the required class declaration. This also introduces the possiblity of namespace aliases, allowing you to reference a namespace with a shorter ‘nickname.’

We could have called the class directly from the namespace (like “new Zend::Auth::Adapter::Http::Resolver::File()”) and left out the use construct, but then we would be back to a long class declaration. Even then, this time around PHP will actually be aware of the namespace (and potentially future IDEs, leading to more powerful code-hinting).

Conclusion

That was just a sample of what you can expect when 5.3 is released. With so many additions that were originally planned for PHP 6, this release is going to feel like an early birthday present. This also means we can see these features added to our production environments more quickly considering an upgrade to 5.3 will go much more quickly than a migration to an entirely new verison.