For example, here is the bug that I have encountered in a server using CentOS:

$big_integer = 1202400000;
echo $big_integer; //outputs 1.2024E+09

$sample_float = (float)100000; //float
echo $sample_float; //outputs 1E+05

As you can see, PHP will automatically convert these types of integers into scientific notation. At first, I though it was simply a case of integer overflow with 32 bit systems, or a misconfiguration in float precision. However, I’ve noticed that this bug will only apply to large integers or floats with a lot of zeros at the end. Apparently, when PHP encounters a number that exceeds the upper limit of 2,147,483,647 for an integer, it automatically converts the number’s type from integer into a double.

Through searching PHP’s bug archives, its seems that I am not alone. Apparently this bug has been documented in the recent versions and is most notable with systems running under CentOS.

So how do we fix this error? Fortunately, we can format these numbers in scientific notation back to their standard integer form using the number_format() function. Here is how to do it:

$big_integer = 1202400000;
$formatted_int = number_format($big_integer, 0, '.', '');
echo $formatted_int; //outputs 1202400000 as expected

$sample_float = (float)100000 //float;
$formatted_float = number_format($sample_float, 2, '.', '');
echo $formatted_float; //outputs 100000.00 as expected

Hope this helps anybody who is experiencing the same problems.

Ever wondered how auto-saving is done? Basically, it is just a simple AJAX script running in the background at set intervals to save the data you are currently working on. Here is a simple tutorial on how to implement auto-saving using jQuery

Before we start, the article assumed the following:

• Basic knowledge of jQuery
• Basic knowledge of PHP

For the articles database, we will only use 4 rows for our table named articles:

• id – this will serve as the primary index for the table; auto-increment
• title – this will contain the title of the article
• content – this will contain the body of the article itself
• timestamp – this will contain the timestamp when the row was last inserted or updated

Let us first start with the form and call it add_article.php for this tutorial. Before we render our form, we must first create a blank instance of a row. The purpose of this is two-fold. One, so that we can generate an article id, and secondly that we cannot really update a non-existent row. There is a more efficient way of implementing this logic without generating a blank row every time, however, for the sake of simplicity and explaining the point of concept for this tutorial, we will skip this part.

add_article.php

//create new article on database
mysql_query("INSERT INTO `articles`(title, content) VALUES('', '')");
$article_id = mysql_insert_id();

The next step is making the form. First, we would create a form element that would to save the article to a standard save page. Lets call it save.php.

Remember the article_id generated in making the blank row? Now we must output it as a hidden input for the article_id associated with the article. We would also need an input text field for the title and a text area for the content. Finally we would need a submit button, and a placeholder container for the “Last saved” timestamp.

add_article.php

<form id="article_form" method="post" action="save.php">

Title:<br />
<input type="text" name="title" id="txt_title" /><br />
Content:<br />
<textarea name="content" id="txt_content" ></textarea><br />
<input type="hidden" name="article_id"
value="<?php echo $article_id ?>" />

<input type="submit" value="Save"/><br />

</form>
<div id="timestamp"></div>

Now for our AJAX back end, we must create a script that will perform the update from the AJAX request that came from add_article.php. Let us call this script autosave.php. In return, the script must output the timestamp when the article was last updated

autosave.php

$title = mysql_real_escape_string($_POST['title']);
$content = mysql_real_escape_string($_POST['content']);
$id = (int)$_POST['article_id'];

//save contents to database
mysql_query("UPDATE `articles`
    SET title = '$title', content = '$content' WHERE id = '$id'");

//get timestamp
$result = mysql_query("SELECT timestamp FROM `articles`
    WHERE id = $id");
$timestamp = mysql_result($result, 0);

//output timestamp
echo 'Last Saved: ', $timestamp;

And finally to tie it all up, we must now create the autosave script in jQuery on add_article.php. First of all, in creating our autosave() function, we will need to create a setTimeout loop that will call itself recursively. For this tutorial, the interval between auto-saving is 20 seconds

add_article.php

function autosave()
{
	var t = setTimeout("autosave()", 20000);
}

And finally, to finish it all up, we must send an AJAX request to our back end autosave.php. Of course, we mustn’t forget to pass the $article_id we generated earlier. Also, auto-saving must only proceed when both title and contents are not empty.

And lastly, when the AJAX request has been successfully processed, we will pass its value to our timestamp container.

add_article.php

function autosave()
{
	var t = setTimeout("autosave()", 20000);

	var title = $("#txt_title").val();
	var content = $("#txt_content").val();

	if (title.length > 0 || content.length > 0)
	{
		$.ajax(
		{
			type: "POST",
			url: "autosave.php",
			data: "article_id=" + <?php echo $article_id ?>
+ "&title=" + title + "&content=" + content,
			cache: false,
			success: function(message)
			{
				$("#timestamp").empty().append(message);
			}
		});
	}
}

Finally, it is just a matter of starting the auto-saving feature when the DOM is ready:

add_article.php

$(document).ready(function(){
	autosave();
});

Working demo of the tutorial and the download links can be found below:

View jQuery Auto-save Demo
Download Source Codes

Assuming we have an XML string assigned to $xml_string

$xml_string='<?xml version="1.0" encoding="utf-8"?>
<a>
	<b>
		<c>
			<d>
				<e>Hello World</e>
			</d>
		</c>
	</b>
</a>';

$xml = new SimpleXMLElement($xml_string);

Here is how it was done before 5.2.0 to access the <e> element

echo $xml->b->c->d->e[0]; //prints Hello World

Now with the new SimpleXMLElement->xpath() function, here is how it is done:

$result = $xml->xpath('//e');
echo $result[0]; //prints Hello World

However, being a new function, it comes with its own bugs and quirks. As for the timebeing, SimpleXMLElement->xpath() function doesn’t support default namespaces and will not be able to perform an XPath search on those types of documents.

The only thing that can be done right now is a simple workaround by removing the namespace attribute, or changing the namespace tag to preserve the namespace. Here is how it is done:

$xml_string='<?xml version="1.0" encoding="utf-8"?>
<a xmlns="http://www.opentravel.org/OTA/2003/05">
	<b>
		<c>
			<d>
				<e>Hello World</e>
			</d>
		</c>
	</b>
</a>';

$processed_string = str_replace("xmlns=", "ns=", $xml_string);
$xml = new SimpleXMLElement($processed_string);
$result = $xml->xpath('//e');
echo $result[0]; //prints Hello World as expected

$name = mysql_real_escape_string(strip_tags($name));
$email = mysql_real_escape_string(strip_tags($email));
$address = mysql_real_escape_string(strip_tags($address));

Even if you created a function to make coding easier, it can still be a little bit tedious:

function escape_mysql($string)
{
	return mysql_real_escape_string(strip_tags($string));
}

$name = escape_mysql($name);
$email = escape_mysql($email);
$address = escape_mysql($address);

I’ll demonstrate a simple technique to make your life easier by using PHP’s references. By passing variables by reference, we can get rid of the variable assignment on the function’s return value. Here is how if should look like in the end:

function escape_mysql(&$string)
{
	$string = mysql_real_escape_string(strip_tags($string));
}

escape_mysql($name);
escape_mysql($email);
escape_mysql($address);

By passing variables by reference in our escape_mysql() function, the variable assignment no longer becomes necessary since the function will do it instead. Now that is a lot more easier to code and understand isn’t it?

Lighttpd or “Lighty” is a lightweight webserver made with speed and load balancing in mind, Unlike Apache which comes with a lot of modules that consumes a lot of server resources. One of the features of Lighttpd is that it is an event-driven web server. It uses select/poll/epoll/kqueue from a single process/thread.

Now for the Pros and Cons:

Pros:

Cons:

Given these Pros and Cons, its really hard to decide when to do a switch to Lighty. But as a basic rule, for server only serving mostly static content, Lighty is the better choice since it lesser overhead than Apache. Youtube’s video servers which serves static content runs on Lighty.

However, if you are on the fringe case wherein you need Apache’s functionality, but lacking on server resources, and an upgrade is not a viable option, there is some good news for you. Lighttpd can be run behind Apache via Apache’s proxy module. Instructions on doing this can be found on this article:

Running Lighttpd through Apache’s proxy module

So what does this basically mean? In short, we can let Apache handle the dynamic content, while we let Lighty handle the static content from a server.

Related links:

It turns out that using $_SERVER['PHP_SELF'] is quite unsafe due to an XSS exploit. What the PHP_SELF variable does is basically return the filename of the executing script. Consider this simple form:

http://test.com/form.php

<form method="POST" action="<?php echo $_SERVER['PHP_SELF']; ?>">
   <input type="text" name="username" />
   <input type="submit" value="Submit" />
</form>

If you think that this form is safe, you are mistaken. If someone inputs this URL:
http://test.com/form.php”><script>alert(‘XSS’)</script><”

The form’s output will now look like this:

<form method="POST" action="form.php">
<script>alert('XSS')</script><"">
   <input type="text" name="username" />
   <input type="submit" value="Submit" />
</form>

To prevent this type of attack here are some things you can do:

1. minimize the use of $_SERVER['PHP_SELF']
If you know the target of the form action beforehand, don’t be lazy to rely on PHP_SELF.

2. use an HTML filter
If using PHP_SELF is unavoidable, the next thing you can do is use an entity filter. You can use either PHP’s htmlentities() or htmlspecialchars(). Or even better, you can even try to do strip_tags() beforehand:

<form method="POST" action="<?php
echo htmlspecialchars(strip_tags($_SERVER['PHP_SELF']), ENT_QUOTES);
?>">
   <input type="text" name="username" />
   <input type="submit" value="Submit" />
</form>

The first step we need to do is create our form which will pass a multi-valued parameter. For example, a checkbox list or a multiple-select list. For our example, we shall use a checkbox list. Here is what it would look like:

Which text editor do you use?<br />
	<form method="post" action="process_input.php">
	  <input type="checkbox" name="editor[]" value="Notepad" />
	  Notepad<br />
	  <input type="checkbox" name="editor[]" value="Scite" />
	  Scite<br />
	  <input type="checkbox" name="editor[]" value="Crimson Editor" />
	  Crimson Editor<br />
	  <input type="checkbox" name="editor[]" value="Dreamweaver" />
	  Dreamweaver<br />
	  <input type="checkbox" name="editor[]" value="vim" />
	  vim<br />
	  <input type="submit" value="submit" />
	</form>

There are basically 3 simple rules in passing input arrays from forms:
1. All inputs should be inside a valid <form> element
2. All members of the same input array should have the same input name.
3. The input names should have an opening and closing bracket([]) to denote that the input being passed is an array

Now that we have passed the form as an input array, how do we process it in PHP? Depending on the method used on the form (POST or GET), we can use one of three predefined variables to extract the value of these inputs. And they are:

1. $_POST – variable used to extract the values of inputs passed through the POST method
2. $_GET – variable used to extract the values of inputs passed through the GET method
3. $_REQUEST – variable used to extract the values of inputs passed either through the POST, GET, or cookies. This is not recommended for serious use due to security implications

In our case, since we have used the POST method, we need to access the $_POST variable to retrieve the data we sent from the form. In our example, $_POST["editor"] will contain the array of values that have been selected from the form. We could then simply use a foreach statement to find all the values that were selected. Here is how the code will look like without any form validation being done:

foreach($_POST["editor"] as $editor)
	{
		echo $editor . "";
	}

However, with a few validations for checking NULL values, here is what the code would end up like:

if (isset($_POST["editor"]) && is_array($_POST["editor"])
&& count($_POST["editor"]) > 0)
{
	foreach ($_POST["editor"] as $editor)
		{
			echo htmlspecialchars($editor, ENT_QUOTES);
			echo '<br />';
		}
}

Special thanks to Tim for the suggestion.

PHP Input Arrays Demo
Download Demo Source Code

This will cause a major impact in the current server set-up being used today. Currently, a majority of hosting companies and servers still uses PHP 4 installed by default. Will this cause a shift in the hosting companies to migrate to PHP 5? This year is going to be a turning point for web scripting languages. This will be the perfect opportunity for other scripting languages such as Python and Ruby to finally catch up. Will the balance of power finally shift? Only time will tell

For this article, you need at least basic knowledge of jQuery and the use of the jQuery Form plug-in.

We will no longer be tackling the basics of using the form plug-in, but you can review it here

To implement a preloader image using the form plug-in, we must first define our preloader image, and give it a corresponding #id so we can refer to our preloader image later on:

<img src="preloader.gif" id="preloader" />

take note that in our tutorial, we are merely using an image. You can also substitute the image with a <div>.

When our form page loads, we must hide the preloader image.:

		$(document).ready(function()
		{
			$("#preloader").hide();
		});

Now here is where the magic happens. The ajaxForm options contains a beforeSubmit and success parameter.

beforeSubmit – defines the pre-submit callback function. In short, it defines what function will be called before the form is submitted
success – defines the post-submit callback function. In short, it defines what function will be called after the form has been successfully processed

What we basically want to do now, is to show the preloader image when the form is still being processed, but hide it once our form has been successfully processed. Here is how to do it:

		$(document).ready(function()
		{
			$('#prog_form').ajaxForm({
					target: 		'#content',
					beforeSubmit: 	showPreloader,
					success: 		hidePreloader
			});	

			$("#preloader").hide();
		});

		function showPreloader()
		{
			$("#preloader").show();
		}

		function hidePreloader()
		{
			$("#preloader").hide();
		}

What happens here is that our pre-submit callback showPreloader makes the preloader image visible, while our post-submit callback hidePreloader exactly does the opposite.

Demo of this tutorial
Download source code

• jQuery
• Form Plugin
• Interface Plugin

In this tutorial, I’ll be making a save preferences form as an example

First of all, we need to have our save settings form. Lets label it as #layer1_form (id = “layer1_form”) :

<form id="layer1_form" method="post" action="save_settings.php">
	Display Settings<br />
	<input type="radio" name="display" checked="checked"
value="Default" />
	Default<br />
	<input type="radio" name="display" value="Option A" />
	Option A<br />
	<input type="radio" name="display" value="Option B" />
	Option B<br /><br />
	Autosave settings<br />
	<input type="radio" name="autosave" checked="checked"
value="Enabled" />
	Enabled<br />
	<input type="radio" name="autosave" value="Disabled" />
	Disabled<br /><br />

	<input type="submit" name="submit" value="Save" />
</form>

basically in our sample, we have 2 settings for the display and auto-save settings. However, since we need show this form in a floating dialog, we must wrap this form on a floating layer. Let’s call this floating layer #layer1 (id = “layer1″).

We also need to define a handle where our window can be clicked to be dragged for our interface plugin. We’ll call our handle #layer1_handle (id = “layer1_handle”).

As with any floating dialogs, we also need a close button. For simplicity, I’ll just use a link named #close (id = “close”). You can also use buttons or images if you want.

Here is what our form would look like:

<div id="layer1">
	<div id="layer1_handle">
			<a href="#" id="close">[ x ]</a>
			Preferences
	</div>
	<div id="layer1_content">
		<form id="layer1_form" method="post" action="save_settings.php">
			Display Settings<br />
			<input type="radio" name="display" checked="checked"
value="Default" />
			Default<br />
			<input type="radio" name="display" value="Option A" />
			Option A<br />
			<input type="radio" name="display" value="Option B" />
			Option B<br /><br />
			Autosave settings<br />
			<input type="radio" name="autosave" checked="checked"
value="Enabled" />
			Enabled<br />
			<input type="radio" name="autosave" value="Disabled" />
			Disabled<br /><br />

			<input type="submit" name="submit" value="Save" />
		</form>
	</div>
</div>

For our backend, we’ll simply print out the options that were selected on the form for simplicity. We’ll call our backend save_settings.php

save_settings.php

<b>Preferences:</b><br />
Display Setting:
<?php echo htmlspecialchars($_POST['display'], ENT_QUOTES); ?><br />
Autosave Setting:
<?php echo htmlspecialchars($_POST['autosave'], ENT_QUOTES); ?><br />

Now that we have defined our form and our backend, the next step will me indicating where we would output the AJAX response. Let’s create a new container called #content. It will contain the button for setting the preferences and will be replaced by the AJAX response when the form action is successful:

<div id="content"><input type="button" id="preferences"
value="Edit Preferences" /></div>

Now that we have defined our form, its time to implement the jQuery functions. First of all, we need to import the libraries by defining the javascript libraries within the <head> of our document:

<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="interface.js"></script>
<script type="text/javascript" src="jquery.form.js"></script>

To load our functions after the DOM has rendered, we must declare the jQuery functions under $(document).ready function of our script inside the <body> of our document:

<script type="text/javascript">
	$(document).ready(function()
	{
		//jQuery events go here
	}
<script>

Now lets define the #layer1 wrapper of our form as a draggable window with a z-index of 20, and an opacity of 0.7 when being dragged:

$('#layer1').Draggable(
		{
			zIndex:	20,
			ghosting:false,
			opacity: 0.7,
			handle:	'#layer1_handle'
		}
	);

and to hide the floating window, we just hide the wrapper, in our case, we need to hide #layer1:

$("#layer1").hide();

and to display our floating dialog when the edit preferences button is clicked:

$('#preferences').click(function()
{
	$("#layer1").show();
});

and to hide the form once again when #close is clicked

$('#close').click(function()
{
	$("#layer1").hide();
});

And finally to define our form as an AJAX form, we need to define #content as the target container where the AJAX response will show. We also need to automatically close the floating dialog window on success:

$('#layer1_form').ajaxForm({
	target: '#content',
	success: function()
	{
		$("#layer1").hide();
	}
});

To view the working demo of this tutorial, just click on the links below

• Full Demo of this tutorial
• Download Source Code
• Alternate tutorial using jqModal

It has been hard-wired to almost every PHP programmer, that when passing arrays or objects to functions, they must be passed by reference, not by value so that the function will not work on the copy, hence improving performance.

Here is the sample code in PHP 4 that most programmers have been taught with regards to references

function foo(&$variable_array)
{
     shuffle($variable_array);
     return $variable_array;
}

$bar = array(1, 2, 3, 4, 5);
foo($bar); //returns a shuffled array

It sounds logical to always use references when passing large and complex variables such as arrays and objects. In this sample code, if we were to pass the array by value, PHP will automatically create a copy of the variable since we modified its contents. However this isn’t usually the case. Take a look at this scenario:

function foo(&$variable_array)
{
     echo $variable_array[0];
}

$bar = array(1, 2, 3, 4, 5);
foo($bar); //prints 1

In this code, we didn’t modify the array’s value at all. If we were to just pass the array by value, PHP will not make a copy of the array since we didn’t have any changes to the variable itself. So instead of speeding up performance, we added an unnecessary step of adding a reference to a variable.

To put is shortly, references should only be used when the variables passed are complex like arrays, objects, and resources and only if the variable is going to me modified inside the function. Otherwise, just use the regular pass by value method.

It is a good thing that thinking about when to use references was significantly made easier in PHP 5, where everything is passed by reference by default.

The calc now supports additional options namely:

The only thing missing for the calc are the additional options for buffs like Blessing, and Impositio Manus. And also the final addition will be the monster data, which I will do once I have some extra slacking time

05/12/2007 – Added effect of DEX to min / max ATK values
05/12/2007 – Added GC damage computation for Bow type weapons
05/16/2007 – Added the effects of Picky Card and “The Sign” accessory as options
05/22/2007 – Added DEF / MDEF reductions to equation

As an added bonus, here are some words on wisdom in family planning:

In light of the recent changes in Google’s SERP algorithm, it seems that a lot of sites have been pushed from the main index into the so called Google Hell. Unless you have garnered enough credibility through high quality backlinks/inbound links, more often than not, your page would be pushed there.

So why is this happening? It seems that features on WordPress that improve usability for users are seen by the googlebots as SPAM. The main culprit? The duplication of content. So how do we solve this? We leave the usability features for the users, but deny access to them from the googlebot. Here are some tips on how to do that:

1. Never put a post in more than one category

This is the simplest way to avoid the googlebot from seeing duplicate content whenever they crawl your category pages. However, this method greatly diminishes the usability of your blog. Which then brings us to our second tip:

2. Block googlebot from your category pages

If duplication of content is unavoidable due to your category pages, then the next step would be making your category pages available for your users, but not for the googlebot. This can be done by editing your robots.txt in the root of your webserver. Below is a sample robots.txt file to exclude the googlebot from tour category pages:

User-agent: *
Allow:

User-agent: *
Disallow: /category/

However, this method will highly depend on how your permalink structure is optimized in wordpress.

3. Block googlebot from your archive pages

Another major culprit on being indexed to the supplemental results is none other than your monthly archives. Just like the case with your categories, more often than not, the content of your front page will be almost exactly the same as the archives for the current month! A major penalty for google. If your archives and category settings cannot be blocked sufficiently by using robots.txt. There is another method, editing the wordpress codes themselves.

Make the links to your archive links have the rel=”nofollow” attribute to prevent it from being crawled. This can be done my modifying the /wp-includes/general-template.php file. Here is how to do it:

Find this code (line 298 in v2.1.3):

elseif ('html' == $format)
     return "\t<li>$before<a href='$url'
title='$title_text'>$text</a>$after</li>\n";
else // custom
     return "\t$before<a href='$url'
title='$title_text'>$text</a>$after\n";

replace with:

elseif ('html' == $format)
     return "\t<li>$before<a href='$url'
title='$title_text rel='nofollow'>$text</a>$after</li>\n";
else // custom
     return "\t$before<a href='$url'
title='$title_text' rel='nofollow'>$text</a>$after\n";

4. Assign a unique meta description for each post

Using the Another WordPress Meta Plugin, you can assign unique meta description for each of your pages. This will help differentiate the articles from your wordpress index page, from the individual posts page themselves.

5. UPDATE: There is already a WordPress Plugin available

It seems that someone else has already figured out this problem before I did and even made a wordpress plugin for it. It works by making the headers of your category and archives files have the noindex attribute. You can download the plugin here [seologs.com]

I hope that these tips have helped you in avoiding the depths of Google hell.