“More computing sins are committed in the name of efficiency (without necessarily achieving it) than for any other single reason – including blind stupidity.”
William A. Wulf

preamble

Since my last article about performance comparison of popular CMSs: Typo3, Joomla!, and Drupal [typo3-joomla-and-drupal-cmss-performance-testing.html] I got enormous amount of messages, emails and notes.

Most discussed question is:
*What the hell you didn’t turn cache on, and forgot about optimization?

And comments like:
In case of optimization zzz will take first place.
No one runs systems like that in real life. Every real web server is optimized for performance ..

I answered several times with:
I make tests to test effectiveness of pure systems rather then caching sub-system or optimization methods.
Developers should think about effectiveness of their components and don’t pass care about performance entirely to caching or other technics.
Surely cache is good as well as better CPU, bandwidth, and cluster when solution is already got all benefits of good software design.

But if you want OK.
I will turn ON everything I know on all CMSs, and will make all environment optimizations. I hope you will be glad.

Surely if you are hacker that want to tune all the daylights you will beat any system.
Let’s think that this environment presents common set of optimizations on general production system.

Prepared configuration

architecture: x86
CPU: 3.0Ghz
RAM: 512Mb
OS: Debian GNU/Linux lenny/sid (testing)
kernel: 2.6.22, optimized for current computer configuration

software versions:
apache: 2.2.8
php: 5.2.5-3
mysql: 5.0.51a-3

joomla!: 1.5.3
drupal: 6.2
typo3: 4.2.1

apache:
web-server API: apache2.0 handler
processing model: mpm-prefork [http://httpd.apache.org/docs/2.0/mod/prefork.html]
MaxClient adapted for load
excessive login disabled
HostNameLookups dissabled

PHP:
XCache PHP opcode cacher installed [http://xcache.lighttpd.net/]

xcache.cacher = On
xcache.optimizer = On
xcache.coverager = Off

xcache.size=64M # cache size
xcache.count=2 # cpu count

xcache.var_size = 64M # variable data cache size
xcache.var_count = 2 # cpu count

MySQL:
mysqli database adapter used where appropriate
bin log disabled
query_cache_limit = 2M # default was 1M
query_cache_size = 64M # default was 16M
table_cache = 256 # default was 64
key_buffer_size = 64M # default was 16M

CMSs returned specially prepared page contains:
menu, login form, 2 articles with overall size 40Kb
Testing series contains results for 10, and 20 simultaneous users.

comparison results

note:
results in the tables are presented in milliseconds per page request
and surely smaller result is better.

10 users

20 users

fast conclusion:
Drupal uses caching mechanism more effectively that explains such lag of others.
Numbers, and graphs are very loud, and so I think you don’t need any additional descriptions.

You can always compare this result with result without optimization techniques using my previous article [typo3-joomla-and-drupal-cmss-performance-testing.html].

Our company above all uses 3 CMSs [http://en.wikipedia.org/wiki/Content_management_system]
Typo3, Joomla!, and Drupal since we find them the most appropriate for most of our tasks.
Check this our article to find more about it [cms-based-web-applications-fast-way-for-creation-of-web-based-solutions.html]

Sometimes our customers asks what is faster, trying to find fair answer I made a short research
in order to compare them and provide our customer as well as you with pretty graphs.

testing conditions

I have created virtual dedicated server with following configuration within our server
to have a picture of average hosting providers.

configuration:
architecture: x86
CPU: 3.0Ghz
RAM: 512Mb
OS: Debian GNU/Linux lenny/sid (testing)
kernel: 2.6.22-3-686

On all CMS returned page contains:
menu, login form, 2 articles with overall size 40Kb

As Joomla! doesn’t have built-in internationalization functionality I made tests with JoomFish 2.0beta extension
that provide that functionality and without it.

Every testing series contains results for 1, 10, and 20 simultaneous users.
Caching functionally:
turned off for Drupal, Joomla!, and Typo3;

apache configuration:
apache web-server API: apache2.0 handler
processing model: mpm-prefork [http://httpd.apache.org/docs/2.0/mod/prefork.html]

software versions:
apache: 2.2.8
php: 5.2.5-3
mysql: 5.0.51a-3

joomla!: 1.5.2
typo3: 4.1.6
drupal:6.2

comparison results

So it’s time to see some results. Keep your eyes widely opened..

note:
results in the tables are presented in milliseconds per page request
and surely smaller result is better

1 user

10 users

20 users

fast conclusions:

as you see in the tables and on graphs

**Drupal is noticeably faster then competitors
**joomfish is a break for Joomla but it is very important extension and very likely it is installed on your system
**without JoomFish Joomla! can be even faster then Typo3

Joomla! Beginners guide: [http://docs.joomla.org/Beginners]

Joomla developer network: [http://dev.joomla.org/]
which includes very useful:
Joomla framework API: [http://api.joomla.org/]
Joomla! tutorials on Wiki: [http://dev.joomla.org/component/option,com_jd-wiki/Itemid,32/]

Joomla! forum: [http://forum.joomla.org]

1. project structure

It is useful during development to keep the code in only one place. You can easy use this structure with your IDEs [http://en.wikipedia.org/wiki/Integrated_development_environment] and VCS [http://en.wikipedia.org/wiki/Version_control_system]

It is recommended to use next structure:

project-root
	com_component
		site
			...
			lang
				...
				en-GB.com_component.ini
				de-DE.com_component.ini
			component.php
		admin
			...
			lang
				...
				en-GB.com_component.ini
				de-DE.com_component.ini
			admin.component.php
			install.sql
			uninstall.sql
		component.xml
	mod_module
		...
		lang
			...
			en-GB.mod_module.ini
			de-DE.mod_module.ini
		module.php
		module.xml
	plg_plugin
		...
		lang
			...
			en-GB.plg_group_plugin.ini
			de-DE.plg_group_plugin.ini
		plugin.php
		plugin.xml
	tpl_temlate
		template.xml
	...

After creation of project structure prepare installation packages with help of Joomla! tutorials and install them to Joomla!. We will work with local installation (or dedicated server in your LAN) because another variants decries performance of developers.

After extensions installation process change files of extensions installed to Joomla! with GNU/Linux symbolic links [http://en.wikipedia.org/wiki/Symbolic_link] or Windows Vista symbolic links [http://en.wikipedia.org/wiki/NTFS_symbolic_link] of your project files.
Note: Don’t forget to use option “Options +FollowSymLinks” for Apache web-server for directory where your Joomla! installed to use symbolic links.

In Joomla! filenames of extensions has special structure. In mentioned structure names of corresponding extensions in filenames and directories replaced with words component, module, and plug-in. The word group in files of plugin replaces name of group to which plug-in relate to [content, editors, search, system, user].
Every group defines set of events on which plug-in will be triggered.

Ready to use project has following structure of relations: (<== symbol means symbolic link)

PRJ-ROOT/COM_COMPONENT/SITE <== J_ROOT/COMPONENTS/COM_COMPONET
PRJ-ROOT/COM_COMPONENT/SITE/LANG/en-GB.com_component.ini
<== J_ROOT/LANGUAGE/en-GB/en-GB.com_component.ini
PRJ-ROOT/COM_COMPONENT/SITE/LANG/de-DE.com_component.ini
<== J_ROOT/LANGUAGE/de-DE/de-DE.com_component.ini

PRJ-ROOT/COM_COMPONENT/ADMIN <== J_ROOT/ADMINISTRATOR/COMPONENTS/COM_COMPONET
PRJ-ROOT/COM_COMPONENT/ADMIN/LANG/en-GB.com_component.ini
<== J_ROOT/ADMINISTRATOR/LANGUAGE/en-GB/en-GB.com_component.ini
PRJ-ROOT/COM_COMPONENT/ADMIN/LANG/de-DE.com_component.ini
<== J_ROOT/ADMINISTRATOR/LANGUAGE/de-DE/de-DE.com_component.ini

PRJ-ROOT/MOD_MODULE <== J_ROOT/MODULES/MOD_MODULE
PRJ-ROOT/MOD_MODULE/LANG/en-GB.mod_module.ini
<== J_ROOT/LANGUAGE/en-GB/en-GB.mod_module.ini
PRJ-ROOT/MOD_MODULE/LANG/de-DE.mod_module.ini
<== J_ROOT/LANGUAGE/de-DE/de-DE.mod_module.ini

PRJ-ROOT/PLG_PLUGIN/plugin.php <== J_ROOT/PLUGINS/GROUP/plugin.php
PRJ-ROOT/PLG_PLUGIN/LANG/en-GB.plg_group_plugin.ini
<== J_ROOT/ADMINISTRATOR/LANGUAGE/en-GB/en-GB.plg_group_plugin.ini
PRJ-ROOT/PLG_PLUGIN/LANG/de-DE.plg_group_plugin.ini
<== J_ROOT/ADMINISTRATOR/LANGUAGE/de-DE/de-DE.plg_group_plugin.ini

As you see languages files of plug-ins installed to administration part of Joomla!. Why so, ask Joomla! developers.

2. internationalization (i18n)

Most of extensions require internationalization. This mechanism is simple to use in Joomla!, but it has some ambiguous decisions.

To use internationalization support of text messages in the code of extensions instead of output of simple strings we should use next construction: JText::_(‘text message’); This call check current locale and using appropriate localization file returns required string.

For instance if current locale is ‘en-GB’ then it seek for appropriate file:
for “site part” of Joomla!: joomla-root/language/en-GB/en-GB.com_component.ini
and in that file I look for sting with id ‘TEXT MESSAGE’

If it can’t find appropriate file then it returns passed string.

Structure of localization file:
identifier=value

identifier – is a string, it should be written in UPPER CASE.
Value – is a localized value.

Example:
We need to output 2 internationalized strings
echo JText::_(‘This is test message.’);
echo JText::_(‘Hello world.’);

Then we create localization file for appropriate locale en-EN.com_component.ini:
THIS IS TEST MESSAGE=This is test message.
HELLO WORLD.=Hello all.

de-DE.com_component.ini:
THIS IS TEST MESSAGE=Das ist testen Meldung.
HELLO WORLD.=Halo eine Welt.

I want to note that in order to use that mechanism for plug-ins you should invoke method loadLanguage of class Jplugin:

loadLanguage(
[name of localization file],
[path to root directory of site part of admin part of Joomla!]

name of localization file, by default plg_group_plugin.ini path to root directory, can be: “j_root/administrator” or “j_root” (by default)

3. layouts

Layouts is a handy mechanism which let us to avoid using of “if construction” in “view” of the MVC model [http://en.wikipedia.org/wiki/Model-view-controller] which Joomla! 1.5 began to use actively for extensions development.

By default structure of extensions presentation in Joomla (for modules, and components) has next structure:

EXTENSION-ROOT
	VIEWS
	   VIEW
               TMPL
		 default.php
	     view.html.php

Here “view.html.php” file is a common part of presentation which can commonly contains invocations of “model” (MVC) or in other words where we extract data that necessary for data output, and some simple logic.
There is a rule to place mature logic to model or controller(MVC). In the “TMPL” directory we keep different presentations. They contain markup or in other words exact presentation of data. An file “default.php “ is a default layout, so it will be used if we wasn’t selected another one. You can easily create additional layouts adding them to ‘TMPL’ directory files with name “layoutname.php”. In order to select specific layout you should in the controller(MVC) before invocation of display() function
select its name with command: JRequest::setVar(‘layout’, ‘layoutname’);

4. using of AJAX

It is hardy to imagine an application that can be developed nowadays without AJAX. [http://en.wikipedia.org/wiki/Ajax_%28programming%29]

It is much easier to use some javascript library like jquery, mootols, dojo, etc.. to invoke Ajax-based methods. I like jquery [http://jquery.com]. However Joomla! Developers have selected another Javascript library – mootols [http://mootools.net] and so I earnestly recommend to you to use for ajax methods invocations Mootools library. If you anyway want to use your favorite JavaScript library you must switch your library to the compatibility mode.

For instance for Jquery it can be do it with:
var jq = jQuery.noConflict();
then instead of ‘$’ you should use ‘jq’ but anyway keep in mind that most of extensions for JavaScript libraries don’t use that mode and so you will have Javascript error because of name collisions.

Example of MVC flow using Ajax invocation:
- Create task in the controller, ex.: getAjaxData

	“controller.php”:
	function getAjaxData() {
		JRequest::setVar('view', 'viewname');
		JRequest::setVar('layout', 'ajaxlayout');

		parent::display();
	}

- Create layout, ex: ajaxlayout

	“viewname/tmpl/ajaxlayout.php”:
	<?php defined('_JEXEC') or die('Restricted access');

	global $mainframe;
	echo <ajax data>;

	$mainframe->close();
	?>

Important note:
You should add invocation: $mainframe->close();
in order to create output flow or it will add Joomla! standard page after result of you Ajax method. Thus creating concrete layout you can pass any data, don’t forget to setup appropriate header. For XML [http://en.wikipedia.org/wiki/Xml] it can be: header(“Content-type: text/xml;charset=utf-8″);

On client-side yous should make invoke defined method using Ajax call, using URL like:
JURI::root().’index.php?option=com_component&task=getajaxdata’;

5. mapping of tables to the Database

Joomla! using simple ORM system [http://en.wikipedia.org/wiki/Object-relational_mapping].
In order to use this mechanism you should describe your DB structure with sets of objects that inherit JTable.

For example:
foo.php:

<?php
defined('_JEXEC') or die('Restricted access');

class TableFoo extends JTable {
	var $id = null;
	var $bar = null;

	function TableFoo(& $db) {
		parent::__construct('#__foo', 'id', $db);
	}

	function bind( $from, $ignore=array() ) {
		$from['bar'] = strtoupper($from['bar']);
		return parent::bind($from, $ignore);
	}

	function check() {
		if (empty($this->bar)) {
			$this->setError( 'Error message');
			return false;
        		}
		return true;
	}

	function delete( $oid=null ) {
		$res = parent::delete($oid);

		// here if you need you can define mechanism
		// to delete linked tables
		return $res;
    	}
}
?>

First of all it is necessary to define public variables that corresponding to fields names of table. Then you should pass name of the table and name of primary key to the constructor.

key methods:

Bind() method using in order to transfer data from external sources (ex.: requst) into object. Overriding that method you can execute specific data transformations of data before adding to the fields of the object.
Check() method make checking of data in the fields, for example it can check that fields not empty or filled with required range of values, etc.
Delete() method can add specific behavior during deletion of records. For example deleting of linked records.

Also JTable class contains set of other handy methods overriding which you can add appropriate specific behavior.
See Joomla! documentation for details.

possible use:

You can get object in the model (MVC) with following: $row =& $this->getTable(‘foo’);

to delete record you invoke: $row->delete($id)

to store record to db:
$row->bind($data);
$row->check();
$row->store();

If then you need get value of primary key you can simply take the value from the object: $row->id;

Surely it is better to add to described calls check of result of methods executions.

Sidebar – is an area that take place on the left or on the right from main area. Usually on sidebar placed blog common or quick access elements. This elements called widgets.
Common examples: authors, tags, categories, etc.

In the world of WordPress widget is a plugin subtype. That is activation/deactivation of widgets realized thru the control panel of plug-ins.

Status control of widgets managed in the Design/Widgets panel. There you can add/remove widgets from/to sidebar and change their parameters.

1. How to add new widget

Since widget is plug-in it is behavior like common plug-in in WordPress. In other words it is php-script which placed in directory/subdirectories “/wp-content/plugins”. For correct information representation widget(plug-in) should has header like above:

‘Plugin Name’ field described symbolic plug-in name in the system.
‘Plugin URI ‘ contains link to plug-in description.
‘description’ description.
‘version’ version
‘Author’ author name
‘Author URI’ uniform resource identifier

In the upshot in order to add new widget to the system we should:
create file “simple-sidebar-widget.php”
add to file described header
copy file to directory “/wp-content/plugins”

Then in the plug-in control panel we have new plug-in with our name:
‘Simple Wordpress Sidebar Widget’

simple-sidebar-widget.php

2. Plug-in registration

In the first step we have added simplest plug-in (but not widget yet)
In order to transform it to the widget, we should register it.

Code for sidebar registration:

To work widget should contain at least 2 functions:
*initialization (here simple_sidebar_widget_register)
*content generation (here simple_sidebar_widget_content_gen)

To get control in the our code we should create hook on some event. We have 2 events to select from. In our case I have selected ‘init event’ (raised when system loaded and initialized).
Hook created with help of add_action function, as parameter to it passed ‘name of event’ (init) and name of handler function (simple_sidebar_widget_register).

If event raised function simple_sidebar_widget_register receive control and perform following actions:
*check possibility to create widget with help of accessibility of widget registration function – function_exists(‘register_sidebar_widget’).
* if required function is accessible it register widget

As you see register_sidebar_widget function receive 2 parameters:
first contain localized name of widget in the widget control panel.
second link to functionality of content-generator (’simple_sidebar_widget_content_gen’).

Now we have full-fledged widget that can be viewed in the widget control panel, it can be added to sidebar (don’t forget to activate it in the plug-in control panel).

3. Representation

If you add our widget to the sidebar it will not show anything. To find any result you should add function of content generation in the following way:

First thing that we do is from array of arguments of function that extract variables we create set of variables.

Mainly it is special variables that should be used. Then we create content of widget: in fixed order we output values of special(which contain basic widget markup) and defined variables.

Now we can see our widget on sidebar.

4. Widget setup

If you want to have possibility to setup widget you should change code to the following:

What changed in our code:

In function ’simple_sidebar_widget_register’ one invocation added (‘register_widget_control’), it register function which catch widget configuration change event (’simple_sidebar_widget_control’).

In the generator of widget content additional code added that receives current configuration of widget get_option(’simple_sidebar_widget’).
Here parameter ’simple_sidebar_widget’ is identifier of parameters set that used in our widget.
Then into variables $show_content and $widget_content extracted current values of parameters.

As I already noted for event processing of configuration changes we should add appropriate event-handler function (’simple_sidebar_widget_control’). In this function we extract parameters from request and analyze changes, also this function create content of configuration form (this functionality moved to ’simple_sidebar_widget_control_gen’).

After we added above code in the parameters of widget we have 2 fields.
One field contains content that should be outputted.
Second field is a switch which allow/forbid output of content.

In closing I want to note that widgets work only with themes that support sidebar.
Described methodology work for WordPress >=2.5, although it is almost the same for previous versions.

related links:
plug-in development – http://codex.wordpress.org/Writing_a_Plugin
list of actions – http://codex.wordpress.org/Plugin_API/Action_Reference
localization: http://codex.wordpress.org/Translating_WordPress