Building apps is complicated. There’s planning, design, development, deployment, customer service, marketing, legal considerations… Yikes! There are also many additional layers of pervasive challenges: How do you keep people engaged? What’s the best way to onboard new users? To navigate the treacherous waters of user psychology and gloss over answer the hard questions, many have turned to a buzzword that has now become notoriously vapid: gamification.

Buzzwords: A Necessary Evil

Words like “cloud” or “real-time” usually start out with good intentions. They help us coalesce loosely connected ideas into common vernacular so that it’s easier to communicate large sets of granular details. The strength of buzzwords is also their downfall: A word becomes a “buzzword” when it gets used too broadly, eventually becoming vague and meaningless. A buzzword is like a brilliant star destined to go supernova and become a cloudy nebula. Here’s a video that shows what that process looks like:

In my opinion, gamification hit the “cloudy nebula” phase some time ago. Gamification is generally the idea of applying gaming principles to non-gaming contexts, like software, marketing, business, and basically anything at this point. In other words, it’s an attempt to turn something boring into something fun. I think this is a great idea if the game mechanics (sets of rules) are used to produce gameplay (specific interactions). Unfortunately, the popularity of gamification has misled many to believe that it’s all about XBOX-like achievements and high score leaderboards without any thought behind their purpose. Gamification has been abused, but there are still lots of positive examples. Indeed, Treehouse uses familiar gaming concepts like badges and points. When you earn a badge, it’s tangible evidence that you’ve successfully completed a course. When you earn points in a subject area, it helps to quantify knowledge for yourself and others. For example, when a student’s points are displayed next to their name in the forum, it’s more than just a high score meant for bragging rights. Rather, it serves as a leading indicator of how knowledgeable that person might be. We’ve had lots of ideas at Treehouse similar to badges and points, but we only work on ideas that we think will actually help improve the efficacy of learning. Badges and points are fun, but more importantly, they’re meaningful.

Gamification Lessons from the Game Industry

Continuing the cosmic comparison, I think we can take the gamification nebula and make a new star out of it by learning from people that actually spend their time making games. It sounds like obvious advice, but learning about an area of study outside your industry and then remixing them with your own work is a great way to create something new and original. If you understand how game designers think, it can help you look beyond the surface details of gamification and understand the inner workings. Game design is a massive topic, but legendary game designer Will Wright (creator of SimCity, The Sims, and Spore) wonderfully articulates some of the more interesting complexities of modern games. There are lots of talks from Will Wright on YouTube and I recommend you learn as much as you can. However, Wright’s talks can be a lot to digest at first, so at the risk of introducing all new buzzwords, I’d like to summarize some of the ideas he shares and explain how I think they apply to building apps.

MENTAL MODELS

Mental model is a term that describes one’s thought process about how something works. For example, I don’t know much about civil engineering, so my mental model of how pipes work in a city looks like something out of Super Mario Bros. However, I do know a lot about computers and websites, so the mental model in my head is probably very close to the reality. It’s still just a model though.

Children’s toys are models that help us form expectations about the world at a very young age. Photo from Flickr user JD Hancock.

Models can help you fill in information gaps. As a thought exercise, think about what happens when you leave a room in your home. You can safely assume that the furniture doesn’t come to life and prance around. However, you can’t really prove it to yourself unless you go back in the room to check. Your own home is an example of a very refined mental model because you’ve had a lot of opportunity to interact and test assumptions. You can confidently fill in the missing information even when you’re not there. In web and mobile apps, models set up expectations that ultimately manifest as user behavior. The user has an idea about how your app will work, so that’s how they interact with your app. As they poke and prod, their mental model will become more closely aligned with the reality of the app you’ve built. As Wright smartly points out in many of his talks, people start forming ideas about a game just by looking at the box art. The same principle can be applied to landing pages and marketing for your web or mobile app. You should strive to set expectations that match the reality of the experience. If you’re selling a mobile app, the screenshots in the app store should give users a pretty good idea of what using that app will be like. Copy that uses familiar terminology can also help shape the user’s model. For example, the team at Treehouse talks a lot about how to name various functions of our service so that people can understand what we’re providing at a glance. Should it be called a course, lesson, syllabus, tutorial, project, deep dive, workshop, etc? What does a user think your app will do before they’ve tried it? With every new page and new interaction, their model is being refined.

LEVELS OF ABSTRACTION

The level of abstraction describes the amount of detail in a system. The highest level encapsulates the entire system, while the lowest level describes the most granular constructs. As you might have guessed already, this idea relates to models.

Like train sets, some models have more detail than others. Photos from Flickr users regan76 and JasonParis.

For example, when I think about how a web browser requests data from a server, my mind leaves out unimportant granular bits like the electricity flowing through the wires or lightwaves hitting the user’s retinas. These are certainly still things that physically happen sometime in that process, but they’re abstracted away in favor of a simpler and more digestible thought process. When providing customers with an explanation of your app’s functions, the level of abstraction should match the task. People like using Google Maps to browse the world’s geography with detailed satellite imagery. However, if they need to get driving directions, it’s better to use the map view. Even though it has less visual information, it’s vastly more useful because the level of abstraction is tailored to the goal. Too much information makes it difficult for the mind to parse with any speed. Levels of abstraction can be applied to many different aspects of apps, but if you’re onboarding new customers, this is especially important. Do you show them the most granular task first and allow them to work their way up to higher level goals? Or, do you first show them the grand scheme of things and then break it down step by step? Does it make more sense to trickle out these details slowly or is it better to put it all in one big user manual? There’s no right answer here, so be very sensitive to the context and mindset of your target audience.

Feedback Loops

When you interact with something in the world, you constantly digest feedback and refine your understanding. In video games, you mash some buttons and watch what happens to your avatar on the screen. Maybe your character moves around and jumps. Learning about the controls isn’t enough to win the game though, so next you learn how to jump onto various platforms and collect items. Then later on, you can apply the different tactics of running and jumping into a cohesive strategy that will help you beat a level. And so on and so forth… This cycle of behavior and reward can be described as a series of nested feedback loops, with each loop taking slightly longer than the last. On Treehouse, you can earn some points by watching a video and completing a code challenge. After you do a few of these, you earn a badge. After you’ve earned a few badges, you might have built a complete project. Once you’ve built several projects and helped students in the forum, you have a lot of points and badges that can help lead to employment. Each level of reward builds on the last and simultaneously drives the next. Video game designers are very good at this sort of thing, because when people play, they just want to kick back and have fun. With the exception of board games, most games have to teach you how to play while you are playing. In web apps, I think this is an excellent way to shape the onboarding experience. Get the momentum going and then help the user pick up each nested goal state along the way. I also think it’s the best way to keep users engaged. It’s not enough to give them one thing or even many things to strive for. Instead, it’s much more interesting to create a series of connected goal states. That way they’re not just grinding out the next few rewards. Rather, they’re reaching for the next goal by standing on their own accomplishments, which can evoke a tremendous sense of pride.

Share Your Story

Gamification is an extremely broad and muddled subject at this point, but if you have any clarity that you’d like to share, I’d love to hear about it in the comments!

The post Hit the Reset Button on Gamification appeared first on Treehouse Blog.

From NIH NOT-OD-14-055 (issued 2/10/14):

This Notice provides guidance about the NIH Fiscal Operations for FY 2014 and implements the  Consolidated Appropriations Act, 2014 (H.R. 3547/Public Law 113-76), signed by President Obama on January 17, 2014.   The Act provides NIH with $30.15 billion, an increase of $1 billion (program level) over FY 2013.  The NIH will continue to manage its portfolio in biomedical research investments in a manner that includes recognizing applications from and providing special incentives for new investigators.

The following NIH fiscal policies are instituted in FY 2014:

FY 2014 Funding Levels:Non-competing continuation awards that have already been made in FY 2014 were generally funded at levels below that indicated on the most recent Notice of Award (generally up to 90% of the previously committed level) as described in NOT-OD-14-012, and in NOT-OD-14-043. Such reductions may be fully or partially restored, depending on the Institute or Center.  Non-competing continuation grants (research and non-research) including those that remain to be issued in FY 2014 likely will be made within the range between the commitment level indicated on the Notice of Award and 3 percent below that level. Out-year commitments for continuation awards in FY 2015 and beyond will remain unchanged.  The number of competing awards will likely exceed the number of competing awards in FY 2013.  The NIH awarding Institutes/Centers (IC) will develop and post their fiscal policies consistent with overall NIH goals and available FY 2014 funds.

Ruth L. Kirschstein National Research Service Awards (NRSA):  Consistent with the  Consolidated Appropriations Act, 2014, and with the recommendations of the Advisory Committee to the Director regarding the Biomedical Research Workforce, the NIH will increase undergraduate and graduate student stipends by 2 percent.   Entry level postdoctoral stipends will be increased to $42,000 with 4 percent increases between the individual levels of experience.   The full range of stipend adjustments for FY 2014 is described at NOT-OD-14-046.    

New Investigators: NIH will continue to support new investigators on R01 equivalent awards at success rates comparable to that of established investigators submitting new (Type 1) R01 equivalent applications.  Achievement of comparable success rates should permit the NIH to support new investigators in accordance with the policies established in FY 2009 and subsequent years as described at http://grants.nih.gov/grants/guide/notice-files/NOT-OD-09-013.html and at http://grants.nih.gov/grants/new_investigators/index.htm.

Salary Limits: Section 203 of the Consolidated Appropriations Act 2014 prohibits payments for salaries under grants and other extramural mechanisms in excess of Executive Level II.  It should be noted, that Executive Level II was increased by 1 percent from $179,700 to $181,500 by Executive Order 13655 that became effective January 12, 2014.  See NOT-OD-14-052 for additional information. 

Other Legislative Mandates: Other statutory requirements are described in NOT-OD-14-053. 

Additional Information:   Additional details on Fiscal Operations, including specific funding strategies for ICs will be posted at http://grants.nih.gov/grants/financial/index.htm.

So you've installed WordPress and want to blog about code. Yay! You're a hero and I thank on behalf of myself an coders everywhere. Here's what you'll need to do and think about to actually get publishing blocks of code.

The HTML for a "code block"

There is an element specifically for code: <code>. I'd say it's semantically correct to wrap any and all code in it. Browser's default stylesheets leave it as inline element, and I'd recommend you leave it that way so you can use it within sentences like I did in the last sentence.

But you'll want to use a block-level element to wrap a block of code. <pre> is the perfect element for that, as it naturally retains spacing. "Pre" as in "Preformatted text". Multiple spaces will render as multiple spaces instead of collapsing into a single space as normally happens in HTML. That's perfect for code, because you'll likely want to use indentation in a block of code and you don't want to resort to any   shenanigans.

So:

<pre><code>Your 
       
       block
      
           of
    
       code
     
     here.</​code></​pre>

Turn off the "Visual" editor

By default, WordPress lets you switch between Visual and Text tabs in the editor.

For you, the Visual editor has to go. You will never use it. You want full control of the text you are writing and want it to stay just how you write it when you save it.

Turn it off under Users > Your Profile

Are you going to blog in Markdown or not?

Here on CSS-Tricks I do not, but if I could go back in time to the beginning I probably would. On most subsequent blogs I've done, I do use Markdown and prefer it. To post a block of code in Markdown, you'll need to indent that code four spaces on every single like, like this:

Yadda yadda yadda. I'm a *paragraph* in Markdown. Here's a [link to Google](http://google.com). Here's a block of code:
    
        <div>
           <p>I'm some code.</p>
        <div>
    
    Another paragraph here.

Manually doing that is going to get old very fast. So you'll want to replace your editor buttons with Markdown buttons. It looks like the plugin Markdown Quicktags can do that.

What's cool about using Markdown is that you don't have to worry about escaping the code. So those angle-brackets are no rendering threat, Markdown will escape them for you. In other words, all those angle brackets (<) in the HTML example above will be turned into < and thus display on the screen as an angle-bracket, not attempt to be rendered by the browser.

That Markdown example above will be turned into this before it hits the browser:

<p>Yadda yadda yadda. I'm a <em>paragraph</em> in Markdown. Here's a <a href="http://google.com">link to Google</a>. Here's a block of code:</p>
    
    <pre><code>&lt;div&gt;
       &lt;p&gt;I'm some code.&lt;/p&gt;
    &lt;div&gt;
    
    <p>Another paragraph here.</p>

If you're interested in blogging in Markdown, you have some options. Jetpack, the Automattic-created and maintained plugin, now offers it as part of it's mega-pack of offerings. At the time being I use WP-Markdown here on CSS-Tricks (I know I said I don't use Markdown, but I do for the Forums and comments, just not blogging).

Two I haven't personally tried are Typewriter and Markdown on Saved Improved.

There is a fairly major limitation here though. Notice that the four-spacing indentation converts into a <pre><code> block, but there was no opportunity there to add attributes to those tags. Attributes (like classes and data-* attributes) are a common need. You might want to use a syntax highlighter (we'll talk about those later) that requires some attributes to do it's thing. Or you might want to identify the code block somehow by language.

GitHub is a big user of Markdown, and they solved this issue by adding the triple-backtick style of code blocks, like this:

```
    <div>
      <p>I'm some code.</p>
    <div>
    ```

I'd call this straight up better. It's easier to jump into a code block while writing without having to worry about the indentation thing. Plus code has it's own indentation going on so it's nice to start flush-left with that.

Beyond that, GitHub-flavored Markdown allows you to specify the language right in the Markdown syntax. So our example could be:

```html
    <div>
      <p>I'm some code.</p>
    <div>
    ```

Which gives:

<div class="highlight highlight-html">
      <pre>
         <span class="nt">&lt;div&gt;</span>
         hi
         <span class="nt">&lt;/div&gt;</span>
      </pre>
    </div>

I'm not sure why it skips the <code> tag and it looks like it does the syntax highlighting server-side with those spans. Just be aware of all that I suppose.

I was able to find wp-gfm which is a GitHub-flavored Markdown plugin for WordPress.

If you go no-Markdown, you'll need to escape the code.

CSS rarely needs escaping, but HTML for sure does, and JavaScript sometimes has HTML in it as well as just about all backend languages, so you might as well just assume you need to escape all code.

You could do it manually by converting all <'s into &lt;'s, but you'll go nutty doing that. You could use a tool like Postable to copy-and-paste blocks to be escaped, but that's slow and tedious too.

I prefer using a plugin called Code Markup for this. It just auto-escaped anything it finds within <code> tags so you just never have to think about it.

Because I use that plugin on this site, I can do stuff like:

<pre data-lang="HTML"><code class="language-markup"><div>
      <p>I'm some code.</p>
    <div></​code></​pre>

And it works great. No escaping. Full attribute control.

Handling Syntax Highlighting

Remember that one option for syntax highlighting blocks of code is not syntax highlighting. Certainly that would be the fastest and easiest way. But you might want it. Personally I like it. I like the way it looks. Here's a few options.

What essentially happens with any syntax highlighter is bits of code end up getting wrapped in <span>s with class names that you colorize with CSS. Choosing is a matter of features.

Prism.js

Here on CSS-Tricks, I use (and recommend) Prism by Lea Verou as it works with those right out of the box. It's small, fast, and (my favorite) as rational class names for styling. You choose which languages you want it to support as you download it.

I also use that escaping plugin, meaning I don't need to escape HTML inside code tags, so again that looks like this:

<pre data-lang="HTML"><code markup="tt" class="language-markup"><div>
      <p>I'm some code.</p>
    <div></​code></​pre>

That class="language-markup" on the code tag is what Prism picks up on to syntax highlight. It works automatically on all code it finds with that class name pattern by default, but you can use the API instead if you want to do your own thing.

The data-lang attribute on the <pre> tag isn't required, but I might use that in CSS to style the look (and label) the code as HTML. The markup attribute you see in there relates to the escaping plugin. By default it still renders things like <span> and <a> elements, but if you use that attribute with an element-as-value that you don't really plan to use, it will escape those too.

Prettify

An extremely popular one is google-code-prettify. To syntax highlight a block, you put class="prettyprint" on either the code or pre tag.

It's a larger file size than Prism, but one advantage is that it auto-detects language (and supports a ton of languages), so it should work on just about anything without you having to specify it.

Others

Digging around a little, there are plenty more that I can't vouch for but seem like they'll do the trick: Rainbow, SyntaxHighlighter, Chili (jQuery), JSHighlighter, jQuery.Syntax (jQuery), GeSHi, Lighter (MooTools), highlight.js, SHJS, and Pygments (Python).

Deciding

To decide amongst these, you might think about these things:

• What languages do I mostly need to support?
• Do I want to show line numbers?
• Do I need to put links within the code?
• Do I want to be able to highlight parts of the code or lines?
• Do I have legacy code blocks I need to support? What format are they in?
• Is the code easy to copy and paste? Do I want features to help with that?
• Is client-side syntax highlighting OK or do I want it to happen server-side?

Dealing with Legacy Code

If you have a bunch of code blocks on a site already, I'd still recommend choosing a syntax highlighter that you like the features of for current and future use. Then finding a way to make it work for the older blocks.

For instance, let's say I have a legacy code block that is marked up like this:

<pre><code class="javascript">
      var thing = document.getElementById("thing");
    </​code></​pre>

That's not the right class name for Prism. So I might use jQuery to do something like:

$("code.javascript")
      .removeClass("javascript")
      .addClass("language-javascript");

And make sure that JavaScript runs before Prism does. I might also take the opportunity to $.trim() the code because, as written above, there is an extra return at the top and bottom which might affect the styling of the code block.

I mean this just as an example. The overall point is: you can manipulate the legacy code blocks as needed to fit the new format.

Third Party Help

When creating the Embedded Pens feature on CodePen, we knew that displaying demos and code in blog posts is kind of a pain in the butt, so we set out to make that easier.

Here's an example of some CSS (complete with a demo) that I'm embedding into this post:

* {
      @include box-sizing(border-box); 
    }
    
    section {
      background: #eee;
      max-width: 600px;
      margin: 0 auto;
      padding: 20px;
      overflow: hidden;
    }
    
    .module {
      width: 48%;
      min-height: 200px;
      background: white;
      position: relative;
      float: left;
      padding: 20px;
      margin-right: 4%;
      margin-bottom: 4%;
      &:nth-child(even) {
        margin-right: 0;
      }
      box-shadow: 0 1px 3px rgba(black, 0.2);
    }
    
    body {
      background: url(http://s.cdpn.io/3/blurry-blue.jpg);
      background-size: cover;
      padding: 30px;
    }
     
    .come-in {
      transform: translateY(150px);
      animation: come-in 0.8s ease forwards;
    }
    .come-in:nth-child(odd) {
      animation-duration: 0.6s;
    }
    .already-visible {
      transform: translateY(0);
      animation: none;
    }
    
    @keyframes come-in {
      to { transform: translateY(0); }
    }

I don't need to worry about syntax highlighting, escaping, or anything, and get the benefit of showing the rendered demo as well. Plus, if you choose, we embed the code of your choice right in there so in the case JavaScript doesn't run (e.g. an RSS reader) the code will still be present in semantic tags.

Many of the other code editor sites offer embedded code as well like JSFiddle and JSBin. GitHub Gists can be useful for this too. Perhaps my favorite reason for using third-party tools for this is that you can go update the demo there and the blog post automatically has the new code. You don't have to update stuff in two places. Although I often just plop code directly into posts as well.

Do you have your own way of handling code blocks on a WordPress site? Do share.

Posting Code Blocks on a WordPress Site is a post from CSS-Tricks

From NIH NOT-OD-14-053 (issued 2/10/14):

The FY 2014 Consolidated Appropriations Act, 2014 (Public Law 113-76) signed into law on January 17, 2014 provides funding to NIH for the fiscal year ending September 30, 2014. The intent of this Notice is to provide information on the following statutory provisions that limit the use of funds on NIH grant, cooperative agreement, and contract awards for FY2014.

From NIH NOT-OD-14-052
(issued 2/10/14):

Questions & Answers

1. If a grant award (competing or non-competing) has already been issued in FY 2014, will an adjustment be made? No adjustments will be made. However, rebudgeting is allowable.

2. Can I rebudget grant funds or charge contracts issued in prior years (see Salary Cap Summary (FY 1990 – FY 2014) funds to allow for the 2014 salary cap increase? Yes, provided funds are available and the increase is warranted. Prorated figures should be used for the applicable months, i.e., the $181,500 level is effective beginning January 12, 2014.

3. If an application/proposal fails to provide needed salary information, will an adjustment be made based on the new rates? No adjustment will be made if an application fails to provide adequate information regarding the individual's actual salary level.

4. Does the NIH appropriation language link the salary cap to a Federal Executive Level or to a dollar level? The link is to the Federal Executive Level pay scale (i.e., Executive Level I for FYs 2001-2011, Executive Level II for FYs 2012-2014).

5. As the cap is linked to Federal Executive Levels, can grantees/contractors with ongoing awards rebudget/charge up to the various salary caps, based on the fiscal year of the award and the time the salary expense is incurred?  Yes, salary may be charged in accordance with the FY cap(s), as long as the levels are consistent with the individual's institutional base pay. Please refer to the salary cap summary with times frames for existing salary caps, at http://grants.nih.gov/grants/policy/salcap_summary.htm.

6. Will grantees be permitted to submit revised categorical budgets reflecting higher base salaries? Not as a general rule. NIH policy for categorical budgets states that grantees should always reflect actual base salaries in the requested budgets or provide an explanation indicating that actual institutional base salary exceeds the current salary limitation. As a general rule, NIH will use the information available in the existing application and make adjustments for the salary cap based on information available at the time of award.

The following are examples of the adjustments that NIH will make when salaries exceed the current salary limitation:

Example 1. Individual with Full-Time Appointment (based on grant award/contract issued on or after January 12, 2014 with salary limitation of $181,500)

Example 2. Individual with Half-Time Appointment (based on a grant award/contract issued on or after January 12, 2014 with salary limitation of $181,500)

Example 3. Individual with a Nine-Month Appointment (based on a grant award/contract issued on or after January 12, 2014 with salary limitation of $181,500)

From NIH NOT-OD-14-046 (issued 2/10/14):

Stipends

Effective with all Kirschstein-NRSA awards made on or after October 1, 2013, the following annual stipend levels apply to all individuals receiving support through institutional research training grants or individual fellowships, including the Minority Access to Research Career (MARC) program.

Undergraduates in the MARC Program:  for institutional training grants (T34):  Two stipend levels are used for undergraduate candidates--Freshmen/Sophomores, and Juniors/Seniors.

Predoctoral: for institutional training grants (T32, T35, T90, TL1) and individual fellowships (F30, F31):  One stipend level is used for all predoctoral candidates, regardless of the level of experience.

Postdoctoral:  for institutional training grants (T32, T90) and individual fellowships (F32):  The stipend level for the entire first year of support is determined by the number of full years of relevant postdoctoral experience when the award is issued. Relevant experience may include research experience (including industrial), teaching assistantship, internship, residency, clinical duties, or other time spent in a health-related field beyond that of the qualifying doctoral degree.  Once the appropriate stipend level has been determined, the fellow must be paid at that level for the entire grant year.  The stipend for each additional year of Kirschstein-NRSA support is the next level in the stipend structure and does not change mid-year.

Senior Fellows (F33 only):  The amount of the Kirschstein-NRSA stipend to be paid must be commensurate with the base salary or remuneration that the individual receiving the award would have been paid by the institution with which he or she has permanent affiliation on the issue date of the fellowship award. In no case shall the stipend award exceed the current Kirschstein-NRSA stipend limit set by NIH.  The level of Kirschstein-NRSA support will take into account concurrent salary support provided by the institution and the policy of the sponsoring institution.  NIH support does not provide fringe benefits for senior fellows.

Relevant Policies

Current stipend levels are to be used in the preparation of future competing and non-competing NRSA institutional training grant and individual fellowship applications.  They will be administratively applied to all applications currently in the review process.

NRSA support is limited to 5 years for predoctoral trainees (6 years for dual-degree training, e.g., MD/PhD, DO/PhD, DDS/PhD, AuD/PhD, DVM/PhD), and 3 years for postdoctoral fellows.  The NIH provides eight levels of postdoctoral stipends to accommodate individuals who complete other forms of health-related training prior to accepting a Kirschstein-NRSA supported position.  (The presence of eight discrete levels of experience, however, does not constitute an endorsement of extended periods of postdoctoral research training.)

It should be noted that the maximum amount that NIH will award to support the compensation package for a graduate student research assistant remains at the zero level postdoctoral stipend, as described in NOT-OD-02-017.

Tuition and Fees, Training Related Expenses, and Institutional Allowance for Kirschstein-NRSA Recipients

The NIH will provide funds for Tuition and Fees, Training Related Expenses, and Institutional Allowance, as detailed below.   Those amounts do not change with the implementation of the FY 2014 budget.

A. Tuition and Fees

• Predoctoral Trainees and Fellows:  For institutional training grants (T32, T34, T35, T90, TL1) and individual fellowships (F30, F31), an amount per predoctoral trainee equal to 60% of the level requested by the applicant institution, up to $16,000 per year, will be provided.  If the trainee or fellow is enrolled in a program that supports formally combined, dual-degree training (e.g., MD/PhD, DO/PhD, DDS/PhD, AuD/PhD, DVM/PhD), the amount provided per trainee or fellow will be 60% of the level requested, up to $21,000 per year.

• Postdoctoral Trainees and Fellows:  For institutional training grants (T32, T90, TL1) and individual fellowships (F32, F33), an amount per postdoctoral trainee or fellow equal to 60% of the level requested by the applicant institution, up to $4,500 per year, will be provided.  If the trainee or fellow is enrolled in a program that supports postdoctoral individuals in formal degree-granting training, an amount per postdoctoral trainee or fellow equal to 60% of the level requested by the applicant institution, up to $16,000 per year, will be provided.

B. Training Related Expenses on Institutional Training Grants

• For institutional training grants (T32, T34, T35, T90, TL1), these expenses (including health insurance costs) for predoctoral and postdoctoral trainees will be paid at the amounts shown below for all competing and non-competing awards made with FY 2014 funds.  

• Predoctoral Trainees: $4,200
• Postdoctoral Trainees: $7,850

C. Institutional Allowance for Individual Fellows
This allowance for predoctoral and postdoctoral fellows will be paid at the amounts shown below for all competing and non-competing awards made with FY 2014 funds.

• Institutional Allowance for individual fellows (F30, F31, F32, F33) sponsored by non-Federal Public, Private, and Non-Profit Institutions (Domestic & Foreign, including health insurance):  

• Predoctoral Fellows: $4,200
• Postdoctoral Fellows: $7,850

• Institutional Allowance for individual fellows (F30, F31, F32, F33) sponsored by Federal and For-Profit Institutions (including health insurance):  

• Predoctoral Fellows: $3,100
• Postdoctoral Fellows: $6,750

Why Big Data Isn’t the Big Problem for Genomic Medicine

Navis Deploys DB Networks To Improve Operations

Ayasdi Delivers Model-Free, Query-Free Insight Discovery With Intel(R) Data Platform