Wednesday, November 21, 2007

Beginnings

I've been a computational biologist for a long time, a lot longer than I've called myself a computational biologist. Basically, I fell in love with computers the first time I saw one. I don't necessarily want to divulge exactly when that was, but suffice it to say that the average Googler was probably fully occupied in meiosis at the time. The computer itself was not very impressive by today's standards, of course, but that wasn't the point. Here was a box where my friends and I could type in simple instructions (in BASIC) and make things happen, like scrolling text or simple animations. I had a hard time explaining to other kids, or my parents for that matter, just what was so compelling about the word 'hello' scrolling back and forth across the screen. But I was hooked.

I did eventually move on to building more complex programs. But what I found I really enjoyed the most was debugging. This is a process of stepping through a program while it is running, line by line, and watching what happens as it unfolds. It's called debugging because usually the motivation is to track down bugs, by seeing exactly when something goes wrong so it can be fixed. Most programmers consider debugging to be, as wikipedia puts it, "a cumbersome and tiring task". But to me it was the ultimate chance to connect the microscopic line-by-line structure of the computer program to its macroscopic behavior as it runs.

I also had a long-standing interest in understanding how living things work. This translated into majoring in biology once I got to college, with a particular interest in genetics. Once again I found myself fascinated with how changes at the microscopic level--mutations in genes--caused visible differences at the macroscopic level. Something as simple as making the connection that blue eyes are the result of a change that gums up the function of a protein involved in making brown pigment. It wasn't much of a leap to connect how I thought about and explained phenotype in terms of genotype, and how I explained the visible behavior of a running program in terms of defects at the coding level.

However similar my thought processes in understanding computational or biological systems, there was always one huge difference: the heroic, often ingenious, but always labor-intensive and time-consuming means needed to get the smallest bit of information about what is going on inside a biological system while it is "running". This stood in stark contrast to the ease with which I could step through a program with a debugger, and monitor or even change any variable I wanted on the fly, all in the space of a few minutes. Whatever amazing progress has been made in modern understanding of biological systems, just what would be possible if we had access to a debugger? At some level, this question has been driving everything I've done since.

No comments: