I voted to try to bring about political change, and I use site-directed mutagenesis to bring about protein change! With site-directed mutagenesis, I can make specific changes in proteins by changing their DNA instructions. This lets me see what different parts of proteins do – and (as I try to distract myself from anxious waiting) I want to tell all of you!
Let me start by telling you what site-directed mutagenesis is *not.* It is *not* CRISPR/Cas, CRISPR/Cas is a gene editing technique you might have heard of (I mean Jennifer Doudna and Emmanuelle Charpentier did win the Nobel Prize recently for developing it!). That technique uses protein and RNA machinery from a bacterial immune system to direct the Cas protein to cut DNA at specific locations – in cells. Then, 1) if you didn’t provide a “replacement,” the cells can try to fix the damage and often end up “knocking out” the gene that got cut. Or 2) if you provided a replacement piece with ends that match the cut sites, they can put in that inserted piece through homologous recombination. This is all happening *in cells* and has been plagued by precision errors (cutting extra places, etc,) but it’s great for some things. http://bit.ly/crisprdoudna
But what if you don’t need to edit the DNA in its normal home? It’s a lot easier to edit DNA when it’s in a small circular piece of DNA called a plasmid inside a test tube than when it’s in a huge coiled-up chromosome inside a cell. So, if we want to study a protein, we can stick the genetic instructions for the protein into a circular piece of DNA called a plasmid vector. This is called molecular cloning and I discussed it in depth here: http://bit.ly/molecularcloningguide
We can then stick that into cells (often bacteria) to get them to make more of the plasmid containing our inserted genetic instructions, and we can stick the plasmid into expression cells to make the corresponding protein. We call this RECOMBINANT protein production.
Once the DNA is in the plasmid, we can use site-directed mutagenesis techniques like SLIC mutagenesis and QuikChange mutagenesis to introduce specific DNA letter changes into the genetic instructions for the protein. And this can lead to specific protein changes.
If you’re wondering why we might want to do this, think of a spoon versus a knife. Structure (bowliness vs. long flat jaggedness) and function (scooping vs slicing) are intimately connected.
The same holds true for biochemical “utensils” like proteins, and we can exploit this relationship to learn about function from structure and structure from function by making specific changes to specific parts using site-directed mutagenesis, then testing to see if those changes affected the protein’s activity.
A protein’s structure comes ultimately from its genetic instructions: the sequence of DNA letters that get copied into RNA letters determines the sequence of proteins letters (amino acids) in a protein. And because those different amino acids have different properties (size, charge, water-likingness), they affect how the protein folds (structure) & how it acts (function). So if we change the gene, we can change the protein and potentially its functioning.
Potentially because it all depends on where you mutate and how drastic the change is. If, for example, you pierced a small hole in the cup of a spoon and the blade of a knife you probably wouldn’t be able to tell anything had changed if you tested out the knife. But if you tried slurping some soup with that spoon you’d probably dribble down your front….
With site-directed mutagenesis you can do things like make
- substitutions (change some DNA lteters)
- these can be drastic (such as changing a negatively-charged aspartate to a positively-charged arginine) or “conservative” (such as shifting around the atoms of leucine to get isoleucine which acts pretty darn similarly)
- insertions (add some DNA lettttters)
- deletions (remove some DNA ltrs)
- when we shorten the ends we typically refer to these changes as “truncations.” If you cut off part of the “starting end” of the protein we call it an N-terminal truncation and if you cut off part of the “ending end” we call it a C-terminal truncation
We refer to the original, “non-mutated” form as “wild-type” and the changed versions as “mutants”
Some notations we use to describe what we’ve done to it:
- For substitutions, we put the original letter first & what it’s changed to afterwards. So, say you changed the 91st amino acid from a glycine (G) to an alanine (A). You could write this as G91A. And if you changed the 215th amino acid from A to G you’d write A215G
- to indicate taking out stretches of amino acids, we use the delta sign, Δ. So if we removed amino acids 80-100, we would write Δ80-100.
Sometimes, when doing mutagenesis, we know exactly where we want to make changes and why. This knowledge sometimes comes from knowing the structures of the proteins (such as from x-ray crystallography or cryo-EM). So, it’s like knowing where to put the hole in the spoon to cause dribbling. But other times we’re less sure. So we can do things like “alanine scan” where we change each protein letter one at a time to alanine (a pretty generic amino acid) or large deletions followed up by more targeted changes once you narrow down the region that’s important for the thing you’re testing.
note on “the thing you’re testing” – a mutation will only show an effect if you’re looking for it. If you never use that hole-y spoon, or you only its edge for scraping something, you won’t know that you’ve changed its scoopfulness. Similarly, mutations might affect a protein activity that’s different from the one you’re testing for. So don’t disregard any amino acid as useless!
I can introduce any of these types of specific mutations to the genetic instructions I put into cells to make protein for me. Unlike with CRISPR/Cas, which relies on in-cell machinery, with site-directed mutagenesis we use PCR (Polymerase Chain Reaction) to make versions of the DNA we want before we even stick it into bacteria.
PCR uses the original gene as a template for making the copies & you provide short strings of DNA called primers that match where you want DNA Pol to start and stop copying. The primers “bookend” the copied parts so If you put mutations in the primers, the copies will include them. And since you design the primers, you can custom design mutations.
You might be wondering – does that mean you can only mutate the starts of genes? No! I use this technique called SLIC where you basically just have to make 2 “parts” with other lapping ends. And once the gene’s in the plasmid you just have a circle you can divide however you want – so you can have 1 “half” start smack dab in the middle of your gene if you want to put a mutation there (this probably makes more sense in the pics). And the “halves” don’t have to be halves. They can be different lengths. And you can piece together multiple pieces.
technical note: if your pieces are drastically different size-wise, you should account for that when you mix them since longer pieces you’ll need more mass-wise to get the same mol-wise (each strand is heavier since it’s longer so the same # of strands will weigh more. thus, it’ll take more nanograms (ng) of the longer one to get the same number of moles as the shorter one (a mole is just 6.02 x 10²³ of something))). http://bit.ly/solutionconcentrations
I like SLIC, but another common way is QuikChange which I’ll talk about further down in the post.
So – SITE & LIGATION INDEPENDENT CLONING (SLIC). If you read yesterday’s post, you might recognize this term. It’s the same technique we used when doing the molecular cloning (moving a piece of DNA from one home to another), but when we use it for mutagenesis we introduce changes to the pieces.
The basic gist of SLIC is that we use polymerase chain reaction (PCR) to make lots of copies of (amplify) “gene pieces” & stick them into bacteria to piece them together. In PCR you amplify specific stretches of DNA from longer pieces of DNA by designing short pieces of DNA (PRIMERS) that specify the “start & stop” sites of that region -> tell DNA Polymerase (DNA Pol) where to start laying down nucleotide “tracks” so we can make our pieces. more here: http://bit.ly/2FiBXsl
If you put some extra DNA letters at the start of those primers, those letters will get stuck onto the thing you’re copying (kinda like adding a generic letterhead & footer)- and if those letters you add complement letters on a different piece of DNA they can stick together. the letters of DNA like to bind their complementary letters, regardless of where they come from – it can be the second strand of the “same piece” or the opposite strand of the “other piece”
We design the gene piece to have bits of the different piece at the ends, so that when DNA Pol starts copying PIECE1, it adds on a bit of PIECE2 at the beginning (kinda like adding a few words from the page you want to come before it)- specifically it adds the part of the plasmid that’s flanking where your gene will go
the PCR reaction gives us double-stranded DNA so the complementarity is “hidden” by the second strand. You have to chew back one of the strands a bit (with an exonuclease) to generate single-stranded “sticky ends” – only the end is chewed & this is the part that matches the vector, so it exposes vector-matching single-stranded DNA that can stick to the vector DNA. The exonuclease chewing is much less precise than endonuclease cleavage (such as the cleavage you get with restriction enzymes), so you’ll get overhangs of different lengths. When you combine them & they stick together, they’ll leave gaps – but this is okay because the bacteria can fill them in
But in order for the bacteria to fill it in properly, they need the right template sequence – the original gene doesn’t “know” the sequence of the other piece – so if you cut off some of the sequence you loose those instructions & the bacteria don’t know how to fill it in -> BUT if you add enough of the other piece’s sequence to the ends, that’s what gets chewed back – that part will match the other part so you’ll get sticking, & the other piece will be there to provide complete info.
Therefore, you design primers so that the ends match & when you chew them back they’re long enough that you don’t loose the “unique” information (you want your primers to have ~20bp overlap between the end of thing 1 & the beginning of thing 2). For example, if the change you want to make is a small mutation, you want to make sure to have ~20 bp on the other sides so the mutation doesn’t get chewed out.
The chewer we choose is T4 polymerase – polymerase? isn’t that what adds the nucleotides? yes – but proofreading polymerases can also remove them – the 3’-5’ exonuclease activity is important for proofreading because it allows the polymerase to “backtrack.” But since you took away the nucleotide train track pieces, the polymerase can’t build track to go forward, so it gets “bored” and starts going the direction it can go – “backwards,” chewing off the ends as it does so and creating single-stranded (ssDNA) overhangs at the 5’ end. You don’t want it to erase all of your (ok, the thermal cycler’s) hard work – you just want it to chew off enough to give you sticky ends, so you only give it ~30 min to do this. Then you stop it by adding a dNTP (DNA letter), but just 1 of the letters – it can add this letter, so it switches to its track-laying (polymerization) mode, but then gets stuck and stalls when it needs to add a different letter⠀
After you give it time to work, you stick into into bacteria. We call this transformation and a common way we do this is “heat shock” where we mix the DNA we want to put in with chemically-weakened bacteria in a tube on ice and then briefly dunk it in a warm water bath then stick it back on ice. The heat shock opens up pores in the bacteria so the DNA can rush in. more here: http://bit.ly/2Jj7L47⠀
After you let it recover a bit you plate it on an agar plate in your classic Petri dish. Agar is related to but different from agarose and it makes a nice solid gel matrix to hold bacteria food. We only want it to be a nice “B&B” for bacteria that have our plasmid (not all the cells will have taken it in and other bacteria could have snuck in at various times) so we need a way to prevent them from staying here. Usually we do this using antibiotic selection. We use a plasmid that has an antibiotic resistance gene and then we spike the food with that antibiotic so that only bacteria with the plasmid can survive). more here: http://bit.ly/2tcW4ky⠀
Another common site-directed mutagenesis method is “Quikchange” – I used this in undergrad. “Quikchange” is the trademark name but you can do it without a kit. Unlike SLIC, which amplifies pieceS – plural – Quikchange makes a single piece. And in QuikChange the product of one reaction is NEVER used as a template for the next, so you don’t get exponential amplification – no pyramid-scheme-like growth. Instead of PCR, it’s “primer extension”
Why? You can’t amplify the first product because it’s nicked. it’s kinda like you have
you want to make
but there’s nothing “to the right” of X in the first reaction to read until you stitch them together. (and the copier, DNA Pol, can only copy in one direction). So you have to put in a lot of the template.
Another disadvantage with QuikChange is that the polymerase has to get all the way around the plasmid – that can be a long way to go without making mistakes so you want a polymerase that is highly processive (can add lots of bases without falling off) and high-fidelity (isn’t prone to making tpyos – you only want the mutations you’re meaning to put in!)
With QuikChange your primers are at the “Same spot” but different strands – so you have 1 primer making a mutated copy of each strand. For substitutions, you center the mutation in the middle of the primers so that there’s enough on either side that it’ll still bind as if it really did match.
Once you have the changed DNA, the process is basically the same, no matter what the mutagenesis method. (transform, recover, plate, select).
Also, in both methods, at some point in the protocol you add an enzyme called DpnI. This chops up the parent plasmid. But not the new one. This is because the parent will be methylated (have -CH3 groups added to it) but the new one won’t be because methylation only happens when the copying is done in bacteria and your PCR products haven’t had that pleasure yet. More here: http://bit.ly/2tZ17FJ
It’s really important to remove the parent cuz it’ll be circular already and have a major transformation (getting into cells) advantage (it’s a lot easier for circular DNA to get into (and survive getting into) cells than linear and/or gapped DNA.
To make things worse, since the parent plasmid has the antibiotic resistance gene you’re using for selection, even if it doesn’t have your gene, it’s important to make sure that there’s none of the original. So you can run a couple of controls. ⠀
In the negative DpnI control you just transform the DpnI-treated individual PCR products alone – if you get colonies on this plate it indicates that not all of the parent plasmid got degraded.
You can also include a positive transformation control you transform non-DpnI-treated parent plasmid. You should get lots of colonies and if you don’t it indicates your transformation method didn’t work or your competent cells are no longer competent (these cells are able to take in DNA easily because they’ve been chemically weakened so their membranes are fragile and stuff, so you have to treat them with extreme TLC – keep them on ice, don’t hold the bottom of the tube, don’t pipette them vigorously, just swirl, etc.)
You’ll probably have a few colonies on the negative control plate but you should have way more on the “real plate” (the one with vector + insert + ligase). You then take a few of those colonies and grow them in some liquid broth, isolate their plasmid DNA and check to make sure it actually has your insert – you can do a quick check with with colony PCR or analytical digest then verify with sequencing. more here: http://bit.ly/2TGAvo5⠀
Quick note: When you order primers they usually come without the 5’ phosphate(s) that DNA normally has. And since the primers form the new ends of your new products, your new products will have unphosphorylated ends. This isn’t a problem with these methods that rely on bacteria to stitch them back together – the bacteria has the equipment needed to patch it up. but it IS a problem if you’re using a method which relies on DNA ligase stitching the break together in a test tube BEFORE you stick it in the bacteria. So when you add the ligase you also have to add a kinase to add on those phosphates. more on this in yesterday’s post
Some final thoughts from someone who mutates lots!…
When I say lots I mean it… I keep a spreadsheet with all of the different “constructs” I’ve made (and a few I’ve inherited from former lab members). A “construct” is basically just a plasmid containing some version of a sequence. So I can have a “wild-type” (unmutated) construct of protein X and then a G215A construct of protein X, which I might write as X(G215A). And then I might have X(Δ315-350) (a deletion construct), etc. And then I might have a bunch of constructs of protein Y, and Z, and…. End result – going into my 5th year of grad school my spreadsheet has over 150 constructs…
It can get unwieldy to write out things like X(G215A;C298Q;F300G;T474A) over and over again, especially on a tiny test tube! So, to make things easier to keep track of, I give each construct an inventory number like “15786” and “15787” (the actual numbers correspond to their spot in a lab database). These numbers are super helpful until you forget that other people can’t know what you’re talking about without you telling them what construct they correspond to…
Going back to the concept of only finding effects for the thing you’re testing for…. Any change you make may have unintended consequences where you change an amino acid & you think you’re only changing one function but you change another as well. For example, maybe you make a letter change to a restriction enzyme’s active site that you think “dulls its blade” so it can’t cut DNA. You test whether it will cut DNA and it won’t. So you might think you did what you’d thought you’d do. But, what if the mutation affected the DNA binding instead of, or in addition to, the cutting? So you need to make sure to test for other things that you might have changed – in this case, you’ll want to test binding as well.
Also, for any change you make, you need to make sure it doesn’t affect the protein’s overall integrity. Some mutations aren’t compatible with protein life… Especially if you make large deletions, insertions, etc, a mutant might not express and/or fold properly. You can do things like run a western blot to see if it is expressing and run a sample of the protein on size-exclusion chromatography (SEC, aka gel filtration) to see if it’s folded properly – it should give a sharp peak if it is).