Using Sessions
For each page that requires session data session_start() must be called. This causes PHP to read the users session id and load the data into RAM. Once loaded it is accessible via the $_SESSION super global array. From their you can modify the contents of $_SESSION.

Note: session_start() cannot be called once output has started.  A warning will be displayed and its possible the session could be lost.  If you are seeing the error “Cannot send session cache limiter” check to make sure no output is going to the browser.  A common problem is an unwanted space or tab at the outsize of the PHP tags.

Once you are done with a session you can call session_close() to force the modifications to the session to be saved. This is not required as PHP will automatically do this once the script ends.

The following is a short example of using a session.

1
2
3
4
5
6

<?php
    session_start();
    $_SESSION["hits"] ++;
    echo "You've visited this page " . $_SESSION["hits"] . " time(s).";
    session_close();
?>

Behind the Scenes
PHP makes using sessions easy, but what you don’t see is what its doing behind the scenes. The default PHP installation uses temporary files on the local disk for storing the session contents. When a session is started PHP will read the file which contains the serialized contents of $_SESSION. The data is unserialized and then placed in $_SESSION. When the session is closed, $_SESSION is serialized and stored in the temporary file.

The more unique hits you receive the more session files are created.  Allowing these files to buildup could cause problems on the web server.  It may run out of space, or you could hit the max file limit.  To prevent this from happening for each new session PHP runs a cleanup routine.  All session files that have timed out are removed from disk.

Custom Session Handlers
There is nothing to prevent you from making your own session handling system.  The PHP session handler is only provided as a convenience.  However before you “remake the wheel” you should consider overriding PHP’s session system using session_set_save_handler.  This allows you to override each of the six internal PHP session calls: open, close, read, write, destroy, and garbage collect.  Using this method you can create your own method of handling session data.

PHP’s documentation contains an example of how to use session_set_save_handler() here.

If you would like some more examples leave me a comment with what you would like to see.

Now at first outsourcing may sound like a great idea. Pay others to develop on your product without having to worry about hiring temporary employees. However, as easy as this sounds, there are some things you need to consider before you attempt to outsource your product.

1. Learning curves: Unfortunately, your outsourcer is going to be at a huge disadvantage, they have no experience with your code. It is harder for an outsourcer to reverse engineer your software enough to program new features, mainly because they lack the ability to keep in constant contact with you. It is easier for a temporary employee to learn the code because they have access to your best resource, your developers. This issue is even further complicated if you are using resources outside of your country. It is hard for an outsourced developer to ask questions while your development team sleeps.
2. Language Barriers: When using an outsourcer outside of your country, communication may not only be affected by time differences, but language barriers. Your outsourcer may not be all too familiar with your language. Items may get lost in translation. This becomes a large issue when you discover the outsourced developer’s interpretation of your design or product requirement document is completely different from the wanted feature.
3. Proper Documentation: Most outsourcers have been trained to program an item specifically to the requirements document. Your documentation should cover every detail to help the outsourcer better understand the features you want. This also extends into the realm of your current software documentation. The more documentation you have about your existing code, the easier it will be for an outsourcer to develop and implement his/her assigned tasks.
4. Coding Standards: Are often ignored by an outsourcer. Most outsourced developers are required to program as quickly and efficiently as possible. This can lead to your software coding standards to be overlooked. Even though the functionality has been added to the software, this doesn’t mean that the functionality can be easily extended, or even maintained well.
5. Loyalty: One thing that can’t be purchased is loyalty. To an outsourcer, you are a client. Next week their will be another client. Their loyalty is with the outsourcing company, not the client. Keep this in mind because loyal employees will be more motivated to make the software better, where an outsourcer is just trying to get the job done.
6. Proper Training: Make sure you have the time to properly train the outsourcer, not just in the code, but on the actual software. It will ease development time if the developer knows where certain functionality is in the UI so that it can easily be traced in the code. Without proper training, you are more likely to encounter features that are not fully implemented because the developer didn’t know about another part of the software.
7. Development Environment: Outsourcers may not use the same editing tools and operating systems that you develop with.  This becomes especially important when an outsourcer uses Windows and your team uses Linux.  Line ending differences can cause merge problems in source control systems.  Make sure you can have your outsourcer use the same environments that you develop on.

Even though there can be difficulties in using outsourcers, I don’t feel it is a bad thing. Using an outsourcer can provide an easy gateway to get the help you need fast, especially when its difficult to find unemployed programmers. But, also think, is it better to delay your release to make sure everything is right and as bug free as possible, or get the product out the door by using developers unfamiliar with your software.