Yesterday saw me back in our Campfire chatroom, this time with insights and innovation expert Steve Portigal.
We were talking about a subject that I found very interesting – using insights to inform design decisions and innovation. We spend a lot of time talking about how and why to conduct user research, but very little time talking about the specifics of applying the things that we learn from that research.
Steve is Principal of portigal.com – a consultancy which specialises in helping companies discover and act on new insights about their customers and themselves. He is also the author of Interviewing Users: How to Uncover Compelling Insights.
It was a busy session, but Steve absolutely nailed it. A lot of handy resources came out of it, and I’ve listed them below so that you don’t have to sift through the transcript to find them.
When to Use Which User-Experience Research Methods Christian Rohrer
Championing Contextual Research in your Organization Steve Portigal
Well, We’ve Done All This Research, Now What? Steve Portigal
Fons Trompenaars’ Global Cultures Model
Steve’s obligatory Star Wars reference Kobayashi Maru
Dollars to Donuts Steve’s podcast (with transcripts)
If you didn’t make the session because you didn’t know about it, make sure you join our community to get updates of upcoming sessions. If you’re interested in seeing what we discussed, or you want to revisit your own questions, here is a full transcript of the chat.
|
Twitter
Google+
The post Transcript: Ask the UXperts:Using Insights to Inform Design & Innovation—with Steve Portigal appeared first on UX Mastery .  by Sarah Hawk via UX Mastery |
As a JavaScript developer, I’m sure you’ve already been falling into this scenario: something goes wrong with the production version of your code, and debugging it directly from the production server is a nightmare simply because it has been minified or has been compiled from another language such as TypeScript or CoffeeScript.
The good news? The latest versions of browsers can help you solve this problem by using source map. In this tutorial, I’ll show you how to find Source Maps in all of the browsers and get the most out of those few minutes you have to debug.
According to the great Introduction to JavaScript Source Maps article, source map is “a way to map a combined/minified file back to an unbuilt state. When you build for production, along with minifying and combining your JavaScript files, you generate a source map which holds information about your original files”.
Please don’t hesitate to read Ryan Seddon’s article first as it goes in great details on how source map works. You’ll then learn that source map uses an intermediate file that does the matching between the production version of your code and its original development state. The format of this file is being described here: Source Map Revision 3 Proposal
Now to illustrate, I’m going to share the way we’re currently working while developing our WebGL Babylon.js open-source framework: http://ift.tt/1aUDteS. It’s written in TypeScript. But the principles will remain the same if you’re using plain JavaScript compressed/minified or other languages such as CoffeeScript.
Let’s now play with the source map magic directly in the browsers.
Recently, I’ve been implementing the support of the Gamepad API in our gaming engine. Let’s use its code for this tutorial.
In this article, I’m using the following browsers:
Navigate to this URL: http://ift.tt/1EUSJc5 and you’ll see this page:
Plug an Xbox 360 or Xbox One controller in the USB port of your machine. Press the A button to activate the gamepad and play with it:
But don’t worry, you won’t need a gamepad controller to follow this tutorial.
Note: The TypeScript compiler is automatically generating the source map for you. If you’d like to generate a source map while generating your minified version of your code, I would recommend using Uglify JS 2: http://ift.tt/MWUf1D
For this article, I even mixed both. I’ve minified the JS generated by TypeScript and kept the source mapping intact using this command line:
uglifyjs testgamepad.js -o testgamepad.min.js --source-map testgamepad.min.js.map --in-source-map testgamepad.js.map
Once the gamepad test page has loaded, press F12 in IE11.
You’ll see that the HTML source is referencing 2 JavaScript files: babylon.gamepads.js at the beginning of the page & testgamepad.min.js at the very end. The first file is coming from our framework on Github and the second one a simple sample showing how to consume it.
Continue reading %Enhance Your JavaScript Debugging with Cross-Browser Source Maps%
I was quite surprised when Microsoft announced that Internet Explorer — the Microsoft browser that has been around for nearly two decades — was going to be replaced by a browser then code-named Project Spartan (the browser’s final name, Microsoft Edge, was just revealed, so I’ll use that name for the rest of the article). […]
Continue reading %Microsoft Edge: A Hands-on Preview%
Maps have become an integral part of our daily lives. They provide directions, help us plan trips, find establishments, visualize data trends and share experiences. Using a map on your website is a great way to help visitors find your business, and provide relevant information based on a user’s location. You can also create applications that present your content in a manner that keeps visitors engaged and coming back to your site.
In this lesson, Robert will walk you through how to setup and configure your first map using the Google Maps API. The lesson includes sample code, so you'll be able to take what you've learned and start creating a map to include in your website. This is a sample lesson from the Learnable course Introduction to Google Maps API available now. As part of the course, we will be creating an interactive visualization to help you apply what you've learned.
Continue reading %Your First Google Map%
A secondary content panel that folds flat, powered by CSS Transformations and jQuery.
Throughout this tutorial I will be outlining how you can leverage the jQuery Interactions libraries to create more interactive and easy to manage admin areas and elements.
We will start off with an explanation of what these interactions are along with a summary of the three main libraries we will be using; dragable, dropable and sortable.
After we have the basics of these libraries I will show you how they can be used in a real world situation to extend your administration areas and create interactive zones.
jQuery Interactions are a collection of different libraries that have been created to abstract away some of the fundamental difficulties of building interactive interfaces.
These scripts are part of the jQuery UI (user interface) family and handle interactions such as dragging, dropping and sorting; with these libraries we can create complex functionality without the need of reinventing the wheel.
Continue reading %Using jQuery Interactions in Your WordPress Admin%
Personal site of Craig Jamieson, an independent design professional from Johannesburg, South Africa.
NECjAR Better worlds start with us. Create timeless interactive entertainment that makes positive change to the human psyche worldwide. Nectar makes everything better.
Choosing the right payment solution for your app could be tricky, especially if you're running a global marketplace. The prospect of dealing with country-specific regulations is not something I look forward to while getting on a new project. Also, there is a lot of boilerplate that you have to handle to get recurring billing to work. Stripe seems to understand the pain thousands of developers face every day and solves it pretty well. In this article, I will demonstrate how to integrate Stripe into your Rails app. Read on.
Before we begin, you will need a Stripe API key. You can obtain one by signing up with Stripe with your bank details. There are two different set of keys, one for your test and one for production.
Let's begin by setting up the Stripe client. Add this to your Gemfile:
[ruby] gem 'stripe', :git => 'http://ift.tt/1lJK0yH' [/ruby]and bundle install.
Once you are done installing your dependencies, you need to setup your API keys. In production, you would store these keys in an environment variable and take it out of the codebase. But for brevity's sake, I'm going to set them in an initializer. Kindly refrain from throwing pitchforks at me... :)
[ruby] # config/initializers/stripe.rb #todo remove the key info from this file and have env variable #todo recreate new API keys when do that if Rails.env == 'production' Rails.configuration.stripe = { :publishable_key => MY_PUBLISHABLE_KEY, :secret_key => MY_SECRET_KEY } else Rails.configuration.stripe = { :publishable_key => TEST_MY_PUBLISHABLE_KEY, :secret_key => TEST_MY_SECRET_KEY } end Stripe.api_key = Rails.configuration.stripe[:secret_key] [/ruby]With that out of the way, let's setup our payment page.
Continue reading %Stripe Subscriptions in Rails%
Are you interested in setting up a Facebook page for your business? Not sure where to start? Maybe you’ve thought about it but didn’t get past choosing a category or creating a cover photo. If you’re considering setting up a Facebook page, or have started the process but never finished, this article is for you. […]
This post How to Set Up a Facebook Page for Business first appeared on Social Media Examiner.
Social Media Examiner - Your Guide to the Social Media Jungle
The average web page has nearly doubled in size since 2010. While this might not come as a surprise to any of us, there is certainly plenty that we can do to scale back the weight of our web pages.
One of my favourite ways to prevent page bloat is to treat everything as a resource that doesn’t need to be on the page until the user has to interact with it. The technique is called lazy-loading, and can be performed on almost any asset. It’s especially good for responsive websites, when the same content needs to be loaded across multiple devices, while still loading as quickly as possible. Let’s take a look at a few ways to make this possible.
The key to lazy-loading these assets is to leave the html structure in tact, while deferring their src attributes until absolutely necessary.
Let’s take a regular image that hasn’t been adjusted for lazy-loading.
<img src="myimg.png" alt="a picture of bacon or something">
In order to lazy-load this image, the first thing we need to do is address the src attribute, so that the DOM won’t grab the asset immediately. To do that, we’ll change the src attribute into a data attribute. <img data-src="myimg.png" alt="a picture of bacon or something">. If we need to lazy-load a responsive image, our snippet will end up looking something like this: <img data-src="myimg.png" dta-srcset="img1.png 320w, img2.png 640w, img3.png 1280w" data-sizes="(min-width: 33em) 75vw, 100vw" alt="a picture of bacon or something">. One thing to note is that while the sizes attribute is not responsible for loading images, it still needs to be lazy-loaded with the src and srcset attributes. This is because if the sizes attribute is present before any of the image assets, the browser will not load the correct image. A side effect of using this technique is that images won’t initially have a width or height, unless they are set beforehand using css or width and height attributes in the HTML.
Lazy-loading video assets can be a little bit tricky. While my initial approach was to do something like this – <video data-src="videofile.mp4"</video> – I found that when the src attribute is added, the video won’t function correctly in all browsers. In order to fix this, a slightly more difficult solution is needed. What does end up working is adding <source> tags in between the opening <video> tags as soon as the video is needed.
Lazy-loading an audio resource is much more like an image, in that all that is needed is to change a data attribute into a source attribute when the resource is needed. Don’t forget to ensure that the controls attribute is present in the audio tag, or else nothing will show up when the tag is present on the page. Here is an example.
Every now and then a third party widget needs to be present on a page. These can be things like photo galleries, social networking feeds, comment systems, and ads. Resources like these can often add to initial page load time, with extra requests and heavy files needed to render the widget. In order to prevent widgets from slowing down the site, we’ll want to lazy-load them in whenever possible. This usually means wrapping the entire widget inside of a script tag, and dropping its contents inside of an empty container just before the asset is needed.
Now that we’ve gone over a few use cases for lazy-loading, let’s take a look at how we can use javascript to tell us when an element needs to be ready and visible to the user.
To do this we’ll be using the getBoundingClientRect() method, which will return an elements size and position relative to the viewport. We’ll attach this to a scroll event listener so that when the user is scrolling we can fire an event to tell us that the element is visible in the viewport. It’s important to remember not to run too many calculations inside of a scroll event listener, since this will lead to performance bottlenecks.
For this demonstration, we’ll be loading an image when it is visible in the users viewport.
See the Pen Lazy-loading an image by Tim (@tevko) on CodePen.
The PolyFill is being included in order to provide support for custom events in IE. We’re also using requestAnimationFrame() which will help to keep a high frame rate while we scroll, allowing for a smooth scrolling experience.
Once the custom event has fired, the notCalled variable is set to false, preventing the checkViewport function from being called needlessly.
While you now have a few techniques aimed at making your websites lighter, faster, and all around easier to use, remember that performance is a constant battle, and there are several other ways to make your site perform better for all devices.
Resources
– CustomEvent API
– requestAnimationFrame API
The post Don’t Load it till it’s Needed appeared first on Web Design Weekly.
The York University/Sheridan College Honors Bachelor of Design Program presents YSDN MADE
Pogo Slider is a jQuery plugin that allows you to create animated image/content sliders. CSS animations are used to transition between slides. A CSS animation can be triggered on element within a slide, after the slide transitions in, and as the slide transitions out.
The post Pogo Slider : jQuery Animated Slider Plugin appeared first on jQuery Rain.
We have something special for all of our readers today. We made a small JavaScript application that conforms to Google’s Material Design Guidelines. It consists of three parts – an alarm clock, a stopwatch and a timer. The application is responsive and has a bunch of subtle animations that react to user input.
We use the modern Materialize framework, together with jQuery, jQuery Timepicker and Hammer.js for touch events. Materialize turns the plain looking standard HTML input fields into these awesome Android-like switches and check boxes. It also adds the the on-click wave ink effect as it has Waves.js included in it’s package.
The post Material Design Stopwatch, Alarm and Timer with jQuery appeared first on jQuery Rain.
If you are working for analytics project, you need a rich chart system to display big data results. Google is providing us a powerful chart tools that you can implement charts very simple, this tutorial will explain you how to implement Google charts with Jquery ajax JSON data. Try out there are many free interactive charts and data tools, take a quick look at this live demo.
The post Google Charts with jQuery Ajax appeared first on jQuery Rain.
EasyAutocomplete is a jQuery autocomplete plugin. It's main objective is to be user friendly for javascript developers.
While designing Babylon.js v2.0 (a library for building 3D on the web), I recently found myself wishing that more APIs were fluent – that is, I wish the community could more easily read, understand, and build upon the work while spending less time in the tech docs. In this tutorial, I’ll walk through Fluent APIs – what to consider, how to write them, and cross-browser performance implications.
A fluent API, as stated by this Wikipedia article, is an implementation of an object-oriented API that aims to provide for more readable code. jQuery, for example, is a great example of what a fluent API allows you to do:
[code language="js"] $('') .html("Fluent API are cool!") .addClass("header") .appendTo("body"); [/code]A fluent API lets you chain function calls by returning the this object.
We can easily create a fluent API like this:
[code language="js"] var MyClass = function(a) { this.a = a; } MyClass.prototype.foo = function(b) { // Do some complex work this.a += Math.cos(b); return this; } [/code]As you can see, the trick is just about returning the this object (a reference to the current instance in this case) to allow the chain to continue.
If you are not aware of how the this keyword works in JavaScript, I recommend reading this great article by Mike West.
We can then chain calls:
[code language="js"] var obj = new MyClass(5); obj.foo(1).foo(2).foo(3); [/code]Before trying to do the same with Babylon.js, I wanted to be sure that this would not generate some performance issues.
So I did a benchmark!
Continue reading %JavaScript like a Boss: Understanding Fluent APIs%
Right out of the box, one of the simplest things you can do with the Meteor JavaScript framework is to create a user accounts system. Just install a pair of packages — accounts-password and accounts-ui — and you'll end up with the following, fully-functional interface: 
accounts-password package by executing the command:
Continue reading %Creating a Custom Login and Registration Form with Meteor%
|
|
Weekly
Peter Cooper recommends
Holly Schinsky recommends
Brian Rinaldi recommends