Light Point Security Advances to Round 3 of the InvestMaryland Challenge

We are excited to announce that Light Point Security has advanced to Round 3 of the InvestMaryland Challenge  in the IT category. This places Light Point Security in the final 10 to win an award of $100,000. The InvestMaryland Challenge is a business competition hosted by the State of Maryland. One winner will be selected from each of three categories, and each winner receives $100,000.

A total of 259 companies applied to the challenge. In the first round it was narrowed down to about 20 companies for each category. In the second round it was narrowed down to the top 10 in each category. The  third and final round will be judged in a face-to-face interview on Mar 5. Each company will have 15 minutes to pitch their company to a panel of judges, followed by a 10 minute Q&A session. The winner of each category will be announced on April 15 at the Governor’s Cup Awards Ceremony.

There are still a lot of good companies in the running, and we are proud to be among them. Good luck to all the finalists!

ARTWEEK ‘14 HIGHLIGHT
International Award Wining Cartoonist, Kevin “Kal” Kallaugher

Coming Tuesday, March 4th, 2014
7:00pm-9:00pm
The Skylight Room, 3rd Floor (next to the elevators), The Commons

In a lively and entertaining illustrated presentation, Kal will provide insight to his 35 year stint as an international award winning cartoonist. Kal will discuss his unique and challenging profession and his 8000 barbed commentaries that have engaged readers and leaders around the globe. The presentation will be capped off with live drawing of Kal’s favorite targets (plus a book signing of Kal’s newest collection Daggers Drawn, perhaps).

Free food will be provided!

Facebook Event || myUMBC Event || ArtWeek Website || commonvision@umbc.edu

Linguistic and System Support for Structured Parallel Programming

Dr. I-Ting Angelina Lee
Computer Science and Artificial Intelligence Laboratory
Massachusetts Institute of Technology

12:00-1:00 Thursday, 20 February 2014, ITE 325b, UMBC

Parallel programming is hard, due to issues such as scheduling and synchronization. Most parallel programs today deal with these issues using low-level system primitives such as pthreads, locks, and conditional variables. Although these low-level primitives are flexible, they, like goto statements, lack structure and make it difficult for the programmer to reason locally about the program state. Just as the use of goto has been mostly deprecated in favor of structured control constructs, we can simplify parallel programming by replacing these low-level primitives with linguistics that enable well-structured parallel programs.

To enable structured parallel programming is not merely a matter of linguistic design. The underlying system must also efficiently support the linguistics. In this talk, I will describe my work on pipeline parallelism, a parallel pattern commonly used in streaming applications, as an example of linguistics for structured parallel programming. I will also draw examples from my research to demonstrate how novel mechanisms in operating systems and hardware, not just the runtime, can help provide efficient support for the linguistics.

I-Ting Angelina Lee is a postdoctoral associate in the Computer Science and Artificial Intelligence Laboratory at MIT, working with Prof. Charles E. Leiserson. Her areas of interest include designing linguistics for parallel programming, developing runtime system support for multithreaded software, and building novel mechanisms in operating systems and hardware to efficiently support parallel abstractions. Her work on “memory-mapped reducers” won best paper at SPAA 2012. Intel has released an experimental branch of Cilk Plus that incorporates support for parallel pipelining based on her work. She received her Ph.D. from MIT in 2012 under the supervision of Prof. Charles E. Leiserson. She received her Bachelor of Science in Computer Science from UC San Diego in 2003.

Host: Tim Oates, Sorry, you need javascript to view this email address.

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.