I recently bought 23andme, a service which requires you to send off a DNA sample, and in return performs a series of interesting tests concerning your health and ancestry. I bought the test as a birthday present to myself, somewhat because I was interested in the results, but also because I wanted to treat it as a catalyst for learning more about the subject.
The first step in the process of getting your DNA analyzed by 23andme, is to put a substantial amount of saliva into to a specialized container they mail you. This saliva contains cheek cells, which is what 23andme use for genotyping. They don’t need many cells, but the reason why they ask for so much saliva is so that it’s harder to take someone else’s DNA without their permission!
Then the DNA sample is mailed off to 23andme’s laboratory where it’s amplified through PCR, a process where the DNA is separated from the nucleus and replicated. Lastly it’s put through a machine which, rather than sequence the whole genome, looking for specific SNPs. These SNPs are responsible for a lot of the biological differences between people, and variations influence a variety of traits such as height, eye color and disease susceptibility.
So now 23andme have analyzed about a million of your SNPs, it’s time to draw some conclusions from the genotyping. Most of the health and trait reports are based on genetic association studies, taking a specific SNP and testing for associations with factors like eye color and diseases like Parkinson’s. Furthermore, 23andme can correlate diseases and symptoms from all their users to specific SNPs, furthering research and understanding of how they affect our bodies.
Genetic associations are not a certainty that a specific SNP will have a specific outcome, but rather a probability. Correlations doesn’t mean causation either, and while there may be an association, additional research is needed to show whether the factor has a causal effect.
There are a bunch of heritable genetic disorders that 23andme tests carrier status for, such as Cystic Fibrosis. While the gene for Cystic Fibrosis is recessive, if you mate with someone who also has the same recessive gene, then the likelihood is that your child will develop the disease is one quater. Other disorders like Huntington’s are dominant, and only requires one parent to be a carrier. 23andme doesn’t seem to do much testing of dominant genetic disorders, as it’s likely that the parents are already aware of the issue.
Working out how SNP affects a phenotype trait is tricky. Most SNP changes have no effect, while other characteristics are due to environmental factors. One way of investigating this, is by studying identical twins. Since they have the exact same DNA, any differences between the two can be attributed to environmental factors. Some phenotypes like height are mostly influenced by your genetics (assuming you have a good nutrition), while others like freckles are more affected by the environment.
This difference between environmental and heritable traits is often called nature vs nuture, and can be fairly controversial at times. Take, for example, IQ. The effect that parents have upon their children’s intelligence is in serious dispute and, while a neglectful and abusive upbringing can have an adverse effect, given a base minimum supportive parenting doesn’t have have much of an influence on IQ. Studies have shown that identical twins who grow up in separate families have an IQ correlation of 0.74, while adoptive siblings have no more similar IQ than strangers.
I’m not going to talk about the more sensitive health information I gleaned from the report, as while President Bush signed the Genetic Information Nondiscrimination Act I’m still wary of how it could affect my insurance in the future. However, let’s talk about a non sensitive trait, lactose intolerance. Lactose intolerance is fairly heritable and is influenced by an SNP near the LCT gene which encodes lactase, an enzyme required for digestion of milk.
Normally, the lactase enzyme is only produced in the first few years of a mammals life. However, certain European populations have a mutation that causes lactase to be produced throughout their lives. Dairy farming, which is widespread primarily in Europe, provided additional sources of nutrition to early inhabitants of Europe. Thus, it is thought, being able to drink milk throughout adulthood would have provided them with an evolutionary advantage.
My genotype for this SNP is AG, or adenine and guanine. This has been correlated with higher adult lactase levels. This allele is rarer in Africa and Asia, hence the high cases of lactose intolerance in those regions.
SNP: rs4988235 (A or G)
Alex’s Genotype: AG
Gene: MCM6
Chromosome: 2
As I say, while this trait is heritable, it is also influenced by environmental characteristics such as the bacteria in your gut. In other words, having a AG genotype doesn’t always mean you’ll be lactose tolerant, and vice versa. It’s all about probability, and in this case 23andme were correct - I am lactose tolerant, which is useful as I enjoy milk!
Calculating ancestry through DNA is an interesting process, because it turns out that the variations between you and your ancestor’s DNA make it impossible to detect relations after a few generations or so. However the Y chromosome is passed down from father to son without much alteration, which means it makes a perfect candidate for looking into your past. Maternal descent is calculated from DNA found in the mitochondria, as this too is passed down unaltered from mother to child. Using these two pieces of information we can look hundreds of thousands of years into our past, as well as at our more recent history.
My ancestors, on both my mother’s and father’s side, are from Europe - mostly from the UK, Ireland and Scotland, with a little Spanish and German mix. My DNA is 2.9% neanderthal, which puts me in the top 91% of 23andme’s members (not sure what conclusions to draw from that!). I’m also distantly related to Jesse James on my mother’s side, and have found a previously unknown second cousin in Scotland.
Genetic family trees can be identified by looking at haplogroups, a set of genetic mutations that are shared by everyone in the group. The likelihood is that if you share a lot of specific genetic mutations with someone, than you’re related. All haplogroups can be traced back to a mutation in a single individual.
For example, 8 percent of asian males are in the same haplogroup as Genghis Khan, and carry Y chromosomes that share many of the same SNPs. Y chromosomes aren’t recombined when they’re inherited, so genetic mutations in them act as markers, allowing geneticists to trace them back and predict in time the moment they occurred. Such a rapid spread of this particular mutation is unlikely to have happened by chance, and suggests that 0.5% of the world’s population are descendants of Genghis Khan and his male relatives - quite a staggering amount.
Geneticists can trace back humans to a single male and female, a genetic “Adam and Eve”. What’s fascinating is that while Adam lived about 142,000 years ago, Eve lived much earlier, about 200,000 years ago - they never met each other. Y-chromosomal Adam lived at a time close to the migration from Africa, and this turmoil could suggest a reason why so few males lineages survived.
Analyzing my DNA has given me a fascinating insight into my health and ancestry, and something I’d recommend to everyone. However, personally the best part of the whole process was learning more about DNA and how it effects us. It’s a fascinating subject which is undergoing a lot of research.
On a separate note, 23andme’s service is really commendable. Businesses that combine commercial products with scientific research and advances are close to my heart. Other examples of this kind of approach are SpaceX and Tesla.
]]> |
 |
|
|
Doctoral students, postdocs and established researchers working in the intersection of technology and social systems might consider applying to the 2013 Digital Societies and Social Technologies Summer Institute, 7/28 to 8/1 at the University of Maryland College Park.
"MOOCs, Education and learning; personal health and well-being; open innovation, eScience, and citizen science; co-production, open source, and new forms of work; cultural heritage and information access; energy management and climate change; civic hacking, engagement and government; disaster response; cybersecurity and privacy – these are just a few problem domains where effective design and robust understanding of complex sociotechnical systems is critical. To meet these challenges a trans-disciplinary community of scholars has come together from fields as wide ranging as CSCW, HCI, social computing, organization studies, information visualization, social informatics, sociology, information systems, medical informatics, computer science, ICT for development, education, learning science, journalism, and political science."
Lodging, meals, and other onsite costs will be covered for all Summer Institute participants. Applications are due by April 5.
]]>
Doctoral students, postdocs and established researchers working in the intersection of technology and social systems might consider applying to the 2013 Digital Societies and Social Technologies Summer Institute, 7/28 to 8/1 at the University of Maryland College Park.
"MOOCs, Education and learning; personal health and well-being; open innovation, eScience, and citizen science; co-production, open source, and new forms of work; cultural heritage and information access; energy management and climate change; civic hacking, engagement and government; disaster response; cybersecurity and privacy – these are just a few problem domains where effective design and robust understanding of complex sociotechnical systems is critical. To meet these challenges a trans-disciplinary community of scholars has come together from fields as wide ranging as CSCW, HCI, social computing, organization studies, information visualization, social informatics, sociology, information systems, medical informatics, computer science, ICT for development, education, learning science, journalism, and political science."
Lodging, meals, and other onsite costs will be covered for all Summer Institute participants. Applications are due by April 5.
]]>
Doctoral students, postdocs and established researchers working in the intersection of technology and social systems might consider applying to the 2013 Digital Societies and Social Technologies Summer Institute, 7/28 to 8/1 at the University of Maryland College Park.
"MOOCs, Education and learning; personal health and well-being; open innovation, eScience, and citizen science; co-production, open source, and new forms of work; cultural heritage and information access; energy management and climate change; civic hacking, engagement and government; disaster response; cybersecurity and privacy – these are just a few problem domains where effective design and robust understanding of complex sociotechnical systems is critical. To meet these challenges a trans-disciplinary community of scholars has come together from fields as wide ranging as CSCW, HCI, social computing, organization studies, information visualization, social informatics, sociology, information systems, medical informatics, computer science, ICT for development, education, learning science, journalism, and political science."
Lodging, meals, and other onsite costs will be covered for all Summer Institute participants. Applications are due by April 5.
]]>jQuery is great. It’s cross-browser, easy to learn, and makes adding interactivity to your website a breeze. It also comes with plenty of plugins to do almost whatever you need it to do.
But what if you can’t find just the right plugin to suit your needs? Or you’re just looking to keep your project DRY by combining some oft-used functionality into one nice, neat package? The solution might be to roll your own plugin to meet exactly your needs.
Writing your own jQuery plugin isn’t as hard as it might seem at first. This tutorial will go through the process of writing a simple plugin, adding some options, and even perform a callback.
We’ll start with the old chesnut of programming tutorials, a “Hello, World!” plugin. Before we can do anything, we need to establish our file and link it to our HTML document. First, we’ll create our plugin file and put it in the “js” directory of our website. It’s traditional to start our filename with “jquery,” followed by the actual plugin name, so we’ll call this “jquery.hello-world.js”.
Our “Hello, World!” plugin, snuggly next to our jQuery core file.
Next, we’ll need to make sure our plugin file, as well as it’s jQuery core big brother, are linked in our HTML file, so place the following two lines at the bottom of your HTML document, just before the closing </body> tag:
<script src="js/jquery-1.9.1.min.js"></script>
<script src="js/jquery.hello-world.js"></script>
jQuery comes with all the necessary hooks to build your plugin file easily. But we still want to be mindful of good JavaScript practices, and make sure we keep everything inside a local scope. We’ll start with the very basic shell of a traditional jQuery plugin:
(function($) {
$.fn.helloWorld = function() {
// Future home of "Hello, World!"
}
}(jQuery));
Let’s take a quick moment to understand what’s going on. By including everything in the (function() {}) self-enclosed JavaScript pattern, we’re making sure that all the variables in our plugin will stay safely outside of the global namespace. We don’t want to cause any collisions with any other JavaScript used on the page, after all.
The other thing you might notice is that we’re defining our plugin as if jQuery was in it’s “no-conflict” mode. Again, we’re seeking to avoid colliding with other JavaScript on the page, and thus we want to make sure that our plugin isn’t reliant on the default $, which could be used by another library.
Finally, $.fn is jQuery’s way of allowing you to define your plugin, which we’ve named helloWorld. With all of our pieces in place, let’s actually do something!
For our plugin, we’re going to do something pretty silly, but also simple enough for our demonstration purposes, and that is to change all the text for the acted upon elements with (what else?) the text “Hello, World!”.
(function($) {
$.fn.helloWorld = function() {
this.each( function() {
$(this).text("Hello, World!");
});
}
}(jQuery));
When we’re invoking the plugin by attaching it to a jQuery selector, the object we’re acting upon is already a jQuery object, so we don’t need to wrap it in the $(this) structure you’re used to. However, once we start looping through each instance of the matching selector, we use the $(this) structure as we would any time we ran our selectors through $.each().
Suppose we wanted to change the text of all of our <h2> headers on the following page:
Our web page, ripe for the text swapping via jQuery.
We would invoke the plugin as you’re already familiar, like so:
<script>
$(document).ready( function() {
$('h2').helloWorld();
});
</script>
To yield this:
Seems silly, I know, but we’ve now replaced all the <h2> headers with “Hello, World!”
We’re not quite done yet. While our plugin technically works, it’s living in its own little isolated world. That is, if you try and chain another jQuery action onto it, nothing’s going to happen because our plugin has led to a dead end. To fix this, be sure to return the results of the plugin as it loops through the DOM elements:
(function($) {
$.fn.helloWorld = function() {
return this.each( function() {
$(this).text("Hello, World!");
});
}
}(jQuery));
And congratulations! You’ve just written you’re first jQuery plugin!
Now that you’re all happy that you’ve built your jQuery plugin, your boss comes back and says that they need to be able to translate the site into Spanish. Uh oh, what do we do now?
Well, we could start by just adding an argument. Let’s take our plugin above, and instead of hard-coding the text into the plugin, we can replace it with a variable and pass that along when we invoke the plugin.
(function($) {
$.fn.helloWorld = function( customText ) {
return this.each( function() {
$(this).text( customText );
});
}
}(jQuery));
There, now we can pass any text we’d like to our plugin. Our offices in Madrid have given us the Spanish translation we need, which we now use as the parameter of our plugin:
<script>
$(document).ready( function() {
$('h2').helloWorld('¡Hola, mundo!');
});
</script>
Our web page now looks like this:
Our plugin, with “Hello, World!” translated into Spanish.
But already we’re a little nervous. What if no text was passed when we called the plugin? As it’s written, the plugin would simply blank out the text of our matched elements, and we probably don’t want that. Also, our boss has already come back to us once asking to make a variable. What if he wants more customization options? Simply adding options ad infinitum isn’t going to work in the long term. A more future-proof solution is the options object.
We already know that the specific text needs to be customizable. Now our boss is asking that the text color and font style be customizable as well. (Yes, I know these are simple options to chain onto our selector via built-in jQuery functions, but go with me here.) Let’s add an options object to our plugin, along with some sensible defaults using the $.extend method:
(function($) {
$.fn.helloWorld = function( options ) {
// Establish our default settings
var settings = $.extend({
text : 'Hello, World!',
color : null,
fontStyle : null
}, options);
return this.each( function() {
// We'll get back to this in a moment
});
}
}(jQuery));
Now we have a settings object that, when the plugin is invoked devoid of any parameters, will use what we’ve established as the default text. We also have two other properties of our settings object, “color” and “fontStyle”, that have no default beyond null. For this plugin, we don’t need to establish any color or font style beyond what is laid out in our CSS, but they’re there for the overriding if we want. We just have to make use of them:
return this.each( function() {
$(this).text( settings.text );
if ( settings.color ) {
$(this).css( 'color', settings.color );
}
if ( settings.fontStyle ) {
$(this).css( 'font-style', settings.fontStyle );
}
});
Since the purpose of this plugin is to replace text, it makes sense to always replace the text with whatever is provided, which is why it also makes sense to provide a default value so that something appears if the plugin is invoked without any options. But the color and font style options are tested for and only acted upon if they are provided.
Our boss has come back and says now they’re going to translate the site into French, and beyond that they want the text to be blue and italic. Fortunately, our plugin can now handle all these requests:
$('h2').helloWorld({
text : 'Salut, le monde!',
color : '#005dff',
fontStyle : 'italic'
});
With several options available to us, our plugin can now speak French, and even change the appearance of the text.
Et voilà! We now have a plugin with a number of possible objects, and the ability to easily add more (or subtract what’s there) in the future without impacting legacy users of the plugin. Hooray for maintainability!
But our boss has come back with yet another request: once the plugin has completed whatever task it was called to do, it should sound an alert informing us of that fact. For this, we have two options: either quit because our boss has obviously never heard of a requirements document, or go the less drastic route and give our plugin the ability to handle callbacks.
Callbacks are options to JavaScript functions that are themselves JavaScript functions. They’re also not unique to jQuery. Again, it may seem like it would be a complicated thing to do, but actually it’s quite simple.
All we need is to establish one more variable in our options object:
// Establish our default settings
var settings = $.extend({
text : 'Hello, World!',
color : null,
fontStyle : null,
complete : null
}, options);
Now we have a “complete” variable to perform an action when, well, our plugin completes its action. To invoke it, we’ll want to make sure that what we’re given is actually a function. Fortunately, jQuery helps us with this with the $.isFunction test:
return this.each( function() {
// Our plugin so far
if ( $.isFunction( settings.complete ) ) {
settings.complete.call( this );
}
});
On the invocation side, our code becomes:
$('h2').helloWorld({
text : 'Salut, le monde!',
color : '#005dff',
fontStyle : 'italic',
complete : function() { alert( 'Done!' ) }
});
And as a result, we see our callback as our plugin is executed:
Our plugin now displays an alert every time it executes, thanks to our callback.
Custom jQuery plugins are a great option when you know you’re going to be doing a lot of the same things over and over in your JavaScript. By writing your own jQuery plugin, you’re both keeping your code DRY and your global namespace nice and clean.
If you’d like to play around with the code from this example, you can grab it from my GitHub.
The post Writing Your Own jQuery Plugins appeared first on Treehouse Blog.
]]>Page edited by Janet Hack
Primary sources are original accounts of historical events. Primary sources may include diaries, letters, newspaper articles, speeches, interviews, oral histories, and other sources.
See our History Subject Guide for more information on locating primary sources.
Phone: 410-455-2346
Chat with a Librarian
Was this helpful? Yes | No | Correct or Suggest an Article | Request Help
Page Information |
|
|---|---|
Tiny URL |
https://wiki.umbc.edu/x/agbcAQ |
Email this Page |