Pathway · Sample Problems
Computational Biology
What real problems look like — and what separates a serious one from the easy way out
You have already read what computational biology is and whether it might be for you. This page goes one level deeper. It shows what actual problems in this pathway look like, in enough detail that you can picture the real work involved — and see the difference between engaging with a problem seriously and doing the least you can get away with.
These are examples, not a menu
Every problem below is an illustration of the kind of work this pathway contains — not a list to choose from. You do not have to pick one of these. In fact, the strongest projects usually begin with a biological question a student is genuinely curious about, and grow their own problem around it. You are welcome to build on one of these examples or design something entirely your own. Either way, the standard is exactly the same.
What makes a problem serious
Across every pathway in this course, the difference between a strong project and a weak one is almost never the topic. It is whether the work shows these six things:
- A real question. You are answering something, not just making something.
- A genuine computational core. A real algorithm, model, or analysis does the work — not a few lines that print a result.
- A design decision you can justify. You considered more than one approach and can say why you chose yours.
- Evidence that you tested it. You checked your result against something you can trust, not just "it ran."
- The ability to explain it live. You can walk through your own code and answer questions about how and why it works.
- Honesty about its limits. You can say what your work does not do, and why that matters.
The easy way out is to take any problem — including the ones below — and build only the shallow version: the part that runs quickly and looks finished. That shortcut is visible almost immediately, and it is unmistakable in the oral defense, where you have to explain and modify your own code on the spot. A problem is only as serious as what you do with it.
The thing to understand before you start
You are not assessed on how difficult your topic sounds. You are assessed on the depth of your engagement with it. A simple question taken seriously beats an ambitious one done shallowly, every time.
Sample problem 1 · Compare sequences to answer a real question
DNA and protein sequences carry a record of how living things are related, and of what a stretch of code might do. A strong problem starts with a genuine question — how similar are two species' versions of the same gene? does this DNA contain a known pattern that signals something biological? — and uses sequence comparison to answer it.
The computational core here is real. Measuring true similarity between sequences is not the same as checking them character by character: sequences differ by insertions and deletions, not just substitutions. Handling that properly leads you to algorithms like longest common subsequence or sequence alignment — the same dynamic-programming ideas that power real bioinformatics tools.
The easy way out
- Count how often each of the four letters appears and stop there
- Compare two sequences position by position and report "60% the same," ignoring insertions and deletions
- Never ask what the number actually means biologically
What a serious version demands
- A real question and real sequences chosen to answer it
- A proper comparison that handles insertions and deletions, not just matches
- A check of your result against a known answer or an established tool
- An honest account of what your measure captures and what it misses
Sample problem 2 · Simulate the central dogma
Cells follow a precise procedure to turn DNA into proteins: transcription copies DNA into messenger RNA, then translation reads that RNA three letters at a time, using codons to build a chain of amino acids. Building a working simulation of this is a genuine modelling problem — you are encoding a real biological process as an algorithm.
The interesting difficulty is in the details biology actually cares about: finding the start codon, reading in the correct frame, stopping at a stop codon, and coping with sequences whose length is not a clean multiple of three or that contain unexpected characters.
The easy way out
- Replace every
TwithU, print it, and call it transcription - Translate a single hardcoded example you already know works
- Ignore start codons, stop codons, reading frames, and bad input
What a serious version demands
- Correct handling of reading frames, start and stop codons
- Sensible behaviour on malformed or incomplete sequences
- Testing against sequences whose protein output is already known
- A clear statement of what your model captures faithfully and where it simplifies real biology
Sample problem 3 · Predict protein structure, then test how well you did
A protein's sequence influences how it folds, and its folded shape determines what it does. Using rules about which amino acids tend to form which structures, you can build a predictor that guesses a protein's secondary structure — helix, sheet, or coil — from its sequence alone.
But the prediction is the easy part. The real work — and the whole point — is finding out how good your predictor actually is. That means measuring it against reality, not admiring the output.
The easy way out
- Apply the given rules, print a string of H, S, and C, and declare success
- Never find out whether a single prediction is correct
- Treat the heuristic as if it were the real answer
What a serious version demands
- Running the predictor against proteins whose real structure is known
- Measuring how often it is right, with actual numbers
- Identifying where the simple rules break down, and why
- A grounded discussion of why real structure prediction is genuinely hard
Sample problem 4 · Work with real biological data
Real computational biology happens on real data: genomic databases, microscope and medical images, physiological recordings. A strong problem takes genuine, messy data and extracts something meaningful from it — counting cells in an image, detecting a feature in a scan, or finding a pattern in a large physiological dataset.
What makes this serious is that real data does not cooperate. It is large, it is messy, and when it involves people, it is sensitive. The work lives in loading and cleaning it, choosing a method that actually scales, checking your result against something trustworthy, and handling the data responsibly.
The easy way out
- Use a tiny, clean, toy dataset that avoids every real difficulty
- "Analyse" an image by converting it to grayscale and stopping
- Report a number with no check on whether it is correct
- Ignore that medical data is about real people
What a serious version demands
- Genuine data at a realistic scale, messiness included
- Actually extracting the result — a count, a detection, a classification
- Validation against a known answer or ground truth
- Care for privacy, and honesty about what the analysis can and cannot conclude
Choosing your own problem
These four problems span a lot of the pathway: comparing sequences, simulating a biological process, predicting and then evaluating, and working with real data. They are meant to show you the shape of the space — not to fence you into it. If a different biological question genuinely pulls at your curiosity, follow it. Bring it to your teacher, shape it into a real problem, and hold it to the same six standards above.
Pick something you actually want to understand. The students who do well in this pathway are not the ones who pick the flashiest topic — they are the ones who take a real question and refuse to stop at the surface.