Permalink | Leave a comment  »

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Just had a whale of a time getting this installed, thought I'd share the solution.

I was getting errors like:

/usr/local/mysql/support-files/mysql.server: line 256: my_print_defaults: command not found

All you need to do is run this commands:

echo "/usr/local/mysql/bin" > /etc/paths.d/mysql && echo "[mysqld]\nbasedir=/usr/local/mysql" >> /etc/my.cnf

Hope that helps!

Permalink | Leave a comment  »

I've decided to turn my dissertation into a freely available template. I know of at least 4 other people who've used this template in one version or another to produce their dissertations, so thought I'd publish it online for all to use. Those doing computer science dissertations (especially those at Sussex Uni!) will find this most useful, though it should be relatively easy to adapt for others.

report.pdf Download this file

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Permalink | Leave a comment  »

The inspiration for how this works came from Gitosis. I highly recommend Garry Dolley's tutorial on how to set it up and for general info. In this short tutorial I assume you're running Gitosis on the same machine you're managing configs for, though it wouldn't be hard at all to change things for other Git repos or remote hosts. I also assume you've got Monit installed and running, though if you don't, just ignore that part of the tutorial and you'll just have to restart the service yourself to pick up new config changes.

I've recently installed nginx on rly.gd, so I'll be taking this as an example. I begin by creating a new repository with Gitosis called nginx-conf (again, see Garry Dolley's tutorial for info). Then, I create a git repo in nginx's config dir (/opt/nginx/conf for me, probably /etc/nginx for you), add all the files, and commit.

1
2
3
4

cd /opt/nginx/conf
git init .
git add .
git commit

Referring again to the same tutorial, I add the Gitosis repo as the remote origin and push the initial commit.

1
2

git remote add origin git@rly.gd:nginx-conf.git
git push origin master

Then, on my local machine, I clone the repo from Gitosis:

1

git clone git@rly.gd:nginx-conf.git

Back on the server, I create a file named post-update in /home/git/repositories/nginx-conf.git/hooks, and chmod it +x. The following script first deletes the old files (don't worry, you've still got a copy in Gitosis!) then clones the latest version:

1
2
3

#!/bin/sh
rm -rf /opt/nginx/conf/* /opt/nginx/conf/.git
git clone --depth=1 /home/git/repositories/nginx-conf.git /opt/nginx/conf

This script means that now when you push to the Gitosis repo, it'll update nginx's config to match the latest revision. So now, when you're making edits to your server config, you just need to commit, push, then restart the service. Taking it one step further, we can automate the last step out of the process too, so the service will restart itself. Depending on how your server is set up, you may just be able to add /etc/init.d/nginx restart to the bottom of your post-update hook, though it's not a very clean or secure solution. Better is to make Monit watch the config for changes, and restart the service if necessary. Here's a monitrc entry for nginx:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

check process nginx with pidfile /opt/nginx/logs/nginx.pid
        start program = "/etc/init.d/nginx start" with timeout 10 seconds
        stop program = "/etc/init.d/nginx stop"
        if cpu > 60% for 2 cycles then alert
        if cpu > 80% for 5 cycles then restart
        if totalmem > 200.0 MB for 5 cycles then restart
        if loadavg(5min) greater than 10 for 8 cycles then stop
        if failed host rly.gd port 80 protocol http
                and request "/"
                then restart
        if 3 restarts within 5 cycles then timeout
        group server
        depends on nginx_conf

check file nginx_conf with path /opt/nginx/conf/nginx.conf
        if changed checksum then restart
        group config

The bit you're interested in specifically is lines 13–17, where we make Monit watch for changes on nginx.conf, and make the nginx service depend on its config.

So that's it, a simple but useful little trick to ease configuration changes. I've used this to automate changes to all my important services on all my servers, and it definitely makes life a lot easier!

Permalink | Leave a comment  »

via mmonit.com

They really aren't kidding, it takes about 5 mins to install and 10 mins to write service definitions - and now I can sleep easy knowing my server will fix *itself*!

Permalink | Leave a comment  »

Permalink | Leave a comment  »

Great! I'll take three!

Permalink | Leave a comment  »

See the full gallery on Posterous

Permalink | Leave a comment  »

See the full gallery on Posterous

Permalink | Leave a comment  »

Mobile Processing app which displays patterns of bright colours and vibrates the phone. Just an experiment into J2ME, not too successful, but still… pretty!

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
43
44
45
46
47

import processing.phone.*;
int BOX_HEIGHT = 10;
int N_COLOURS = 4;
int N_SIZES = 5;
color[] colours;
int[] sizes;
int i;
int j;
Phone p;

void setup() {
	p = new Phone(this);
	p.fullscreen();
	colorMode(HSB, 360, 100, 100);
	noStroke();
	BOX_HEIGHT = random(1,40);
	N_COLOURS = random(2, 50);
	N_SIZES = random(2, 50);
	colours = new color[N_COLOURS];
	for (int i = 0; i < N_COLOURS; i++) {
		colours[i] = color(random(360), 100, 100);
	}
	sizes = new int[N_SIZES];
	for (int i = 0; i < N_SIZES; i++) {
		sizes[i] = random(1, width / 2);
	}
	i = j = 0;
}

void keyPressed() {
	setup();
}

void draw() {
	background(0);
	if (i == j) { p.vibrate(150); }
	for (int y = 0; y < height; y += BOX_HEIGHT) {
		for (int x = 0; x < width; ) {
			int this_width = sizes[j];
			fill(colours[i = (i + 1) % N_COLOURS]);
			rect(x, y, this_width, BOX_HEIGHT);
			x += this_width;
		}
	}
	i = (i + 1) % N_COLOURS;
	j = (j + 1) % N_SIZES;
}

Permalink | Leave a comment  »

Phew, after a whole load of work and messing about, Ollie Glass and I have (finally) uploaded our PTurtle library!

It’s aimed at teachers and those just setting out learning programming through Processing, and was born out of a course we taught to PGDip students at the University of Brighton.

The commands are the same as classic LOGO, but being written in Java and based in Processing, allows learning from the ground up:

The complete code to draw a rectangle, using only methods of one object:

1
2
3
4
5
6
7
8
9
10

import pturtle.*;
Turtle t = new Turtle(this);
t.forward(10);
t.right(90);
t.forward(10);
t.right(90);
t.forward(10);
t.right(90);
t.forward(10);
t.right(90);

The same, but after the student has been taught loops:

1
2
3
4
5
6

import pturtle.*;
Turtle t = new Turtle(this);
for (int i = 0; i < 4; i++) {
	t.forward(10);
	t.right(90);
}

There’s convenience methods in there for just about every way you could conceive of using the Turtle, as well as an advanced HistoryTurtle class, that leaves a modifiable trail.

We’ve got tonnes of past student work which we’ll be posting up soon, please don’t hesitate to contact either Ollie or myself if you have any difficulties with the Turtle! :)

Permalink | Leave a comment  »

Made my girlfriend’s valentines card in Processing, drawing simple curveVertex() s, colours generated using toxi's colorutils, and outputted to PDF for high res print.

Click the image for the final PDF, here’s the code:

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

import toxi.math.noise.*;

import toxi.math.waves.*;
import toxi.geom.*;
import toxi.math.*;
import toxi.math.conversion.*;
import toxi.geom.util.*;
import toxi.util.datatypes.*;
import toxi.color.*;
import toxi.color.theory.*;
private static final int NUM_NODES = 3;

void setup() {
	size(1200, 1800);
	smooth();
}

void draw() {
	//beginRecord(PDF, "frame-####.pdf");
	background(0);
	noFill();
	ColorList cl = ColorRange.WARM.getColors(TColor.RED, 100, 0.05f) .sortByCriteria(AccessCriteria.HUE, false);

	for (int i = 0; i < 12; i++) {
		int[] nodeX = new int[NUM_NODES];
		int[] nodeY = new int[NUM_NODES];

		int lastX = (int) random(-300, width + 300);
		for (int j = 0; j < nodeX.length; j++) {
			lastX = nodeX[j] = lastX + (int) random(-500, 500);
		}

		int max_node_height = height / (NUM_NODES + 2);
		for (int j = 1;	j <= NUM_NODES;	j++) {
			int position = (int) (random(0, max_node_height) + (j * max_node_height));
			nodeY[j - 1] = position;
		}
		for (int k = 0; k < 500; k += random(3, 8)) {
			stroke(cl.get((int) (k % (int) cl.size())).toARGB());
			beginShape();
			curveVertex(k + nodeX[0] + random(-10, 10), 0);
			curveVertex(k + nodeX[0] + random(-10, 10), 0);
			for (int j = 0;	j < NUM_NODES; j++) {
				curveVertex(k + nodeX[j], nodeY[j]);
			}
			curveVertex(k + nodeX[NUM_NODES - 1] + random(-150, 150), height);
			curveVertex(k + nodeX[NUM_NODES - 1] + random(-150, 150), height);
			endShape();	
		}
	}

	for (int i = 0; i < 20; i++) {
		pushMatrix();
		translate(random(0, width), random(0, height));
		scale(random(0, 1));
		beginShape();
		fill(0, 0, 0);
		noStroke();
		vertex(55, 20);
		vertex(75, 40);
		bezierVertex(75, 37, 70, 25, 50, 25);
		bezierVertex(20, 25, 20, 62.5f, 20, 62.5f);
		bezierVertex(20, 80, 40, 102, 75, 120);
		bezierVertex(110, 102, 130, 80, 130, 62.5f);
		bezierVertex(130, 62.5f, 130, 25, 100, 25);
		bezierVertex(85, 25, 75, 37, 75, 40);
		endShape();
		popMatrix();
	}
	//endRecord();
}

Permalink | Leave a comment  »

Today, after giving up messing about with getting XeTeX installed on XP, I decided to see if I could fix my Ubuntu install, which I’d nuked by converting over to ext4. Turns out, it was quite an easy fix, so I thought I’d note it for anyone else who encounters the same.

For reference, the current version of GRUB doesn’t support ext4 yet, so you may get the following error when loading the kernel:

Error 13: Invalid or unsupported executable format

Or, when loading the initrd:

Error 6: Attempt to access block outside partition

Basically, GRUB attempts to read the kernel and initrd using ext2 drivers, and will sometimes fail as the disk format has subtly changed. The (easy) fix is to install GRUB2, which supports ext4. I managed to do this by downloading the latest Jaunty ISO, using Unetbootin:http://unetbootin.sourceforge.net/ to write it to a USB key, and using the kernel from that to boot my system:

• Let the machine boot to GRUB (you may have to press ESC to see the GRUB menu)
• Highlight your normal boot option and press E to edit
• Highlight the line beginning “kernel” and press E again
• Remove the current kernel path (something like /boot/vmlinuz...) and replace it with (hd1,0)/ubnkern
• Hit enter to return to the boot option, highlight the line beginning initrd and press E again
• Remove the initrd path (/boot/initrd...) and replace with (hd1,0)/ubninit
• Hit enter again and then B to boot!

Once back in my system, I installed grub-pc, ran update-from-grub-legacy, and rebooted to a machine that can once again boot itself, completely in ext4!

Permalink | Leave a comment  »

This post is a very special post. It marks (exactly) three years since I registered georgebashi.com, (roughly) two years since I started blogging “regularly”, and (close to) one year since I published the last design for this site.

Things have changed a great deal in these 1/2/3 years; I started off with crappy static pages, I’ve used no less than five blog engines (two self-written), I’ve produced hundreds of designs and mockups, and I’ve finally settled with something I’m reasonably happy with. I think my problem is that the idea of blogs themselves have never really sat well with me; I’m not a fan of reading or writing long flows of text no matter what the format, be it books, assignments or otherwise. Since I started this site I’ve always aspired toward a “content-first” approach, where the work I’m talking about (a photo, a video, some code) is the centre-piece and speaks for itself; my words simply contextualise, reinforce, and occasionally mock. In my search for this ideal solution, I tried thousands of different dedicated photoblogs and custom themes for awful CMSs (WordPress, TextPattern, Typo to name a few), but never really found anything that worked out.

I was then introduced to tumblr by Ollie Glass, who has been using it privately for a while to collect his thoughts and “scraps” from his researched, and really liked the idea. Totally content-first, blindingly easy to post to, and completely hassle-free. Wanting to self-host, I searched around and found Chyrp, which is now running this final version of the blog. It’s not fantastic, but it does 80% of what I’m after and it’s not difficult to add the last 20%. I’m hoping that having a nice, clean, easy-to-post-to blog will make me use this a lot more often, even if the content may sometimes be a little inane!

So I present to you the new and improved site. It’s now hosted on a brand new server (“cloudy”) located in London, which I’m funding by selling space on (contact me if interested!). The freedom of administering my own machine rather than putting up with awful shared hosting is fantastic, and I’ve got everything set up just how I like it, using the latest bits of kit to have the site ticking along at incredible speed.

I’m really looking forward to seeing how the site and the coming year will turn out – I’m sure I’ll post at the same time again next year, so see you then (but hopefully before!)

Permalink | Leave a comment  »

As the first bit of experimentation for my masters project, I wrote a tile server for Google Maps. Basically, Maps works by downloading small (256×256px) “tiles” of the map as you drag around (this is why if you drag fast you see it appear in squares). You can use the Google Maps API to really easily overlay or entirely replace the default map with your own imagery, just by making a program which generates these small images.

As part of my project, I may be drawing images over the map, so decided to try out map tile generation to see if it is feasible. I needed an image that I could draw sections of independently of the rest of the image, and zoom in to great detail – fractals! The classic Mandelbrot set was the obvious choice, so I found a Processing example, tweaked it a bit, and wrote a Java Servlet which used Processing as a back-end to draw the map tiles. This worked incredibly well (after dealing with some issues with Processing not being thread-safe), and within an hour or two of conception had a fully working version. I showed this off in my tutor meeting, but due to my rubbish home broadband it was taking upwards of a minute to load a screenful.

I then decided to “grow up” the implementation, rewriting it in PHP and putting it on this site. Initially this worked fine (after adding caching for the tiles) but very quickly brought the server to a standstill, as fractals are pretty hefty calculations, and one person visiting the site would request ~30 of them just by going to the web page. I adapted some optimised code from The Computer Language Benchmarks Game but this didn’t help much, as the code wasn’t too bad already!

My next idea was to pre-generate all the tiles on my machine, and upload these to the web host – this way, the web server would only need to generate tiles if the user zoomed in too far. I hacked the servlet into a standalone app; removing Processing and instead using the javax.imageio classes to directly write PNGs, using 4 threads and pumping out tiles as fast as possible. I left this running for a couple days, creating about 25GB of tiles, uploading them to the web server as I went along.

I played with this new ultra-snappy version for a while, but realised that the interesting part of fractals is the ability to zoom in to infinite detail – panning around is all well and good but as soon as you zoomed too far the server went horribly slow again. At this point, I only really had one option left – rewrite the tile generation in C. I ported over the Java code to calculate the fractal, and used libpng to write out the images. Surprisingly quickly I had a C version (I didn’t bother with threading as this is a headache in C), which, after a bit of benchmarking, turned out to be massively faster than both the Java and PHP versions. Before people jump on that as “LOL JAVA IS SLOW!!1”, the language benchmarks I took the code from show Java as only slightly slower than C – I think the bottleneck was in fact in writing out the PNG, as I was (accidentally) using the OpenJDK implementation which is not known for its speed!

Anyway, with this new C version I started pre-generating tiles at lightening speed, when on a hunch decided to change the PHP code to simply run the C executable to generate the tiles. Trying it out, I was amazed. I even had to do a quick check to make sure it wasn’t still serving cached tiles and was in fact generating them on-the-fly.

So there you have it! I’ve just realised I’ve written that huge essay and not provided a link to the hyper-optimized, super-fast, Google Maps Mandelbrot!

Source code to all of this available on request; I plan to tidy it up and release it on here some time soon as well.

Permalink | Leave a comment  »

Lumin was to be our third Android app. We both had the idea independently and started coding – it wasn’t until we both asked each other’s help that we realised we were both making the same app!
We ended up blending James’ UI with my audio engine. The idea was a simple step sequencer, where the user could light up squares to set a pattern of notes to play, accompanied by some beautiful samples I created using non-traditional scales. This was the first app that I spent any serious time doing graphics for – I’ve started to learn Illustrator as a result.

This was to be our first paid app, but we couldn’t bring ourselves to release it as we found no way of making it stable – the phone just can’t handle playing samples and keeping time accurately enough for it to be fun. I felt that if people would be paying for a sequencer, it should at least be able to keep time!

This one is on the backburner until Android’s sound support improves – but at that point there’s a paid app ready to go!

Permalink | Leave a comment  »