This graph is simply information I collected about the size of the source code files for various plugins. There is also a general graph comparing the sizes of the core. I had started to do a comparison of binary sizes, but because of the optimizations and debugging builds I have – it might be a while before I could get accurate numbers for that.

This is a misleading name because it does more than just monitor the scaling, it allows you to change it easily. Most people disregard these settings because many settings like this don’t make a huge difference in other applications. There is one place it makes a big difference, which is the mother of all CPU users: Web Flash-based video. This thing basically physically abuses your processor. You can use flash little performance tests to get an idea of how CPU scaling affects your hardware.

In the same way, I find that actually making use of the Powersave and other options when on battery. On desktop systems where power consumption isn’t an issue, this setting will always be set at Performance. While Ondemand is rather good for typical use, some users find that it degrades response-time for things like Compiz.

Also remember that IOWait is typically the bottleneck for a lot of applications. I chose to use Flash as an example because it does a poor job of accomplishing it’s job and as a result requires a magnitude of additional computational power. You can easily compare the amount of processor usage to anything like VLC, Totem, or Mplayer and they will be a fraction of the usage.

While it’s not as complete as sdljava, it’s much smaller and is hand written. While the idea of hand-writing lots of C wrapper code seems daunting, it was not much more than writing a class with many native methods, running javah and writing some simple glue. Here is quick rundown of what is supported:

• Video functions including support for OpenGL bindings. We also provide our own very small GL bindings, GLbits.
• Audio functions with support for callbacks to generate audio from Java.
• Event functions (including SDL_SetEventFilter with a callback) and simple class system that allows for use of instanceof.
• Joystick, Keyboard, and Mouse functions for polling device input.
• Time functions like SDL_Delay and SDL_GetTicks incase their Java counterparts have undesired affects

However, it’s also important to note what wasn’t implemented:

• Input/output (RWops) for files, since a java.io.File or java.nio.FileChannel (and variants) should be used instead.
• Thread functions for SDL, since java.lang.Thread should be used instead.

While the code is not 100% complete, it can easily be thought of as at least 85% completed, and work will continue as warranted. It doesn’t hurt that the code is licensed under the LGPL, so anyone can modify and commit changes. Even though the code isn’t complete I compared the amount of both C and Java code between the projects:

The default configurations for TCP in Ubuntu and Debian are good, but they aren’t profiled to meat your specific connection. Last I checked I believe they are defaulted to a DSL-like connection, which is probably somewhere in the middle-ground between dial-up and high performance broadband. Here are some simple additions you can make to your /etc/sysctl.conf file (as root):

net.core.rmem_default = 524288
net.core.rmem_max = 524288
net.core.wmem_default = 524288
net.core.wmem_max = 524288
net.ipv4.tcp_wmem = 4096 87380 524288
net.ipv4.tcp_rmem = 4096 87380 524288
net.ipv4.tcp_mem = 524288 524288 524288
net.ipv4.tcp_rfc1337 = 1
net.ipv4.ip_no_pmtu_disc = 0
net.ipv4.tcp_sack = 1
net.ipv4.tcp_fack = 1
net.ipv4.tcp_window_scaling = 1
net.ipv4.tcp_timestamps = 1
net.ipv4.tcp_ecn = 0
net.ipv4.route.flush = 1

The easiest way to make these configuration changes and apply them is to press ALT+F2 and run gksudo gedit /etc/sysctl.conf (you can copy and paste that), which will open up the text editor. Paste the above changes at the end of the file, save, and exit. Now press ALT+F2 again and enter gksudo sysctl -p to apply these changes. If you want to see what these commands are doing you’ll have to press the Run in Terminal button instead of just Run.

Another trick is using ionice to give different processes more priority on reading and writing to your file system. A good example is the Transmission torrent client, which I prefer to run in the background most of the time. You have to get the Process ID (PID) by using the System Monitor, which can be ran from the Administration menu or by pressing ALT+F2 gnome-system-monitor. Go to the process list and find the name of the program (transmission in this example), copy the PID, and then press ALT+F2 gksudo ionice -c 3 -p 1234 where 1234 is instead the PID. I used 3 here to make it use Idle scheduling, but you can use 1, 2, and 3 for varying degrees. See man ionice for how that works in detail.

• Cutting down on HTTP requests, which are limited to 2 per domain. If you know your front page will require 10 CSS files for the different components or widgets, then just serve it as one single request.
• Lower total size of files due to increased compression dictionary. For instance, if a CSS property is used twice it will likely reference the dictionary second time. (Compare to making a tar.gz of all your cs/js files to just zipping them)
• “Bundles” will stay cached on the client and each bundle is a unique ID. Areas that have different functionality on your site will require different bundles of stylesheets.
• Minifies your Javascript and CSS (or uses minified files), but doesn’t alter any of your files. (Keeps a cache)

Basically bandwidth is better spent just transmitting the files you will likely need at a later time. A good example is with stylesheets. Most pages have a base stylesheet that gets applied to every page, let’s say that’s 15 KB. Let’s say the user navigates to another page, but they won’t have to download that base stylesheet again since it’s likely cached, but they will have to download the new stylesheet for things specific to that page. The idea is to create a “bundle” of stylesheets that should be loaded together, so they won’t have to load another until they navigate to some drastically different area.

The same concept is used for Javascript being served, although the impact is much greater. A common site will easily tip the scales at 150 KB of scripts before being optimized.

We’ll be making the Diet framework available under the LGPL license. While it will be part of our Twig framework, we think it’s important for it to be easy to separate.

CSS Sprites, simply put, are a win-win. Steve Souders explains this well in his High Performance Web Sites: 14 Rules for Faster Pages on YUI Theater. I think the most critical element here is that it significantly cuts down on HTTP requests, which are the serious bottleneck due to a standard limit of 2 per unique domain name.

A common complaint about this method is that combining all the images into a larger one creates a “waste of space”. Indeed there will be small gaps between your images, however:

• You should be using PNG (8-bit if you can) for this image. These image formats use lossless compression, and long contiguous areas of empty space will be compressed so well it won’t affect the size of the resulting file.
• Multiple images inside a PNG-8 will share the same palette and may reduce the file size. Before compression this is about 0.7 KB per image. Creating just a 3×3 grid of CSS sprites this yields 20KB of savings.
• The compression dictionary will be much better with multiple images. With a single 16×16 icon there likely isn’t many data patterns that can be used to reduce the size of the file. With multiple images you’re compression ratio will become higher because there is more similarities to take advantage of in the image.

Cutting down on file size is always nice, but really it’s the fact that you’ll be making much less HTTP requests to the server. Anyone using Firebug will notice that most of the time is spent establishing a connection to the server. This is because many servers have a limitation on concurrent HTTP transactions.

Don’t forget to put different types of content on different sub-domains if you have that option. Stylesheets, scripts, and images can all be on separate domains, although it can be tedious to get stylesheets and images on separate domains since you’ll lose relative pathing.

I’ve tried all the “fixes” (such as setting vm.swappiness to 0), but I think it’s time to just go without a swap partition. If I can find out how to get the swap to only mount when it will be needed that would be great, but otherwise I’ll setup a daemon script that simply checks the current usage level, and if over say 75% runs swapon -a.

Just to be clear I’m not running Apache, MySQL, or PHP on this machine, which may use the swap in this way legitimately.

You think I’m crazy? Well, maybe since I am talking to a imaginary reader for the sake of writing this post, but the statistics about my swap usage just don’t add up:

• I’ve got 2GB of RAM in this notebook.
• I never see it go beyond 800MB of actual usage. (Unless I am running my Virtual Machine for XP to test IE7)
• sysctl vm.swappiness gives “vm.swappiness = 0″.
• That’s great that it’s low, but it’s using my swap which is much slower and unneeded, while there is still 1GB of untouched memory.

What’s the point in having 2GB of memory if the kernel is going to fight and keep me below 1GB usage?