A seriously ill child is every family’s nightmare. So it’s no wonder that young patients and their families are filled with anxiety when a child requires frequent hospital visits. And while a great bedside manner can help alleviate the stress, a hospital, even a pediatric one, can still be a frightening place for kids and parents—which is why Boston Children’s Hospital installed a Kinect-enabled interactive media wall in its recently renovated lobby.

The 20-foot-tall, gently curved wall engages the young patients and their families as it displays any of nine scenes, each filled with special effects controlled by the onlookers’ movements. Youngsters quickly discover that a wave of their hand can rearrange stars in a night sky, or that walking will make leaves flutter in a garden scene. Parents, too, get in on the action, eagerly helping their child become immersed in the interactive wonders.

(Please visit the site to view this video)

The Kinect-enabled interactive media wall at Boston Children's Hospital helps give seriously ill children a
sense of empowerment at a time when their lives seem out of control.

The media wall was created for Boston Children’s Hospital by the combined talents of designers, engineers, mathematicians, and behavioral specialists at the University of Connecticut (UConn). As Tim Hunter, director of UConn’s Digital Media Center and Digital Media & Design program explains, the experience is intended first and foremost for the youngsters, who are delighted to have a sense of control in a situation where they often feel helpless.

“Our goal was to create something that would empower physically and emotionally challenged children at a time in their life when most events are beyond their control,” says Hunter. “Doctors and nurses, along with Mom and Dad, dictate most of what’s happening to them—for good reason. We wanted to make something the kids could take control of—something that would be theirs; something they would look forward to when they come to the hospital.”

“However,” Hunter continues, “we wanted to create something for the family, too. After all, the entire family is going through this, and we wanted to let parents be part of the engagement, to be able to have this group family experience.”

The wall’s seemingly magical powers are the product of a lot of technology, including 13 Kinect sensors and seven optical cameras, which combine to cover a space of 18 feet by 24 feet (about 5.5 meters by 7.3 meters). The project was begun in 2012, before the Kinect for Windows v2 sensor was available, but the finished installation uses a combination of five v2 and eight original sensors, all mounted overhead. The five Kinect v2 sensors capture the frontal view of the participants, while the eight original Kinect sensors track the participants from behind. Together with the seven optical cameras, they provide a stream of high quality data on movements and gestures, which are then used to animate avatars or otherwise manipulate the onscreen display.

With all those sensors in place, the system can readily track individual people, with one Kinect sensor handing off the tracking to another as a participant moves through each sensor’s range. The multiplicity of sensors also means that participants, or their on-screen avatars, can readily interact, which makes the experience all the more engaging, especially when patients and parents cooperate.

Theoretically, the system could capture the movements of as many people as can fit into the area that the 13 sensors monitor. But as Tim Gifford, director of UConn’s Advanced Interactive Technology Center explains, the team designed the software to limit the number of bodies being tracked. For instance, in the media wall’s musical instrument scene, the software allows up to 12 participants to play simultaneously. Likewise, the “star man” experience, in which participants use their gestures to change the shape of a constellation, can accommodate a total of eight participants at a time. Otherwise, says Gifford, “The kids can no longer appreciate what their movements are causing.”

The interactive media wall opened in late 2014, to rave reviews from patients, families, and hospital staff. And while the technological wizardry is indeed amazing, the real enchantment of the wall is found in the smiles on the faces of seriously ill children, who can take control of their environment and find delight in an immersive experience.

The Kinect for Windows Team

Key links

• Learn more about Kinect for Windows
• Boston Children’s Hospital
• University of Connecticut Digital Media and Design
• Follow us on Facebook and Twitter

I’ve spoken in other posts about the vagaries of the titles that I have had over the years. The latest round of titles are indicative of some of the internal problems the discipline faces.

Right now, put simply, It is hard to say what is content. And what is publishing.

In a world where GitHub is seen as a final destination, publishing is simply “Save.”

In a world where GitHub is seen as a final destination, content is a markdown file called “Readme.”

In the old days, publishing meant a big, fat book that took months to complete. It was called a manual. Think about that word for a minute.

Creating content was simply “writing” and it was done by writers. Even in the nascent days of personal computing back in the 80s, these ere understandable job descriptions. And something like Technical Writng made sense to most people that I met.

If I were to go to my alma mater today in order to recruit my replacement, it would be a difficult job. For one, it cannot be summed up in short order like “software engineering or technical writing.” The type of engineering I do is not sexy. The type of writing that I do is not sexy. The support I provide to other users is not sexy.

While I really enjoy my job right now and think I am providing a worthwile, valuable set of services, I don’t think it is easy to describe. I also think that no one in computer science school would really want aspire to do this. They aspire to do different things and well-trained in doing them.

So there is a tension on both sides of the hiring equation. My employer cannot easily describe the role in a way that it will attract great candidates because great candidates have many options. And aspiring grads have little interest in the hodgepodge description of the current skill set.

When it was “writer” and “manual” it was a lot easier for everyone.

We are very excited to provide built-in support for the Scale Agile Framework using our existing Scrum, Agile, and CMMI templates.

Some time ago, we published a whitepaper: Scaled Agile Framework: Using TFS to support epics, release trains, and multiple backlogs, which detailed how to use TFS to support SAFe practices.

In support of that guidance, we also published on the Microsoft Download Center, a set of Process Template Samples with Support for SAFe.

With theMay 15 deployment of Visual Studio Online, the Agile, Scrum, and CMMI process templates are now updated to include these changes. All existing and new projects will have the following SAFe concepts built right in:

Support for Epics

We have added an Epic work item type and a backlog/board to track Epics.

Epics are hierarchically above Features. Features are mapped to Epics, like Backlog items are mapped to Features.

Full backlog and board functionality are available. You can manage the Epic backlog like any other backlog as well as customize your Kanban columns and cards to match your needs.

It is important to know that the Epics backlog is not enabled by default. To enable this feature, you’ll need to visit the Team Settings page and check the “Epics” checkbox.

The Epics backlog can be turned on or off at the team level. As per our whitepaper, Portfolio Teams should enable the Epics backlog. Program and Feature teams can disable the Epics backlog if they don’t manage Epics in your organization.

Support for Architectural vs. Business backlogs

We have added a “Value Area” field to all work items that appears on a backlog, that is: Epics, Features, and on (depending on your process template): Product Backlog Items, User Stories, or Requirements.

The Value area has two values: Business and Architectural. By default value, all Epics, Features, and Stories are Business types. To create an Architectural Epic, Feature, or Story, set the value to Architectural.

Note in the Epic Kanban board example above, we’ve added “Value Area” as a field that appears on the card. This allows you to quickly see which Epics are supporting your Architectural Roadmap. You can, of course, also do this with your Features and Stories board. The field is always available from the work item form.

With this functionality you can define Architectural Epics, which breakdown into Architectural Features and Stories, allowing you to track your architectural roadmap across your organization.

TFS 2015 RTM On-premise release

For the TFS 2015 RTM on-premises release, the shipped process templates will include these changes. Existing team projects will not be modified. Existing TFS 2013 customers can enable this functionality today, by following the guidance in the whitepaper: Scaled Agile Framework: Using TFS to support epics, release trains, and multiple backlogs.

To all the SAFe Agilistas out there, enjoy these changes! If you aren’t interested in SAFe, don’t worry. We made the additional functionally opt-in.  

Since the General Availability of Azure Stream Analytics last month, ASA users have generated many helpful samples, blog posts, and videos to share their solutions and experiences using ASA.  Here are some of are favorites.  Do you have something great to share?  Tweet us at @AzureStreaming

Analyzing Google Analytics Data in Real Time with Azure Stream Analytics: This video from BlueGranite walks through an end-to-end solution for analyzing and visualizing Google Analytics web traffic data in a live dashboard.

Connected Car with Microsoft Azure: Blog post and video demo for streaming car data (engine speed, location, fuel level, etc.) in real time from an Android drive simulator application.

SQL Server Intrusion Detection: Tutorial for analyzing failed on-prem SQL Server logins to detect and alert on potential malicious behavior.

ServiceFabric + ASA = Crime Detection: Blog post outlining a POC to analyze simulated traffic camera data to detect stolen vehicles and display findings in a PowerMap.

With Office 365 API Tools, you can integrate Office 365 services - including Mail, Calendar, Contacts, Files and other services - with your applications. Office 365 API Tools take care of registering your application to consume Office 365 APIs and adding necessary NuGet libraries to your project. Before you get started, you will need an Office 365 Developer Tenant. If you don’t have an Office 365 Developer tenant yet, but are interested in the Office 365 APIs, the API Sandbox offers you a quick in-browser C#/JavaScript code editing experience to try the APIs with no sign-up needed.

Note: To use Office 365 API Tools with Visual Studio 2015 RC, you will need Microsoft Visual Studio Enterprise 2015 RC with Microsoft Office Developer Tools. Choose the Custom option when running the Visual Studio installer and check the option to install Microsoft Office Development Tools. 

If you are using Visual Studio 2013, then you will need the latest version of Microsoft Office Developer Tools for Visual Studio 2013.

In the following walkthrough, we will build a simple Windows Store app and integrate Office 365 APIs to let users sign in, view files stored on their OneDrive accounts and their contacts. Let’s start by creating a new Windows 8 store app. For this demo, I named my app O365SampleApp.

1. Configure Office 365 API

We will use Office 365 API Tools to configure the app to use Office 365 APIs. To do so, right-click on the project node in the solution explorer and select Add -> Connected Service… Select Office 365 APIs from the list of providers and click Configure.

Click on the Register your app link and enter the credentials for your Office 365 Developer tenant account. Note: This step registers your app on Azure Active Directory associated with your Office 365 tenant.

Now you will be presented with the page to set permissions for various Office 365 services. Set the following permissions and click the Add button once all the permissions are set:

1. For the Contacts service, set the Read your contacts permission.
2. For the My Files service, set the Read your files permission.

The above steps will add some NuGet libraries, and also enable Read your contacts and Read your files permissions for the app that was registered on Azure Active Directory. A complete list of libraries that were added can be seen in the Visual Studio output window.

2. Access Office 365 API by using .NET Client Library

To access Office 365 APIs using the .NET client library, first acquire an access token. Then get the Outlook Services client for fetching Contacts and SharePoint Client for fetching MyFiles. We can then send asynchronous queries to interact with contacts/files data.

2.1 Get Access Token

In this walkthrough, we will use Azure Active Directory Authentication Libraries (ADAL) to authenticate users and obtain an access token for securing API calls.

Add Microsoft.IdentityModel.Clients.ActiveDirectory to your project through the NuGet Package Manager.

Next, add a new class to the solution; let’s call it AuthenticationHelper.cs and replace the content of this file with:

using Microsoft.IdentityModel.Clients.ActiveDirectory;
using System;
using System.Threading.Tasks;
using Windows.Security.Authentication.Web;
using Windows.Storage;
using Windows.UI.Popups;

namespace O365SampleApp
{
    class AuthenticationHelper
    {
        public static readonly string DiscoveryServiceResourceId = "https://api.office.com/discovery/";
        const string AuthorityFormat = "https://login.microsoftonline.com/{0}/";
        static readonly Uri DiscoveryServiceEndpointUri = new Uri("https://api.office.com/discovery/v1.0/me/");
        static readonly string ClientId = App.Current.Resources["ida:ClientID"].ToString();
        static ApplicationDataContainer AppSettings = ApplicationData.Current.LocalSettings;
        static string _authority = String.Empty;
        static string _lastTenantId = "common";
        const string _lastTenantIdKey = "LastAuthority";
        static AuthenticationContext authContext = null;

        public static Uri AppRedirectURI
        {
            get
            {
                return WebAuthenticationBroker.GetCurrentApplicationCallbackUri();
            }
        }

        public static string LastTenantId
        {
            get
            {
                if (AppSettings.Values.ContainsKey(_lastTenantIdKey) && AppSettings.Values[_lastTenantIdKey] != null)
                {
                    return AppSettings.Values[_lastTenantIdKey].ToString();
                }
                else
                {
                    return _lastTenantId;
                }
            }
            set
            {
                _lastTenantId = value;
                AppSettings.Values[_lastTenantIdKey] = _lastTenantId;
            }
        }

        public static string Authority
        {
            get
            {
                _authority = String.Format(AuthorityFormat, LastTenantId);
                return _authority;
            }
        }

        public static async Task<AuthenticationResult> GetAccessToken(string serviceResourceId)
        {
            AuthenticationResult authResult = null;
            if (authContext == null)
            {
                authContext = new AuthenticationContext(Authority);

                #region To enable Windows Integrated Authentication (if you deploying your app in a corporate network)
                //// To enable Windows Integrated Authentication, in Package.appxmanifest, in the Capabilities tab, enable:
                //// * Enterprise Authentication
                //// * Private Networks (Client & Server)
                //// * Shared User Certificates
                //// Plus add (uncomment) the following line of code:
                //authContext.UseCorporateNetwork = true;
                #endregion

                authResult = await authContext.AcquireTokenAsync(serviceResourceId, ClientId, AppRedirectURI);
            }
            else
            {
                authResult = await authContext.AcquireTokenSilentAsync(serviceResourceId, ClientId);
            }
            LastTenantId = authResult.TenantId;
            if (authResult.Status != AuthenticationStatus.Success)
            {
                LastTenantId = authResult.TenantId;
                if (authResult.Error == "authentication_canceled")
                {
                    // The user cancelled the sign-in, no need to display a message.
                }
                else
                {
                    MessageDialog dialog = new MessageDialog(string.Format("If the error continues, please contact your administrator.\n\nError: {0}\n\n Error Description:\n\n{1}", authResult.Error, authResult.ErrorDescription), "Sorry, an error occurred while signing you in.");
                    await dialog.ShowAsync();
                }
            }
            return authResult;
        }

        public static void SignOut()
        {
            authContext = new AuthenticationContext(Authority);
            authContext.TokenCache.Clear();
            authContext = null;
            ApplicationData.Current.LocalSettings.Values["TenantId"] = null;
            ApplicationData.Current.LocalSettings.Values["LastAuthority"] = null;
        }
    }
}

2.2 Get Outlook Services Client and SharePoint Client

An OutlookServiceClient is required to access Calendar, Contacts and Mail APIs. While, a SharePointClient is required to access Files APIs.

Add a new class to the solution; let’s call it Office365Helper.cs and replace the content of this file with:

using Microsoft.Office365.Discovery;
using Microsoft.Office365.OutlookServices;
using Microsoft.Office365.SharePoint.CoreServices;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace O365SampleApp
{
    class Office365Helper
    {
        private static IDictionary<string, CapabilityDiscoveryResult> AppCapabilities = null;

        private static async Task getAppCapabilities()
        {
            DiscoveryClient discoveryClient = new DiscoveryClient(
                    async () =>
                    {
                        var authResult = await AuthenticationHelper.GetAccessToken(AuthenticationHelper.DiscoveryServiceResourceId);
                        return authResult.AccessToken;
                    }
                );
            AppCapabilities = await discoveryClient.DiscoverCapabilitiesAsync();
        }

        public async static Task<OutlookServicesClient> CreateOutlookClientAsync(string capability)
        {
            if (AppCapabilities == null)
            {
                await getAppCapabilities();
            }
            var myCapability = AppCapabilities
                                        .Where(s => s.Key == capability)
                                        .Select(p => new { Key = p.Key, ServiceResourceId = p.Value.ServiceResourceId, ServiceEndPointUri = p.Value.ServiceEndpointUri })
                                        .FirstOrDefault();
            OutlookServicesClient outlookClient = new OutlookServicesClient(myCapability.ServiceEndPointUri,
                     async () =>
                     {
                         var authResult = await AuthenticationHelper.GetAccessToken(myCapability.ServiceResourceId);
                         return authResult.AccessToken;
                     });
            return outlookClient;
        }

        public async static Task<SharePointClient> CreateSharePointClientAsync(string capability)
        {
            if (AppCapabilities == null)
            {
                await getAppCapabilities();
            }
            var myCapability = AppCapabilities
                                        .Where(s => s.Key == capability)
                                        .Select(p => new { Key = p.Key, ServiceResourceId = p.Value.ServiceResourceId, ServiceEndPointUri = p.Value.ServiceEndpointUri })
                                        .FirstOrDefault();
            SharePointClient spClient = new SharePointClient(myCapability.ServiceEndPointUri,
                     async () =>
                     {
                         var authResult = await AuthenticationHelper.GetAccessToken(myCapability.ServiceResourceId);
                         return authResult.AccessToken;
                     });
            return spClient;
        }
    }
}

2.3 Interact with Contact and Files Data

By sending async queries to OutlookServiceClient and SharePointClient, we can interact with Contact and Files data respectively.

Add the following getContacts() and getMyFiles() methods to Office365Helper class in Office365Helper.cs file.

public static async Task<List<IContact>> getContacts(OutlookServicesClient contactsClient)
        {
            List<IContact> myContacts = new List<IContact>();
            var contactsResult = await contactsClient.Me.Contacts.OrderBy(c => c.DisplayName).ExecuteAsync();
            do
            {
                var contacts = contactsResult.CurrentPage;
                foreach (var contact in contacts)
                {
                    myContacts.Add(contact);
                }
                contactsResult = await contactsResult.GetNextPageAsync();
            } while (contactsResult != null);
            return myContacts;
        }

        public static async Task<List<Microsoft.Office365.SharePoint.FileServices.IItem>> getMyFiles(SharePointClient spClient)
        {
            List<Microsoft.Office365.SharePoint.FileServices.IItem> myFiles = new List<Microsoft.Office365.SharePoint.FileServices.IItem>();
            var myFileResult = await spClient.Files.ExecuteAsync();
            do
            {
                var files = myFileResult.CurrentPage;
                foreach (var file in files)
                {
                    myFiles.Add(file);
                }
                myFileResult = await myFileResult.GetNextPageAsync();
            } while (myFileResult != null);
            return myFiles;
        }

3. Update MainPage.xaml to Include GetContacts and GetMyFiles Buttons

Now we will add 3 buttons to our MainPage to trigger the getContacts, getMyFiles and SignOut calls. To do so, open MainPage.xaml from solution explorer and add the following 3 buttons:

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
<Button x:Name="BtnGetContacts" Content="Get Contacts" HorizontalAlignment="Left" Margin="58,110,0,0" VerticalAlignment="Top" RenderTransformOrigin="-1.737,-2.446" Click="BtnGetContacts_Click"/>
<Button x:Name="BtnGetMyFiles" Content="Get My Files" HorizontalAlignment="Left" Margin="58,167,0,0" VerticalAlignment="Top" RenderTransformOrigin="-1.737,-2.446" Click="BtnGetMyFiles_Click"/>
<Button x:Name="BtnSignOut" Content="Sign Out" HorizontalAlignment="Left" Margin="58,225,0,0" VerticalAlignment="Top" RenderTransformOrigin="-1.737,-2.446" Click="BtnSignOut_Click"/>
</Grid>

Let’s now create button click event handlers. Open MainPage.xaml.cs file and add these methods within the MainPage class.

private async void BtnGetContacts_Click(object sender, RoutedEventArgs e)
{
    var contactsClient = await Office365Helper.CreateOutlookClientAsync("Contacts");
    var contacts = await Office365Helper.getContacts(contactsClient);

    string contactsString = "";
    foreach (var contact in contacts)
    {
        contactsString += contact.DisplayName + Environment.NewLine;
    }
    MessageDialog mg = new MessageDialog(contactsString, "Contacts");
    await mg.ShowAsync();
}

private async void BtnGetMyFiles_Click(object sender, RoutedEventArgs e)
{
    var spClient = await Office365Helper.CreateSharePointClientAsync("MyFiles");
    var myFiles = await Office365Helper.getMyFiles(spClient);

    string myFilesString = "";
    foreach (var myFile in myFiles)
    {
         myFilesString += myFile.Type + " - " + myFile.Name + Environment.NewLine;
    }
    MessageDialog mg = new MessageDialog(myFilesString, "My Files");
    await mg.ShowAsync();
}

private void BtnSignOut_Click(object sender, RoutedEventArgs e)
{
    AuthenticationHelper.SignOut();
}

Note: Add using Windows.UI.Popups; to MainPage.xaml.cs so that we can show Contacts and Files results on a MessageDialog.

Our app is now ready to fetch a list of Contacts and MyFiles. You can now press F5 and click on “Get Contacts” button to see a list of your contacts or “Get My Files” button to see the files stored on OneDrive.

Next Steps

Apart from just interacting with Contacts and Files APIs, you can also interact with Mail, Calendar and other services. A complete list can be found on Office 365 API reference. For any service that you want your app to interact with, remember to set the right permissions when using the Office 365 APIs connected service wizard to configure Office 365 APIs. You can also explore the Office 365 APIs using the API Sandbox. Various sample projects for almost every project type can be found on Office Developer GitHub. 

This week we are deploying our sprint 82 work for VS Online.  This is a very BIG deployment – lot’s of stuff.  You can read the release notes.

First and foremost Build.VNext is here!  It is now in Public Preview and everyone can try it.  We also now have a hosted build pool so you don’t have to install a local build agent on Windows if you don’t want to.  If you want to build on Linux or the MacOS, you will still need to setup up local agent for now.

Since I offered a early peek at Build.VNext on my blog a month or so ago, I’ve been inundated with people requesting to have their account enabled.  It’s been really great to see how much interest there has been.  Now everyone has it and you don’t need to ask for it any longer.

I’ve also gotten a ton of questions about enabling something akin to gated checkin and checkin policies for Git.  This deployment introduces Branch policies that enable this.  We have not yet exposed an extensibility mechanism but plan to in the future.  For now we have a build policy that’s akin to gated checkin and a code review policy.  Very cool.

This deployment also brings a bunch of agile planning enhancements that I think you are going to love.

Check out the release notes for all the details and see you again soon!

Brian

So SQL 2000 has been out of support for a while now.  But I know some of you still run it.  As you upgrade your environments you might find you are upgrading a SQL Server 2000, 2005, 2008 or 2008 R2 server that has linked server connections to a SQL 2000 server.  If so, it can be tricky, since the newer OleDB drivers in SQL Server no longer support connecting to SQL 2000.

Anyway, here's how to do it.  You can't use SQLNCLI11, and shouldn't use MSDASQL.  If you try to use MSDASQL SQL Server will silently use SQLNCLI11 instead, so that won't work either.  So first you need to install an older version of the SQL Native Client OleDB provider, SQLNCLI10.  It can be installed side-by-side with SQLNCLI11, and is still supported.

So first download the newest SQL Native Client OleDB provider that still supports connecting to SQL 2000, SQLNCLI10 from here:

Microsoft® SQL Server® 2008 R2 SP2 Feature Pack

Then set up the linked server like this, after adjusting the server name in sp_addlinkedserver and the login mapping in sp_addlinkedsrvlogin for your environment.

 EXEC sp_MSset_oledb_prop N'SQLNCLI10', N'AllowInProcess', 1
 GO
 EXEC sp_addlinkedserver @server = N'SQL2000', @srvproduct=N'', @provider=N'SQLNCLI10', @datasrc=N'MySql2000Server'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'collation compatible', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'data access', @optvalue=N'true'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'dist', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'pub', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'rpc', @optvalue=N'true'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'rpc out', @optvalue=N'true'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'sub', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'connect timeout', @optvalue=N'0'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'collation name', @optvalue=null
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'lazy schema validation', @optvalue=N'false'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'query timeout', @optvalue=N'0'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'use remote collation', @optvalue=N'true'
 GO
 EXEC sp_serveroption @server=N'SQL2000', @optname=N'remote proc transaction promotion', @optvalue=N'true'
 GO
 EXEC sp_addlinkedsrvlogin @rmtsrvname = N'SQL2000', @locallogin = NULL , @useself = N'False', @rmtuser = N'dw', @rmtpassword = N'P@ssword'
 GO

Then you can test with a query like

 select * from openquery (sql2000, 'select @@servername a' )

David

Peyton Casper is an Microsoft Student Partner (MSP) at University of Texas, Arlington and is majoring in computer science. He is an accomplished student developer and uses Github regularly on his projects. Read on to find out more about Github and how important versioning control is now and for your career, also check out Peyton’s Github at https://github.com/vadlak.

Github: What is it?
Github is currently one of the most popular version control providers available right now and is increasingly being used in industry. Having even a basic understanding of version control – which is used to manage multiple versions of computer files - and its underlying methodology can be a huge bonus to your resume as it provides you with a tool that can allow you to easily manage team projects, maintain multiple releases, and track changes. Github extends a widely used implementation of version control called Git, and relies on a basic methodology of; clone, branch, modify, commit and merge.

Understanding version control
Version control in itself has been widely popular in industry as it allows a large team to easily work and maintain a project in unison. Repository hosting companies like Github have been gaining increasing popularity in the industry as it allows the user to easily setup a Git based project without needing to maintain the infrastructure for it. Being able to write down that you already know how to use a very integral piece of software development can be a huge selling point on your resume and a huge tool for your personal projects. I personally use multiple private repos from Github as a way to maintain my code across multiple devices and ensure I can always roll back if something goes wrong.

When you are ready to begin working on a project, you will first want to clone it, which is the process of downloading repository and making a local copy. Branching creates an independent copy of a repositories code and allows you to write new code that may or may not be working for a while without having to worry about not having a working copy. A very simple and popular implementation that many repositories use is to maintain a master and development branch, where your master houses your most recent working code and your development houses your next release. Once you have finished modifying your code, you will then want to commit your changes to the branch by writing a detailed commit message in case you need to reference this later. Committing is only a holding stage in where you stage all of your changes for the final step which is merging. Merging is when you are ready to bring your changes in sync with your team’s changes by solving any merge conflicts with the current branch and finally merging them into the branch.

Github for your career
Version control has become such an integral part of the software development industry that knowing how to use this tool can be a huge plus for your resume and personal tool belt. Whether your end up using a service like Github or hosting your own repository on a local machine, ensure that you learn and implement the Git methodology so that you can easily adapt your knowledge to any environment. Get creative, code something, and manage it with a Git repository!

5 free Github repos for students: https://education.github.com/pack

The MSP Github Page: https://github.com/MSPStudentDeveloperContent 

Apply to be an MSP by July 15th, 2015. For more information about the MSP Program see our website.  

We’re pleased to announce that Activity and Events Reporting data is now available, in preview, through the Azure AD Graph API.   You may have seen some of this information already surfaced through the Azure Management Portal, under the Reports tab in the Active Directory extension.  These reports and activity logs are now also available to developers through the Graph API with this release. For more details, check out the MSDN documentation here: Azure AD Reports and Events (Preview)

Like other applications using the Graph API, access is available through requesting permission scopes to Graph API through the Azure Management Portal.  To access reporting data, your application will need to either:

• request the Read directory data delegated permission AND the user needs to be a company administrator, OR
• in the case of application-only, the application needs to be given application permissions to Read directory data.

Example REST API calls

Here are a couple of examples for you, so you can see how easy it is to get this rich information. Note: since this is a preview feature, these queries are ONLY available using api-version=beta.

Viewing the list of reports

Viewing a specific report type

To view data in a specific report type, query /reports/<reportName>

To view a report type by a date range

Most datetime fields are filterable. Use $filter OData querying format to query different intervals. For example:

Pretty simple – but if you want to find out more, check out our simple Report API Sample to see how to get all the reports as well as to filter the reports on dateTime.  We also have a Reporting API getting started guide for simple rest calls. Using only REST calls, this API can easily be integrated into SEIM tools such as splunk and arcsight.

Feedback

We'd love to hear from you.  Please give us feedback through our forums or through comments below.

Get rolling and rocking soon. Analyze activity logs to protect your users and optimize your app purchase and usage.

As mentioned in my last post (insert link), we are publishing the recordings for the Modern Business technical series that have been delivered
around Australia, and this post is to announce the availability of the Grow Efficiently Part 2 material. Just like with the Part 1 content, there have been some updates, and there is also some new content based on more recent changes that will be added .

Grow Efficiently, Part 2: Adapt to Change

This course provides training on how to use the latest Microsoft client, database, and cloud productivity technologies to deliver solutions that help SMBs grow and adapt to change—from expanding the infrastructure that powers their business applications, to adding new PCs, devices and apps that help employees do their best work. Topics include Windows 8.1 migrations for SMBs, deploying Office 365, and SQL Server 2014 planning and implementation, both on-premises and in Microsoft Azure.

Application Compatibility Remediation for Windows 8.1 

In this module you will learn how to discover applications which are deployed to devices in your environment, determine if those applications pose compatibility problems Windows 8.1, and solve compatibility problems with ACT 6 by creating and deploying application SHIM's that fix compatibility issues.

Preparing for a Windows 8.1 Deployment with MDT  

In this module you will learn how to prepare Windows 8.1 deployment package using Microsoft Deployment Tools (MDT) 2013.

Growing Infrastructure With Microsoft Azure

In this module you will learn about extending customer environments into Azure, and leveraging it's IaaS capabilities.

Deploying a Database to Azure and Backing up to Azure

In this module you will work with Azure and your on-premises SQL Server 2014 VM's to Deploy a database from the on-premises SQL Server environment to Azure and Backup Databases from SQL Server Management Studio directly to Azure storage.

Deploying Office 365

In this module you will learn what's included with different Office 365, Office 354 fast track , Deployment steps, enhance steps, Email migration and active directory password sync

The Dynamics CRM to SharePoint integration has always been a key solution to document management within CRM.  With two currently available solutions, the List Component and new server-based SharePoint integration, CRM is pleased to focus our efforts on the server-based integration.  Dynamics CRM 2015 Update 1 will deprecate the List Component as a result of SharePoint's deprecation of the sandbox solution, a dependency of the List Component.

Customers with List Component are advised to upgrade to the server-based SharePoint integration.  With CRM 2015 Update 1, server-based integration gains hybrid support between CRM Online and SharePoint On-Prem.  In a subsequent release, CRM will support CRM On-Prem to SharePoint Online and CRM On-Prem to SharePoint On-Prem.  SharePoint Online or SharePoint Server 2013 SP1 and above is required for server-based integration.

See Set up SharePoint integration with Microsoft Dynamics CRM for more information on enabling server-based SharePoint integration.

As part of migrating team posts to this team blog, we are pleased to highlight the Champion Awards 2015 winners, the “best of the best”, selected by their ALM Ranger peers and communities, for impact over the past 12 months again.

It has been a humbling experience to review each of the comments and realize the magnitude of impact these engineers have made to our communities.

The Visual Studio ALM Rangers team is a model of how Microsoft Product Groups, Services, User Education, Developer Experience and Communities can collaborate together to deliver out of band solutions for missing features and guidance.

It would not be possible without the passion and commitment that you bring to these projects and the communities.

and the winners are …

It is evident from the percentages, that it was a really close race between nominees in all of the categories.

Congratulations!

See champion awards (aka.ms/vsarchampions) for more champions.

Wow, what a busy last few weeks (months for many of us) as we prepped and delivered a couple huge events with BUILD and Ignite. I had the pleasure of being involved with the planning around our .NET content and community event at BUILD and I also got to get up on stage with my manager for the first time and deliver a foundational (read: Overview/What’s New) session at Ignite.

I thought I’d write up my thoughts on my experience at both conferences as well as point out some of my favorite sessions and helpful links along the way.

//BUILD

There were a lot of great announcements, downloads, and more OSS goodness at //BUILD this year. Like:

• Visual Studio 2015 RC
• .NET Framework 4.6 RC
• .NET Core (on GitHub)
• ASP.NET 5 (on GitHub)

I noticed attendees were excited about the direction of .NET and being open source and were generally familiar with our prior announcements and posts on the .NET Team Blog. They were looking at the next level: how the projects were coming along and how to get involved. Common questions I got were…

• How do I get started? – Here’s a great place to start learning and experimentingCan my app run on .NET Core?– Check out corefx-progress and the .NET Portability Analyzer
• What is the .NET Foundation? – We’re here to foster an open ecosystem around .NET by providing legal protection, infrastructure, community support, mentorship and visibility. We want our projects to focus on building amazing things and not the paperwork and infrastructure needed to support OSS projects. Check out our website at www.dotnetfoundation.org and join us in the forums.
• How can I help? – File an issue, submit a PR, or chat with the team. Check out our contributing guides. Keep tabs on http://dotnet.github.io/ for a quick look at all the repos and activity going on in the .NET Foundation and get involved!

I also got to do a Channel 9 “Live” interview on the .NET Foundation. I’ve done so many recording where I’m the interviewer, it was fun being the interviewee this time. VERY classy, professional production. And Seth Juarez, the new Channel 9 host, was AWESOME. I was up there with Jay Schmelzer, Immo Landwerth and Martin Woodward (also on the .NET Team with me). Jay is also the President of the .NET Foundation, Immo is on the Advisory Council and project lead for CoreFx and Martin is the Executive Director of the .NET Foundation. I’m officially the “secretary” but I rather call myself the Technical Evangelist :-).

Check out the interview here: .NET Open Source Initiative

There were also a TON more .NET related sessions at BUILD. Check out them all here.

“After Hours” Community Event

The goal of this event was to speak to the local community as an evening (i.e. after work) free user group presentation & social event, utilizing speakers & experts that were at BUILD. We partnered with the local field evangelism team that helped book an amazing venue. Our message centered on .NET innovations + cross-plat + OSS to educate and energize the local community about .NET and the .NET Foundation.

Speakers were divided into four presentations:

• Matt Thomson (Evangelism team lead) and the CEO of Hackers & Founders
• Scott Hanselman& Damian Edwards on ASP.NET 5
• Phil Haack (GitHub) & Immo Landwerth (.NET Team) with Geoff Norton (@kangaroo) on .NET OSS
• Martin Woodward& Chris Wanstrath (CEO of GitHub) thanking the community and encouraging contributions

The presenters were AWESOME. We had 268 attendees and 90% of them were local SF so that was great to see. Check out some of the tweets: https://twitter.com/search?q=%23AfterHoursAtBuild&src=tyah

Scott and Damian were awesome as always and showed us how to get started with ASP.NET 5 and .NET Core running on Linux. Then they fielded questions for about 20 minutes. Immo and Phil took time to show us how the .NET team is working (successfully) with the community on GitHub. Geoff Norton, our top community contributor, was also really awesome, telling a good, honest story and is a super likable guy. On behalf of the entire team, Immo and Phil thanked him for his amazing contributions.

My personal favorite speaker was Chris Wanstrath CEO of GitHub. He delivered a motivational speech to all those people that were “afraid” of contributing to OSS. He said we’ve all been there, afraid of what people will think of your first contribution, it’s tough out there. It’s our jobs to change that. That really resonated with me.

Ignite

Let me first say that Chicago is my kind of town, baby! We had pretty great weather and I made it out to a Sox game which was fantastic (Cubs were on the road, but I did ride a bike by Wrigley field). Of the 23,000 people there (wow), about 15% were developers.

.NET OSS & Cross-platform support also had a huge interest here and I did a lot of pointing people to our repos. Even VB developers I spoke with were excited to learn that the future of VB.NET is being planned out in the open on the Roslyn repo, and of course I encourage all the VB devs out there to get involved. Please! :-)

Jay and I made a great team on stage. Demos resonated with people and we got great attendance (almost 600 people) and great comments (which is a relief because Jay was reading them too ;)). This was a whirlwind tour of a ton of stuff in on the Microsoft stack, .NET, Visual Studio, including modern mobile and web development across platforms.

Watch: An Overview of the Microsoft Application Platform for Developers and Watch the rest of the Developer-focused sessions here.

Of course, no trip to another city is complete without baseball. :)

Thank you San Francisco and Chicago, see you next time!

Enjoy!

Over in the May challenges from LitDev:

https://social.msdn.microsoft.com/Forums/en-US/49548117-105e-4f79-b20f-709901f5784e/challenge-of-the-month-may-2015?forum=smallbasic

I suggested some dragon games:

Community Suggestion (By Ed Price)

• Write a Dragon Game. It can be any game where you try to slay a dragon, whether it is a text-based game, graphical, or a combination. You could also make the dragon the hero.

The first Dragon Game comes from Athasak.

And from Nonki:

Hello Athasak, great game!  Thanks.

To get a feel of the productivity we're adding in Visual Studio 2015 for connecting to services, here's the quick video for connecting to Azure Storage

We're finalizing the experience for Visual Studio 2015, and would like your feedback for how we can improve Connected Services, and specifically the Azure Storage connected service.

You can provide your feedback here or through UserVoice 

Thanks,

Steve