I will preface this by saying that I did a terrible job backing up my contacts, text messages, apps and phone settings before I tried to re-flash my phone. Don’t do that. It’s a pain.

I have a shiny phone, called a Samsung Galaxy Ace, and it runs a well-known version of Linux called Android (please stop me if I’m patronising you). I feel very lucky to carry around such a fancy little computer in my pocket all the time. My favourite free apps that I’ve found are MIUI music player, Dolphin internet browser, and F-droid, which is a repository of free and open source software for Android phones. The only app I have actually paid money for is Cogs, which is a completely amazing steampunk puzzle game.

The version of Android that my phone came installed with was some bizarre combination of what Samsung and Orange thought that I would enjoy, which disabled quite a few of the phone’s more interesting features. The nice thing about these phones, however, is that you can install different operating systems on them. I chose CyanogenMod mainly because I had heard of it. Here is a walkthrough of CyanogenMod 7 if you are curious about what it looks like.

I followed the phone-specific instructions on this website for installation. Before following the instructions, please remember to back up anything important using your phone’s native features and also in a second way. I used Titanium Backup, which didn’t work well at all for me. Pick something else.

In brief, the version of CyanogenMod for the Galaxy Ace is codenamed “cooper”. You can read about it on the CyanogenMod wiki, and download it from here. Incidentally, installing it on your phone is terrifying and I really don’t recommend doing it while hung over on December 29th.

I, rather cleverly, managed to lose all my contacts thanks to my aforementioned failure to back them up properly. Fortunately, Orange kept a backup for me (if you are with Orange, yours are downloadable from here). It’s an odd list of old and new contacts, which you can export in comma separated value (csv) format. I went through and pruned out a couple of ex-boyfriends and all the empty columns. I ended up with a csv file that looked like this:

Other Phone,Mobile Phone,First Name,Last Name
01xxxxxxxxx, 07xxxxxxxxx, Joe, Bloggs

There’s probably an easier way to put them back onto your phone via an app, but I decided to try and convert them to VCard format so I could import them directly. I wrote a python program to do this that you can download: csvtovcard.py. If you put the program in the same folder as a csv file (formatted as above) called “Contacts.csv” and run the program, it should output a file called Contacts.vcf which contains all your contacts. The main thing I learned from this is that putting spaces at the end of lines really, really breaks VCards.

So, I had my contacts back. I also tried restoring all my apps from Titanium Backup. Don’t do that. I ended up in a situation whereby I had CyanogenMod installed, with several bits broken (including wifi and email), and I needed to re-install to see if I could fix it. I didn’t get around to this until 3 months after installation, by which point I had lots of text messages from my loved ones that I wanted to keep hold of.

It turns out all text messages are kept on an SQLite database on the phone. It’s in a protected area that isn’t mounted when you connect your phone by to your computer via USB. You can find out where it’s kept by typing the following commands in a terminal emulator on a rooted phone:

su
file | grep -i mmssms

When you find mmssms.db, you can copy it over to your computer using the USB android debug bridge (ADB). It’s available for various operating systems, but you can download it for Debian as a package from here. After installing ADB, type:

abd pull /path/to/file ./

There are probably all kinds of clever things you can do to restore your text messages, but I just wanted to look at them, so I installed sqlitebrowser from the repositories and open up the file occasionally to remind myself how funny and lovely all my friends are.

The moral of this story is: try not to break things – and if you do, try to fix them afterwards.

Anyway, before my brain explodes from over-knowledge-ness, I thought I’d blog about the program I made! It’s a cellular automaton (like Conway’s Game of Life) that essentially represents lots of bacteria immobilised on a silicon chip. I based it on this paper from 2004. In my simulation, the cells grow, divide and die based on how much food they are getting from the environment.

The bacteria contain a special gene from fireflies called luciferase, which allows them to bioluminesce. Halfway through the simulation, the cells are bathed in a solution that causes DNA damage. This activates the luciferase gene. The idea behind the original experiment was to use bacteria to sense when a molecule causes DNA damage, in order to screen for molecules that might cause cancer.

The simulation outputs a rudimentary display to the terminal. The glowing bacteria are represented by the letter “O” and the wild-type bacteria are shown by the “#” symbol.

If you want to read more about the biological background and the implementation, you can read my report, or try compiling and running my C code.

This was a really good opportunity to test out all the things I learned about C this week! In addition, the write-up I handed in was written in LaTeX, which I am completely new to. I’ve uploaded my Tex files (report.tex and code.tex) and the bibliography file (cellularautomata.bib, which was created by Mendeley) if you want to have a look at them – it turns out that the trick with LaTeX is just to have a template file to build on.

I found a useful bit of LaTeX code to stitch two PDFs together (which you can download as a file):

\documentclass[11pt,a4paper]{article}

\usepackage{pdfpages}
\begin{document}

\includepdf[pages={1-5}]{writeup.pdf}
\includepdf[pages={1-7}]{code.pdf}

\end{document}

Pretty cool, huh? I’ve put all the LaTeX bits together in a .tar.gz file here. To extract and compile, run these commands in sequence:

tar -xzvf tex-files.tar.gz
pdflatex writeup.tex
bibtex writeup.aux
pdflatex writeup.tex
pdflatex writeup.tex
pdflatex code.tex
pdflatex stitch.tex

Enzymes are the machines of the biological world. In our bodies, they break down our food, fight off invading bacteria, turn sugar into energy, and perform all the processes that keep us alive. Honed by millions of years of evolution, they perform reactions at lightning speed – thousands of times faster than they would happen naturally. Chemists look on in envy as enzymes effortlessly do things that would take them millions of pounds of equipment, and often several years, to copy.

At home, we’re all familiar with enzymes as the secret behind biological washing powders, which clean stains at low temperatures. Commercially, enzymes are used to recycle paper, as well as in septic tanks, and even in kitchens as meat tenderisers. And they do this all at room temperature, without help from strong chemicals.

Making enzymes that perform any reaction we want could revolutionise modern living. Imagine soaking your potatoes in an enzyme bath that takes the skins right off, no peeling necessary. We could make enzymes to break down oil spills into harmless substances, make new medicines that target specific cancers or infections and destroy them – or even make a magic spray that eats away the horrible sticky marks that price labels always leave on books, without destroying the cardboard covers (this one is a dream of mine).

So why haven’t we done this? Well, enzymes need to be a specific shape in order to work at all. Unfortunately, enzymes are a type of protein, and we still don’t know how to make proteins that fold into the shapes we want. A protein chain will always fold into the same shape, time and time again – but the forces behind this are, for the most part, a complete mystery. Until we know this, it’s impossible to make artificial enzymes that are anything other than floppy, useless messes.

We can copy proteins from the natural world, stealing structural sections and active sites and mashing them together. But – if the enzyme produced is even functional – we’re still limited to reactions that real enzymes already do catalyse. So, we’re stuck in this situation, where we can’t design our own enzymes, because we don’t know how to make the structure. But what if we could side-step that problem altogether, and make evolution do the work for us?

Enter antibodies. Antibodies are the first line of defence your immune system puts up against invading germs. They’re proteins as well, and they bind very tightly to specific parts of the bacteria or virus your body is fighting, signalling to the rest of the immune system to come in and destroy it. New antibodies are produced every time your immune system comes across a new pathogen. Antibodies are very specific – each antibody binds to one thing, and it binds that one thing very well indeed.

Scientists raise specific antibodies against a particular molecule by injecting it into a rabbit or a mouse. The animal’s immune system then makes new antibodies against the unfamiliar molecule, which can be taken out and grown in a petri dish.

But what use is a protein that just binds tightly to something if you’re trying to make an enzyme? Well, enzymes use a lot of different tools to make reactions happen. But if we take a step back and look at the whole picture, one common theme underpins them all: enzymes bind the most tightly to the intermediate stage of the reaction they supervise.

Take, for example, an enzyme that converts starch into sugar. It will bind to starch fairly well to start things off, but it will twist the starch molecule out of shape, because it really wants to bind to the intermediate. The intermediate’s structure isn’t quite starch, and it isn’t quite sugar, but it’s something in between. This twisting puts a strain on the starch, making the molecule react and form the intermediate. Intermediates are always unstable molecules, so then the intermediate will rapidly turn into the final product, which is sugar. Et voilà, the reaction has occurred.

So if we can create a stable version of this intermediate and create an antibody which binds to it, we’ll have a sturdy protein shape that catalyses a reaction the way we want it to – no assembly required. These new biological machines have been dubbed “abzymes”, and have already been used to target and inactivate the HIV virus.

Without having to unlock the secrets of protein structure, we’ve managed to make custom, functioning enzymes, just by relying on the immune system to do the work for us. Abzymes: lazy science at its best.

The organism I was looking at was budding yeast – also known as baker’s, or brewer’s yeast. It’s a type of single celled fungus that’s super useful in the kitchen, and is used a lot by biologists for finding out more about the things that happen in cells. Yeast cells sometimes need to recycle the proteins on their outer membrane.

First, a little pit appears in the membrane where the protein (depicted in pink) is.

Then, the pit elongates into a tube shape.

From the end of the tube, a round compartment buds off.

The compartment travels into the cell, where its contents are sorted.

I was looking at the elongation step of this process. My simulation calculates the length of the tube over time.

I wrote it in Python, and I’m releasing it freely under GPL. It consists of four core programs:

• main.py – the central program (I made an extra version that runs several times – repeatedmain.py)
• classes.py – this module contains descriptions of all the agents in my model
• parameters.py – this contains all the constants, like the temperature
• functions.py – this contains all the functions called by main.py

I also made four graphics programs that use the data output:

• graphs.py – requires the PyX module
• images.py – requires the PyX module
• animation.sh – a bash script that requires the ImageMagick suite of programs
• newimages.py – requires PyGame

You can vary lots of the parameters and see what effect they have on the results. The results my simulation gives out aren’t very close to what really happens in cells. I was looking at only a few of the proteins involved, but in reality there are dozens. Hopefully the next student who builds on my code will bring it a little further towards the real world.

If you want more information, I have some PDFs of my final reports. For a brief overview, here’s the presentation I gave last week. For a less brief overview, here’s my written report (figures here). Woo, science!

A big thank you to my supervisor, Rhoda and my co-supervisor Kathryn.

As a student, economy is very important in my meal plans. This is a dish I make quite often, that costs a whopping 46p per serving, provides one of your “five a day” and 6% of your protein RDA. Tesco’s 11p noodles are one of my favourite things in the world – they’re vegetarian if you throw away the flavouring packet, and they have a nice texture. You can substitute in any other brand of instant noodles – you just might have to adjust the cooking time and amount of water. This serves 1.

Ingredients and cost
1 tsp sesame oil for frying (£0.02)
1 tsp Chinese five spice powder (£0.04)
1/4 spring onion, finely chopped (£0.03)
200ml boiling water (free)
1 vegetable stock cube (£0.09)
50g frozen peas (£0.07)
50g frozen sweetcorn (£0.07)
sprinkle of chilli flakes (£0.03)
1 packet of Tesco’s 11p noodles (£0.11)
optional: 1/4 red bell pepper, finely chopped (£0.20, bringing the total cost up to a shocking 66p)

Method
1. Heat up the sesame oil in a saucepan, then add the onion and five spice powder, and fry for a minute or so.
2. Add the boiling water, stock cube, frozen vegetables, bell pepper (if using) and chilli flakes, and bring to the boil.
3. Add the noodles and cook for 2.5 minutes, stirring occasionally.

Serve with a spoon, fork and napkin. It’s messy to eat!

My code can be downloaded from here. In this post, I’m going to take you through how I converted these three models into a single model, added a third dimension, and persuaded the viruses and bacteria to replicate. This is a tale of how it’s possible to do some quite cool things to a program even if you don’t fully understand how it works.

If you’re particularly interested, you can download a PDF of the report I handed in here. It starts with a brief review of a mathematical bacteriophage model, then goes on to the FLAME model in the second half (page 2). I got a mark of 95% for it, so I’m showing it off to everyone ^_^

Three becomes one.
This part was arguably the simplest. The C file phageAndBacteriaV6.c contained conditional statements like this one:

if (BACTERIARADIUS == 100){
     //SAR11
     yUpperBorder = 24;
     yLowerBorder = 736;
} else if (BACTERIARADIUS == 500){
     //Bacteria X
     yUpperBorder = 40;
     yLowerBorder = 720;
} else {
     //Vibrio
     yUpperBorder = 57;
     yLowerBorder = 703;
}

Which handily deals with all the different behaviours of the bacterial species. So all I had to do was combine the bacteria from all 3 versions of the 0.xml file together, and change their IDs to avoid overlap. Then I used conditional display in the FLAME visualiser to make them different sizes and colours in my animation.

Going from 2D to 3D
This was slightly harder – but nowhere near as difficult as I’d anticipated. Broadly, I found everywhere that X and Y were referenced in the code, and added a Z. I replicated a couple of position-checking functions wholesale (including the one above) and added some variables in some places. I found it useful to use “grep -i”, followed by the name of the thing I’d changed, at the command line to look for where variables were used.

You’re probably familiar with the equation to find the length between 2 points in 2 dimensions (from good old Pythagoras):

Extending it to three dimension gives:

So I changed that function, and that does it for phageAndBacteriaV6.c.

I used the FLAME editor to change phageAndBacteriaV6.xml to include the variable “bacteriaZ” as a double belonging to the “Bacteria” agent and to the “bacteriaInformation” message. I also added the variable “phageZ” as a double to the Phage agent and the phageInformation message.

Next, I needed to add starting Z positions for the bacteria and viruses to 0.xml. This was a bit more tricky. I started out by simply using “Find and Replace” in Gedit to change:

</bacteriaY>

to

</bacteriaY>
<bacteriaZ>120</bacteriaZ>

and the same with phageY and phageZ. This was great, because I could then try compiling the model, by running xparser, then “make”. There was only one error on the first attempt (I’d forgotten an asterisk somewhere) and then it all worked fine. I opened up the files using the FLAME visualiser and added the Z component to the visualisation, and there they were, bobbing around.

Great! Except that the bacteria and phages all started from the same Z position (i.e. in the same plane). I wanted them in random places, so I made up a little bash script:

#! /bin/bash

RANGE=780

for i in {1..30}
do
echo $i
number=$RANDOM
let “number %= $RANGE”
let “number=$number + 57″
sed -ie “0,/<phageZ>120/{s/<phageZ>120/<phageZ>$number/}” ./test.xml
done

Which I ran once, then changed the word “phage” to “bacteria” and ran again. This distributed them randomly within the boundaries of my little universe (between 57 and 837 units, somewhat arbitrarily).

Bacterial replication
I was only supposed to be adding phage replication, but I thought bacterial would be interesting (and straightforward), so I did that first. I have to admit I was stumped to begin with, but upon reading the manual (which I should definitely have done first), I discovered the built-in function add_agentname_agent(var1,…,varN). So, based on a random number, I can get my bacteria to divide occasionally. I included this bit of code inside the bacteriaRandomMove() function, which is called at every time step.

double diceRoll = 0;
diceRoll = ((double)rand()/((double)RAND_MAX)); //0 and 1
if (diceRoll <= dividingProbability) {
     printf("Bacteria %d at bx %f by %f bz %f has divided \n", BACTERIAID, BACTERIAX, BACTERIAY, BACTERIAZ);
     add_Bacteria_agent(newb_ID, BACTERIAX, BACTERIAY, BACTERIAZ, BACTERIARADIUS, DEFENSEFACTOR);
     }

Easy peasy! The only problem with this, is that the bacteria ends up with the same ID as its mother. This means that if the one bacteria is killed, its descendants will be as well. According to a trusted source (my awesome friend Gavin), this is an outstanding bug in FLAME, as there is no way to give consecutive numbers to new agents. People often solve this problem by giving agents random IDs over a large range – which does run the risk of occasional collisions, but is certainly better than my method.

Phage burst
There was already a function that kills a bacteria when it is hit by a successful phage attack, so I just had to add in my phage replication code there.

int makeNewPhage(int lphageID, double lphageLife, double lphageX, double lphageY, double lphageZ, double lphageRadius, int lsetSeed, double bactRadius) {
     int burstSize = 0;
     if (bactRadius == 100){
          //SAR11
          burstSize = 1;
     } else if (bactRadius == 500){
          //Bacteria X
          burstSize = 5;
     } else {
          //Vibrio
          burstSize = 9;
     }
     printf(“%d\n”,burstSize);
     int i;
     for(i=0;i<burstSize;i++) { add_Phage_agent(lphageID, lphageLife, lphageX, lphageY, lphageZ, lphageRadius, lsetSeed);}
     return 0;
}

• S3 7
• S6 3
• S10 1
• S10 2
• S10 5

Items that can be donated include bedding, clothes, shoes, cutlery, crockery, unopened toiletries, books, CDs and DVDs. Leave your clear sack outside your house out for collection on:

• Monday 28 May
• Thursday 31 May
• Friday 08 June
• Monday 11 June
• Monday 25 June
• Thursday 28 June

I think it’s pretty cool. It represents a community of bacteria being attacked by viruses. These viruses – known as “bacteriophages” – could be really useful for treating infections, because they can kill bacteria which are resistant to traditional antibiotics.

In order to work out what dosage to use, and when to apply it, we need to know more about how bacteria and viruses interact with each other. This is difficult to study in real life, since viruses are so tiny – but by using computer models, we can make better approximations of how they behave.

The animation shows three types of bacteria, represented by green, blue and pink spheres. The orange dots are viruses. When a bacterium is infected by one of the viruses, it bursts, releasing lots of new viruses. Each virus and bacterium is an “agent” inside the model, and they each follow a particular set of rules, and carry pieces of information. I was using a piece of software called “FLAME” for this.

FLAME uses C and XML to make rules for the agents in a model. I found the documentation a bit obtuse, so I thought I’d make a blog post about exactly what I did, in case it was useful to anyone.

Initially, you need to install a set of programs – gcc, xparser, libmboard, and the FLAME visualiser. The installation instructions on the website are quite straight-forward, so I’ll start my tutorial by talking about running a model.

Running a model in FLAME using the Linux command line

You can download my model code from here. It contains 4 files.

• 0.xml describes the starting state of all the agents in the model
• phageAndBacteriaV6.c contains all of the functions that the agents use
• phageAndBacteriaV6.xml describes all the agents, and the messages they send each other
• visual-rules.xml dictates how the model will be visualised

You start by using the xparser program on the xml file. I saved all my files in /home/beth/models/ so that is the location that I will use in my command line work – you should substitute it for your working folder. So: open up a terminal. Next, navigate to the directory where you have installed xparser and run

./xparser /home/beth/models/phageAndBacteriaV6.xml

This will create a load of files in home/beth/models. Navigate to /home/beth/models and run

make

This creates the model programs, most importantly one called main. You can then run the model, giving the number of iterations you want (in this case, 100) and the location of the 0.xml file (in this case, ./0.xml)

./main 100 ./0.xml

This creates a load of xml files, numbered 1 to 100. Each one contains information about every single agent in the model at a particular time step. Now, these don’t look very exciting in themselves, but this is where the flame visualiser comes in.

Navigate to where you’ve installed the visualiser and run

./flame_visualiser

A window should pop up. Go to “File” > “Open” and find visual-rules.xml. If you click on “Open Visual Window”, you should now see lots of lovely spheres. It’s a fairly straight-forward program to use – you can drag the picture around, start and stop the animation, go back and forward through the iterations, and zoom. If you have a tiny screen, you can grab and move the window by holding down Alt when you click & drag.

I made my animation by opening “Image Settings” and then setting the iteration to 0 and clicking “Start Animation.” This saves a series of numbered images. You can rotate the picture while you’re recording if you fancy. Then I opened up The GIMP, clicked “File” > “Open As Layers” and selected all 100 images. Then I saved the image as a .gif, selecting “Save As Animation”.

So that’s how to run an existing model, and make a pretty picture. In my next post, I talk about how to edit one.

The Hunger Games and A Dangerous Method are also definitely worth a watch, for cool sci fi and angry Freud, respectively.

…watching food programs. Hugh Fearnley-Whittingstall’s River Cottage Veg is showing again on More4 on Sundays at the moment. I love all the River Cottage series anyway, since I’m a huge foodie, but as a vegetarian, watching a food show where I can cook everything on the menu is a particular treat. I have the cookbook that goes with the series as well, and I’ve really enjoyed cooking and eating the recipes I’ve tried, especially the macaroni peas and the spicy carrot and chickpea pita pocket.

The Fabulous Baker Brothers is another food-focussed show I’ve been enjoying, as well as my old favourite, Jamie’s 30 Minute Meals. Edit: I forgot How to Cook Like Heston! How could I? It’s wonderful and mad.

…using PyX to make graphs. It’s a really useful Python module that makes both graphs and pictures. You put in your data and out comes a PDF or a postscript file. It’s super easy to change colours, line styles and axes – and because it’s Python, it fits in well with the simulation that I’m making in the same language. I found the documentation and examples on the website really useful and easy to understand.

…reading some Red Dwarf books. Red Dwarf: Infinity Welcomes Careful Drivers and Better than Life are two old favourites of mine. While the TV series was a bit hit-and-miss in places, the books are very funny and very polished – they employ the same kind of anarchic, surreal comedy as Douglas Adams, with more curry and fewer dressing gowns.

…doing some other things. Apart from all of that, I’ve mostly been huddling inside in the warm and dry while torrential rain thunders outside, revising for my upcoming exams, and turning up at my partner, John’s, house to demand food (successfully: I am working my way through a slice of freshly-based soda bread as we speak). Stay dry, folks.

Strawberry compote for the terminally impatient
Serves 2 or 3

Ingredients:
5 or 6 rubbish strawberries
Zest of 0.25 lemon
Juice of 0.25 lemon (optional, because they’re probably sour enough already)
1 tbsp sugar
0.25 tsp vanilla essence

Directions:
Slice the strawberries.
Put all the ingredients in a saucepan over a low heat and cook until the strawberries are soft – around 5 minutes
Mash with a fork
Serve with anything you like. I went for a croissant and a spoonful of double cream because apparently my resolution this year is to become fat like a house.