When we want some kind of background process running our PHP code, we have a simple challenge: we can’t leave it up to the client. On the web, people hit their stop button, their browsers lock up and they force quit, they even have the odd power outage. When we want to do complex processing on the server side, we need to detach from the client-server model of a web-served script. PHP can fork a script, but the parent script is still facing an unreliable client.

Our best option, then, is to launch a background process from the command line. There are three steps to this: starting the background script, passing it information to do its job, and checking when it’s finished.

Starting the background script
On UNIX systems, we can easily call another PHP script via the shell, set it to run off in the background and send its output to /dev/null. Here’s a sample:

exec ("/usr/bin/php proc.php >/dev/null &");

Here, we call the exec function; instructing it to run our local PHP binary - usually at /usr/bin/php or /usr/local/bin/php, check with your host/sysadmin. We pass it a single argument: the filename of the PHP script that handles our background process. We then send the output to /dev/null, effectively destroying it. The last character, the & symbol, is important - this tells the system to start this process in the background and to let us continue.

Talking to the background process
It’s all very well to start a background process, but now it needs to know what to do. We handle this through command line arguments. Let’s update the previous example:

exec ("/usr/bin/php proc.php --task=50 >/dev/null &");

Our proc.php file might look like this:

<?php
echo "Handling process ".$argv[1];

Running “php proc.php –task=50″ on command line produces the following output:

Handling process --task=50

From here, you can easily design your script to do what it needs to.

Monitoring the background process
There’s just one last detail: how do we monitor the progress of our background process? It’s best to use an independent datastore that can be relied upon, instead of communicating with running threads - your application’s MySQL database would be perfect. You can create a “sessions” or “jobs” table with an ID column, a status column (started, in progress, finished - 0, 1, 2), and any other information you need. Before you start your background process, create a new entry in this table and check the insert ID, then pass it to the background process when you start it:

exec ("/usr/bin/php proc.php --some_info=50 --job=1234 >/dev/null &");

Your proc.php file can then update the table row with the ID you supply it, and your front end applications can provide status updates to end users by checking up on all pending jobs for the current user - relatively straightforward business logic.

If you’re going to be running many background processes, a job queue and an “always-on” script running on your server may also be an option. In this case, consider looking into pcntl_fork() and the program execution functions.

Bookmark It

Hide Sites

The signup validation is the bane of a web application - despite disposable emails more and more common, site owners and sales staff continue to insist on tying an email address to every user. The validation email, a common task for web developers, can quickly take up far more development time than it involves user time. Making the process of building and maintaining email routines as efficient as possible is simple better for everybody.

The challenge is this: an email, once sent, is not actually sent. For example, when PHP’s mail() function returns true, it simply means that the message has been passed on to the system’s mail server and received succesfully. The actual email could be sent many hours later, or never at all.

Fakemail, from the creators of SimpleTest, is a mail server gateway of sorts, in that it replaces your local mail server for momentarily. When an email is sent on the machine, Fakemail will pick it up and divert it to a predictable location on the filesystem.

We can then create reliable email systems in three easy steps:

1. Build a single, common email routine for the application
2. Run the email routine during build tests
3. Check the email was sent

Building a common email routine
This is the single most important factor. As your email routines grow in complexity beyond a single call to a native language API, it’s important that all your email routines use the same final message sending code, if not exactly the same emailing system altogether. For PHP, I recommend the PEAR mailing classes.

Run the email routine during build tests
Use Phing to automate your build process, if only to make sure you run your unit tests every time. Then use SimpleTest or PHPUnit (or even Selenium) to start Fakemail and then run the signup (or similar) routine, causing an email to be sent.

Check the email was sent
Finally, use a unit test or other server-side script to verify that the email was sent: assert that Fakemail created a particular file e.g. templaterecipient@localhost.1 will be created for the first email sent to templaterecipient@localhost.

Fakemail coexists happily with unit testing; in fact, the project website offers sample code for SimpleTest, useful for PHP developers. A similar routine in other web stacks should be fairly trivial to setup; the SimpleTest unit test is barely 20 lines long.

Testing email is not hard, and it can save a lot of stress later. To get started with Fakemail, just check out the extensive tutorial on the project page.

Bookmark It

Hide Sites

Wordpress is a CMS that was built for blogging but many people have repurposed it for magazines, newspapers, blog networks and all sorts of other goodies! But did you know you can hack your Wordpress blog to be a no-cost solution for a social network? Well you can, and here’s fifteen plug-ins that will let you do it.

1. WP-Gravatar
Install WP-Gravatar for adding ‘faces’ to your members and your writers. This plugin lets you use Gravatar, MyBlogLog, OpenAvatar, Wavatar, Identicon, monsterID or Favico.ico files with your comments. Gives you a Widget with your profile info and your gravatar. Let’s you set your own CSS style to use with the Comments section and the author about box.

2. Ajaxed Wordpress
A highly customizable plugin to add AJAX to your blog. AWP uses AJAX to load posts inline, paginate posts, load and submit comments, and more. For that Web 2.0 look and feel.

3. Members Only
A WordPress plugin that allows you to make your WordPress blog only viewable to visitors that are logged in. This is good for protecting your user’s data and your blog content.

4. Profiles
Profiles allows the easy display and management of personal profiles / biographies, or any other similarly periodic information. In particular, it adds a “profiles” tab to the management section and allows you to easily edit information about the profiles as well as associate an image (with optional watermark) with each profile.

5. WP Super Cache
A very fast caching engine for WordPress that produces static html files. When your network does start to receive high levels of traffic, you’ll need this to prevent your site from going down.

6. Post-Plugin Library
Makes calling Similar posts, Recent Posts, Random Posts and Recent Comments easier.

7. Exec PHP
This plug-in is a godsend! It allows you to add PHP markup to wordpress pages and posts. This will give you even greater control over how wordpress looks and acts, allowing you customize with no restriction.

8. Quick SMS
This will allow visitors to send SMS messages to blog owners. It would be ideal for a WordpressMU network as it would allow everyone to stay in constant contact with each other. Could also be hacked to create a “twitter”-like service for all members.

9. UMapper
UMapper plugin is universal mapping platform, which makes it a snap to create engaging maps and add them to your blog posts. Microsoft Virtual Earth, Google Maps, OpenStreet - all are supported by this truly universal (hence the name UMapper - Universal Mapper) plugin.

10. Invite Friends
This plugins main goal was to provide the ability to any of your registered users, to invite more people to the community.

11. NextGen Gallery
Very customizable Gallery option for Wordpress. Turn your blog into a mini ‘Flickr’!

12. Popup Scheduler
If used correctly, a popup is always the best way to achieve great results (be it in sales or subscription rate). It is also the best tool to grab your readers attention. This plugin allow you to customize and schedule a popup to show according to various situation. 1) You can schedule a popup to show a welcome message whenever a new visitor arrives at your site 2) You can schedule a popup to show on the readers returned visit to thank them for reading your blog and invite them to subscribe to your feed/email update. 3) If there is any major changes to your website, you can show a popup to inform your readers of the changes 4) If you are selling products on your blog, you can schedule a popup whenever you have a new product launch 5) During a campaign (such as charity donation drive, blogathon etc), you can schedule a popup to show for a number of days to increase the awareness of the campaign. and many more…

13. SABRE
Sabre is an acronym for Simple Anti Bot Registration Engine. It’s a set of counter measures against spam registration on your blog.

14. Dashboard Editor
This plugin allows you to add whatever you want to the Wordpress dashboard through PHP and HTML even Sidebar Widgets. You can also wipe the entire dashboard or individually remove some of the more irritating sections like the Dev news, Planet Wordpress and the getting started section. This allows for the creation of custom designs for the back end to hide the fact that you’re even using Wordpress!

15. SezWho
SezWho is a distributed context, rating and reputation system for social media sites like blogs, forums, wikis, video/picture sharing sites, discussion boards and anywhere else where people collaborate on the web.

Bookmark It

Hide Sites

We all love web apps, as long as you’re connected they provide cheap, fast and less resource alternatives to desktop solutions. On top of that they store your data in the cloud, a good place for it if your computer ever crashes or is stolen.

My initial observations…

1) It’s Built on Flex/Flash 9
One thing Adobe has got to be proud of is that so far it looks like all the A.viary apps are being built using many of their products like Flex, Flash and Coldfusion. A while back I speculated that Adobe might simply try to buy these guys out rather than compete. If that’s the case, A.viary did themselves a big favor by using an all Adobe back-end.

2) It’s a Little Slow
One thing that’s always been annoying about Flash-based web apps is that the more robust of them take a long time to load. This isn’t a huge concern but it us annoying. They need to figure out a way to bench mark this app so that more of the loading happens while the user is operating the software, not waiting to use it.

3) You can Import Images from the Web
I used to be a big fan of Picnik.com but now that they charge your separately than Flickr does for a Pro Account, not so much. Since I already own Photoshop, I don’t feel the need to pay to be able to do the same things in a web app. That app should be free, even if it needs to run adds to pay for itself. A.viary (for now) is 100% free and overs a bucketload of functionality over Picnik.

4) It rethinks the ‘Work Window’
One flaw in a lot of new design software applications is that they either clone Adobe’s Photoshop or Corel’s Draw. With A.viary things are reminiscent of existing operands but you can tell the designers tried to diversify a bit. In the end the UI feels more like GIMP than Photoshop.

5. Key commands Work
One of the things that makes this suite so useful is that key commands work as if it were truly a desktop app. This definitely decreased the time it took me to get to know the software, and start using it to make something.

6. Filters / Layers / Effects
Nothing new here, if you’ve used Adobe, you’ve used most of these before. There are some unique ones though. What the heck is Kuwahara?

7. Undo is Fast
The system must cache your every step because Undo/Redo seems almost faster than most desktop apps!

8. Saving is Public/Private
Saving your files takes a page out of the book of most web applications by allowing you either to save your files privately or in the public gallery of A.viary users for all to see. You’re also given the option to allow others to edit. This is cool but I wish there were more granular control. For instance if, I wanted my friend Mike to collaborate with me on a design but not the whole world I’d be out of luck.

All in all the A.viary product line looks impressive and is poised to really disrupt the industry!

Bookmark It

Hide Sites

SimpleTest is a PHP unit testing and web testing framework along the lines of JUnit and JWebUnit. It provides a comprehensive set of APIs for testing everything from your class methods to your SSL-secured authentication pages.

Unit testing in PHP generally validates that individual sections of your source code are functioning as expected. As your project grows, it’s hard to remember what each and every module is responsible for, especially with multiple developers. Unit tests help check that a function or method does what it’s meant to, and when run during a build process or around version control commits, can check that recent changes haven’t broken expected functionality.

Let’s look at a simple SimpleTest example:

<?php
define('SIMPLE_TEST', 'simpletest/');
 
require_once(SIMPLE_TEST . 'autorun.php');
require_once('arithmetic_class.php');
 
class TestOfArithmetic extends UnitTestCase {
    function TestOfArithmetic() {
        $this->UnitTestCase('Test of Arithmetic');
    }
 
    function testAddition() {
        $arithmetic = new Arithmetic();
        $result = $arithmetic->add(1,1);
        $this->assertEqual($result, 2);
    }
}
?>

SimpleTest provides PHP classes that serve as the ground work for unit testing. When we define a new unit test case - in this case, “TestOfArithmetic”, SimpleTest automatically works out what tests you’ve defined in order to run them. We then simple create new methods for our tests, run whatever logic we need, and use assert calls to check that we have achieved our expected outcome. In this case, we want to assert that the return value of Arithmetic::add(1, 1) equals 2.

This may seem rather lengthy for a single test, but additional tests can be added on in as little as a single line of code, and an entire application can be quickly checked for reliability with just a few hundred lines of unit tests. Once this is in place, we can run our unit tests by loading up this script in our browser, and if everything is in order, we see a nice and concise status page displaying the results of the tests.

Of course, why write tests after you write your application code, when you could write it sooner and sooner, and maybe even before? That’s the approach of test driven development (TDD) - SimpleTest is perfectly happy with writing tests for code that doesn’t exist yet. TDD, from one of the guys who created Extreme Programming (XP), basically involves writing tests to define the design of code, and then working away at the code till it passes the tests, and SimpleTest is a great way to achieve it in PHP.

SimpleTest is hosted on SourceForge, so head over and try it out. They’ve also got a great tutorial on their main project site.

Bookmark It

Hide Sites

ORM brings data closer to a programming paradigm, where actual information is stored and accessed through interfaces that resemble actual objects. In PHP frameworks, this is typically achieved through the framework providing classes representing database information, that can then be manipulated as actual objects such as a car or a booking. This is almost always a level above actual database operations - when using an ORM layer, writing actual SQL queries is taken care of, although an understanding of how to is always helpful.

Let’s consider a simple database, consisting of users and posts. ORM defines relationships between objects (and in general, also between tables) where an object either has one or has many of another object. For example, a post might have one author, while an author would have many posts. By adding foreign keys to the actual database, and defining these simple relationships (usually hard-coded), an ORM layer can take care of working with related data.

CakePHP’s ORM layer is possibly one of the most used ORM layers of any PHP framework, and is a good example of how a simple ORM implementation should function. In Cake, when an author model is defined as having many posts, any calls to fetch a particular author will automatically fetch all posts related to that author. The entire database logic is taken care of, and instead of thinking in terms of SQL queries, we get to think in terms of actual objects.

Symfony also has quite a nice ORM layer, although the symfony implementation is a little more hands-off, based around database design conventions and it’s YAML schema file approach. But you don’t need to be using a PHP framework to take advantage of ORM; the Doctrine project provides a powerful ORM layer that can be implemented on its own or within an MVC framework. Doctrine also provides an object-oriented SQL-like language to write database queries - the Doctrine Query Language is is great for complex object retrieval. Propel is another popular option, and is actually the ORM layer behind Symfony.

At the end of the day, ORM provides a fundamental advantage over writing raw SQL queries: it’s designed to retrieve information, not record sets. While thinking about data in terms of objects is a major paradigm shift from hands-on PHP scripting, it’s a great way to deal with the challenge of complex databases. So what are you waiting for? Grab a framework or a library, and dive in to the world of ORM.

Bookmark It

Hide Sites

This is an example how to search your blog as a query in Google. But have you ever wanted to learn how to make your own ‘Search Tools’ for Firefox so that you can look-up information on your own blog quickly, from anywhere on the internet? Or do you want to hack Google Custom search to improve your earnings and it’s functionality?

It turns out making a search tool is relatively simple. In fact using this tool, you can make one in about five minutes. The trick is to figure out what a search query on your blog looks like. For Wordpress users, it might look like this:

http://yourblog.com/blog/?s=news&search=Search

This is important because you’ll notice the form asks you for a front of search term and a back of search term. The query itself should be left out so that your users can enter whatever they want. Let’s dissect the search query….

FRONT
http://yourblog.com/blog/?s=

QUERY
news

BACK
&search=Search

Your own search queries may look a bit different than this depending upon the software you use. To get the query preform a search using the GUI and then copy and paste the query from the navigation bar.

If you’re using Google custom search, you’ll notice that the query looks very different. This is because they use identifiers to keep track of revenues earned from custom search. Now, I have no idea if hacking their custom code is a violation of TOS but I’ve done it, it works but since it’s questionable I can’t flat out explain what to do here. Instead, we’ll create one using the Wordpress specific query….

Ready.to then creates the XML file needed to add custom search to your top navigation bar. You can see where it puts the tool below:

Notice that I now have custom search option added to my Firefox Toolbar. That’s great, you’ve got an XML file, however if you upload the file to your blog and link to it, Firefox won’t know to execute the script. To do that you need to add a bit of javascript code to the header of your site and use another custom query for linking.

<script type="text/javascript">
<!--
function addp(csurl) {
try {
window.external.AddSearchProvider(csurl);
} catch (e) {
alert("You need to use Internet Explorer (7.0 or later)
or Firefox (2.0 or later) to install the OpenSearch plug-in.");
}}
//-->
</SCRIPT>

That script tells the browser what to do with the .xml file. Now we need to tell Firefox where to find it, and that it’s an executable and not just a linked file. We do this with the addp request defined in the header script…


<a href="#" onClick="addp("http://developertutorials.com/blog/DevTut.xml");">

This tells the browser that the file is executable, the script tells FireFox what to do with that executable (add it to the toolbar).

That’s it, if everything went well you’ve created a custom search tool for Firefox in about five minutes. You can get the Developer Tutorial Firefox Search Tool here.

Bookmark It

Hide Sites

Image via Wikipedia

Are people getting spoiled?

In the last two years or so, the number of free design ‘instruction’ and resource sites has exploded. Unfortunately, a lot of people seem to think we live in the Matrix, where ideas can just be downloaded into their heads. Well, it’s 2008 and they haven’t invented that technology yet. Until they do we still have to work to come up with new ideas and to learn how to best execute them.

It takes a little bit of time and experimentation to understand design effects, not just how to do them, but why one might use them and when to use one effect versus another. Every good designer has a ‘method to their madness’ and it’s important to try to get into the same headspace as your favorite designer. This means relaxing a bit an realizing that you may not get everything right the first time, or you may spend a few hours Googling around trying to get everything to make sense. Vandelay Design has some good advice:

One of the things that I like about web design is that there’s always plenty to learn, regardless of how experienced you are. I know that my knowledge really only scratches the surface of web design and development, and I appreciate the fact that seemingly unlimited resources are available to allow me to become a better designer.

The design community is filled with sources of inspiration and helpful sites for encouraging growth in abilities. Each of us needs to take our own unique approach to personal development that works for us.

In my post ‘The Tutorial for all Tutorials‘, I listed the rules I try to follow when making good design tutorials. Now I’m going to share advice on how to follow them…

1. Learn Fundamentals
When you’re trying to follow a tutorial about how to turn your little brother into giant Robeast in Photoshop it might help to know what the difference between the burn tool and the shadow tool. Because design tutorials are so common these days, some writers are going to assume a lot about their audience. This means they may not list every single step because they assume some people will be able to follow them regardless. I know this because occasionally I’m guilty of it. No matter what, you simply aren’t the best designer you can be if you don’t at least try learn the basics of your craft. So if you don’t already know, learn what the photoshop tools do.

2. Know when You’re Out of Your League
It never hurts to ask questions. A few people may ridicule you or they may ignore you or they may be a little hard on you. That’s okay because your asking the question didn’t do anything but show your dedication to getting things right. However, rather than emailing the writer directly, why not post your thoughts as a comment? Essentially by reading design tutorial blogs we are crowd sourcing instruction, why not also crowd source support for those tutorials? If you post comments on developertutorials.com or my other blog rest assured, someone will answer them. It also takes the pressure off the tutorial writer because they know they don’t have to answer the same question fifteen times.

3. Reread Before You Give Up
The other day I was having some trouble figuring out Subversion. I was following a tutorial but for some reason at the time everything was coming out greek and I could not figure out the techniques I was trying to learn. I didn’t give up, I didn’t ask questions but somehow I still got everything working. How? I walked away.

The next day I came back and followed the same tutorial word for word and it worked. The only thing that had changed between the first day and the second day was me. I had new perspective and things started to make sense that hadn’t before. I realized I had skipped a few words that turned out to be critical, I had misinterpreted other sections and a few things I was able to guess at. Remember when your people used to tell you to put a study sheet under your pillow the night before an exam? This is because, contrary to popular belief, you still think in your sleep and sometimes the subconscious can solve problems passively without your being aware.

4. You Do Not Suck at Photoshop
No matter what your profession or hobby is, if you aren’t confident about your own prowess, people are less-likely to believe in you. In “Five Point Form: Mastering Professionalism as a Freelance Designer” I talked about this a bit…

Another thing I’ve learned is that most people are completely incapable from recognizing real talent from anything else that might be put in front of them. If they aren’t designers, they don’t think like designers and they don’t really know what makes one designer better than another. Thus, they need to be convinced. I’ve seen people who choose horrible color palettes and layouts make upwards of $10K while people making photoshop designs that are nothing short of brilliant make pennies. The average client is waiting on you to tell them that you’re great, that you know your stuff and to prove it to the best of their understanding. This is why presenting yourself with confidence (not arrogance) is key to getting class “A” projects.

The bottom line is you need to muster up confidence, this will lead to trying new things and making bold creative decisions that can’t be taught. So don’t believe the hype, you do not suck a photoshop!

Ultimately, we all need to be patient with each other. If a tutorial isn’t 100% up to par, don’t try to demean the person who is essentially offering a free service. Make suggestions. A few people have asked me flat out to revisit my posts on how to Design a Wordpress Tutorial from Scratch. They were polite, and brought up valid critiques that made me realize I didn’t cover things as well as I should have. As a result I’ll be revisiting that series later this month.

Bookmark It

Hide Sites

The Selenium project provides a set of tools to handle the testing of web applications. Selenium itself is simply a portable software testing framework, where the tests can be written in HTML or a programming/scripting language. The difference with Selenium is that tests are run directly within a web browser, “just like real users do.”

As a result, Selenium are very much oriented towards client-side results. For example, one of the simplest tests you can run in Selenium is loading a URL and checking if a certain snippet of text is or isn’t on the page. Selenium offers a number of applications built around the same standard, but we’re interested in Selenium IDE, a Firefox extension that allows tests to be developed and run from within Firefox with no additional software installation.

To get started with Selenium, just head over to the addon page to download Selenium IDE. Once you’ve installed it, restart Firefox and find Selenium in your Tools menu. Load it up, and find an application you want to practice on - one of your pet projects, maybe, or a website you frequently visit. Because Selenium runs on top of a standard web browser, it doesn’t care what you test, as long as it has HTML to work with.

The moment you start Selenium IDE, it starts recording commands. Selenium testing is composed of “test suites”, of which you may have one per application. Each suite includes cases, one of which has been created already and helpfully titled “Untitled”, and each cases consists of a series of commands to be executed in succession. When you start navigating around the current page, Selenium IDE will add those navigation procedures to the current test case, so that they can be replayed at a later stage. Start by clicking on a link; you’ll see a “clickAndWait” appear in the table panel of your Selenium window.

To create your Selenium tests, you can simply navigate around your website while recording. Selenium records everything from clicking links to entering data in input fields and submitting forms. To stop recording, hit the red circle in the top-right. At a basic level, this tests that your pages are being served correctly. You can then add in commands within the table - I suggest starting with “verifyTextPresent” to check if a snippet of text is found within the page (expressions allowed).

Once you’re finished, your test window might look something like this:

To run your tests, just hit the green play buttons - you may need to slow down Selenium to wait for pages to load if you’re running tests over the internet. Remember that some of Selenium’s tests are based on the DOM, and will fail if the DOM hasn’t loaded yet even if the application is running fine.

To save your tests to run them later, just use the File menu. In future posts, we’ll look at more complex use of Selenium and the multitude of custom commands available. In the meantime, why not subscribe to our RSS feed?

Bookmark It

Hide Sites

PHP 5 supports most of the legacy syntax features of PHP 4. Most code written for PHP 4 should function fine under PHP 5, and a comprehensive test suite could check this. However, many of the backwards-incompatible changes in PHP 5 were in regard to language quirks, and quite a few hacks rely on these in order to function. Here are some issues to watch out for:

• Class names provided by language features - get_class(), get_parent_class() and get_class_methods() now return the name of the classes/methods exactly as declared; earlier, they were lowercased first
• The new object model is quite different - an empty object is no longer considered “empty” by empty(), among other changes
• Files with functions cannot be included twice; PHP 5 throws an error as the function is being redeclared
• Illegal uses of string offsets (e.g. $somestring[0]) will throw an error
• On Windows servers, the include/require_once functions are case insensitive - “SomeFile.php” and “somefile.php” will only be included once

Legacy applications making use of the CLI, especially under Windows, should be aware of the new names for binaries. The CGI binary has been renamed to php-cgi (previously php), while the CLI binary has been moved back into the main directory as php. Other applications calling PHP scripts may also want to look at php-win on Windows, which serves the same function as the CLI except without the black “DOS box”.

Finally, there are some new reserved keywords. If you are upgrading straight to PHP 5.3, watch out for the new namespace keywords, including “namespace”, “use” and __NAMESPACE__. The new OOP features introduce quite a few keywords popular in enterprise applications - “public”, “private”, “protected”, “clone”, “try” and “this” come to mind (more available here). Error checking every file (run “php -l /path/to/file.php”) can pick these up fair quickly.

PHP 4 has been discontinued for some time; indeed, the latest release, 4.4.8, is from early January. Major legacy applications should be ported as quickly as possible to avoid security issues; existing code should be thoroughly checked for syntax and language feature changes as well. The PHP manual has some handy documentation on migrating, and the PHP 5 features are clearly noted all around the manual - check the revision history of functions as well.

Bookmark It

Hide Sites