“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].

JoomFish heavily influences Joomla! performance and with new release of JoomFish we have a question: which performance changes we have with new version of JoomFish 2.0b2.

New revolution today, no just another good enhancement

Testing conditions exactly like in previous test:
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
CMSs returned specially prepared page contains:
menu, login form, 2 articles with overall size 40Kb
Testing series contains results for 1, 10, and 20 simultaneous users.
Caching functionally turned off.

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.3
joomFish: 2.0b2

Look on these tables and pictures.
I think you don’t need any conclusions because pictures and table are quite plain.

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

1 user

10 users

20 users

In order to have an access to compilation subsystem we should use classes located at javax.tools package [http://java.sun.com/javase/6/docs/api/javax/tools/package-summary.html].
In the future in this package possibly appear classes to work with different external utilities,
but at this moment we have only access to the compiler.

As simple example let’s look on request to compile:

	JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

	Iterable<SimpleJavaFileObject> srcList =  Arrays.asList(new SimpleJavaFileObject[]{
		new SimpleJavaFileObject(URI.create(”string:///myclass.java”), Kind.SOURCE) {

			@Override
			public CharSequence getCharContent(boolean ignoreEncodingErrors) {
				return “class myclass {}”;
			}
		}
	});
       JavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
       compiler.getTask(null, fileManager, null, null, null, srcList).call();

Let’s try to understand how it’s work:

The compiler access input data not directly but via objects inherited form JavaFileObject.
Therefore depending on needs of developer information for compilation can be received from any place:
network, file, memory; for that we need to implement successor of JavaFileObject.
It is better to do it by inheriting class-gag SimpleJavaFileObject

In our example implementation of SimpleJavaFileObject returns source of class as constant string.

It is slightly harder with output data. There is another abstraction layer called JavaFileManager that is
object factory per se.

Standard file manager that we receive in our example let us work with files on the disk. If you need to place output data
on the network on in the memory you need to override JavaFileManager. It is better to do it inheriting
ForwardingJavaFileManager, this class retarget request to provided during creation file manager.
At the same time you can handle only those request that you need.

Last string of example creates compilation command and execute it at once. As a result of execution we have file
in the execution directory of example with name myclass.class that contains bytecode of appropriate class.

It is noteworthy that classloaders of system know nothing about existence of given class and so call
Class.forName(“myclass”) throws ClassNotFoundException.
Let’s complete our example to get class bytecode as byte array. For that we need to implement our own file manager:

public class JavaMemFileManager extends ForwardingJavaFileManager {

	class ClassMemFileObject extends SimpleJavaFileObject {
		ByteArrayOutputStream os = new ByteArrayOutputStream();

		ClassMemFileObject(String className) {
			super(URI.create("mem:///" + className + Kind.CLASS.extension), Kind.CLASS);
		}
		byte[] getBytes() {
			return os.toByteArray();
		}

		@Override
		public OutputStream openOutputStream() throws IOException {
			return os;
		}
	}

	private HashMap<String, ClassMemFileObject> classes =
			new HashMap<String, ClassMemFileObject>();

	public JavaMemFileManager() {
		super(ToolProvider.getSystemJavaCompiler().getStandardFileManager(null, null, null));
	}

	@Override
	public JavaFileObject getJavaFileForOutput(Location location,
			String className, Kind kind, FileObject sibling) throws IOException {
		if (StandardLocation.CLASS_OUTPUT == location && JavaFileObject.Kind.CLASS == kind) {
			ClassMemFileObject clazz = new ClassMemFileObject(className);
			classes.put(className, clazz);
			return clazz;
		} else {
			return super.getJavaFileForOutput(location, className, kind, sibling);
		}
	}

	public byte[] getClassBytes(String className) {
		if (classes.containsKey(className)) {
			return classes.get(className).getBytes();
		}
		return null;
	}
}

As you see our file manager override method getJavaFileForOutput that complier calls to receive output file object.
Here we check destination, for new classes it should be StandardLocation.CLASS_OUTPUT and type.
If it correspond to newly compiled class then we create new file object: we save it and pass it to the compiler.
Then we can receive access to the bytecode with method getClassBytes(className) passing the name of the class.

Let us change previous example to use new functionality:

	....
	JavaFileManager fileManager = new JavaMemFileManager();
	compiler.getTask(null, fileManager, null, null, null, srcList).call();

	byte[] myClassBytes = ((JavaMemFileManager)fileManager).getClassBytes(“myclass”);
	….

And yet one feature of example execution in our case will be absence of file on the disk.

Finally I made a library that makes easier access to Java6 Compiler API.
See details on: [ http://opensource.helion-prime.com/jruntime/ ]

Our world is currently in transition from traditional desktop applications to web-oriented where most of time we want to do everything in the Web with help of our browsers.
Sometimes nevertheless we want to use some web-applications like: Gmail, Google docs, FaceBook or on-line dictionary as desktop application. Is it possible ? Try the Prism.

prism world

With Prism you can run web-oriented applications directly on desktop in their own window where they have access to all windows features and you still can access these same applications from your web browser.
Prism is built on Firefox so it supports all rich internet technologies and runs on Windows, Mac OS X, and Linux.
Also Prism developers thinking how to integrate better the Prism with Firefox,
enabling one-click “make this a desktop app” functionality that preserves a user preferences.

For more information about Prism go to the project page: [http://developer.mozilla.org/en/docs/Prism]
When invoked it is as pretty as following picture:

getting Started with Prism

download and install appopriate version for your platform:

Prism for Firefox v0.2 for Firefox 3.0b3pre or greater, Windows/Mac/Linux.

The standalone version of Prism v0.9 is also available:
for Windows (installer, archive), Mac and Linux.

Mozilla foundation wants for you

Prism is open source project and if you want to help Mozilla with Prism development go to:
[http://wiki.mozilla.org/Prism]
forum for discussions: [https://labs.mozilla.com/forum/index.php/board,16.0.html]
Bugzilla for bug reporting: [https://bugzilla.mozilla.org/enter_bug.cgi?product=Mozilla+Labs&component=Prism]

There is set of plug-ins that really simplify development process and glance will help you select something for your daily work.

golden list

name: firebug
functions: edit, debug, and monitor CSS, HTML, and JavaScript live
hints: page loading analysis, live working with CSS styles, JavaScript debugger
add-on page: [https://addons.mozilla.org/en-US/firefox/addon/1843]

name: user agent switcher
functions: switch the user agent of the browser
hints: cool but IE, and Firefox still interpret code differently and anyway for interpretation tests you need ‘ies4linux’ [http://www.tatanka.com.br/ies4linux/page/Main_Page]
add-on page: [https://addons.mozilla.org/en-US/firefox/addon/59]

name: firesizer
functions: resize of firefox the window to specific dimensions
hints: it helps to test site in required resolutions
add-on page: [https://addons.mozilla.org/en-US/firefox/addon/5792]

name: SQLite manager
functions: manage SQLite databases
hints: I think you know why it is better to use SQLite DB on workplaces
add-on page: [https://addons.mozilla.org/en-US/firefox/addon/5817]

name: add N edit cookies
functions: allows you add and edit session and saved cookies in live
add-on page: [https://addons.mozilla.org/en-US/firefox/addon/573]

If you use RoR [http://en.wikipedia.org/wiki/Ruby_on_Rails] then you already know that
ERuby [http://en.wikipedia.org/wiki/ERuby] is pretty enough and you don’t ever think you need something else.

Haml {markup haiku}

Haml is an alternative way to code your “views”. It can be much easier, look on these examples:

XHTML:
<strong class=”code” id=”message”>Hello, World!</strong>

Haml:
%strong{:class => “code”, :id => “message”} Hello, World!

XHTML:
<div id=’content’>
<div class=’left column’>
<h2>Welcome to our site!>/h2>
<p>
<%= print_information %>
</p>
</div>
<div class=”right column”>
<%= render :partial => “sidebar” %>
</div>
</div>

Haml:
#content
.left.column
%h2 Welcome to our site!
%p= print_information
.right.column= render :partial => “sidebar”

like it .. so give you a try with Haml..

haml site: [http://haml.hamptoncatlin.com/]
haml docs: [http://haml.hamptoncatlin.com/docs/]

Yahoo! corporation [http://en.wikipedia.org/wiki/Yahoo!] has world busiest and largest database.
System has build for analytical purposes, and contains history of web-users behavior.
It has size: 2-petabyte, and loading about 24 billion events a day.
Engineers of Yahoo expect size increasing up to 5-petabyte by next year.

In order to compare sizes:
USA Revenue Service DB: about 150 terabyte
Ebay: overall size: 6-petabyte, size of biggest system: about 1.4-petabyte

We should understand that we are talking about DBs. Because there are data repository with much greater sizes but data in such repositories practically unaccessible for analyzes and processing.

Surely it is nice to know that it works on modified PostgreSQL [http://en.wikipedia.org/wiki/Postgresql].
PostgreSQL continues active development and prove status as best open-source RDBMS.

As we remember in 2007 year Sun Microsystems [http://en.wikipedia.org/wiki/Sun_microsystems] published
production test [http://www.spec.org/jAppServer2004/results/res2007q3/] which showed that tuned PostgreSQL performance
is very close to Oracle DB [http://en.wikipedia.org/wiki/Oracle_db]: difference only about 15%. Don’t forget about price of Oracle DB.