Download DOC - Scholarly Exchange

nonpolar polar basic acidic (stop codon)
2nd base
U
U
C
1st base
A
A
G
UUU
(Phe/F) Phenylalanine UCU (Ser/S) Serine
UAU (Tyr/Y) Tyrosine
UGU (Cys/C) Cysteine
UUC
(Phe/F) Phenylalanine UCC (Ser/S) Serine
UAC (Tyr/Y) Tyrosine
UGC (Cys/C) Cysteine
UUA
(Leu/L) Leucine
UCA (Ser/S) Serine
UAA Stop (Ochre)
UGA Stop (Opal)
UUG
(Leu/L) Leucine
UCG (Ser/S) Serine
UAG Stop (Amber)
UGG (Trp/W) Tryptophan
CUU
(Leu/L) Leucine
CCU (Pro/P) Proline
CAU (His/H) Histidine
CGU (Arg/R) Arginine
CUC
(Leu/L) Leucine
CCC (Pro/P) Proline
CAC (His/H) Histidine
CGC (Arg/R) Arginine
CUA
(Leu/L) Leucine
CCA (Pro/P) Proline
CAA (Gln/Q) Glutamine
CGA (Arg/R) Arginine
CUG
(Leu/L) Leucine
CCG (Pro/P) Proline
CAG (Gln/Q) Glutamine
CGG (Arg/R) Arginine
AUU
(Ile/I) Isoleucine
ACU (Thr/T) Threonine
AAU (Asn/N) Asparagine
AGU (Ser/S) Serine
AUC
(Ile/I) Isoleucine
ACC (Thr/T) Threonine
AAC (Asn/N) Asparagine
AGC (Ser/S) Serine
(Ile/I) Isoleucine
ACA (Thr/T) Threonine
AAA (Lys/K) Lysine
AGA (Arg/R) Arginine
(Met/M) Methionine
ACG (Thr/T) Threonine
AAG (Lys/K) Lysine
AGG (Arg/R) Arginine
GUU
(Val/V) Valine
GCU (Ala/A) Alanine
GAU (Asp/D) Aspartic acid GGU (Gly/G) Glycine
GUC
(Val/V) Valine
GCC (Ala/A) Alanine
GAC (Asp/D) Aspartic acid GGC (Gly/G) Glycine
GUA
(Val/V) Valine
GCA (Ala/A) Alanine
GAA (Glu/E) Glutamic acid GGA (Gly/G) Glycine
GUG
(Val/V) Valine
GCG (Ala/A) Alanine
GAG (Glu/E) Glutamic acid GGG (Gly/G) Glycine
AUA
AUG
G
C
[A]
[A] The codon AUG both codes for methionine and serves as an initiation site: the first AUG in an mRNA's
coding region is where translation into protein begins.
[Show title “A 3D representation of the genetic code” and the
skinned version of the code, hold for 3 seconds, then remove the
title and allow the skinned version to slowly rotate.]
The genetic code can mean different things to different people. Some people take it to mean all of an
organism’s DNA instructions. Other people would argue that the term “genome” is a better way to describe
the set of DNA instructions. Most scientists would say that the genetic code is the code that takes DNA
information and converts it to protein information. So, we will use the term “genetic code” to describe this
systematic conversion of information. In other words, we’ll use it to describe the code that takes
information in the DNA and RNA language of four letters and translates that information into related
information that is spelled out in the 20 letters of the protein language.
Ok, so now that we’re clear on what we mean when we say “genetic code”, what are some ways to visualize
and understand this code? The traditional visualization of the code is a table like this one,
[switch to the “GeneticCodeTable.png” image]
which you can find on Wikipedia. As you can see, this table helps a person see how the RNA letters U, C,
A and G,
[if possible, bring in the four png images and put them in a row
under the CodonTable. If this is to time-intensive for the $100
version, please don’t do this].
which can be arranged into 64 different 3-letter words called codons, are matched up with the 20 letters of
the protein language.
Unfortunately, there are many features of the genetic code that this table does not adequately show us. For
example, this table doesn’t give us a good idea of how one codon can mutate to another codon, which is the
cause of some diseases such as Sickle Cell Anemia.
[switch back to the rotating skinned version of the code]
In our animation, we show a 3-dimensional visualization of the genetic code. To create this visualization,
we start with four rods that stick out of a central ball.
[remove skinned version and replace with the purple ball and
four rods, slowly oscillating 30 degrees left and right over and
over]
These rods represent the four letters of RNA, which are nearly identical to the four letters of DNA. In our
visualization, the blue rod pointing up represents the letter A. As you may have learned, A forms a pair
with the letter T in DNA, but in RNA it forms a pair with the letter U, which is nearly identical in shape and
chemical formula as T. In our visualization, the letter U is represented by the red rod, which points to the
rear of our 3D model.
The other two rods represent G and C, with G in black going to the left and C in white going to the right.
Now, this first group of four rods represents the first letter in the three letter words called codons. As we
build our visualization, we must add two more sets of rods, so that we can show all three codon letters in our
3D model. Ok. So, let’s add the second set. There we go…
[add the second set of rods and the silver balls]
As you may have noticed, this second set of rods is much longer than the first set. That’s because the
second letter of each codon word gives us the most information about what kind of protein letter it will
ultimately specify. In the English language, we know that some parts of a word are more useful to our
brains when it comes to word recognition. Usually the first and last letters of an English word are most
useful. But in codon words it’s the opposite. The first and (especially) the last letter of each three-letter
word are the least informative. So, in our 3D model, we’ve made these letters smaller than the middle letter,
as can be seen when we add the final set of rods (here they are)
[add the third set of rods and the green balls, with the whole
skeleton still oscillating slowly back and forth]
which represent the last letter of the three-letter word and are therefore the shortest set of rods.
If you took the time to count these short rods, you’d find that there are 64 of them. That’s because each of
the first four rods had four long rods sprouting from their tips, for a total of 16 long rods, since 4 times 4 is
16. Likewise, each of the 16 long rods have four tiny rods sprouting from their tips for a total of 64 tiny
rods, since 16 times 4 is 64.
The 64 short rods tell us that there are 64 ways to put the 4 letters into 3-letter words. Now, since we are
trying to go from the RNA or DNA language of 4 letters to the protein language of 20 letters, we had no
choice but to use three letter RNA or DNA words. 2-letter words would have been too short because they
would have only given us 16 possibilities. But now that we have 64 possibilities, we have more than we
need. Does this mean that we should use up 20 of those 64 words and leave the other 44 as “nonsense”
words that have no meaning? Well that’s what Francis Crick, the co-discoverer of DNA’s structure thought
that that’s what we should do. But thankfully, Nature is a lot smarter than Francis Crick!
Instead of those 44 words being mere nonsense, they are used as backup codes for the protein letters. Just
like the word cap and the word hat, in the right context, mean the same thing, so also the RNA word, for
example, AAA means the same as the RNA word AAG. Both words mean the letter “K” in the protein
alphabet, which happens to stand for the amino acid lysine.
The beauty of this system of backup codes can be seen as we look at how codons can mutate to other
codons.
[Do the three mutation animations as needed by the script]
In the following animation, we see how the codon AAA can mutate to GAA, or to AGA, or to AAG.
Obviously, these three mutations are not the only mutations that can happen to AAA. It could have mutated
by replacing one of its A’s with a C or U so that, if you count them all together, there are 9 ways that AAA
can change by what is called a single point mutation, which is the kind of mutation that leads to Sickle Cell
Anemia, for example.
But with the A to G changes that we are about to show you, it will give you the general idea of how one
codon can change to another codon by a point mutation.
So, let’s look at the first mutation example: the AAA going to the GAA.
In our 3D model, we see that the rod that sticks out of the central purple ball is the one that rotates into a
new position. The result is that the tiny rod that used to be at the very top of our model has now moved
down and to the left. This tiny rod no longer is the end of the word AAA, it is now the end of the word
GAA.
In the second mutation example, we see the drastic bending of the second rod, which takes the AAA codon
to the AGA codon. Again, your eyes should follow the tiny rod that starts at the top of the model and see
that it moves even further down and to the left compared to the first mutation.
In the third mutation example, we see a relatively small change. The tiny rod simply bends down to a new
position such that AAA becomes AAG.
This third mutation example shows us the power of the backup code system. As I mentioned earlier, AAA
and AAG code for the same thing in the protein alphabet. So, if there is an A to G mutation in the third
letter of the AAA codon, it doesn’t affect the meaning of the message. In other words, the genetic code is
extremely robust with respect to mutation errors. And thank goodness! Otherwise many more of us would
be affected by debilitating genetic diseases.