Although the name suggests that it will mercilessly murder the process, its more a signal thrower. Signals tell processes to take determinate actions such as pause, continue, terminate, interrupt current work etc.

Anatomy of process’ death process

There are basically four forms to terminate a process:

Wrong way to terminate a process

Signal 15, SIGTERM. The Terminate Call

Tells your process to end the task cleanly, closing all network connections, file handles, notifying child processes, resetting the terminal and go home in peace. The first thing to do when it becomes unresponsive.

Signal 2, SIGINT. The Interrupt – A slap on the face

Tells your process to stop what it is doing right now and leave immediately. The only way when SIGTERM fails to do the job cleanly. CTRL+C will throw this signal too.

Signal 1, SIGHUP. The Hangup – Kick on the tummy

Quite similar to SIGINT, SIGHUP is one step up. The Hangup is equivalent to the physical medium holding the process going down. It was very common on dial-up lines to indicate that the line had hang-up the call thus terminating the connection.

Signal 9, SIGKILL. The Kill – A bullet on process’ head

SIGKILL will wipe the process out from your tree leaving all the crap it was using. Its the worst way of terminating a process since it will keep your resources open and can lead to any sort of mayhem.

So what to do?

As mentioned on UUK9 (Useless use of Kill -9):

Generally, send 15 (SIGTERM), and wait a second or two, and if that doesn’t
work, send 2 (SIGINT), and if that doesn’t work, send 1 (SIGHUP). If that doesn’t,
REMOVE THE BINARY because the program is badly behaved!

Quite extremist, but totally true!

Treat your processes with dignity, and they won’t betray you! HTH!

Related posts:

1. Automating human intervention tasks with Expect

NOTE: As pointed by Robert, the amount of I/O generated by the swapfile may greatly decrease the iPhone’s SSD lifetime since is designed to be more at rest.

After buying an iPhone 2G from a friend I just couldn’t resists and started hacking all that I could. Put on the latest firmware by the time (3.1.3) and Jailbroke it, put on Saurik‘s Cycorder via Cydia (apt^w repository) (also from Saurik) in order to gain movie recording ability but didn’t went any further than that.

Then, as I don’t have a 3G/EDGE plan on my carrier, I decided only to access internet over WiFI but even scrambling APN credentials my little buddy kept connecting to my carrier EDGE network (and thus spending my money on high taxes).

After reading a while I discovered that SBSSettings would give me the option to control EDGE status (enabled/disabled) instead of just jamming credentials (that were being ignored by the carrier anyway). Installed and it just worked like a charm…. BUT… I’ve noticed that my Spingboard page transitions became a little hangy and apps opening and closing started to take much longer than it usual. From SBSSettings pane, I constantly see my memory running out due to iPhone’s lack of memory and lots of apps in background struggling for resources.

Some apps are constantly running on background since boot: the Phone app (obviously) and the Mail app. I had to go often to the SBSSettings’ process manager and shut down Safari or iPod app when they insisted in being kept alive even after being closed thus still consuming my precious resources. The “Free Memory” tool from SBSSettings also helped a (tiny [micro]) little bit.

SBSSettings is your nerdy fat friend

After some researching on iPhone speed issues I’ve found that SBSSettings, just eats tons of memory from the device. This got some discussion because someone on behalf of BigBoss commented on a post on the same blog saying that SBSSettings did not ran in background, instead it would use some Springboard hooks that would activate the app when triggered and then destroyed the app instance when closed.

Actually SBSettings does not run in the background (which I believe is the whole premise of this article). Instead, it hooks springboard functions. When certain events inside springboard occur, springboard (which is a single process already running without sbsettings installed) causes the sbsettings window to open. When you close the window, it goes back to being idle again. It uses about 1mb of memory to exist but does not run in the background, does not slow the device down, and does not cause performance issues. It would be very nice if some research could be done before posting these sorts of articles :(

some commenter entitled on behalf of BigBoss

Well, I decided that I didn’t want to write (or think) on things based on assumptions so I decided to take a look further into my device system, logged on by SSH and ran a top command (had to install the “Top” app from Cydia) and there he was:

So it is, in some kind of way, running on background on my iPhone since the SBSSettings tab wasn’t open.

Proposed workaround

The proposed workaround is to install BossPrefs (even not supporting WIFI toggling by its interface on the 3.0 firmware) that is SBSSettings “father” (where it derived from it) and is quite being discontinued by BigBoss. I haven’t tried that yet because I’m still tied emotionally with SBSSettings even with the speed issue.

Even more heavy crap stuff

As if I hadn’t enough problems, I also have installed Veency (for VNC^w support) and OpenSSH (for SSH support! RAH) and they just goes background and eat memory (and battery) as well.

Well, I benefit from SSH and Veency. From SSH because I’m an unix freak and like the lovely smell of an embedded shell under a *nix kernel. Besides syncing my iPhone wirelessly is convenient too. Veency is nice to read SMS messages, view notes or monitor any app from distance, for example: Working on your desktop/laptop computer and having the cellphone on your pocket or far from the table (I’m not lazy I just like connecting remotely to stuff!). They didn’t quite handle much trouble to memory because SBSSettings toggle buttons permit me to shut’em down and up whenever needed. It also keep my battery from draining unnecessarily.

Now THAT’s heavy, baby!

Going further down I managed to install Winterboard (also via Cydia) since I like custom themed things – just like Hell Angel’s likes custom bikes – that also runs backgrounded and thus handling the same side effects. That really lagged stuff out too.

Then I noticed things started to get very laggy, but the hell, I NEED (ok, maybe I don’t) those awesomeness! SBSSettings just give me fine control over my device. But I had to choose: look’n'feel + control or performance.

I really love all that Cydia awesomeness and when I was almost removing Winterboard, SBSSettings and such, I remembered that I’ve heard in some article that Apple didn’t allowed 3rd-party apps to be put in background because “it would drain the battery and the short iPhone memory (128M)” that struggles to support the Phone, and iPod app that are natively always running on background. So if I won’t reduce the number of backgrounded apps, the only thing left is to get more memory but, how?

I can’t solder more RAM, that would be too way extreme. Then it snapped the sysamin insde me and though that the memory issue could be aided with a swap/page file (virtual memory) but it wasn’t implemented natively on device (I believe in behalf of the type of Flash Memory on the device that lacks on read/write speed). But what the hell, why not?

Dynamic paging

Searching the internet I’ve found this forum topic on modmyi.com that discussed the implementation of swap file (dynamic paging) on the device and, guess what, they did it. It’s a single plist file and we get a sensible less lagging and gagging.

I just moved the plist file on the device over ssh and rebooted. It’s working quite better than before, so I don’t need to thrash my goods so soon.

I forgot to measure my iPhone load values before enabling dynamic paging (shame on me) to compare the gains so if anyone has some, please share on the comments! Hope this works for you as well as it worked for me! Do you have any other performance tips?

Related posts:

1. Typing less with SSH
2. Sustainability application under Software Development

Some of my clients are hosted on shared hostings and some of them doesn’t allow password-less authentication “in behalf of my security”. Well, I can’t really afford opening my password manager, locating it and then copying and pasting back to my terminal. Too much time spent.

I have heard about expect long ago but never quite stopped to look at it since I never really had that need but in this case it came quite handy. Hop in aboard the new less typing world!

Expect is a Unix automation and testing tool, written by Don Libes [from NIST] as an extension to the Tcl scripting language, for interactive applications such as telnet, ftp, passwd, fsck, rlogin, tip, ssh, and others. It uses Unix pseudo terminals to wrap up subprocesses transparently, allowing the automation of arbitrary applications that are accessed over a terminal. With Tk, interactive applications can be wrapped in X11 GUIs.

Source: Wikipedia

Expect Overview

Expect runs a very simple kind of script file in its own language. This script contains the logic to perform the automation and it’s called as first argument to the expect command. For a argument-less script named fake_ssh_host-x.exp the call would be.

expect fake_ssh_host-x.exp

If it took any argument it would just be appended to the call:

expect fake_ssh_host-x.exp somefile.txt

Quick Expect anatomy

Expect directives are line-separated and not terminated. Expect even has some object-notation for grouping expect events.

Variables

Variables are assigned in expect with the set directive.

set pass "mypass"

Variables are further referenced prefixed with a dollar-sign $.

Command-line arguments

Command-line arguments are get through the $argv variable and the lindex call. Now that we have learned how to assign variables, let’s assign one with a command-line argument.

set filename [lindex $argv 0]

Note that indexes start at 0, as the standard.
You can have multiple command-line arguments:

set filename [lindex $argv 0]
set user [lindex $argv 1]
set host [lindex $argv 2]

Spawning the tampered process

We use Expect in order to tamper output from a process and thus automate the inputs. We need to tell our Expect script which process it must spawn. This is done though the spawn directive that prefixes a normal command-line statement for that call.

spawn ssh user@host

Timeout

Timeout determines the number of seconds that the process has to respond before being considered jammed (or b0rked) and is set through the timeout directive, much like as a variable is.

# one minute timeout
set timeout 60

timeout is disabled if set to -1

Observing data

The expect directive tells the script which text to expect from standard output.

expect "String"

Posting data

Posting data to standard input is done through the send directive. This statement when precede by an expect statement will execute only when given string matched.

send $pass

Grouping expectations and posts

This kinda object-notation is used to couple expect/send statements.

expect {
	"password:" {
		send "$pass\r"
	}
} 
# or shortened
expect {
	"password:" { send "$pass\r" }
}

If you need to append more commands on an expect block just append the line within the expected element closure (in expanded form) or append to the line in a semi-colon delimited form.

expect {
	"password:" {
		send "$pass\r"
		set timeout -1
	}
} 
# or shortened
expect {
	"password:" { send "$pass\r" ; set timeout -1 }
}

Coupling multiple expectations is also easy:

expect {
	"yes/no):" send "yes"
	"password:" { send "$pass\r" ; set timeout -1 }
	eof exit
}

Printing messages on screen

If you want to send messages to the standard output rather than the process’ input, you do exactly like the send statement described earlier in this article but the command is send_user.

send_user "Connected to host"

Outputting to a file

Sure, you can always pipe the output natively from the shell with the output redirectors > but we can also do that within Expect by setting the file variable coupled with the open directive.

# filename in example is set to expect.out
# 'w' opens file for writing, 'a' to append
set file [open expect.out w]

More documentation can be found on Expect’s website or in its man page.

man expect

Faking a private key authentication AKA Automating a password authentication

For both examples we will need variables and the expect, send and spawn directives.

SSH Session

We will expect the message asking us if we want to accept the key and send yes to accept it. Then we will expect for the password: string and send our password stored in a variable.

#!/usr/bin/expect -f
set timeout -1
spawn ssh username@host
set pass "mypass"
expect {
        password: { send "$pass\r"  }
	} "yes/no)?" {
		send "yes\r"
		set timeout -1
        } eof {
                exit
        }
}

SCP Session

We will follow the same logic from the above example but we’ll add some command-line arguments to catch the filename and path to be transfered.

#!/usr/bin/expect -f
set timeout -1
set filename [lindex $argv 0]
set dst_path [lindex $argv 1]
spawn scp $filename username@host:$dst_path
set pass "mypass"
expect {
        password: { send "$pass\r"  }
	} "yes/no)?" {
		send "yes\r"
		set timeout -1
        } eof {
                exit
        }
}

And you’re done. No more typing and unnecessary time spending.

Related posts:

1. Typing less with SSH
2. Smartly resolving your WordPress pages and posts JavaScript and CSS dependences
3. Scytale, a greek cryptography system implemented in C++

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!

Related posts:

1. 5 best practices on developing WordPress plugins
2. Smartly resolving your WordPress pages and posts JavaScript and CSS dependences
3. Scytale, a greek cryptography system implemented in C++

The language files can be found at the official Simple:Press Forum translations website.

Enjoy!

Related posts:

1. Brazillian Portuguese (pt_BR) language file for WP-Filebase released
2. 5 best practices on developing WordPress plugins
3. Smartly resolving your WordPress pages and posts JavaScript and CSS dependences

For me as a Linux^w user I always had to type long lines to start my SSH^w sessions. It’s no rocket science, you know, but for he who types thousands of characters each day, each character save is golden.

We usally start our SSH sessions by typing the following command string:

ssh user@domain.tld

I’ve tried to shorten this by adding the domain and its TLD^w to my hosts file with a shorter alias like

hname hostname.tld

But obviously that crashed against Apache^w Vhost^w capability, the request never make it to the other end.

I personally have SSH keys on some of my servers to avoid typing passwords, that is good to prevent against MITM^w attacks and keyloggers, but I still have to type the string mentioned lines above.

Then, with 3 lines in a SSH’s configuration file on my home directory (yes, you don’t need to alter the server’s SSH configuration file and yes, you can do that on your shared hosting’s shell account).

It’s very simple. SSH allows some user-based configuration in your ~/.ssh directory (note that ~ stands for your home directory (usually /home/yourusername) and it also provides Aliases^w capability.

The aliases can be configured in such a way that you won’t need to type neither the FQDN^w nor even type a single username EVER MORE!

Your old

ssh user@domain.tld

will be shortened to

ssh aliasname

Ok, talk is cheap, show me the code!

Creating the need files and directories

All the magic occurs on the config in your already-mentioned ~/.ssh/ directory. If you don’t have one, create it and secure it, as the following:

mkdir ~/.ssh/
chmod 700 ~/.ssh/

If the file does not exists, create it and secure it propperly, like:

touch ~/.ssh/config
chmod 600 ~/.ssh/config

Syntax model

Host [alias name]
HostName [host's fqdn]
User [username to log-in as]

Without the braces, please!

For a user called jdoe on mydomain.com being shorted md, the code would be the following:

Host md
HostName mydomain.com
User jdoe

Save the file and you can start typing less with SSH:

ssh md

And that’s IT!

Wow that’s great! What else this beauty can do?

Omnipresence

Do you have the same username in a large number of machines, like in a local network? So you have to love the * wildcard.

Host *
User jdoe

I have many names

Want to follow a naming pattern but also wants to have shorter ones? Give multiple aliases!

Host gdf gandalf
HostName gandalf.mydomain.com
User jdoe

Avoid the front door

Security through obscurity is always fun! Have your SSH aliases even in hosts with sshd running in a different port.

Host md
HostName mydomain.com
User jdoe
Port 11

Be backwards compatible

Have outdated SSH servers? I hope not! But if you do, you may also define a different protocol in a host-based manner.

Host md
HostName mydomain.com
User jdoe
Protocol 1

Handle multiple keys

You may specify the specific (what?) SSH key file for a host.

Host md
HostName mydomain.com
User jdoe
IdentityFile ~/mykey.pub

And it also works on SCP!

Oh yeah, file transfers are easier now!

scp somefile.txt md:/path/to/upload

More parameters can be found on SSH manual, page 5.

man ssh 5

Phew! That’s all folks! Hope it helps someone as much as helped me! Anyone have any neat SSH trick?

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!

Related posts:

1. 5 best practices on developing WordPress plugins
2. Alternative syntax for PHP control structures

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?

Related posts:

1. Brazillian Portuguese (pt_BR) language file for WP-Filebase released
2. Sustainability application under Software Development

This plugin is a great download / file manager that covered just all holes that we need in our clients’ projects. It features a highly configurable theming, internationalization, categorization, download counter, traffic/bitrate limiter and more.

This is certainly a recommended WordPress Plugin for all.

The language file was translated from the provided template.po.

Please submit any fixes for translation errors that you may find.

Download pt_BR.mo language file for WP-Filebase
Optional download pt_BR.po language file for WP-Filebase

No related posts.

The game released by Cisco as part of its CCNA training has the objective of training your binary skills. You will be asked for the bits corresponding to a certain value or vice-versa.

Very interesting, can get really naughty sometimes.

Play at your own risk at Cisco’s website.

No related posts.