Luckily they could get away with read-only access at these locations, so the trick is being able to take the live SugarCRM application with all its data, and running it on a PC.

The path of least resistance was to run the CRM application in virtual machine on the laptops. The live application is about 1 GByte in size, runs on Linux, uses PHP 5.3 and MySQL.

So, we have an application that runs on a cloud-based virtual server, and also want to run that same server on a PC under Windows. My first thought was that the cloud-based virtual server could simply be picked up, i.e. cloned, and dropped onto the PC. That was the first hurdle – finding a cloud service where we could clone the server and download the clone. We could not find one, however.

Although cloud servers use virtualisation and servers can be cloned in the cloud, those clones were not something we could download and run locally. I suspect it has more to do with client lock-in than with the technology. We could install our own virtualisation layer on top of our cloud server, but that would mean a whole new level to manage – another operating system, with all its upgrade, configuration and security issues to handle. So that, unfortunately, was out.

So as far as cloning the application is concerned, we would be copying the scripts (using rcync) and exporting the database, then loading it all up on a local machine. That is not too much of a hassle as it can all be scripted.

So that takes us to the target machine: Linux on a PC.

I looked at VirtualBox, with is true Open Source, free and runs on just about anything. It works impressively, and can be installed on just about any host operating system, so will work in the field on Windows laptops or Macs. I did find it was a bit of a resource hog, however, so not sure how it would work on an older PC.

I did not want to get involved in setting up and configuring an OS to host the SugarCRM application from scratch, so looked around for ready-built virtual servers. VirtualBoxImages.com had a tidy array of virtual servers to download, and I tried a couple. None quite hit the mark though: PHP5.3, simple to install a PHP application, and no need for a GUI. Most provided a full GUI, which was just overkill. I want a virtual machine I can send to an end user, get them to run the machine, then access the application through a web browser on their machines. It needed to be simple, and just work without any messing around in the GUIs of the guest operating system.

Given this, and my concern about resources, I kept looking around at other virtual machine solutions. I eventually stumbled on VMware. This has been around for a long time, and due to its commercial nature I kind of dismissed it for cost reasons. However, the VMware Player is free to install and use. If you have a VMware image of a machine, then you can run it up on a PC with little bother.

So where to get a suitable VMware image? This is where I stumbled on Bitnami. This service provides ready-made Operating System images, and additional “stacks” that sit on top of them. The OSs are stripped down to just what is necessary to run the stacks. The stacks are applications set up to install on the OSs with the minimum of effort.

In my case I had the “stack” – a live SugarCRM application, and just needed the base OS. There is a nice one called LampStack, which is a Ubuntu OS with PHP 5.3, MySQL, and a collection of other goodies ready to run most PHP applications. It is all bundled up into a VMware image so it can be dropped in and just works – and it really does. It took a couple of hours (with some excellent help from the Bitnami community) to get the full production copy of SugarCRM running on the LampStack virtual machine on my laptop.

Resource-wise it works great too, and is no slower then the production application on the cloud server, while just ticking over on the CPU. It is eating about 4Gbyte of disk space so far, but that is not an issue – everything these days is massive.

I’m going to roll this out to the client this week, as they are going to be flying out to the jungles (Honduras, Mexico, Cuba, and a far other far-flung locations) within the next few weeks. Taking the CRM with them, so they can manage the day-to-day business while out there, is now going to be possible.

In all, a lovely solution using some fantastic work from the Open Source community.

To demonstrate the colours of the rainbow, I wanted to knock up a quick Arduino project that allowed any colour of the rainbow to be selected.

The user input was simply a potentiometer, and the output was to be three LEDs – a red, green and blue.

Working out how to map the potentiometer value (0 to 1023) onto brightnesses for each of the three LEDs was the main task. Looking around, there is a common algorithm listed here:

http://en.wikipedia.org/wiki/HSL_and_HSV

This algorithm turns values of hue, saturation and brightness into RGB intensities. Many Arduino projects implement this algorithm, an example of which can be found here:

http://eduardofv.com/read_post/179-Arduino-RGB-LED-HSV-Color-Wheel-

Without exception, all these projects implement a colour wheel. A colour wheel pulls in (on full saturation) any combination of any two primary colours. So it starts off with 100% red, then fades into 100% green (with yellow produced en-route) which then fades into 100% blue (with cyan on the way). It then fades back into 100% red, visiting magenta half-way between red and blue.

But hold on – the rainbow does not contain magenta. If may be a nice colour for mood lighting, but to show the colours of the rainbow, it just would not do.

The following diagram from Wikipedia shows how the colour wheel hue maps onto the RGB intensities. The function listed in the above project takes a value for the hue between 0 and 255, with 0 being red on the left of the colour wheel bar, and 255 being the red on the far right.

Being a wheel, the bar above wraps around – the red at each end is the same colour. Rainbows don’t wrap like this – red is at one end, and blue is at the other end. This range covers 240° of the colour wheel as seen above.

So, with a hue in the colour wheel being represented in the range 0 to 255, or 0° to 360°, if we are to reduce the range to 0°-240°, then this would be represented by a range of 0 to 170 in the algorithm.

So in the Arduino project, a potentiometer range of 0-1023 is converted to a hue range of 0-170. Turning the potentiometer through its full range then gives a colour output covering the full range of the colours of a rainbow.

However, there is another twist. The rainbow does not stop at red and blue at each end. It carries on through infra-red and ultra-violet, neither of which we can see. So to demonstrate the colour range of a rainbow fully, we need to start at total darkness at both ends of the scale, fading up into red at one end, and fading from blue to darkness at the other end.

So this is what I am aiming for. The saturation (S) is set to 100%, as is the brightness (V). These are two settings that would affect the output as a whole. A saturation of less than 100% would “bleed” other colours through, which a rainbow would never do. A brightness of less than 100% would not be useful here – it would be like looking at a rainbow with a pair of neutral sub-glasses on: it would still be a rainbow.

We can do this using the brightness parameter of the HSV-to-RGB converter, rather than messing around with its innards. That way we can easily switch between colour wheel and rainbow to show how they differ.

Here is the code so far, which is work-in-progress. You can switch between colour-wheel and rainbow modes by setting pin 12 to either 0V or +5V.

/*
 Rainbow

 Take a tricolour LED through the colours of the rainbow using an analogue input.

 The circuit:
 * TBC

 Created 21 April 2012
 By Jason Judge

 This example code is in the public domain.

 */

// The three primary colour LEDs, driven as analgue outputs (actually PWM, but
// close enough for our analogue eyes).

const int ledPinRed = 11;    // Red LED connected to analogue out pin
const int ledPinGrn = 10;    // Green LED connected to analogue out pin
const int ledPinBlu = 9;     // Blue LED connected to analogue out pin

const int modeSwitchPin = 12;

// The Hue potentiometer goes on an analogue pin, taking the pin from
// 0V to 5V.

const int potPinHue = 0;

// Constants to define the ranges.

const int hueRedLow = 0;
const int hueRedHigh = 255;
const int hueBlue = 170;

// The size of the angle of one sector (1/6 of a colour wheel), and of a complete
// cycle of the colour wheel.

const int angleMin = 0;
const int angleSector = 60;
const int angleMax = 360;

const int brightMin = 0;
const int brightMax = 255;

// Work variables.

// The potentiometer value is mapped to the range 0 to 360 (degrees).
int potValueHue;

// The hue is the range 0 (red) to 170 (blue) in rainbow
// mode or 255 (red) in colour wheel mode.
// The brightness ranges from 0 (dark) to 255 (full brightness)

int hue, brightness;

// The saturation is fixed at 255 (full) to remove blead-through of different
// colours.
// It could be linked to another potentiometer if a demonstration of hue
// is desired.

const int saturation = 255;

// The brightess of each LED (0 to 255).

unsigned int r, g, b;

void setup()  {
    // Still need to set a baud rate, even for USB.
    Serial.begin(9600);

    // Set LED pins to output.
    pinMode(ledPinRed, OUTPUT);
    pinMode(ledPinGrn, OUTPUT);
    pinMode(ledPinBlu, OUTPUT);

    // Poteniometer analogue pin is an input.
    pinMode(potPinHue, INPUT);

    // TODO: mode switch in a digital input.
    pinMode(modeSwitchPin, INPUT);
}

void loop()  {
    // The Hue potentiometer value is mapped to degrees - 0 to 360 - for convenience.
    potValueHue = map(analogRead(potPinHue), 0, 1023, 0, 360);

    // Control the mode using a physical switch.

    if (digitalRead(modeSwitchPin)) {
        // Rainbow colour mode (infra-red to ultra-violet - well invisible to invisible  .

        // The hue ranges from red (0) at 60 degrees to blue (170) at 300 degrees.
        hue = constrain(map(potValueHue, angleSector, angleMax - angleSector, hueRedLow, hueBlue), hueRedLow, hueBlue);

        // Brightness - fade up 0-60 degrees
        brightness = constrain(map(potValueHue, angleMin, angleSector, brightMin, brightMax), brightMin, brightMax);

        // Brightness fade down 300-360 degrees
        brightness = brightness - constrain(map(potValueHue, angleMax - angleSector, angleMax, brightMin, brightMax), brightMin, brightMax);
    } else {
        // Colour wheel mode (red to red, wrapped around in a cycle).

        hue = map(potValueHue, angleMin, angleMax, hueRedLow, hueRedHigh);

        // The brightness is fixed at full for the colour wheel. This could be
        // linked to another poteniometer if that is a concept you wish to
        // demonstrate.
        brightness = 255;
    }

    // Do the conversion.
    HSBToRGB(hue, saturation, brightness, &r, &g, &b);

    analogWrite(ledPinRed, r);
    analogWrite(ledPinGrn, g);
    analogWrite(ledPinBlu, b);

    Serial.print(" bright=");
    Serial.print(brightness);
    Serial.print(" hue=");
    Serial.print(hue);
    Serial.print(" red=");
    Serial.print(r);
    Serial.print(" green=");
    Serial.print(g);
    Serial.print(" blue=");
    Serial.print(b);
    Serial.println("");
    delay(50);
}

// This function taken from here:
// http://eduardofv.com/read_post/179-Arduino-RGB-LED-HSV-Color-Wheel-

void HSBToRGB(
    unsigned int inHue, unsigned int inSaturation, unsigned int inBrightness,
    unsigned int *oR, unsigned int *oG, unsigned int *oB )
{
    if (inSaturation == 0)
    {
        // achromatic (grey)
        *oR = *oG = *oB = inBrightness;
    }
    else
    {
        unsigned int scaledHue = (inHue * 6);
        unsigned int sector = scaledHue >> 8; // sector 0 to 5 around the color wheel
        unsigned int offsetInSector = scaledHue - (sector << 8);	// position within the sector         unsigned int p = (inBrightness * ( 255 - inSaturation )) >> 8;
        unsigned int q = (inBrightness * ( 255 - ((inSaturation * offsetInSector) >>  )) >> 8;
        unsigned int t = (inBrightness * ( 255 - ((inSaturation * ( 255 - offsetInSector )) >>  )) >> 8;

        switch( sector ) {
        case 0:
            *oR = inBrightness;
            *oG = t;
            *oB = p;
            break;
        case 1:
            *oR = q;
            *oG = inBrightness;
            *oB = p;
            break;
        case 2:
            *oR = p;
            *oG = inBrightness;
            *oB = t;
            break;
        case 3:
            *oR = p;
            *oG = q;
            *oB = inBrightness;
            break;
        case 4:
            *oR = t;
            *oG = p;
            *oB = inBrightness;
            break;
        default:    // case 5:
            *oR = inBrightness;
            *oG = p;
            *oB = q;
            break;
        }
    }
}

The site allows you to take control of a relative’s PC (let’s face it – mum or dad’s PC) remotely. You can see what is happening, move the mouse, click in stuff and operate the keyboard, giving you full control to make those necessary tweaks and updates. Obviously the machine needs to be working enough to get Internet access, but there is still a lot that can be done using this tool.

The main issue I see with it, is explaining to the remote party what they need to do. The website has quite a visual front page, that can confuse some people a lot. They also deliver different front pages to different people. I’m not sure whether this is some kind of A/B testing, but trying to work out whether people are on the right site and describing the links they need to click on, is very difficult when their description does not match what you can see. Some of the flashy messages they put on the front page also sound very spammy, so I often doubt they have got to the right site when they read out the, “have fun join your friends” message that is bizarrely put up there for some people. That is just something to be aware of.

Overall though, I would recommend giving it a try.

The project involved taking book loan data from Newcastle Libraries, and plotting the distance those books were taken to the homes of the borrowers. The idea was to look for patterns in the data that were not obvious in any other form, to see if it could be used to help distribute the books between the libraries in a more relevant way.

I worked mainly on the front end (graphical visualisation) while Peter Bull @RoguePlanetoid worked on the back end (ASP.net data delivery).

One of the first things I needed to decide, was what visualisation library we were going to use. I had never used any before, so needed to chose the one that would offer the least resistance to learning.

The three main contenders were:

• Processing (JavaScript port being processing.js)
• Raphaël
• Paper.js

All three seem to do much the same thing. The main differentiating features we identified are:

• Processing is driven from its own language. The other two are driven from JavaScript by using and manipulating JavaScript objects directly.
• Raphaël supports older browsers than the other two. This was not particularly important to us. However, Raphaël does not support Android due to the way it relies on SVG. This was a little more important.
• Raphaël and Paper.js both support object-base interaction. By clicking on a visual object, it is easy to interact with it. This is much more difficult in Processing.
• Paper.js and Processing both use canvas, so will support IE from 9 onwards.

In the end paper.js won. Putting a quick visualisation together that worked across all the browsers we were using and did not involve learning too many new languages and language constructs, is why it stood out.

One thing all three had in common was the difficulty in finding worked examples. Nearly all example code we found were compact and certainly showed the frameworks off, but were seldom commented to explain what they did and how they worked. That was a shame, as it slowed down our learning somewhat. People were kind enough to put examples up for us to see, but five more minutes to add half a dozen lines of comments would have really added the cherry on the top.

This excellent article gives a great summary of these packages, comparing features in a very visual way, while getting right to the bottom line of why you would chose one over another:

http://coding.smashingmagazine.com/2012/02/22/web-drawing-throwdown-paper-processing-raphael/

[to be continued]

Connecting an iPhone to this server involves a couple of unintuitive steps, which are documented here:

http://help.yahoo.com/l/us/yahoo/smallbusiness/bizmail/mobile/mobile-11.html

When it [erroneously IMO] fails to connect to the server using SSL, and asks if you want to connect to the server without SSL, you need to answer “yes”. This is the only way to break out of the setup endless loop. Then you can go back in and switch SSL on and update the SMTP ports.

git is a system for storing files. Those files are stored in a database on your local machine, and that gives it some special properties: the files can be versioned. That means changes to the files can be recorded by the database, and so you have a complete history of all the changes that have been made.

The database you have on your machine is called a git repository. Even though you manage your local files in your local database, its reach is much further than that. You can synchronise the changes in your git repository with a remote git repository. Other people can share that repository, so you can see the changes that each of you makes.

When git repositories are synchronized (e.g. when you push all the changes in your repository to the central repository) git will ensure that all the changes are merged together nicely, but will also ensure that any changes can be picked apart and undone if necessary.

It can get pretty complicated if you look at it too deeply, but usually works smoothly. Essentially it allows many people, all distributed over a wide geographic area, to work on one central set of files, i.e. one project – usually a software project. However, it allows those different people to manage their changes locally, without affecting anyone else, and them the changes can be merged together at a time of everyone’s choosing.

So, different can be working on different parts of a large project, each perhaps making many changes, but pull all those parts together in one place as each part is, in turn, completed.

The central repository is where github comes in. github is one of the first, and the most famous of the git repositories available on the Internet. As well as the basic git functionality that you would use on your own machine, it has many additional features and tools that make collaboration with large teams of developers very easy.

github provides free public repositories for open source projects. So long as the code being managed in the repository is available on an open source licence, and is free for anyone to look at and download any time they like, then the repository is free. Private repositories are also available with a subscription cost.

Here, for example, is the initial data put up by Alistair for the CultureCode hack:

https://github.com/alistairuk/CultureCode-Data

Anyone can download that data and use it. You can then make changes to it, and request that those changes be pushed back to Alistair’s repository (but that would be a decision that Alistair would made, since he is the owner of that repository).

It needs to be mentioned that git is a distributed change management or code control system. Everyone working on a project will take a copy of the whole of the central repository, and when working on that repository that they have copied, they are essentially working independently.  They do not have to push their changes back to the central repository, and even if they do, the repository owner does not have to accept those changes (assuming the pusher has not already been given permission to push anything they like already).

This gives both support to sub-projects to develop code without falling over each other’s feet, and also the ability for a solid product (e.g. a software application) to be put together without accepting changes that may break it.

In summary:

• git allows lots of people to work on a software project from different locations, at the same time.
• github provides public repositories where the software projects can be hosted and shared.
• A git repository is a lot cleverer than simply a shared network folder, because it tracks changes and supports the merging of changes in very clever ways.

These are the steps you should follow to create a simple HTML signature:

1. Start writing a new email by clicking the “Write” button.
2. In the blank email form that comes up, enter the signature of your choice. Use the text formatting buttons to get it looking how you like it – font sizes, colours, bold, italic etc.
3. Once the signature looks right, select it using the mouse.
4. The non-intuitive step involves selecting Insert->HTML from the top menu of the email. This will open a small window showing the HTML of the signature you selected.
5. Select all the HTML in the window, and copy it (press Ctrl-C from the keyboard or right-click the mouse and select “Copy”).
6. Close the “Insert HTML” box by cancelling it.
7. Go back to the main Thunderbird window and select Tools->Account Settings from the top menu.
8. Select the account on the left-hand side of the “Account Settings” window for which you want to set the signature. You will see the “Signature text” box with the “Use HTML” tickbox above it.
9. Tick the “Use HTML” box.
10. Click in the “Signature text” box then paste the signature – either Ctrl-V using the keyboard or right-click then “Paste” using the mouse.
11. Click “OK” to close the “Account Settings” window.
12. Now try creating a new email. The signature should appear, with “–” just before it.

If you need to change the signature or tweak it, then go back to step 1. Each time you will start with the last signature you created as a starting point.

You can even include an image or logo in the signature if you wish. You can link to an image on your local hard drive or copy and paste an image into the signature. Either way will work, even though they operate in different ways. When you copy the HTML, just make sure you copy it all exactly as it appears in the Insert->HTML box. It will appear to be complicated codes, but that is what carries the formatting and the images.

# awk -F: '{print $1}' /etc/passwd | xargs -l1 crontab -lu 2>/dev/null

It’s a handy command to keep in your toolbox.

What it does, is take the first field – the username – from the passwd file, then pass each username to the crontab command to list the table. xargs is used to pass the usernames one at a time, since crontab only accepts one username.

For example, to remove all mail from the outgoing queue with the word “c@sino” in the subject, use this command:

   qmhandle.pl -S'c@sino'

Perhaps delete all mail that is stuck in the queue from user “mym3ds@spammer.com”:

   qmhandle.pl -f'mym3ds@spammer.com'

Remember that last one is a regular expression, so escape any special characters.

Showing the state of the queues:

   qmhandle -s

Then listing what is in those queues:

   qmhandle -l | more

The qmhandle.pl script can be found here, but may well be already installed on your server, especially if you use Plesk to manage your server:

http://sourceforge.net/projects/qmhandle/

The record could not be updated due to a permissions issue

This happened for just ten records out of three thousand, and I was logged in as an administrator, so there should not have been any real privilege issues.

The answer was that the records being updated had been deleted in the CRM. SugarCRM was attempting to create new contact records with the IDs supplied, but the old deleted records were still there in the database, preventing the new records from being created.

The record could not be updated due to a permissions issue