Microsoft Ignite Summary

Microsoft Ignite Summary

This past week was the first Microsoft Ignite conference in Chicago, IL. As a prior attendee of Microsoft’s BUILD conference each year, this was quite a change for me. There was a healthy mix of IT Pro, SysAdmin and Dev sessions, over 200 sessions in total for the week. There was also a consistent hint of Azure and Office 365 in every session, regardless of category or audience type. It’s absolutely clear Microsoft wants everyone in the cloud, mainly in Azure, and we saw that even in on-prem sessions. The expo was huge, with lots of opportunities to talk with both Microsoft and their partners. From hands-on labs to live and in some cases interactive demos, there seemed to be something for everyone there.

I attended mostly developer sessions with a few “Here’s what’s coming” sessions on SharePoint 2016. Here is a brief summary:

SharePoint 2016

We can look forward to the return of portals, only in the form of Next-Gen Portals. We will see better support for embedded video, a simplified admin portal, and better People experiences with Microsoft’s newest technology Delve.

Files will be stored across devices, with the idea of OneDrive replacing your organization’s file server. We can also expect to see improved auditing and reporting of changes to files.

Enterprise Search improves with personalized discovery experiences and governance controls. We’ll also see an improved user experience, with a more modern collaboration feel and personalized insights.

One of the biggest improvements I heard was Zero Downtime Patching. Only those updates that are critical to the operating system’s health are pushed, and are delivered in one line with no end user impact. Another key improvement is the new Server Role Selection when configuring a new SharePoint instance. Selecting a specific server role, such as strictly a basic WFE that will serve up documents and accept approvals will have a smaller footprint than a more collaborative environment or one with custom applications.

We can expect to see more about SharePoint 2016 between Q1 and Q2 of 2016.

Skype for Business

In the Gemini 2 release for Office, we can expect a co-auth feature, which will allow all users to simultaneously modify a single document, while we can all see the changes happening live.

Documents included in meeting invites, even as a hyperlink pointing to OneDrive, will automatically be loaded into the meeting when the meeting starts, eliminating the need to wait for everyone to go find and open their local copy of the document, or have to resend to those who deleted their invitation or their document.

Skype for Business for iOS and Android will be available by fall 2015, for Mac by the end of 2015

A key improvement is the broadcast meeting option, which should be available by this summer. This feature can scale up to handle over 10,000 users at a time, with no additional infrastructure required, and runs on any device. Another improvement is Search in Skype for Business will no longer require an MS Account. You can have either an MSID or a Skype account to take advantage of Search.

By the end of 2015, we can also expect to have all enterprise voice features including call forwarding, call park, audio conferencing and PSTN calling.

Office Graph

The new Delve technology uses a machine learning and metadata functionality referred to as Office Graph. Basically, enterprise data is intelligently organized around the user. Office graph can receive data from many data sources, not just Office or SharePoint, and can also send notifications to and receive actions from third-party applications.

Microsoft’s Delve consumes this Office Graph data and renders it as Cards or Boards, allowing you to group shared information logically. There isn’t a whole lot of detailed information on this yet as it’s still in development, but what we saw seems to me to have real potential.

Visual Studio 2015 and Visual Studio Code

If you haven’t tried out Visual Studio 2015 yet, you need to. You can choose from the Community version or the Enterprise version, both are in RC right now. The environment looks and feels very similar to VS2013, except there are a lot more features baked into this one. I’m only going to touch on a few:

There is a Diagnostics Tool Window allowing an improved troubleshooting experience including UI debugging for XAML applications, and Android support.

Any debug window now allows Lambda expressions to evaluate objects dynamically.

Adding $ReturnValue in the Watch window exposes an n-based array of return values based on your current operation while debugging. This eliminates the need to specify variables by simply putting $ReturnValue1, $ReturnValue2, etc. in the Watch window and start seeing more dynamically what’s going on.

Finally, if you enable Diagnostic Performance Tools, when you put a breakpoint at the end of a particular method, it will give you the total run time for that method. You can then mouse over that info to get even more details.

Another one to download and try is the text editor Visual Studio Code. Microsoft has provided us with a clean, slim text editor that includes Intellisense and limited runtime capability, such as monitoring a node.js server while testing whatever code is in the editor window at the time. It can also look through and debug a folder or set of files without having a project loaded. Keep in mind, it’s just a text editor, not an IDE, although there was a lot of discussion around adding more features and making it more like an extremely slimmed down IDE, but it was all just discussion. VS Code uses a code analyzer that’s a component of the Roslyn compiler called Omnisharp, which is where the Intellisense capability comes from.

C# 6.0

Many of the changes to C# in this release are syntax-related, meaning there is no performance impact to leveraging these fantastic improvements! Here are a few:

You will be able to import a type with a using statement. For example, instead of adding using System then adding Console.WriteLine in your code, you can add using System.Console and change your code to say WriteLine(). This also allows enum members like System.DayOfWeek, and also extension methods like System.Linq.Enumerable. The benefit here is it will bring in just the extension methods from that particular class instead of all of them like System.Linq would, resulting in a lower overall footprint.

We will now have Expression-bodied members. For example, instead of formatting a string object and saying

return object.ToString()

we can now say

ToString() => String.Format("({0},{1})",X, Y);

Basically, the getter is implied, so all you need now is the getter object => resulting value.

We will also have String Interpolation. For example,


now becomes

ToString() => $"({X},{Y});"

This eliminates the need for a placeholder when doing string formatting. This also works with verbatim strings like @”something”. If you want to make it invariant to culture, you can also use FormattableString.

Also coming is nameof. This is used to manage method arguments in a more dynamic way. For example, if you have an argument foo and you want to handle an ArgumentException in case someone leaves it empty, putting a

throw new ArgumentException("Error","foo");

won’t work if you change the name of the argument to bar. To resolve this, you can now change your exception line to

throw new ArgumentException("Error",nameof(foo));

When you change the above argument to bar, your exception will automatically change as well.

Finally, we will have Null Conditional Operators. For example, let’s say you have a null check on an array variable called foo[]. Instead of doing this:

if (foo[0] == null || foo[0].Type != SomeSpecificType)

you now have the ability to just do this:

if(foo[0]?.Type != SomeSpecificType)

The question mark will evaluate the condition to the left to see if it’s null. If it’s not, it will then continue to evaluate the condition to the right. This will save some time and a few lines of code!

ASP.Net 5.0

Prepare for a completely new ASP.Net! Microsoft is introducing the .Net Core 5 layer into ASP.Net, which allows you to build web applications using a unified Base Class Model where NuGet is mainstream and a very active part of your development. Like other .Net technologies, this will also be open source. It uses the DNX compiler, which will create a small web service to interact with your project, consuming less resources while still giving you the full effect of a deployed solution for debugging and troubleshooting.

ASP.Net 5 runs on top of .Net Framework 4.6 and .Net Core 5. This gives you the flexibility of using either framework for building your web applications! The startup footprint is now < 20MB, which is a huge improvement over the prior 200MB+ startup. There is a catch to WebForms cannot use WebForms in .Net Core 5. However, because Microsoft will continue to support WebForms as a development method, you can simply use .Net Framework 4.6 to continue making WebForms applications. If you want to take advantage of .Net Core 5, you will need to build an MVC web application.

With .Net Core 5 the familiar web.config is gone. That file is strictly used for IIS configuration now. Instead, we get to use JSON files, like project.json to manage application configuration. This provides a very familiar look and feel with the flexibility of editing the configuration in any text editor. All project options and dependencies are declared here and loaded in JSON format.

Another benefit is custom error handling without the need for building a whole set of custom error pages. Adding an error handler in project.json will throw a friendly error on the web page instead of the familiar yellow screen of death.

We can also expect seamless integration with task managers like Gulp and Grunt, and package managers like Bower, to provide limited maintenance on the part of the developer to ensure the latest releases of any CDN or package is in the project without rebuilding/redeploying it. We will also get Task Runner Explorer in Visual Studio 2015, which allows you to see all Gulp tasks and connect them to events in your project, so content is loaded or updated dynamically based on certain events or conditions.

One final feature of ASP.Net 5.0 I thought was cool was a whole new way of implementing dependency injection into your solution. Using Razor syntax, simply do this at the top of your web page:

@inject something

Yeah, it’s now that simple.

The future of TypeScript

The JavaScript language hasn’t had a mainstream update in over 15 years, and a lot is about to change. First, the JavaScript community has agreed to a yearly cadence of updates and changes to avoid lapses in time like has happened in the past. Yes this will require tools, editors and even browsers to step up and meet this cadence. Within the next year we can expect to see a shift towards a more C# like language, including classes, modules, arrow functions, destructing, rest/spread, let/const, template strings, symbols, and computer properties to mention a few.

A few things we can expect to see soon are let, which allows you to change a variable type mid-function. For example:

let index = 0; // this is an integer

later on in your code, doing this will change the type, where just declaring a var would throw an error:

let index = "foo"; // now it's a string

Here’s another one: looping through an array of objects and trying to return the value of each can lead to just returning the index of the object instead of the value. For example:

for(var obj in array)

Changing the for statement slightly will now return the value of each as enumeration happens:

for(var obj of array)

Notice the in changed to an of there. That’s all that’s needed!

Like .Net Core 5, TypeScript will be using a tsconfig.json file to establish environment configuration. Once set up, we can use something like

import * as Util from "util"

to import all modules from a util file somewhere in the environment. However, if you just want to import specific modules from that file, you can do this:

import (module1,module2) from "util"

Makes it easier to keep the overall resource load down and make the application more efficient!

We can also expect to see Decorators in ECMAScript 7, which will provide a nice separation of concern in the application. As well we’ll see Async and Await, which behave just like C# and simplify working with Promises. Finally we will see Union Types and Type Guards, completely optional but useful for managing type safety in the application.

We saw a lot at this inaugural Ignite conference. There was a lot of information passed around, and this list is by no means all-inclusive. I’m looking forward to getting started on many of these things soon. This next year many things are changing!

Comments are closed.