Finding APIs/web services

Finding APIs and web services is really quite easy. If you regularly use a web application - for example, I’ve often used Twitter - check if the application provides an API (Twitter has quite a comprehensive one). Next, if you’re looking for data on a particular topic, try searching for it. A quick search for “map api” returns all kinds of useful results. Finally, if you just want to take a look at the internet’s available APIs, head to Programmable Web; they have by far the most comprehensive database available, and it’s fully searchable.

Handling API output

The easiest way is a really PHP-friendly APIs that provides serialized PHP. You can just fetch the URL with file_get_contents(), and run the output through unserialize(); in two lines of code, you have your data ready to work with.

However, most APIs won’t offer serialized PHP output; some might offer JSON, or JavaScript Object Notation, which is somewhat like PHP’s serialized data (although JSON is integrated in the JavaScript language). Others offer XML gateways, while some even provide SOAP, a (rather complicated) means for computers to talk to each other natively. You really have three options:

1. Interpret the output of the API or web service with a PHP-based parser, such as an XML parser (which you can easily find on phpclasses.org) or a SOAP client (try nusoap).
2. Use PHP sample code provided by the API/web service owner - e.g. this Google Checkout PHP sample. Some even provide PECl extensions.
3. Use a third-party library to access the service. For example, people have written PHP classes that allow you to interact with the Flickr API. PHP Classes.org has hundreds of these, and others are just a web search away.

Some PHP-friendly APIs

Of course, if you just want to get started right now and quickly add some functionality to your application, try these:

• reCAPTCHA PHP library: add effective CAPTCHA to your application in pure PHP with reCAPTCHA
• Yahoo PHP developer center: Yahoo! provides some very useful search APIs that you can probably use. Also see my PHP Site Search Made Easy tutorial making use of these APIs.
• Flickr Services with PHP Response

Have a look through these APIs and you could be building a mashup quickly in no time.

Bookmark It

Hide Sites

Local development server

Now, when developing your applications, you can’t simply keep uploading to your web host’s server for testing. Having a local development server with PHP and MySQL is invaluable; whether it’s on your local machine or a seperate box (I use an old P4). Configuring all the applications under Windows can be a real pain, but luckily there are some all-in-one installers that make it easy:

WampServer
WampServer is by far the best option for Windows; it comes with Apache, PHP, MySQL and phpMyAdmin all ready and configured. Best of all, you can manage multiple versions of Apache, PHP and MySQL, and it supports easy switching out of the box, to closely replicate your production environment.

XAMPP Lite
While WampServer is certainly very powerful and effective, I personally use XAMPP Lite, as it offers the usual Apache/PHP/MySQL, phpMyAdmin, and best of all, it’s entirely portable - I can pop it on a USB stick and take it to another machine if needed. The XAMPP control panel is also simple and effective.

DIY
Thanks to the wide availability of online tutorials in this area, setting up your own Apache/PHP/MySQL server isn’t as hard as it used to be. If you really want to roll your own WAMP, take a look at one of these tutorials.

If you’re on a Linux box, you can probably just install Apache, PHP and MySQL from your package manager. If you’re running Ubuntu, try this guide.

PHP Configuration

Seeing as you won’t be running a production web server from your local development setup, you might as well configure it to best suit development. With a few of these simple changes, you can tweak your PHP setup to best suit you. Load up your PHP.ini file and have a read through these suggestions.

short_open_tag = On
If you’re working with view files written for a PHP framework, or just generally open source PHP applications, chances are you’ll need to enable this directive. When it comes to PHP tags, <?php is the standard, and <? is widely accepted but not always available. Save yourself a lot of hassle by enabling this directive.

implicit_flush = On
When you make a call to echo() or print(), or put a HTML block between PHP code blocks, PHP doesn’t always output it automatically. Setting implicit_flush to On forces it to do so. This is a great help for debugging; the moment something happens, you’ll see it in your browser/console window. (I believe PHP-CLI enables this by default.) However, by no means enable this on a production server, as it has serious performance implications.

docref_root = “/phpmanual/” and docref_ext = .html
Do yourself a favour and grab a copy of the PHP manual, pop it on your local development server and point docref_root to it. Enable docref_ext as .html as well; whenever you see a PHP error, it’ll link to your readily-accessible local copy of the manual. An invaluable debugging tool.

memory_limit
Depending on how you want to manage your resource usage on your local machine, set memory_limit to either 16M or some reasonably high amount (a quarter of RAM is appropriate; mine is set to 128M on a 512mb RAM box). If you have fairly resource intensive scripts, setting memory_limit to a high value should help avoid problems later on; if you’re on a constrained shared host and need to get used to not being able to use a lot of memory, set it fairly low - 16M or maybe 32M at the most. Remember that you can usually override this within your scripts using ini_set(’memory_limit’, ‘xxxM’);

Linux IDEs/editors

When it comes to php editors on Linux, there aren’t too many real Linux options. Luckily, however, some of the best cross platform editors work far better on Linux than on Windows (quite possibly as a result of Linux OSes being typically more efficient than Windows on the same hardware). Here are some of the best options.

Eclipse

Eclipse is pretty much the gold standard for IDEs. It’s entirely open source and heavily customisable, so much so that some professional IDEs are built on top of Eclipse, as we’ll see in a moment. Eclipse was built with Java in mind, but thanks to its powerful plugin system, Zend provides the PHP Development Tools (PDT) for Eclipse, which can transform your Eclipse IDE into a fully-fledged PHP development environment.

Zend Studio for Eclipse

Well, bring on the Eclipse derivatives. Next up is Zend Studio for Eclipse, the successor to the old Zend Studio (which was actually rather powerful, albeit terribly underperforming). With ZSE, the IDE is almost managable for Windows, and certainly an option for developers on Linux boxes. Zend advertises it as the most powerful IDE for PHP, and they’re probably right; the feature set is more or less unmatched from any other general cross-platform PHP IDE, although interestingly PhpED on Windows does come close. To identify the differences between ZSE and just PDT on Eclipse, Zend provides a comparison table.

Aptana

Aptana PHP Development Environment is yet another Eclipse derivative; the Aptana-provided PHP plugin has one of the best editing systems for PHP, and is very helpful when bashing out code and identifying syntax errors. Interestingly, it’s a general plugin for Aptana’s derivative of Eclipse, and you can also install their RadRails plugin alongside to quickly switch between PHP and RoR. If you don’t want to download Aptana’s editor and already have Eclipse, you can install Aptana itself as a plugin on top of Eclipse.

General editors

Of course, for quick hacks you can’t go past a simple text editor. I usually work with Gnome, so I always keep gedit handy, and gphpedit is useful; for KDE, there’s Quanta and a few alternatives. You don’t really need autocomplete and other code intelligence in your spare editor; syntax highlighting will help you put together hacks quickly and effectively.

That’s all, folks!

And that’s all for part two of our series on the ultimate php web development environment. In part 3, we’ll take a look at setting up a linux server to help with your PHP web development, from the usual LAMP to samba shares, a local SVN server to webmin for web-based server administration. If you liked this part of the series, please subscribe to our PHP RSS feed to keep up to date on our latest PHP articles.

Bookmark It

Hide Sites

However, many of these packages are bloated, slow and full of specialised features that you may never want to use. Sifting through the repository is also a challenge; a basic category system is in place, but it’s hard to tell what you want when you don’t know what’s available. Here are some gems from the PEAR repository that you could really find useful.

1. Services_Akismet: Deal with spam once and for all
When it comes to dealing with comment spam, you can’t go past Akismet. It powers just about every Wordpress blog out there, including this one; it also has an API web service that allow it to be used in any other web application, and Services_Akismet takes advantage of this. Best of all, it’s free for personal or commercial use.

2. HTTP_Request: Perform complex HTTP requests
Sure, there are many web services to hook into and web pages to download, but how do you access them all? Some times you need to go a little beyond basic file_get_contents; make HTTP requests with sessions attached, upload files, do some basic authentication, maybe even work with a proxy. HTTP_Request will help you do all this and more in a matter of a few lines of code.

3. Archive_Tar
When maintaining a big web application, you’ll often find your server filling up with cache files, archives and data dumps. Storing these effectively is very important to maintaining the performance of your server; if you don’t access them frequently, the best way to achieve this is with Archive_Tar. Similar to creating a .tar tarball and compressing it with GZip on your machine, Archive_Tar will allow your web server to compress large files quickly and effectively.

4. Spreadsheet_Excel_Writer
When creating MS Office files programmaticaly, you often have to rely on having a Windows server with the actual Office products installed to generate your files. However, COM isn’t the best approach if performance is a concern, and more often than not you’ll be deploying on a Windows server. If you need to generate Excel files, no matter what platform you’re working with, Spreadsheet_Excel_Writer is your best bet for pure PHP.

5. XML_Parser
XML is becoming more and more prominent in web applications. From configuration files to meta information and even page data. XML_Parser provides a consistent, reliable, effective way to parse XML files, and is reasonably fast as well.

Have a look through these PEAR packages; remember you can easily install them just by running `pear install PACKAGE_NAME` at a command line/terminal. If this isn’t an option, you can still download them and include them as usual (although you may need to slightly rewrite file paths within the PEAR packages, as they include each other).

Bookmark It

Hide Sites

Measure script execution time

This is the easiest part. PHP’s microtime() function will give you the current timestamp in microseconds (you need that level of precision for script execution time). However, microtime() will give you a value like 0.13554500 978913621, when what you really want is 978913621.13554500 (the 0 taken off the decimal section and added on to the integer). We can take care of this easily with a function we’ll call microtime_float().

So, to implement script execution time, we just take this value at the start of the script and at (or near) the end, then subtract them. First, at the very start of your page’s code, add this function:

function microtime_float()
{
    list($utime, $time) = explode(" ", microtime());
    return ((float)$utime + (float)$time);
}

$script_start = microtime_float();

Then at the end, add this:

$script_end = microtime_float();
echo "Script executed in ".bcsub($script_end, $script_start, 4)." seconds.";

Measure script execution time in stages

We can use milestones in a script to track how certain sections of code are performing. The best way to achieve this is a simple function with some static variable inside. However, needs can quickly get complicated, so I built a simple static class to handle everything. Include this class in your application:

<?php
class ScriptTimer {
  static $milestones;
  function microtime_float() {
    list($utime, $time) = explode(" ", microtime());
    return ((float)$utime + (float)$time);
  }
  function timing_milestone($name) {
    self::$milestones[] = array($name, self::microtime_float());
  }
  function dump_profile($return = false) {
    self::$milestones[] = array('finish', self::microtime_float());
    $output = '<table border="1">'.
              '<tr><th>Milestone</th><th>Diff</th><th>Cumulative</th></tr>';
    foreach (self::$milestones as $elem => $data) {
      $output .= '<tr><td>'.$data[0].'</td>'.
        '<td>'.round(($elem ? $data[1] - self::$milestones[$elem - 1][1]: '0'), 5).'</td>'.
        '<td>'.round(($data[1] - self::$milestones[0][1]), 5).'</td></tr>';
    }
    $output .= '</table>';
    if ($return) return $output;
    echo $output;
  }
}

As you can see, it’s a fairly simple class. It basically stores an array of milestones, each named, in ScriptTimer::$milestones. Each time you call ScriptTimer::timing_milestone(), you pass it a name of the current milestone. This might be ‘begin’, ‘init db’, ‘fetch rss’, ‘end’, or anything you like. When you call ScriptTimeer::dump_profile(), it runs through all these milestones and generates a HTML report. Trying it out in a real application results in something like the following:

It’s no full-on profiler, but it can still prove highly useful in quickly performance testing your application. To use it, just call ScriptTimer::timing_milestone(’some milestone name’) at major sections of your code. This is the testing script I used:

ScriptTimer::timing_milestone('begin');
usleep(3000); // do some db stuff
ScriptTimer::timing_milestone('db ready');
usleep(5200); // do some cache stuff
ScriptTimer::timing_milestone('caches primed');
usleep(8000); // render the output
ScriptTimer::timing_milestone('all output');
usleep(600); // clean up
ScriptTimer::timing_milestone('garbage collected');
ScriptTimer::dump_profile();

I’ve used the usleep() function to simulate loading time - don’t do this in your real application! Just add the ScriptTimer::timing_milestone() calls in, and call ScriptTimer::dump_profile() at the end. No need to initialise; the class works statically for simplicity.

Workaround for max_execution_time limit

Depending on your server configuration, you should be able to work around the max_execution_time script execution time limit very easily. A call to ini_set() should change the value of max_execution_time for the current execution, like so:

ini_set('max_execution_time', '0'); // 0 = no limit.

Bookmark It

Hide Sites

1. Zend Developer Zone
Zend’s Developer Zone frequently publishes articles and tutorials on just about every area of PHP. Some of the recent items up there include the value of web services, various PHP conferences (and unconferences) coming up, and my favorite, “Designing Klingon Warships Using Behaviour Driven Development”.

2. PHP Architect C7Y
C7Y is the community website of php architect, another PHP company similar to Zend. C7Y features articles on PHP development, interesting forum discussions and news from the PHP world, among other things.

3. PHPDeveloper.org
PHPDeveloper is about what’s happening in the PHP world. If something important comes up, chances are it’ll soon be up on phpdeveloper.org. Interesting posts on major PHP blogs, job openings, releases of open source projects and new tutorials all make it to phpdeveloper.org, making it an invaluable resource.

4. Digg.com/programming
Digg’s programming section regularly features major articles of interest to web developers. Along with the software section, Digg has everything from a video on using the Greasemonkey extension to Firefox, to powerful CSS techniques, practical uses of the Firefox Web Developer toolbar and the lateast Adobe AIR release as it happens. Definitely worth keeping an eye on. Reddit’s programming section also has some gems.

5. PHPClasses.org
No matter what you’re attempting to do in PHP, chances are it’s been done before. PHPClasses.org is the most comprehensive repository of user-submitted php classes, to handle everything from communicating via the MSN Messenger protocol to parsing configuration files, send SMS messages to reading apache log files. This can save you hours of development, and you can learn something new from innovative approaches other people have taken.

6. Planet PHP

Planet PHP is a blog planet, aggregating posts from well over 100 major PHP blogs. If something big is happening in the PHP world, chances are it’ll turn up on Planet PHP. This is fairly high traffic, however, so it’s easiest to grab the feed in your feed reader - see below.

7. Bonus: Google Reader to keep track of it all

Of course, you can’t keep track of all of these sites yourself. Load up your favorite RSS/atom feed reader - we prefer Google Reader, but there are many others - and add these feeds:

Zend Dev Zone
php architect C7Y
phpdeveloper.org
Planet PHP
Developer Tutorials PHP Blog

You can then load up Google Reader (or your feed reader of choice) every morning and find the latest PHP news, tips and tricks, patterns and approaches, invaluable for becoming a better PHP developer.

Bookmark It

Hide Sites

Naturally, I chose the latter. Here’s ten lines of code that do just that.

Communicating via COM in PHP is easy as ever; especially for people coming from a VB background where executing complex tasks in MS-applications is a piece of cake, you will feel right at home in PHP. In fact, VB COM calls can be converted to PHP COM calls in just a few simple search and replaces.

Without further ado, here’s the code. I’ll point out a gotcha I noticed in just a moment.

<?php
$word = new COM("word.application") or die ("Could not initialise MS Word object.");
$word->Documents->Open(realpath("Sample.doc"));

// Extract content.
$content = (string) $word->ActiveDocument->Content;

echo $content;

$word->ActiveDocument->Close(false);

$word->Quit();
$word = null;
unset($word);

We first create a new COM object of word.application, which provides access to core MS Word functionality. We then tell it to open “Sample.doc” in the current directory. There’s a bit of a bug/feature when trying to get the content out, however. If you debug this code, you’ll find that $word->ActiveDocument->Content is an empty object (variant). If you assign the value to a variable you’ll get an empty string, as the variant object has no real __toString(). The workaround in PHP is to explicitly type cast the value as a string and make PHP/COM take care of finding the real value. If you try this in a VB macro run inside Word, this is not neccessary - a MsgBox(ActiveDocument.Content) works fine.

We also need to be aware of performance considerations on Windows servers - creating a COM object initialises a fully-fledged instance of WINWORD.exe, and a 10-15MB memory footprint associated with it. We first call the Quit() method on the Word COM object, then null the variable and destroy it to be safe. Watch your task manager while running this script and you’ll notice WINWORD.exe appears briefly then exits.

So, in just ten lines of code you can get the text out of an MS Word document, easy as ever!

If you want to explore this approach further, load up MS Word and open the Visual Basic Script Editor - press Alt+F11, then F2. (If that doesn’t work, Tools > Macros > Visual Basic Script Editor, or “Visual Basic” under the Developer tab 2007, then press F2.) From the library drop-down box in the “Object Browser” - which might say “” by default - select Word. Just about everything you see there is available via COM in PHP.

Bookmark It

Hide Sites

After you’ve been coding PHP for a while, you start to work out what the tools of the trade are, which applications can help you work more effectively, and essentially how to get things done. While developing, your environment is crucial: not having the right tools to do your job can be a serious impediment on productivity. In this new series, I’ll help you bring together the ultimate PHP web development environment.

In part 1 of this series, we’ll start with the usual suspects: software. The software you use can make or break your project; not being able to debug code, for instance, can double the time taken to complete a project. Here I’ll be covering software for Windows users, but many of the suggestions here are relevant for OS X and Linux users as well.

Web browsers

We could have started with the IDE, but your web application doesn’t end at the IDE. In fact, a sufficiently low-featured IDE can help your project if coupled with a decent browser. The web browsers - yes, browsers, not just one browser - you use are arguably the most important part of your arsenal. A sufficiently powerful web browser can make pulling an application interface together extremely fast, while an outdated and inflexible browser can cause endless grief. Remember, you’re a web developer, and your web browser is your window into the world you work in.

Firefox is pretty much assumed here. If you’re developing web applications with PHP and you aren’t using Firefox, you’ve either got a fantastic home-brew browser that does everything you need, or you’re developing much slower than you should be, most likely the latter. Using Firefox is especially important for rich internet applications, where the focus shifts considerably to Javascript and HTML/CSS.

I’m not trying to be an open source fanboy here - no other browser will allow you to debug javascript as it happens, add new javascript in while debugging, totally recreate the DOM of the page the javascript is working on while editing the javascript while debugging etc. etc. The key to Firefox is the wide variety of web development extensions available. No matter what platform you’re on, grab a copy of Firefox, then install Firebug, Live HTTP Headers and Web Developer. Have a look through each of these and you’ll realise just how much power they offer. FirePHP is also fantastic.

Of course, you can’t just work with one browser all the time. Given IE’s dominance, a copy of Internet Explorer 7 and regular rendering tests of your applications on it should be taken for granted. Once you’ve got IE7, take a look at the IE Developer Toolbar too; you might be pleasantly surprised at how much power IE web developers have as well (although nowhere near as much as Firefox).

And finally, given IE8 is going to be highly standards compliant, having a stable standards compliant web browser might be an idea for future-proofing your application. Ironically, the best browser for this is Apple’s Safari. Safari uses the WebKit rendering engine, which is not only far more standards compliant than Firefox, it’s also considerably faster. Under Windows, Safari isn’t a very good idea for standard web browsing given some past security concerns, but checking your applications render fine on Safari is definitely a good idea for future proofing your application.

Editor

Okay, I’m putting this out here right now: it doesn’t matter what IDE you use, as long as it has a debugger. This limits your options considerably; for Windows, the best way to get an IDE with a debugger is to get yourself a copy of PHPEdit or PhpEd. A number of other IDEs offer inbuilt debuggers, but none manage the simplicity and ease of use as these two, especially PhpEd. And it just so happens that both PHPEdit and PhpEd have syntax highlighting, code completion, CVS integration and all the usual features you’d expect to get out of an IDE.

It’s worth mentioning Zend’s Zend Studio and Zend Studio for Eclipse, as these are by far the best editors available for simply coding PHP, especially the original Zend Studio. The code intelligence is second to none, code completion is the most helpful of any IDE I’ve ever seen and the full-on feature set is ideal for any web developer. However, Zend Studio has two strikes against it: first, it uses Java, and second, the debugger is very complicated to setup (I think it needs a seperate product altogether, Zend Studio Server, although after hours of searching I simply could not work this one out). The problem with using Java is that the editor is very slow; in my tests, it started using 250MB of memory after working with some code for an hour, and it also slowed to a crawl. Think three second lags just to open context menus or expand a filesystem tree; five seconds to open a new (1KB!) file and fifteen seconds to switch to the inbuilt web browser. You’ve got work to do.

For a more comprehensive, albeit less detailed, roundup of IDEs, check out this article on IBM’s Developer Works.

To complement your IDE, and for quick code edits and tests, grab a copy of Notepad2 as well, and remember that if your PHP binary is in your system PATH you can test out code interactively just by running php -a through Start > Run (also winkey + R).

That’s all, folks!

That’s all for browsers and editors today; in the next part of this series, I’ll take a look at configuring PHP and various other software and some Linux editors and utilities.

Bookmark It

Hide Sites

Toby suggested that we generally communicate in approximate times, but on the web we usually work with exact timestamps. His idea was that by displaying the time as you would describe it verbally, he could better communicate the time in a visitor-friendly way.

After reading his post, I understood the merits of the approach, but it struck me that a relative time might be a little more useful for many situations. For example, in a fast moving discussion, a short timestamp (e.g. 8:30 AM) as well as a verbal summary of how long ago the time was (e.g. “4 hours ago”, “20 minutes ago”) are most useful to the user. In fact, this is precisely what Gmail does:

A common feature of Gmail’s timestamp system is approximation, similar to what Toby was getting at. For example, as you approach 60 minutes in the hour, Gmail seems to switch from “x minutes ago” to “1 hour ago”, even if you’re not quite there.

Now, I figured this could be achieved very easily in PHP - and it could. After the jump, here’s the code:

<?php
function RelativeTime($time, $now = false)
{
	$time = (int) $time;
	$curr = $now ? $now : time();
	$shift = $curr - $time;

	if ($shift < 45):
		$diff = $shift;
		$term = "second";
	elseif ($shift < 2700):
		$diff = round($shift / 60);
		$term = "minute";
	elseif ($shift < 64800):
		$diff = round($shift / 60 / 60);
		$term = "hour";
	else:
		$diff = round($shift / 60 / 60 / 24);
		$term = "day";
	endif;

	if ($diff == 1) $term .= "s";
	return "$diff $term ago";
}

It’s got a few unusual constants in there - the number values refer to 75% of the number of seconds in a particular period of time. 75% seemed like a reasonable measure beyond which we could round up - for example, the function will say “45 seconds ago” for 45 seconds, but “1 minute ago” for 46. The same goes for 2700 seconds, equal to 45 minutes, and 64800 seconds, or eighteen hours. Beyond this it simply uses the number of days.

The function will give you values like “20 seconds ago”, “10 minutes ago”, “3 hours ago” etc. Adding the Numbers_Words PEAR package might improve readability of your timestamps even more

So give it a go - it’s especially handy for message boards, comment lists and news readers, especially with threaded discussion. The code is very basic at the moment, suitable for adapting to whatever purpose you see fit.

EDIT: Hasin Hayder, a fellow DT blogger, wrote a post about a similar function that you may be interested in.

Bookmark It

Hide Sites

Namespaces were introduced to solve the problem of naming clashes. Once upon a time, all your code lived in one, two, maybe three files, and you could see and know exactly what was going on. Then applications started expanding, and OOP came along. Suddenly there were hundreds of functions, classes and methods in your application, not to mention variables and properties.

It was generally accepted that names should therefore be descriptive. However, names soon became very brief and generic, such as new(), Blog::add_post(), $config etc. All very well when you controlled all the code in the scope of your application, but the moment you came to integrating or reusing code everything went awry. To avoid this, names were long winded, prefixed and determinedly different.

So, where do namespaces fit in? Well, first we had raw procedural code, then we had functions, then we put functions inside classes. The best way to explain namespaces is that we can now put functions inside classes inside namespaces. this page has some good samples.

Of course, this is only going to work if namespaces names are unique.

Once PHP 5.3 goes mainstream, I suspect we’ll see the same trends in namespace naming as we did in class / package naming. In the samples used to demonstrate namespaces, we’ve seen anything from Company::Project::Package containing classs Package, Package_Something, Package_Something_Else; to MyProject::Package::Class containing class Class.

Ideally, we’d have [OriginOfCode::]Project::Package[::SubPackage] for naming conventions. The origin of the code could be the project itself (e.g. for open source collaborative projects), and could be omitted where appropriate. Subpackages would have to be clearly defined - there is no need to create a seperate namespace just for a new class. On the other hand, it makes perfect sense to have Zend::Framework::Service::Delicious and Zend::Framework::Service::Akismet.

Taking this to the extreme, we maintain a global list of TLNs - like TLDs, but Top Level Namespaces - and have a basic registration system. $0.25 to register your very own JohnCitizen namespace in PHP history? Each developer/company/project could then manage their top level namespace - and, if they so desire, park it with keyword-rich classes commented with ads for the latest and greatest in commercial PHP development tools. Just kidding.

So, what are your thoughts on namespaces and naming conventions? Should we be enforcing certain formats for namespace names? Will we ever see Microsoft::Windows::Core::Filesystem::Utils::Defragement, or will namespaces be the final solution to ensuring code can co-exist as the one big happy family that is the PHP ecosystem?

Bookmark It

Hide Sites

The Zend Framework is a fairly standard, (optionally) MVC PHP application framework. It comes with all the usual functionality; request routing, database access, templates (through view files) etc. It also comes with a lot of extra functionality that you might find useful in your application, including some of the best web services libraries available, especially when working with Google’s APIs.

But here’s the kicker: it works entirely standalone. The classes and their methods can, generally, be used statically in any context, or at least independently of the framework. You can use the Zend Framework’s libraries to manipulate dates and times, work with RSS feeds, interact with Google’s Gdata APIs, even generate PDF files (although the functionality isn’t as mature as FPDF).

Fred Wu recently blogged about using Zend Framework with CodeIgniter. It’s a fantastic way to make use of the efforts of all ZF contributors, as well as speed up development significantly. Chances are, if there’s something you’re trying to do in your web application, the Zend Framework can help.

So check it out. It might just make your day.

Bookmark It

Hide Sites