This has led me to play around with Varnish, which has been on my to-do for a while now. With minimum configuration the access times for the front page are now sub 1ms - impressive!

(All of these tests have been carried out from my old VPS to avoid any bandwidth related issues with my broadband.)

One of the a cool features is the dictation, so I don't have to type anymore as my iPad will actually convert it back into text. This is in theory, it only seems to work about half the time, the other half I've got to correct it, which is a pain. I guess it will force to me to speak either the queens English or talk like a yank (no offence to any Americans who are reading this of course).

Now I'm just looking for some cool iPad apps, I've found Flipbook, if anyone has many suggestions send them my way

java.lang.UnsatisfiedLinkError: Could not load SWT library. Reasons: 
no swt-gtk-3738 in java.library.path
no swt-gtk in java.library.path
Can't load library: /home/marc/.swt/lib/linux/x86_64/libswt-gtk-3738.so
Can't load library: /home/marc/.swt/lib/linux/x86_64/libswt-gtk.so

The latest version of Eclipse (Version: 3.7.1, Build id: I20110909-1335) requires SWT 3.7.1 and not 3.7.2 that has now been pushed to the Gentoo testing branch.

emerge =dev-java/swt-3.7.1

Will fix the issue, it may as well be worth updating your masks at the same time.

Were 'X' is a solid LED and the numbers represent the other LEDs being turned on after a given delay (1  second divided by the remaining LEDs).

(1) (2) (3) (4) (5) (6) (7) (8)

(x) (1) (2) (3) (4) (5) (6) (7)

(x) (x) (1) (2) (3) (4) (5) (6)

...

(x) (x) (x) (x) (x) (x) (x) (x)

Code:

int ledPins[] = {2,3,4,5,6,7,8,9}; 
int numberOfLeds = 8;

void setup()
{
  for(int i = 0; i < 8; i++){
      pinMode(ledPins[i], OUTPUT); 
  }                                   
}

void loop()
{
  for (int i = 0; i < 8; i++) {
    countLeds(i);
  }
}

void countLeds(int starting)
{
  // Switch them off
  for(int i = starting; i < numberOfLeds; i++) {
    digitalWrite(ledPins[i], LOW);
  }

  // Switch on
  for(int i = starting; i < numberOfLeds; i++) {
      digitalWrite(ledPins[i], HIGH);
      delay(1000 / (numberOfLeds - starting));
  }
}

Nothing special really, but I quite enjoyed getting back to basics. Watch this space for more Arduino hackery.

1. Restart and hold down option
2. Select use Safari and open up this web page and remember the following steps
3. Quit Safari, open up Terminal from the Utilities menu and run
4. Mount the TimeMachine share
   1. mkdir /Volumes/TimeMachine
   2. mount_afp aftp://<username>:<password>@<host>/TimeMachine /Volumes/TimeMachine
   3. ls -l /Volumes/TimeMachine

   mkdir /Volumes/TimeMachine
   mount_afp aftp://<username>:<password>@<host>/TimeMachine /Volumes/TimeMachine
   ls -l /Volumes/TimeMachine

5. Now run the following to mount the sparsebundle
   1. mkdir /Volumes/Backup
   2. hdiutil mount -owners on -mountrandom /Volumes/Backup -stdinpass /Volumes/TimeMachine/*.sparsebundle
   3. ls -l /Volumes/Backup

   mkdir /Volumes/Backup
   hdiutil mount -owners on -mountrandom /Volumes/Backup -stdinpass /Volumes/TimeMachine/*.sparsebundle
   ls -l /Volumes/Backup

6. Quit Terminal
7. Select restore and select TimeMachine drive, your TimeMachine backup should be visible

What I used to use was a VM copy of my server environment which was preconfigured to be the same as my production environment, this allows me to test my applications before I deploy them in a like-for-like senario. The downside of this on a MBA is the heat is generated, heat from the computations required to run a OS in another OS, not a great solution. If I owned a powerful desktop this would be acceptable but not on portable device which lives on my lap.

Next I tried an app called MAMP, an all-in-one out-of-box solution which includes Apache, MySQL and PHP. This is all well and good when you just use these components, but I tend to use nginx and SQLite now anyways, as they use less resources on my VPS which allows my server to focus more on the meaty part of any PHP application, the PHP code itself. At the moment I’m quite interested in the next release of PHP, PHP 5.4 beta 2 which includes it’s traits support (if you don’t know what that is go and google it). Using this out-of-box solution is quick but doesn’t include the PHP betas, I’ve tried compiling it against the MAMP libraries but it’s impossible to compile as the headers aren’t included in the MAMP application.

Final and the best solution I have found so far is to kick it old skool, and just compile it all from source using MacPorts. Apart from PHP 5.4 which you have to configure yourself and build, something I haven’t managed yet – only because I haven’t tried. Hopefully sometime this week I will get able to get a custom port up of PHP 5.4 beta 2 running. If I do I will do post the results of how to do this here first.

Where I currently work I'm an Senior Software Engineer in a team which primarily writes PHP code - why? Because it's quick and flexible language which allows us to be reactive to change within the business. Since my first day there we have been focused on using the MVC pattern, but with a twist - MLVC; the L being Logic. The purpose being to force you to write your algorithms into a abstract way so other applications/tasks can make use of them. Until recently this was fine... a new application came along (call it App A) and we wrote a new set of models and wrote some logic to populate/manipulate/update/etc. them. The problem came when we want to use these models in another application (App B), the logic we wrote for those models was built with App A in mind, without a few weeks of abstracting, refactoring, testing we wouldn't have been able to make use of these models for App B. This is where the visitor pattern comes in, if we used it from the word go we wouldn't have had such a problem when App B came along. Consider this example...

class Model_A {
	public $data = null; // Please use accessors, not public vars
}

class Logic_A {
	public static function getModelA() {
		$model = new Model_A();
		$model->data = DB::fetchData(/** Use App A's data source */);
		return $model;
	}
}

$modelA = Logic_A::getModelA();

There's nothing technically wrong with that (except the public $data, see comment), but if I want to use another data source or I want to expand it to let's say save the data to another data source, like a cache for example, I would expand the Logic_A to do this. What if another application doesn't want to save the model to a cache, or worse, it wants to write the data to a file... expand Logic_A again. Now you should see that's there a problem here, you're putting all of your logic into one class, which has been design to application agnostic and it's going to become 100s, if not 1000s of lines code long in no time at all...

Now consider the following instead...

class Model_A implements Interface_AcceptVisitor {
	public $data = null; // Once again this is bad practise, this is only an example

	public function acceptVisitor(Visitor_Abstract $visitor) {
		$visitor->visit($this);
	}
}

interface Interface_AcceptVisitor {
	public function acceptVisitor(Visitor_Abstract $visitor);
}

abstract class Visitor_Abstract {
	abstract public function visit($instance);
}

class Visitor_A {
	public $dataSource = null;
	public function visit($instance) {
		if (!$this->dataSource) return; // Visitor requires a data source
		$instance->data = DB::fetchData($this->dataSource);
	}
}

$loadDataVisitor = new Visitor_A();
$loadDataVisitor->dataSource = /** Use App X's data source */;

$modelA = new Model_A();
$modelA->acceptVisitor($loadDataVisitor);

Well what's different, apart from the use of the visitor pattern, the output is the same, but now I'm able to use another data source and allows the logic and the model to do what they do best. In addition to this, I'm able to re-use this visitor on another model too.

Ok what if I wanted to expand the second example to save the model to a cache then, how would I do that - easy, write another visitor to save the model. What if another application wants to save the data to a file - easy, write another visitor to-do that. Now here's the another nice feature of this pattern, another developer can come along and pick and chose which visitors they want to apply to their models, without getting stuck by reading 1000's of code to find the one function that does what they want. If a visitor doesn't exist, then they can write a new one, instead of try to hack in some custom logic into monster of a logic class.

From my own point of view this allows me break down really complex logic into manageable algorithms, which I don't have to worry about trying to force into one huge class and at the same time make it abstract enough that someone else can use it.

How do you scale a web site/application? Or any application for that matter? Well you can bury you head in the sand and throw more hardware resources to the problem (faster hardware, more memory, etc.) ... or make it horizontally scalable of course!

I'm really hate using this phrase but it is technically correct ... "to the cloud" (sorry Chris). What I hate about it the most is the fact that people in marketing (Microsoft's latest advert campaign) tend to use it without actually knowing what the cloud is. Cloud computing is just a fancy word someone coined for the Internet - the Internet being a vast collection of servers. That's what I mean when I say horizontally scalable, use a collection of servers to do your work for you and not one really powerful machine.

Now let's get a bit technical. The popular way of distributing your work I know is to use a Message-Oriented Middleware, where messages are passed between two or more processors via a message broker. The brokers job is to accept incoming messages, save them to a queue and then dispatch them to an available process. This all well and good, but in my experience the broker can become the single point of failure, unless you use a cluster of them. MOM's tend to be quite CPU and memory intensive, meaning it has to live on it's own hardware. This is where Gearman comes in...

Gearman...

"...allows you to do work in parallel, to load balance processing, and to call functions between languages. It can be used in a variety of applications, from high-availability web sites to the transport of database replication events. In other words, it is the nervous system for how distributed processing communicates." (http://gearman.org/).

The main difference for me is the fact you can have multiple Gearman job servers running on your platform, compared a MOM platform where you have one message broker being your have a single point of failure - meaning less headaches for everyone.

One way I see it adding benefit a scalable project if is to configure your boxes which are going to processing work a single Gearman job server and have all the workers on that box pointing to that server. Next load balance these boxes via virtual IP (VIP). Now all you do is send your jobs to this VIP which will be sent a job server and then be picked up by one of the workers. To scale your application add more boxes to your little Gearman cluster. This solution not only scales your throughput, it also scales the application which is handling your jobs. Another difference which is quite interesting, you can run processes in parallel and wait for them to completed before continuing, e.g. computing basic statistics for group of users and then combining the results (see MapReduce).

Gearman is still quite young and still in beta so expect the somethings to change as it develops and matures. Saying that it's currently being used by some really large websites - Grooveshark, Yahoo and Digg. As Gearman is written by the same people who write and maintain Memcache, I'm expecting it to stay around for quite a while.