Cellular automaton model of bacterial biosensors

So this fortnight at the doctoral training centre, we've been from "Hello World" to image processing in C and Perl. Yeah.

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.

A picture of the simulation running

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

...

Abzymes: tiny factories made to order

I wrote this for the Wellcome science writing prize. It didn't make the shortlist, so I can publish it here!

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.

...

Modelling endocytosis in baker's yeast

For my lab project this year I made a computer model of a biological process.

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:

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.

...