7 days of WordPress plugins, themes & templates - for free!* Unlimited asset downloads! Start 7-Day Free Trial
  1. Code
  2. WordPress

Your First WordPress Plugin: Simple Optimization

Scroll to top
Read Time: 12 mins

WordPress is the largest blogging platform available on the internet today; and with the official release of version three just around the corner, it's only going to get bigger. As such, over the next few self-contained tuts, we're going to learn the ins and outs of WordPress plugin development, starting with the creation of our first simple plugin, "Simple Optimization."

Step 0 Before we Begin

This tutorial is going to assume that you have at least a beginner's understanding of PHP and the WordPress syntax. Though we'll be covering everything, some knowledge beforehand will help you grasp the concepts much more easily. I'll also assumes that you have a WP blog setup and ready to go.

Step 1. What our Plugin Does

The very first step, when writing a WP plugin, is to determine everything you want it to do. Since this is our first plugin, we won't do anything too drastic. Let's create something which will speed up our blog; our pages will render faster, and we'll also do a little SEO to improve our search rank and findability.

"Always create a list of what you want your plugin to actually do before you write any code!"

Remove useless meta tags:

  • "rsd_link" - Really Simple Discovery Link
  • "wlwmanifest_link" - Windows Live Writer link
  • "wp_generator" - WordPress version number

Remove unnecessary filters:

  • "wptexturize" - Curly quotes
  • "wp_filter_kses" - HTML in user profiles


  • Insert post tags into <head> as keywords
  • Insert post excerpt into <head> as description

Step 2. Laying the Groundwork

To start, navigate to your plugins folder ("/wp-content/plugins/"), and create a new folder. We'll call ours "simple-optimization." Next, inside of this folder we're going to need to create two files. The first will be the actual plugin file (named "main.php"), and the second will be the mandatory README ("readme.txt"). We're going to leave readme.txt empty for the time being; so open main.php in your preferred text-editor and copy in the code below.

This text is the bare-bones minimum needed for a plugin to appear in the WordPress plugin directory. You'll obviously need to fill each part as you see fit.

Step 3. Adding Features

The first two features we're going to implement will also be the simplest. By default, WordPress adds several meta-tags to the <head> section of your blog, but the simple fact of the matter is that these meta-tags have absolutely no value at all; so we're simply going to stop WordPress from adding them. Anytime WordPress performs an action, it's either called a filter or an action, and we can either remove or manipulate these filters and actions (you can find a list of all the filters here, and all the actions here). In this case, we want to remove the various actions that add those meta-tags.

To do so, we use a very simple function called "remove_action('action','function')". This function will remove the function declared in the second parameter from the action, the first parameter.

The same exact same principle applies to the two filters we're going to remove:

Step 4. SEO

Now that we've cut out that bloat, let's ensure our blog has some basic SEO; meaning, let's make sure we have keywords per-page, which correspond to that page and change the description to match more with the article. For our keywords, we're going to grab the tags of the current page/post. This is made super simple by the function "wp_get_post_tags()". wp_get_post_tags will return an array of tags from the current post. We can then easily format this array into a string and place it within our header (inside the function "wp_head()", that every theme should have in it already) by attaching our function to the wp_head action.

Let's start out by creating a new function, tags_to_keywords(), and, inside of this function, we'll write a simple if statement, which checks to see if the current page is a single post or page (using the WP functions: is_single() and is_page()). Next, we'll create a variable inside this if statement, named $tags, and set its content to the function wp_get_post_tags(); however, in order for this function to work, we need to pass in a parameter of "post_id". The easiest way for us to obtain that is to globalize the WP variable $post which contains the post ID ($post->ID, $post is an object which is why we're calling its values like so).

Next, we'll use a foreach to filter through the $tags data, and create a new array with only the information we want ($tag_array). Following that, we'll implode the array into a string and separate each item from the array with a comma and space ($tag_string). Then, we'll create another if statement that checks to see if $tag_string has a value (meaning, do we have any tags for the post) and if it does, echo out the final HTML.

The last thing we need to do now is attach our new function with the wp_head action. To do this, we're going to call add_action('action','function'), and pass it the parameters "wp_head" and "tags_to_keywords" (in that order).

To further increase our SEO, we're going to add our description meta-data to the header as well, using the same method as the keywords. Once we have the if statement rewritten, we're going to create a new variable $all_post_content and fill it using the WP function wp_get_single_post() (and pass the parameter of $post->ID). This will give us an object full of all the data about our post. With this variable, we can create a description using the actual content of the post, but we're going to shorten it down to one hundred characters using the function substr ($excerpt). And then, we'll just echo out the HTML with the excerpt written in. (Optionally, you can also add an else statement, and echo your blog description using the function get_bloginfo('description').)

Step 5. Optimizing the Database

The final feature for our plugin is going to optimize our database tables by removing overhead (useless/excess data in a SQL table created by manipulating the database). To begin, we'll create a new function (optimize_database), and inside of it, we're going to call the global WPDB variable ($wpdb). That way, we can interact with the database, without having to re-enter our authentication details. $wpdb has several methods you can use to interact with and retrieve information from the database (Full list here), but we're only going to be using one, get_results. Using get_results with the parameters of "SHOW TABLES" and "ARRAY_A" will return to us an associative array of all the table names in the database. At that point, we can use a foreach to loop through each of the array values (using array_values to get the table name, because of how it's layered by the function) and use another $wpdb method, query to run the optimize command ("OPTIMIZE TABLE _____").

While this function works, it will never actually run because WordPress has no way to know to run it. Luckily, WordPress has a feature called cron, which schedules functions to run at specific intervals (daily, weekly, etc...); this is perfect for us, since we want to frequently optimize our database. To use Cron, we're going to create a new function (simple_optimization_cron_on), and fill it with another function call to wp_schedule_event(). To work, wp_schedule_event needs three things: a time to run, an interval between each run, and a function to call; so we'll pass it the parameters: 'time()' (we'll assume that whenever the cron event is created is a good time to call the function), 'daily', 'optimize_database' in that order.

Great, now we have our optimize_database function being added to the WP cron list, or we would if we were to call the simple_optimization_cron_on function. It's really unsafe and is a bad practice to call your own event addition functions, because through some arbitrary system of events, it could cause the function to be called multiple times. WordPress happens to have a set of specific hooks for plugins to solve this problem: register_activation_hook and register_deactivation_hook. These functions are called when a plugin is turned on (activated) and turned off (deactivated). This way, our cron function can only be added once. Now, we have the ability to remove the cron event if the plugin stops being used. To work, these functions need two pieces of information: the url to the file that has the activation and deactivation functions (99% of the time "__FILE__" will work perfectly here), and the name of the activation and deactivation function. We'll also create a new function (simple_optimization_cron_off), and fill it with a call to another function (wp_clear_scheduled_hook('optimize_database')) to delete our cron event.

Step 6. Filling out the ReadMe

The last thing we need to do for our new plugin is fill in the readme.txt file. The readme.txt file is used by the WordPress Plugin directory to display all the information you provide it about your plugin. The best way to learn how to write an effective readme.txt file is to download the default from WP, and alter it accordingly to fit your plugin. Since ours was so simplistic, this is what I personally ended up with:

That's it!

You just successfully wrote your first WordPress plugin, which is working and ready for the WP Plugins Directory. Along the way, you learned about filters and actions, using WP global objects, a lot about the WordPress nomencalture, how to interact with the database, cron events, and activation/deactivation hooks. If you have any questions, please leave a comment and I'll respond as soon as I can.

The final code:

Did you find this post useful?
Want a weekly email summary?
Subscribe below and we’ll send you a weekly email summary of all new Code tutorials. Never miss out on learning about the next big thing.
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.