The central dogma

From gene to protein

Lesson 2 opened the box and named the molecules in a cell. This lesson follows the information inside them. A gene is a stretch of DNA, and the cell turns it into a protein in two steps: it copies the gene into RNA, and then it reads the RNA to build the protein. By the end you will have written Python that does the same for every one of syn3A’s genes, and the 455 proteins it makes will match the published ones letter for letter.

The picture below shows the whole process. Tap a step to look closer, or switch to Code view to see the same pipeline in software terms.

From gene to protein

How a cell turns a gene into a working protein, in five steps. Tap a step, or a part of the picture.

BiologyCode view

DNA → RNA → protein: genes are copied into short-lived messages, and ribosomes read them to build proteins.

1. 1Gene
2. 2Transcription
3. 3mRNA
4. 4Translation
5. 5Protein
6. All steps

The central dogma

DNA → RNA → protein

Information flows one way: from the DNA genome, to short-lived RNA copies, to proteins that do the work. Biologists call this the central dogma. Tap a step, or a part of the picture, to look closer.

‹ PreviousStart: step 1 ›

ACGTU: the letters (RNA has U where DNA has T)amino acids: oily, polar, positive, negative

The letters are real syn3A DNA: the start of its dnaA gene (JCVISYN3A_0001), whose protein begins MNVNDILKELKLSLMANKNI. Shapes are simplified. Numbers: GenBank CP016816.2 and Thornburg et al. (2019), Frontiers in Molecular Biosciences 6:130.

Genes: where the instructions are

A gene is a stretch of DNA that the cell copies into RNA. Most genes are recipes for proteins: their RNA is a message that ribosomes read. A few genes make RNAs that do a job themselves, such as the RNAs inside the ribosome and the transfer RNAs that bring amino acids to it.

syn3A has 493 genes. Its GenBank record lists 455 protein-coding genes and 38 RNA genes: 6 ribosomal RNA genes (two copies each of three kinds), 29 transfer RNA genes, and three others. You will sometimes see 452 protein-coding genes quoted instead; papers that use a slightly different annotation count them that way.

A protein-coding gene has more parts than the protein recipe itself. RNA polymerase, the enzyme that copies DNA into RNA, lands on a promoter just before the gene and starts copying at position +1. The copy runs to a terminator, where the polymerase lets go. Inside the copy, the protein recipe runs from a start codon, ATG, to a stop codon. The stretches before the start and after the stop are copied but not read into protein. Just before the start codon sits a short Shine–Dalgarno sequence, where the ribosome grabs on.

DNA has two strands, and genes sit on both. GenBank writes every position along one strand, the one in the file. A gene on that strand runs left to right, from small numbers to big ones, and GenBank writes it as 7435..9939. A gene on the other strand runs the opposite way, and GenBank writes it as complement(9991..10968): the numbers are still on the file’s strand, smaller first, but the gene is read on the partner strand, from 10,968 down to 9,991.

Here are all 493 of syn3A’s genes, from its real GenBank record. Tap a gene to see its card, or step through them with Previous and Next.

syn3A’s 493 genes

syn3A’s whole chromosome, a loop of 543,379 base pairs, drawn as a circle. Every gene sits at its real place and length: the outer ring holds the genes on the forward strand, the inner ring those on the other strand. Tap a gene, or step through them.

All493Protein-coding455RNA genes38Uses TGA343Unknown function130

‹ Previous493 genesNext ›

Find a gene

Go

Zoom: 10,000 bases around the origin (base 1)

Above the line, forward-strand genes point right (→). Below it, other-strand genes point left (←).

The whole genome

All 493 genes: 455 for proteins and 38 for RNAs. 217 lie on the forward strand (outer ring) and 276 on the other strand (inner ring).

Tap a gene on the circle or the strip, use Previous and Next, or search by name or locus tag.

Protein genes, by rough group

• Translation 94
• Making and processing RNA 49
• DNA 26
• Transport 31
• Metabolism 109
• Membrane and secretion 13
• Cell division 3
• Unknown function 130
• RNA genes 38rRNA, tRNA, other

The groups are rough guesses from the product names in GenBank, so a few genes sit in the wrong one. Very short genes (a tRNA gene is about 76 bases) are drawn a little wider than true scale so you can see them.

Data: NCBI GenBank CP016816.2 (JCVI-syn3A), via site/src/data/syn3a-genes.json.

Some things to notice:

• The genes are packed tight. 88% of the genome codes for protein. The middle-sized gap between two neighboring genes is only 36 base pairs, and 63 pairs of neighbors overlap.
• Both strands carry genes: 201 protein genes on the file’s strand and 254 on the other.
• Proteins come in all sizes. The shortest is 37 amino acids, ribosomal protein L36 (gene rpmJ). The middle length is 283 and the longest is 1,795.
• Even this minimal cell has mysteries. The 2018 GenBank record calls 130 proteins “uncharacterized”. Later work worked out jobs for many of them, but about 90 are still unclear.

Math toolkit: positions and strands

GenBank counts bases from 1, and a range includes both ends. So dnaA, at 1..1353, is

$$\text{length} = \text{end} - \text{start} + 1 = 1{,}353 - 1 + 1 = 1{,}353 \text{ bases}$$

That is $1{,}353 \div 3 = 451$ codons. The last codon is the stop, which adds no amino acid, so the protein has 450 amino acids.

Python counts from 0, and a slice stops just before its end index. GenBank’s base 1 is Python’s genome[0], so GenBank’s start..end is

genome[start - 1:end]

The start moves down by one, and the end stays where it is, because the slice leaves out its end index. For dnaA that is genome[0:1353]: 1,353 letters.

For a gene on the other strand, cut out the same slice and then take its reverse complement, from Lesson 2. The gene at complement(9991..10968) is reverse_complement(genome[9990:10968]): 978 letters that start with the start codon ATG.

Check yourselfsyn3A's ftsZ gene runs from base 331,411 to base 332,568, on the other strand. How long is it, and how many amino acids does its protein have?

Length: $332{,}568 - 331{,}411 + 1 = 1{,}158$ bases. That is $1{,}158 \div 3 = 386$ codons, and without the stop codon, 385 amino acids.

Check yourselfWhich Python slice holds ftsZ, and what do you do with it next?

genome[331410:332568]. The gene is on the other strand, so take the reverse complement of that slice before reading it.

Check yourselfLetter 10 of a gene is in which codon, and where in it?

Codon $\lfloor (10 - 1) \div 3 \rfloor + 1 = 4$, as its first letter. Codon 1 holds letters 1–3, codon 2 letters 4–6, codon 3 letters 7–9, and codon 4 starts at letter 10.

Transcription: DNA to RNA

Transcription copies a gene into RNA. The enzyme that does it is RNA polymerase. First it has to find where a gene starts. A helper protein called the sigma factor rides on the polymerase and feels along the DNA for two short signposts: in E. coli, the letters TTGACA (the −35 box) and TATAAT (the −10 box), about 17 base pairs apart. The numbers say how far each box sits before position +1, where copying starts, about 7 bases after the −10 box. Real promoters rarely match all twelve letters, and the closer the match, the more often the gene is copied.

Once it has bound, the polymerase pulls the two DNA strands apart. It reads one of them, the template strand, and builds the RNA by pairing with it: A with U, T with A, G with C, C with G. The two strands run in opposite directions, so the polymerase reads the template from its 3′ end toward its 5′ end, and the RNA grows from its 5′ end to its 3′ end.

The other DNA strand is the coding strand. The RNA has the same letters as the coding strand, with U in place of T. That is why gene sequences are always written as the coding strand: the RNA, and the protein, can be read straight off it.

The figure shows the three stages. The polymerase lands on the promoter; it opens a bubble about 13 base pairs long and copies the template, with the newest 8 or so RNA letters still paired to the DNA; and at the end of the gene it lets go.

How does the polymerase know where to stop? Many bacterial genes end with a terminator: a stretch rich in G and C that, once copied, folds back on itself into a tight hairpin, followed by a run of T’s. The hairpin pulls on the polymerase, and behind it the RNA is held only by weak A–U pairs, so the RNA comes loose. syn3A’s gyrA gene ends with one: the third panel of the figure shows its real letters.

In the whole-cell model of syn3A, each polymerase adds about 25 letters per second, a value measured in E. coli. So a 1,000-letter gene takes

$$\frac{1{,}000 \text{ letters}}{25 \text{ letters per second}} = 40 \text{ seconds}$$

syn3A has about 187 RNA polymerases, and about 29 of them are copying a gene at any moment. The genes for ribosomal RNA are copied fastest, about 90 letters per second, with two polymerases on each.

Now be the polymerase. In Polymerase Pilot, slide along the DNA until both of sigma’s windows match, bind, choose your template strand, and spot the terminator before you reach it. The sequences are made up, built around the textbook boxes.

3D game · Polymerase Pilot

Be the RNA polymerase

Mistakes 0Stars 0/15

Sound on

1. Find the promoter2. Spacing matters3. The other strand4. Transcribe and stop5. Real speed

1. Find the promoter

You are RNA polymerase, the enzyme that copies a gene into RNA. First, find where a gene starts: its promoter.

Your sigma factor (σ, the orange part) has two reading windows, 17 base pairs apart. One looks for TTGACA (the −35 box). The other looks for TATAAT (the −10 box).

Slide along the DNA. When both windows match, the grip meter fills up. Then tap Bind here.

The DNA here is made up, built around the textbook boxes and terminator of E. coli genes.

Start scanning

Top 5′→3′Bottom 3′←5′

−35−10+1

AATTCTTTAGAACACTTTACACATACTTTCCTTTAGCTTATGTTTGTAGTTGTATCAAGTTTGACAGTCATCTCATCAGCCAGTATAATACTACAAACCAGTGGGTCGATTATCGAACTG

TTAAGAAATCTTGTGAAATGTGTATGAAAGGAAATCGAATACAAACATCAACATAGTTCAAACTGTCAGTAGAGTAGTCGGTCATATTATGATGTTTGGTCACCCAGCTAATAGCTTGAC

Sigma reads the top strand, 5′→3′, left to right →

−35 window 1/6AATTCTwants TTGACA

−10 window 3/6TACTTTwants TATAAT

Grip 4 · no grip

Slide the polymerase along the DNA

◀◀ 5◀ 11 ▶5 ▶▶

⟲ Turn aroundBind here

The sequences in this game are made up, built around the textbook E. coli promoter boxes (−35 TTGACA, −10 TATAAT) and a typical terminator. Drawn roughly to scale: the DNA is 2 nm wide with 0.34 nm per base pair, and a real RNA polymerase is about 15 nm long.

Your first Python of the lesson does the polymerase’s job: given a template strand, written 5′ to 3′ as sequences always are, return the mRNA, also 5′ to 3′. The last check uses a real syn3A gene on the other strand, where GenBank’s strand is the template.

Python exercise

Transcribe: DNA to mRNA

PAIR = {"A": "T", "T": "A", "G": "C", "C": "G"} # each DNA base and its partner def transcribe(template): """The mRNA made from a gene's template strand. Both are written 5′→3′.""" # RNA polymerase reads the template strand and builds the mRNA from the # partners of its bases. The two strands run in opposite directions, so # the mRNA is the template's reverse complement, in RNA letters. # Step 1: make the template uppercase, so lowercase input works too. # Step 2: take its reverse complement, as in Lesson 2: swap each base for # its partner with PAIR, then reverse the order with [::-1]. # Step 3: RNA uses U where DNA uses T. text.replace("T", "U") swaps them. # Return one uppercase string. raise NotImplementedError("Write your code here") # Remove the # below to try it. This made-up template should give AUGGGGUAA. # print(transcribe("TTACCCCAT")) # Then a real gene. dnaA, syn3A's first gene, is on the forward strand, so its # template is the other strand. The template for dnaA's first 20 bases, # written 5′→3′, is AAAATATCGTTTACGTTCAT. You should see AUGAACGUAAACGAUAUUUU. # print(transcribe("AAAATATCGTTTACGTTCAT")) # rnsD runs the other way: GenBank writes it as complement(9991..10968). For a # gene like that, the genome as GenBank writes it IS the template strand. # from virtualcell.genomes import load_syn3a_genome # genome = load_syn3a_genome() # print(transcribe(genome[9990:10968])[:30])

Ctrl+Enter runs your code. Tab indents; press Esc then Tab to leave the editor.

Run and checkHint (3 left)Show solutionReset

The genetic code

A ribosome reads an mRNA three letters at a time. Each group of three is a codon, and each codon stands for one amino acid or for “stop”. The table that links them is the genetic code. Four letters in three positions make $4 \times 4 \times 4 = 64$ codons, for only 20 amino acids and stop, so most amino acids have several codons. AUG is special: it means methionine, and it is also the usual start codon, where a ribosome begins.

The code is often drawn as a wheel. Read it from the center out: the first letter of the codon, then the second, then the third, and on the rim the amino acid. Tap any codon or amino acid, or build a codon with the buttons.

The genetic code

Read the wheel from the center out: the first letter of a codon, then the second, then the third, and on the rim the amino acid it stands for. Tap any codon or amino acid.

Standard codesyn3A (code 4)

syn3A’s usageFind a codon

64 codons: 61 stand for the 20 amino acids and 3 mean stop.

Build a codon:

1stUCAG

2ndUCAG

3rdUCAG

64 codons, 20 amino acids

Three letters, each one of four (U, C, A, G), give 4 × 4 × 4 = 64 codons. Most amino acids have two or more codons, so a change in the third letter often makes no difference.

syn3A’s 455 genes hold 159,283 codons. The most used is AAA (lysine), 15,126 times; the rarest is CGG (arginine), only 10 times.

oily (hydrophobic)polar (water-loving)positive chargenegative chargeglycine and prolinestopstart (AUG)

Codes: NCBI genetic code tables 1 (standard) and 4 (Mycoplasma and Spiroplasma). Usage: all codons of syn3A’s 455 protein genes, start and stop codons included, from GenBank CP016816.2.

A different code in syn3A

Almost all living things use the same code, the standard code. syn3A doesn’t. Like the mycoplasma bacteria it was built from, it uses genetic code 4, where one codon changes meaning: UGA means tryptophan, not stop. syn3A has only two stop codons, UAA and UAG. Switch the wheel to syn3A’s code to watch UGA flip.

The change is real and the genome is full of it. Inside syn3A’s genes, TGA (UGA in the mRNA) appears 1,383 times, against only 36 for TGG, tryptophan’s other codon. 343 of its 455 genes contain a TGA. syn3A has a transfer RNA whose anticodon pairs with UGA, and it lacks the release factor that reads UGA as stop in E. coli. Read with the standard code, 343 of its proteins would be cut short.

Turn on syn3A’s usage on the wheel to see which codons the cell really uses. Its DNA is rich in A and T, and its codons show it: AAA, for lysine, appears 15,126 times, and CGG only 10. Only 7.75% of third letters are G or C.

Math toolkit: codons and reading frames

Why three letters? A code needs at least 21 different words: 20 amino acids and stop. With 4 letters,

• 1-letter words give $4^1 = 4$: not enough.
• 2-letter words give $4^2 = 16$: still not enough.
• 3-letter words give $4^3 = 64$: enough, with 43 to spare.

So three is the shortest length that works, and the spare words are why most amino acids have several codons: 61 codons for 20 amino acids in the standard code, about 3 each.

A ribosome has to start reading in the right place. Shift the start by one letter and every codon changes. Take ATGAAACCC:

• Starting at letter 1: ATG AAA CCC, which reads M K P.
• Starting at letter 2: TGA AAC, then two letters left over.
• Starting at letter 3: GAA ACC, then one letter left over.

These are the three reading frames of a strand. In Python they start at index 0, 1, or 2. The other strand has three more, so every stretch of DNA has six reading frames. A gene uses one of them, from its start codon on.

Two exercises turn this into code. First, cut a sequence into codons in any frame.

Python exercise

Cut a sequence into codons

def codons(sequence, frame=0): """Cut a sequence into codons, groups of 3 letters, starting at index frame.""" # A ribosome reads 3 letters at a time, so where it starts matters. # frame is 0, 1 or 2: how many letters to skip before the first codon. # Step 1: the codons start at index frame, then frame + 3, frame + 6, ... # range(start, stop, step) counts like that. # Step 2: the codon that starts at index i is sequence[i:i + 3]. # Step 3: leave out a group at the end that has fewer than 3 letters. # Return a list of the codons. raise NotImplementedError("Write your code here") # Remove the #s below to try it. You should see ['ATG', 'AAA', 'CCC'], # then ['TGA', 'AAC'] (frame 1 skips the first letter; the last "CC" is not a codon). # print(codons("ATGAAACCC")) # print(codons("ATGAAACCC", 1)) # Then a real gene: syn3A's dnaA, bases 1 to 1,353 of its genome. # from virtualcell.genomes import load_syn3a_genome # dnaA = load_syn3a_genome()[0:1353] # print(len(codons(dnaA)), codons(dnaA)[:5], codons(dnaA)[-1])

Ctrl+Enter runs your code. Tab indents; press Esc then Tab to leave the editor.

Run and checkHint (3 left)Show solutionReset

Then translate: look each codon up in the genetic code, which the engine gives you as two Python dicts in virtualcell.genetic_code, STANDARD_CODE and SYN3A_CODE. Their keys are RNA codons such as "AUG", and "*" means stop. Stop at the first stop codon. One check translates a real syn3A gene, rpmH, whose protein is part of the ribosome.

Python exercise

Translate: mRNA to protein

from virtualcell.genetic_code import STANDARD_CODE, STOP, SYN3A_CODE # The code tables map RNA codons to one-letter amino acids. Have a look: print(SYN3A_CODE["AUG"], SYN3A_CODE["AAA"], SYN3A_CODE["UAA"]) # M K * (* means stop) print(SYN3A_CODE["UGA"], STANDARD_CODE["UGA"]) # W * (syn3A reads UGA as tryptophan) def translate(sequence, code=SYN3A_CODE): """The protein a sequence codes for, read codon by codon from its first letter.""" # Step 1: make the sequence uppercase and turn T into U. The code's keys are # RNA codons like "AUG", and this way DNA works too. # Step 2: go through the codons: the one at index i is rna[i:i + 3], for # i = 0, 3, 6, ... Leave out an incomplete codon at the end. # Step 3: look each codon up in code. If it is STOP ("*"), the protein is # finished: break out of the loop without adding the "*". # Otherwise add the amino acid to a list. # Return the amino acids as one string, such as "MAK". raise NotImplementedError("Write your code here") # Remove the # below to try it. You should see MAK: methionine, alanine, lysine. # print(translate("AUGGCCAAAUAA")) # Then a real gene: rpmH, which makes ribosomal protein L34. GenBank writes it # as complement(542952..543086). Here is its coding strand, from start to stop: RPMH = ( "ATGAAAAGAACTTGACAACCATCAAAACTAAAACATGCACGTGTT" "CATGGATTTAGAGCAAGAATGGCTACTGAAAATGGTAGAAAAGTA" "ATTAAAGCTCGTAGAGCTAAAGGTAGAGTTAGATTATCTGCTTAA" ) # print(translate(RPMH)) # print(translate(RPMH, STANDARD_CODE)) # the same gene, read with the standard code

Ctrl+Enter runs your code. Tab indents; press Esc then Tab to leave the editor.

Run and checkHint (3 left)Show solutionReset

Math toolkit: chance and stop codons

How do you find a gene in a long string of DNA? Look for a long stretch with no stop codon. In random DNA with all four letters equally common, each codon is a stop with chance

$$p = \frac{3}{64} \approx 0.047 \quad \text{(standard code)}$$

So stops turn up about every $1 \div p \approx 21$ codons. With syn3A’s code, only 2 of the 64 codons are stops: $p = 2/64 \approx 0.031$, about one every 32 codons.

syn3A’s letters aren’t equally common: A is 37.5% of its genome, T 38.2%, G 11.9%, and C 12.4%. The chance of a codon is the product of the chances of its letters, so

$$P(\text{TAA}) = 0.382 \times 0.375 \times 0.375 \approx 0.054, \qquad P(\text{TAG}) = 0.382 \times 0.375 \times 0.119 \approx 0.017$$

Together, $p \approx 0.071$: in random DNA with syn3A’s letters, a stop turns up about every 14 codons. A and T are common, and so are TAA and TAG.

Now the chance that $n$ random codons in a row contain no stop. Each one misses with chance $1 - p$, and the chances multiply:

$$P(\text{no stop in } n \text{ codons}) = (1 - p)^n$$

For big $n$, use logs as in Lesson 1: $\log_{10}\big((1-p)^n\big) = n \times \log_{10}(1 - p)$. For a middle-sized syn3A gene of 283 codons, with $p = 0.071$:

$$283 \times \log_{10}(0.929) = 283 \times (-0.032) \approx -9.0$$

So the chance is about $10^{-9}$, one in a billion. A long open stretch almost never happens by chance, which is why it marks a gene. A stretch from a start codon to the next stop in the same frame is called an open reading frame, or ORF.

Find the gene puts this to work on real syn3A DNA. Each lane under the letters shows one reading frame, with stop codons as red bars. Find the long stretch with no stops that starts with ATG. Later levels shuffle a real gene, flip to the other strand, and switch to syn3A’s code.

Game · Find the gene

Which frame reads through?

Stars 0/15

Sound on

1. Three frames2. Start and stop3. Stops by chance4. The other strand5. syn3A’s code

syn3A’s code (4): stops TAA TAGMade-up DNA

 

+1+2+3

160

letterDNA5′+1+2+3

102030405060

AGATTTTCAATTGTTATCACTTTTAGGAAACACTAGTCTCTTAAAAGTCTTTAAGTATTA

3′

RArgFPheSSerIIleVValIIleTThrFPheRArgKLysHHisSTOPTAGSSerLLeuKLysSSerLLeuSTOPTAAVValLLeu

DAspFPheQGlnLLeuLLeuSSerLLeuLLeuGGlyNAsnTThrSSerLLeuLLeuKLysVValFPheKLysYTyr

IIleFPheNAsnCCysYTyrHHisFPheSTOPTAGEGluTThrLLeuVValSSerSTOPTAAKLysSSerLLeuSSerIIle

1. Three frames

A ribosome reads a gene three letters at a time. Each group of three is a codon, and each codon stands for one amino acid.

But where do you start? Start at letter 1, 2 or 3 and the same letters fall into different codons. These are the three reading frames, +1, +2 and +3 (offsets 0, 1 and 2 in Python).

Red bars are stop codons. Find the frame that reads all the way through without one. This sequence is made up.

Read the three frames

oily polar + charge − charge ATG (start) stop

Translation: RNA to protein

Translation turns an mRNA into a protein. It happens on the ribosome, a machine made of three RNAs and about fifty proteins, in two parts: a small subunit that holds the mRNA and a large subunit that joins the amino acids. syn3A has about 500 ribosomes.

The ribosome can’t read amino acids. Transfer RNAs (tRNAs) are the adapters. Each tRNA carries one kind of amino acid at one end, and at the other end has three letters, its anticodon, that pair with a codon. The ribosome only checks that pairing; the amino acid just rides along. syn3A manages with 29 kinds of tRNA for its 62 codons that mean amino acids, because some tRNAs pair loosely at the third letter.

The ribosome has three places for tRNAs side by side along the mRNA: the A site, where a new tRNA arrives, the P site, which holds the tRNA carrying the growing chain, and the E site, where the empty tRNA exits.

To start, the small subunit’s own RNA pairs with the Shine–Dalgarno sequence, AGGAGG or something like it, which puts the start codon a few letters later right in the P site. The first tRNA brings methionine. Whatever the start codon is (in syn3A, 437 genes start with ATG, 12 with GTG, and a few with TTG, ATA, or ATT), the first amino acid is always methionine, M. Then the large subunit joins.

Then the same cycle repeats for every codon:

1. A tRNA whose anticodon pairs with the codon in the A site arrives.
2. The chain on the P-site tRNA is joined onto the new amino acid by a peptide bond.
3. The ribosome moves 3 letters along. The tRNAs shift from A to P and from P to E, and the empty one leaves.

The chain threads out through a tunnel in the large subunit and starts to fold. When a stop codon reaches the A site, no tRNA fits. A release factor binds instead and cuts the protein free. syn3A has one, which reads UAA and UAG.

As soon as one ribosome moves away from the start, another can board, so one mRNA carries several ribosomes at once, about one every 300 letters. Bacteria have no nucleus, so ribosomes start reading an mRNA while the polymerase is still making it.

In Ribosome Rush, you are the ribosome. The codon waiting in the A site is shown in big letters. Tap the tRNA whose anticodon pairs with it, letter by letter, and pick the release factor at a stop codon. Level 4 tests what you know about syn3A’s code, and level 5 builds a real syn3A protein from start to stop.

3D game · Ribosome Rush

You are the ribosome

Streak 0Stars 0/15

Sound on

1. Read the codon2. Match the anticodon3. Against the clock4. The syn3A twist5. Build a real protein

1. Read the codon

You are the ribosome. You read the mRNA three letters at a time. Each group of three is a codon, and each codon calls for one amino acid.

tRNAs bring the amino acids. Find the codon in the little codon table, then tap the tRNA card with that amino acid.

The first codon, AUG, is the start codon: it takes a starter tRNA carrying methionine (M). At the stop codon, pick the release factor.

This mRNA is made up: 6 codons.

Start

Codon 1 of 60 mistakes

P site · start codon5′AUG3′3′???5′

AUUIle

AUCIle

AUAIle

AUGMet

1YTyr3′AUA5′2MMet3′UAC5′3DAsp3′CUA5′4RF1Release factorfor a stop codon

Show the codon table

This mRNA is made up. The game uses exact pairs; real tRNAs can also pair loosely (wobble) at the third letter, so syn3A gets by with 29 kinds of tRNA. Sizes are not to scale: a real ribosome is about 20 nm across, and the folded protein is a sketch.

How many, and how fast

Here are the main numbers for gene expression in syn3A. Most come from the whole-cell model built by Zaida Luthey-Schulten’s group, and some of them were measured in E. coli.

In one syn3A cell	Value
Genes	493: 455 for proteins, 38 for RNAs
RNA polymerases	about 187, with about 29 copying at any moment
Transcription speed	about 25 letters per second
mRNAs	a few hundred at a time: about one per gene
mRNA half-life	about 4 minutes
Ribosomes	about 500
Translation speed	about 5 amino acids per second (10–20 in E. coli)
Ribosomes on one mRNA	about one every 300 letters
Protein half-life	about 25 hours
Cell cycle	about 105 minutes

A middle-sized syn3A protein has 283 amino acids. Its gene, with the stop codon, is $(283 + 1) \times 3 = 852$ letters long. Copying it takes $852 \div 25 \approx 34$ seconds, and one ribosome reads it in $283 \div 5 \approx 57$ seconds.

Math toolkit: half-lives and steady state

An mRNA doesn’t last. Enzymes chop it up at random: every mRNA has the same small chance of being chopped in each second, however old it is. Then the number left falls by half every half-life, $t_{1/2}$. For syn3A’s mRNAs that is about 4 minutes. Start with 8 copies and stop making more:

• after 4 minutes, about 4 are left;
• after 8 minutes, about 2;
• after 12 minutes, about 1.

In general, after a time $t$ the fraction left is

$$\text{fraction left} = \left(\tfrac{1}{2}\right)^{t / t_{1/2}}$$

How long does one mRNA last, on average? Longer than one half-life, because a few copies survive for many half-lives and pull the average up. The average lifetime is

$$\tau = \frac{t_{1/2}}{\ln 2} \approx 1.44 \times t_{1/2}$$

where $\ln 2 \approx 0.693$ is the natural logarithm of 2, math.log(2) in Python. It comes from the same $e$ you met in Lesson 2: the fraction left is also $e^{-t/\tau}$. For a 4-minute half-life, $\tau = 4 \div 0.693 \approx 5.8$ minutes.

Now keep making new copies, at a steady rate $k$ per minute. At first the count climbs. But the more copies there are, the more get chopped each minute: about one in every $\tau$ minutes’ worth. The count stops changing when the copies made each minute equal the copies chopped:

$$k = \frac{N}{\tau} \quad\Longrightarrow\quad N = k \times \tau$$

This is a steady state: the copies keep changing, but their number doesn’t. It settles at the production rate times the average lifetime, wherever it started.

Now put the numbers together for one gene:

• A ribosome reads 5 amino acids, or 15 letters, per second, so it clears 300 letters in 20 seconds, and a new ribosome can board every 20 seconds. Each mRNA makes about 3 proteins a minute.
• Each mRNA lasts about 5.8 minutes, so it makes about $3 \times 5.8 \approx 17$ proteins in its life.
• A ribosomal protein needs about 500 new copies every cell cycle, one for each new ribosome. That takes about $500 \div 17 \approx 29$ mRNAs in 105 minutes: about 0.3 new mRNAs a minute.
• At steady state the cell then holds $0.3 \times 5.8 \approx 1.7$ copies of that mRNA at a time.

So even a busy gene keeps only one or two copies of its mRNA. With so few molecules, chance matters: some cells will have more and some fewer, which is what Lesson 7 is about.

Expression Factory simulates one gene in one syn3A cell, from birth to division, with real randomness. The pink strands are mRNAs, the purple balls riding them are ribosomes, and every gold dot is a finished protein. Use the sliders to set how often the gene is copied, how long each mRNA lasts, and how many proteins each one makes, then try the five challenges.

Simulation · Expression Factory

One gene, one cell, one cell cycle

Stars 0/15

Sound on

1. One at a time2. Half-life3. 500 by division4. Steady state5. Noise

Challenge: syn3A holds about one mRNA per gene at any moment. Set the transcription rate so this gene averages about 1 mRNA, keep it there for the last 30 minutes, and let the cell reach division.

1. One at a time

This is one gene in one syn3A cell, from birth to division: 105 minutes, sped up.

RNA polymerase copies the gene into mRNA at random moments. Ribosomes ride each mRNA and build proteins, until the mRNA is chopped up.

Right now this gene makes far too many mRNAs. Slow it down until it averages about 1.

Start

★★★ within 10% of 1 · ★★ within 25% · ★ within 50%

• Gene
• RNA polymerase
• mRNA
• Ribosome
• Protein
• Average of many cells ± spread

RunNew cellReplay seed 1231

These settings average 1.00 × 5.8 = 5.8 mRNAs. Goal: about 1.

Transcription rate

1.00 mRNAs a minute

−+

New mRNAs at random moments, on average one every 1.0 minutes.

mRNA half-life

4 minutes

−+

Each second, each mRNA has a 0.29% chance of being chopped up. syn3A: 4 minutes.

Proteins from each mRNA

3.0 a minute

−+

A ribosome boards every 20 s and takes 70 s to read the mRNA, so 3.5 ride it at once. syn3A: 3.

Simulation speed

3 min per second

−+

A 105-minute run takes 35 s.

The numbers for a typical syn3A protein of 349 amino acids (1,050 letters of mRNA)

Mean lifetime of one mRNA

half-life ÷ ln 2 = 4 ÷ 0.693 = 5.8 min

mRNAs at a time (steady state)

rate × lifetime = 1.00 × 5.8 = 5.8

Proteins from each mRNA

3.0 a minute × 5.8 min = 17.3

Proteins by division

1.00 × 105 = 105 mRNAs × 17.3 ≈ 1,818; the model expects 1,660 ± 234

Why less than the quick estimate? It counts every protein those mRNAs will ever make, but the last ones are still being read at division, and each protein takes 70 s to finish. The ± is the spread from chance alone (one standard deviation): about two cells in three land within it.

Numbers from syn3A’s model (Thornburg et al. 2019). Ribosomes and proteins are drawn roughly to scale; the mRNAs are drawn short (stretched out, 1,050 letters would be about 600 nm, longer than the 400 nm cell). A simplified model: real cells also change these rates as they grow.

Then put the steady-state formula into code.

Python exercise

How many copies of an mRNA?

import math from virtualcell.constants import SYN3A_MRNA_HALF_LIFE_MIN # 4 minutes def mrna_steady_state(per_minute, half_life_minutes): """Average copies of an mRNA in the cell: made at per_minute, broken down with a half-life.""" # Step 1: one copy lasts, on average, the half-life divided by ln 2. # ln is the natural logarithm: math.log(2) is about 0.693, so the # average lifetime is about 1.44 half-lives. # Step 2: once the count has settled (steady state), the copies in the cell # = new copies per minute × the minutes each copy lasts. # Return that number. raise NotImplementedError("Write your code here") # Remove the # below to try it. One new mRNA a minute, each lasting about # 5.77 minutes on average, should keep about 5.77 copies in the cell. # print(mrna_steady_state(1, SYN3A_MRNA_HALF_LIFE_MIN))

Ctrl+Enter runs your code. Tab indents; press Esc then Tab to leave the editor.

Run and checkHint (3 left)Show solutionReset

What a protein costs

Making a protein is expensive. Loading each amino acid onto its tRNA uses about 2 ATP, and the ribosome uses about 2 more for each step, so each amino acid costs about 4 ATP. A middle-sized protein of 283 amino acids costs about $283 \times 4 \approx 1{,}100$ ATP. Recall from Lesson 2 that each ATP is worth about 20 kT.

For the whole cell: 500 ribosomes at 5 amino acids per second, for 105 minutes, join about

$$500 \times 5 \times 105 \times 60 \approx 1.6 \times 10^{7} \text{ amino acids}$$

That is about 45,000 new proteins of average size every cell cycle, for about 60 million ATP. The syn3A model’s own estimate is similar: about 77 million ATP for all the work of copying and reading genes in one cycle, 59 million of it for translation.

Mutations: when the code changes

A mutation is a change in the DNA. The simplest kind swaps one letter for another, and what it does to the protein depends on where it lands:

• Silent: the new codon means the same amino acid, so the protein doesn’t change. This happens most often at the third letter. GCA, GCC, GCG, and GCT all mean alanine.
• Missense: one amino acid changes. Some swaps barely matter; others break the protein.
• Nonsense: the new codon is a stop, so the protein ends early.

In syn3A’s ptsH gene, the 88 codons between the start and the stop allow 792 one-letter changes (3 for each letter). 173 of them are silent, 591 are missense, and 28 are nonsense.

Adding or removing a letter is worse. The ribosome still reads in threes from the start, so every codon after the change is regrouped: a frameshift. The protein is wrong from that point on, and the new frame soon hits a stop codon by chance, in syn3A’s DNA after about 14 codons. In 1961, Francis Crick, Sydney Brenner, and colleagues used frameshifts in a virus gene to show that the code is read three letters at a time. One extra letter broke the gene, and three extra letters close together let it work again.

syn3A’s code adds a twist. A change from TGG to TGA is silent in syn3A, because both mean tryptophan. In E. coli the same change is a nonsense mutation.

In Mutation Lab, a real syn3A gene runs across the top in codons, with its protein underneath as a chain of beads. Tap a codon to zoom in, then change, insert, or delete a letter, and watch the protein rebuild itself. Each mission asks for one kind of mutation.

Game · Mutation Lab

1. Silent

Stars 0/18

Sound on

1. Silent2. Missense3. Nonsense4. Frameshift5. syn3A vs E. coli6. Fix it

Goal: Change one letter and keep the protein exactly the same.

Tip: try the third letter of a codon.Hint

ptsH · JCVISYN3A_0694 · real syn3A DNA, 270 letterssyn3A’s code

5′3′

1ATGGCAAAG10TTTTCAGCTA20TTATTACAGA30TAAAGTAGGT40TTACATGCCA50GACCAGCTTC60AGTATTAGCT70AAAGAAGCTT80CAAAATTTAG90TTCACACATT100ACTATTATGG110CTGGTGAAAA120GCAAGGTAAT130TTAAAATCAA140TTATGAATGT150AATGGCAATG160GCTATTAAAA170CTGGAACTGA180AGTAACTATT190CAAGCTGATG200GAACTGATGA210AGAACAAGCA220ATCAAAGCAA230TTAAACAAAC240CATGATTGAC250ACAGCTTTAA260TTCAAGGATA270A

MAKFSAIITDKVGLHARPASVLAKEASKFSSHITIMAGEKQGNLKSIMNVMAMAIKTGTEVTIQADGTDEEQAIKAIKQTMIDTALIQGSTOP

1510152025303540455055606570758085

Protein 89 of 89 amino acids

L oilyS polarK + chargedE − chargedA never made changed new frame

Mission 1: Silent

This is ptsH, a real syn3A gene (JCVISYN3A_0694). Its 270 letters make a protein of 89 amino acids that helps the cell take in sugar.

Change one letter so the protein stays exactly the same. That is a silent mutation. It works because the code has spare words: several codons can mean the same amino acid.

Tap a codon to zoom in, pick a letter, then choose what to change it to.

Start mission

Real geneThe real gene: 89 amino acids.

Change a letter and watch what happens to the protein.

Start the mission, then tap a codon to zoom in.

UndoReset gene0 edits tried

Check yourselfA gene's codon AAA (lysine) changes to AAG. What kind of mutation is it?

Silent: AAG also means lysine, so the protein doesn’t change.

Check yourselfA codon TTA (leucine) changes to TAA. What happens?

TAA is a stop codon, so this is a nonsense mutation: the protein ends at that point, and everything after it is never made.

Check yourselfWhy does deleting 3 letters do less damage than deleting 1?

Three letters are a whole codon. The protein loses one amino acid (or two, if the deletion spans two codons), but every codon after it is read in the right frame. Deleting 1 letter shifts the frame for the rest of the gene.

From genome to proteome in code

Now put the whole lesson into code. The proteome is the full set of a cell’s proteins. The plan: read the list of genes from syn3A’s GenBank record, cut each gene out of the genome, translate it with syn3A’s code, and check every protein against the one GenBank lists.

In Lesson 2 you read the sequence at the end of a GenBank file. The genes are listed above it, in the FEATURES table. Here is the entry for the gene on the other strand from earlier, from syn3A’s real record:

     gene            complement(9991..10968)
                     /gene="rnsD; uptD"
                     /locus_tag="JCVISYN3A_0008"
     CDS             complement(9991..10968)
                     /gene="rnsD; uptD"
                     /locus_tag="JCVISYN3A_0008"
                     /codon_start=1
                     /transl_table=4
                     /product="Nucleoside ABC transporter permease"
                     /protein_id="AVX54576.1"
                     /translation="MTILFNTSILTWALALVGVLLFASLSSLVSEKAGVVNIAVEGMM
                     IIGALVVSILGTYLTSNDNKSNYTQIPIVLLAGVITAVFALLHAFPAITLKANQIISG

Each feature starts on a line with its kind at position 5, such as gene or CDS (a coding sequence: the part that becomes protein), and its location after it. The lines below it, indented by 21 spaces, are its qualifiers: a /, a name, =, and a value in quotes. Long values carry on over several lines. /transl_table=4 is GenBank’s note that this gene uses code 4. The record also marks 3 broken genes, pseudogenes, with a bare /pseudo; they make no protein.

This exercise is a challenge: read the whole FEATURES table into a list of Python dicts. The starter walks you through it step by step.

Python exercise

Challenge: read the genes in a GenBank record

from virtualcell.genomes import read_data_text # reads the course's data files # The small GenBank record from Lesson 2: the first 1,500 bases of syn3A, with dnaA. record = read_data_text("syn3a_dnaA.gb") print(record[record.index("FEATURES") : record.index("ORIGIN")]) # its FEATURES table def parse_features(text): """The FEATURES table of a GenBank record, as a list of dicts (one per feature).""" # Each feature becomes a dict like this one (the dnaA gene in the printout): # {"kind": "gene", "start": 1, "end": 1353, "strand": 1, # "gene": "dnaA", "locus_tag": "JCVISYN3A_0001"} # start and end are numbers, counted from 1 as GenBank does. strand is -1 # when the location says complement(a..b), meaning the gene is on the other # strand (a is still the smaller number), and 1 otherwise. Every qualifier # becomes a key, with the quotes taken off its value. A qualifier with no # value, like /pseudo, becomes True: it marks a broken gene (a pseudogene) # that makes no protein, and you will need it to count the real ones. features = [] # the answer: one dict per feature, in file order feature = None # the feature being read right now key = None # the qualifier being read right now inside = False # True once we are past the line that starts with "FEATURES" for line in text.splitlines(): # Step 1: skip the lines before "FEATURES" (set inside = True when you # reach it), and stop the loop (break) at the line "ORIGIN". # Step 2: a line with a letter at position 5 (line[5] != " ") starts a feature: # " CDS complement(9991..10968)" # kind, location = line.split() gives "CDS" and "complement(9991..10968)". # Work out the strand, take off "complement(" and ")", and # location.split("..") gives the start and end as text. Make the dict # with int() numbers, append it to features, and keep it in feature. # Step 3: any other line belongs to the current feature. Strip off its spaces. # If it starts with "/", it is a new qualifier: line[1:].split("=", 1) # turns '/gene="dnaA"' into "gene" and '"dnaA"'. With no "=", like # /pseudo, the value is True. Then store feature[key] = value. # Step 4: a line that doesn't start with "/" carries on the value before it. # Add it to feature[key] with a space in between, but with no space # when key is "translation" (amino acids, not words). raise NotImplementedError("Write your code here") # Step 5: take the quotes off every text value: value.strip('"') # (True and the numbers aren't text: isinstance(value, str) tells you.) return features # Remove the #s below to try it. You should see 3 features: source, gene and CDS. # features = parse_features(record) # print(len(features), "features:", [f["kind"] for f in features]) # print(features[2]) # dnaA's CDS # Then syn3A's whole record (1.2 MB, so the first download takes a moment): # from virtualcell.genomes import load_syn3a_genbank # everything = parse_features(load_syn3a_genbank()) # print(len(everything), "features")

Ctrl+Enter runs your code. Tab indents; press Esc then Tab to leave the editor.

Run and checkHint (3 left)Show solutionReset

Now the pipeline. For each protein-coding gene, cut it out with genome[start - 1:end], take the reverse complement if it is on the other strand, translate it, and make the first amino acid M. The starter includes working versions of the functions you wrote earlier, so this exercise doesn’t depend on them. The last check runs all 455 genes.

Python exercise

Every gene to its protein

from virtualcell.genetic_code import STANDARD_CODE, STOP, SYN3A_CODE from virtualcell.genomes import load_syn3a_genbank, load_syn3a_genome def gene_to_protein(genome, feature, code=SYN3A_CODE): """The protein a gene makes. feature is a CDS dict from parse_features.""" # feature looks like {"kind": "CDS", "start": 331411, "end": 332568, "strand": -1, ...} # Step 1: cut the gene out of the genome. GenBank counts from 1 and includes # the end, so its bases start..end are genome[start - 1:end] in Python. # Step 2: if the strand is -1, the gene is on the other strand: use # reverse_complement on the piece, so it reads from its start codon. # Step 3: translate it with the code you were given: translate(dna, code). # Step 4: the first codon always brings methionine, even when it is GTG, TTG, # ATA or ATT, which mean other amino acids inside a gene. Make the # first letter "M". raise NotImplementedError("Write your code here") # --------------------------------------------------------------------------- # Helpers you can use. They are the same as your answers to the earlier # exercises (reverse_complement is from Lesson 2), so this one works on its own. # --------------------------------------------------------------------------- PAIR = {"A": "T", "T": "A", "G": "C", "C": "G"} # each base and its partner def reverse_complement(sequence): """The other strand of a DNA sequence, read in its own direction.""" complement = "".join(PAIR[base] for base in sequence.upper()) return complement[::-1] def translate(sequence, code=SYN3A_CODE): """The protein a sequence codes for, read codon by codon from its first letter.""" rna = sequence.upper().replace("T", "U") protein = [] for i in range(0, len(rna) - 2, 3): # every complete codon amino_acid = code[rna[i : i + 3]] if amino_acid == STOP: break protein.append(amino_acid) return "".join(protein) def parse_features(text): """The FEATURES table of a GenBank record, as a list of dicts (one per feature).""" features = [] feature = None # the feature being read key = None # the qualifier being read inside = False # True once we are past the FEATURES line for line in text.splitlines(): if line.startswith("FEATURES"): inside = True elif line.startswith("ORIGIN"): break elif not inside: continue elif line[5] != " ": kind, location = line.split() strand = 1 if location.startswith("complement("): strand = -1 location = location[len("complement(") : -1] start, end = location.split("..") feature = {"kind": kind, "start": int(start), "end": int(end), "strand": strand} features.append(feature) else: line = line.strip() if line.startswith("/"): if "=" in line: key, value = line[1:].split("=", 1) else: key, value = line[1:], True feature[key] = value elif key == "translation": feature[key] += line else: feature[key] += " " + line for feature in features: for key, value in feature.items(): if isinstance(value, str): feature[key] = value.strip('"') return features # Remove the #s below to try it on dnaA, syn3A's first gene. The two lines # printed at the end should be the same. # genome = load_syn3a_genome() # genes = parse_features(load_syn3a_genbank()) # proteins = [f for f in genes if f["kind"] == "CDS" and not f.get("pseudo")] # the 455 real ones # dnaA = proteins[0] # print(gene_to_protein(genome, dnaA)[:40]) # print(dnaA["translation"][:40]) # GenBank's protein, for comparison # Then all 455 at once: # matches = sum(gene_to_protein(genome, f) == f["translation"] for f in proteins) # print(matches, "of", len(proteins), "proteins match GenBank")

Ctrl+Enter runs your code. Tab indents; press Esc then Tab to leave the editor.

Run and checkHint (3 left)Show solutionReset

One more, if you want it: find the genes yourself, with no GenBank at all, by searching for long open reading frames. The checks compare your list with GenBank’s genes, and the success message explains the ones you miss.

Python exercise

Optional challenge: find the genes yourself

from virtualcell.genetic_code import STANDARD_CODE, STOP, SYN3A_CODE from virtualcell.genomes import load_syn3a_genome def find_orfs(dna, min_codons=100, code=SYN3A_CODE): """Open reading frames on this strand, as sorted 1-based (start, end) pairs.""" # An open reading frame (ORF) runs from an ATG to the next stop codon in the # same frame, stop included. Do this for each frame (0, 1 and 2): # Step 1: walk along the codons, i = frame, frame + 3, frame + 6, ... # Keep a variable start: None while you are not inside an ORF. # Step 2: outside an ORF, an "ATG" at index i starts one: start = i. # (Inside an ORF, more ATGs don't start new ones: ORFs don't nest.) # Step 3: inside an ORF, a stop codon ends it. The code's keys are RNA # codons, so check code[codon.replace("T", "U")] == STOP. # The ORF has (i + 3 - start) // 3 codons, counting the stop. If that # is at least min_codons, keep (start + 1, i + 3): GenBank's 1-based # positions of its first and last letters. Then set start back to None. # An ORF still open when the sequence ends has no stop: leave it out. # Return the ORFs from all three frames in one list, sorted. raise NotImplementedError("Write your code here") # Remove the # below to try it on a made-up sequence. You should see [(3, 11), (12, 20)]. # print(find_orfs("CCATGAAATAGATGCCCTAA", min_codons=3)) # Then the first 12,000 bases of syn3A's genome. GenBank has 7 genes on this # strand there, starting at 1, 1511, 2675, 3207, 4064, 5515 and 7435. # genome = load_syn3a_genome() # print(find_orfs(genome[:12000]))

Ctrl+Enter runs your code. Tab indents; press Esc then Tab to leave the editor.

Run and checkHint (3 left)Show solutionReset

Code milestone: the gene-to-protein pipeline

Two new modules join the engine in this lesson:

• virtualcell/expression.py holds transcribe, codons, translate, mrna_steady_state, and find_orfs.
• virtualcell/annotation.py holds parse_features and gene_to_protein.

Two pieces are written for you. virtualcell/genetic_code.py has the standard code and syn3A’s code 4. genomes.py can now load syn3A’s full GenBank record, and constants.py has this lesson’s numbers: polymerases, ribosomes, speeds, and half-lives.

Copy each function you wrote into its module, replacing the stub, then run the checks from the engine folder:

python -m pytest

When they pass, the engine can rebuild syn3A’s proteome:

from virtualcell.genomes import load_syn3a_genome, load_syn3a_genbank
from virtualcell.annotation import parse_features, gene_to_protein

genome = load_syn3a_genome()
genes = [f for f in parse_features(load_syn3a_genbank())
         if f["kind"] == "CDS" and "pseudo" not in f]

proteins = {g["locus_tag"]: gene_to_protein(genome, g) for g in genes}
print(len(proteins))                        # 455
print(proteins["JCVISYN3A_0648"])           # MKVRSSVKQICDKCRVIRRKGRVMIICVTPKHKQRQG
print(sum(proteins[g["locus_tag"]] == g["translation"] for g in genes))  # 455

Numbers to remember

Quantity	Value
A gene in GenBank	start..end, counted from 1, both ends included
Its length	end − start + 1
The same gene in Python	genome[start - 1:end], reverse-complemented if on the other strand
Promoter boxes (E. coli)	−35 TTGACA and −10 TATAAT, about 17 base pairs apart
Codons	3 letters; 64 codons for 20 amino acids and stop
syn3A’s code (code 4)	UGA means tryptophan; stops are UAA and UAG
Stops in random DNA	1 in 21 codons (equal letters, standard code); about 1 in 14 in syn3A’s DNA
Transcription	about 25 letters per second
Translation	about 5 amino acids per second in syn3A’s model; 10–20 in E. coli
syn3A	493 genes; about 187 RNA polymerases; about 500 ribosomes
mRNA half-life	about 4 minutes; average lifetime = half-life ÷ ln 2, about 5.8 minutes
Steady state	number of copies = production rate × average lifetime
Cost of a protein	about 4 ATP per amino acid

Next lesson: molecules in motion. You will see how molecules wander through a crowded cell by random walks, how fast reactions happen, and build your first simulator.

Sources and further reading

• Thornburg ZR, et al. Kinetic modeling of the genetic information processes in a minimal cell. Frontiers in Molecular Biosciences 6:130 (2019). Polymerase and ribosome counts, speeds, half-lives, and ATP costs.
• Thornburg ZR, et al. Fundamental behaviors emerge from simulations of a living minimal cell. Cell 185:345–360 (2022).
• Breuer M, et al. Essential metabolism for a minimal cell. eLife 8:e36842 (2019).
• Bianchi DM, et al. Toward the complete functional characterization of a minimal bacterial proteome. Journal of Physical Chemistry B 126:6820–6834 (2022).
• syn3A’s genome and genes: NCBI GenBank record CP016816.2.
• The genetic codes: NCBI, The Genetic Codes, tables 1 and 4.
• Crick FHC. On protein synthesis. Symposia of the Society for Experimental Biology 12:138–163 (1958).
• Crick FHC, Barnett L, Brenner S, Watts-Tobin RJ. General nature of the genetic code for proteins. Nature 192:1227–1232 (1961).
• Milo R, Phillips R. Cell Biology by the Numbers. Garland Science, 2015. Free online at book.bionumbers.org.
• Alberts B, et al. Molecular Biology of the Cell, 6th edition. Garland Science, 2014.