The genetic code and translation

Translation is where the information in nucleic acid finally becomes a protein. It requires a dictionary, the genetic code, that relates three-nucleotide codons to amino acids, and a machine, the ribosome, that reads an mRNA codon by codon and joins the corresponding amino acids into a chain. Between the two stand the transfer RNAs, adapter molecules that carry amino acids on one end and recognize codons with the other. This lesson explains how the code was cracked, how it is organized, how tRNAs are charged with the right amino acid, and how the ribosome initiates, elongates and terminates a polypeptide. It also shows how to translate sequences in code and find open reading frames, skills used throughout the rest of the course.

Cracking the code

With four bases and 20 amino acids, a code using two bases per amino acid would give only 16 combinations, too few, so the code must use at least three. In 1961 Francis Crick, Sydney Brenner and colleagues used frameshift mutations in phage T4 to show that the code is read in non-overlapping triplets from a fixed starting point: a single insertion or deletion destroyed gene function, but combining three insertions (or three deletions) close together restored it.

The same year, Marshall Nirenberg and Heinrich Matthaei at the US National Institutes of Health made a cell-free extract from E. coli that could make protein, added a synthetic RNA consisting only of uracil, poly(U), and found that it produced a polypeptide made only of phenylalanine. UUU therefore codes for phenylalanine. Over the next five years, the rest of the code was worked out using other synthetic RNAs, including precisely repeating sequences made by Har Gobind Khorana, and by a binding assay in which trinucleotides of known sequence caused specific charged tRNAs to stick to ribosomes. Khorana had begun his work on synthesizing nucleotides while at the British Columbia Research Council in Vancouver in the 1950s, before moving to Wisconsin. Nirenberg, Khorana and Robert Holley, who determined the first tRNA structure, shared the 1968 Nobel Prize.

Features of the code

Of the 64 codons, 61 specify amino acids and three, UAA, UAG and UGA, are stop codons that end translation. AUG codes for methionine and also serves as the usual start codon. The code is degenerate (or redundant): most amino acids are specified by more than one codon, and the codons for the same amino acid usually differ only at the third position. Leucine, serine and arginine have six codons each, while methionine and tryptophan have only one. The code is unambiguous, since each codon specifies only one amino acid, and nearly universal: with a few exceptions in mitochondria and some microorganisms, the same code is used by bacteria, archaea, plants, fungi and animals, strong evidence that all life shares a common ancestor.

The organization of the code is not random. Codons for chemically similar amino acids tend to be similar, and the third-position redundancy means that many single-base changes are silent. Codons with U in the second position specify hydrophobic amino acids. As a result, the most common point mutations often cause no change or a change to a similar amino acid, which limits their harm; studies comparing the real code with random alternative codes find that it is unusually good at minimizing the effects of errors.

Translating sequences

In code, the genetic code is usually stored as a lookup table from codons to one-letter amino acid symbols. The compact construction below builds the table from the standard order of bases (T, C, A, G) and a 64-letter string listing the amino acids in that order, with * for stop. The function translates a DNA coding strand three bases at a time, which is equivalent to translating the mRNA.

bases = "TCAG"
aas = "FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG"
CODON = {a + b + c: aas[16 * i + 4 * j + k]
         for i, a in enumerate(bases) for j, b in enumerate(bases) for k, c in enumerate(bases)}

def translate(dna, stop_at_stop=True):
    protein = []
    for i in range(0, len(dna) - 2, 3):
        aa = CODON[dna[i:i+3]]
        if aa == "*" and stop_at_stop:
            break
        protein.append(aa)
    return "".join(protein)

print("number of codons:", len(CODON))
print("stop codons:", sorted(c for c, a in CODON.items() if a == "*"))
from collections import Counter
deg = Counter(CODON.values())
print("codons per amino acid:", dict(sorted(deg.items(), key=lambda kv: -kv[1])))
print("ATGGCTAAGGCATTATGA ->", translate("ATGGCTAAGGCATTATGA"))

number of codons: 64
stop codons: ['TAA', 'TAG', 'TGA']
codons per amino acid: {'L': 6, 'S': 6, 'R': 6, 'P': 4, 'T': 4, 'V': 4, 'A': 4, 'G': 4, '*': 3, 'I': 3, 'F': 2, 'Y': 2, 'C': 2, 'H': 2, 'Q': 2, 'N': 2, 'K': 2, 'D': 2, 'E': 2, 'W': 1, 'M': 1}
ATGGCTAAGGCATTATGA -> MAKAL

Reading frames and open reading frames

Because codons are read in non-overlapping triplets, any stretch of sequence can be read in three reading frames on each strand, six in total. Only one is normally used for a given gene. An open reading frame (ORF) is a stretch beginning with a start codon and continuing, without a stop codon, for a reasonable length. Stop codons occur by chance about once every 21 codons in random sequence (3 of 64), so a long ORF, hundreds of codons without a stop, is a strong hint that a sequence encodes a protein. Finding ORFs is a first step in annotating a newly sequenced genome (BIOL-410).

bases = "TCAG"
aas = "FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG"
CODON = {a + b + c: aas[16 * i + 4 * j + k]
         for i, a in enumerate(bases) for j, b in enumerate(bases) for k, c in enumerate(bases)}

import random
random.seed(207)
COMP = str.maketrans("ACGT", "TGCA")
def revcomp(s): return s.translate(COMP)[::-1]

def orfs(dna, min_codons=30):
    found = []
    for strand, seq in (("+", dna), ("-", revcomp(dna))):
        for frame in range(3):
            i = frame
            while i < len(seq) - 2:
                if seq[i:i+3] == "ATG":
                    j = i
                    while j < len(seq) - 2 and CODON[seq[j:j+3]] != "*":
                        j += 3
                    if j < len(seq) - 2 and (j - i) // 3 >= min_codons:
                        found.append((strand, frame + 1, i, (j - i) // 3))
                    i = j + 3
                else:
                    i += 3
    return found

# Embed a 120-codon ORF inside random sequence, on the minus strand
gene = "ATG" + "".join(random.choice([c for c in CODON if CODON[c] != "*"]) for _ in range(119)) + "TAA"
dna = "".join(random.choices("ACGT", k=300)) + revcomp(gene) + "".join(random.choices("ACGT", k=300))
print("sequence length:", len(dna))
for strand, frame, start, length in orfs(dna):
    print(f"ORF on {strand} strand, frame {frame}, starting at {start}: {length} codons")

sequence length: 963
ORF on + strand, frame 1, starting at 153: 63 codons
ORF on + strand, frame 2, starting at 100: 33 codons
ORF on + strand, frame 2, starting at 325: 45 codons
ORF on + strand, frame 3, starting at 683: 41 codons
ORF on - strand, frame 1, starting at 300: 120 codons
ORF on - strand, frame 2, starting at 121: 35 codons
ORF on - strand, frame 3, starting at 278: 53 codons

The search finds the planted 120-codon ORF on the minus strand and, depending on chance, perhaps a few shorter ones. Real annotation pipelines add other evidence: codon usage typical of the organism, ribosome-binding sites, similarity to known proteins and, increasingly, experimental data showing which regions are actually translated.

Transfer RNA and its charging

Transfer RNAs are about 76 nucleotides long and fold into a cloverleaf secondary structure that packs into an L-shaped three-dimensional form. At one end of the L, three nucleotides form the anticodon, which pairs with the codon in the mRNA. At the other end, the 3′ terminus always ends in CCA, and the amino acid is attached to the 3′-OH of the final adenosine. A tRNA carrying its amino acid is said to be charged, or aminoacylated.

Charging is carried out by aminoacyl-tRNA synthetases, typically one for each amino acid. Each synthetase recognizes both its amino acid and all the tRNAs for that amino acid, using ATP to attach them. The synthetases are the real decoders of the genetic code: once a tRNA is charged, the ribosome checks only codon–anticodon pairing, not the amino acid itself. Experiments in which cysteine on a charged tRNA for cysteine was chemically converted to alanine showed that the ribosome then inserted alanine at cysteine codons. To maintain accuracy, many synthetases have an editing site that removes wrongly attached amino acids. Isoleucyl-tRNA synthetase, for instance, sometimes activates the slightly smaller valine, but removes it at the editing site, reducing errors to about 1 in 40,000.

Wobble

Cells have fewer tRNA types than the 61 sense codons, typically 30 to 45, because one tRNA can read several codons. Crick’s wobble hypothesis explains how: the first two codon positions pair strictly with the anticodon, but pairing between the third codon base and the first anticodon base is relaxed. A G in the anticodon’s first position can pair with C or U, and inosine (I), a modified base found in some tRNAs, can pair with U, C or A. This is why third-position changes are so often silent.

The ribosome

Ribosomes are large RNA–protein machines. The bacterial 70S ribosome has a small 30S subunit and a large 50S subunit; the eukaryotic 80S ribosome has 40S and 60S subunits. (The S stands for svedberg units of sedimentation, which are not additive.) About two thirds of the bacterial ribosome’s mass is RNA. The small subunit binds the mRNA and checks codon–anticodon pairing; the large subunit contains the peptidyl transferase center, which joins amino acids. High-resolution structures of the ribosome, recognized by the 2009 Nobel Prize in Chemistry to Venkatraman Ramakrishnan, Thomas Steitz and Ada Yonath, showed that the peptidyl transferase center is made entirely of RNA, with no protein within reach of the reaction: the ribosome is a ribozyme.

The ribosome has three tRNA-binding sites. The A (aminoacyl) site receives each incoming charged tRNA. The P (peptidyl) site holds the tRNA carrying the growing polypeptide. The E (exit) site holds the empty tRNA before it leaves. The mRNA threads through the small subunit, and the polypeptide emerges through a tunnel in the large subunit.

Initiation

Translation begins at a start codon, almost always AUG, and the ribosome must find the right one. In bacteria, the 16S rRNA of the small subunit pairs with a purine-rich ribosome-binding site, the Shine–Dalgarno sequence (consensus AGGAGG), located about 7 nucleotides upstream of the start codon. This places the start codon in the P site. A special initiator tRNA carries N-formylmethionine (fMet). Initiation factors IF1, IF2 and IF3 assist, and the large subunit joins once the initiator tRNA is in place. Because each gene in a polycistronic mRNA has its own Shine–Dalgarno sequence, ribosomes can start at several points along one mRNA.

Eukaryotic ribosomes find the start codon differently. The cap-binding complex eIF4F, including eIF4E, binds the 5′ cap and recruits the small subunit carrying the initiator tRNA (which carries ordinary methionine). The complex then scans along the mRNA until it encounters an AUG in a good context, the Kozak sequence, with consensus GCCRCCAUGG (where R is a purine). The first AUG is used in most mRNAs. The poly(A) tail, bound by poly(A)-binding protein, interacts with eIF4G at the cap, effectively making the mRNA circular and boosting initiation. Eukaryotic mRNAs are almost always monocistronic.

Elongation and termination

Each elongation cycle adds one amino acid. A charged tRNA, delivered to the A site by the GTP-binding elongation factor EF-Tu (eEF1A in eukaryotes), is tested for correct pairing with the codon. If the match is right, the small subunit closes around it, EF-Tu splits GTP and leaves, and the tRNA settles fully into the A site. Incorrect tRNAs usually dissociate before or after GTP hydrolysis; this two-stage check, kinetic proofreading, keeps the error rate to about 1 in 10⁴ amino acids. Peptidyl transferase then moves the growing chain from the P-site tRNA onto the amino acid in the A site, forming a peptide bond. Finally, elongation factor EF-G (eEF2), also using GTP, translocates the ribosome by one codon, moving the tRNAs from A and P to P and E.

When a stop codon enters the A site, no tRNA matches it. Instead, a protein release factor binds (RF1 or RF2 in bacteria, eRF1 in eukaryotes), and its structure mimics a tRNA. The release factor triggers peptidyl transferase to add water rather than an amino acid, releasing the finished polypeptide. Ribosome recycling factors then split the subunits so they can start again.

Many ribosomes can translate one mRNA at the same time, spaced about 100 to 200 nucleotides apart, forming a polyribosome or polysome. A single mRNA can therefore produce many protein molecules quickly. In bacteria, polysomes form on mRNAs still being transcribed (lesson 5).

Antibiotics and the ribosome

Because bacterial and eukaryotic ribosomes differ, many antibiotics target the bacterial ribosome. Their effects revealed much about how ribosomes work. Streptomycin and other aminoglycosides bind the small subunit and cause misreading. Tetracyclines block tRNA binding to the A site. Chloramphenicol inhibits peptidyl transferase. Macrolides such as erythromycin and azithromycin block the exit tunnel. Some side effects of these drugs reflect the bacterial ancestry of mitochondria, whose ribosomes resemble bacterial ones; aminoglycosides, for instance, can damage hearing in people with a particular mitochondrial rRNA variant. Canadian and American guidelines increasingly recommend testing for that variant before aminoglycoside treatment in some settings, such as newborn intensive care.

bases = "TCAG"
aas = "FFLLSSSSYY**CC*WLLLLPPPPHHQQRRRRIIIMTTTTNNKKSSRRVVVVAAAADDEEGGGG"
CODON = {a + b + c: aas[16 * i + 4 * j + k]
         for i, a in enumerate(bases) for j, b in enumerate(bases) for k, c in enumerate(bases)}

# Codon usage in a coding sequence: how often each synonymous codon is used
from collections import Counter, defaultdict
seq = ("ATGGCTGCAGCCGCGCTGCTGCTGTTACTTCTCAAAAAGAAAGAAGAGGAAGGCGGTGGGGGA"
       "CGTCGCAGAAGGCGCTCTAGCAGTTCATCCTCGACCACTACAACGTTTTTCTACTATTGA")
counts = Counter(seq[i:i+3] for i in range(0, len(seq) - 2, 3))
by_aa = defaultdict(dict)
for codon, n in counts.items():
    by_aa[CODON[codon]][codon] = n
for aa in ["L", "K", "E", "G", "R", "S"]:
    total = sum(by_aa[aa].values())
    shares = ", ".join(f"{c} {n/total:.0%}" for c, n in sorted(by_aa[aa].items(), key=lambda kv: -kv[1]))
    print(f"{aa}: {shares}")

L: CTG 50%, TTA 17%, CTT 17%, CTC 17%
K: AAA 67%, AAG 33%
E: GAA 67%, GAG 33%
G: GGC 25%, GGT 25%, GGG 25%, GGA 25%
R: CGC 40%, CGT 20%, AGA 20%, AGG 20%
S: TCT 17%, AGC 17%, AGT 17%, TCA 17%, TCC 17%, TCG 17%

Organisms do not use synonymous codons equally. Highly expressed genes in E. coli and yeast prefer codons read by abundant tRNAs, which speeds translation. When a human gene is expressed in bacteria for research or industrial production, for example insulin made in E. coli, scientists often rewrite it with codons preferred by the host, called codon optimization, to improve yields.