BIO/CSC295 2009F, Class 04: The Central Dogma (1)

Admin:
* Les Duke invitational Saturday morning.  Buses leave from the PEC
  at a variety of times.  EC for attending and supporting Ben.
* Go see home volleyball this weekend.  4pm and 8pm on Friday,
  11am and 3pm on Saturday.
* Vida has been sick.  That means you get to watch the "train wreck 
  in slow motion" of Sam trying to describe biology.
* There is no homework for Thursday.  You may, however, want to look 
  over Chapter 2 again.
* The Web exploration asks you to go to a variety of sites.  You will need
  to enable scripting on each of those sites.
* Upcoming Bio picnic [See the BioSEPC for more info].
  Friday the 25th at 5:30
  You need to provide your ID number, which is officially private info
    and faculty are not allowed to ask for it
  Usually at the Robertsons', next to the Reading lab
  "Everyone" is welcome, even those weirdo math/cs/polisci majors
  But you need to sign up

Overview:
* Lab Exercises, Continued
* Basics of the Central Dogma
* Key Processes
* Some Related Issues
* Computational Problems
* Web Exploration

Lab Exercises: Some Notes/Questions

* What was the hardest part?
  * For a biologist: Figuring out where to put all the commands
  * For a computer scientist: Figuring out where to put all the commands
    And where all the parentheses go: SYNTAX
  * Remembering the exact commands : VOCABULARY; help may help
    * But you may want to take notes, too
  * The map function

* Which of these do you prefer?
def base_pair(nucleotide):
    """Convert a nucleotide (represented as a one-character string) to 
       the paired nucleotide."""
    nucleotide = string.upper(nucleotide)
    if nucleotide == 'A':
        return 'T'
    elif nucleotide == 'C':
        return 'G'
    elif nucleotide == 'G':
        return 'C'
    elif nucleotide == 'T':
        return 'A'
    else:
        return '*'

def base_pair(nucleotide):
    """Convert a nucleotide (represented as a one-character string) to 
       the paired nucleotide."""
    if nucleotide == 'A':
        return 'T'
    elif nucleotide == 'C':
        return 'G'
    elif nucleotide == 'G':
        return 'C'
    elif nucleotide == 'T':
        return 'A'
    if nucleotide == 'a':
        return 't'
    elif nucleotide == 'c':
        return 'g'
    elif nucleotide == 'g':
        return 'c'
    elif nucleotide == 't':
        return 'a'
    else:
        return '*'

The first is shorter and a bit more elegant
However, the first causes the loss of information in cases in which
case has meaning (e.g., lowercase noncoding, uppercase coding)

* How did you do the conversion using string.replace?

"The Central Dogma"

* Does the chapter ever officially define the central dogma?
* What do the topics of the chapter seem to be?
* What does the phrase "The Central Dogma" (of molecular biology) mean?

The chapter is about ...
* Genes and how they code for certain things
* Transcription from DNA into mRNA
* Inheritance and Punnett squares
* Transcription seems to be very algorithmic, at least as 
  described
* mRNA codes for amino acids (and how)
* Mutations are changes in the DNA
* Which means that we'll need to find ways to look for changes in
  DNA by comparing genes
* Lots of public data available, which should be useful

The central dogma
* What many people say: Replication, Transcription, Translation
* Coined by Francis Crick
* Crick's primary dogma: INFORMATION IS NOT TRANSFERED FROM PROTEINS

What are the computational problems from this chapter?

* Transcription: Convert DNA sequence to mRNA
  * Need to be careful in specification: using template or coding strand,
    starting at 5' or 3'.
  * In real practice, you need to identify the real coding sequence
* Translation: Convert an mRNA sequence to an amino acid sequence
* Identifying coding sequence

* Comparing DNA sequences
  * Finding simple mutations
  * Finding insertions
  * Finding deletions
  * And dealing with "garbage" DNA while doing it

* Algorithms for dealing with Punnett squares, particularly with
  more complex inheritance combinations