In strict languages like C/C++ or Java, you can’t return a boolean in an integer function and so on. PHP gives the coder this “freedom” (that I interpret as “room for mistakes and laziness”).

You can go a little tidier when using type strict languages returning 0 or -1 (thus needing a signed int return type).

Exceptions are handled in a different way (will explain further) and you won’t need anymore to chunk your funky error codes/messages into your return codes.

NOTE: All the examples are in PHP and functions are merely illustrative.

Using PHP’s trigger_error

This function can help you to standardize your errors with PHP’s native errors like notices and fatal errors. I used this for long time attached to an error handler class. This worked out most for system errors and notices like “unable to open file” and such but they mostly were treated by issuing fatal errors and forcing user to a custom-built Error 500 – Internal Server Error page (in case of web code) or exiting to system with a custom error code.

Testing with if/else

As mentioned above, I started handling errors with false-ing and null’ing the return of functions and checking them for that. Example:

function find_id_by_name($name) {
 
	$query = "SELECT id FROM users WHERE name = '{$name}'";
 
	$result = mysql_query($query);
 
	if (mysql_num_rows($result) == 0)
		return false;
	else
		return mysql_result($result, 0);
 
} // end :: function :: find_id_by_name

And then checked when calling:

if ($id = find_id_by_name("John Doe")):
	# do stuff
else:
	# print some message on screen
endif;

NOTE: Returning zero (0) would trigger a false condition too.

Although this works pretty well it has several problems:

Obtrusion

If the checking code block prints messages on screen directly with print or echo it will be obtrusive for other functions calling it.

Multiple fail points

If a function can fail many ways, if you take the false/null approach you will know only that the function has failed but will have to insert debugging checkpoints on the function to know where it failed exactly.

Returning error codes may aid this point but cannot be used in integer functions because it would mix up with valid return entries and would still hurt our return type integrity.

Return Codes

As mentioned above, one could return integer error codes in order to identify the type of error that occurred. Although is a great leap in front of the null/false initiative.

define('ERROR_NO_USER',1);
define('ERROR_INVALID_PASSWORD',2);
 
function auth_user($username, $password) {
 
	$user = find_user($username);
 
	if (!$user)
		return ERROR_NO_USER;
 
	if ($user->password !== hash_function($password))
		return ERROR_INVALID_PASSWORD
 
	return $user;
 
} // end :: function :: auth_user

Note that this function returns an Object while it returns integers on failure.

To check if user has successfully authed, we would use something like:

if (is_numeric($user = auth_user("jdoe", "passw0rd")))
	# hmmm... error occurred!
else:
	$_SESSION['user'] = $user;
endif;

But this still doesn’t seems right, and you still have to cluch a switch statement inside the error treating area to take actions depending on error code.

Returning error codes in functions with integer return type

In functions with integer return type you can’t return positive error codes because it would be confused with valid non-error entries unless you used negatively signed integers for that.

function find_id_by_name($name) {
 
	# ... some code to get user data ...

	# User entry exists?
	if (!$user)
		return -1;
 
	# User account is inactive?
	if ($user->isInactive())
		return -2;
 
	return $user->id;
 
} // end :: function :: find_id_by_name

Signaling failures in a return-safe manner

You can always use a identifier of the same return type to illustrate failures. This technique can only be used to signalize entire function failure and does not gives you the fine grained error control that try gives.

Integer return types

Procedural languages like C has done this forever. In integer returned functions you can return -1 to signalize function failure.

function find_id_by_name($name) {
 
	# ... some code

	if ($ids)
		return $id;
	else
		return -1;
 
} // end :: function :: find_id_by_name

Returning empty lists

When dealing with function that returns lists (lists/arrays, dictionaries and such) you can also use an empty list in return signaling that no entries are found. This persists the function return-type and will flow naturally if parent function uses the returned value into a foreach or for statement.

function find_users_by_country($country_id) {
 
	# ... some code

	if ($users)
		return $users;
	else
		return array();
 
} // end :: function :: find_users_by_country

Using Try/Catch and Exceptions

One of the greatest practices I learned in my life as a developer was to introduce the power of try/catch into my code. This long-known practice by Java users was introduced in PHP version 5 and I think it’s present in almost every OOP^w implementation like Java, PHP5, C++, Python and even in Flash AS3 (since its inherited from Java structure).

It gives you the ability to raise real-time errors during execution without the need to interfere within your returns. It helps you keeping your functions returning only data its expecting.

Try/Catch overview

The try block surrounds a set of statements that must “not throw an exception” to proceed. If any of the inner statements throws any exception, function execution proceeds but its routed to the catch block corresponding to the kind of exception that was raised.

But hell, what are exceptions?

As corrected by SeanJA from SquirrelHacker Exceptions are the Object-oriented form special errors that aren’t expected in the flow.

Exception are good to distinguish errors from each other from their class type. Exceptions can also have custom properties and methods for each type. You just have to define them in your exception class. They also extends a main Exception class with methods generally available to all classes such as the getMessage method in PHP.

In most implementation, exception classes often receives a custom message as first parameter that would be read later on by the corresponding getMessage method.

Example:

try {
	do_something();
	do_other_thing();
 
} catch (Exception $e) {
 
	print $e->getMessage();
 
} // end :: try

Throwing exceptions (errors)

Inside your function you can use the throw statement to generate exceptions that will be caught in the catch block of the caller function. Lets rewrite our function used in the early example with exceptions.

function find_id_by_name($name) {
 
	# ... some code to get user data ...

	# Connection is up?
	if (!$this->conn)
		throw new Exception("Connection was dropped.");
 
	return $user->id;
 
} // end :: function :: find_id_by_name

Custom-built exceptions

Working with generic exceptions is already very useful but it stills give you few control about the type of error generated. Generic exceptions are good if you will only catch and forward the error messages or if your error handling is independent of the error type.

You can easily generate custom exceptions by extending the main Exception class (varies according to the language). In PHP, this is the Exception class.

class FileLockedException extends Exception {
} // end :: class :: FileLockedException

That’s it, if you don’t need no additional methods or proprieties, you’re done! You may successful use your new exceptions while treating errors with catch. If you need it, just treat your Exception class as any normal OOP class.

class FileLockedException extends Exception {
 
	public $timestamp;
 
} // end :: class :: FileLockedException
 
some_function() {
 
	$ex = new FileLockedException();
	$ex->timestamp = date("Y-m-d H:i:s");
 
	throw $ex;
 
} // end :: function :: some_function

Catching exceptions

As seen on the example on try/catch overview, catching just requires a catch statement for the corresponding Exception class. All exceptions that doesn’t have an catch statement for its own class type will fall back to the main exception class.

try {
 
	do_something();
	do_other_thing();
 
} catch (FileLockedException $e) {
	print "Cannot open file for writing, locked!";
 
} catch (Exception $e) {
 
	print $e->getMessage();
 
} // end :: try

Rethrow, bubbling up exceptions

Exceptions can be bubbled up by rethrowing with a throw statement under a catch block. This is used to delegate the control of parsing the error to a parent function and to force triggering the catch blocks on them.

function do_something() {
 
	try {
 
		do_stuff();
 
	} catch (Exception $e) {
 
		throw $e;
 
	} // end :: try
 
} // end :: function :: do_something
 
function do_stuff() {
 
	if ($somethingWentWrong)
		throw new Exception("Something went wrong!");
 
} // end :: function :: do_stuff

Overhead & Overkill or When to use exceptions?

SeanJA wrote an excellent article about that clarifing some points (thanks SeanJA!).

To differ errors from exceptions, you need to point out if what you are returning is expected or not. You can achieve this by focusing on the purpose of your function.

To keep up with previous examples, lets assume our login function. Which is its purpose? The function is asked “This user credentials are valid?” and it expects “Yes” or “No”.

Credentials are a tuple of username and password so if one of these are wrong, your function should naturally return false because one of them are wrong, but that is expected.

Unexpected data is something that is beyond your control, like a locked file, a database timeout and such. Check out SeanJA if you need more clarification on this subject.

Once I got in love with Exceptions I can’t live without it. It gets you even more in depth within OOP, and I’m satisfied with it.

Treat your errors well and they will not betray you late in the nite!

No related posts.

Wordpress^w‘s excellent plugin infrastructure with their hooks and actions provides us a beautiful and clean form of including our JavaScript in specific pages.

In this tutorial, we will be using three WordPress functions: get_post_meta() and wp_enqueue_script() and wp_enqueue_style().

Custom Fields

Well, you may have noticed that get_post_meta() is about the custom fields and you’re just right.

We’ll be using posts and pages custom field to add scripts and stylesheet files. I’m using the keys ‘js’ and ‘css’ to JavaScript and CSS files respectively.

If you don’t know how to use custom fields, please visit the WordPress documentation on Custom Fields.

The documentation on these functions are available at WordPress documentation site:

get_post_meta

http://codex.wordpress.org/Function_Reference/get_post_meta

wp_enqueue_style

http://codex.wordpress.org/Function_Reference/wp_enqueue_style

wp_enqueue_script

http://codex.wordpress.org/Function_Reference/wp_enqueue_script

get_post_meta

This function is responsible by getting our custom field entries and returning them as an array.
If one or more entries are found, the array is returned with normal indexes (0..1…) and with the custom field values. If no entries are found, an empty array is returned.

Well, our return type will be always array so foreach will fit perfectly even on an empty set.

header.php file

All code described in the following examples must be placed at least one line before the wp_head() function in your header.php file. if your header.php file is missing a wp_head() call, it shouldn’t. wp_head() function does lots of important things and many plugins use it. Please consider adding it to your code.

wp_enqueue_script and wp_enqueue_style

Some plugin developers may be not aware of these beautiful functions or even how scripts and stylesheets are managed by WordPress.

All scripts and style, when properly set, are enqueued and inserted automatically when wp_head() is called. Enqueuing your scripts and style are a better way other than just hooking wp_head() and printing to the output buffer.

This assures that our scripts and styles will be included only at the wp_head() call and will not be printed out from nowhere messing out peoples templates and plugins.

NOTE: Due the printing menace of script tags and JavaScript code chunks, WP-Minify parses the ENTIRE site output in order to properly minify them.

This technique also prevents overlapping includes of twicely defined entries.

Wordpress gives us respectively wp_enqueue_script and wp_enqueue_style for enqueueing scripts and stylesheets. Both functions receive a script or stylesheet unique identifier as the first parameter and the path as second (more parameters are available, please refer to the documentation for more understanding on this subject).

As this is an automated process, I’m using as unique identifier the md5 hash of the file’s path (the custom field value).

NOTE: This solution is made for JavaScript and CSS files that follows a unique parent directory. Please refer to the examples for more explanation.

So let’s get back to our header.php file just before the wp_head() call that we mentioned before. We also remember that the custom field key for JavaScript files that we’ll be using in this example is ‘js’.

JavaScript files

The following code will use get_post_meta to get the array (empty or not) of JavaScript files that have been set through custom fields under the js folder under our template directory.

foreach($js = get_post_meta($post->ID,'js') as $jscript) wp_enqueue_script(md5($jscript),get_bloginfo('template_directory').'/js/'.$jscript);

CSS files

The following code will use get_post_meta to get the array (empty or not) of CSS files that have been set through custom fields under the css folder under our template directory.

foreach($css = get_post_meta($post->ID,'css') as $style) wp_enqueue_style(md5($style),get_bloginfo('template_directory').'/css/'.$style);

Simple huh? One line each and your problems are solved.

You may now call wp_head() and go drink your coffee!

No related posts.

As WordPress is a Procedural Programming^w oriented platform the function wrapped to the hooks and actions have no scope when called except global this can be hell when developing plugins. We must take extra-care to not compromise our plugin security and compatibility.

In our road developing plugins we learned some lessons, here is our share.

1. Enable your WP_DEBUG

This caused me some nightmares the first time I turned it on. Lots of plugin developers doesn’t have the habit of working with PHP’s error_reporting at the E_ALL level (Maximum Level, including notices of undefined variables) and I god SEVERAL notices on screen.

WP_DEBUG can be enabled by simply adding the following line to your wp-config.php file.

define('WP_DEBUG',true);

PHP is a very friendly (if we can call this way) programming language that doesn’t cares very much to variable initialization but you should initialize all your variables and check if they are set with the language’s native isset() function.

If you have WP_DEBUG you will se NO errors at all so if your script breaks somewhere at the development, you’ll suffer lots of pain trying to blindly debug your code. Lots of experience had me finding unclosed brackets, parentheses and semicolons but, come on, I’m no masochist.

The best tip here is to have a development WordPress installation. If this is not possible (or you are just too lazy), as lots of plugin developers (very popular ones) aren’t caring about notices showing up to your visitors if you have WP_DEBUG enabled you can always use the good and old PHP code to enable debug only if you are the visitor.

# 200.200.200.200 is an example IP and should be replaced by your own
# if you don't know your IP you can visit www.whatismyip.com
if ($_SERVER['REMOTE_ADDR'] == '200.200.200.200') define('WP_DEBUG',true);

2. Have a cleanup deactivation routine

Had you ever took a look at your wp_options table after a long time activating and deactivating plugins? If you so you probably had seen the garbage left out there.

If you are going to write an option with add_option or update_option please, please, please, be sure to remove your options upon plugin deactivation. I'm pretty sure no one wants your options leftovers as a souvenir.

To achieve such thing, you must register a deactivation hook by the register_deactivation_hook as following

register_deactivation_hook( __FILE__, 'plugin_deactivate' );

And obviously you will have to code an appropriate deactivation function, like plugin_deactivate in the example.

NOTE: Your deactivation function must be at the script's main PHP file.
NOTE: Your deactivation function may have any name.
NOTE: The __FILE__ part specified at the deactivation hook is referencing your own script file.

I personally put all my options that goes to the wp_options database in a global associative array so if I add more options my cleanup function will still be compliant.

global $aOptions;
$aOptions = array(
    'myplugin-default-lang' => 'en_US'
);

I also put my deactivation and cleanup functions apart so I can call the cleanup from within the deactivation function. This is made so if I want to add more deactivation functionalities else than cleanup I can do this without polluting my cleanup function with non-cleanup procedures.

The plugin_deactivate function will look like the following:

function plugin_deactivate() {
    // Cleanup
    plugin_cleanup();
} // end :: function :: plugin_deactivate

And the cleanup function as it follows:

function plugin_cleanup() {
 
    global $aOptions;
 
    // Delete our options
    foreach ($aOptions as $sOptionKey => $sOptionValue):
        delete_option($sOptionKey);
    endforeach;
 
} // end :: function :: plugin_cleanup

This should be enough to keep your options table tidy.

3. Protect files that shouldn't be accessed directly

Almost all your plugin files shouldn't be access directly. Exception goes to scripts that receives data from outside the WordPress framework like thumbnail generators, image replacement techniques, AJAX, and such.

To disable direct access to your PHP files you must check if some WordPress function is present and if not, shutdown the script if a good and old exit(); call.

The example goes as:

if (!function_exists ('add_action')):
    header('Status: 403 Forbidden');
    header('HTTP/1.1 403 Forbidden');
    exit();
endif;

The example above also sends a 403 header in both formats (Internet Explorer and decent browsers, respectively).

4. Use internationalization even if you aren't going to translate yet

Even if you are not planning release you plugin with many languages I strongly recommend that you build yours i18n-ready by wrapping your texts on gettextw functions so other users can help (or even you in the future) to translate your plugin.

The basics

Internationalization basics in PHP is very simple. There are mainly two functions: __() and _e(). The difference is that __() returns the internationalized string _e() echoes it.

When text is within a variable or returned by a function you should use the __() function and if you want to echo it, _e() instead.

Echoing internationalized text in a template file

<h2><?php _e('My text goes here','My text domain goes here'); ?></h2>

Returning internationalized text in a function

function somefunction() {
    return __('My text goes here','My text domain goes here');</h2>
} // end :: function :: somefunction

Internationalization is a wide subject and is covered greatly in the WordPress "Writing a Plugin" page.

Internationalizing your plugin is also a good marketing strategy since if someone releases a language file for your plugin, is also making it available in a wider market-share slice.

5. Employ current coding best practices

There are some wide best practices that are not exclusively to the WordPress Plugin scope.

Separate your code

Applying this technique on WordPress Plugin development is such as having the plugin's main php file just making the calls and registering the hooks and have your functions properly laid under a lib/ function or such. Same things goes to images/, js/ (JavaScript) and css/.

Document your code

Ok, this is like telling grown-ups to not touch the hot oven or putting the finger in a wall socket but many people still lacks in documenting code.

I suggest to keep your functions, classes and files documented in the phpDocumentor syntax.

This kind of syntax is inherited from Java and other languages apply it since is very readable and parse-able.

It goes like the following:

/**
 * My loved function
 *
 * This function collects some data and process in this way to give the desired result.
 *
 * @param    string   $varname    Description of the variable
 * @param    int   $othervarname    Description of the variable
 * @return    void   This function returns nothing
 */

Stay DRY

Try to avoid two functions that do basically the same thing. If you have two functions in separate classes that to the same thing (like string sanitization), consider having a utility class.

Bonus Tip!

Avoid kidnapping people's wp_head() and wp_footer() with your plugin propaganda. If you want to make such thing, do as HTML code comment or make this branding stuff optional.

If you are going to make your plugin free, make it free, not AD dependant. If you think your plugin should be paid, then make it paid. Placing plugin ADs in the themplate may scare out some users. Your free plugin shall make your own propaganda by being useful and rich-featured, not by printing it out.

What's your tip?

No related posts.

The C-like syntax for control structures are very intuitive but can deal lots of trouble when your code has lot of pages and lots of ifs, fors, while and therefore lots of opening and closing braces.

NOTE: As remembered by jakyra on DZone, if you keep your code tidy you shouldn’t have functions that long and though not having this kind of problem, but this alternative syntax still have good benefits.

The alternative syntax

The alternative syntax consists in changing the opening brace ({) to a colon (:) and each closing brace to its respective closing function: endif;, endfor;, endforeach;, endwhile; and endswitch;.

Closing functions list

opens if ([parameters]):

closes endif;

opens for ([parameters]):

closes endfor;

opens foreach ([parameters]):

closes endforeach;

opens while ([parameters]):

closes endwhile;

opens switch ([value]):

closes endswitch;

Benefits of this alternative syntax

The benefits of using this syntax are clear when put into practice. A far more readable code with no more commenting out braces like } // end :: if. You can instantly know which structural condition this closing brace belongs to and will no longer get confused between these and function braces.

Disadvantages of the alternative syntax

I personally do not consider this as a disadvantage but some people might consider since some text editors and IDEs have the ability to highlight the matching brace.

Examples

If

NOTE: else and elseif control structures follow the same structure.

// Standard syntax
if ($variable === TRUE) {
	$otherVariable = "foo";
	$aThirdVariable = "bar";
} elseif ($variable == "foo") {
	$otherVariable = "foo";
	$aThirdVariable = "foo";
} else {
	$otherVariable = "bar";
	$aThirdVariable = "foo";
} // end :: if

// Alternative syntax
if ($variable === TRUE):
	$otherVariable = "foo";
	$aThirdVariable = "bar";
elseif ($variable == "foo"):
	$otherVariable = "foo";
	$aThirdVariable = "foo";
else:
	$otherVariable = "bar";
	$aThirdVariable = "foo";
endif;

Foreach

$array = array("foo","bar");
 
// Standard syntax
foreach ($array as $key => $value) {
	$foo = $key;
	$bar = $value;
} // end :: foreach

$array = array("foo","bar");
 
// Alternative syntax
foreach ($array as $key => $value):
	$foo = $key;
	$bar = $value;
endforeach;

For

// Standard syntax
for (
	$i=0;
	$i<10;
	$i++
) {
	$foo = $i;
	$bar = $i*10;
	print $foo+$bar;
} // end :: for

// Alternative syntax
for (
	$i=0;
	$i<10;
	$i++
):
	$foo = $i;
	$bar = $i*10;
	print $foo+$bar;
endfor;

While

$i = 10;
 
// Standard syntax
while ($i > 0) {
	$foo = $i--;
	print $foo;
} // end :: while

$i = 10;
 
// Alternative syntax
while ($i > 0):
	$foo = $i--;
	print $foo;
endwhile;

Switch

// Standard syntax
switch ($foo) {
case "foo":
	$bar = FALSE;
	break;
case "bar":
default:
	$bar = TRUE;
} // end :: switch

// Alternative syntax
switch ($foo):
case "foo":
	$bar = FALSE;
	break;
case "bar":
default:
	$bar = TRUE;
endswitch;

Photo: Andy Fitz @ Flickr

No related posts.

For years optimization techniques such as Caching in many levels (Disk/Memory), Compression, Clustering and other were developed to acheive greater performance.

Global Warming is there for years and is getting worse every year but it seems that movements under IT has begun in order to create greener solutions. Many hosts such as Dreamhost (which we’re proud of being our hosting company) have already started their effort in reducing or even neutralizing their Carbon Footprint and now developers can help on their side too.

The Concept

Well, we don’t have to go too far to realize where optimization crosses paths with sustainability. It’s simple, it’s all about electricity (power) saving.

Again, it’s all about electricity. Every single bit minor instruction spends a very little piece of energy that goes through the processor and memory I/O operations and spends some little more sending data over the ethernet ports.

Let’s go from the beginning. The user has requested a website, the request goes through all the routers and switches in the way to the requisition.

NOTE: We are not considering this power consumption because it is not dependent on the application’s optimization.

Here is where optimization makes the difference: the way back.

Larger image or source files will take more CPU cycles to be processed, more Disk usage and more space allocated in memory. Then these big files have to be sent to the client and if you have many files this means more HTTP connections and headers being sent.

Techniques such CSS Sprites (heavily used by Google and other big companies) aid to reduce the HTTP Connections between the server and the client.

Each HTTP connections contains not only the file’s data but it is preceded by header data with the file’s type, modified date and some other info so two square 20px images are bigger than one rectangular 40px per 20px image (the two 20px square images side by side).

Then the requested files come from the server to the client by all the router and switches in-between them spending more power in transmission until it gets to its destiny where will consume more power to be rendered by client browser’s engine and window manager (Windows, Gnome, Kde etc).

How to collaborate?

Optimize your software. Yahoo‘s YSlow and Google‘s Page Speed are great kickstarts. You can also check our articles on caching.

As all great saving and recycling, results will only take place with everyone’s effort. These taken under huge proportions can result in great saving and thus more breathe to our planet.

Think green.

Other considerations under power saving on software development

In this 2007 article, Mark Ontkush showed his study where dark-pallete-themed web applications required less energy from users’ CRT monitors.

“an all white web page uses about 74 watts to display, while an all black page uses only 59 watts. I thought I would do a little math and see what could be saved by moving a high volume site to the black format.”

Mark Ontkush

And then the results came when he compared to traffic reports of huge websites such as Google:

Take at look at Google, who gets about 200 million queries a day. Let’s assume each query is displayed for about 10 seconds; that means Google is running for about 550,000 hours every day on some desktop. Assuming that users run Google in full screen mode, the shift to a black background [on a CRT monitor! mjo] will save a total of 15 (74-59) watts. That turns into a global savings of 8.3 Megawatt-hours per day, or about 3000 Megawatt-hours a year. Now take into account that about 25 percent of the monitors in the world are CRTs, and at 10 cents a kilowatt-hour, that’s $75,000, a goodly amount of energy and dollars for changing a few color codes.

Mark Ontkush

Black is the new black!

Unfortunately, dark-themed websites tend to be less accepted by the users, and some have even reported that white characters tend to blur by reading stress while reading an extensive text.

And you developer? What are you doing to save the world?

No related posts.

Scientific notation, also known as standard form or as exponential notation, is a way of writing numbers that accommodates values too large or small to be conveniently written in standard decimal notation. Scientific notation has a number of useful properties and is often favored by scientists, mathematicians and engineers, who work with such numbers.

Scientific Notation @ Wikipedia

So as we – developers – are part-scientists,part-mathematicians and part-engineers, so I guess this is perfect for us!

We have all seen that on high school and it seemed quite strange but it is quite simple indeed:

Equation

The equation is as it follows in a simplified language:
Simplified number x10number of decimal units

The “Simplified number” is the number in a simplified manner.
Examples:

• 1000000 = 1
• 4230000 = 423

And then we just add in the other hand the number of decimal units that were simpled-out.

• 1000000 becomes 1×10⁶
• 4230000 becomes 423×10⁴

You can even balance decimal units as you want as 423x104 can also be written as 4.23x106. Add to the decimal units the number of units before your period “.”. The goal is to keep the number as lowest (simple) possible so generally the 4.23x106 approach is preferred.

Negative / Very small numbers

Scientific notation can also represent the low numbers by negativing the decimal units count on the equation:
4.23x10-4 becomes 0.000423

Note that we have 6 units on the decimal side (4 from the ^-4 and other two from the two decimal units at the multiplying part). That easy.

Caution!

This can be used to simplify virtually any number but I assume you won’t start writing 4×10² instead of 400! Scientific notation is good to simplify great numbers but may also lead to a less-readable code. It is a good practice to assign these values to constants or comment-out.

Language implementation

Each language defines its own way to handle scientific notation here are some examples:

C++

const float FIVEMILLION = 5e6;
const float FIVECENTS = 5e-2;

PHP

define('FIVEMILLION',5e6);
define('FIVECENTS',5e-2);

NOTE: There are implementation in other languages than listed above

NOTE: Scientific Notation is also present in several applications (even the simplest desk calculator) when the output number is too large represented by the E letter followed by the power that is elevated.

Which is your idea for writing less code?

No related posts.

Content minification is a well-known best-practice for bandwidth reduction (saves client’s money) thus giving better page load time (gives client a good smile). Since it removes all unnecessary code (like comments, extra spaces, tabs etc) and join files together, the total of KBs saved even in bandwidth and browser rendering.

Here we always implemented the Minify PHP5 tool from Steve Clay and Ryan Grove because it always worked like a charm and the results are quite amazing.

In wordpress we got problems implementing this because plugins added their own js and css files at will. WP-Minify from Thaya Kareeson came to save our souls but we got some misbehaving plugins that still adding link and script tags by echoing to the page.

Fortunately, this new version preprocesses the output thus gathering any inline style/script reference and adding it to a temporary file that is included in the minification process.

I got tricked there because voting badges and other stuff uses inline script tags to generate the badge. WP-Minify’s preprocessing fufreaked me up because this script tag depended on the_permalink() function from WordPress thus not generating the correct output on the temporary file created. Before I started freaking out I realized that the plugin’s configuration page had an script (and style) blacklist. Just added the src url (without the querystring) and everything worked like a charm!

Nice job Thaya!

No related posts.

This errors happens when you send a header command and has already outputted text to your output buffer (generally, the browser). Then you grep your code for misleft debugging prints, echos, print_rs and var_dumps but they are gone or commented.

Oh yeah, somehow some data were added during the transfer somewhere in your source files. Great! Now some cool action!

DON’T PANIC
As the 1st rule of code debugging, read the error message.

Warning: Cannot modify header information – headers already sent by (output started at /var/www/projects/…/app/models/Keyword.php:168) in /var/www/…/app/lib/AppController.class.php on line 421

It is all there. Notice the part where it says “output started at”. This tells you where to look for the added ghost data, the file and the line. Couldn’t be easier, could it? Just go to the line and trigger your home and end keys and the cursor will reveal the menace. Be ruthless! Just remove them and reload.

The second part tells you here your header command was triggered, again, file and line.

Some people (like people from Zend) tells users to never mind the php close tag ?> so you don’t get bothered by these errors. This is due PHP ignoring spaces within his enclosure tags but it prints the spaces out of them so if you don’t close the tag, there will be no tags out of them.

About this discussion, I choose keeping the close tag. As I said at the debate in a previous article: “Its not needed, ok. But it exists (and it is part of the code structure) so it shall be used.” and “If your FTP or IDE or ANYTHING puts unwanted data on your code, switch your application. Accidental white spaces. Accident happens when errors happens. A stable code/environment shall not have ‘accidents’”, but if you do, just read the error code and clean it up.

No related posts.

We’ll use JQuery‘s selectors to get the links we want.

All external links

UPDATED: As WordPress makes all links absolute this code got useless. I’ve updated it now to check additionally if the link does not starts with the current domain. I’ve tested it and it worked!

NOTE: I’ve searched for a shorter form where starts-with and negation could be applied together. If someone has a better solution, please share!

$(document).ready(function() {
    var domain = window.location.host;
 
    $("a[href^='http://']").not("[href^='http://"+domain+"']").click(function(ev){
        ev.preventDefault();
        window.open(this.href);
    });
});

All links from a div with ‘#id_div’ id attribute

$(document).ready(function() {
    $('div#id_div a').bind('click',function(ev) {
        ev.preventDefault();
        window.open(this.href);
    }
    );
});

NOTE: I’m using ev.preventDefault() rather than return false to follow JQuery pattern. Just a good practice.
NOTE: ev is just a variable name I gave. You may change it to suit your needs.

Any more ideas?

No related posts.

Sure, he found the “01″ and thought “Oh yeah babe, it’s an octal number!” — wrong my friend, it’s just a zero-padded number, sorry disappointing.

So, I had to supply the second argument called radix as 10 (decimal) that is indeed the base you are going to use. Setting this makes parseInt to respect you instead of having his free-will.

So I ‘ve got:

var _orderDateMonth = parseInt($('#survey_order_date_month').val(),10); // decimal base!

NOTE: The dollar sign ($) and .val() are specific JQuery functions.

NOTE: I personally hate when people break up the date parts into different inputs. If you are already going to use JavaScript, implement a damn date-picker!

No related posts.