Now there are a lot of articles out there that give pointers on how optimize your blog/site to reduce bounce rate, so I’m not even going to try and talk about that here. If you are after a good source of information, however, I’d recommend checking out problogger. What I am going to talk about though, is how you can use Google Analytics to determine where to focus your efforts. Google Analytics is very good at showing your overall bounce rate, but you can get more detail and start targeting particular posts and keywords to reduce that bounce rate.

Right, let’s get started:

Update: While the instructions below definitely give a good overview of how to complete the task, I subsequently decided to put together a screencast that guides you through the process more slowly. For those who like textual instructions, the original instructions are below the screencast.

Firstly, head over the Google Analytics top content report, which can be found under Content > Top Content.

Next, add the keywords for the content to the report. The image to the right shows how to do this, but basically look for the drop-down list to the right of the Page column heading.

Activate the advanced filter so we remove all of those pages that haven’t been hit as the result of an organic search.

Add a filter to exclude the string “(not set)”, removing those non organic search pages.

Now switch Google Analytics to the performance view of the report. This can be done by selecting the third icon along in the views selector, which is located top-right above the report table.

Now that you are in performance reporting mode, switch the performance field over to reporting on bounce rate. This can be done by selecting “Bounce Rate” from the individual page performance drop-down in the column heading of the report.

The end result will look something like what’s displayed below. Thankfully I’m not too susceptible to stats-envy

Now to make this report truly useful, I would recommend extending the timeline for the report to longer than a month (at least when first analysing the data). For my blog, I chose a six-month period. It’s certainly very telling. For me, I can see that I’m getting a fair bit of organic search traffic for android web applications on my iPhone and Android Web Application Frameworks post. Certain keyword combinations do better than others, but overall this could definitely be improved. So what does this tell me. Well if I have a few posts in the wings, then if I’m thinking about one related to Android that should take priority. Post it, and make sure I promote it from the post getting good organic traffic.

Finally, I used the Google Analytics export to PDF functionality to provide myself a good optimization worksheet. Before I did this though I did add an additional filter to cull some of the lesser visited pages on my site.

Anyway, I hope that’s as helpful to someone else as I found it myself, and certainly if there are other useful Google Analytics tips that people know I’d certainly love to hear about it.

The trick here is to call on your old friend, regular expressions. There are a few things you need to do to make it all look pretty. In my case, I wanted to have line breaks where they appeared in the chat log, the time entries displayed in italics and the chat participants names bolded.

So without further ado; using your favourite regular expression powered text editor run the following regular expressions (you will probably need to break them into component parts to run them):

Step 1 – Get Linebreaks into the chat log
2 Spaces required at the each of every line to tell markdown to insert a line break:

/(.)$/$1 /g

Step 2 – Italicise the time markers
*blah* instructs markdown to italicise the text:

/(\d{1,2}\:\d{2}\s(A|P)M)/*$1*/ig

Step 3 – Bold the participants names
**blah** instructs markdown to bold the text:

/((\*|M|^)\s\w+\:)/**$1**/ig

That oughta do it. You can now drop your chat log into any markdown syntax enabled tool (including unfuddle).

The following article gets you well on your way:
http://code.google.com/appengine/articles/django.html

One problem, however, is that there have been some changes in django that mean the code they provide to call initialize django from your main.py script doesn’t work. Change your main.py script it to what is displayed below, however, and it all works fine:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

import logging, os, sys
 
# Google App Engine imports.
from google.appengine.ext.webapp import util
 
# Remove the standard version of Django.
for k in [k for k in sys.modules if k.startswith('django')]:
  del sys.modules[k]
 
# Force sys.path to have our own directory first, in case we want to import
# from it.
sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
 
# Must set this env var *before* importing any part of Django
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
 
import django.core.handlers.wsgi
import django.core.signals
import django.db
import django.dispatch.dispatcher
 
def log_exception(*args, **kwds):
 logging.exception('Exception in request:')
 
# create a new signal object
sig = django.dispatch.Signal()
 
# Log errors.
sig.connect(log_exception, django.core.signals.got_request_exception)
 
# Unregister the rollback event handler.
sig.disconnect(django.db._rollback_on_exception, django.core.signals.got_request_exception)
 
def main():
  # Create a Django application for WSGI.
  application = django.core.handlers.wsgi.WSGIHandler()
 
  # Run the WSGI CGI handler with that application.
  util.run_wsgi_app(application)
 
if __name__ == '__main__':
  main()

The key being that django.dispatch.dispatcher no longer works, and you need to create a django.dispatch.Signal instance and use that in place of the dispatcher.connect and dispatcher.disconnect function calls.

Update:
Thanks to @joerussbowman for the heads up on app-engine-patch which is a quick and easy way to get up and running with django on appengine. Definitely recommend checking it out.

Now these textures are great but you are probably going to have to use some really large images if you want to use them on your site, and I really didn’t want to have to. Thankfully the GIMP includes a filter to make an object seamless, which means you can tile it effectively as the page background of your site.

To make an image file tileable, simply open the image in GIMP, and then from the Filters menu, select Map > Make Seamless. No options are required, it just works (see below for a before and after pics).

Before

Before

After

After

Website Monitoring Strategy Architecture

Monitoring Architecture

The design of this architecture is focused on getting the best “bang for your buck” monitoring.  That is, services that you can monitor from your own internal network you should, but obviously you want something keeping an eye on the the monitoring service (who watches the watchmen?).  This is where the services listed in the wikipedia article should be investigated.  In addition to implementing the external monitors to ensure the internal monitoring services are operating, it is probably worthwhile having the external service monitor some of the key services also (you usually get more that one monitored service with hosted monitoring solutions).

In terms of how you monitor the internal solution, there are a number of options, but depend on how you can set things up.  The simplest strategy that is fairly effective, is to write a small file (deleting any existing file first) on one of the monitored webservers as one of the actions the internal monitoring server completes during its “rounds”.  That webserver should then have a very lightweight script deployed to it to check that the creation date of the file is within certain tolerances (say up to 5 minutes).  This script is an example of what I call a “full stack health check”, which I cover in the next section.

Implementing “Full Stack Health Checks”

In my opinion, the most efficient and effective way to implement health-checking on web and application servers is to write lightweight scripts that do what your application is going to do.  For instance, a health checking script that is being used to monitor the health and availability of a web application that uses a database (fairly common), should at least make a connection to the database and perform a simple select statement to ensure that the database is available as well as the webserver.  In most instances, it can be possible to attach a monitoring service to the main page of a website to achieve a similar result; however, it is common for high-traffic webservers to use caching mechanisms to improve response times and in these cases, a monitoring solution would not pick up a problem that will show itself to the public soon enough.  Given this example, implementing  health check scripts and deploying them in their own directory on the webserver (and setting up some caching exceptions where appropriate) might give you a heads-up to fixing a problem before the general site public even notice.

When writing a “full stack” check, my recommendation would be to simply return the text “OK” in the case that the stack of services validated in the call are operational.  When a particular component of the stack is not operational, however, rather than simply returning “Broken” (or something similar) you should return something helpful, and this could be the text of an exception message, or something that you have determined to be the cause of an error with that component.  This failure message text (if kept short) can be emailed and SMSed to the on-call staff, and give them a heads up as to any other key members of staff they might need to involve to fix a problem.  For example, a message such as “database blah could not accept connection” could give a web support programmer the heads up they will probably need to get a database administrator on the phone to help with assisting the problem.

Build a Monitoring Catalogue

Still on my to-do list is to build a catalogue of monitoring end-points that relates back to critical websites and applications that I am responsible for maintaining at the company where I work.  This catalogue is then used to ensure that suitable coverage of key services is covered by whatever monitoring strategy is put in place.

Installing Ubuntu 8.10

Installation of linux on the wind can be done in one of two ways:

• By using an external DVD/CD drive to install the OS (very simple)
• By using a bootable USB key.  This is the method I used, and these instructions proved invaluable to complete the process.

Getting the Inbuilt Wifi device working

My recommendation is to download the appropriate drivers and compile the new required modules for the current kernel version.  Detailed instructions on how to do this can be found on the wind wiki.

Installing the touchpad driver installed

Now apparently there are two different versions of touchpads, so depending on which one you have your experience may vary to mine.  My wind shipped with the synaptic touchpad, and apparently I’m quite lucky as it worked out of the box.  I believe MSI have changed touchpad vendor and the experience isn’t quite as pleasant for that variant.  

Once I have figured out how to configure the touchpad (currently investigating tpconfig) I will update this post.

Card Reader Configuration

The following blog post has some excellent pointers:

http://kd-signofthetimes.blogspot.com/2008/09/advent-4211-sd-cardsolved.html

Summary

All the information is out there for anyone to install linux on their wind, and personally I recommend it. In the ultraportable space I believe linux kills the competition.  I would highly recommend the msiwind.net site, as the forums and wiki are invaluable for all things windy.

Step 1 – Linux Installation

Well I started with an Ubuntu 8.04 server install, selecting the LAMP, OpenSSH and PostgresSQL server options.

Installing Extra Packages that will be required during the install

Some additional packages will need to be installed to handle the installation succesfully.  Running the following commands should take care of this:

sudo apt-get install curl
sudo apt-get install php5-cli
sudo apt-get install php5-pgsql
sudo apt-get install php-pear

PHP Pear Packages Configuration

In addition to some ubuntu packages, you will need some php packages installed as per the matrix prerequisites.

sudo pear install DB Mail Mail_Mime XML_HTMLSax XML_Parser Text_Diff

Step 2 – Database Configuration and Preparation

As per the instructions on the matrix site, we need to prepare the database for the installation of the MySource Matrix product.  Now most of the information that I am using to setup the Postgres installation comes straight from the postgres page on the ubuntu community site:

https://help.ubuntu.com/community/PostgreSQL

Creating the database users

sudo -u postgres createuser -D -P matrix
sudo -u postgres createuser -D -P matrix_secondary

To the prompts regarding superuser and roles, answer no to both questions.  The -P password parameter tells the createuser command that you want to set a password for the user.  Initially I didn’t use the password parameter but found the matrix database installation failed when I used no password (as such, I ended up having to use the psql console to alter the users).

Creating the database

sudo -u postgres createdb -O matrix -E SQL_ASCII mysource_matrix

Installing the PLPGSQL language into the new database

sudo -u postgres createlang plpgsql mysource_matrix

At this stage we should now have the database installed and available for the matrix installation, so let’s get cracking with that.

Step 3 – Matrix MySource Download and Installation

From here, you can pretty much pick up from the matrix installation instructions as per the Squiz site:

http://matrix.squiz.net/resources/installation

There are only a few differences:

• When changing the ownership of the data and cache directories, use the user and group of “www-data” instead of “apache”.
• Configuring hosts on apache on Ubuntu can be done better that what is specified in the installation instructions (see below), so I’d recommend having a bit of a read on the apache documentation.  But in essence, what you will probably be doing is creating a config file in the /etc/apache2/sites-available directory and then creating a symbolic link to it in the /etc/apache2/sites-enabled directory.

Step 4 – Leaning up your Machine

If you like me have created a virtual machine for your Matrix install, then you probably want to get rid of some of the extra stuff that has been installed as part of an out-of-the-box Ubuntu server installations (using the installation options I indicated towards the beginning of the article).    Based on the 8.04 version of the install, I performed the following steps to clean up a little:

TO BE COMPLETED…

Some Extra Notes – Port Forwarding with VirtualBox

As I have set up my Matrix install as a VirtualBox virtual machine using NAT networking, it was important to enable port forwarding to enable access to the webserver on the machine (as well as the SSH server).  To assist with this process the following article has some excellent information on how to set this up:

http://www.aviransplace.com/2008/06/12/virtualbox-configuring-port-forwarding-with-nat/

To make this process a little quicker, I created a batch file so I could do take care of things with one command:

SET VBOXPATH=C:Program FilesSunxVM VirtualBox
"%VBOXPATH%VBoxManage" setextradata %1 "VBoxInternal/Devices/pcnet/0/LUN#0/Config/%2/Protocol" TCP
"%VBOXPATH%VBoxManage" setextradata %1 "VBoxInternal/Devices/pcnet/0/LUN#0/Config/%2/GuestPort" %3
"%VBOXPATH%VBoxManage" setextradata %1 "VBoxInternal/Devices/pcnet/0/LUN#0/Config/%2/HostPort" %4

Which allows me to run the following command, instead of having to execute the three separate commands as per the article above:

VBoxPortForward "Local Matrix Server" Apache 8080 8080