We've all been there. There are times when you simply want to throw some JavaScript code up and see how it works. Sure, you could go through the hassle of:

• Setting up a dedicated directory
• Create a file with markup
• Finding the latest version of your favorite libraries, downloading them and including them in your code
• Creating your stylesheet
• Configuring your webserver

That seems like an awful lot of work just do do some simple code testing. Thankfully there are tools that make this type of work trivial.

In this tutorial, I'd like to go over one of my favorite tools for interactive JavaScript testing, JSBin.

The Case for JSBin

As I mentioned previously, in many cases you simply need to test a small subset of JavaScript code. Setting up a whole development environment for such a use case, in most cases, doesn't really make a lot of sense unless there's a clear dependency on hardware (for example, WebRTC) or reliance on a third party API or product where you need backend services to successfully access information.

What JSBin offers is a browser-based user interface where you can enter:

• HTML markup
• CSS
• JavaScript

... and get immediate feedback based on your code. In addition, you can optionally include any number of popular frameworks into your onscreen code, allowing you to leverage the framework's capabilities as well. The main benefit is the real-time feedback you get from the updates you make.

Let's look at these tools a little more closely.

Getting to Know JSBin

JSBin was created and is actively maintained by well-respected developer Remy Sharp. The idea to develop it came from the need to collaborate interactively with other developers to debug JavaScript code. It has since matured into a robust tool which:

• Allows groups of developers to work together to solve code problems
• Serves as a sort of bin that developers can go back to reference
• Makes sharing code and solutions incredibly easy

JSBin is also opensource licensed under the liberal MIT license allowing community members to freely contribute to it or fork it to create their own customized solutions.

JSBin offers a straightforward UI that breaks each type of code into individual vertical panels.

Each panel provides a mini-IDE that allows you to enter code and receive immediate feedback via the Output panel. For example, if I add the following code to the HTML panel:

<div>Rey Bango</div>

I'll immediately see the new element and the text render in the Output panel.

Of course, you can add any number of elements to the markup allowing you to create a page quickly and interactively. Being able to style your markup is equally important since in some cases, the JavaScript you're testing is explicitly designed to manipulate styles and CSS rules applied to your elements. That's where the CSS panel comes in. It offers full CSS style capability, so you can layout your elements to suit your needs, even taking advantage of CSS3 rules. So adding the following code:

div { 
      color: red; 
      font:20px Tahoma,sans-serif; 
      border: 1px solid black; 
      width: 100px;
      margin: 30px;
      padding: 10px; 
      transform:rotate(15deg);
      -webkit-transform:rotate(15deg); 
    }

... provides the following results:

So far, the code has been simple but I need to stress that the important thing here is not the complexity of the code but the fact that you're able to receive immediate feedback. I could easily grab more involved code, like that of the CSS Transitions demo on the Mozilla Developer Network and add that into JSBin to produce a similar effect for my test code:

div { 
      color: red; 
      font:20px Tahoma,sans-serif; 
      border: 1px solid black; 
      width: 100px;
      margin: 30px;
      padding: 10px; 
      -moz-transition:width 2s, height 2s, background-color 2s, -moz-transform 2s;
        -webkit-transition:width 2s, height 2s, background-color 2s, -webkit-transform 2s;
        -o-transition:width 2s, height 2s, background-color 2s, -o-transform 2s;
        transition:width 2s, height 2s, background-color 2s, transform 2s;
    }
    
    div:hover {
        background-color: #FFCCCC;
        width:200px;
        height:200px;
        -moz-transform:rotate(180deg);
        -webkit-transform:rotate(180deg);
        -o-transform:rotate(180deg);
        transform:rotate(180deg);
    }

So while I'm more specifically focused on the JavaScript aspect of JSBin, it's clear that web developers in general can benefit from the interactive nature of the tool.

Using JavaScript

For me, the main benefit of JSBin is the ability to test JavaScript quickly. I'm able to whip up quick and dirty code that I can test and adjust on-the-fly without the need to spin up a whole work environment. Sure, most browsers provide developer tools that offer a console where you can enter quick snippets but they're not yet at a point where you can interactively test large amounts of code, let alone define complementary custom markup and styling to the output.

JSBin's JavaScript panel is where you're able to define your custom JavaScript code. As expected, you have full access to the language as well as the DOM API supported by the browser. This means that when I write:

var myDiv = document.querySelector( "div" );
    
    myDiv.innerHTML = "Foo";

it:

• Allows me to create a local variable
• Provides access to the div element I created in the HTML panel
• Changes the element's content

The results are immediate, allowing me to debug as I'm writing the code.

Having access to plain ole JavaScript is great but it's very common to use a JavaScript utility library like jQuery or a full-blown framework like Ember to abstract the complexities of cross-browser development or create app-like experiences in the browser. JSBin addresses this by allowing you to include most of the popular libraries into your test code.

Clicking on the Add library menu option provides a very long list of supported libraries that can be injected into your JSBin project. What this does is creates a script tag in your code that pulls the JavaScript file from a CDN. Selecting "jQuery 2.0.2" from the list injects the following:

<script src="http://ajax.googleapis.com/ajax/libs/jquery/2.0.2/jquery.min.js"></script&gt;
    <meta charset=utf-8 />

... while selecting Backbone adds the following:

<script src="http://documentcloud.github.io/underscore/underscore-min.js"></script&gt;
    <script src="http://documentcloud.github.io/backbone/backbone-min.js"></script&gt;

Notice how JSBin uses different CDNs based on where the files are available. Most of the big name projects are listed, including:

• jQuery
• Dojo
• Modernizr
• Bootstrap

... and many more.

Adding in jQuery gives me full access to all of the libraries' excellent helper methods and capabilities. I can switch to using its nice, terse API to access DOM elements and set values in one nicely-chained line of code:

$( "div" ).text( "Foo" );

Or, I can take it a bit further and test out an Ajax request to Flickr's API to pull back JSON data and render images based on it:

(function() {
      var flickerAPI = "http://api.flickr.com/services/feeds/photos_public.gne?jsoncallback=?";
      $.getJSON( flickerAPI, {
        tags: "mount rainier",
        tagmode: "any",
        format: "json"
      })
        .done(function( data ) {
          $.each( data.items, function( i, item ) {
            $( "<img>" ).attr( "src", item.media.m ).appendTo( "div" );
            if ( i === 3 ) {
              return false;
            }
          });
        });
    })();

The code above would render as follows:

Having the full power of these libraries and frameworks really opens up the testing scenarios that you can setup with JSBin.

Again, this is a list of the most popular libraries and frameworks available and clearly, some niche ones just won't be in the list. If you need to add your own custom library, the documentation shows how you can add it in yourself.

Additional Features and Resources

I find JSBin invaluable for my desktop development and as I shift to focusing on mobile devices, I'm glad to see that I'll be able to continue to use it to test on those devices as well. As of version three, JSBin has incorporated a feature called "live rendering" which acts as a simulcast across multiple connected devices. These devices aren't explicitly connected but instead, leverage a specific URL which allows them to essentially render the results at the same time. You can see this feature in action in the following video.

Another important feature is the ability to create your own JSBin account where you can save your bins for future reference and sharing. Registration is simple and you can even leverage your Github credentials via Github's OAuth functionality.

The key benefit to registering is the ability to keep a history of the bins you create so that you can revisit them later.

To really get a feel for the full breadth of functionality offered by JSBin, I urge you to go to Remy's Youtube channel for JSBin, where he's done a bang up job of creating tutorial videos exploring all of the excellent features of the service. The FAQ also does a great job of answering common questions you might have.

JSBin is one of my most valuable tools I've found for JavaScript development. The fact that it's free and open source makes it a no-brainer to add to any toolkit. And Remy's continued commitment to the service is commendable. All of this combined, makes it easy for me to spread the word about such a great tool.

We’ve all been there. There are times when you simply want to throw some JavaScript code up and see how it works. Sure, you could go through the hassle of:

• Setting up a dedicated directory
• Create a file with markup
• Finding the latest version of your favorite libraries, downloading them and including them in your code
• Creating your stylesheet
• Configuring your webserver

That seems like an awful lot of work just do do some simple code testing. Thankfully there are tools that make this type of work trivial.

In this tutorial, I’d like to go over one of my favorite tools for interactive JavaScript testing, JSBin.

The Case for JSBin

As I mentioned previously, in many cases you simply need to test a small subset of JavaScript code. Setting up a whole development environment for such a use case, in most cases, doesn’t really make a lot of sense unless there’s a clear dependency on hardware (for example, WebRTC) or reliance on a third party API or product where you need backend services to successfully access information.

What JSBin offers is a browser-based user interface where you can enter:

• HTML markup
• CSS
• JavaScript

… and get immediate feedback based on your code. In addition, you can optionally include any number of popular frameworks into your onscreen code, allowing you to leverage the framework’s capabilities as well. The main benefit is the real-time feedback you get from the updates you make.

Let’s look at these tools a little more closely.

Getting to Know JSBin

JSBin was created and is actively maintained by well-respected developer Remy Sharp. The idea to develop it came from the need to collaborate interactively with other developers to debug JavaScript code. It has since matured into a robust tool which:

• Allows groups of developers to work together to solve code problems
• Serves as a sort of bin that developers can go back to reference
• Makes sharing code and solutions incredibly easy

JSBin is also opensource licensed under the liberal MIT license allowing community members to freely contribute to it or fork it to create their own customized solutions.

JSBin offers a straightforward UI that breaks each type of code into individual vertical panels.

Each panel provides a mini-IDE that allows you to enter code and receive immediate feedback via the Output panel. For example, if I add the following code to the HTML panel:

<div>Rey Bango</div>

I’ll immediately see the new element and the text render in the Output panel.

Of course, you can add any number of elements to the markup allowing you to create a page quickly and interactively. Being able to style your markup is equally important since in some cases, the JavaScript you’re testing is explicitly designed to manipulate styles and CSS rules applied to your elements. That’s where the CSS panel comes in. It offers full CSS style capability, so you can layout your elements to suit your needs, even taking advantage of CSS3 rules. So adding the following code:

div { 
      color: red; 
      font:20px Tahoma,sans-serif; 
      border: 1px solid black; 
      width: 100px;
      margin: 30px;
      padding: 10px; 
      transform:rotate(15deg);
      -webkit-transform:rotate(15deg); 
    }

… provides the following results:

So far, the code has been simple but I need to stress that the important thing here is not the complexity of the code but the fact that you’re able to receive immediate feedback. I could easily grab more involved code, like that of the CSS Transitions demo on the Mozilla Developer Network and add that into JSBin to produce a similar effect for my test code:

div { 
      color: red; 
      font:20px Tahoma,sans-serif; 
      border: 1px solid black; 
      width: 100px;
      margin: 30px;
      padding: 10px; 
      -moz-transition:width 2s, height 2s, background-color 2s, -moz-transform 2s;
        -webkit-transition:width 2s, height 2s, background-color 2s, -webkit-transform 2s;
        -o-transition:width 2s, height 2s, background-color 2s, -o-transform 2s;
        transition:width 2s, height 2s, background-color 2s, transform 2s;
    }
    
    div:hover {
        background-color: #FFCCCC;
        width:200px;
        height:200px;
        -moz-transform:rotate(180deg);
        -webkit-transform:rotate(180deg);
        -o-transform:rotate(180deg);
        transform:rotate(180deg);
    }
    

So while I’m more specifically focused on the JavaScript aspect of JSBin, it’s clear that web developers in general can benefit from the interactive nature of the tool.

Using JavaScript

For me, the main benefit of JSBin is the ability to test JavaScript quickly. I’m able to whip up quick and dirty code that I can test and adjust on-the-fly without the need to spin up a whole work environment. Sure, most browsers provide developer tools that offer a console where you can enter quick snippets but they’re not yet at a point where you can interactively test large amounts of code, let alone define complementary custom markup and styling to the output.

JSBin’s JavaScript panel is where you’re able to define your custom JavaScript code. As expected, you have full access to the language as well as the DOM API supported by the browser. This means that when I write:

var myDiv = document.querySelector( "div" );
    
    myDiv.innerHTML = "Foo";
    

it:

• Allows me to create a local variable
• Provides access to the div element I created in the HTML panel
• Changes the element’s content

The results are immediate, allowing me to debug as I’m writing the code.

Having access to plain ole JavaScript is great but it’s very common to use a JavaScript utility library like jQuery or a full-blown framework like Ember to abstract the complexities of cross-browser development or create app-like experiences in the browser. JSBin addresses this by allowing you to include most of the popular libraries into your test code.

Clicking on the Add library menu option provides a very long list of supported libraries that can be injected into your JSBin project. What this does is creates a script tag in your code that pulls the JavaScript file from a CDN. Selecting “jQuery 2.0.2” from the list injects the following:

<script src="http://ajax.googleapis.com/ajax/libs/jquery/2.0.2/jquery.min.js"></script&gt;
    <meta charset=utf-8 />
    

… while selecting Backbone adds the following:

<script src="http://documentcloud.github.io/underscore/underscore-min.js"></script&gt;
    <script src="http://documentcloud.github.io/backbone/backbone-min.js"></script&gt;
    

Notice how JSBin uses different CDNs based on where the files are available. Most of the big name projects are listed, including:

• jQuery
• Dojo
• Modernizr
• Bootstrap

… and many more.

Adding in jQuery gives me full access to all of the libraries’ excellent helper methods and capabilities. I can switch to using its nice, terse API to access DOM elements and set values in one nicely-chained line of code:

$( "div" ).text( "Foo" );

Or, I can take it a bit further and test out an Ajax request to Flickr’s API to pull back JSON data and render images based on it:

(function() {
      var flickerAPI = "http://api.flickr.com/services/feeds/photos_public.gne?jsoncallback=?";
      $.getJSON( flickerAPI, {
        tags: "mount rainier",
        tagmode: "any",
        format: "json"
      })
        .done(function( data ) {
          $.each( data.items, function( i, item ) {
            $( "<img>" ).attr( "src", item.media.m ).appendTo( "div" );
            if ( i === 3 ) {
              return false;
            }
          });
        });
    })();
    

The code above would render as follows:

Having the full power of these libraries and frameworks really opens up the testing scenarios that you can setup with JSBin.

Again, this is a list of the most popular libraries and frameworks available and clearly, some niche ones just won’t be in the list. If you need to add your own custom library, the documentation shows how you can add it in yourself.

Additional Features and Resources

I find JSBin invaluable for my desktop development and as I shift to focusing on mobile devices, I’m glad to see that I’ll be able to continue to use it to test on those devices as well. As of version three, JSBin has incorporated a feature called “live rendering” which acts as a simulcast across multiple connected devices. These devices aren’t explicitly connected but instead, leverage a specific URL which allows them to essentially render the results at the same time. You can see this feature in action in the following video.

Another important feature is the ability to create your own JSBin account where you can save your bins for future reference and sharing. Registration is simple and you can even leverage your Github credentials via Github’s OAuth functionality.

The key benefit to registering is the ability to keep a history of the bins you create so that you can revisit them later.

To really get a feel for the full breadth of functionality offered by JSBin, I urge you to go to Remy’s Youtube channel for JSBin, where he’s done a bang up job of creating tutorial videos exploring all of the excellent features of the service. The FAQ also does a great job of answering common questions you might have.

JSBin is one of my most valuable tools I’ve found for JavaScript development. The fact that it’s free and open source makes it a no-brainer to add to any toolkit. And Remy’s continued commitment to the service is commendable. All of this combined, makes it easy for me to spread the word about such a great tool.

Templating; it’s a fantastic web design idea for pulling together a business’ online presence, and creating the appearance of consistency.

It’s especially useful when there are multiple sites, product lines, and/or tons of content. Either way, the last thing you want is a clamor of different voices diluting the brand and confusing customers.

What is templating

Templating is a way to treat a page as a fixed layout that accommodates changing content over time and in different locations. Think of templates as storefronts. Rather than rebuilding every time the store’s inventory (or typical customer) changes, you would simply place the newest or most relevant products in the window displays; the shop sign stays the same, the positions of windows and doors never varies, the paint and window trim rarely (if ever) change, and only to colors strictly prescribed on a short list.

Keeping to the storefront analogy, a set of websites or landing pages can be treated rather like a franchise or chain. No matter where we are in the world, we’ll know we’ve arrived at our favorite restaurant or clothing store because it looks exactly the same in San Diego as it does in New Delhi. So, for example, an entertainment brand with multiple events can simply drop different event info and photos into each of its event sites, which all have identical layouts.

Of course, there is also the idea of the web design template as a saleable product, which many designers have explored as a way to generate additional income, with varying degrees of success. In this case, a template is developed purely for the purpose of purchasing and customizing by others. It’s a jumping-off point, a framework, even a creative spark, that other designers can bend or expand in varying degrees, depending on time, need and inspiration.

The pros of templating

For both business development and design, a smart template system can practically eliminate the cost (and stress) of a full redesign and, in the case of an entertainment brand, fans (and investors) will immediately recognize that the event was organized by the same company.

For content-heavy sites, templating is a way to coral articles and images into databases so that it can be managed by non-designers. Biz dev, marketing, and other departments can contribute their unique knowledge by tagging articles according to their importance to the company, directing it to display where the right audience will see it, at the right time. Content that lives in a database, independent of any particular page, can also be repurposed for multiple uses, and fed to a templated page based on tags and/or categories as needed.

For designers, the process of establishing a template system can be a satisfying web design challenge, because template design carries with it its own set of strategic requirements, such as relating to content in its most abstract form — title, subtitle, synopsis, lead-in, etc. — rather than the concrete, specific content of a single article.

The cons of templating

There’s a dark side to templating. It’s similar to the dangers of an overworked styleguide or brand guidelines document. In a word, the danger is rigidity.

Excessive rigidity is what stalls and stagnates what may have once been a vital brand. Rather than building lively avenues for reaching customers, it erects walls, enforces tense boundaries and stunts potential relationships. Resources that could be spent championing the brand are instead spent policing it.

The same types of things will happen in web design when templating is overused. In a large company, underutilized designers will find themselves in a repetitive rut. From a business point of view, customers will begin to sense a crust forming: a brand that stops shifting, growing and reinventing itself is no longer alive. Reassuring consistency has given way to oppressive repetitiveness.

To be sure, consistency, at its best, is reassuring. Traditionally-minded customers are wary of change, and in industries like finance even moreso. They don’t want an “exciting” experience; they want something that they believe will be exactly the same the day they go to withdraw their cash as it was the day they deposited it.

On the other hand, businesses that are currently emerging — even in finance — have a need to express vitality, currency, and a capacity to quickly adapt in the face of change and adversity.

To template is human

The concept of templates has been around since long before the web, when Bronze Age craftspeople first created molds for forming spear blades. The word itself originates in medieval France: a temple was a device that insured woven cloth would always be the correct width.

As a layout device, templates have saved businesses incalculable sums of money. Printing companies still use stationery and brochure templates to create inexpensive ephemera for small business customers. The template concept has found new meaning with the evolution of blog software, and its accompanying content management systems, which popularized the practice of separating content from page layout.

A good example of a rigid, but successful, template is Sony Pictures’ Movies and Television sections. Everything gets the same treatment: a hero image, a trailer, a media scroller, signup/social links, a synopsis, and top level credits (oh, and an “if you like this, then you’ll like that…” footer). If users want more, a click takes them either to a dedicated, unique website, or the network page for the television show.

Sony Movies (left) and Sony Television (right).

In Sony’s case, this works because the content itself is so varied. Users are exploring crime, supernatural suspense, comedy and more. By the time they click on their second show title, they know what kind of information they can expect and where on the page it will be. The rest is entertainment.

To deviate from a template is also human

What do you do, however, when a show title or other subject needs to break out? In Sony’s case, when budget and popularity have justified it, the title gets its own unique online experience. Designed into the template is a place for a link to an external site. The user gets to decide whether it’s time to experience something different.

Templates are basically a set of design and content decisions that have been made so that they don’t have to be constantly re-made. Deviating from a template means making new decisions: somebody’s got to think. That’s a good thing.

Here are a few examples of how and when it may be time to stop, think, and break the template:

• We have new content that doesn’t fit into the template.
• We have new content that isn’t served by the template.
• The type of content we are getting lately is no longer served by the current template.
• User feedback (in person, via analytics, etc.) is telling us the current template is no longer adequate.

The point is to remain vigilant. This is one of those critical moments where design is so much more than decoration. Change isn’t a maybe: you can count on it.

An interesting case to study is the Coca Cola brand. Poke around on the website. They are definitely templating, but they are also thinking hard about when and where to do things differently. The Food section is structurally the same, but definitely has its own feel. Localized versions of the site introduce their own unique elements. Partner and other external sites (such as the Beverage Institute for Health & Wellness website) may be completely different — the template is gone, but still reflect Coca Cola’s brand values in their aesthetics.

Coca Cola (left), Coca Cola Food (center) and The Beverage Institute for Health & Wellness (right).

Takeaways

The idea that eliminating design will save resources may be a myth. The downside of rigidity is that it makes a thing brittle, and very easy to shatter.

While non-designers can now — and should — be involved in the strategic placement and deployment of content, the most successful templated site designs have ongoing involvement from a solid design team.

If you’ve got some sort of say in the process, consider carving out a bit of space for fresh design opportunities. If you don’t have a decision-making role, there may still be ways to either sound the alarm or inspire some healthy rebellion.

Have you built a brand using templates? Is templating essential in web design? Let us know your thoughts in the comments.

Featured image/thumbnail, storefront image via Shutterstock.

Video Courses: 1500+ WordPress, Joomla! & Drupal Lessons – only $27!

Being able to easily link to content inside mobile apps could make them easier to use and also boost the mobile ad industry.

In the beginning there was the Web, a thicket of virtual pages connected by hyperlinks that enabled blogging to flourish and companies like Google to make piles of money by directing people where advertisers wanted them to go. Today mobile apps increasingly rule our free time and require us to dive into separate, walled-off digital containers that don’t link up.

See if this fits you:

 Eye discomfort and vision problems when viewing a computer screen for extended periods.

Who hasn’t been there? This could apply to many college students, avid gamers, and workaholics on any given day. 

Then according to the American Optometric Association, you could be suffering from Computer Vision Syndrome. This is a group of eye and vision-related problems that result from prolonged computer use.

With symptoms like eyestrain, headaches, and dry eyes, this is one of those conditions where a whole lot of people could likely WebMD self-diagnose themselves.

Try it out… 

Don’t be worried. In the never-ending list of health issues, Computer Vision Syndrome (CVS) is pretty miniscule. There have been no proven links to long-term eye issues like cataracts. 

Still, some of the more severe symptoms include neck and shoulder pain, fatigue, and blurred vision. If you work a job that requires long hours in front of a screen, all of that stress can take its toll. 

Tips to avoid eyestrain include: taking breaks, adjusting monitor and room lighting, and making sure your prescription is appropriate for reading at close distances. 

If you’ve been feeling the strain, read more about how to protect your eyes here.