Do you sometimes long for the good old days of device management? In most organizations, all you had to think about was governing a series of desktop PCs, usually running on Windows. iOS and Android hadn’t even been invented, and the idea that anyone could connect to corporate data from anywhere seemed ludicrous. How times have changed!

Today, the floodgates have opened. Your colleagues likely use a whole range of smartphones and tablets in their personal lives. And, without understanding the complexity and risk this poses, they expect you to make it possible to connect these devices to the company portal. End users, don’t you just love them?

At present, IT managers, faced with this wave of requests - “why can’t I connect my smartphone to the Intranet?” – need to pay real attention to how they deal with this Device Diversity. You can’t take the ostrich position here and bury your head in the sand – ignoring Device Diversity will leave you open to risk.

What is Device Diversity again?

Gartner describes Device Diversity as “the growing variety of devices, computing styles, user contexts and interaction paradigms”. As the name suggests, there are now a huge amount of devices and a number of operating systems which your colleagues use to access company systems.

In a few short years’ billions of smartphones and tablets have saturated the market, all running different Operating Systems:

Source: IDC 2015

For each individual OS, there’s a big variety of system updates. And then there are all the different devices of varying age, size, power and security.

We’re all for Device Diversity (we’re big fans of Xamarin which lets developers build apps for different OS’ in one go). However, managing this diversity is complex, and requires significant governance. If you don’t maintain control over which devices your employees use to access corporate data, you open yourself up to risk. But there’s a Catch 22 here – if you do try and impose controls on which devices your colleagues can use, you face the risk of a staff mutiny.

What’s the problem with Device Diversity?

So, why’s Device Diversity a problem? We wouldn’t want a world where there’s only a handful of devices – diversity makes the market super competitive and very exciting. However, this diversity does pose a problem to businesses in the following areas:

• Security

If your employees are using older, outdated operating systems, these might be at risk of hacking. The latest OS’ all have the latest security patches too, and should, in theory, be protected against most threats. Older systems are less secure however, and are at greater risk of being breached. While your company portal should have a strong firewall, outdated and corrupted devices present a weakness for nefarious hackers to exploit.

• Apps functioning on all systems

If you have chosen an enterprise app where users can access the company Intranet from mobile, that app will need to be accessible from all devices. You’ll want updates deployed uniformly on each device type too - you don’t want Android users to be left behind the iOS owners. Keeping this up to date when workers use a wide range of devices and Operating System is really hard.

• Frustrated users

Tied into the previous point, if your app doesn’t work well on the user’s device, you can guarantee a long stream of complaints and moans. You’ll spend your days fixing these issues rather than doing what you’re really employed to do.

• Missed productivity opportunities

Again, if your Intranet doesn’t work well (or at all) on your employees’ devices, you’ll have wasted a lot of money on an app. Mobile should make people more productive, but if users can’t actually access their productivity tools from their device, you’re wasting time and budget.

So what am I supposed to do?!

Don’t worry, Device Diversity doesn’t have to be a bad thing. All it takes is a well-planned strategy which corresponds with your company’s and employees’ needs. Follow this consistently and Device Diversity will become your friend (or will at least be manageable).

You basically have two options for dealing with Device Diversity:

1.   Buy one device for all users in the company and end diversity!

This is the ‘anti-BYOD’ approach. If you have the budget, asking all your employees to use one specific device (or one of a limited number) is perhaps the ideal solution. If the devices are good quality and up to date, your employees will probably be pretty happy. What you don’t want however, is to enforce unpopular devices that no one wants to use.

2.   Provide colleagues with a list of accepted providers

Your second solution is to provide a list of ‘approved’ BYOD devices. Encourage 4-7 ‘ideal’ devices, but also ‘tolerate’ a number of other smartphones and tablets that can be used. Circulate an ‘out of bounds’ list too, which makes sure people don’t buy devices that won’t be compatible with the Intranet.

Whatever solution you choose, SharePlus from Infragistics configures with many of the most commonly used devices and OS’ in the field. Your users get a fully managed access to SharePoint from smartphones and tablets, even without an Internet connection. Most importantly, you maintain total control over the devices in your network, meaning Device Diversity is no longer a problem.

Try a free demo of SharePlus Enterprise today, and see how much more you can achieve from SharePoint on iOS.

Numbers without context are of very limited use. So it's a good thing that articles in newspapers and reports in the wider world will often compare the figures they relay to the (mean) average. But invariably that simply isn't enough to get a gauge of what the data being reported really tells us. There's an old "joke" about a statistician who drowned in a lake of average depth a few inches (the precise average depth seems to vary depending on who is telling the joke), but over-simplifying by just reporting or comparing with an average really can be highly misleading.

At the time of writing, the White Moose Café in Dublin in the Republic of Ireland has a rating of 3.8 stars (out of 5) on Facebook. From just this number, without looking at the distribution of scores, you might take that to mean something like "People generally think this is a good café which could perhaps make a few improvements to bump it above 4 stars". In fact the establishment has well over seven thousand reviews but only 42 reviewers gave it a 2-star, 3-star or 4-star rating! The overwhelming majority of ratings are either 1 or 5 stars. This rather extreme example of polarized opinions is the result of a disagreement between the proprietor and a vegan customer that led initially to a bombardment of negative reviews from many further vegans and a subsequent backlash from meat-eaters; It's safe to say most of the reviewers have never been to the café. (You can find out much more about this story here.) The average rating doesn't give us any hint of the underlying story.

So hopefully you can see why it's a good idea to go beyond just reporting (mean) averages or comparing one result to the average. We have plenty of other descriptive statistics that can tell us something more about the distribution of a set of results: median, mode, standard deviation, variance, skew, kurtosis, range, interquartile range... But frequently the best option is to visualize the results. Facebook does actually do this with its review system, as the screenshot below shows:

A classic example illustrating the need for visualization is Anscombe's quartet: a set of four small datasets of paired x and y values. All four datasets have identical mean (9) and variance (11) in the x variable and almost identical mean (~7.5) and variance (~4.12) in the y variable. The correlation coefficient for each dataset is also the same (0.82) to two decimal places. Actually plotting the data as a simple set of scatter plots highlights that the four datasets are, in fact, very different.

Perhaps most surprisingly, the linear regression lines for each set are (almost) the same. This is a case of garbage in, garbage out; if you try to fit a straight line to show how one variable effects another and the relationship is not even close to linear then don't expect your line to be even remotely representative of your data. Of course, we're not particularly good at absorbing and interpreting large amounts of data in tabular form so the fact set II isn't linear may not be entirely obvious in, say, a spreadsheet: Plot your data before trying to fit it!

Scatter plots are the obvious choice for paired datasets like Anscombe's. The one dimensional equivalent is the strip plot. Let's just use Anscombe's y values as a quick example:

The strip plots nicely highlights the presence of outliers in Set III and Set IV and show that the bulk of the data points lie between 5 and 10 for all sets.

Strip plots often work well when there is only a modest number of data points for each set. With larger datasets things quickly become overcrowded. One could try to get around this by giving each point a random vertical offset to clear things up a bit, essentially adding jitter to a non-existent second variable, but a more common alternative is to bin the data and create histograms. Below, for example, is a histogram made from 300,000 data points generated by a specific continuous random number generator.

Picking an appropriate bin width is important. Given that the above figure shows continuous data you may be able to tell that the bin width used is really unnecessarily wide. Instead of using bins one unit wide, we can decrease it to, say, 0.1 units wide.

Hopefully this makes it more obvious that the random number generator was pulling numbers from a normal distribution. The mean of the specific distribution was 15 and the standard deviation 2. In the next example numbers are drawn from a different normal distribution.

The normal distribution in this case has the same mean as the previous example — 15 — but the standard deviation is much bigger — 5. This means that the probability of getting a number below 8 or above 22 is much much higher than for the previous example. But there's no way of telling that if you just quote the mean.

Create modern Web apps for any scenario with your favorite frameworks. Download Ignite UI today and experience the power of Infragistics jQuery controls.

By now you should be familiar with the challenge of networking on the web. The world around us has become much more connected and we have almost constant access to the internet with mobile devices and the rise of wearable tech. As a result many of us are now far more likely to quickly surf the web for help rather than seek out a colleague who may or may not have the answers.

These behaviors have lead to the evolution of various online communities, where developers of all types and abilities can communicate in order to network and solve problems. Some of these sites can be graveyards for ancient requests, consisting of ‘How can I accomplish basic function X?’ followed by a lazy but functional answer which offers little to no real aspect of improving your abilities as a developer.

Others however are far more focused on the developers themselves and really do help them to become better at their jobs. One such site is CodeProject, which we’re going to take a look at today.

An established presence on the web

CodeProject was created in 1999 with the intention of providing computer programmers with a place to meet and discuss implementation of ideas. The site also acts as a resource for all of the latest technology news, and provides articles with source code that can help with day to day programming issues.

The main selling point of CodeProject is its user generated content, which comes in many forms:

Articles

These are resources by programmers for programmers. They contain top-quality information on how to tackle issues that will come up in the real world. The articles are sorted into “most viewed” and “most popular” in order to help you find the most relevant information.

Tutorials

These are for those who have just started to code.  They contain easy to follow step by step procedures that help beginners to understand the underlying principles of coding.

For example, if you’re aiming to start using SharePoint this year, why not start with a 5 star rated tutorial like SharePoint 2013 - Introduction, Features, and Roles.

Discussions

CodeProject has many discussion boards where you can chat with fellow developers. Whether the aim is to help or seek answers, the discussion boards can be a direct way to achieve these goals. The lounge feature can also be used to have a more laid back discussion with like-minded people but be warned... House rules apply!

Newsletters

Weekly newsletters highlight the latest and most popular articles and news pieces from the previous week. Newsletters can be customized to ensure they only contain relevant information from the vast archives of the site. This is a good way to curate the site’s content and filter out the things that may distract you from your task at hand.

Surveys

Weekly surveys help to paint a picture of popular opinions amongst developers. Whether it’s “How many hours a week do you code?“ or  “Will you write an app for a smartwatch this year?” the results can be used to get a grasp of how the rest of the community feels about the topic at hand. Each survey also comes with a message board underneath so readers can see context to the results.

Features

After checking out all of CodeProject's features we compiled these three tips which can be used to get the most value out of the site:

1. Connect

Try to network with people that you share passions with. Everybody on CodeProject has a personal profile which usually contains social media details. Don’t be afraid to send somebody a message as most users will have signed up with the intention to network or at the very least communicate.

2. Participate

Whether you are a newbie or an expert in your relative field you will always have some experience to offer. Remember that the perspective of a newbie may help to inspire valuable articles and resources from the other users on the site. If writing tutorials is not your thing, then try asking a few questions or checking if you can help with any of the unanswered questions.

3. Protect your Rep

Nobody likes a spammer and CodeProject is no different. It may sound obvious but come across as a real human being who values the community. That means being courteous and specific as well as searching through the resources for others who may have had the same issues as you. Keep your contributions consistent and who knows? Maybe you will be rewarded with the prestigious “Most Valuable Professional” award which is presented to a small handful of people annually based on their contributions in both article submissions and answering questions.

A valuable resource

The reason that CodeProject has amassed 11 million+ users is simple: Computer programmers love to interact with each other. All of the articles and discussion boards can be read without registering but the real magic happens when you sign up. Whether it’s downloading a zip file of the latest scripts or just having your own profile in the “Who's Who” list, you will surely notice yourself becoming a part of the community.

 Want to build your desktop, mobile or web applications with high-performance controls? Download Ultimate Free trial today or contact us and see what it can do for you.

Jargon is a funny thing isn’t it? A language that is ‘normal’ to a specific industry can be alien to others and quite naturally hard to pick up - take medical or legal orientations for example.  This level of verbal intricacy can be exacerbated by the frequency at which the validity of these terms can change. Whilst this may not be a risk for most professionals, anyone working within the tech industry will probably have fallen prey to this particular phenomenon. In SharePoint Parlance, one such term would be the term “app.”

For most people familiar with technology, an app has a specific meaning. Furthermore, most vendors have their own form of app store too. What Apple began, Google continued and Microsoft successfully gate-crashed.  An app represents a “thing” that a user can download to meet a need, whether this is a gaming, organizational or functional need.  App stores have conditioned people to seek out what they need and in a way, most users expect this form of transactional interaction across more technological walks of life.

What we want to explore in this post is how jargon changes have been applied to the SharePoint world we all know and love. It only seems recently that Microsoft revitalized the idea of an app store for SharePoint when the 2013 version was shipped. What we’d like to walk you through today is the renaming of these apps with the pending launch of SharePoint 2016 in the spring. Or as we like to call it, “The Microsoft Rename Game.”

App or Add-in?

The first inkling of change came from the Ignite conference at the turn of last year. Whilst we all tend to look out for the sexy headlines (SharePoint 2016 Hybrid, etc.) there is always value in looking at some of the smaller, less publicized stories that are produced at these conferences.

In our instance, the renaming of the SharePoint App Model to Add-in Model.

Sounds odd right?  Well, let’s delve into that.

The reasons behind this change can be summarized as such:

1. Confusion across Microsoft’s product range as to the exact meaning of the word App
2. Negativity from the Partner Network over the perceived meaning of the word

The Microsoft Product Range

The biggest reason behind the change is to garner a more harmonized and consistent experience across Microsoft’s products and stores.  Consider the large number of devices that Microsoft is catering for with device based Office products and you’ll get a lengthy list.  This would start with iOS devices, Android Devices and so on.  If a user downloaded what they perceived to be the Office “App” and then subsequently found there were other “apps” inside it, such as Word and Excel, it’s pretty clear to see why there would be confusion.

This conflict is also evident in the fully fledged desktop applications. The Apps tab gives access to both the Office Store and a summary of installed apps. Again, this is further evidence of where an “app within an app” can confuse users.

Feedback from the Partner Network

A secondary but no less insignificant reason, is feedback from the partner network.  An App in SharePoint can appear a simple thing to an end-user but in reality can be the results of significant amounts of work.  The app model allowed SharePoint developers to integrate non SharePoint data and any technology stack of their choosing into the product.  However, the caveat to this is pricing.

If the visible end product looks and feels like an app, those responsible for paying the bills may benchmark the value against a £5 application or some-such from a device app-store.

User behavior & moving forward

On the flip side though, Microsoft are using this perception positively. As users are already familiar with the notion of “adding things to SharePoint / Office”, the name change really becomes quite easy to understand.  So, from here onwards, the new terminology that Microsoft would like to push is:

• SharePoint Add-ins
• Office Add-ins

Jeremy Thake, senior Product Marketing Manager at Microsoft, has provided a list of useful terms on his blog which you can check out here. For a quick glance, here’s that all important new naming convention list…

Making things easier

Lastly, please keep in mind that the confusion is only made worse by the state of flux that Microsoft is in. Documentation is still being updated and lots of literature is still to be written. 

The new naming convention will, in the long run, make things a lot easier and straighter forward to understand.  Removing the ambiguity over specific terms across the Microsoft space will only lead itself to both positivity and profitability.

The provider() function allows us to create a configurable service where we can set input per application for the service created using the provider (). For example, if we need to set API key to access a service on the application level, we can set that in the module config and pass input to the provider using the $provide service. All the others ways to create services internally use the $provide service.

Creating a service using $provide service in module.config

Let us start by creating a very simple service using the provider() function.  

app.config(function ($provide) {
    $provide.provider('globalsetting', function () {this.$get =function () {var appname ="Lawyer App";return {
                appName: appname
            };
        }
    })
});

 Let’s explore what is going on in the above snippet. To create a service using provider, we need to use the $provide service. The provider function of the $provide service takes two parameters: the name of the service and the function. A provider function must have a $get function. To create a simple service using the provider(), we need to perform following five steps:

1. Inject the $provide service in the app config method
2. Create a provider using the provider() function
3. Pass two parameters to the provider() function: the name of the service and a function
4. The provider function must contain a $get function
5. Return an object literal from the $get function

We can use the globalsetting service created using the provider by injecting it in a controller as shown in the listing below:

app.controller("ProductController", function ($scope, globalsetting) {

    $scope.name = globalsetting.appName;

});

Eventually, we can display data from the globalsetting setting service on the view by using the ng-controller directive as shown in the snippet below:

<div ng-controller="ProductController">
        {{name}}</div>

Creating a service using the provider () as a function of the module object

We have created a service using the provider inside the config of module. There is also another way to create a service using the provider: AngularJS also has exposed the provider() function on the module object. For simplicity’s sake, we can directly use the module.provider() to create a service and register the created service in the config of module.

To create the service using the provider() function on the module object, we need to:

1. Create a service using the module.provider()
2. Register the service in the module.config()
3. While registering the service, we need to append the Provider with the service name. So if the service name is globalsetting, we will register in module.config as globalsettingProvider

Let us recreate the globalsetting service using the module.provider() function:

app.provider('globalsetting', function () {this.$get =function () {var appname ="Lawyer App";return {
            appName: appname
        };
    }
});

In step 2, we need to inject the service to the app config. Do you remember injecting the $routeProvider? In the same way, we need to inject the globalsettingProvider in the app config as shown in the snippet below:

app.config(function (globalsettingProvider) {
});

There is no setter in the globalsetting service, so we are not passing any value to the service created using the provider. We can use globalservice in the same way as when it was created using the $provide service in the config:

app.controller("ProductController", function ($scope, globalsetting) {

    $scope.name = globalsetting.appName;

});

Creating Setter for the provider()

Let us take a look in the globalsetting service. Right now we are hardcoding the name of the app, but in a real life scenario, we may want to pass the name of the app from the main module app. To do this, we need to create a setter for the provider. Setters are nothing but a function like $get in the provider.  We can create a setter for the globalsetting service provider as shown in the listing below:

app.provider('globalsetting', function () {var appname ="LAWYER APP";this.setAppName =function (value) {
        appname = value; 
    }this.$get =function () {return {
            appName: appname
        };
    }

});

Let’s see what’s going on in here:

1. We created a setter function.
2. We are passing a parameter in the setter function.
3. We’re also setting the appname with  parameter passed 

Now while injecting the globalserviceprovider to the app config, we can pass the name of the app.

app.config(function (globalsettingProvider) {
    globalsettingProvider.setAppName("Infragistics App");
});

Eventually globalservice can be used in the controller as shown in the listing below:

app.controller("ProductController", function ($scope, globalsetting) {

    $scope.name = globalsetting.appName;

});

Refactoring factory () to use $provide service

As we discussed earlier, the service() and factory() functions are just syntactic sugar on $provide and internally uses $provide. Let us see how we could refactor a service created using the factory() to use $provide. Here we’re creating a service called greet using the factory() as shown in the listing below:

app.factory('greet', function () {return {
        message:"hello to my app"
    }
});

Internally, the factory() function uses the $provide service. So instead of using the factory() method on the module object, we can create the following as the service:

app.config(function ($provide) {
    $provide.factory('greet', function () {return {
            message:"hello to my app"
        }
    })
})

As you can see, the $provide service exposes a factory() method, which takes two parameters: the name of the service and the function.  So we can conclude that using the factory() function to create a service is a simplified syntax of $provide.factory().

Where to use a Provider

We should use a provider when we are creating a service for the entire application. For example, when we are creating service to retrieve data from the API we need to set the API key once per application. We can set that in the config of app and pass that to the setter function of the provider.

And that about covers it for AngularJS providers! I hope you find this post useful, and thanks for reading!

With each passing day, new devices with new screen sizes are popping up - and as web developers, we need to create web applications that are responsive to these various screen sizes. There are multiple ways you can create a responsive layout, however I find Bootstrap grid layout to be the easiest. In this post, we will cover various aspects of the Bootstrap Grid system with various examples. To start with let us create a four equal column layout for medium-sized devices in Bootstrap Grid system.

4 equal columns layout

To create the layout, you need to complete the following steps:

1.       Create a div with class container for fixed width or container-fluid for the full width of the screen

2.       Create a div with class row. Div with the class row must be inside container

3.       Create 4 divs for 4 columns.  Div of the column must be the immediate child of the row div

4.       Content will be inside the column div

To create four equal columns in a row, I have created four divs with the class set at col-md-3 as shown in the listing below:

  <divclass="row">

            <divclass="col-md-3">

                <buttonclass="btn btn-success">column1</button>

            </div>

            <divclass="col-md-3">

                <buttonclass="btn btn-info">column2</button>

            </div>

            <divclass="col-md-3">

                <buttonclass="btn btn-danger">column3</button>

            </div>

            <divclass="col-md-3">

                <buttonclass="btn btn-warning">column4</button>

            </div>

        </div>

The Bootstrap Grid system divides the available width of the screen to 12 columns.  So to create four columns, we have used col-md-3 class (for medium devices).

3 unequal columns layout

To create three unequal columns in a row, I have created three divs with the class set at col-md-3, col-md-6, and col-md-4 as shown in the listing below:

<divclass="row">

            <divclass="col-md-3">

                 <h2>some text</h2>

            </div>

            <divclass="col-md-6">

                <h2>some text</h2>

            </div>

            <divclass="col-md-4">

                <h2>some text</h2>

            </div>

        </div>

We have used class .col-md-* to create the layout, one with equal columns and another with unequal columns for medium devices. For other devices, we have other classes available which we’ll discuss later in the post. Let us go further to discuss theoretical concept of Grid system.

Bootstrap Grid System

The Bootstrap 3.0 Grid system was designed with mobile in mind. It is responsive and it gives us classes to create layouts for extra small devices, small devices, desktops, and extra larger desktops. Various classes provided to us for various kind of devices are shown in the image below:

The Bootstrap Grid system divides each type of screen into 12 columns. The width of the columns depends on the screen size, but Bootstrap considers various screens sizes and their columns sizes are as follows:

These 12 columns can be scaled up or down in different variations depending on the screen size, as shown below:

We can create above layout for medium size devices using the listing below:

  <divclass="container">

        <divclass="row">

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

            <divclass="col-md-1">

                col-md-1

            </div>

        </div>

        <divclass="row">

            <divclass="col-md-2">

                col-md-2

            </div>

            <divclass="col-md-2">

                col-md-2

            </div>

            <divclass="col-md-2">

                col-md-2

            </div>

            <divclass="col-md-2">

                col-md-2

            </div>

            <divclass="col-md-2">

                col-md-2

            </div>

            <divclass="col-md-2">

                col-md-2

            </div>

        </div>

        <divclass="row">

            <divclass="col-md-3">

                col-md-3

            </div>

            <divclass="col-md-3">

                col-md-3

            </div>

            <divclass="col-md-3">

                col-md-3

            </div>

            <divclass="col-md-3">

                col-md-3

            </div>

        </div>

        <divclass="row">

            <divclass="col-md-4">

                col-md-4

            </div>

            <divclass="col-md-4">

                col-md-4

            </div>

            <divclass="col-md-4">

                col-md-4

            </div>

        </div>

        <divclass="row">

            <divclass="col-md-6">

                col-md-6

            </div>

            <divclass="col-md-6">

                col-md-6

            </div>

        </div>

    </div>

Rules to use Bootstrap Grid system

To work with the Bootstrap Grid layout, we need to take care of the following points:

·         Rows must be placed either within a container (for fixed width) or container.fluid (for full width) to fetch proper padding and alignment.

·         Columns must be immediate children of rows.

·         Content should be placed inside the columns.

·         Each rows has two available columns.

·         If more than 12 columns are placed within a single row, each group of extra columns will, as one unit, wrap onto a new line.

Creating layout for medium devices

Let us say that we need to create a layout for medium device with following requirement

·         Should have three columns

·         Width of the 1st column should be equal to width of 2 columns.

·         Width of the 2nd column should be equal to the width of 6 columns.

·         Width of the 3rd column should be equal to the width of 4 columns.

This layout can be created as shown in the listing below:

<divclass="container-fluid">

<divclass="row">

            <divclass="col-md-2">

                <h2>.col-md-2</h2>

                <p>some text</p>

            </div>

            <divclass="col-md-6">

                <h2>.col-md-6</h2>

                <p>some text</p>

            </div>

            <divclass="col-md-4">

                <h2>.col-md-4</h2>

                <p>some text</p>

            </div>

 </div>

</div>

This will create a layout as shown below:

If you do not wish to work with the full width of the device and want to use a fixed width, put the row div inside the container class as shown in the listing below:

<divclass="container">

<divclass="row">

            <divclass="col-md-2">

                <h2>.col-md-2</h2>

                <p>some text</p>

            </div>

            <divclass="col-md-6">

                <h2>.col-md-6</h2>

                <p>some text</p>

            </div>

            <divclass="col-md-4">

                <h2>.col-md-4</h2>

                <p>some text</p>

            </div>

 </div>

</div>

Here the layout would be created as shown in the image below which is using the fixed width:

If we put more than 12 columns in a single row then the extra columns as unit will be stacked to the next line.

Creating layout for small devices

Let us say that we need to create a layout for a small device with following requirements:

·         Should have three columns

·         Width of 1st column should be equal to width of 2 columns.

·         Width of the 2^nd should be equal to the width of the 6 columns.

·         Width of the 3rd should be equal to the width of the 4 columns.

This layout can be created for small devices as shown in the listing below:

<divclass="container-fluid">       

        <divclass="row">

            <divclass="col-sm-2">

                <h2>.col-sm-2</h2>

                <p>some text</p>

            </div>

            <divclass="col-sm-6">

                <h2>.col-sm-6</h2>

                <p>some text</p>

            </div>

            <divclass="col-sm-4">

                <h2>.col-sm-4</h2>

                <p>some text </p>

            </div>

        </div>

    </div>

This snippet will give you the layout shown in the image below. As you may notice, the width of the second column is thrice of the width of first column. Also the other important point you may notice is that the columns are not stacking vertically, even when the width of the browsers is reduced (simulating small devices).

In the same way, layouts for large and extra small devices can be created using the classes .col-mg-* and .col-xs.* respectively.

Creating layouts for tablet and desktop

We can combine the col-md-* class and col-sm-* class to create layouts for desktops and tablets. We can create a layout of three unequal columns as shown in the listing below: 

<divclass="row">

            <divclass="col-md-2 col-sm-2">

                 <h2>some text</h2>

            </div>

            <divclass="col-md-6 col-sm-6">

                <h2>some text</h2>

            </div>

            <divclass="col-md-4 col-sm-4">

                <h2>some text</h2>

            </div>

        </div>

The above created layout would be responsive to both medium screen size desktops and the tablets.  

Creating layout for tablet, desktop, and mobile

We can combine the col-md-* class, col-xs-*, and col-sm-* class to create layouts for desktops and tablets – let’s see how to create a layout of three unequal columns as shown in the listing below: 

<divclass="row">

            <divclass="col-md-2 col-sm-2 col-xs-2">

                 <h2>some text</h2>

            </div>

            <divclass="col-md-6 col-sm-6 col-xs-6">

                <h2>some text</h2>

            </div>

            <divclass="col-md-4 col-sm-4 col-xs-4">

                <h2>some text</h2>

            </div>

        </div>

The above created layout would be responsive to both medium screen size desktops, mobile devices and tablets.            

Nesting columns

Bootstrap allows the nesting of columns as well, which means we can put rows and columns inside an existing column. Keep in mind that even in nesting, the sum of the total columns should not be greater than 12 in a same row.  To understand this better, let us consider the following scenario:

·         There is a row.

·         There are two columns in the row.

·         The First column is of class col-md-4.

·         The Second column is of class col-md-8.

·         There is a nested column inside the first column.

Here, the maximum number of nested column would be 12 inside the col-md-4. More than 12 columns would be stacked to the next line in the first column.  Let us consider the listing below, where we have kept more than 12 nested columns.

<divclass="row">

            <divclass="col-md-4">

                <divclass="row">

                    <divclass="col-md-2">

                       <h2>text here</h2>

                    </div>

                    <divclass="col-md-2">

                        <h2>text here </h2>

                    </div>

                    <divclass="col-md-2">

                        <h2>text here </h2>

                    </div>

                    <divclass="col-md-2">

                        <h2>text here </h2>

                    </div>

                    <divclass="col-md-2">

                        <h2>text here </h2>

                    </div>

                    <divclass="col-md-2">

                        <h2>text here </h2>

                    </div>

                    <divclass="col-md-2">

                        <h2>text here </h2>

                    </div>

                    <divclass="col-md-2">

                        <h2>text here </h2>

                    </div>

                </div>

            </div>

            <divclass="col-md-8">

                <h1>I am level  - col-md-8  </h1>

            </div>

        </div>

Here we have put more than 12 nested columns in the first column of the main row. Extra nested columns would be stacked to next line as shown in the image below:

Column Offset

Bootstrap allows us to move columns to the right using the class .col-md-offset-*. So let us say we want to move a column by 4 columns to the right, then we will have to use the class col-md-offset-4. This can be done as shown in the listing below:

<divclass="row">

            <divclass="col-md-5 col-md-offset-4">

               <h2>moved 4 columns right</h2>

            </div>

            <divclass="col-md-3">

                <h2>col-md-3  </h2>

            </div>

        </div>

Offset columns are then displayed as shown in the image below:

Column Push and Pull

Bootstrap also allows us to reorder columns, too. We can use col-md-push-* or col-md-pull-* classes to do this:

<divclass="row">

            <divclass="col-md-9 col-md-push-3">col-md-9 col-md-push-3</div>

            <divclass="col-md-3 col-md-pull-9">col-md-3 col-md-pull-9</div>

 </div>

Here, the first column would be pushed by 3 columns to the right and second column would be pulled to 9 columns to the left as shown below:

Conclusion

As we’ve demonstrated, you can use various classes provided by Bootstrap to create responsive layouts for your web applications. In this post, we focused on row and columns classes along with offset, push, pull, and nesting the columns. I hope you find this post useful, and thanks for reading!

Create modern Web apps for any scenario with your favorite frameworks. Download Ignite UI today and experience the power of Infragistics jQuery controls.

Have a few minutes of down-time today? Why not check out the hot topics from the past 2 weeks, as identified by the elite developer community here at Infragistics?

5. Responsive Web Design: What the Internet Looks Like in 2016 (Canva)

4. What Should I Make? Beginner Programming Project Ideas (Programming for Beginners)

3. Why You Should Avoid Job Titles Like “Coding Ninja” (And What You Should Do Instead) (LinkedIn)

2. Useful Apps To Learn Design And Coding On Your Smartphone (Forbes)

1. What Program Languages Should I Use? (Java, C#, C++, or HTML5) (CodeProject)

You know wireframes. The white-gray-black series of doodles of your website, mobile app, rich app - that make the process proper, eliminate logical flaws and ultimately save project time.

Cool. Except, sometimes they don’t.

Wireframes, even the interactive ones, don’t make much sense to someone who hasn’t dealt with wireframes before, or doesn’t have the time, ability or desire to understand them. And often times, that someone is the project’s decision maker.

What can we do?

Too often, wireframes are as dull and unengaging as the plot of Deadpool - one guy takes revenge and kills a truckload of people in the meantime. Nothing remarkable, we have seen that a million times.

But Deadpool is awesome. What makes it great are the punchlines flying around all the time. References to other Marvel movies (e.g. X-Men), unrelated flicks and series (e.g., Homeland), mockery and self-irony (e.g., Ryan Raynolds’ acting abilities) give life to the basic structure of the movie.

Here’s a crazy idea: How about we make the person looking at our wireframes enjoy themselves, so they actually spend more time on it?

How about we include cultural references here and there. For example:

A) Turn to advertising. Let the professional copywriters do your job. Include a famous TV commercial slogan (try „Just do it“ or „Do the Dew“ for your good old action button);

B) Pay tribute to screenwriters and songwriters. Replace the „lorem ipsum“ paragraphs with the lyrics of a song or a quote from a movie character.

Spice up your wireframe with paragraph text from Breaking Bad

C) Movie posters have it all. Is the company you’re making a website for selling soap? Try the headline of Fight Club „Mischief, mayhem, soap“. It sticks.

A few words of advice,

should you go down this path of the dark side:

1. Make sure you use cultural references that your audience will understand (see what I did in the previous sentence?) and not be offended by.

2. Don’t confuse people. This is a wireframe/prototype that should make sense to the person looking at it - if it’s a button for „go“ (Start), don’t write „Gone in 60 Seconds“. It won’t make sense.

3. Don’t spend twice as much time on the wireframe/prototype just because you want to sound smart. It’s not about you. It’s about the wireframe and saving time for the project.

4. Don’t overdo it. You don’t need to make every line a punchline. Have one killer one and leave it at that.

5. Know your audience. If your client is a serious enterprise investing millions in the project, be careful. There are the people who love Deadpool, and there are those who just think it’s just not serious enough.

6. Use what’s given to you. This approach is used to replace lorem ipsum / dummy texts. If someone made the effort to give you the text that’s actually going to be in the final product - use it. Don’t change text for fun’s sake - you’re not a comedian.

So, will this approach make any dull wireframe awesome?

Heck no — it’s your job to make a great, easy-to understand, breeze-to-click-through wireframe that helps rather than confuses the audience. But pouring some heart and soul and a few funny lines can give that excellent wireframe of yours an extra edge. To infinity and beyond! Let me know if you’ve tried this approach, and whether it has done miracles for you, or you've lost that million-dollar contract because of too much fun you had while prototyping.

Do you think Twitter is all about procrastination? You’d be wrong. Following a wide range of Twitter users, sourcing information from a variety of accounts and really engaging with posts can have considerable benefits for your professional life.

A recent five year study taken by over 200 Twitter users discovered some fascinating insights into the impact the social network has had on their professional lives. Twitter offered a range of benefits to the study’s respondents, yet by far the most important was that they were more likely to innovate and suggest new ideas. The study discovered that the more diverse a person’s network of friends and sources on Twitter, the more innovative their ideas tended to be.  

Twitter is all about sharing news, ideas and cutting-edge stories. It’s therefore no surprise that by accessing all this information first, you’ll be able to act on it in your professional life.

The report’s authors highlighted two specific ways Twitter increases our ability to assimilate – and then use – all this new information:

1.   Idea scouting– when you identify new ideas by following experts on Twitter.

2.   Idea connecting– when you see new ideas on Twitter and relate to how these could be used in your own organization as a business opportunity. Typically, this will involve sharing the new idea with the most appropriate stakeholders in the business.

It’s clear that when used wisely, Twitter can give a real boost to your career. So, if you’re a developer who works with SharePoint, how can you use Twitter to scout and connect new ideas? By following some of the experts in our list of the five best SharePoint pro Twitter accounts, that’s how!

1. Office 365 Community

Office 365 Community is a developer focused Twitter feed from Microsoft. It provides all the latest news and updates in technical aspects of Office 365 and SharePoint. By following Office 365 community you’ll be informed about:

• The latest news about Microsoft events around the world.
• General community information.
• Information on previews and other releases.
• Information about webinars, Twitter-jams and Q&A’s.

How will it help you?

Office 365 Community can give you direct insight into the latest news relating to SharePoint and related products. You’ll have an idea of what’s going on before anyone else and will be able to impress your boss with knowledge on new products and patches.

2. Chris O'Brien

SharePoint MVP, blogger and all-round expert; UK-based Chris O’Brien is definitely one to follow. With years of experience as a SharePoint consultant, and making regular appearances at Microsoft and SharePoint events, Chris is a big deal in the SharePoint dev world. By following Chris you’ll get all the latest on:

• Reports and news on problems and fixes.
• Responses to your burning SharePoint dev questions.
• The latest news on webinars and related events.
• Hot-off-the-press blogs by Chris himself.

How will it help you?

Following Chris will provide you with insights into SharePoint development and you’ll be made aware of Chris’ latest blogs as soon as they’re released. From great in-depth blogs to an insightful how-to, Chris shares plenty of his expert knowledge. Who wouldn’t want to access that?

3. Jeff Teper

As corporate vice-president of SharePoint and OneDrive, Jeff Teper is about as close to the SharePoint action as can be. He has enormous expertise and insight into the product’s future, which makes following Jeff a wise idea. Expect doses of:

• Insights into the world of Microsoft.
• A lot of love for developers!
• The latest news on product development.

How will it help you?

We highlighted Jeff in our recent ‘SharePoint Experts’ post. With Jeff’s updates popping up in your newsfeed, you’ll always have the latest authoritative insights into the future of SharePoint - extremely useful if you want to know the direction SharePoint is headed.

4. Vesa Juvonen

Vesa Juvonen is a Microsoft-certified solution master and Senior Program Manager for SharePoint and Office 365. What this means is that the Helsinki native spends his days developing the vision for the future of SharePoint. You need to follow Vesa for:

• Up-to-the-minute product release details.
• Information about new version updates.
• Insights into changes, plans and policy in Redmond.
• New podcasts and webinars.

How will it help you?

Put simply, following Vesa will give you all the latest news right from the heart of SharePoint and Office 365. As a core member of the Office 365 Dev Patterns and Practices team, which provides regular blogs, documentation and best practice advice for developers, you’ll know how and where to get the latest updates and make your environment the best it can be.

5. Matthias Einig

An MVP and founder of influential development tools company Rencore, Matthias is a force to be reckoned with in the SharePoint world. Tweeting regularly on a wide range of news and updates, Matthias engages with the community about:

• App development
• Tips and tricks to improve your environment
• Interesting and noteworthy news and articles from other sources
• Info on the latest events

How will it help you?

Following Matthias will provide real insight into best practice around SharePoint development, and introduce you to a range of new ideas and innovations – key to giving you the inspiration you need to improve your own environment.

Looking to extend SharePoint to mobile devices? Try a free demo of SharePlus Enterprise today, and see how much more you can achieve from SharePoint on iOS.

I've previously noted that I think stacked area charts are frequently used when a conventional line chart would be a better option. Here is the (fictional) example I used previously and the conventional line chart alternative.

In short, if you want people to be able to make reasonably accurate judgments of the magnitudes of the individual components, and how they change depending on some other variable (such as time), the conventional line chart design is almost always going to be the best option. The lack of a steady baseline for all but the bottom component makes this task difficult for the stacked area chart.

Stacked area charts can be useful if you want to illustrate an ordered sum of components that change with another variable. While previously I suggested how the cost of milk production from farm to shop might change with time might be suitable, here I'd like to consider something very different: selected mathematical series.

You're probably familiar with trigonometric functions like sine and cosine and you may also know about the exponential function and hyperbolic functions. It's fairly easy to draw graphs of these functions if you have a calculator of some sort. When tied up in complicated equations, these functions may become awkward to deal with. Consequently, alternative ways of approximating these functions can come in very handy.

The functions mentioned above are all analytic functions. What this really means is quite complicated to attempt to explain so I won't try to do so here. Instead I'll just stick to the following: these functions can all be written as a sum of powers of their argument (typically denoted x), that is, as a polynomial. Being explicit helps, so here is a way of rewriting the exponential function:

In a similar manner, here is another way of expressing the cosine function:

And here is the hyperbolic cosine function (typically written as cosh):

In general, to get an exact value for one of these functions using summation we need to sum to infinity. This is not the case at the origin where all but the first term will equal 0. Close to the origin we will also get a good approximation as x is small. But how close and how good? We can plot the first few terms of, for example, the exponential function expression and see. The black line in the GIF below shows the exact exponential function, the blue wedges show the result of adding more and more terms from the right-hand side of the equation (from the zeroth power of x up to the 8th) for the exponential function above. The translucent red wedge indicates the area not covered by the polynomial approximation.

Below about x=1 we can see that the first three terms of the polynomial are a pretty good approximation for the exponential function. To get a good approximation around x=3 we need to go up to the sixth or seventh power of x (i.e. seven or eight terms of the polynomial). As the GIF below shows, even going to the eighth power of x isn't sufficient around x=6.

We can look at the hyperbolic cosine function in a similar way, though there are no terms with odd powers of x.

As you might expect, when we look at large distances from the origin, we need more and more terms of the polynomial in order to closely match the exact function. At x=±6, adding up terms up to the 8th power of x is not sufficient to get a good approximation.

I think these are cases where stacked area charts can be of real use. We're genuinely interested in the progressive sums of components, not the individual parts and that's where stacked charts excel.

You probably noticed that I skipped over producing charts for the cosine function. That's because stacked charts fail. Why? Because successive terms have opposite signs. While including more and more terms in the polynomial approximation does get you closer and closer to the exact function, you can't show this as a simple stack because some terms add to the total while others subtract. This also a problem for the exponential function when x is negative: terms involving even powers of x will be positive while those involving odd powers of x will be negative. This is a purely visual issue that doesn't crop up when we plot lines instead of stacks.

Hopefully I've shown that stacked area charts can be useful when it is the ordered sums of components that are of interest and if the conditions are right. For the conditions to be right then all components of the stack must share the same sign (or be 0) at each (visible) point along the horizontal axis.

Bring high volumes of complex information to life with Infragistics WPF powerful data visualization capabilities! Download free trial now!

UXify US is an annual half day conference about designing great digital experiences.

This year’s fourth annual user experience conference, UXify, brings together the community of academics, practitioners, technologists, and business leaders for a conversation about Migrating from Desktop to Web and Mobile.

Thought leaders from across the East coast will be discussing applied design, UX, content strategy and development at Infragistics ultra-sleek, central NJ-based headquarters.

We invite you to join us! It's an excellent opportunity to network, learn, share knowledge and gain new insights!

When

Saturday, April 9

Noon - 5PM

Where

Infragistics Headquarters

2 Commerce Drive

Cranbury, NJ 08512

Why Should You Attend?

Designing great user experiences isn’t easy. It takes a great deal of knowledge, experience and passion. Now add the complexity inherent in legacy business applications and you start to get an idea how daunting it can be when the decision is made to take an existing desktop application and migrate it to the web.

Key to a successful migration is NOT responsive design. It’s an understanding of how the web-based environment (and access to it via mobile devices) changes the user’s interaction dynamic. Allow users to get up from their desks and suddenly you notice that they want to do their jobs (and interact with your application) in ways not previously considered (work from the train anyone?).

Selected 2015 Conference Presentations

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

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

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

-------------------------------------------------------

Kevin Richardson has been working in the area of user experience for 25 years. With a PhD in Cognitive Psychology, he has deep experience across business verticals.

On the weekends, you can find Kevin on his motorcycle, racing for Infragistics Racing.

When you start learning the very first characteristics of AngularJS, you may come across something called Dependency Injection (DI): the premise that AngularJS injects dependencies whenever an application needs them. As a developer, our task is only to pass the dependency to the module and everything else will be taken care by AngularJS.

To create a controller, we pass $scope object and other dependencies to the module’s controller function. For example, to create a ProductController, we are passing $scope object and Calculator service dependencies. As a developer our job is to pass the dependencies and AngularJS will inject them whenever the application needs them.

As a developer, we really don’t care about how AngularJS injects dependencies – we don’t need to know how the injection process works to develop applications.  However, it is better if we know different ways of passing dependencies. In AngularJS, dependencies can be passed in three possible ways. They are as follows:

1. Passing a dependency as Function Arguments
2. Passing a dependency as Array Arguments
3. Passing a dependency using the $inject service

Let us explore these options one by one.

 Passing a dependency as a Function Argument

Perhaps most of the time you pass a dependency as a function argument, which is perfectly fine. For example, we pass a $scope object to create a controller as shown in the listing below:

app.controller("ProductController", function ($scope) {

    $scope.message ="Hey I am passed as function argument"

});

Passing dependencies as function arguments works perfectly fine, until we deploy the application in the production with a minified version of the application. Usually to improve the performance, we minify the application in production, but passing the dependency as a function argument breaks when we minify the application.

Obviously in production, for better performance, we would like to deploy the minified version of the application, but the application will break because the parameter name will change to a shorter alias name. To avoid this break in production, we should choose another option.

Passing a dependency as Array Arguments

Perhaps the most popular way of passing a dependency in an AngularJS application is passing them as Array Arguments. When we pass a dependency as an Array Argument, the application does not break in production when we minify the application. We can do this in two possible ways.

1. Using the Named function
2. Using the Inline Anonymous function

Using the Named function

We can pass dependencies as Array Arguments with the named function as shown in the listing below:

var app = angular.module('app', []);function ProductController($scope) {
    $scope.greet ="Infragistics";
};
app.controller('ProductController', ['$scope', ProductController]);

As you’ll notice, we are passing a dependency $scope object in the array along with the name of the controller function. More than one dependency can be passed, separated by a comma. For example we can pass both $http service and the $scope object as dependencies as shown in the listing below:

var app = angular.module('app', []);function ProductController($scope,$http) {
    $scope.greet = $http.get("api.com");
};
app.controller('ProductController', ['$scope','$http', ProductController]);

As we discussed earlier, passing dependencies as Array Arguments does not break application when we minify the application.

Using the Inline Anonymous function

Personally I find using a named function much more convenient than using an inline anonymous function. For me, it’s easy to manage the named controller function. If you prefer the inline function, you can pass dependencies as array arguments exactly the same way you pass them in named controller functions. We can pass dependencies in an inline function as array arguments, as shown in the listing below:

var app = angular.module('app', []);

app.controller('ProductController', ['$scope', '$http', function ($scope,$http) {

    $scope.greet ="Foo is Great!"
}]);

Keep in mind that dependencies injected as Array arguments work even if we minify the application.

Passing a dependency using the $inject service

There is one more way to inject dependencies in AngularJS: by using the $inject service. In doing so, we manually inject the dependencies. We can inject $scope object dependencies using the $inject service as shown in the listing below:

function ProductController($scope){
    $scope.greet ="Foo is Not Great!5";
}

ProductController.$inject = ['$scope'];

app.controller('ProductController', ProductController);

Using the $inject service also does not break the application when we minify the application for production. Most often we will find $inject services being used to inject dependencies in unit testing of the controller.

Before we end this article, let us see how we can use $inject to inject a service to the controller in a real time application. We have created a service as shown in the listing below:

app.factory("Calculator", function () {return {
        add:function (a, b) {return a + b;
        }
    }
});

We need to use a Calculator service inside CalController. The CalController can be created as shown in the listing below:

app.controller('CalController', CalController);function CalController($scope, Calculator) {

    $scope.result =0;
    $scope.add =function () {
        alert("hi22");
        $scope.result= Calculator.add($scope.num1, $scope.num2);
    }
};

At this point, the application should work because dependencies are passed as function arguments. However, the application will break when we minify it. So let us go ahead and inject the dependencies using the $inject as shown in the listing below:

CalController.$inject = ['$scope', 'Calculator'];

On the view, the controller can used as shown below:

<div ng-controller="CalController"><input type="number" ng-model="num1" placeholder="Enter number 1"/><input type="number" ng-model="num2" placeholder="Enter number 2"/><button ng-click="add()">Add</button>
        {{result}}</div>

And there you have it: how to interject dependencies in AngularJS apps. I hope you find this post useful, and thanks for reading!

Our series would be incomplete if we didn't take a moment to head to Maryland and dig into the meetups in Baltimore! Check out the infographic below and mark down a meeting date!

Share With The Code Below!

On February 19th we hosted a webinar titled “Creating a Single Page Application using AngularJS and Web API” for the Indian 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 create your own SPA, including the ins and outs of Web APIs, how to expose CRUD operations on data, how to create different views for your SPA, and more. You can view the recording of the entire presentation here:

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

You can also find presentation slides here.

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

I recently waited for a flight in Newark Liberty International Airport’s Terminal C. Expecting the typical travelling experience of delayed departures and time wasted waiting at the gate, I was surprised to find that the poorly rated airport had implemented a massive upgrade to their customer experience by installing iPads at every seat in the terminal.

This upgrade, courtesy of the innovative company OTG, drastically changes the travelling experience by providing a means for all passing travelers to monitor their flight status, browse the web, and even order food straight to their seat and pay for it with a built-in credit card reader. Experiencing this new way to kill time in an airport terminal made me consider the effect of minimizing the gaps between customers and satisfaction. 

In the past, grabbing a quick bite to eat between connecting flights has rarely been more appetizing than a stop at a magazine stand or fast food counter. A stressed traveler pressed for time will sacrifice quality for ease of access (a choice familiar to everyone who has ever taken a road trip on the interstate highways). And keeping yourself occupied while waiting for a flight (and eating your pre-packaged turkey wrap) usually involves a frustrating interaction with unreliable airport Wi-Fi or searching for an available charging station. With the installation of new, self-serve technology (and free Internet access, including your flight’s gate number and boarding time), a larger range of quality choices has become easily accessible to customers. Any traveler can pick an open seat and gain instant access to the range of services provided by United.

This self-serve method has the power to change what was previously a dreaded experience into something like a casual stop in the Apple store, all while minimizing the stress of flying. Users of all ages can walk up to an inviting interface and explore what it has to offer. By providing a commitment-free way to spend time at arm’s reach, United has demonstrated that they understand some of our fundamental needs as airport users and actually improved our experience.

Microsoft’s .NET Foundation has now been running for around two years, after its initial announcement by Scott Guthrie at the Build 2014 conference (highlights of which can be found here). The .NET Foundation was created to foster the open development of the .NET ecosystem, and to use community participation and rapid innovation to help fortify it. But, for that to sound like any kind of impressive feat, we first need to understand what the .NET Framework is.

What is .NET?

The .NET Framework began its life as a proprietary framework for building Windows apps, but Microsoft changed the license model to more closely follow a contemporary community-developed open source type project.

Almost all .NET framework applications, components and controls are built using Microsoft’s Frame Class Library (FCL) as a basis. One of the big selling points of .NET  is its language interoperability– a feature which allows code to be written in different languages. The primary language used in .NET applications is C#, but other popular options include:

• VB.NET
• J#
• F#

Microsoft has of course deeply accommodated .NET into their integrated development environment (IDE) Visual Studio. As with many of Microsoft products, if you go all in you get many benefits. Using C#, .NET and Visual Studio together offers a host of benefits.

The .NET Foundation

The .NET Foundation is an independent organization created to adopt the open development and collaboration around the Microsoft .NET Framework. It serves as a forum for both community and commercial developers to broaden and strengthen the future of the .NET environment by promoting openness and community participation to encourage innovation.

All contributions have standard open source licenses and a lack of platform restrictions means users have the ability to run it on any platform. Users are also able to integrate suggestions & submissions from other developers. It was heralded as the next step in terms of open source; the umbrella for all these projects to be contributed under, and the foundation on which projects and code can be contributed into open source.

Some of the founding contributions to be included under the .NET Foundation are:

• ASP.NET
• Xamarin
• “Roslyn”
• Microsoft Azure SDK
• Windows Phone Toolkit

Who’s in it?

Projects that are currently under the stewardship of the .NET Foundation include the .NET compiler platform (AKA “Roslyn”) – which includes hosting for C# and Visual Basic (VB) .NET languages. Both are available via the traditional command-line programs. Roslyn exposes modules for the syntactic analysis of code and code emission.

The ASP.NET family (along with Roslyn) were open sourced by MS Open Technologies. ASP.NET was founded in 2002 along with the first iteration of the .NET Framework, and is built on the Common Language Runtime (CLR). This means programmers can write for ASP.NET using any supported .NET language.

Xamarin has contributed several open source projects to the .NET Framework, including the Xamarin.Mobile and Xamarin.Auth APIs, as well as the very popular Mailkit and Mimekit projects.

How does it help?

The .NET Foundation supports .NET open source in a number of different ways. It offers the benefits of the .NET platform to the wider community of developers, and promotes the benefits of the open source model to developers already using .NET. The Foundation also provides administration and support for multiple .NET open source projects assigned to it. New .NET projects joining the foundation can receive mentorship and access to current developers working with .NET open source projects. The foundation also works with Microsoft and the broader industry in attempts to increase the exposure of open source projects in the community.

Services for .NET Foundation Projects include:

• Project Guidance and Mentoring
• IP and Legal
• Technical Support
• Marketing and Communications
• Financial Support

Get involved!

The .NET Foundation is always looking for involvement from the community, whether it’s contributing to a project, new submissions or just simply spreading the word. Join in on community conversations regarding the Foundation on the community forum.

Interested in discovering more? Find out everything there is to know on the .NET Foundation - and how you can make a difference - on their website. You can also follow their blog and Twitter page, or check them out on GitHub.

Want to build your desktop, mobile or web applications with high-performance controls? Download Ultimate Free trial today or contact us and see what it can do for you.

We can all agree that a good user experience (UX) is core to retaining customers to your product. People’s leniency towards below-average UX is continually declining, and they take no shame in deleting an app just moments after downloading if it’s slow to load or unintuitive to use. However, the terminology regarding what makes for good data UX design is somewhat clouded. In this post we’ll explore what exactly determines ‘good UX’ but first let’s look at what it means (and what it takes) to impress your customer.

According to research, it takes all of 7 seconds for us to make our first impressions. As shallow as this may make us seem as humans, we’re of the notion that first impressions are second fiddle to the long-term impression you leave on your audience. Being able to retain your audience’s attention during a presentation, for example, is good – but having them discuss it a week down the line is far more impressive. The goal should always be to get you audience, customer, or whoever it may be thinking in their own time – be that because their experience was particularly appealing or intuitive, it struck a chord with them from the way it was displayed, or because of the content they viewed. Or, even better, all of the above!

First steps

So what can you do to make your UX memorable, to make it stand out? The first step is understanding exactly what is meant by UX design. From the words of experts in the field:

“UX is the process of designing (be that digital or physical) products that are useful, easy to use and delightful to interact with.”

Taking from that, UX is essentially the experience that user has when they interact with your product. So, by definition, UX design is about the decisions that are made regarding how the user and the product will interact. So, good data UX happens when these decisions are informed and a high level of consideration and time is taken over them, resulting in the data you’re displaying having a bigger impact on your audience.

Data to dashboard

A good data visualization will provide a unique or striking insight into a set of data, drawing up interesting comparisons or differences to show to your customer or viewer. A dashboard is a combination of multiple visualizations on one screen, and so opens up even more possibilities for comparing and contrasting data. Dashboards are a fantastic way to impress your audience, and when combined with an intuitive user experience will ensure to grab their attention.

One example of this is social analytics statistics. Coming with the rise of social media in the enterprise, social analytics are becoming increasingly pertinent and popular methods of data analysis. Modern Business Intelligence (BI) tools offer templates for analytics that are popular with the community – be it the latest Facebook, Google or Twitter statistics.

Don’t get caught out

Creating a fluid and appealing user experience for your data is extremely important, but just as important is the actual data you put in. So, when it comes to the actual content of your dashboard, there are a few things to be wary of.

It’s not all about numbers

With such vast quantities of data of different shapes and sizes out there, it’s easy to get lost in the numbers. It’s even more easy, however, to end up over-relying on those numbers. Rolling the behavior of millions into a single number is not always a good thing. Even organized sets of data don’t answer questions in regards to data-driven UX design. These gaps can be filled by qualitative insights or the lesser-known “thick data” - data that provides insights into the everyday lives of consumers, explaining why they have certain preferences and the reasons they behave the way they do.

Bigger isn’t always better

Sometimes, bigger is better. When dealing with something subjective, the more responses you can accumulate the better, as it provides greater accuracy and gives you more confidence in your results. However, for some analyses, sheer volume is not the sole answer, and metricssuch as variety can also be very important. More diverse sources create a more nuanced picture which can better encapsulate your findings. Perhaps a better analogy is broader is always better.

Objectively speaking

As effective as data can be in expressing your findings, always remember that ‘it’s not gospel’. Datasets are created by humans, who interpret them and assign meaning to them. There are both limitations and at least some level of bias in every type of data, but good data should describe its biases and always provide context.

Data and design on one screen

With such ample data out there, making data-driven decisions has never been easier. ReportPlus, from Infragistics, combines the power of data analysis with the appeal of sleek user design in one enterprise tool. Available on major mobile platforms iOS and Android, and soon on dekstop and web, users can create the latest compelling data visualizations and share key metrics with their teams, wherever they happen to be.

Try ReportPlus free today and begin turning dead data into dynamic decision making.

When I first entered the workforce, I was in awe of the programmers around me.  I'd spent 4 years of college learning how to implement Alpha-Beta pruning and various flavors of sort(), while these guys had been building things that real people used in the real world for years, or even decades.  I imagine it was, on a much smaller and more cerebral scale, the way a college football player feels upon turning pro.

This didn't last.  After a while, I viewed them less with reverence and more as simple peers from whom I could learn, given their comparable wealth of experience.  As the years passed, the scales began to balance as I acquired more and more experience.  I was no longer the greenest developer around, and there was a healthy mix of people more and less experienced than I was.

The Path to Leadership

As this transformation took place, I started to develop opinions and preferences of my own, based on experience and on becoming a student of the craft.  I began to read books by people like Uncle Bob Martin and Michael Feathers.  And, sometimes, these opinions I was developing didn't line up with those of some of the people around me.  I started to notice that the practices advocated by industry thought leaders were dismissed or ignored by some of the people around me.

At the same time, I began to notice that the people making technical decisions from positions with names like, "Architect," "Principal Software Engineer," and "Team Lead," weren't necessarily the best, technically.  Often, these leadership roles seemed to be as much a function of number of years with the company and familiarity with the domain as they were a function of technical acumen.  And where the developers more experienced than me seemed diverse in their skill, philosophy and approach, the decision-makers seemed disproportionately to value a "crank out reams of code" approach.  And, of course, when you have differences of opinion with the decision-makers, it doesn't tend to go your way.

As I grew in my career and moved around a bit, this philosophical friction with entrenched technical leaders led me to the conclusion that the path to joy was to become a company's technical decision maker.  I'm also an ambitious, overachiever sort, so wanting to 'ascend' to a leadership position fell in line with my goals anyway.  I'd work hard and bide my time until I earned a leadership position, and would remain unsatisfied with my lot in life until that time.

Leadership Realized

There was a happy-ish ending to the first part of this story.  I found my way into leadership, through a combination of hard work, years in the field, and moving around some.  I was finally in a position where I owned the decision making.  I was no longer subject to determinations that the best approach to a public API was one giant class with hundreds of static methods.  I could preside over a clean codebase and a clean approach.

And, I did.  Things went well.  But there was a hidden irony to this which was that, as I acquired more leadership responsibilities, I dealt less with actual implementation.  I had all of the freedom in the world to make technical decisions, and no time with which to make them.  I delegated the work, for the most part, and trusted team members to do the right thing.

What I finally realized was that what I wanted wasn't actually to be the lead, per se.  By nature, I'm nothing resembling a micromanager, and I was't looking to be the person that made decisions for groups.  I was just looking not to have that done to me.  I didn't want to be micromanaged.  It took a lot of years, a number of promotions, and a wide variety of roles to understand this.

Team Member Is Just Fine

I was working as a CIO when I had this epiphany.  I had the IT and software development organizations reporting to me, and writing code was something I did in the evenings in order to keep my skills sharp.  Some serious reflection and evaluation of my situation led me to back away from that role and strike out on my own.

I became a freelancer, doing a mixture of application development, coaching, and IT management consulting.  The result was that I got to return to situations where I was closer to or directly involved with actually building stuff, but where I still was not being micromanaged.  And, I was quite happy with that.

But another interesting thing happened during this time, which was the departure of any remaining feeling that my role on a team represented achievement or rank.  The formation of a software team isn't as simple or obtuse as "the best, most qualified person is the leader."  I could choose to plug into a team to lend a hand and take technical direction from someone else, without it somehow lessening my standing or the perception of my competence.

This was a huge and surprising relief.  You see, being a team or department leader can be exhausting.  The buck stops with you and so you only get a small grace period where your answer can be "I don't know."  There's a point where anyone on the team can say, "gosh, that's just over my head -- I need help."  As the leader and closer, that's where you step in and handle it.  And, that's a lot of pressure.

I'd love to be able to give my younger self this message, but I'll have to settle for giving it to everyone reading.  You can find good teams, run by folks that aren't micro-managers.  You can put yourself in situations where you're empowered to make good decisions.  If you want leadership positions and to follow that path with your career, by all means, do it.  But understand that it's not a better position nor is it an indicator of alpha status and competence.  Pitching in, writing code, and contributing to a team is a great way to spend a career.   It's perfectly okay not to lead.

Deliver the most demanding and beautiful touch-friendly dashboards for desktop and mobile apps with over 75 HTML5 charts, gauges, financial charts, statistical and technical indicators, trend lines and more. Download Ignite UI now and experience the power of Infragistics jQuery controls.

Essential to the process of creating and developing engaging interfaces for our users are thoughtful animations. In conjunction with wireframe testing and validation, we also need to be considering the overall design language and aesthetics. There are so many things to consider. As designers we want clean typography for the content, a beautiful color palette, expressive yet immediately understandable iconography but this isn’t enough. A successful product is one that can connect to the user on a personal level. Animations make this connection.

It’s only natural, as humans, to expect motion in our lives. I pull out my desk chair and it rolls. Drop a basketball and watch it bounce. These expectations, whether we realize it or not, are in our minds when interacting with our apps.

Communicate Status and Provide Feedback

Great transitions have meaning; we don’t want to water down our products with needless animations. These will distract users from the content. For example, a meaningful transition may occur after a user completes a form, or to notify a user that the information they submitted was received by the app.

*created with Indigo Studio

Sure, you could just have the confirmation appear over the login form, but it would feel forced and unnatural. The result would require attention and place an additional, albeit small, cognitive load on the user in order to make the connection between their action and what happened on their screen. By having a well thought out transition, the user is guided on a journey from one visual state (the sign up form) to the next visual state (confirmation message), minimizing attentional and cognitive requirements.

Direct the User’s Attention

Transitions may also be used to direct your user’s attention to certain aspects of the content. In doing so, you help the user focus on what is relevant as they complete their task.

In this example, as the side panel transitions in, the main content animates to the lower right corner of the viewport. This puts the user’s attention solely on the content that is in the navigation drawer, allowing them to focus on what is important in this visual state. When closing the navigation panel, notice how the content transitions to its original position. This technique also help users remember the “resting” location of the navigation.

Be smart about your transitions and don’t be afraid to experiment. Test with users to validate ideas. Remember to have your transitions guide the user from one visual state to the next without distracting them from the content. When returning back to a visual state (ie: closing a menu), all elements should animate back to their original locations. You’ll learn that by providing transitions that delight, users will feel a greater connection with your app.

In ASP.NET MVC, Filters are used to inject logic at different levels of request processing and allow us to share logics across Controllers. For example, let’s say we want to run a security logic or a logging logic across the controller. To do so, we’ll write a filter containing those logics and enable them across all controllers. When we enable a filter across all controllers or actions, the filter enables the upcoming HTTP request.

Let us consider a scenario of Logging: for every incoming request, we need to log some data to the files on the basis of some logic. If we don’t create this logic inside a custom filter, then we will have to write logic for each controller’s action. This mechanism will lead to two problems:

1. duplication of code; and
2. violation of the Single Responsibility Principles; actions will now perform additional tasks of logging.

We can mitigate the problems above by putting the logging logics inside a custom action filter and applying the filter at all the controllers’ level.

Have you ever come across source code as shown in the image below? [Authorize] is an Authorization filter, and it gets executed before any HTPP request or Action method execution.  The Authorize filter is part of MVC, but if needed, we can create a custom filter too.

In ASP.NET MVC, there are four types of filters:

1. Authentication Filter  
2. Authorization Filter
3. Action Filter
4. Result Filter
5. Exception Filter

The sequence of running of various filters are as follows:

• The Authentication filter runs before any other filter or action method
• The Authorization filter runs after the Authentication filter and before any other filter or action method
• The Action filter runs before and after any action method
• The Result filter runs before and after execution of any action result
• The Exception filter runs only if action methods, filters or action results throw an exception

In a diagram, we can depict the sequence of filter execution as shown below:

Each filter has its own purposes, however most of the time you will find yourself writing a Custom Action Filter. They get executed before and after execution of an action.

Custom Action Filter

We write custom action filters for various reasons. We may have a custom action filter for logging, or for saving data to database before any action execution. We could also have one for fetching data from the database and setting it as the global values of the application. We can create custom action filters for various reasons including but not limited to:

• Creating a privileged authorization
• Logging the user request
• Pre-processing image upload
• Fetching data to display in the layout menu
• Localization of the application
• Reading browser user agent information to perform a particular task
• Caching, etc.

To create a custom action filter, we need to perform the following tasks:

1. Create a class
2. Inherit it from ActionFilterAttribute class
3. Override at least one of the following methods:

• OnActionExecuting– This method is called before a controller action is executed.
• OnActionExecuted– This method is called after a controller action is executed.
• OnResultExecuting– This method is called before a controller action result is executed.
• OnResultExecuted– This method is called after a controller action result is executed.

Let us create a custom action filter which will perform two tasks, in the most simplistic way. Of course you can write more sophisticated code inside the custom action filter, but we are going to create a custom filter with the name MyFirstCustomFilter, which will perform the following two tasks:

1. Set some data value in global ViewBag.
2. Log the incoming request to the controller action method.

The filter can be created as shown in the listing below:

usingSystem;usingSystem.Diagnostics;usingSystem.Web.Mvc;namespaceWebApplication1
{publicclassMyFirstCustomFilter : ActionFilterAttribute
    {publicoverridevoidOnResultExecuting(ResultExecutingContext filterContext)
        {//You may fetch data from database here 
            filterContext.Controller.ViewBag.GreetMesssage = "Hello Foo";base.OnResultExecuting(filterContext);
        }publicoverridevoidOnActionExecuting(ActionExecutingContext filterContext)
        {var controllerName = filterContext.RouteData.Values["controller"];var actionName = filterContext.RouteData.Values["action"];var message = String.Format("{0} controller:{1} action:{2}", "onactionexecuting", controllerName, actionName);
            Debug.WriteLine(message, "Action Filter Log");base.OnActionExecuting(filterContext);
        }
    }
}

In the above listing, we are simply setting ViewBag property for the controllers being executed. The ViewBag property will be set before a controller action result is executed, since we are overriding the OnResultExecuting method. Also, we are overriding OnActionExecuting to log the information about controller’s action method.

So now we’ve created the custom action filter. Now we can apply that at three possible levels:

• As a Global filter
• At a Controller level
• At an Action level

Applying as a Global Filter

We can apply a custom filter at a global level by adding a filter to the global filter in App_Start\FilterConfig. Once added at the global level, the filter would be available for all the controllers in the MVC application.

publicclassFilterConfig
    {publicstaticvoidRegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new HandleErrorAttribute());
            filters.Add(new MyFirstCustomFilter());
        }
    }

Filter at a Controller level

To apply a filter at the controller level, we can apply it as an attribute to a particular controller. When applied as controller level, the action would be available to all the actions of the particular controller. We can apply MyFirstCustomFilter to HomeController as shown in the listing below:

[MyFirstCustomFilter]publicclassHomeController : Controller
    {public ActionResult Index()
        {returnView();
        }
     }

Filter at an Action level

Finally, to apply a filter at a particular action, we can apply it as an attribute of the Action as shown in the listing below:

[MyFirstCustomFilter]public ActionResult Contact()
        {
            ViewBag.Message = "Your contact page.";returnView();
        }

And that’s about it for custom action filters! I hope you find this post useful, and thanks for reading. Have something to add? Feel free to leave a comment!