So, do themes and plugins serve a system-level or a user-level function?

p.s. Some have compared WordPress plugin and theme API to the way Linux loads kernel modules, when in fact relating it to system call interface (SCI) would be more appropriate.

I have come to conclusion that its purpose is to give everyone the freedom to do whatever they want with my work as long as they retain the freedom to derive from it.

With every software there are only two things one can do with it — either run it or modify it. By applying the GPL licence to my original work I am making sure that these two things can always happen and nobody can take those freedoms away.

The important point is that I am ‘enforcing’ these rules only in the context of the work that I have written and distributed. WordPress has been built upon the b2 blogging software by modifying its source code and adding new functionality, and because b2 was licensed under the GPL, the derived and altered source code is also licenced under the GPL. Although there might be not a single line of code left from the days of b2, WordPress started off as a tiny modification of its source code, and therefore must retain its licence. This is a very important point to understand for those trying to dismiss the spirit of GPL, because it’s the only thing left when every single line of code is different from the original. And it doesn’t matter if that change happened in a single patch or thousands of them.

Plugin functionality in WordPress didn’t exist in b2 and was added only in 2004 when WordPress 1.2 was released. Before that, one would have to make changes directly to the source code in order to alter the way WordPress works.

Therefore, the important question is — if changing the source code is clearly deriving from the original, then what is a plugin? Is it simply an elegant way to “modify” the source code or is it something else?

If we think of the plugin architecture as a “socket” through which one can get access to the “power”, does GPL has any say over what can be plugged into that socket? Do I, as the creator of the “socket”, want to determine and have control over what can be plugged in there?

I view software exactly as devices with plugs which need sockets of power to function. If lower level sockets didn’t exist, everyone would need to write software in assembly with the only knowledge being the hardware on which it will run. Like building a table lamp with its own wind farm.

Relying on existing interfaces for creating new functionality is an inherent feature of how computers work. Even programming languages can be considered as semantic interfaces through which we communicate and control the hardware. For example, WordPress will always need PHP to run. Outside PHP WordPress is not WordPress anymore.

With that comparison in mind, we should note that WordPress can be licensed under the GPL only because the licence of PHP doesn’t impose any restrictions or rules on how the products derived from it are licensed. At the same time, WordPress has no influence over how PHP can be used.

I think that once you create an interface in your software through which you want others to modify or change the way software works, you have given others the freedom to plug in anything into it. You have created an interface which no longer requires others to derive from your original work, in order to use it. When someone uses that interface, nothing is being changed or altered in your original work.

By creating such plugin architecture, you have decided to give others the freedom to add any type of functionality without any restrictions. That added functionality is a derivative work only in a sense that it uses your “socket”, while the functionality itself stands on its own. It’s like plugging an amplifier into an audio system — the amplification depends only on the existence of a signal not on the type of socket it’s passed through.

To conclude, I think WordPress plugins and themes are not derivative works of WordPress. Use of plugins and themes is protected by the freedom Zero of the GPL — “the freedom to run the program, for any purpose”. Once you have allowed users to run any plugins or themes, you can’t limit them to plugins and themes that are licensed only under GPL.

This would be extremely useful for all the tablets out there.

Inside /api you’ll find index.php which processes all the update requests. You should place this in something like http://updates.example.com and update $api_url in /plugin/test-plugin-update/test-plugin-update.php and /theme/portfolio-racer/inc/updates.php accordingly. If you activate these sample plugins without changing API URL, updates will be checked against my test server. If you decide to update, both plugin and theme will be replaced with exactly the same version of each.

This is an OpenID Server. Nothing to see here… move along.

Download: ajax-cache-purge.zip (June 26, 2010)

Installation

Please note that this plugin is intended for people who run their own servers.

1. Upload and enable the plugin.
2. Add the value of wp_cache_key_cookie to the cache key.

Nginx Example

fastcgi_cache_path 	/var/www/cache  levels=1:2
			keys_zone=wp-cache:10m
			inactive=2m max_size=2000m;
fastcgi_temp_path 	/var/www/cache/tmp;
server {
	# other config options
	location ~ \.php$ {
		# Cookie is supplied by the plugin
		set $wp_cache_key_cookie 0;
		if ($http_cookie ~* "wp_cache_key_cookie[^=]*=([^;]+)(;|$)") {
			set $wp_cache_key_cookie wp_cache_key_cookie_$1;
		}
		set $wp_cache_key $scheme$host|$request_uri|args=$args$|$wp_cache_key_cookie;
		#add key in header for debugging
		#add_header	WP_KEY $osc_cache_key;
		fastcgi_cache 		wp-cache;
		fastcgi_cache_key 	$wp_cache_key;
	}
}

Several weeks ago the screen inverter of my Dell Latitude D820 laptop (which also has a trackpoint) failed and turned it into a desktop that can only be used with an external monitor. So I found a used IBM ThinkPad A31p (released in 2002), which is now running Ubuntu that supports every piece of hardware inside it. Although I won’t be carrying it around very often because it weights 3.45 kg (7.6 lb), I might make a sticker that says “Used Aboard the Shuttle Spacecraft” and look cool even with a laptop that old.

Once you get used to the trackpoint, everything else seems so clumsy and frustrating. There is even a handy little application for configuring the trackpoint settings, called ‘Configure TrackPoint‘:

How come that for interface elements in Gnome (in Ubuntu 10.04) we’re still stuck with bitmaps instead of scalable vector graphics.

if (function_exists('apc_clear_cache') && $_GET['pass'] == 'secret') {
        if (apc_clear_cache() && apc_clear_cache('user'))
                print 'All Clear!';
        else
                print 'Clearing Failed!';
        print '<pre>';
        print_r(apc_cache_info());
        print '</pre>';
} else {
        print 'Authenticate, please!';
}

Then call the script via http://example.com/clearapc.php?pass=secret

Instead of using ?pass=secret, you might well call the filename something that is hard to guess: clearapc93920.php

If you were to build a tablet that has a touch screen not bigger than 9 inches and a modern browser as its only application, GSM + data connection, instant startup and a batter life of 12 hours, which OS would you choose?

I can’t understand why Google needs Chrome OS. Is it only for devices that don’t have touchscreens?

On every page request javascript calls version.php?timestamp (which is never cached because of the timestamp), which using stat() reads the last modified timestamp of that text file and compares it to the value of VERSION_NO cookie. If they are different, a new cookie value is set, which in turn changes the cache key for all future requests, and the cache is invalidated.

The only thing I don’t know is how fast and resource hungry is the stat() call?

Update: or would it be better to use filemtime()? There is a comment which says that 1000 filemtime() calls take 0.0049 seconds, which I think is very reasonable.