Types of mutation and their molecular consequences

A mutation is nothing more exotic than an edit to the DNA text. One letter swapped for another, a letter or two dropped or inserted, or a whole block copied, deleted, or moved. That is the entire menu. The interesting question is not what a mutation is, it is what a given edit does downstream, and the honest answer depends on two things: what kind of edit it is, and where it lands. Two mutations of the same physical size can do nothing at all or wreck a protein, and this lesson is about predicting which.

You already have the machinery to reason about most of this. In S5.5 you saw that the ribosome reads the message in triplets with no separators between them, that the code is redundant so several codons can spell the same amino acid, and that adding or removing a base slides the frame for everything downstream. Keep that picture close. Almost every consequence below falls out of it.

Substitutions: change one letter

A substitution, also called a point mutation, swaps a single base for a different one. A becomes G, C becomes T, and so on. The base count does not change, so the reading frame does not move. Only the codon that contains the swapped base can be affected, and every codon before and after it groups exactly as before. The blast radius is one codon. What happens inside that one codon splits into three named outcomes.

Silent: the code absorbs it

Recall the redundancy from S5.5. With 64 codons spelling only 20 amino acids, most amino acids have several codons, and synonymous codons usually differ only in their third base. So when a substitution lands on a third base, it very often turns one codon into another codon for the very same amino acid. The protein comes out identical. Nothing changed in the output. This is a silent mutation, and it is the redundancy doing exactly the shock-absorbing job you predicted in the last module.

Missense: a different amino acid

If the swap lands somewhere that changes which amino acid the codon specifies, you get a missense mutation. The protein is now built with one wrong residue at one position. Whether that matters is a spectrum, not a yes or no. Recall from the proteins module (S4) that amino acids differ in the chemistry of their side chains. Swap one amino acid for another with similar chemistry, roughly the same size and charge, and the protein often folds and works about as well as before. This is called a conservative substitution. Swap in a residue with clashing chemistry, or hit a position the fold depends on, and the protein can misfold or lose its job.

The classic example is sickle-cell disease. A single base change in the beta-globin gene turns one codon from glutamate to valine at position six of the protein. That is one residue out of about 146, a swap from a charged side chain to an oily one, and it is enough to make hemoglobin molecules stick together and deform the red blood cell. One letter, one residue, a whole disease. Missense is where the phrase small change, large effect earns its keep.

Nonsense: an early stop

If the swap turns an amino-acid codon into one of the stop codons UAA, UAG, or UGA, you get a nonsense mutation. Now the ribosome hits a stop signal too early and releases a truncated protein, cut off wherever the premature stop landed. A protein missing its back half is usually dead weight. Often the cell notices the premature stop and destroys the whole mRNA before it is even fully translated, a quality-control step you can meet in a moment. Either way, a nonsense mutation tends to knock the gene out.

Insertions and deletions: change the length

Now the edit that changes the number of bases. Insert one or more bases, delete one or more, and you have an insertion or deletion, together shortened to indel. Here the reading frame is suddenly in play, and the single most important number is whether the length change is a multiple of three.

If you add or remove a multiple of three bases, the frame downstream is preserved. You have added or deleted whole codons, so the ribosome adds or drops whole amino acids and then reads the rest of the message in its original grouping. This is an in-frame indel. It edits the protein locally, sometimes harmlessly, sometimes not, but it does not garble everything after it.

If the length change is not a multiple of three, every triplet boundary past the cut slides over, and you get a frameshift, exactly the effect you traced in S5.5. From the point of the indel onward, the ribosome reads a completely different, usually meaningless, string of codons, and it almost always runs into a premature stop before long. One base added or removed can therefore ruin an entire protein from that point on, while one base swapped touches a single residue. That asymmetry is a direct consequence of there being no separators in the message, only a running count of bases from the start.

Bigger edits: duplications, deletions, and rearrangements

Point mutations and small indels are not the whole story. Larger events edit DNA in blocks. A stretch can be duplicated so the genome carries an extra copy, a large region can be deleted outright, and pieces can be inverted (flipped end to end) or translocated (moved to a different chromosome). These are called structural variants, and a change in the number of copies of a region is a copy-number variant. Their effects run from silent to catastrophic depending on what they land on, the same way as the small edits, just at a bigger scale.

One block-scale example sharpens the multiple-of-three rule. Some diseases come from a short run of three bases repeated many times, a trinucleotide repeat, that expands across generations. Because the repeat unit is three bases long, the expansion is a multiple of three, so it does not shift the frame. Instead it inserts a long run of the same amino acid. Huntington's disease works this way, an expanding CAG repeat that adds a growing stretch of glutamines. It is a reminder that in-frame does not mean harmless, it means the frame survives while something else breaks.

Location decides as much as type

So far everything assumed the edit hits a protein-coding stretch. Most of your genome is not that. Recall from S6.2 that coding sequence is a small fraction of the total, and the rest includes regulatory sequences, splice signals, RNA genes, and long tracts with no known job. The same physical edit means wildly different things depending on which of these it lands in.

An edit inside a coding region can change the protein, along the silent, missense, nonsense, and frameshift lines above. An edit in a regulatory region changes not the protein's sequence but its expression, how much of it is made and when. Recall the promoter from S5.6, the landing pad that says a gene begins here. A mutation that weakens or strengthens a promoter or an enhancer leaves the protein sequence perfect while turning its production up or down, which can matter as much as any coding change. And an edit deep in a stretch with no function may do nothing measurable at all. That last case is not rare. It is the common case, and it is the setup for the point the whole lesson has been building toward.

Run the compiler and classify each edit

Reading the taxonomy is not the same as producing it. Go back to the DNA-to-protein compiler from S5.5 and drive it through every category deliberately. Before each edit, predict the class, then check the label the widget gives you.

Try these in order. Change a third base and aim for a silent result where the protein is unchanged. Change a base so a single residue swaps, that is missense. Change a base so a codon becomes a stop and watch the protein truncate, that is nonsense. Then remove one base and watch the frameshift ripple through every downstream codon, and remove three bases and watch the frame survive while only a residue or two disappears. Feeling the difference between a one-base and a three-base deletion is the single most useful reflex in this lesson.

// translate.ts: the ribosome as a loop over codons
const CODON_TABLE: Record<string, string> = {
  AUG: "M", GCA: "A", CUG: "L", ACC: "T",
  UAA: "*", UAG: "*", UGA: "*", /* ...all 64 codons... */
};

function translate(mrna: string): string {
  const rna = mrna.toUpperCase().replace(/T/g, "U");
  let protein = "";
  for (let i = 0; i + 3 <= rna.length; i += 3) {
    const aa = CODON_TABLE[rna.slice(i, i + 3)] ?? "X";
    if (aa === "*") break; // ribosome releases at the first stop
    protein += aa;
  }
  return protein;
}

translate("AUGGCACUGACCUAA"); // "MALT"