Note: Although we say this post will show you how to use Visual Studio to write AngularJS applications and unit tests, you can use these methods to configure test environments for any IDE.  

To write unit tests I will use jasmine, to run them I’ll use karma, and to create proxies of AngularJS components like filter, controller, and service, I’ll use ng-mock. In this post we will cover the following topics:

• Setting up the development environment
• Setting up the test environment for jasmine
• Setting up the karma test runner environment
• Writing the unit test for filter, controller, and service

We will use npm to install dependencies and Visual Studio to write code, and we’ll run tests using karma from the command prompt. At the end of the post, we should have tests running as shown in the image below:

So let’s get started!

Step 1

Create an ASP.NET Web Application project in Visual Studio by choosing the Empty template project type.

Even though I am creating an AngularJS project in Visual Studio, you can create project using any IDE of your choice. The only thing you need to keep in mind is that all commands we will run here should be executed inside the root folder of the project.

Step 2

Once the project is created, launch the command prompt as an admin and change the directory to the root folder of created project folder. In the case of Visual Studio, change the directory to the project folder, not the solution folder.

For example, the folder structure I am using is as follows:

• AngularJSUnitTestDemo : Solution Folder
• AngularJSUnitTestDemo : Root folder of project. So, we navigated here.

 Step 3

We need to make sure that NodeJS is installed on the machine. If it is not installed, download and install it from https://nodejs.org/en/. We can verify whether NodeJS is installed or not by running the following command:

• node --version 

If we get NodeJS version as output, then NodeJS is installed on the machine.

In this step, we installed and verified NodeJS.

Step 4

Next, let’s install AngularJS to the project. There are various ways to do so (NuGet package, Bower etc.), however, I am choosing NPM to install AngularJS in the project. To install, run the npm command as shown below:

•  npm install angular --save

In this step, we have installed AngularJS to the project.

Step 5

Now we are going to use Karma test runner to run tests.  Learn more about Karma here: https://karma-runner.github.io/1.0/index.html Created by the Angular team, Karma is a spec-based test runner. To install Karma, run the command as shown below:

•  npm install -g karma --save-dev

In this step, we have installed Karma in the project.

Step 6

We are going to use Jasmine, behavior driven JavaScript Test framework to write Unit Tests. Learn more about Jasmine here:  http://jasmine.github.io

We will install Jasmine Core and Jasmine Karma. To install them run the command as shown below:

• npm install karma-jasmine jasmine-core --save-dev

 In this step, we have installed the jasmine core and the jasmine karma plugin in the project.

Step 7

We will use the ngMock module to mock up AngularJS services, modules, controllers, filters and more. To use ngMock, we need to install the angular-mocks library in the project. To do so, run the command as shown below:

• npm install angular-mocks --save-dev

 In this step, we have installed angular-mocks library in the project.

 Step 8

Karma allows us to run tests in multiple browsers. To do so, we need to install different browser plugins. In this example, I’d like to run a test in Chrome, so I’ll go ahead and install a Chrome browser plugin as follows:

• npm install karma-chrome-launcher --save-dev

In this step, we have installed the Chrome browser karma launcher. If you wish, you can install other browser launchers too.

Step 9

We can have any folder structure for the project adhering to our business requirements. However, for the purpose of this post, I am going to keep it simple. I will create two folders: app and tests. The app folder will keep all Angular scripts files and the tests folder to keep all the tests. To create these folders,  run the commands as shown below:

• md app
• md tests

 Step 10

This step is only required if you are working in Visual Studio, otherwise you can skip this step. We are going to add all newly installed files and newly created folder in the project. Go back to Visual Studio.

In this step we have included all of our newly created files and folders in Visual Studio project.

 Step 11

In this step, we are going to add new files to the project:

• CalculatorApp.js to write AngularJS code. Add this file in app folder.
• CalculatorAppTest.js to write unit tests for controller, filters, services written in CalculatorApp.js. Add this file in tests folder.
• SpecRunner.html to display test results in browser using jasmine
• Index.html, html page of the application.

To add files in Visual Studio,

• Right click on the project/ app folder and add a file called CalculatorApp.js
• Right click on the project/tests folder and add a file called CalculatorAppTest.js
• Right click on the project and add an HTML file called SpecRunner.html
• Right click on the project and add an HTML file called index.html

In this step, we have added new files to write code, unit test and display test results.

Step 12

In this step, we will setup SpecRunner.html. This will render test results in the browser. So, open SpecRunner.html and add the following references.

Jasmine Test Results<metacharset="utf-8"/><linkhref="node_modules/jasmine-core/lib/jasmine-core/jasmine.css"rel="stylesheet"/><scriptsrc="node_modules/jasmine-core/lib/jasmine-core/jasmine.js"></s cript><scriptsrc="node_modules/jasmine-core/lib/jasmine-core/jasmine-html.js"></s cript><scriptsrc="node_modules/jasmine-core/lib/jasmine-core/boot.js"></s cript><scriptsrc="node_modules/angular/angular.js"></s cript><scriptsrc="node_modules/angular-mocks/angular-mocks.js"></s cript><scriptsrc="app/CalculatorApp.js"><scriptsrc="tests/CalculatorAppTest.js"></s cript>

Step 13 - Writing Tests for AngularJS filter

Finally, we have reached to step in which we will write some tests! Let’s start by writing tests for the AngularJS filter. Add following test to CalculatorAppTest.js.

describe('Calculator App Tests', function () {

    beforeEach(module('MyApp'));

    describe('reversestringfiltertest', function () {var reverse;
        beforeEach(inject(function ($filter) { //initialize filter
            reverse = $filter('reverse', {});
        }));

        it('Should reverse a string', function () { 
            expect(reverse('india')).toBe('aidni'); //pass test
            expect(reverse('don')).toBe('don'); //fail test
        });

    });


});

In the above code snippet, we are creating a proxy of the module and filter using ng-mock. We have written tests for the filter name ‘reverse’ from module ‘MyApp’ and we are injecting the filter using the $filter service of ng-mock.

At this point, if we go ahead and run the SpecRunner.html, we will get a failed test result because we have not created the AngularJS filter or the ‘MyApp’ module.

So now let us go ahead and create an AngularJS Module ‘MyApp’ with filter ‘reverse’. We will create these in the App/CalculatorApp.js

var MyApp = angular.module("MyApp", []);

MyApp.filter('reverse', [function () {returnfunction (string) {return string.split('').reverse().join('');
    }
}]);

Now go back and run once again, run SpecRunner.html. We will find, once again test is failed. As it is showing in test failure message that – Expected ‘nod’ to be ‘don’

 If you remember, we deliberately wrote a failed test. So now let’s go ahead and fix the test in CalculatorAppTest.js

describe('Calculator App Tests', function () {

    beforeEach(module('MyApp'));

    describe('reversestringfiltertest', function () {var reverse;
        beforeEach(inject(function ($filter) { //initialize filter
            reverse = $filter('reverse', {});
        }));

        it('Should reverse a string', function () { 
            expect(reverse('india')).toBe('aidni');
            expect(reverse('don')).toBe('nod'); 
        });

    });


});

When we run the test in SpecRunner.html, we’ll find all tests are passed as shown in the image below.

In this step, we wrote a test for AngularJS filter and ran that using Jasmine SpecRunner.html.

Problems in running test using SpecRunner.html

You may have noticed the only problem in the approach above is that each time we change the test code or source code, we need to go back and either load SpecRunner.html again or refresh it manually to see the updated test result. In real project development, this could be a pain. We need a mechanism in which whenever the code changes, tests should be executed automatically. To do this, we have test runner. We have already installed the Karma test runner to automatically run tests whenever code changes, so now let’s configure it to do that.

Step 14

To configure Karma, we need to run command Karma init.

• karma init

You will be prompted with many questions to answer, use the following answers as displayed below:

Karma.cnf.js file has been created after answering those questions. Next, let us open Visual Studio and include the newly created file Karma.conf.js in project.  Open Karma.conf.js and add references of Angular and Angular Mock. Your Files sections should look like the image below:

files: ['node_modules/angular/angular.js','node_modules/angular-mocks/angular-mocks.js','app/*.js','tests/*Test.js'
    ],

Next go back to command prompt and run the command

•  karma start

As soon as we run the karma start command, tests will start executing and we can see test results on the command prompt as shown in the image below.  As you change the code and save the file, the test will be executed automatically.

Step 15

Now let’s write a unit test for the AngularJS Controller. Add the following test to CalculatorAppTest.js and add a test for the controller below to the filter test or below the filter test describe.

describe('addcontrollertest', function () {var $controller;
        beforeEach(inject(function (_$controller_) {
            $controller = _$controller_;
        }));
        it('1 + 1 should equal 2', function () {var $scope = {};var controller = $controller('CalculatorController', { $scope: $scope });
            $scope.num1 =1;
            $scope.num2 =2;
            $scope.add();
            expect($scope.sum).toBe(3);
        });
    });

We are creating a proxy of the controller and injecting that using ng-mock $controller service.  Once the controller is injected, take the reference of CalculatorController (controller in the test here) and calling the add method.  At this point the test will fail, since we have not written controller yet.  Karma is giving the failure message that CalculatorController is not a function.

Next let us go ahead and write the controller in the ‘MyApp’ module.

MyApp.controller('CalculatorController', function ($scope) {

    $scope.add =function () {
        $scope.sum = $scope.num1 + $scope.num2;
    }
});

As soon as we save the CalculatorApp.js file after writing the controller, the test will pass as shown in the image below:

Step 16: Testing AngularJS Factory with local data  

Let us say that we have created an AngularJS service using factory method name PlayerLocalApi. This service is returning local data which is hard coded as of now. The Service is created as shown in the listing below:

MyApp.factory('PlayerLocalApi', function () {//var data = [{ "Name": "Dhananjay Kumar", "Age": 33.0 }];var data = [{ "Id":"1", "Name":"Dhananjay Kumar", "Age":33.0 }, { "Id":"2", "Name":"Sachin Tendulkar", "Age":22.0 }, { "Id":"6", "Name":"rahul dravid", "Age":60.0 }];var PlayerLocalApi = {};
    PlayerLocalApi.getPlayers =function () {return data;
    }return PlayerLocalApi;
});

We can write a unit test to test the service as shown in the listing below:

describe('playerservicetest', function () {var data = [{ "Id":"1", "Name":"Dhananjay Kumar", "Age":33.0 }, { "Id":"2", "Name":"Sachin Tendulkar", "Age":22.0 }, { "Id":"6", "Name":"rahul dravid", "Age":60.0 }];var PlayerLocalApi = {};

        beforeEach(inject(function (_PlayerLocalApi_) {
            PlayerLocalApi = _PlayerLocalApi_;
        }));
        it('should return search player data', function () {
            expect(PlayerLocalApi.getPlayers()).toEqual(data);

        });

    });

In the above code snippet, we are injecting the service PlayerLocalApi and then calling getPlayers on that. Also, we have exact test data to test the data returns from the service. This test will pass.

Just to make sure that we have written the test correctly, go back to service and comment the second data and uncomment the first data so the modified service is as listed below:

MyApp.factory('PlayerLocalApi', function () {var data = [{ "Name":"Dhananjay Kumar", "Age":33.0 }];//var data = [{ "Id": "1", "Name": "Dhananjay Kumar", "Age": 33.0 }, { "Id": "2", "Name": "Sachin Tendulkar", "Age": 22.0 }, { "Id": "6", "Name": "rahul dravid", "Age": 60.0 }];var PlayerLocalApi = {};
    PlayerLocalApi.getPlayers =function () {return data;
    }return PlayerLocalApi;
});

Now the service is returning data which is not the same as test data in the test so we will get a failed test as shown in the image below:

And that’s how to write unit tests for services returning local data.

Conclusion

In this post we covered a lot! We learned how to:

• Set up a development environment
• Set up a test environment for jasmine
• Setup a karma test runner environment
• Write unit tests for filter, controller, and service

In further posts, we will see how to write unit tests for $http, $q services etc. I hope you find this post useful. Thanks for reading!

Being able to generate (apparently) random numbers is an essential requirement for many areas of math, statistics, the sciences, technology and gaming. For instance, they can be used to assign participants to a group in a randomized controlled trial, to determine the output of a computer game or to find approximate solutions to otherwise intractable problems. I frequently use random numbers to check my solutions to perfectly tractable statistical problems too. Cryptographic random number generators, which we won't cover here, can be used in security.

Types of Random Number Generator

For the purpose of this article at least, we can think of there being three categories of random-number collection:

• "True" random numbers;
• Pseudorandom numbers;
• Quasirandom sequences.

True (or hardware) random number generators (TRNGs) use real-world physical processes believed to be random in nature to create streams of numbers. Decay events from a radioactive source, for example, are random and uncorrelated with each other, atmospheric noise can also be used.

TRNGs often aren't practical or convenient (or necessary) for many purposes. A far more common alternative is to create a stream of numbers that appear to be randomly distributed over some interval using a computer algorithm. These algorithms are not truly unpredictable and so are referred to as pseudorandom number generators (PRNGs).

Finally, quasirandom sequences are a finite collection of numbers that are meant to be representative of a sample space in some way. For example, the mean of the sequence may be the same (or very similar to) the known mean of the population. While quasirandom sequences are interesting and can be useful, they're not the focus of this article and won't be discussed further.

The Standard Uniform Distribution

Generally, the output of a large number of values from a pseudorandom number generator is meant to approximate the standard uniform distribution (SUD) that covers the range 0 to 1. There is, however, some variation in whether either/both of the end points are included. In the conceptual world of the mathematics of continuous distributions there is basically no difference between the uniform distribution between [0,1] (includes 0 and 1) and the uniform distribution between (0,1) (excludes 0 and 1). In the real world of floating point numbers, with only a finite number of possible values between 0 and 1, the difference is real and could potentially be problematic. One might, for example, want to use the generated number inside the natural logarithm function Math.log.

Generating a random number for another distribution is usually "just" a matter of using one or more numbers from an SUD PRNG to produce an appropriate value from the distribution of interest. Depending on the desired final distribution, this might involve one line of code or something quite complex. For the rest of this article I will stick to discussing the generation of numbers from a SUD PRNG.

Period

A useful PRNG must have a large period, which is to say that it must be able to output a large number of numbers without repeating itself. For example, the Wichmann Hill PRNG of 1982 (more on this later) has a period of nearly 7 trillion numbers, while the exceedingly popular Mersenne Twister PRNG has a period of 2¹⁹⁹³⁷− 1 numbers. The former is considered quite short by modern standards.

What's wrong with Math.random?

You may use JavaScript's built-in Math.random regularly and have no problems with it. It does, however, have one big limitation: its output is not reproducible. Run code that utilizes Math.random again and again and you'll get a different set of results each time. In many cases that really isn't a problem. In fact in many (most, probably) cases it'll be exactly what you want. Unpredictability (to a human sat staring at the output at least) is exactly what is required. But sometimes we do want to see the same set of results.

Moving away from JavaScript for a moment, consider running a simulation experiment for a piece of work you wish to publish. Perhaps you're using C++ or Java or R or... You want your results to be reproducible. These languages (and many others besides) offer a way of "seeding" the initial state of their PRNGs. You set the seed in some way or other and you get the same sequence of "random" numbers out. Math.random requires a seed too, there's just no way of setting it yourself. The specification for Math.random is also fairly open-ended, allowing browser vendors to use "an implementation-dependent algorithm" so long as the output is approximately uniform over the range [0,1).

From a personal perspective, I'm a big fan of browser-based interactive data visualization for communicating both data and concepts. This could include simulation; there are limits to what is practical in a browser but web workers can help. Simulation frequently requires random numbers. If the random numbers are not reproducible then the conditions for a simulation can't be re-run. There are plenty of other use cases too, such as a repeatable animation, and JavaScript isn't just the programming language of the browser any more.

Problematic PRNGs

Up until now I've skipped over how uniform-distribution PRNGs work. It's all been something of a black box: you call a function one or more times, possibly setting a seed, and then some pseudorandom numbers come out. The problem is that creating a good PRNG is difficult. There are thousands of papers on the topic and multiple methods. And multiple instances where people who know much more about this topic than I appear to have got things wrong. For instance...

RANDU

RANDU is a "linear congruential generator" (LCG) developed by IBM in the 1950's. LCG's use a recurrence relation of the following form to generate new pseudorandom numbers:

In the case of RANDU, c is 0, a is 65,539 and m is 2³¹. Because c is 0, RANDU is a member of a subset of LCG's called "multiplicative congruential generators" (MCG). To get a number in the range 0 to 1 (as is desired for a replacement for Math.random), one just needs to divide the result of the RANDU recurrence relation by m. A JavaScript implementation (which you definitely shouldn't use!) could look something like this:

var randu = function(seed){"use strict";
   if(!isFinite(seed)){
      throw new Error("Seed not a finite number");
   }
   var x = Math.round(seed);
   var a = 65539;
   var m = Math.pow(2, 31);

   if(x<1 || x≥m){
      throw new Error("Seed out of bounds");
   }

   return function(){
      x = (a*x)%m;
      return x/m;
   };
    
};

The parity of the value generated by the recurrence relation in RANDU never changes. That is to say, an odd seed gives rise only to odd values of x while an even seed gives rise only to even values of x. This isn't exactly a desirable property, but there are bigger problems.

The period of an LCG is at most m, but for RANDU it is much less than that and depends on the parity of the seed. For odd seeds it's over 536 million but for even seeds it can be as little as 16,384.

There's another reason not to bother with an even seed: One common, simple method for assessing the randomness of a generator is to plot pairs of successive values as a scatterplot. A good PRNG should fill a 1-by-1 square fairly evenly. With 10,000 random numbers, 5,000 points, and a seed of 1 everything looks reasonable. (You can think of "x" as referring to the values in even-index positions in an (0-indexed) array of 10,000 random numbers. That is indices 0, 2, 4, 6... 9,996, 9,998. Points on the scatter plot are made by matching up with the next odd-index (1, 3, 5, 7... 9,997, 9999) "y" value.)

With some even seeds we something quite different. Below is a scatterplot for the seed 32,768.

Clearly we don't just have a deficit of points in the case of even seeds. In some cases, we have unambiguous relationships between neighboring values.

It would be simple enough to adapt the randu function above to reject even seeds, giving an appropriate error message. Unfortunately, odds seeds show structure too. To see this we just need to extend the scatterplot idea to three dimensions by looking at triplets of successive random numbers. 3D scatter plots are frequently pretty useless. RANDU data provides something of an exception to this rule. (Here the indices for "x" values are 0, 3, 6, 9... 9,993, 9,996, the indices for "y" values are 1, 4, 7, 10... 9,994, 9997 and the indices for "z" values are 2, 5, 8, 11... 9,995, 9,998.)

Rather than fill the box roughly evenly, triplets of numbers all lie in one of 15 planes, regardless of the seed! (Actually, for the even seed 32,768 it's worse than this.) We can compare this with results from Math.random (I used Chrome for this); the difference is stark.

One general problem with 3D scatterplots is that the visibility of structure in the plot can depend on the viewing angle. From certain angles the structure in RANDU plot is hidden. This could be the case for Math.random. To help with this issue I created an interactive version that lets you choose a PRNG (and, where appropriate, one or more seeds) and visualizes the results using WebGL. This demo can be found here and the box of random numbers can be rotated (using the mouse) and viewed from different angles. I've yet to find any obvious signs of structure when using Math.random across a number of browsers (Chrome, Firefox, Maxthon, IE, Edge and Opera on the desktop and Safari on iOS).

The appearance of lattice structures in 3 or more dimensions exists for all MCG's, but it is particularly bad for RANDU. It has been known about since the 1960's. Despite this, RANDU was still used in the 1970's and some simulation results from that era should, perhaps, be viewed with skepticism.

Excel

You may be wondering whether problems with PRNG's were confined to the 1960's and '70's? The short answer to this question is "no". After criticism of it's old random number generator, Microsoft changed to the Wichmann–Hill PRNG for Excel 2003. The WH generator (first published in 1982) combines three MCG's to overcome some of the shortcomings of single MCGs (such as a relatively short period and the lattice planes and hyperplanes seen when looking at groups of neighboring values). A quick JavaScript implementation of WH could look like the following:

var wh = function(seeds){"use strict";

   if(seeds.length<3){
      throw new Error("Not enough seeds");
   }

   var xA = Math.round(seeds[0]);
   var aA = 171;
   var mA = 30269;

   var xB = Math.round(seeds[1]);
   var aB = 172;
   var mB = 30307;

   var xC = Math.round(seeds[2]);
   var aC = 170;
   var mC = 30323;
   
   if(!isFinite(xA) || !isFinite(xB) || !isFinite(xC)){
      throw new Error("Seed not a finite number");
   }

   if(Math.min(xA,xB,xC)<1 || xA≥mA || xB≥mB || xC≥mC){
      throw new Error("Seed out of bounds");
   }  

   return function(){
      xA = (aA*xA)%mA;
      xB = (aB*xB)%mB;
      xC = (aC*xC)%mC;
      return (xA/mA + xB/mB + xC/mC) % 1;
   };
	  
};

Again we can look for structure when plotting sets of neighboring values in two or three dimensions:

While this clearly isn't sufficient to say whether or not we have a good random number generator, the plots above at least look reasonable. (You can also check the three-dimensional box in the WebGL demo mentioned above.) However, the original implementation of the WH algorithm for the RAND function in Excel occasionally spat out negative numbers!

The WH algorithm fails a number of more modern and stringent tests of PRNGs and it seems Microsoft has moved on to using the popular (but rather more complex) Mersenne Twister algorithm.

V8

Earlier I used output from Chrome's implementation of Math.random to illustrate what the distribution of triplets of random numbers should look like when plotted as a three-dimensional scatterplot. However, the algorithm that was used by V8, Chrome's JavaScript engine, was recently shown to be flawed. Specifically, it reproduced the same "random" character strings with far higher frequency than it should have, as this long but informative article describes. V8 developers promptly changed the algorithm used and the issue seems to have been fixed in Chrome since version 49.

Speed

Another consideration before you try to "grow your own" JavaScript PRNG is speed. One should expect Math.random to be highly optimized. For example, some very rough tests using several browsers showed Math.random to be ~3 times quicker at producing 100,000 random numbers than the simple WH implementation above. Having said this, we're still talking of the order of just tens of milliseconds (at least in Chrome and Firefox on my laptop) so this may not be a bottleneck, even if you do require a large number of random numbers. Of course, more complex PRNGs with better statistical properties may be slower.

Conclusions

I've barely touched the surface here. I've only looked at a couple of simple PRNGs and showed that they can still be problematic. There are far more complicated algorithms for PRNGs out there, some that have passed a large number of quite stringent statistical tests. And some of these already have open source JavaScript implementations.

If you don't need reproducibility, Math.random may be just fine for all your random number needs. Either way, if reliability of your random number generator is critical to how your site functions then you should perform relevant checks. In the case of Math.random this means checking in all target browsers since the JavaScript specification does not specify a particular algorithm that vendors must use.

Try our JavaScript HTML5 controls for your web apps and take immediate advantage of their stunning data visualization capabilities. Download Free Trial today.

The popularity and impact of data visualizations has increased dramatically over a relatively short space of time. Google Trends shows a near 100% increase in search frequency for data visualizations since 2009, and we have seen a multitude of tools and software become available, allowing almost anyone to create data visualizations with relative ease.

We are instinctively more drawn to images than text, as the brain is able to process images at a far quicker rate. However, this doesn’t mean you can just throw together a mass of images and shapes onto a dashboard and expect to wow your audience. Much like the cognitive aspects behind our attraction to images, there are other inherent – and to some extent, subconscious – behaviors that become relevant. One of those is first impressions.

We all know the saying: first impressions last a lifetime. But how much truth is there behind it? Well, as it turns out; quite a lot. Similar to the instinctive fight or flight response, humans perform an act of unconscious thinking called rapid cognition; more instinctual and quicker than the deliberate decision-making style of thinking we are accustomed to. Rapid cognition is our ability to dig deeper and gauge what is really important from a very short experience. As much as we’re told to never judge a book by its cover, this ability to rapidly parse through large amounts of information and decide what’s most important without engaging in slower, more rational ways of thinking is something we do every day.

Psychologists call the phenomenon ‘thin-slicing’: perceiving details or information within seconds that might take months or years of evaluation with the rational part of the mind. Malcolm Gladwell describes it as the following:

“Thin-slicing is not an exotic gift. It is a central part of what it means to be human. We thin-slice whenever we meet a new person or have to make sense of something quickly… …we come to rely on that ability because there are lots of situations where careful attention to the details, even for no more than a second, can tell us an awful lot.”

The good news is, you’re able to change and disprove any false first impressions someone may have of you as they get to know you. Online, however, this is much more difficult as our attention spans are at record lows. With it being more difficult than ever to arrest your reader’s attention, you can’t afford to let bad first impressions get in the way of your data visualizations – especially when the message that’s buried deeper is well worth exploring.

To prevent this, we’re going to discuss 5 of the most common mistakes to avoid when it comes to visualizing different types of data.

1.  Data overload

Many data visualizations and BI dashboards fall victim to data overload– the overcrowding of content, some of which may not add anything to the understanding of the data. For example, while a 3-dimensional chart may look impressive, they can often make the interpretation of data more difficult.

In the same vein, a BI dashboard with 5 charts and numerous labels may showcase a notable amount of findings, but is ultimately useless if your reader cannot distinguish what they’re looking at. Unnecessary illustrations, drop shadows, fonts and ornamentations can distract from the data, so use them sparingly. In most instances, less is more.

2.  Accessing axis

When dealing with quantitative data, bar or line charts are two of the best methods of visualizing your content. One common mistake is often to do with the chart axes; while it may seem efficient to start the Y-axis value above zero for larger values, this can truncate the bars and prevent an accurate representation of their values.

3.  Don’t slice too thin

Dealing with whole numbers, data often comes in the form of part-to-whole relationships, better known as pie charts. Pie charts are an extremely popular method of conveying data, and yet are much maligned for being, as Walter Hickey puts it, “incredibly bad at the one thing they’re ostensibly designed to do”.

Without section labels, it’s actually very difficult to distinguish the sizes of pie ‘segments’ (could you tell the difference between 36% and 37%?) so ensure all areas of your chart are clearly labelled. Also worth considering is the number of categories used; too many different segments can make it hard to differentiate between each.

4.  Crossed wires

Data that lies within a certain range is often used to showcase change over time. Line charts are therefore an effective way of conveying the changes or differences between the data over time. You may have started to notice a trend here, but it’s important not to use too many lines in your chart. Having a mass of interchanging lines across a chart can quickly become confusing, so we suggest not using any more than 4 series.

5.  Be appropriate

Heat maps are one of the newest charts in the data visualization world, and have quickly become popular. Using geographical space as a base is perfect for categorical data, but there are a few obstacles that can trip you up. Color and data ranges should both be used appropriately with heat maps.

Some colors stand out more than others, which can give unnecessary weight to data. Instead, use a single color with varying shades to show levels of intensity. For the data itself, select 3-6 numerical ranges that distribute the data evenly between them. +/- signs can extend the high and low ranges.

Effective storytelling through data is a required skill which will help you drive influence in your organization – download this whitepaper now to learn more!

The GitHub is one of the most popular code sharing platform, which follows GIT algorithm for version control.  In this blog post, we will learn how to work with GitHub repository and Visual Studio 2015. This blog post would help you in answering following two questions:

1. How to sync or share project from Visual Studio to a GitHub Repository
2. How to clone a GitHub Repository in Visual Studio?

Syncing or Sharing project from Visual Studio in GitHub Repository

We need to follow steps as mentioned below to share project.

Step 1

Start with creating a Repository on GitHub. To do that navigate to https://github.com/ and click on + sign to create a new repository. I am assuming that, you have already created an account in GitHub.

Next you need to provide information such as:

1. Name of the repository
2. Description of the repository
3. Whether repository is public or private
4. Whether to initialize repository with a README.

Make sure not to initialize the repository with a README. If you do so, you will get some error while syncing the project to the repository.  Once repository is created, click on Clone or download dropdown and copy the web URL as shown in the image below. We need GitHub repository URL later in Visual Studio.

Step 2

Install Git for Windows on the machine. You can download it from here  https://git-scm.com/download/win . After downloading follow the screens to install git on windows.

Step 3

Open the visual studio solution, you want to publish to GitHub repository in Visual Studio. In Visual Studio Solution Explorer, right click on the solution and click on Add Solution to Source Control.

Step 4

Next open Team Explorer by pressing Ctrl+M or opening from View->Team Explorer. In the Team Explorer, click on Home icon and then select Sync option.

On the next screen, enter GitHub Repository URL (from step 1) and click on publish.

Next you will be prompted for GitHub credentials, enter that to sync or publish Visual Studio project to GitHub repository.

To verify whether project got successfully published, navigate to GitHub.com and open the repository, you should find project from Visual Studio listed here.

 Sync the changes

After successfully publishing of project, you can commit the changes to the sever also.  After changing the code, right click on the solution in the solution explorer and select Commit from the context menu.

Next you will be asked to enter the comment for Commit.  After entering commit message click on Commit All.

On the next screen click on Sync as shown in the image below

 On the next screen click on Push in Outgoing Commits section.

After successful push, you should get message successfully pushed to origin/master as shown in the image below

In this way, you can sync work on project in Visual Studio to GitHub Repository.

How to clone a GitHub Repository in Visual Studio?

Cloning a repository is very simple. To clone, launch Visual Studio and open Team Explorer.  To clone a repository, you need to provide two information

1. GitHub repository URL
2. Empty folder in which repository will be cloned.

Click on connect button in Team Explorer and provide GitHub repository URL and folder name to clone the repository locally.

 After successful clone, open the folder you will find projects from the GitHub repository.I hope this post helps you in working with GitHub repository and Visual Studio. Thanks for reading.

A brief history -

Conceived in the fall of 2007, with the vision of becoming the go-to development platform for cross browser and OS compatibility, Microsoft created Silverlight as a free plug-in development tool to foster a new level of interactivity for Web and mobile applications. One of the largest reasons for Silverlight’s previous success may be attributed to its support for rich UI features such as animations, graphics and visual media, as it was created to include a subset of WPF.

An unclear future -

In the spring of 2015 Microsoft announced that it will be officially dropping support for Silverlight starting with its new Edge browser and has entered maintenance mode for the platform in Internet Explorer 11 with the official retirement of Silverlight projected for 2021 - as far as Microsoft is concerned, Internet Explorer 11 is the last and only version of the browser that will support Silverlight.

The writing is on the wall - Silverlight is no longer the answer to superior cross-browser support and is significantly less viable as a web-browser technology in this regard, with support phased out or in the process of - with virtually all conventional browsers opting for the more secure, both architecturally and in regard to market share, (read future proof) HTML5.

Flash forward to 2016 and it's clear to most, that the platform, having long entered its twilight phase is close to moribundity.

The market response to the new paradigm of plugless browsing and likely with foresight to Microsoft's plans for the retirement of Silverlight, has been gradually shifting towards the more versatile and integrated feature laden, HTML5/Javascript.

Netflix has executed its plan for phasing out support for the latest Silverlight 5 iteration in favor of HTML5’s premium video extensions, with the platform being particularly well suited for web content delivery across a wide span of mobile devices, this same trend can be seen with other major video sharing and streaming services, such as Youtube, Dailymotion and Vimeo; plugless browsing really does appear to be the wave of the future.

Technology giant Google, dropped support for Silverlight indirectly by its Google Chrome browser, a result of its deprecation of NPAPI support; this decision single handedly shifted the landscape of silverlights availability to consumers with Google Chrome comprising 48.65% of all browsers in use as of the date of this writing in July, 2016, (http://www.netmarketshare.com/browser-market-share.aspx?qprid=0&qpcustomd=0).

Why HTML5?

The potential benefits of HTML5 are many and include a single solution - offering support for all of today’s most popular platforms such as Windows, Android, Mac and iOS; allowing for greater flexibility for developers, access to a larger potential client base by which their applications may be used, a more consistent experience and potentially vastly shorter overall time between conception and deployment and we didn’t even touch on its rich UI features.

HTML5 enables you to incorporate the very rich UI features that made Silverlight successful, doing it all without ever requiring consumers to download a single plugin; including support for animations, embedded visual and audio media, gesture support and an ever improving video streaming potential.

Closing words - Rest in peace, Silverlight - move along, there’s nothing to see here, folks

In all seriousness though, it's clear that HTML5 is here to stay and ultimately allows you to create rich visually appealing applications that Silverlight enabled you to build previously, and did I mention being a single multi-platform solution?

For the time-being, there may be an argument for continuing to rely on Silverlight in certain scenarios and the platform may remain a viable option for legacy apps running OOB, but with Microsoft essentially entering maintenance mode with the platform, having expressed publicly that no new development efforts will be made, (rather focusing efforts on their new Edge browser, which in itself marks the end of conventional browser support for SL in Microsoft's lineup) application development potential here too is doomed to stagnate, at least eventually.

If you are interested in building dynamic interfaces with the intention of it lasting longer than the next model of Windows Phone, then HTML5 is the way to go. Microsoft has provided us with its stance, officially supporting Silverlight until 2021, but the fact of the matter is that it will only be usable by what will very soon be legacy OS and web browsers.

Have you recently started development or are maintaining an application using Silverlight? if staying on the cutting edge and ensuring a future proof solution for cross platform apps is important to you, it may be wise to invest in a viable migration strategy, perhaps using HTML5 as a robust, secure and arguably future proof alternative; check out this blog for recommended migration strategies: Why you need a Silverlight Migration Strategy

When deciding to buy or build BI into your application it’s important to make that decision carefully and thoughtfully. In software development there always comes a time when you have to decide to build or buy certain software that you believe is necessary either within your product or to help build your product. You begin to search the web to find any existing tools out there that can solve the problem. Today, there is a massive selection of software to solve nearly every business problem you can think of and new ones are being launched every day. The mistake I have noticed is that many software professionals (including myself) seem to underestimate the effort involved in building solutions yourself. Rich Mironov, Software Product Management Consultant, calls it the DIY Illusion. He describes it as the idea that if a commercially available product doesn’t give us exactly what we want, an internal team can create it in short order. His conclusion after 15 years of experience watching his clients make the same mistake is that:

“Commercial software is almost always a huge bargain versus internally built systems, both in time and money. As technical and business leaders, we should closely inspect every request to do it ourselves. And not fall victim to the DIY illusion.”

As product manager for ReportPlus, which is a BI and data discovery tool that can be embedded into desktop, iOS, and web apps, I believe that many times building your data visualization and business intelligence yourself instead of buying it from a vendor can lead to a DIY nightmare. Here’s why:

• Not as simple as it seems. As simple as data visualization software sometimes appears there is a lot of magic and complexities that occur behind the scenes including preexisting data connectors to on-premise and cloud data sources, dynamic interactions with the dashboards/charts, intelligent analytics engines that crunch the data and help display the visualizations quickly.  
• There are no small features in software. Development teams underestimate the cost of creating and supporting home grown software. They also underestimate how quickly it can be built. I’ve been guilty of this myself as a product manager.
• Belief that it’s too expensive. There’s a misconception that embedded BI tools are pricey. With new tools like ReportPlus, the cost of embedding BI for analytics and dashboard needs is much more affordable.
• It’s not a one time thing. The requests for reports and dashboards is ongoing and sometimes never ending. If you build your first, you will probably be asked to build another. Choosing a tool that can allow you to create these dashboards quickly and embed them with a few lines of code, can help you focus your development resources on real customer issues instead of building new chart types connected to new data sources. If your team is doing this today you can probably train one person on the new BI tool and have the rest of the team focused on proactive instead of reactive work.

In addition, there are some very clear benefits to choosing to buy an embedded BI product.

• Faster time to market. In this hyper-competitive landscape, we are all looking for ways to ship faster software and gain a competitive edge. Shipping an analytics mobile application in 4 months vs. 1 year can have a huge difference in how you separate yourself from your competition. An Aberdeen Group report Titled “Embedded Analytics for the ISV: Supercharging Applications with BI” states that 73% of ISV’s choose to embed BI in their applications as a competitive differentiator.
• Allows you to focus your resources on where you truly add value. If you offer CRM, ERP, HR software, building out dashboards might not be the best place to focus your team's time. Focus your team on where they can deliver real value to your product or company. At a previous company I worked for, we were evaluating purchases of an embedded BI solution and the development manager sat in on the demo for a product and then wondered what the 2 data analysts would do since we might not need two people to build reports and dashboards anymore. That was exactly the benefit of the software. You get productivity benefits and can allow your team to work on more creative and proactive projects rather than report creation.

Of course, there are times when it does make sense to build BI in-house.  

• Limited set of requirements or small scope of project. You could be working on a project whose scope is extremely limited and you don’t believe the investment on embedding BI will be worth it.
• Very specific requirements. Your users might have very specific requirements that can’t be met by the tools available in the market.  
• BI and data analytics is a core part of your product. If BI and analytics are a core piece of the value you deliver to your customers and you have the expertise to build them yourself, then maybe building it in-house is the better option.

Before deciding to buy or build, be sure to evaluate all the available options in the market and avoid the DIY illusion. For more information on embedding ReportPlus into your iOS, desktop, and web applications, visit our ReportPlus Embedded page, view our documentation for embedding on the web, desktop, or iOS, or start your free ReportPlus trial that gives you access to embedding dashboards.

Bill Masur

Product Manager ReportPlus

With mobile technology now a ubiquitous component of doing business, providing your employees with comprehensive mobile solutions is critical to the success of your enterprise. But simply handing them devices loaded with apps isn’t enough; it takes careful planning to execute an effective mobile strategy.

Strategize or fall behind

In a 2015 survey of 1200 knowledge workers in Western Europe and the US, employees revealed a series of insights into the real state of mobile in the workforce today. Findings showed that:

• Mobility is critical to getting their jobs done; 80% depended on mobile, and 60% revealed their customers expect them to be contactable out of work hours.
• Only one third of employees feel their company is providing sufficient mobile technology support.
• Because IT departments are currently failing to respond to their mobile needs, 34% of respondents regularly found ‘workarounds’ to overcome company limitations.
• It is clear that many organizations are failing their employees – and in the long run, their customers – by not providing comprehensive mobile solutions.

However, those companies that do implement a mobility strategy reap the rewards. For example, British Gas, an energy company, supplied its field workers with tablets as they installed new meters in customers’ homes. This avoided the need to carry around large (and often outdated) manuals. It also helped employees contact customers more easily while on the road and track the process of every job. This led to a remarkable boost in productivity, simplified installations, increased employee satisfaction and enhanced customer service.

Success though involves more than simply providing employees with a device and some apps.

Building a strategy

There are a wide range of factors to consider when developing an enterprise mobility strategy. It is essential that the company has a clear vision regarding what it wants from the mobile strategy, who will actually be using the device(s) and what the use case will be.

In some industries – such as contracting or construction, it will make the most sense for your company to provide workers with a company supplied device. They will be carrying out a range of tasks and will need a dedicated tool to help with all of these. In other industries however – such as healthcare – it may make more sense to allow employees to download a company supplied app to their own personal device.

With a clear vision of where you want your company to be in terms of mobility, the next step is planning how to get there. Incorporating the following factors will ensure you have all your bases covered.

1. Evaluate current IT

The first step in your strategy should be to evaluate your current IT scenario. Your employees are likely to be using a range of hardware – not only in terms of OS, but also in terms of portable devices, laptops, tablets and mobiles. Besides hardware it is also crucial to consider the software your employees use. Do you have a SharePoint environment for file sharing? Which kind of CRM are you running? Do you use a cloud based environment and do your employees use specialized tools that they’ll need to use on the road? You may find it valuable to produce a checklist as in the example in this whitepaper.

2. Bring Your Own Device (BYOD) or company supplied?

A second question is to decide what your approach to mobile devices themselves will be. BYOD involves allowing employees to connect to your company’s systems via their own personal devices. Some of the advantages of BYOD include cost savings, employee empowerment, while at the same time personal devices may be more complicated to manage and update and may pose a higher risk of hacking and inappropriate use.

3. Choose your Mobile Device Management (MDM) provider

If employees are accessing company data via the cloud, beyond the parameters of your physical office, you face issues around data security and hacking. There is also a risk of current employees losing devices or intentionally sharing private company data while out the office. Beyond basic data protection, you should also consider one of a range of MDM suppliers such as MobileIron, Citrix or VMware Airwatch. These tools provide a method of controlling devices from a central console, remote data wipe and encryption at rest and in transit.

4. Training and adoption success

Achieving long term ROI requires absolute user adoption of the solution you choose. While an intuitive User Interface (UI) and the versatility of mobile will certainly encourage adoption, training is likely to be beneficial too. Prior to introducing your strategy, carry out research with users about their preferred solutions asking the following kinds of questions such as: Which OS/device types do they currently use, and what do they want to use in future? What corporate apps do they want on their phones and tablets? Would they actually prefer BYOD or company supplied?

5. Measure success

Before you actually deploy your chosen solution, it is wise to define the metrics you will use to gauge success. Again, the measurement you use will depend largely on your use cases, and can be achieved by considering pure monetary ROI or by carrying out opinion surveys with employees, 3, 6 and 12 months into the deployment.

Read more on the topic and see a complete checklist with suggested time frames for each step of the mobile strategy process in the whitepaper ‘Planning an Effective Mobile Strategy’ - it has everything you need to take on an enterprise-wide mobile strategy of your own!

From the people, for the people. Аnd for fun. 

It’s what UX Camp Berlin is about - the UBER and Airbnb of conferences. In other words, it’s one of the best events I had the privilege to attend this year.

What is UXcamp Berlin?

UXcamp Berlin is an intense, two-day event, born from the desire to share knowledge and party at the same time. It’s а place where you can meet, learn from or just have fun with 500 international UX professionals from such diverse disciplines as Information Architecture, Development, Interaction & Visual Design, Service Design, Psychology and Usability.

'Rules of UXcamp Berlin:
There are no spectators, only participants. Attendees must give a demo, a session, or help with one, or otherwise volunteer / contribute in some way to support the event.'

This year, the large number of UX professionals resulted in 10 (yes, 10) simultaneously running sessions during the course of the 2 day event, 2 official parties (Friday and Saturday nights) and, I feel compelled to mention, a room streaming the 2016 UEFA European Championship!

How can I get there and why?

According to the rules there are two ways to get in the camp:

1. You can attend as a volunteer, if you sign up fast while there are available slots.
As a volunteer, you help by donating 1 hour of your time assisting at the hot beverages stand, helping with the registrations, delivering the water to the venue, etc.

or

2. You can join as а session host. Registering to host a session is free but you have to be REALLY quick since the number of tickets is limited and sells out in 2 minutes (literally).
No rush at all ;)

Hosts moderate 45 minute sessions. Some sessions were focused on regular talks, discussions and workshops covering a great variety of topics - gov.uk insights on how to design for a better citizen experience, involving playfulness in a serious topic, innovative research methods, how to create a kick-ass presentation and many more including Raya Dimitrova’s talk 'Building UX Culture in the Workplace' and my discussion 'Empathy and Mirror Neurons'. Stay tuned to this space!

Other sessions were more abstract. You could attend a guitar performance, a chair yoga lesson, personal stories about hitchhiking, or something totally bananas…like wearing an actual banana costume for two ridiculously hot days in order to prove the point that

Surprise and Absurdity Works.

I’ll try to put that session into practice to see if it really does work :)

1. This is me making it short. Just 7 more rows below.
2. Forget about this post.
3-4. Imagine yourself giving a talk at a conference in a Kermit/Niki Minaj Halloween costume.
5. Good news - you can actually do it next year!
6. Turn to your side and say something absurd to the person next to you.
7. Surprise! It’s the zombie banana guy.



8. No, he won’t haunt you in your dreams. Ok, he might but his preferred habitat is UXcamp Berlin or twitter.
Want to make your own story, or be a part of one? Join the event next year at http://www.uxcampeurope.org/!

ReportPlus Desktop Version 1.0 is here with the following enhancements and fixes:

Enhancements:

• Application themes support
• Improved login experience

Fixed Issues:

• Dashboard cannot be opened when cloud repository is disabled in user's configuration
• Exceptions during signing in are not properly logged
• Log file size is not limited
• Category series chart cannot be rendered when Japanese character appears in category's label

Build 1.0.1183.0 - Jul-29-2016

Almost a year ago, we announced the retirement of our Windows 8 and Windows Phone 8 products.  This was in response to the ever-changing Windows platform, and the utter lack of market interest.  Since then, we have been planning and waiting for the right time to make our move.  The time is now!  The Windows Platform has made a number of improvements and the market is starting to gain traction.  We have recognized that now is the perfect time to launch our Infragistics UWP controls to the world.  I am exited to announce that we are making our Infragistics UWP controls available to you today. 

But wait a minute Brian…. the title says “Preview”, what’s up with that?  If you have been following my career here at Infragistics for the last 5 years, you know that I don’t like to keep things from my community.  I want your honest and candid feedback, and the best way to get that is to give you what we have now.  Not tomorrow, not next week, not next month, but now.  I wanted to get these controls in your hands as soon as possible, because waiting sucks.  We have some loose ends to tie up before we can call these controls RTM, but don’t let that “Preview” term fool you.  These controls are ready to be thrown into the fire and pushed to their limits.

Now, I’m not just giving paying customers early access to the Infragistics UWP controls.  I’m giving everyone access to the Infragistics UWP controls for FREE!  That’s right, no purchases necessary.  Anyone from the community can download these great controls and start using them NOW.  All I ask is that you contact support for any issues or bugs you run into, submit any feature requests to the Infragistics Product Ideas website, and you send me your honest feedback directly.  I want to know what you think of these controls and what you need in order to be successful building UWP apps.  So what are you waiting for?

Download the FREE Infragistics UWP Preview

While your Infragistics UWP Preview controls are downloading, let’s take a quick look at what you’ll be getting.

Sample Browser

This first thing I want to point out is that we are providing a very simple Sample Browser to help you become familiar with the controls.  Install it, run it, explore it.  This should do for now, at least until we can ship the official Infragistics UWP Sample Browser.

Data Grid

The first control up, is our brand new UWP Data Grid written from the ground up to allow us to take advantage of everything that UWP has to offer.  Even though this is a preview release of our Data Grid, it has a ton of features that you can start taking advantage of right now.  Everything form the basics of column definitions, to sorting, filtering, responsiveness, and even async data loading.  This Data Grid has some great features that will take your UWP apps to the next level.

Data Chart

Next up is our UWP Data Chart.  This control has been the power house of Infragistics for many years on other platforms.  Now, you can take advantage of the power and massive feature set provided by the Data Chart.  There are literally too many features to even fathom talking about all of them in this post.  So I will simply sum them up and you can go play with the Data Chart yourself.  Make sure you set aside a year or so to really dive in.  That’s just how many features we pack into this mobile data chart.  The UWP Data Chart comes with over 50 chart types including bar, column, line, area, spline, waterfall, point, OHLC, polar, radial, and many many more.  Besides a crazy number of supported chart types, there are an even larger number of features with each chart.  Crosshairs, legends, markers, panning, zooming, and much more.  Basically, the Infragistics Data Chart is the Chuck Norris of charts.  Nothing else needs to be said.

Pie Chart

Who doesn’t like pie?  The main features of the Pie Chart include label configurations, like position and extent, label font properties, controlling pie radius, start angle, sweep direction, exploded slices and distance from center for exploded slices, selected slices, and legend. The ability to prevent the labels from colliding with each other or the slices.

Funnel Chart

A single series chart that displays data in a funnel shape with a variable number of sections each representing the data as different portions of 100% or to weight the height of the slices based on value. The Funnel Chart can be configured to be inverted, to use Bezier Curve for its shape or weighted slices.

Radial Gauge

The Radial Gauge contains a number of visual elements, such as a scale with tick marks and labels, a needle, and a number of ranges. The Radial Gauge has different label configurations, like color, extent, and interval. Radial Gauge has different range properties, like color, start and end value. The needle of the Radial Gauge can be configured by setting its color, needle and pivot shapes and outlines. The transitions between different sets of settings can be animated.

Linear Gauge

The Linear Gauge is useful for showing a single measure on a linear range. It has different label configurations, like color, extent, interval, and position of the first and last labels. The needle of the Linear Gauge can be configured by setting its color, outline, shape, size. The transitions between different sets of settings can be animated.

Bullet Graph

The Bullet Graph displays a single primary measure and compares it to one or more other measures to create a concise data visualization. It supports a variety of configurations, e.g. orientation, scale, tick marks, ranges and colors along with animated transitions between different sets of settings.

128 Barcode

The 128 Barcode can be used in inventory, shipping and distribution applications. The 128 Barcode has different configurations, like label’s color and font, background color, and stretch.

QR Barcode

The QR (Quick Response) Barcode can be used in commercial tracking, entertainment and transport ticketing, product marketing applications.

Let’s Wrap this Baby Up!

Seeing this preview probably has you asking yourself, “Brian, these controls are amazing and I can’t wait to use them, but what’s next?  What’s your long term plan for UWP?”.  Well, I’m glad you asked.  As I write this blog, we are researching controls such as a new mobile scheduler, a ribbon control, an Excel experience, a Word experience, and many other controls that really concentrate on line of business scenarios for mobile applications.  We have a long term plan for supporting your UWP application needs, and we are committed to bringing you the markets best, highest performing, and most beautiful mobile controls period.  In order to accomplish this, we need your help. 

If you have ideas about new features we should bring to our controls, important issues we need to fix, or even brand new controls you’d like us to introduce, please let us know by posting them on our Product Ideas website.  Follow and engage with us on Twitter via @infragistics. You can also follow and contact me directly on Twitter at @brianlagunas.  Also make sure to connect with our various teams via our Community Forumswhere you can interact with Infragistics engineers and other customers.  

Lastly, when you do build something cool with our controls, please make sure to let us know.

ReportPlus is a powerful tool to create, share and visualize your data from any device. But how can you use it to discover insights from that data, and track your key business metrics? In this webinar, ReportPlus Product Manager Bill Masur walks you through the latest release of ReportPlus for Desktop and Mobile, and gives you a sneak peek of what to expect in the future.

[youtube] width="560" height="315" src="http://www.youtube.com/embed/7HJhpA5PwDA" [/youtube]

In this one hour presentation, you’ll learn how to create, edit and share dashboards from your iOS, Android, or desktop device; connect to your data from over 20 popular sources including Excel - or bring in your favorite data source; visualize your data with interactive drag and drop reports, and more. To make the most of your webinar experience, visit www.reportplus.com for additional product details, offers, and pricing information.

Why would you care about creating a “UX culture” in the workplace? And what does that even mean?

If you are a fan of definitions, here’s one for “UX culture”:
The awareness of the team members/company employees of the importance of UX and it’s role in the work process.

Now why is that a thing?

From what I have seen here at Infragistics, the benefits of having built UX culture amongst your work peers are:

1. Others (non-designers) can tackle small UX issues by themselves
   Or in other words - UX becoming everybody’s job

   On one hand this helps the designers focus more on the big picture and the more complex design challenges while devs take care of the small UX issues by themselves (using the most basic, good design practices). On the other hand, this gives the devs a bit more confidence about their design skills and helps them avoid creating UX issues in the first place (now that they know broader spacings are not the enemy ;-).

2. Better understanding of the design work
   Or Less “Why do that?”

   Now that the non-designers have a basic design dictionary in their heads, discussions are more productive and to the point, rather than circling back to the unhelpful “I just like this more”.

3. Enlarge the scope of your impact
   Or Strategic vs Tactical

   UX culture effects not only the regular employees but the headquarters as well. And this is where the real value for you, the designer, is. Once product owners and executives understand the value of UX, you have the green light to act and make an impact on the larger strategic level... the ‘what are we really doing here’ level. You can do the research required to understand ‘what user needs are we satisfying’ rather than just managing tactical improvements like making the navigation of the site less confusing.

Get the bosses on board

The fastest and most straightforward way of getting UX into the board room is to introduce the stakeholders to the actual end user of the product.
Just letting them see ordinary users fighting with what they believed was a brilliant solution will do magic. Seeing first hand how actual people interact with the product will convince your bosses that user research and UX efforts are meaningful and worth the investment of time and money. You don’t even need those special one-way-mirror rooms. A recording of a few actual people using the product in a non-directed manner will be enough.

Once they are convinced, the rest of the company, the people who actually do the work, should follow.

The conversion process

I have heard from our HR that to change the culture, you need to change the conversation in the room enough number of times.
So how do you change the conversation in the room?

Step 1 - The seed = the UX advocate

Are you a UX designer? Then hey, the seed is planted! The fact that you are hired is the first prerequisite. And even if you are not exactly titled “designer” or “ux” but you carry the pro-UX gene in your blood, you can still take on that advocate role and be great at it! All you have to do now is water that UX seed until it grows up and starts producing new seeds (once you convince people design matters, new ux advocates will appear)! Then keep watering it until it takes over the house.

Step 2 - The watering

UX Smalltalk

Be a design advocate on a 24/7 basis. You don’t even need to put much effort into it if UX is truly your passion. All you have to do is let it out. Anytime you find yourself chatting with colleagues - over the water cooler, while having lunch together or in the kitchen drinking your morning coffee, throw in a UX comment. Make a name for yourself as the UX person.
At our Infragistics office in Bulgaria, Stefan Ivanov has been advocating UX for so long now that people themselves don’t miss a chance to mention the magic UX word around him. “And UX is important” is a random sentence you may hear thrown in Stefan’s presence even without direct relevance to the discussion - just to make sure it ends happily :)

UX Training

One way to spread UX awareness across a greater scope of people is conducting regularly scheduled UX training classes. These need only take an hour or two and focus on UX principles, methods, processes, etc. Including a hands-on exercise at the end gives people a taste for what UX really means. At Infragistics we have monthly UX training in each of our largest global offices. One designer creates the presentation and hands-on exercise, then shares it with 2 other designers who will present it in the other 2 offices. This allows us to distribute the training preparation between all the members of the UX team and deliver them regularly. If you are a one person UXer across many offices, you’ll need to conduct the class remotely. On occasion, we’ve had to present live in one office and have remote attendees participate from the other offices. We’ve found that Google Hangout, Skype for Business or any of a number of other screen sharing/conference call application work pretty well.

To attract more attendees, it helps to load the training rooms with treats, drinks, and snacks to make participation in the training nicer and more casual. This is an hour or two people would spend in an environment different from their desk/cubicle/office where they will learn something useful while enjoying their time. After all - who doesn’t like to participate in a fun and interesting design workshop? And free snacks on top of it!

UX Club

For those who show interest in diving deeper into UX topics, we have also been organizing UX club meetings. They cover topics the club members are interested in that were not included in the trainings (e.g. gamification or different workshops). This watermelon workshop was, besides being fun, also useful for helping us pick good pie slices animations.

UX workshops on work tasks

If you work in a big enough company, test the design artifacts you create for a given project with colleagues who don’t work on this project and don’t know much about it. This is not only a cheap way to do early validation, but also helps grow the UX culture by allowing colleagues to experience test sessions firsthand.

Including actual users in the workshops will, of course, provide better data. In this case you can record the testing session and review it later with your team members. Discuss the discoveries that emerged from the testing and what you can do together as a team to tackle them. Just like with the stakeholders, meeting the team members with an actual user interacting with their creation will set new, UX-friendlier grounds.

Attend scrums

If you are facing a team that hasn’t worked with a UX specialist before, the most efficient way of teaching them where UX work can help is by attending the weekly scrum meetings, where teams discuss what will be worked on during the coming week. At each meeting, mark the tasks in which you will get involved. Done on a regular basis, eventually the team will learn where UX is needed and will begin inviting you to participate themselves.

When Infragistics hired Stefan Ivanov as the first UX Architect in the Bulgarian office, he had to do exactly that. He regularly attended numerous scrum meetings. One year later, it totally paid off. Now he doesn’t need to attend as many scrums simply because team members already know when the UX people need to be involved and come look for us. If this isn’t a proof for having successfully built a UX culture, I don’t know what is!

Needed assets

• How persistent you are.
  Changing a culture is not something that happens overnight. It takes time and it happens little by little. Like an ant, you should be stubbornly building that UX ant hill without letting anything stop you.

• Will you manage to communicate your message to upper management?
  In order to take 2 hours per month from people’s working time, you need the permission of the boss. And preferably their blessing as well. If you first win over the corporate “heads” to your UX side, the “body” will follow. By the way, the heads mentioning UX in their inspirational speeches can also help a great deal ;)

Begin with your boss and be persistent until you reach the UX company support you need to do your job most efficiently. After all, this is your UX context of use and we all know that context of use is a key factor in creating a great UX experience.

What are you waiting for? Aren’t you already planning your next step for spreading your UX spidernet in the office?

Extracting a report from Microsoft Analysis Services can be a cumbersome experience: not only do you need to configure your server, but you must also configure a folder in Report Manager and configure the model you’ll be using. If you’re using Report Builder through a browser, you are stuck with an .RDL file, which you can only open using Report Builder. Try opening it with anything else, and you’re out of luck.

Once more, ReportPlus steps up to the plate to offer a quick and easy alternative. With the new ReportPlus Desktop, you do not need any other server-side configuration of third-party applications; simply configure Analysis Services with only three clicks and gain access to your data in a heartbeat.

Adding your Analysis Services data sources into ReportPlus Desktop is as easy as adding a spreadsheet. Just enter your server details, your credentials, and access your data in the usual way.

Did you know that you can also Sort by caption? This means that you can not only apply filters and sort your information, but you can also define whether the filter will be applied to your dimensions’ labels or the corresponding values.

To access this option, simply access the dimension’s Sorting options in the Filters, Columns or Rows placeholders.

While Sorting by Caption might come in handy, one of the biggest advantages of using SSAS in any dashboard is, by far, the ability to create dynamic Global Filters.

With Analysis Services, there are two additional fields for you:

• A field to select which data will be displayed.

• A field to set your filter with data for measure.

We’ve only covered a few advantages of empowering Analysis Services data with ReportPlus Desktop, but there’s much more.

Interested in finding out more about ReportPlus? Sign up for our ReportPlus Desktop free trial now, or contact us to see the wonders it can work for you and your team!

In a web application project, exporting a grid to an Excel file is one of the most frequent requirements. There are various ways to do this, but IgniteUI makes it super simple. All it takes is one line of code! In this post, we will learn to:

• Create a grid
• Export the grid to an Excel file
• Export a grid with features like Pagination enabled to an Excel file

Let’s get started.

Step1: Adding References

To work with any IgniteUI control, first we need to add the required JavaScript and CSS references. So, let us start with that. We have three options to add references:

1. Download IgniteUI and add the required files to the project.
2. Use NuGet package in Visual Studio. Right click on the project and select Manage NuGet package. Search IgniteUI in NuGet Package Manager, and install trial version of IgniteUI in the project.
3. Via CDN: The IgniteUI team provides a public CDN to use.

In this demo, I have installed IgniteUI using the NuGet package in the project. We need to add the required references as shown in the listing below:

<linkhref="Content/Infragistics/css/themes/infragistics/infragistics.theme.css"rel="stylesheet"/><linkhref="Content/Infragistics/css/structure/infragistics.css"rel="stylesheet"/><scriptsrc="scripts/jquery-2.0.3.min.js"></s cript><scriptsrc="scripts/jquery-ui-1.10.3.min.js"></s cript><scriptsrc="scripts/Infragistics/js/infragistics.core.js"></s cript><scriptsrc="scripts/Infragistics/js/infragistics.lob.js"></s cript><scriptsrc="scripts/Infragistics/js/modules/infragistics.documents.core.js"></s cript><scriptsrc="scripts/Infragistics/js/modules/infragistics.excel.js"></s cript><scriptsrc="scripts/Infragistics/js/modules/infragistics.gridexcelexporter.js"></s cript><scriptsrc="http://www.igniteui.com/js/external/FileSaver.js"></s cript><scriptsrc="http://www.igniteui.com/js/external/Blob.js"></s cript><scriptsrc="demo.js"></s cript>

Essentially we are adding references of:

• IgniteUI CSS libraries
• jQuery library
• jQuery UI library
• IgniteUI core, dev, and lob libraries
• IgniteUI libraries for excel export

Keep in mind that you need to follow the same sequence of adding references as shown in the above listing. You may notice that I have also added a reference to the demo.js file. As a starter, demo.js contains a function as shown in the listing below. We will write all the required JavaScript code inside this function.

 $(function () {//write ignite code here 


});

 We also have another option to write IgniteUI code: inside the jQuery document ready function.

$(document).ready(function () {//write ignite code here 

});

Create HTML  

Next let’s create our HTML page with two elements:

• An HTML table that gets converted to igGrid
• An HTML button that, when clicked, will export the grid to Excel

Let us go ahead and create HTML as shown in the listing below:

<body><tableid="grid"></t able>
<buttonid="btnExportToExcel"type="button">Export to Excel</b utton></b ody>

Creating the igGrid

You can create an igGrid by binding data from:

1. JSON data from the backend server
2. OData EndPoint
3. Binding to a local data source. igGrid could be bound to a JSON object array created locally in the application

We have created a JSON object array productData as shown in the listing below:

var productData = [
          { "ProductID":1, "Name":"Adjustable Race", "ProductNumber":"AR-5381", "SafetyStockLevel":1000 },
          { "ProductID":2, "Name":"Bearing Ball", "ProductNumber":"BA-8327", "SafetyStockLevel":1000 },
          { "ProductID":3, "Name":"BB Ball Bearing", "ProductNumber":"BE-2349", "SafetyStockLevel":800 },
          { "ProductID":4, "Name":"Headset Ball Bearings", "ProductNumber":"BE-2908", "SafetyStockLevel":800 },
          { "ProductID":316, "Name":"Blade", "ProductNumber":"BL-2036", "SafetyStockLevel":800 },
          { "ProductID":317, "Name":"LL Crankarm", "ProductNumber":"CA-5965", "SafetyStockLevel":500 },
          { "ProductID":318, "Name":"ML Crankarm", "ProductNumber":"CA-6738", "SafetyStockLevel":500 },
          { "ProductID":319, "Name":"HL Crankarm", "ProductNumber":"CA-7457", "SafetyStockLevel":500 },
          { "ProductID":320, "Name":"Chainring Bolts", "ProductNumber":"CB-2903", "SafetyStockLevel":1000 },
          { "ProductID":321, "Name":"Chainring Nut", "ProductNumber":"CN-6137", "SafetyStockLevel":1000 }
    ];

 We can bind the above data and create a grid as shown in the listing below. Essentially, we need to select HTML table and convert that to igGrid by setting various properties. Keep in mind that to create a minimum grid, we need to set only the datasource property. However, here we are setting other properties like columns header, primary key, etc.

So, igGrid can be created as shown in the listing below:

$("#grid").igGrid({
        columns: [
          { key:"ProductID", headerText:"Product ID" },
          { key:"Name", headerText:"Name" },
          { key:"ProductNumber", headerText:"Product number" },
          { key:"SafetyStockLevel", headerText:"Safety stock level" }
        ],
        autoGenerateColumns:false,
        primaryKey:"ProductID",
        dataSource: productData,
        width:"1500px"
    });

You may want to notice the dataSource property in the above listing is set to productData JSON object array. Keep in mind that it can be set to:

• ODATA EndPoint URL
• REST service EndPoint retruning JSON data
• Local JOSN data

Regardless of what type of source is set to the dataSource property of igGrid, exporting to Excel would be the same. At this point, when running the application, you will find a grid and a button as shown in the image below:

We need to export the grid to Excel at the click of the button.

 Exporting igGrid to Excel

Exporting the igGrid to an Excel fine is very simple. IgniteUI has given us a method on ig object called GridExcelExporter.exportGrid. We need to use this method to export a grid to an Excel. When clicking the button, the above grid can be exported to Excel as shown in the listing below.

   $("#btnExportToExcel").click(function () {

        console.log("exporting to Excel");
        $.ig.GridExcelExporter.exportGrid($("#grid"));
    }); 

As you might have noticed, we are passing the id of the grid inside GridExcelExporter.exportGrid method. Right now the Excel file would be saved with the default name. If we wish to download the Excel fie with a desired name, then we need to set the filename property value as shown in the listing below.

        $("#btnExportToExcel").click(function () {
        console.log("exporting to Excel");
        $.ig.GridExcelExporter.exportGrid($("#grid"), {
            fileName:"yourfilename"
        });
    });

Exporting Grid with features enabled

So far we have exported a simple Grid, but we may have a scenario in which the grid has many features enabled, such as Paging, Sorting, and Filtering etc.  By default, GridExcelExporter will ignore the features and export the whole grid in an Excel file.

Let us say we have features enabled in igGrid as shown in the listing below:

$("#grid").igGrid({
        columns: [
          { key:"ProductID", headerText:"Product ID" },
          { key:"Name", headerText:"Name" },
          { key:"ProductNumber", headerText:"Product number" },
          { key:"SafetyStockLevel", headerText:"Safety stock level" }
        ],
        autoGenerateColumns:false,
        primaryKey:"ProductID",
        dataSource: productData,
        features: [
                  {
                      name:'Paging',
                      type:"local",
                      pageSize:2
                  },
                  {
                      name:"Filtering"
                  },
                  {
                      name:"Sorting"
                  }
        ],
        width:"1500px"
    });

We can persist these features while exporting to Excel as shown in listing below. Here we are setting gridFeatureOptions properties such as sorting and paging.

   $("#btnExportToExcel").click(function () {
        console.log("exporting to Excel");
        $.ig.GridExcelExporter.exportGrid($("#grid"), {
            fileName:"yourfilename",
            gridFeatureOptions: { "sorting":"applied","paging":"currentPage", "summaries":"applied" },
        });
    });

If we don’t set a value for gridFeatureOptions, by default the Excel file will be exported ignoring the grid features. For example, igGrid will have pagination enabled with 2 records per page and there are a total of 5 pages. If gridFeatureOptions are not set, IgniteUI will export all 10 records in the Excel file.

 Conclusion

In this post, we learnt that it is very easy to export a Grid to an Excel file using IgniteUI GridExcelExporter.  For reference, let us put every piece of code together.

$(function () {var productData = [
         { "ProductID":1, "Name":"Adjustable Race", "ProductNumber":"AR-5381", "SafetyStockLevel":1000 },
         { "ProductID":2, "Name":"Bearing Ball", "ProductNumber":"BA-8327", "SafetyStockLevel":1000 },
         { "ProductID":3, "Name":"BB Ball Bearing", "ProductNumber":"BE-2349", "SafetyStockLevel":800 },
         { "ProductID":4, "Name":"Headset Ball Bearings", "ProductNumber":"BE-2908", "SafetyStockLevel":800 },
         { "ProductID":316, "Name":"Blade", "ProductNumber":"BL-2036", "SafetyStockLevel":800 },
         { "ProductID":317, "Name":"LL Crankarm", "ProductNumber":"CA-5965", "SafetyStockLevel":500 },
         { "ProductID":318, "Name":"ML Crankarm", "ProductNumber":"CA-6738", "SafetyStockLevel":500 },
         { "ProductID":319, "Name":"HL Crankarm", "ProductNumber":"CA-7457", "SafetyStockLevel":500 },
         { "ProductID":320, "Name":"Chainring Bolts", "ProductNumber":"CB-2903", "SafetyStockLevel":1000 },
         { "ProductID":321, "Name":"Chainring Nut", "ProductNumber":"CN-6137", "SafetyStockLevel":1000 }
    ];// Creating GRID 
    $("#grid").igGrid({
        columns: [
          { key:"ProductID", headerText:"Product ID" },
          { key:"Name", headerText:"Name" },
          { key:"ProductNumber", headerText:"Product number" },
          { key:"SafetyStockLevel", headerText:"Safety stock level" }
        ],
        autoGenerateColumns:false,
        primaryKey:"ProductID",
        dataSource: productData,
        features: [
                  {
                      name:'Paging',
                      type:"local",
                      pageSize:2
                  },
                  {
                      name:"Filtering"
                  },
                  {
                      name:"Sorting"
                  }
        ],
        width:"1500px"
    });// Exporting to Excel 
    $("#btnExportToExcel").click(function () {
        console.log("exporting to Excel");
        $.ig.GridExcelExporter.exportGrid($("#grid"), {
            fileName:"yourfilename",
            gridFeatureOptions: { "sorting":"applied","paging":"currentPage", "summaries":"applied" },
        });
    });

});

I hope you find this post useful! Keep an eye on future posts where we will cover other IgniteUI controls and their features. Thanks for reading.

Do you ever get a little tired of office jargon?

Maybe you have begun to think in paragraphs like this: To enable your Blue Sky Thinking, and to futureproof moving forward, you need to be constantly reaching out to the right stakeholders. As a business you aim to synergize in the right ways to leverage your mental real estate and create an uplift in your target verticals. Obviously. You do it by valuing your employee skillsets, making sure you touch base offline regularly with customers and clients, grab the low hanging fruit, be a product evangelist, and pretty much always take the holistic, 360 degrees, helicopter view on things. Your fears are dominated by not having enough bandwidth, a jam in the pipeline, the strategic staircase crumbling, a paradigm shift you don’t expect, and ultimately being unable to square the circle.

And breath.

The corporate world in general is crammed with jargon, doublespeak, oxymoron’s, and cliché. It wouldn’t be unusual to hear along the corridors of corporate America, team members in a meeting “calling out” to one another, or emphasizing the need to “get their ducks in a row.” And it gets worse if you work in a tech company—you exist in a world where the jargon can reach even higher levels of baloney—and that’s before we even consider the vast valley of acronyms!

That said, there are some ‘buzz words’ that are actually important, despite them being part of the jargon wheelhouse. ‘Data visualization’ is a good example. Today, we’ll take a closer look at what that is and why it shouldn’t be consigned to the back catalogue of business-speak.

Data what?

For most of the above sayings or phrases there is some good, simple and practical thinking behind them—they don’t become cliché for nothing, right? ‘Grab the low hanging fruit’ is, behind the lame expression, smart advice. Data visualization is an even simpler concept: as the name suggests, it is the presentation of data or information in pictorial or graphical form. Usually, data visualization is used to put together large amounts of information in an engaging manner to make it quicker and easier to understand for your business’s decision makers. It also shows new patterns that are important for predicting future business outcomes or gleaning new insights. By making use of good data visualization, companies can take otherwise static information and ‘drill down’ to get more detail and discover new ideas and gain new perspectives.

Data…so what?

Okay, this sounds convenient and a better way to approach certain information. But it’s not just a fun and engaging way to present important aspects of your business stats and how it functions—there is science behind it. The way our brains process information means that seeing complicated information in graph or chart form is easier than having to study reams and reams of spreadsheets or lengthy pages of a report.

Big Data is a relatively recent phenomenon, but one that is here to stay—in fact, the amount data we produce every day is only going to get larger, deeper and more complex. And as that happens we need to find ways of parsing through it and finding the information that will give us business value.

This should be seen as an opportunity for companies to tailor their services to fit with their customers better. Before the data explosion and ability to carry out data visualization, it was a struggle for most businesses to reach the level of insight that they can today, by comparison. As we ‘move forward’ we can hope to know more about our customers and clients, as well as our competition and the market we work in. And as data continues to evolve, we can use visualization techniques to advance our businesses along with it.

More than a pretty picture 

By utilizing good data visualization, your organization can:

• Discover aspects of your business that need attention
• Understand influences that lead to certain customer behavior
• Prioritize the most important functions of your business
• Forecast sales and other important bottom line stats

Infragistics has purpose-built solutions that put data visualization for your business first. ReportPlus is one such solution, allowing you to securely get the most out of your data by bringing a self-service style Business Intelligence (BI) to your organization. Create, access and collaborate over rich visualizations and dashboards on any device while on the move or in the office. And because the platform is built by user experience experts and designed specifically for business users, you can create a highly functioning dashboard in minutes, and with a touch or click you can share with team members and other colleagues based anywhere. 

ReportPlus enables:

• A drag-and-drop experience to connect all your popular data sources
• Easily chosen visualization types and templates with a quick swipe
• Field filters at a tap or click
• Your dashboard to live in the cloud or on-premises
• Instant sharing

To bring self-service data visualization and BI to your organization, try ReportPlus free for 30 days!

On July 27^th, we hosted a webinar titled “Getting started with AngularJS 2.0” for the India region, and we’d like to share the presentation and recorded webinar with you now! In the webinar, we covered everything you need to know to get started with AngularJS 2.0, including:

• Setting up development environment
• Understanding Components
• Bootstrapping application
• Classes and Interface in TypeScript
• Data Bindings- interpolation, property binding, and event binding
• Nested components

You can view the recording of the entire presentation here:

[youtube] width="560" height="315" src="http://www.youtube.com/embed/ZrUEaklMRaM" [/youtube]

You can also view the presentation slide deck here.

Once again, thank you so much for your interest in our webinars – and we look forward to seeing you at a future webinar!

ReportPlus Desktop Version 1.0.1210 is here with the following enhancements and fixes:

Enhancements:

• Box and OneDrive® data sources support
• In-memory data source support (CTP)
• CSV data source performance improvements
• Custom dashboard themes support

Fixed Issues:

• The Submit Request button on Settings -> Feedback & Support -> Get Support tab leads to an incorrect page
• Incomplete list of values returned for a global filter
• OData DateTime filter request does not provide the proper DateTime format
• Pie chart labels don't appear when it looks like that there is enough space
• Semicolon separator cannot be used as a data separator in a CSV data source
• An exception is thrown upon trying to change the encoding of a CSV file containing Japanese symbols
• Hidden fields are included in transposed fields' result
• Y-axis labels not appearing on Horizontal bar chart widget
• Yesterday is not supported as a date global filter value
• Incorrect date range returned for LastYear, LastMonth and LastWeek date filter rules

Build 1.0.1210.0 - Aug-16-2016

Hot off the heels of our release of the first version of ReportPlus desktop, we are excited to announce that ReportPlus now supports connecting to Box and OneDrive to visualize your excel spreadsheets on ReportPlus Desktop and Mobile(iOS and Android). We currently support connecting to spreadsheets on DropBox, Google Drive, and SharePoint and with the addition of Box and OneDrive, we now support all of the most popular cloud storage providers. With this release we can now help Box and OneDrive users take their boring spreadsheets and turn them into interactive visualizations and dashboards to better understand their data. The combination of ReportPlus and OneDrive/Box allows users to track key metrics right in the palm of their hands with our “Apple Featured” mobile experience.

Spreadsheets are Still King

We all have a love/hate relationship with managing our metrics through a simple spreadsheet, but the reality is that it’s become a standard that everyone is familiar with. It’s a universal language in the business world. Our own observation of how people use ReportPlus has shown that over 50% of the data that’s visualized with our product is from a spreadsheet such as Excel, CSV, or a Google Sheet. With this release, we are adding two of the most popular cloud storage providers where people typically store their spreadsheets to view across their devices and easily share them with others: Box and OneDrive.

ReportPlus + Box/OneDrive = Magic

For our users, adding Box and OneDrive allows them to do some pretty powerful things with very little effort. Personally, it’s one of my favorite ways to use ReportPlus with a spreadsheet in the cloud where the data can be updated in real-time and instantly visualized with ReportPlus. It’s a powerful way to maintain a spreadsheet on Box, OneDrive, DropBox, SharePoint, or Google Drive: simply connect your data with ReportPlus to visualize it at a glance and keep everyone updated with dashboards showcasing the latest metrics. It’s one of the simplest and most cost efficient ways to keep your whole team informed on their mobile and desktop devices while keeping all your data in one place.

Real-time Data with No Help From IT

When you build dashboards with ReportPlus using spreadsheets on Box or OneDrive, they remain securely connected. That means every time you update your data in Box or OneDrive, your dashboards stay updated within ReportPlus with the latest view of your business.  

For more information on how to connect to Box or OneDrive and create your first visualization checkout this short video.

[youtube] width="560" height="315" src="http://www.youtube.com/embed/yeWF6Iv6oug" [/youtube]

A Few Other Goodies in This Release:

iOS:  

• Faster loading on CSV files
• Bug fixes

Desktop:

• Faster loading on CSV files
• Support for custom themes
• In-memory data source support for Windows developers embedding ReportPlus dashboards into their application
• Bug fixes

For a full list of enhancements and more info, check out our release notes here. Also, we plan on adding additional data sources over the coming months, so I encourage you to let us know what data sources you would like for us to add by submitting an idea here.

Learn more about where we’ll be on the Infragistics event page!

It’s now the norm for every college student to be connected to the Internet via their smartphones, tablets or laptops. With Wi-Fi accessible across campus, students can be connected all hours of the day. But, while the students themselves are using up-to-date technology many other parts of the university (and higher education establishments in general) are struggling to keep up.

“Ask any student ‘how has technology been used to improve the classroom or enhance the learning experience?’ and you will get a blank expression. Technology has infused and changed every part of this generation’s life—except for education.”

Donn Davis, co-founder, Revolution

In just two years, those born in the start of this millennium will be eligible to attend college (let that one sink in!) and as such it’s fair to assume that those students will expect certain technologies, software and hardware as standard. And as we continue further into the digital age, this expectation will only increase into the following generations. Other sectors are wasting no time in making the most of advanced software: e-commerce, entertainment, and travel have witnessed reduced costs and improved communications thanks to a host of improved tech. For education institutions, both students and teachers have the opportunity to benefit massively from mobile technologies, and yet a technology gap still remains.

The value of mobile apps

A study on mobile education in the United States by GMSA indicates that utilizing mobile in higher education establishments is quickly becoming an area for rapid innovation and subsequent growth. The study suggests a substantial move towards the adoption of mobile devices and applications among students and professors on campuses throughout the United States. Another interesting conclusion was that the expectation of access to a device – namely a laptop – is a given within higher education, but more recently has witnessed many universities making the switch from laptops to tablets, or even offering both.

Today’s students, more than ever before, expect personalized, mobile interactions in their education – with peers, professors and the broader campus community – as well as solutions to assist in managing their schedules and workloads. Common practices such as viewing class material, listening to podcasts or lecturer presentations, and checking class schedules can be done from a student’s personal smartphone. On the other side of the coin, lecturers, professors and other campus educators can benefit from a centralized space for subject information – using mobile devices to notify students of class updates, conduct quizzes, tests or polls and submit data while doing classroom field work, as well as directing their own ongoing personal research.

As the study shows, 70% of CIOs and senior IT leaders see mobile apps as an important part of campus plans to enhance instructional resources and campus services moving forward. Subsequently, some universities have begun to move away from running their own costly laptop programs, as the proliferation of student-owned smartphones and tablets and an ever-present Wi-Fi connection has lessened this need considerably. Instead, they are focusing their efforts on a solution that can empower faculty members, students and even campus alumni to connect with each other and to the information and resources they need. Particular interest lies in the potential use and support of campus mobile apps, acknowledged as “the new campus portal buttons on a smartphone screen replace the bookmarks on an internet browser or the hot links on a campus portal.”

Extend your existing portal to support mobile working

A tool such as SharePlus, from Infragistics, provides a flexible and reliable native mobile solution for both iOS and Android devices.

A centralized, connected workspace

Whether on-premises or in the cloud, students and teachers can access a single mobile workspace to work individually and as part of a team. SharePlus gives you the ability to collaborate on documents with SharePoint, Office 365, Dropbox, Google Drive and more. Calendars, announcements, tasks, social features and more are all available with the ease of mobile access.

A personalized experience

Different universities each with different faculties, staff and management result in a variety of different teaching styles and methods. Therefore, a solution that accommodates high levels of customization is vital for meeting the unique needs of higher education establishments. Custom mobile workspaces offer users a focused environment that is tailored to their needs.

The security of information

The increase in mobile devices and native mobile apps is often accompanied by concerns over the security of the content stored on them. SharePlus allows you to easily enforce and manage permissions, ensuring you’re in control at all times. Built-in security features and MDM integration offer added security to make sure sensitive information and content is right where it needs to be.

For more information on how SharePlus can help your institution transition in the modern way of working anywhere, anytime, visit the SharePlus site, or contact us today.