We’re thrilled to announce that today’s Windows Insider build enables Service Workers by default in Microsoft Edge for the first time.

This is an exciting milestone for us and for the web! These new APIs allow the web to offer better experiences when devices are offline or have limited connectivity, and to send push notifications even when the page or browser isn’t open.

This milestone also establishes the foundation for full-featured Progressive Web App experiences in Microsoft Edge and the Microsoft Store. We’ve carefully tailored our implementation together with Windows and are excited to be the only browser on Windows 10 to provide push handling in the background to optimize for better battery usage. We’ll have more to share about PWAs on Windows in the weeks ahead, so be sure to stay tuned!

We believe Service Workers are a foundational new tool for the web with the potential to usher in a new golden age of web apps. You can try out web experiences powered by Service Workers in Microsoft Edge on starting with today’s Windows Insider release, 17063.

Before we walk through how Service Workers work, let’s start with some context on how the web has tried to handle offline capabilities before Service Workers came along.

The state of the web

Not too long ago, the web’s capabilities were lagging behind what native apps could do. Browser vendors, standards bodies, and the web community have relentlessly attacked this gap over the last decade, with the goal of enabling richer web experiences.

A particularly egregious sore spot for the web has always been how it handled—or failed to handle—the lack of an internet connection, or a poor-quality connection. Offline and the web never really went well together—in most cases, we were given a frustrating error page that only made it clearer that the web’s greatest asset was also its greatest weakness: the internet. In contrast, native apps are typically designed to provide a good experience even while offline or experiencing spotty service.

On top of that, native apps can re-engage their users with push notifications. On the web, after the browser or the app disappears, so does your ability to deliver relevant information or updates to your users.

In the rearview: Application Cache

By 2012, we were able to do offline on the web by introducing a new standard: Application Cache (or App Cache for short). Developers could list URLs for the browser to keep in a special cache called the App Cache, so that when users visited the page they would see something other than an infuriating error page.

Unfortunately, this wasn’t the silver bullet we were looking for in terms of bringing offline to the web. There are more than a few well-documented limitations for App Cache that made it confusing and error prone for many users and web developers. The sum of it all was that there was little control in how the App Cache would work since most of the logic occurred behind-the-scenes in the browser.

That meant if you ran into an issue, it would be exceedingly difficult to understand how to resolve it. There was an obvious need for something that gave greater control to developers by offering the capabilities of App Cache but made it more programmatic and dynamic while doing away with many of its limitations that made it difficult to debug.

Hit Rewind

App Cache left a lot to be desired. For the next swing at enabling offline scenarios, it was clear that browsers needed to provide web developers true control over what would happen when a page and its sub-resources were downloaded, rather than having it automatically and transparently handled in the browser.

With the ability to intercept network requests from a page and to prescribe what to do with each, site authors would be able to respond back to the page with a resource that it could use. Before we get there, it seems that we would need to revisit one of the most fundamental aspects of the web: fetching a resource.

How fetching!

As you may recall from my last post on Fetch, we now have the fetch() method as well as the Request and Response primitives. As a refresher, here’s how you might retrieve some JSON data using the fetch API:

Every request that happens on a page (including the initial navigation, CSS, images, scripts and XHR) is defined as a fetch. The fetch() method (as shown in the code sample) is just a way to explicitly initiate a fetch, while implicit fetches occur when loading a page and all of its sub-resources.

Since we’ve unified the concepts of fetching resources across the web platform, we can provide site authors the chance to define their own behavior via a centralized algorithm. So, how do we pass that control over to you?

Service worker: the worker that serves

Web workers have long been a great tool to offload intensive JavaScript to a separate execution context that doesn’t block the UI nor interaction with the page. Given the right conditions, we can repurpose the concept of a web worker to allow a developer to write logic in response to a fetch occurring on a page. This worker wouldn’t just be a web worker, though. It deserves a new name: Service worker.

A service worker, like a web worker, is written in a JavaScript file. In the script, you can define an event listener for the fetch event. This event is special, in that it gets fired every time the page makes a request for a resource. In the handler for the fetch event, a developer will have access to the actual Request being made.

You can choose to respond with a fetch for the provided Request using the JavaScript APIs which returns a Response back to the page. Doing this essentially follows the typical browser behavior for that request—it’s not intrinsically useful to just do a fetch for the request, ideally it would be more useful if we save previous Response objects for later.

Cache it!

The Cache API allows us to look up a specific Request and get its associated Response object. The APIs give access to a new underlying key/value storage mechanism, where the key is a Request object and the value is a Response object. The underlying caches are separate from the browser’s HTTP cache and are origin-bound (meaning that they are isolated based on scheme://hostname:port) so that you cannot access caches outside of your origin. Each origin can define multiple different caches with different names. The APIs allow you asynchronously open and manipulate the caches by making use of Promises:

These caches are completely managed by the developer, including updating the entries and purging them when they’re no longer needed – this allows you to rely on what will be there when you may not necessarily be connected to the internet.

Although the Caches API is defined as part of the Service Worker spec, it can also be accessed from the main page.

So now you have two asynchronous storage APIs to choose from: Indexed DB and the Caches API. In general, if what you’re trying to store is URL-addressable, use the Caches API; for everything else, use Indexed DB.

Now that we have a way to save those Response objects for later use, we’re in business!

Back to the worker

With a service worker, we can intercept the request and respond from cache. This gives us the ability to improve page load performance and reliability, as well as to offer an offline experience. You can choose to let the fetch go through to the internet as is, or to get something from the cache using the Cache API.

The first step to using a service worker is to register it on the page. You can do this by first feature-detecting and then calling the necessary APIs:

As part of the registration, you’ll need to specify the location of the service worker script file and define the scope. The scope is used to define the range of URLs that you want the service worker to control. After a service worker is registered, the browser will keep track of the service worker and the scope it is registered to.

Upon navigating to a page, the browser will check if a service worker is registered for that page based on the scope. If so, the page will go on to use that service worker until it is navigated away or closed. In such a case, the page is said to be controlled by that service worker. Otherwise, the page will instead use the network as usual, and will not be controlled by a service worker.

Upon registration, the service worker won’t control the page that registered it. It will take control if you refresh the page or you open a new page that’s within its scope.

After initiating the registration of a service worker, it will go through the registration process. That will involve going through the different phases of its lifecycle.

The service worker lifecycle

Let’s unpack the different phases of the service worker’s lifecycle, starting with what happens once you try to register it.

Installing

This is the first step that any service worker goes through. After the JavaScript file has been downloaded and parsed by the browser, it will run the install event of your script. That’s when you’ll want to get everything ready such as priming your caches.

In the following example, the oninstall event handler in the service worker will create a cache called “static-v1” and add all the static resources of the page to the cache for later use by the fetch handler.

Installed

Once the service worker is installed, the setup is complete, and the service worker is awaiting all pages/iframes (clients) that are controlled by this service worker registration to be closed so that it can be activated. It could be potentially problematic to change the service worker for pages that are still actively using a previous version of the service worker, so the browser will instead wait until they’ve been navigated away or closed.

Activating

Once no clients are controlled by the service worker registration (or if you called the skipWaiting API), the service worker goes to the activating phase. This will run the activate event in the service worker which will give you the opportunity to clean up after the previous workers that may have left things behind, such as stale caches.

In this example, the onactivate event handler in the service worker will remove all caches that are not named “static-v1.”

Activated

Once it’s been activated, the service worker can now handle fetch and other events as well!

In this example, the onfetch event handler in the service worker will respond back to the page with a match from the cache if it exists and if there isn’t an entry in the cache, it will defer to making a fetch to the internet instead. If that fetch fails, it will resort to returning a fallback.

Redundant

The final phase of the service worker is when it is being replaced by another service worker because there’s a new one available that is going to take its place.

There’s more to it: the big picture

So far, we’ve explored the following service worker events: install, activate, and fetch. Install and activate are considered lifetime events while fetch is considered a functional event. What if we could expand on the service worker’s programming model and introduce other functional events that could plug in to it? Given that service workers are event-driven and are not tied down to the lifetime of a page, we could add other events such as push and notificationclick which would present the necessary APIs to enable push notifications on the web.

Push it to the limit

Push notifications provide a mechanism for developers to inform their users in a timely, power-efficient and dependable way, that re-engages them with customized and relevant content. Compared to current web notifications, a push notification can be delivered to a user without needing the browser/app or page to be opened.

The W3C Push API and Notification API go hand-in-hand to enable push notifications in modern browsers. The Push API is used to set up a push subscription and is invoked when a message is pushed to the corresponding service worker. The service worker then is responsible for showing a notification to the user using the Notification API and reacting to user interaction with the notification.

A standardized method of message delivery is also important for the W3C Push API to work consistently across all major browsers where application servers will need to use multiple push services. For instance, Google Chrome and Mozilla Firefox use Firebase Cloud Messaging (FCM) and Mozilla Cloud Services (MCS), respectively while Microsoft Edge relies on the Windows Push Notification Service (WNS) to deliver push messages.

To reach reasonable interoperability with other browsers’ messaging services, WNS has now deployed support for the Web Push protocols being finalized within IETF, as well as the Message Encryption spec and the Voluntary Application Server Identification (VAPID) spec for web push. Web developers can now use the Web Push APIs and service workers to provide an interoperable push service on the web.

To start, you’ll first need to make sure your web server is setup to send pushes. The Web-Push open-source library is a great reference for anyone new to web push. The contributors have done a reasonable job in keeping up with the IETF specs. After starting up a node.js server based on the web-push library, you’ll need to setup the VAPID keys. Keep in mind that you’ll need to use HTTPS as it is required for service workers and push. You only need to set up the VAPID keys once which can be generated easily using the corresponding function in the web-push library.

Once that’s all sorted out, it’s time to take advantage of push in your site or app. Once the page loads, the first thing you’ll want to do is get the public key from the application server so that you can set up the push subscription.

With the public key in hand, as before, we’ll need to install the service worker, but this time, we’ll also create a push subscription.

Before a new push subscription is created, Microsoft Edge will check whether a user granted permission to receive notifications. If not, the user will be prompted by the browser for permission. You can read more about permission management in an earlier post about Web Notifications in Microsoft Edge. From a user’s perspective, notifications from the page or from a push service appear identical, so we are using the same permission for both types of notifications.

To create a push subscription, you’ll need to set the userVisibleOnly option to “true” – meaning a notification must be shown as a result of a push – and provide a valid applicationServerKey. If there is already a push subscription, there is no need to subscribe again.

At any point when a push is received by the client, a corresponding service worker is run to handle the event. As part of this push handling, a notification must be shown so that the user understands that something is potentially happening in the background.

Of course, after a notification is shown, there is still the matter of dealing with when its been clicked. As such, we need to have another event listener in the service worker that would handle this case.

In this case, we first dismiss the notification and then we can choose to open a window to the intended destination. You’re also able to sort through the already open windows and focus one of those, or perhaps even navigate an existing window.

Push: The Next Generation

As part of our ongoing commitment to expanding the possibilities of the web, Microsoft Edge and PWAs in Windows will handle these service worker push event handlers in the background—there’s no need for Microsoft Edge or your PWA to be running for the push to be handled. That’s because we’ve integrated with Windows to allow for a more holistic approach to push notifications.

By leveraging Windows’ time-tested process lifetime management, we’re able to offer a system that reacts appropriately to system pressures such as low battery or high CPU and memory usage. For users, that means better resource management and battery life expectations. For developers, it means a push event handler that will get to run to completion, without interruption from user actions such as closing the browser window or app. Note that a service worker instance that is running in the foreground for the fetch event will not be the same as the one in the background handling the push event.

Notifications in Microsoft Edge and PWAs will be integrated in the Windows Action Center. If a user receives a notification and didn’t get the chance to act on it, it will get tucked away into Action Center for later, so notifications never get left unseen. Action Center will also group multiple notifications coming from the same domain, so that users have an easier time sorting through them.

Service worker: properties

I’d like to take a moment to go over some things you should keep in mind when using service workers in your web app or site. In no particular order, here they are:

• HTTPS-only. Service workers will not work in HTTP; you will need to use HTTPS. Fortunately, if you’re testing locally, you’re allowed to register service workers on localhost.
• No DOM access is allowed. As with web workers, you don’t get access to the page’s object model. This means that if you need to change something about the page, you’ll need to use postMessage from the service worker to the page so that you can handle it DOM changes from the page.
• Executes separate from page. Because these scripts are not tied to the lifetime of a page, it’s important to understand that they do not share the same context as the page. Aside from not having access to the DOM (as stated earlier), they won’t have access to the same variables available on the page.
• Trumps App Cache. Service workers and App Cache don’t play well together. App Cache will be ignored when service workers are in use. Service workers were meant to give more control to the web developer—imagine if you had to deal with the magic of App Cache while you’re trying to step through the logic of your service worker!
• Script can’t be on CDN. The JavaScript file for the service worker can’t be hosted on a Content Distribution Network (CDN), it must be on the same domain as the page. However, if you like, you can import scripts from your CDN.
• Can be terminated any time. Remember that service workers are meant to be short-lived and their lifetime is tied to events. In particular, service workers have a time limit in which they must finish executing their event handlers. In other cases, the browser or the operating system may choose to terminate a service worker that impacts the battery, CPU, or memory consumption. In either case, it would be prudent to not rely on global variables in the service worker in case a different service worker instance is used on a subsequent event that’s being handled.
• Only asynchronous requests allowed. Synchronous XHR is not allowed here! Neither is localStorage, so it’s best to make use of Indexed DB and the new Caches API described earlier.
• Service worker to scope is 1:1. You’ll only be able to have one service worker per scope. That means if you try to register a different service worker for a scope that already has a service worker, that service worker will be updated.

Recap

Service workers are so much more than an HTTP proxy! They are the foundation of a web app model that enables event-driven JavaScript to run, independent of web pages. Service workers were brought in to the web platform as a necessity to enable offline use cases, but it’s clear that they can do so much more, as we continue to extend their capabilities to other scenarios. Today we have push, but in the future, there will be other exciting capabilities that will bring the web that much closer to offering the captivating and reliable experiences we’ve always wanted.

Go put a worker to work!

So, what are you waiting for? You can get started testing service workers in Microsoft Edge today by installing the Windows Insider Preview build 17063 or higher. We’d love to hear your feedback, so please share any bugs you encounter or reach out to us on Twitter to get in touch!

— Ali Alabbas, Program Manager, Microsoft Edge
— Jatinder Mann, Program Manager, Microsoft Edge

The post Service Workers: Going beyond the page appeared first on Microsoft Edge Dev Blog.

Great applications help users do great things — enabling a wide range of creative, productivity and entertainment scenarios. Returning to activities can be a challenge, especially when a person wants to continue those activities across multiple devices. By writing User Activities, application developers have a new tool to get users back into their application.

In this article, you’ll learn how to drive application re-engagement by writing great User Activities into the Microsoft Graph with their UWP applications. This article is also a companion to the Microsoft Connect(); session: Engaging with your customers on any platform using the Microsoft Graph, Activity Feed, and Adaptive Cards.

User Activities and Timeline

Starting in Windows Insider Preview build 17056 or higher, User Activities generated by your application appear in Timeline. By writing User Activities into the Microsoft Graph, you can express specific content within your application as a destination which is showcased in Windows, and accessible on your iOS and Android devices.

Each User Activity represents a single destination within your app: such as a TV show, document or your current campaign in a game. When you engage with that activity (by creating an Activity Session), the system creates a history record indicating the start and end time for that activity. As you re-engage with that User Activity over time, multiple History Records will be recorded for a single User Activity. Here’s how to get started:

• Install Windows SDK for Windows 10 Fall Creators Update (10.0.16299) or the latest Windows Insider Preview SDK. The Windows Insider Preview SDK requires Visual Studio 2017
• To try out Timeline, install the Windows Insider Preview on the target machine

Adding UserActivities to your app

UserActivities are the unit of user engagement in Windows, and they consist of three components: a deep-link, visuals and content metadata.

1. The Activation Deep Link is a URI that can be passed back to an application or experience in order to resume the application with specific context. Typically, these links take the form of protocol handler for a scheme (e.g. “my-app://page2?action=edit”) or an AppUriHandlers (e.g. http://constoso.com/page2?action=edit).
2. Visuals are a set of properties that allow users to visually identify an activity, for example: title, description, or Adaptive Card elements.
3. Finally, Content Metadata is metadata for the content of the of activity that can be used to group and retrieve activities under a specific context. Often, this takes the form of http://schema.org data.

In order to integrate UserActivities with your application, you need to:

1. Generate UserActivity objects when your user’s context changes within an application (page navigation, new game, etc.)
2. Populate UserActivity objects with the minimum set of required fields: ActivityId, ActivationUri, DisplayText
3. Add a custom scheme handler to your application so it can be re-activated by your UserActivities

UserActivities can be integrated into an application with just a few lines of code:

UserActivitySession _currentActivity;

private async Task GenerateActivityAsync()
{
    //Get the default UserActivityChannel and query it for our UserActivity. If the activity doesn't exist, one is created.
    UserActivityChannel channel = UserActivityChannel.GetDefault();
    UserActivity userActivity = await channel.GetOrCreateUserActivityAsync("MainPage");

    //Populate required properties
    userActivity.VisualElements.DisplayText = "Hello Activities";
    userActivity.ActivationUri = new Uri("my-app://page2?action=edit");

    //Save
    await userActivity.SaveAsync(); //save the new metadata

    //Dispose of any current UserActivitySession, and create a new one.
    _currentActivity?.Dispose();
    _currentActivity = userActivity.CreateSession();
}

The first line in the GenerateActivityAsync() method gets a user’s UserActivityChannel. This is the feed that this app’s activities will be published to. The next line queries that channel of an activity called “MainPage”

• Your application should name activities in such a way that same ID is generated each time the user is in a particular location in the app. For example, if your application is page-based, use an identifier for the page, if it’s document based, use the name of the doc (or a hash of the name).
• If there is an existing activity in the feed with the same ID, that activity will be return from the channel (with the UserActivity object State property set to Published). If there is no activity with that name, and new activity with State set to New.
• Activities are scoped to your app, there is no need to worry about your activity ID colliding with IDs from other applications

After getting or creating the activity the next lines of code specify the other two required fields: the DisplayText and the ActivationUri.

Next, save the UserActivity metadata, by calling SaveAsync(), and finally CreateSession(). That last method returns a UserActivitySession object that we can use to manage when the user is actually engaged with the UserActivity. For example, we should call Dispose() on the UserActivitySession when the user leaves the page. In the example above, we also call Dispose() on _currentActivity right before we call CreateSession(). This is because we made _currentActivity a member field of our page, and we want to stop any existing activity before we start the new one (the ‘?’ is an inline null-check).

Since, in this case, our ActivationUri is a custom scheme, we also need to register the Protocol in the application manifest. This can be done in the Package.appmanifest XML file, or using the designer, as shown below. Double-click the Package.appmanifest file to launch the designer, select the Declarations tab and add a Protocol definition. The only property that needs to be filled out, for now, is Name. It should match the URI we specified above hello-activities.

Now we need to write some code to tell the application what to do when it’s been activated via a protocol. In this case, we’ll override the OnActivated method in App.xaml.cs to pass the URI on to our MainPage:

protected override void OnActivated(IActivatedEventArgs e)
{
    LoadFrame(e);
    if (e.Kind == ActivationKind.Protocol)
    {
        var uriArgs = e as ProtocolActivatedEventArgs;
        if (uriArgs != null)
        {
            Frame rootFrame = Window.Current.Content as Frame;
	    if (uriArgs.Host == "page2”)
            {
                rootFrame.Navigate(typeof(SecondaryPage), uriArgs)
            }
        }
    }
    Window.Current.Activate();
}

Use Adaptive Cards to Improve the Timeline Experience

User Activities will appear in Cortana and Timeline experiences. When activities appear in Timeline, we display them using the Adaptive Card framework. If you do not provide an adaptive card for each activity, Timeline will automatically create a simple activity card based on your application name and icon, the required Title field and optional Description field. Below is an example Adaptive Card payload and the card it produces.

{
  "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
  "type": "AdaptiveCard",
  "backgroundImage": "https://winblogs.azureedge.net/win/2017/11/eb5d872c743f8f54b957ff3f5ef3066b.jpg",
  "body": [
    {
      "type": "Container",
      "items": [
        {
          "type": "TextBlock",
          "text": "Windows Blog",
          "weight": "bolder",
          "size": "large",
          "wrap": true,
          "maxLines": 3
        },
        {
          "type": "TextBlock",
          "text": "Training Haiti’s radiologists: St. Louis doctor takes her teaching global",
          "size": "default",
          "wrap": true,
          "maxLines": 3
        }
      ]
    }
  ]
}

Adaptive Cards can be added to the UserActivity object by passing a JSON string to the AdaptiveCardBuilder and setting the UserActivity.VisualElements.Content property:

activity.VisualElements.Content =
AdaptiveCardBuilder.CreateAdaptiveCardFromJson(cardText);

Cross-platform and Service-to-service integration

If your application has a cross-platform presence (for example on Android and iOS), or maintains user state in the cloud, you can publish UserActivities via integration with Microsoft Graph.

Once your application or service is authenticated with a Microsoft Account, it is two simple REST calls to generate Activity and History objects, using the same data as described above.

Summary

In this blog post, we learned how to use the UserActivity API to make your application show up in Timeline and Cortana, but there is much more you can do:

• Learn more about UserActivity API on the Windows Dev Center, or check out the sample code at https://github.com/Microsoft/project-rome
• Check some more sophisticated Adaptive Cards at io
• Publish UserActivities from iOS, Android or your web service via MS Graph
• Learn more about Project Rome on GitHub

The post Application Engagement in Windows Timeline with User Activities appeared first on Building Apps for Windows.

Today we are pleased to announce the release of a new Azure Financial Services Regulated Workloads Blueprint.

The Azure Security and Compliance Blueprint Program provides automated solutions and guidance for rapid deployment of Azure services that meet specific regulatory requirements from weeks to a few hours. The new Financial Services Regulated Workloads Blueprint gives you an automated solution that will help guide you in storing and managing sensitive financial information such as payment data in Azure. The Financial Services Blueprint is designed to help customers meet compliance requirements outlined in the American Institute of Certified Public Accountants (AICPA) SOC 1 and SOC 2 standards, the Payment Card Industry Data Security Standard (PCI DSS) version 3.2, as well as the Federal Financial Institutions Examination Council (FFIEC), and Gramm-Leach-Bliley Act (GLBA).

Using the Financial Services Blueprint, you can deploy and securely configure an Azure SQL Database, a web application protected by security services such as Azure App Service Environment (ASE), the Web Application Firewall (WAF), and Azure Security Center (ASC). Automated templates and reference architectures are provided to help you implement the technical controls required to achieve a trusted and more secure end to end compliant deployment.

The Financial Services Blueprint also includes a new customer responsibility matrix using the FFIEC risk assessment tool. In addition, the Workbook included in the Blueprint provides customer actionable answers to controls across 19 control domains, and provides control alignment with compliance regimes including PCI DSS, FFIEC, GLBA, and SOC. 

• Explore the solution at https://aka.ms/fsiblueprint which includes links to the scripts and Azure Resource Manager templates.
• Review the customer responsibility matrix to understand how security controls where implemented to help meet various requirements.
• Watch the eight-minute video discussing the solution and describing the deployment process.

For any questions and to access to these documents, please e-mail AzureBlueprint@microsoft.com.

We welcome your comments and suggestions to help us continually improve your Azure Security and Compliance Blueprint Program experience.

The Developer Economics Q4 2017 survey is here in its 14^th edition to shed light on the future of the software industry. Every year more than 40,000 developers around the world participate in this survey, so this is a chance to be part of something big, voice your thoughts, and make your own contribution to the developer community.

Is this survey for me?

The survey is for all developers engaging in the following software development areas: cloud, mobile, desktop, IoT, AR/VR, machine learning, data science, web, backend, and gaming.

What questions am I likely to be asked?

The survey asks questions about the status and the future of the software industry.

• What’s going up and what’s going down in the software industry?
• Are you working on the projects you would like to work on?
• Where do you think development time should be invested?
• Which are your favorite tools and platforms?

What’s in it for me?

There are some perks to go with your participation. Have a look at what you can get our hands on:

• Amazing prizes up for grabs:  A Pixel 2 phone, an iPhone X, a Windows Acer MR headset, a Nintendo Switch, Raspberry Pi 3’s, and more
• A Developer Scorecard showing responses from developers in your region
• A free State of the Developer Nation Q1, 2018 report with the key findings (February 2018)

What’s in it for Microsoft?

This is an independent survey from SlashData, an analyst firm in the developer economy that tracks global software developer trends. We’re interested in seeing the report that comes from this survey, and we want to ensure the broadest developer audience participates.

Of course, any data collected by this survey is between you and SlashData. You should review their Terms & Conditions page to learn more about the awarding of prizes, their data privacy policy, and how SlashData will handle your personal data.

Ready to go?

The survey is open until December 31, 2017.

Take the survey today

The survey is available in English, Chinese (Simplified, & Traditional), Spanish, Portuguese, Vietnamese, Russian, Japanese, or Korean.

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 17061 or greater). The Preview SDK Build 17061 contains bug fixes and under development changes to the API surface area.

The Preview SDK can be downloaded from developer section on Windows Insider.

For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

Things to note:

• This build works in conjunction with previously released SDKs and Visual Studio 2017. You can install this SDK and still also continue to submit your apps that target Windows 10 Creators build or earlier to the store.
• The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.

Known Issues

• Installation on an operating system that is not a Windows 10 Insider Preview build is not supported and may fail.
• Cannot deploy to a device: When attempting to deploy to a mobile device, it fails with the following error:  DEP0001: Unexpected Error: SmartDeviceException – Class not registered [0x80131500]

Please follow this posting for updates.  https://developercommunity.visualstudio.com/content/problem/122425/dep0001-unexpected-error-smartdeviceexception-the.html

• XAML Designer fails to load: When attempting to load the XAML designer, an Unhandled exception occurs “The XAML Designer has excited unexpectedly.

What’s New:

• C++/WinRT Now Available: The C++/WinRT headers and cppwinrt compiler (cppwinrt.exe) are now included in the Windows SDK. The compiler comes in handy if you need to consume a third-party WinRT component or if you need to author your own WinRT components with C++/WinRT. The easiest way to get working with it after installing the Windows Insider Preview SDK is to start the Visual Studio Developer Command Prompt and run the compiler in that environment. Authoring support is currently experimental and subject to change. Stay tuned as we will publish more detailed instructions on how to use the compiler in the coming week.The ModernCPP blog has a deeper dive into the CppWinRT compiler. Please give us feedback by creating an issue at: https://github.com/microsoft/cppwinrt.

 Breaking Changes

• New MIDL key words.

As a part of the “modernizing IDL” effort, several new keywords are added to the midlrt tool. These new keywords will cause build breaks if they are encountered in IDL files.

The new keywords are:

• event
• set
• get
• partial
• unsealed
• overridable
• protected
• importwinmd

If any of these keywords is used as an identifier, it will generate a build failure indicating a syntax error.

The error will be similar to:

1 >d:ossrconecorecomcombaseunittestastatestserverstestserver6idlremreleasetest.idl(12) : error MIDL2025 : [msg]syntax error [context]: expecting a declarator or * near “)”

To fix this, modify the identifier in error to an “@” prefix in front of the identifier. That will cause MIDL to treat the offending element as an identifier instead of a keyword.

API Updates and Additions

When targeting new APIs, consider writing your app to be adaptive in order to run correctly on the widest number of Windows 10 devices. Please see Dynamically detecting features with API contracts (10 by 10) for more information.

The following APIs have been added to the platform since the release of 16299.

namespace Windows.ApplicationModel {
  public enum AddResourcePackageOptions : uint
  public sealed class AppInstance
  public sealed class PackageCatalog {
    IAsyncOperationWithProgress<PackageCatalogAddResourcePackageResult, PackageInstallProgress> AddResourcePackageAsync(string resourcePackageFamilyName, string resourceID, AddResourcePackageOptions options);
    IAsyncOperation<PackageCatalogRemoveResourcePackagesResult> RemoveResourcePackagesAsync(IIterable<Package> resourcePackages);
  }
  public sealed class PackageCatalogAddResourcePackageResult
  public sealed class PackageCatalogRemoveResourcePackagesResult
  public struct PackageInstallProgress
  public enum StartupTaskState {
    EnabledByPolicy = 4,
  }
}
namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    BarcodeScannerProvider = 1022,
  }
  public sealed class BarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
  public interface IBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs
}
namespace Windows.ApplicationModel.Background {
  public enum BackgroundAccessRequestKind
  public static class BackgroundExecutionManager {
    public static IAsyncOperation<bool> RequestAccessKindAsync(BackgroundAccessRequestKind requestedAccess, string reason);
  }
  public sealed class CustomSystemEventTrigger : IBackgroundTrigger
  public enum CustomSystemEventTriggerRecurrence
  public sealed class MobileBroadbandPcoDataChangeTrigger : IBackgroundTrigger
  public sealed class NetworkOperatorDataUsageTrigger : IBackgroundTrigger
  public sealed class StorageLibraryChangeTrackerTrigger : IBackgroundTrigger
  public sealed class TetheringEntitlementCheckTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
  public enum PhoneCallMedia {
    AudioAndRealTimeText = 2,
  }
  public sealed class VoipCallCoordinator {
    VoipPhoneCall RequestNewAppInitiatedCall(string context, string contactName, string contactNumber, string serviceName, VoipPhoneCallMedia media);
    VoipPhoneCall RequestNewIncomingCall(string context, string contactName, string contactNumber, Uri contactImage, string serviceName, Uri brandingImage, string callDetails, Uri ringtone, VoipPhoneCallMedia media, TimeSpan ringTimeout, string contactRemoteId);
  }
  public sealed class VoipPhoneCall {
    void NotifyCallAccepted(VoipPhoneCallMedia media);
  }
}
namespace Windows.ApplicationModel.Core {
  public sealed class AppListEntry {
    IAsyncOperation<bool> LaunchForUserAsync(User user);
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataPackagePropertySet : IIterable<IKeyValuePair<string, object>>, IMap<string, object> {
    string ContentSourceUserActivityJson { get; set; }
  }
  public sealed class DataPackagePropertySetView : IIterable<IKeyValuePair<string, object>>, IMapView<string, object> {
    string ContentSourceUserActivityJson { get; }
  }
  public static class StandardDataFormats {
    public static string UserActivityJsonArray { get; }
  }
}
namespace Windows.ApplicationModel.Store.Preview {
  public enum StoreSystemFeature {
    ArchitectureArm64 = 34,
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallItem {
    bool LaunchAfterInstall { get; set; }
  }
  public sealed class AppInstallManager {
    IAsyncOperation<bool> GetIsPackageIdentityAllowedToInstallAsync(string correlationVector, string packageIdentityName, string publisherCertificateName);
    IAsyncOperation<bool> GetIsPackageIdentityAllowedToInstallForUserAsync(User user, string correlationVector, string packageIdentityName, string publisherCertificateName);
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesAsync(string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesForUserAsync(User user, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<AppInstallItem> SearchForUpdatesAsync(string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<AppInstallItem> SearchForUpdatesForUserAsync(User user, string productId, string skuId, string correlationVector, string clientId, AppUpdateOptions updateOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallAsync(string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
    IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallForUserAsync(User user, string productId, string flightId, string clientId, string correlationVector, AppInstallOptions installOptions);
  }
  public sealed class AppInstallOptions
  public sealed class AppInstallStatus {
    bool IsStaged { get; }
  }
  public sealed class AppUpdateOptions
}
namespace Windows.ApplicationModel.UserActivities {
  public sealed class UserActivity {
    public UserActivity(string activityId);
    string ToJson();
    public static string ToJsonArray(IIterable<UserActivity> activities);
    public static UserActivity TryParseFromJson(string json);
    public static IVector<UserActivity> TryParseFromJsonArray(string json);
  }
  public sealed class UserActivityChannel {
    public static void DisableAutoSessionCreation();
    IAsyncOperation<IVector<UserActivitySessionHistoryItem>> GetRecentUserActivitiesAsync(int maxUniqueActivities);
    IAsyncOperation<IVector<UserActivitySessionHistoryItem>> GetSessionHistoryItemsForUserActivityAsync(string activityId, DateTime startTime);
    public static UserActivityChannel TryGetForWebAccount(WebAccount account);
  }
  public sealed class UserActivityRequest
  public sealed class UserActivityRequestedEventArgs
  public sealed class UserActivityRequestManager
  public sealed class UserActivitySessionHistoryItem
  public sealed class UserActivityVisualElements {
    string AttributionDisplayText { get; set; }
  }
}
namespace Windows.Devices.Bluetooth {
  public sealed class BluetoothAdapter {
    bool AreClassicSecureConnectionsSupported { get; }
    bool AreLowEnergySecureConnectionsSupported { get; }
  }
  public sealed class BluetoothDevice : IClosable {
    bool WasSecureConnectionUsedForPairing { get; }
  }
  public sealed class BluetoothLEDevice : IClosable {
    bool WasSecureConnectionUsedForPairing { get; }
  }
}
namespace Windows.Devices.Display {
  public sealed class DisplayMonitor
  public enum DisplayMonitorConnectionKind
  public enum DisplayMonitorDescriptorKind
  public enum DisplayMonitorPhysicalConnectorKind
  public enum DisplayMonitorUsageKind
}
namespace Windows.Devices.PointOfService {
  public sealed class BarcodeScannerReport {
    public BarcodeScannerReport(uint scanDataType, IBuffer scanData, IBuffer scanDataLabel);
  }
  public sealed class ClaimedBarcodeScanner : IClosable {
    bool IsVideoPreviewShownOnEnable { get; set; }
    void HideVideoPreview();
    IAsyncOperation<bool> ShowVideoPreviewAsync();
  }
  public sealed class UnifiedPosErrorData {
    public UnifiedPosErrorData(string message, UnifiedPosErrorSeverity severity, UnifiedPosErrorReason reason, uint extendedReason);
  }
}
namespace Windows.Devices.PointOfService.Provider {
  public sealed class BarcodeScannerDisableScannerRequest
  public sealed class BarcodeScannerDisableScannerRequestEventArgs
  public sealed class BarcodeScannerEnableScannerRequest
  public sealed class BarcodeScannerEnableScannerRequestEventArgs
  public sealed class BarcodeScannerGetSymbologyAttributesRequest
  public sealed class BarcodeScannerGetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerHideVideoPreviewRequest
  public sealed class BarcodeScannerHideVideoPreviewRequestEventArgs
  public sealed class BarcodeScannerProviderConnection : IClosable
  public sealed class BarcodeScannerProviderTriggerDetails
  public sealed class BarcodeScannerSetActiveSymbologiesRequest
  public sealed class BarcodeScannerSetActiveSymbologiesRequestEventArgs
  public sealed class BarcodeScannerSetSymbologyAttributesRequest
  public sealed class BarcodeScannerSetSymbologyAttributesRequestEventArgs
  public sealed class BarcodeScannerStartSoftwareTriggerRequest
  public sealed class BarcodeScannerStartSoftwareTriggerRequestEventArgs
  public sealed class BarcodeScannerStopSoftwareTriggerRequest
  public sealed class BarcodeScannerStopSoftwareTriggerRequestEventArgs
  public enum BarcodeScannerTriggerState
  public sealed class BarcodeSymbologyAttributesBuilder
}
namespace Windows.Foundation.Numerics {
  public struct Rational
}
namespace Windows.Globalization {
  public static class ApplicationLanguages {
    public static IVectorView<string> GetLanguagesForUser(User user);
  }
  public sealed class Language {
    LanguageLayoutDirection LayoutDirection { get; }
  }
  public enum LanguageLayoutDirection
}
namespace Windows.Graphics {
  public struct DisplayAdapterId
  public interface IGeometrySource2D
}
namespace Windows.Graphics.Capture {
  public sealed class Direct3D11CaptureFrame : IClosable
  public sealed class Direct3D11CaptureFramePool : IClosable
  public sealed class GraphicsCaptureItem
  public sealed class GraphicsCapturePicker
  public sealed class GraphicsCaptureSession : IClosable
}
namespace Windows.Graphics.DirectX {
  public enum DirectXColorSpace
}
namespace Windows.Graphics.Display {
  public sealed class AdvancedColorInfo
  public enum AdvancedColorKind
  public sealed class BrightnessOverrideSettings
  public sealed class ColorOverrideSettings
  public enum DisplayBrightnessOverrideScenario
  public enum DisplayColorOverrideScenario
  public sealed class DisplayEnhancementOverride
  public sealed class DisplayEnhancementOverrideCapabilities
  public sealed class DisplayEnhancementOverrideCapabilitiesChangedEventArgs
  public sealed class DisplayInformation {
    event TypedEventHandler<DisplayInformation, object> AdvancedColorInfoChanged;
    AdvancedColorInfo GetAdvancedColorInfo();
  }
  public enum HdrMetadataFormat
  public struct NitRange
}
namespace Windows.Graphics.Holographic {
  public sealed class HolographicCamera {
    bool CanOverrideViewport { get; }
  }
  public sealed class HolographicCameraPose {
    void OverrideProjectionTransform(HolographicStereoTransform projectionTransform);
    void OverrideViewport(Rect leftViewport, Rect rightViewport);
    void OverrideViewTransform(SpatialCoordinateSystem coordinateSystem, HolographicStereoTransform coordinateSystemToViewTransform);
  }
  public sealed class HolographicFramePresentationMonitor : IClosable
  public sealed class HolographicFramePresentationReport
  public sealed class HolographicSpace {
    HolographicSpaceUserPresence UserPresence { get; }
    event TypedEventHandler<HolographicSpace, object> UserPresenceChanged;
    HolographicFramePresentationMonitor CreateFramePresentationMonitor(uint maxQueuedReports);
    void WaitForNextFrameReady();
    void WaitForNextFrameReadyWithHeadStart(TimeSpan requestedHeadStartDuration);
  }
  public enum HolographicSpaceUserPresence
}
namespace Windows.Graphics.Imaging {
  public enum BitmapPixelFormat {
    P010 = 104,
  }
}
namespace Windows.Graphics.Printing {
  public sealed class PrintPageRange
  public sealed class PrintPageRangeOptions
  public sealed class PrintTaskOptions : IPrintTaskOptionsCore, IPrintTaskOptionsCoreProperties, IPrintTaskOptionsCoreUIConfiguration {
    IVector<PrintPageRange> CustomPageRanges { get; }
    PrintPageRangeOptions PageRangeOptions { get; }
  }
  public static class StandardPrintTaskOptions {
    public static string CustomPageRanges { get; }
  }
}
namespace Windows.Graphics.Printing.OptionDetails {
  public sealed class PrintBindingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintBorderingOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCollationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintColorModeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCopiesOptionDetails : IPrintNumberOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCustomItemListOptionDetails : IPrintCustomOptionDetails, IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
    void AddItem(string itemId, string displayName, string description, IRandomAccessStreamWithContentType icon);
  }
  public sealed class PrintCustomTextOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintCustomToggleOptionDetails : IPrintCustomOptionDetails, IPrintOptionDetails
  public sealed class PrintDuplexOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintHolePunchOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintMediaSizeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintMediaTypeOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public enum PrintOptionType {
    Toggle = 4,
  }
  public sealed class PrintOrientationOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintPageRangeOptionDetails : IPrintOptionDetails
  public sealed class PrintQualityOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintStapleOptionDetails : IPrintItemListOptionDetails, IPrintOptionDetails {
    string Description { get; set; }
    string WarningText { get; set; }
  }
  public sealed class PrintTaskOptionDetails : IPrintTaskOptionsCore, IPrintTaskOptionsCoreUIConfiguration {
    PrintCustomToggleOptionDetails CreateToggleOption(string optionId, string displayName);
  }
}
namespace Windows.Management.Deployment {
  public sealed class PackageManager {
    IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RequestAddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> relatedPackageUris, IIterable<Uri> packageUrisToInstall);
  }
}
namespace Windows.Management.Update {
  public sealed class PreviewBuildsManager
  public sealed class PreviewBuildsState
}
namespace Windows.Media {
  public sealed class VideoFrame : IClosable, IMediaFrame {
    IAsyncAction CopyToAsync(VideoFrame frame, IReference<BitmapBounds> sourceBounds, IReference<BitmapBounds> destinationBounds);
    public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height);
    public static VideoFrame CreateAsDirect3D11SurfaceBacked(DirectXPixelFormat format, int width, int height, IDirect3DDevice device);
    public static VideoFrame CreateWithDirect3D11Surface(IDirect3DSurface surface);
    public static VideoFrame CreateWithSoftwareBitmap(SoftwareBitmap bitmap);
  }
}
namespace Windows.Media.Audio {
  public sealed class AudioGraph : IClosable {
    IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource);
    IAsyncOperation<CreateMediaSourceAudioInputNodeResult> CreateMediaSourceAudioInputNodeAsync(MediaSource mediaSource, AudioNodeEmitter emitter);
  }
  public sealed class AudioGraphSettings {
    double MaxPlaybackSpeedFactor { get; set; }
  }
  public sealed class AudioStateMonitor
  public sealed class CreateMediaSourceAudioInputNodeResult
  public sealed class MediaSourceAudioInputNode : IAudioInputNode, IAudioInputNode2, IAudioNode, IClosable
  public enum MediaSourceAudioInputNodeCreationStatus
}
namespace Windows.Media.Capture {
  public sealed class CapturedFrame : IClosable, IContentTypeProvider, IInputStream, IOutputStream, IRandomAccessStream, IRandomAccessStreamWithContentType {
    BitmapPropertySet BitmapProperties { get; }
    CapturedFrameControlValues ControlValues { get; }
  }
  public enum KnownVideoProfile {
    HdrWithWcgPhoto = 8,
    HdrWithWcgVideo = 7,
    HighFrameRate = 5,
    VariablePhotoSequence = 6,
    VideoHdr8 = 9,
  }
  public sealed class MediaCaptureSettings {
    IDirect3DDevice Direct3D11Device { get; }
  }
  public sealed class MediaCaptureVideoProfile {
    IVectorView<MediaFrameSourceInfo> FrameSourceInfos { get; }
    IMapView<Guid, object> Properties { get; }
  }
  public sealed class MediaCaptureVideoProfileMediaDescription {
    IMapView<Guid, object> Properties { get; }
    string Subtype { get; }
  }
}
namespace Windows.Media.Capture.Frames {
  public sealed class AudioMediaFrame
  public sealed class MediaFrameFormat {
    AudioEncodingProperties AudioEncodingProperties { get; }
  }
  public sealed class MediaFrameReference : IClosable {
    AudioMediaFrame AudioMediaFrame { get; }
  }
  public sealed class MediaFrameSourceController {
    AudioDeviceController AudioDeviceController { get; }
  }
  public sealed class MediaFrameSourceInfo {
    string ProfileId { get; }
    IVectorView<MediaCaptureVideoProfileMediaDescription> VideoProfileMediaDescription { get; }
  }
  public enum MediaFrameSourceKind {
    Audio = 4,
    Image = 5,
  }
}
namespace Windows.Media.Core {
  public sealed class AudioStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    AudioStreamDescriptor Copy();
  }
  public sealed class MediaBindingEventArgs {
    void SetDownloadOperation(DownloadOperation downloadOperation);
  }
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    DownloadOperation DownloadOperation { get; }
    public static MediaSource CreateFromDownloadOperation(DownloadOperation downloadOperation);
  }
  public sealed class TimedMetadataStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2
  public sealed class VideoStreamDescriptor : IMediaStreamDescriptor, IMediaStreamDescriptor2 {
    VideoStreamDescriptor Copy();
  }
}
namespace Windows.Media.Devices {
  public sealed class VideoDeviceController : IMediaDeviceController {
    VideoTemporalDenoisingControl VideoTemporalDenoisingControl { get; }
  }
  public sealed class VideoTemporalDenoisingControl
  public enum VideoTemporalDenoisingMode
}
namespace Windows.Media.DialProtocol {
  public sealed class DialReceiverApp {
    IAsyncOperation<string> GetUniqueDeviceNameAsync();
  }
}
namespace Windows.Media.Effects {
  public sealed class VideoTransformEffectDefinition : IVideoEffectDefinition {
    VideoTransformSphericalProjection SphericalProjection { get; }
  }
  public sealed class VideoTransformSphericalProjection
}
namespace Windows.Media.MediaProperties {
  public sealed class AudioEncodingProperties : IMediaEncodingProperties {
    AudioEncodingProperties Copy();
  }
  public sealed class ContainerEncodingProperties : IMediaEncodingProperties {
    ContainerEncodingProperties Copy();
  }
  public sealed class ImageEncodingProperties : IMediaEncodingProperties {
    ImageEncodingProperties Copy();
  }
  public sealed class MediaEncodingProfile {
    IVector<TimedMetadataStreamDescriptor> GetTimedMetadataTracks();
    void SetTimedMetadataTracks(IIterable<TimedMetadataStreamDescriptor> value);
  }
  public static class MediaEncodingSubtypes {
    public static string P010 { get; }
  }
  public enum MediaPixelFormat {
    P010 = 2,
  }
  public sealed class TimedMetadataEncodingProperties : IMediaEncodingProperties
  public sealed class VideoEncodingProperties : IMediaEncodingProperties {
    VideoEncodingProperties Copy();
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackSession {
    MediaRotation PlaybackRotation { get; set; }
    MediaPlaybackSessionOutputDegradationPolicyState GetOutputDegradationPolicyState();
  }
  public sealed class MediaPlaybackSessionOutputDegradationPolicyState
  public enum MediaPlaybackSessionVideoConstrictionReason
  public sealed class MediaPlayer : IClosable {
    AudioStateMonitor AudioStateMonitor { get; }
  }
}
namespace Windows.Media.SpeechSynthesis {
  public enum SpeechAppendedSilence
  public enum SpeechPunctuationSilence
  public sealed class SpeechSynthesizerOptions {
    SpeechAppendedSilence AppendedSilence { get; set; }
    SpeechPunctuationSilence PunctuationSilence { get; set; }
  }
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadCompletedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadFailedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
  public sealed class AdaptiveMediaSourceDownloadRequestedEventArgs {
    string ResourceContentType { get; }
    IReference<TimeSpan> ResourceDuration { get; }
  }
}
namespace Windows.Networking.BackgroundTransfer {
  public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
  public sealed class UploadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
    void MakeCurrentInTransferGroup();
  }
}
namespace Windows.Networking.Connectivity {
  public sealed class CellularApnContext {
    string ProfileName { get; set; }
  }
  public sealed class ConnectionProfileFilter {
    IReference<Guid> PurposeGuid { get; set; }
  }
  public sealed class WwanConnectionProfileDetails {
    WwanNetworkIPKind IPKind { get; }
    IVectorView<Guid> PurposeGuids { get; }
  }
  public enum WwanNetworkIPKind
}
namespace Windows.Networking.NetworkOperators {
  public sealed class ESim
  public sealed class ESimAddedEventArgs
  public enum ESimAuthenticationPreference
  public sealed class ESimDownloadProfileMetadataResult
  public static class ESimManager
  public sealed class ESimOperationResult
  public enum ESimOperationStatus
  public sealed class ESimPolicy
  public sealed class ESimProfile
  public enum ESimProfileClass
  public struct ESimProfileInstallProgress
  public sealed class ESimProfileMetadata
  public enum ESimProfileMetadataState
  public sealed class ESimProfilePolicy
  public enum ESimProfileState
  public sealed class ESimRemovedEventArgs
  public sealed class ESimServiceInfo
  public enum ESimState
  public sealed class ESimUpdatedEventArgs
  public sealed class ESimWatcher
  public enum ESimWatcherStatus
  public sealed class MobileBroadbandAntennaSar {
    public MobileBroadbandAntennaSar(int antennaIndex, int sarBackoffIndex);
  }
  public sealed class MobileBroadbandModem {
    bool IsInEmergencyCallMode { get; }
    event TypedEventHandler<MobileBroadbandModem, object> IsInEmergencyCallModeChanged;
    IAsyncOperation<MobileBroadbandPco> TryGetPcoAsync();
  }
  public sealed class MobileBroadbandModemIsolation
  public sealed class MobileBroadbandPco
  public sealed class MobileBroadbandPcoDataChangeTriggerDetails
  public enum NetworkOperatorDataUsageNotificationKind
  public sealed class NetworkOperatorDataUsageTriggerDetails
  public sealed class TetheringEntitlementCheckTriggerDetails
}
namespace Windows.Networking.Sockets {
  public sealed class MessageWebSocket : IClosable, IWebSocket {
    IAsyncOperationWithProgress<uint, uint> SendFinalFrameAsync(IBuffer data);
    IAsyncOperationWithProgress<uint, uint> SendNonfinalFrameAsync(IBuffer data);
  }
  public sealed class ServerMessageWebSocket : IClosable
  public sealed class ServerMessageWebSocketControl
  public sealed class ServerMessageWebSocketInformation
  public sealed class ServerStreamWebSocket : IClosable
  public sealed class ServerStreamWebSocketInformation
}
namespace Windows.Networking.Vpn {
  public sealed class VpnChannel {
    object CurrentRequestTransportContext { get; }
    void AddAndAssociateTransport(object transport, object context);
    ControlChannelTriggerStatus GetSlotTypeForTransportContext(object context);
    void ReplaceAndAssociateTransport(object transport, object context);
    void StartReconnectingTransport(object transport, object context);
    void StartWithTrafficFilter(IIterable<HostName> assignedClientIpv4Addresses, IIterable<HostName> assignedClientIpv6Addresses, VpnInterfaceId vpninterfaceId, VpnRouteAssignment assignedRoutes, VpnDomainNameAssignment assignedNamespace, uint mtuSize, uint maxFrameSize, bool reserved, IIterable<object> transports, VpnTrafficFilterAssignment assignedTrafficFilters);
  }
  public sealed class VpnPacketBuffer {
    object TransportContext { get; set; }
  }
}
namespace Windows.Security.Authentication.Identity.Provider {
  public enum SecondaryAuthenticationFactorAuthenticationMessage {
    CanceledByUser = 22,
    CenterHand = 23,
    ConnectionRequired = 20,
    DeviceUnavailable = 28,
    MoveHandCloser = 24,
    MoveHandFarther = 25,
    PlaceHandAbove = 26,
    RecognitionFailed = 27,
    TimeLimitExceeded = 21,
  }
}
namespace Windows.Security.Authentication.Web.Core {
  public sealed class FindAllAccountsResult
  public enum FindAllWebAccountsStatus
  public static class WebAuthenticationCoreManager {
    public static IAsyncOperation<FindAllAccountsResult> FindAllAccountsAsync(WebAccountProvider provider);
    public static IAsyncOperation<FindAllAccountsResult> FindAllAccountsAsync(WebAccountProvider provider, string clientId);
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public sealed class WebProviderTokenRequest {
    string ApplicationPackageFamilyName { get; }
    string ApplicationProcessName { get; }
    IAsyncOperation<bool> CheckApplicationForCapabilityAsync(string capabilityName);
  }
}
namespace Windows.Services.Maps {
  public sealed class MapRouteDrivingOptions {
    IReference<DateTime> DepartureTime { get; set; }
  }
  public sealed class PlaceInfo {
    public static PlaceInfo CreateFromAddress(string displayAddress);
    public static PlaceInfo CreateFromAddress(string displayAddress, string displayName);
  }
}
namespace Windows.Services.Store {
  public sealed class StoreCanAcquireLicenseResult
  public enum StoreCanLicenseStatus
  public sealed class StoreContext {
    bool CanSilentlyDownloadStorePackageUpdates { get; }
    IAsyncOperation<StoreCanAcquireLicenseResult> CanAcquireStoreLicenseAsync(string productStoreId);
    IAsyncOperation<StoreCanAcquireLicenseResult> CanAcquireStoreLicenseForOptionalPackageAsync(Package optionalPackage);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> DownloadAndInstallStorePackagesAsync(IIterable<string> storeIds);
    IAsyncOperation<IVectorView<StoreQueueItem>> GetAssociatedStoreQueueItemsAsync();
    IAsyncOperation<StoreProductQueryResult> GetStoreProductsAsync(IIterable<string> productKinds, IIterable<string> storeIds, StoreProductOptions storeProductOptions);
    IAsyncOperation<IVectorView<StoreQueueItem>> GetStoreQueueItemsAsync(IIterable<string> storeIds);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> RequestDownloadAndInstallStorePackagesAsync(IIterable<string> storeIds, StorePackageInstallOptions storePackageInstallOptions);
    IAsyncOperation<StoreUninstallStorePackageResult> RequestUninstallStorePackageAsync(Package package);
    IAsyncOperation<StoreUninstallStorePackageResult> RequestUninstallStorePackageByStoreIdAsync(string storeId);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadAndInstallStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
    IAsyncOperationWithProgress<StorePackageUpdateResult, StorePackageUpdateStatus> TrySilentDownloadStorePackageUpdatesAsync(IIterable<StorePackageUpdate> storePackageUpdates);
    IAsyncOperation<StoreUninstallStorePackageResult> UninstallStorePackageAsync(Package package);
    IAsyncOperation<StoreUninstallStorePackageResult> UninstallStorePackageByStoreIdAsync(string storeId);
  }
  public sealed class StorePackageInstallOptions
  public sealed class StorePackageUpdateResult {
    IVectorView<StoreQueueItem> StoreQueueItems { get; }
  }
  public sealed class StoreProductOptions
  public sealed class StoreQueueItem
  public sealed class StoreQueueItemCompletedEventArgs
  public enum StoreQueueItemExtendedState
  public enum StoreQueueItemKind
  public enum StoreQueueItemState
  public sealed class StoreQueueItemStatus
  public sealed class StoreUninstallStorePackageResult
  public enum StoreUninstallStorePackageStatus
}
namespace Windows.Storage {
  public sealed class StorageFolder : IStorageFolder, IStorageFolder2, IStorageFolderQueryOperations, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider {
    StorageLibraryChangeTracker TryGetChangeTracker();
  }
}
namespace Windows.Storage.Provider {
  public interface IStorageProviderUriSource
  public sealed class StorageProviderGetContentInfoForPathResult
  public sealed class StorageProviderGetPathForContentUriResult
  public enum StorageProviderUriSourceStatus
}
namespace Windows.Storage.Search {
  public sealed class StorageLibraryChangeTrackerTriggerDetails
}
namespace Windows.System {
  public sealed class AppActivationResult
  public sealed class AppDiagnosticInfo {
    IAsyncOperation<AppActivationResult> LaunchAsync();
  }
  public sealed class AppExecutionStateChangeResult
  public sealed class AppResourceGroupInfo {
    IAsyncOperation<AppExecutionStateChangeResult> StartResumeAsync();
    IAsyncOperation<AppExecutionStateChangeResult> StartSuspendAsync();
    IAsyncOperation<AppExecutionStateChangeResult> StartTerminateAsync();
  }
  public enum AutoUpdateTimeZoneStatus
  public static class TimeZoneSettings {
    public static IAsyncOperation<AutoUpdateTimeZoneStatus> AutoUpdateTimeZoneAsync(TimeSpan timeout);
  }
  public sealed class User {
    public static User GetDefault();
  }
  public enum UserType {
    SystemManaged = 4,
  }
}
namespace Windows.System.Diagnostics {
  public sealed class DiagnosticInvoker {
    IAsyncOperationWithProgress<DiagnosticActionResult, DiagnosticActionState> RunDiagnosticActionFromStringAsync(string context);
  }
}
namespace Windows.System.Diagnostics.DevicePortal {
  public sealed class DevicePortalConnection {
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol);
    ServerMessageWebSocket GetServerMessageWebSocketForRequest(HttpRequestMessage request, SocketMessageType messageType, string protocol, uint outboundBufferSizeInBytes, uint maxMessageSize, MessageWebSocketReceiveMode receiveMode);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request);
    ServerStreamWebSocket GetServerStreamWebSocketForRequest(HttpRequestMessage request, string protocol, uint outboundBufferSizeInBytes, bool noDelay);
  }
  public sealed class DevicePortalConnectionRequestReceivedEventArgs {
    bool IsWebSocketUpgradeRequest { get; }
    IVectorView<string> WebSocketProtocolsRequested { get; }
    Deferral GetDeferral();
  }
}
namespace Windows.System.Inventory {
  public sealed class InstalledDesktopApp : IStringable
}
namespace Windows.System.Profile {
  public static class AnalyticsInfo {
    public static IAsyncOperation<IMapView<string, string>> GetClientPropertiesAsync(IIterable<string> attributeNames);
  }
}
namespace Windows.System.RemoteSystems {
  public sealed class RemoteSystem {
    RemoteSystemPlatform Platform { get; }
  }
  public sealed class RemoteSystemEnumerationCompletedEventArgs
  public enum RemoteSystemPlatform
  public sealed class RemoteSystemWatcher {
    event TypedEventHandler<RemoteSystemWatcher, RemoteSystemEnumerationCompletedEventArgs> EnumerationCompleted;
    event TypedEventHandler<RemoteSystemWatcher, RemoteSystemWatcherErrorOcurredEventArgs> ErrorOcurred;
  }
  public enum RemoteSystemWatcherError
  public sealed class RemoteSystemWatcherErrorOcurredEventArgs
}
namespace Windows.System.UserProfile {
  public static class GlobalizationPreferences {
    public static GlobalizationPreferencesForUser GetForUser(User user);
  }
  public sealed class GlobalizationPreferencesForUser
}
namespace Windows.UI.ApplicationSettings {
  public sealed class AccountsSettingsPane {
    public static IAsyncAction ShowAddAccountForUserAsync(User user);
    public static IAsyncAction ShowManageAccountsForUserAsync(User user);
  }
  public sealed class AccountsSettingsPaneCommandsRequestedEventArgs {
    User User { get; }
  }
}
namespace Windows.UI.Composition {
  public sealed class AnimationController : CompositionObject
  public enum AnimationControllerProgressBehavior
  public sealed class BounceScalarNaturalMotionAnimation : ScalarNaturalMotionAnimation
  public sealed class BounceVector2NaturalMotionAnimation : Vector2NaturalMotionAnimation
  public sealed class BounceVector3NaturalMotionAnimation : Vector3NaturalMotionAnimation
  public sealed class CompositionContainerShape : CompositionShape
  public sealed class CompositionEllipseGeometry : CompositionGeometry
  public class CompositionGeometry : CompositionObject
  public class CompositionLight : CompositionObject {
    bool IsEnabled { get; set; }
  }
  public sealed class CompositionLineGeometry : CompositionGeometry
  public class CompositionObject : IClosable {
    AnimationController TryGetAnimationController(string propertyName);
  }
  public sealed class CompositionPath : IGeometrySource2D
  public sealed class CompositionPathGeometry : CompositionGeometry
  public sealed class CompositionRectangleGeometry : CompositionGeometry
  public sealed class CompositionRoundedRectangleGeometry : CompositionGeometry
  public class CompositionShape : CompositionObject
  public sealed class CompositionShapeCollection : CompositionObject, IIterable<CompositionShape>, IVector<CompositionShape>
  public sealed class CompositionSpriteShape : CompositionShape
  public enum CompositionStrokeCap
  public sealed class CompositionStrokeDashArray : CompositionObject, IIterable<float>, IVector<float>
  public enum CompositionStrokeLineJoin
  public sealed class CompositionViewBox : CompositionObject
  public sealed class Compositor : IClosable {
    string Comment { get; set; }
    float GlobalPlaybackRate { get; set; }
    public static float MaxGlobalPlaybackRate { get; }
    public static float MinGlobalPlaybackRate { get; }
    BounceScalarNaturalMotionAnimation CreateBounceScalarAnimation();
    BounceVector2NaturalMotionAnimation CreateBounceVector2Animation();
    BounceVector3NaturalMotionAnimation CreateBounceVector3Animation();
    CompositionContainerShape CreateContainerShape();
    CompositionEllipseGeometry CreateEllipseGeometry();
    CompositionLineGeometry CreateLineGeometry();
    CompositionPathGeometry CreatePathGeometry();
    CompositionPathGeometry CreatePathGeometry(CompositionPath path);
    PathKeyFrameAnimation CreatePathKeyFrameAnimation();
    CompositionRectangleGeometry CreateRectangleGeometry();
    CompositionRoundedRectangleGeometry CreateRoundedRectangleGeometry();
    ShapeVisual CreateShapeVisual();
    CompositionSpriteShape CreateSpriteShape();
    CompositionSpriteShape CreateSpriteShape(CompositionGeometry geometry);
    CompositionViewBox CreateViewBox();
    IAsyncAction RequestCommitAsync();
  }
  public sealed class PathKeyFrameAnimation : KeyFrameAnimation
  public sealed class PointLight : CompositionLight {
    float MaxAttenuationCutoff { get; set; }
    float MinAttenuationCutoff { get; set; }
  }
  public sealed class ShapeVisual : ContainerVisual
  public sealed class SpotLight : CompositionLight {
    float MaxAttenuationCutoff { get; set; }
    float MinAttenuationCutoff { get; set; }
  }
}
namespace Windows.UI.Composition.Core {
  public sealed class CompositorController : IClosable
}
namespace Windows.UI.Composition.Desktop {
  public sealed class DesktopWindowTarget : CompositionTarget
}
namespace Windows.UI.Composition.Diagnostics {
  public sealed class CompositionDebugHeatMaps
  public enum CompositionDebugOverdrawContentKinds : uint
  public sealed class CompositionDebugSettings
}
namespace Windows.UI.Composition.Interactions {
  public enum VisualInteractionSourceRedirectionMode {
    CapableTouchpadAndPointerWheel = 3,
    PointerWheelOnly = 2,
  }
}
namespace Windows.UI.Core {
  public enum AppViewBackButtonVisibility {
    Disabled = 2,
  }
  public sealed class CoreComponentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
    DispatcherQueue DispatcherQueue { get; }
  }
  public sealed class CoreIndependentInputSource : ICoreInputSourceBase, ICorePointerInputSource, ICorePointerInputSource2 {
    DispatcherQueue DispatcherQueue { get; }
  }
  public interface ICorePointerInputSource2 : ICorePointerInputSource
}
namespace Windows.UI.Input.Core {
  public sealed class RadialControllerIndependentInputSource {
    DispatcherQueue DispatcherQueue { get; }
  }
}
namespace Windows.UI.Input.Inking {
  public sealed class InkDrawingAttributes {
    InkModelerAttributes ModelerAttributes { get; }
  }
  public sealed class InkInputConfiguration
  public sealed class InkModelerAttributes
  public sealed class InkPresenter {
    InkInputConfiguration InputConfiguration { get; }
  }
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialInteractionController {
    BatteryReport TryGetBatteryReport();
  }
}
namespace Windows.UI.Notifications {
  public sealed class ScheduledToastNotification {
    IReference<DateTime> ExpirationTime { get; set; }
  }
}
namespace Windows.UI.StartScreen {
  public sealed class TileMixedRealityModel {
    TileMixedRealityModelActivationBehavior ActivationBehavior { get; set; }
  }
  public enum TileMixedRealityModelActivationBehavior
}
namespace Windows.UI.Text {
  public sealed class ContentLinkInfo
  public sealed class RichEditTextRange : ITextRange
  public enum TextRangeUnit {
    ContentLink = 32,
  }
}
namespace Windows.UI.ViewManagement {
  public sealed class ApplicationViewTab
  public sealed class ApplicationViewTabBadge
  public sealed class ApplicationViewTabIcon
  public sealed class ApplicationViewTabManager
  public sealed class ApplicationViewTabManagerTabClosedEventArgs
  public sealed class ApplicationViewTabManagerTabCloseRequestedEventArgs
  public sealed class ApplicationViewTabManagerTabDraggedOutEventArgs
  public sealed class ApplicationViewTabManagerTabDroppedInEventArgs
  public sealed class ApplicationViewTabManagerTabRearrangedEventArgs
  public static class ApplicationViewTabPolicy
}
namespace Windows.UI.ViewManagement.Core {
  public sealed class CoreInputView {
    event TypedEventHandler<CoreInputView, object> XYFocusTransferredToPrimaryView;
    event TypedEventHandler<CoreInputView, CoreInputViewTransferringXYFocusEventArgs> XYFocusTransferringFromPrimaryView;
    bool TryTransferXYFocusToPrimaryView(Rect origin, CoreInputViewXYFocusTransferDirection direction);
  }
  public sealed class CoreInputViewTransferringXYFocusEventArgs
  public enum CoreInputViewXYFocusTransferDirection
}
namespace Windows.UI.WebUI {
  public sealed class WebUIBarcodeScannerPreviewActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IBarcodeScannerPreviewActivatedEventArgs
  public sealed class WebUILaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILaunchActivatedEventArgs, ILaunchActivatedEventArgs2, IPrelaunchActivatedEventArgs {
    TileActivatedInfo TileActivatedInfo { get; }
  }
}
namespace Windows.UI.Xaml {
  public sealed class BringIntoViewOptions {
    double HorizontalAlignmentRatio { get; set; }
    double HorizontalOffset { get; set; }
    double VerticalAlignmentRatio { get; set; }
    double VerticalOffset { get; set; }
  }
  public sealed class BringIntoViewRequestedEventArgs : RoutedEventArgs
  public sealed class ElementSoundPlayer {
    public static ElementSpatialAudioMode SpatialAudioMode { get; set; }
  }
  public enum ElementSpatialAudioMode
  public enum FocusVisualKind {
    Reveal = 2,
  }
  public class UIElement : DependencyObject {
    public static RoutedEvent BringIntoViewRequestedEvent { get; }
    public static RoutedEvent ContextRequestedEvent { get; }
    KeyboardAcceleratorPlacementMode KeyboardAcceleratorPlacementMode { get; set; }
    public static DependencyProperty KeyboardAcceleratorPlacementModeProperty { get; }
    DependencyObject KeyboardAcceleratorPlacementTarget { get; set; }
    public static DependencyProperty KeyboardAcceleratorPlacementTargetProperty { get; }
    DependencyObject KeyTipTarget { get; set; }
    public static DependencyProperty KeyTipTargetProperty { get; }
    event TypedEventHandler<UIElement, BringIntoViewRequestedEventArgs> BringIntoViewRequested;
    virtual void OnBringIntoViewRequested(BringIntoViewRequestedEventArgs e);
    virtual void OnKeyboardAcceleratorInvoked(KeyboardAcceleratorInvokedEventArgs args);
    public static void RegisterAsScrollPort(UIElement element);
  }
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty HeadingLevelProperty { get; }
  }
  public sealed class AutomationProperties {
    public static DependencyProperty HeadingLevelProperty { get; }
    public static AutomationHeadingLevel GetHeadingLevel(DependencyObject element);
    public static void SetHeadingLevel(DependencyObject element, AutomationHeadingLevel value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationHeadingLevel
  public class AutomationPeer : DependencyObject {
    AutomationHeadingLevel GetHeadingLevel();
    virtual AutomationHeadingLevel GetHeadingLevelCore();
  }
  public sealed class AutoSuggestBoxAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider {
    void Invoke();
  }
  public class CalendarDatePickerAutomationPeer : FrameworkElementAutomationPeer, IInvokeProvider, IValueProvider
  public class TreeViewItemAutomationPeer : ListViewItemAutomationPeer, IExpandCollapseProvider
  public class TreeViewListAutomationPeer : SelectorAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
  public class AppBarButton : Button, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    AppBarButtonTemplateSettings TemplateSettings { get; }
  }
  public class AppBarToggleButton : ToggleButton, ICommandBarElement, ICommandBarElement2 {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    AppBarToggleButtonTemplateSettings TemplateSettings { get; }
  }
  public sealed class ContentLinkChangedEventArgs
  public enum ContentLinkChangeKind
  public sealed class HandwritingPanelClosedEventArgs
  public sealed class HandwritingPanelOpenedEventArgs
  public enum HandwritingPanelPlacementAlignment
  public class HandwritingView : Control
  public class MediaTransportControls : Control {
    bool IsCompactOverlayButtonVisible { get; set; }
    public static DependencyProperty IsCompactOverlayButtonVisibleProperty { get; }
    bool IsCompactOverlayEnabled { get; set; }
    public static DependencyProperty IsCompactOverlayEnabledProperty { get; }
  }
  public class MenuFlyoutItem : MenuFlyoutItemBase {
    string KeyboardAcceleratorTextOverride { get; set; }
    public static DependencyProperty KeyboardAcceleratorTextOverrideProperty { get; }
    MenuFlyoutItemTemplateSettings TemplateSettings { get; }
  }
  public class NavigationView : ContentControl {
    string PaneTitle { get; set; }
    public static DependencyProperty PaneTitleProperty { get; }
    event TypedEventHandler<NavigationView, object> PaneClosed;
    event TypedEventHandler<NavigationView, NavigationViewPaneClosingEventArgs> PaneClosing;
    event TypedEventHandler<NavigationView, object> PaneOpened;
    event TypedEventHandler<NavigationView, object> PaneOpening;
  }
  public sealed class NavigationViewPaneClosingEventArgs
  public class RefreshContainer : ContentControl
  public sealed class RefreshInteractionRatioChangedEventArgs
  public enum RefreshPullDirection
  public sealed class RefreshRequestedEventArgs
  public sealed class RefreshStateChangedEventArgs
  public class RefreshVisualizer : Control
  public enum RefreshVisualizerOrientation
  public enum RefreshVisualizerState
  public class RichEditBox : Control {
    SolidColorBrush ContentLinkBackgroundColor { get; set; }
    public static DependencyProperty ContentLinkBackgroundColorProperty { get; }
    SolidColorBrush ContentLinkForegroundColor { get; set; }
    public static DependencyProperty ContentLinkForegroundColorProperty { get; }
    ContentLinkProviderCollection ContentLinkProviders { get; set; }
    public static DependencyProperty ContentLinkProvidersProperty { get; }
    HandwritingView HandwritingView { get; set; }
    public static DependencyProperty HandwritingViewProperty { get; }
    bool IsHandwritingViewEnabled { get; set; }
    public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
    event TypedEventHandler<RichEditBox, ContentLinkChangedEventArgs> ContentLinkChanged;
    event TypedEventHandler<RichEditBox, ContentLinkInvokedEventArgs> ContentLinkInvoked;
  }
  public class TextBox : Control {
    HandwritingView HandwritingView { get; set; }
    public static DependencyProperty HandwritingViewProperty { get; }
    bool IsHandwritingViewEnabled { get; set; }
    public static DependencyProperty IsHandwritingViewEnabledProperty { get; }
  }
  public class TreeView : Control
  public sealed class TreeViewCollapsedEventArgs
  public sealed class TreeViewExpandingEventArgs
  public class TreeViewItem : ListViewItem
  public sealed class TreeViewItemInvokedEventArgs
  public class TreeViewItemTemplateSettings : DependencyObject
  public class TreeViewList : ListView
  public class TreeViewNode : DependencyObject
  public enum TreeViewSelectionMode
  public sealed class WebView : FrameworkElement {
    event TypedEventHandler<WebView, WebViewSeparateProcessLostEventArgs> SeparateProcessLost;
  }
  public enum WebViewExecutionMode {
    SeparateProcess = 2,
  }
  public enum WebViewPermissionType {
    Screen = 5,
    WebVR = 6,
  }
  public sealed class WebViewSeparateProcessLostEventArgs
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapControl : Control {
    string Region { get; set; }
    public static DependencyProperty RegionProperty { get; }
  }
  public class MapElement : DependencyObject {
    bool IsEnabled { get; set; }
    public static DependencyProperty IsEnabledProperty { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public sealed class AppBarButtonTemplateSettings : DependencyObject
  public sealed class AppBarToggleButtonTemplateSettings : DependencyObject
  public class ListViewItemPresenter : ContentPresenter {
    bool DisableTilt { get; set; }
    public static DependencyProperty DisableTiltProperty { get; }
  }
  public sealed class MenuFlyoutItemTemplateSettings : DependencyObject
}
namespace Windows.UI.Xaml.Documents {
  public sealed class ContactContentLinkProvider : ContentLinkProvider
  public sealed class ContentLink : Inline
  public sealed class ContentLinkInvokedEventArgs
  public class ContentLinkProvider : DependencyObject
  public sealed class ContentLinkProviderCollection : IIterable<ContentLinkProvider>, IVector<ContentLinkProvider>
  public sealed class PlaceContentLinkProvider : ContentLinkProvider
}
namespace Windows.UI.Xaml.Input {
  public sealed class FocusManager {
    public static IAsyncOperation<FocusMovementResult> TryFocusAsync(DependencyObject element, FocusState value);
    public static IAsyncOperation<FocusMovementResult> TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection);
    public static IAsyncOperation<FocusMovementResult> TryMoveFocusAsync(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
  }
  public sealed class FocusMovementResult
  public sealed class GettingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
  public sealed class KeyboardAcceleratorInvokedEventArgs {
    KeyboardAccelerator KeyboardAccelerator { get; }
  }
  public enum KeyboardAcceleratorPlacementMode
  public sealed class LosingFocusEventArgs : RoutedEventArgs {
    bool TryCancel();
    bool TrySetNewFocusedElement(DependencyObject element);
  }
}
namespace Windows.UI.Xaml.Media {
  public sealed class CompositionTarget {
    public static event EventHandler<RenderedEventArgs> Rendered;
  }
  public sealed class RenderedEventArgs
}
namespace Windows.Web.UI {
  public interface IWebViewControl
  public sealed class WebViewControlContentLoadingEventArgs
  public sealed class WebViewControlDeferredPermissionRequest
  public sealed class WebViewControlDOMContentLoadedEventArgs
  public sealed class WebViewControlLongRunningScriptDetectedEventArgs
  public sealed class WebViewControlNavigationCompletedEventArgs
  public sealed class WebViewControlNavigationStartingEventArgs
  public sealed class WebViewControlNewWindowRequestedEventArgs
  public sealed class WebViewControlPermissionRequest
  public sealed class WebViewControlPermissionRequestedEventArgs
  public enum WebViewControlPermissionState
  public enum WebViewControlPermissionType
  public sealed class WebViewControlScriptNotifyEventArgs
  public sealed class WebViewControlSettings
  public sealed class WebViewControlUnsupportedUriSchemeIdentifiedEventArgs
  public sealed class WebViewControlUnviewableContentIdentifiedEventArgs
  public sealed class WebViewControlWebResourceRequestedEventArgs
}
namespace Windows.Web.UI.Interop {
  public sealed class WebViewControl : IWebViewControl
  public sealed class WebViewControlAcceleratorKeyPressedEventArgs
  public enum WebViewControlAcceleratorKeyRoutingStage
  public enum WebViewControlMoveFocusReason
  public sealed class WebViewControlMoveFocusRequestedEventArgs
  public sealed class WebViewControlProcess
  public enum WebViewControlProcessCapabilityState
  public sealed class WebViewControlProcessOptions
}

The post Windows 10 SDK Preview Build 17061 now available appeared first on Building Apps for Windows.

Azure customers manage budgets at a workload level and need granular controls on monitoring the spend on cloud services. Workloads sometimes share a subscription and yet need to be budgeted for individually. As a first step in making these granular controls available we are previewing an ARM API to set and manage a budget at the subscription scope. Current EA customers have a similar capability in the EA portal, at the department level. This release is the first step towards making the same set of capabilities work for you across the hierarchy of your management plane.

The budgets API enables you to setup a budget for a subscription, and also setup multiple notification thresholds. To illustrate, you might have a subscription where you setup a budget of $1,000 and setup notifications at 25%, 50%, 75%, and 100%. These notifications would be triggered when your usage costs exceed $250, $500, $750, and $1,000 respectively.

Subscription budget API

The API documentation provides detailed guidance on the operations supported and the payloads. The API supports multiple budgets to be created for a subscription over the duration of the budget. At the end of the duration the budget resets and starts over. For this release we are supporting monthly, quarterly, and annual budgets. If you have other requirements that are not met by these options, let us know via the comments. Currently you can have up to 5 notifications per budget and are not limited on the number of budgets you can create.

Calling the API

The budgets API is documented in the Azure rest docs and supports the following REST operations:

Operations supported

1. List all budgets for a subscription
2. Get a budget
3. Create or update a Budget
4. Delete a budget

Constraints

In the preview release you will need to have contributor privileges to operate on budgets. Also in this release, budgets will only account for native Azure services and will not include Marketplace charges.

Looking forward

Budgets at the subscription is only the first step in a number of releases planned to improve the cost management experience. In addition to a portal experience we are also working on creating more granular budget and management experience that includes resource groups tags services and a host of other options. Stay tuned and please share your feedback on cost related challenges or ideas.

Additional resources

• To learn more, please visit the Azure Rest API specs Swagger.
• For more information, please visit Azure consumption documentation page.

VS 2017 15.5 is now available for production use, and 15.6 Preview 1 is also available. As usual, here are feature tables for the STL and compiler, plus a detailed list of STL improvements. (You can also read our previous changelog for VS 2017 15.3.) Please note that due to our branch structure and merge timing, features and fixes described below as being in VS 2017 15.6 have been checked in and will be available by the time that it’s ready for production use, but 15.6 Preview 1 contains only a subset of those features and fixes.

STL Feature Status:

• “…”: For clarity, the Library Fundamentals V1 paper has been decomposed into its individual features, marked by “…” here. The <memory_resource> header will be available in VS 2017 15.6, completing this paper.
  
• missing vs. patch: To give you a better idea of our status, unimplemented papers are marked “missing” for primary features, or “patch” for papers that merely fixed parts of a primary feature. We implement them together, so the large number of “patch” rows doesn’t really indicate a large amount of missing work.
  
• N/A: For clarity, this table has omitted a number of papers that are Not Applicable (nothing for implementers to do, or users to take advantage of), such as wording clarifications.
  
• [14]: These C++17 features are implemented unconditionally, even in /std:c++14 mode (the default). For some features, this was because they predated the introduction of MSVC’s Standard mode options. For other features, conditional implementation would be nearly pointless or undesirably complicated.
  
• [atomic]: This was almost completely implemented in VS 2017 15.3, and the remaining differences are difficult to observe (some signatures differ from the Standard, as observed by taking their address or providing explicit template arguments). The STL’s next major binary-incompatible version will fix the remaining differences.
  
• [byte]: std::byte is enabled by /std:c++17, but has a fine-grained opt-out macro (_HAS_STD_BYTE can be defined to be 0). This is because given certain patterns of using-directives, it can conflict with the Windows SDK’s headers. This has been reported to the SDK team and will be fixed, but in the meantime the escape hatch is available.
  
• [C11]: First available in VS 2015, the Universal CRT implemented the parts of the C11 Standard Library that are required by C++17, with minor exceptions. Those exceptions (which are tracked by bugs) are: missing C99 strftime() E/O alternative conversion specifiers, missing C11 fopen() exclusive mode, and missing C11 aligned_alloc(). The strftime() and fopen() functionality will be implemented in the future. aligned_alloc() will probably never be implemented, as C11 specified it in a way that’s incompatible with our implementation (namely, that free() must be able to handle highly aligned allocations).
  
• [char_traits]: This will be partially available in VS 2017 15.6. The library changes have been implemented and tested, but they’re currently enabled for only the Clang and EDG compiler front-ends (which have implemented the compiler builtins that power this feature). When C1XX (MSVC’s compiler front-end) implements these builtins, we’ll mark this feature as complete.
  
• [decay]: This paper is technically N/A, as it doesn’t require implementers to take action, and it doesn’t result in an observable feature for users. However, it improves compiler throughput, so we’ve gone ahead and implemented it unconditionally (as an exception to “C++17 before C++20”). This will ship in a VS 2017 update after 15.6 (denoted by “15.x” here).
  
• [depr] and [rem]: See C++17 Feature Removals And Deprecations.
  
• [DR]: These papers were voted into the Working Paper after C++17, but as Defect Reports, meaning that they retroactively apply to C++17 (as bugfixes).
  
• [guides]: This will be partially available in VS 2017 15.6. The library changes have been implemented and tested, but they’re currently enabled for Clang only. (Testing MSVC’s STL with Clang found two compiler bugs, LLVM#34970 and LLVM#35045. We implemented a workaround for the former, which has been fixed for Clang 6. The latter appears to be extremely obscure and unlikely to be encountered by ordinary code.) When C1XX and EDG implement class template argument deduction, we’ll mark this feature as complete.
  
• [obj_rep]: This type trait (powered by a compiler builtin) is currently enabled for C1XX only. The builtin was recently implemented in Clang, so when Clang 6 is released, we plan to enable the type trait for it. The type trait is also not yet enabled for EDG (which implemented the builtin earlier, but was affected by a compiler bug until recently).
  
• [parallel]: We’re gradually implementing experimental support for the parallel algorithms.
  

Here are the parallel algorithms that we’ve implemented:

• 15.5, intentionally not parallelized: copy, copy_n, fill, fill_n, move, reverse, reverse_copy, rotate, rotate_copy, swap_ranges. (The signatures for these parallel algorithms are added but not parallelized at this time; profiling showed no benefit in parallelizing algorithms that only move or permute elements.)
  
• 15.5: all_of, any_of, for_each, for_each_n, none_of, reduce, replace, replace_if, sort.
  
• 15.6 Preview 1: adjacent_find, count, count_if, equal, find, find_end, find_first_of, find_if, find_if_not.
  
• 15.6 after Preview 1: mismatch, remove, remove_if, search, search_n, transform.
  
• 15.x: partition, stable_sort.
  

Compiler Feature Status:

• [throw()]: In /std:c++14 mode, dynamic exception specifications remain unimplemented, and throw() is still treated as a synonym for __declspec(nothrow). In C++17, dynamic exception specifications were mostly removed by P0003R5, leaving one vestige: throw() is deprecated and required to behave as a synonym for noexcept. In /std:c++17 mode, MSVC now conforms to the Standard by giving throw() the same behavior as noexcept, i.e. enforcement via termination. The compiler option /Zc:noexceptTypes- requests our old behavior of __declspec(nothrow). It’s likely that throw() will be removed in C++20. To help with migrating code in response to these changes in the Standard and our implementation, new compiler warnings for exception specification issues have been added under /std:c++17 and /permissive- as documented here.
  
• [twoPhase]: Two-phase name lookup is partially implemented in VS 2017 15.5 and 15.6, with an increasing number of scenarios working. Please read our Sept 2017 post for more details. The compiler front-end team is monitoring progress via approximately 85 test cases taken from in-house and external test suites and real codebases, with approximately 68% of them passing as of Dec 2017.
  
• [exprSFINAE]: Expression SFINAE has been partially implemented in VS 2017 RTM through 15.6. While many scenarios work (and it has been sufficient for the STL’s purposes for 2 years), some parts are still missing and some workarounds are still required, like the “unique tag type” workaround. As the Parse Tree Rejuvenation effort progresses forward, we’ll be able to support dependent name binding inside decltype expressions, which will help us complete Expression SFINAE. This completion will require the /permissive- mode as it will depend on two-phase name lookup.
  
• [preprocessor]: Support for C99’s preprocessor rules is unchanged (considered partial due to support for variadic macros, although there are numerous bugs). We’re overhauling the preprocessor, and we’ll experimentally ship those changes under the /permissive- mode soon.
  
• [ifConstexpr]: “if constexpr” is supported in /std:c++14 with a warning that can be suppressed, delighting template metaprogramming library authors everywhere.
  
• [launder]: std::launder(), which is 99.9% compiler magic, is currently listed in the compiler feature table, although we may move it to the library feature table in the future.
  

STL Fixes:

The following fixes are available in VS 2017 15.5, unless otherwise specified as appearing in VS 2017 15.6.

Significant Changes:

• The STL is now tested with Clang/LLVM 5.0.0 (in our internal test suites and libc++’s test suite) and no longer supports Clang/C2 3.8.
  
• The STL now identifies itself with two macros, defined by including any STL header (e.g. <ciso646>). _MSVC_STL_VERSION is defined as 141 and will remain that way for the VS 2017 v141 toolset series. _MSVC_STL_UPDATE is defined as 201709 in VS 2017 15.5, and will be increased as features are added in future updates. (The year-month typically won’t correspond to an update’s release date. Our process for updating this macro is “we’re checking in std::meow() and it’s now October, so we need to change the value”, and depending on branch/merge timing, it might take a month or more to ship.) The value for VS 2017 15.6 is not yet set in stone, but it will be 201711 or greater.
  

New Warnings And Errors:

• Including <execution> now emits “warning STL4019: Parallel algorithms support is experimental in this release of Visual C++. Object files and static libraries that include <execution> may need to be rebuilt to link with a future update of Visual C++, and programs using <execution> may not run on Windows XP. This warning will be removed when parallel algorithms support is completed in a future update. You can define _SILENCE_PARALLEL_ALGORITHMS_EXPERIMENTAL_WARNING to acknowledge that you have received this warning.”
  
• (15.6) Added a compiler/STL version mismatch check (with an escape hatch, _ALLOW_COMPILER_AND_STL_VERSION_MISMATCH). Our STL is tested with the corresponding version of C1XX, and they’re treated as a unit by the IDE. (That is, selecting an older toolset will use an older C1XX and a correspondingly older STL.) Our STL is also tested with the latest released version of Clang/LLVM. Mixing an older STL with a newer compiler is untested and unsupported, but will typically work. (For example, using Clang 6 with VS 2017 15.5.) However, because the STL’s implementation is constantly evolving to consume freshly-implemented compiler features and bugfixes, mixing a newer STL with an older compiler is a recipe for doom. By adding a version mismatch check, we can emit a comprehensible error message when imminent doom is detected. Currently, we check C1XX’s version with “#if _MSC_VER < 1912” and emit “#error STL1001: Unexpected compiler version, expected MSVC 19.12.” We also check Clang’s version with “#if __clang_major__ < 5” and emit “#error STL1000: Unexpected compiler version, expected Clang 5.” (We currently don’t check EDG’s version, or that of any other front-ends.) In the future, we will regularly increase the versions being checked here. (For subtle reasons, the lower bound for C1XX’s version being checked here may not always correspond to the version number that it’s actually shipping with. For example, VS 2017 RTM (15.0) was compiler version 19.10, VS 2017 15.3 was 19.11, VS 2017 15.5 was 19.12, and VS 2017 15.6 will be 19.13. While 15.6’s STL is shipping with and being tested with the 19.13 compiler, its version mismatch check will accept 19.12. This is because a checked-in copy of the toolset is used to build the shipping toolset, and at the time that 15.6 branched for release, the checked-in toolset was still identifying itself as 19.12. We might clarify the error message in the future by adding “or newer”.)
  
• (15.6) The [[nodiscard]] attribute has been applied to nearly 2,500 functions in the STL. In /std:c++17 mode, this will emit a compiler warning when the return value of a function is being discarded instead of stored or inspected. (The warning can be portably and locally suppressed by casting to void.) We’ve carefully chosen which functions to mark with [[nodiscard]], so that the warnings will be valuable instead of noisy. Our criteria for emitting the warning are: discarding the return value is a guaranteed leak (e.g. std::allocator::allocate(), but not unique_ptr::release() – this was a judgement call), discarding the return value is near-guaranteed to be incorrect (e.g. remove()/remove_if()/unique()), or the function is essentially a pure observer (e.g. vector::empty() and std::is_sorted()). If you encounter these [[nodiscard]] warnings, we believe it’s highly likely that your code contains a bug, so please think about it instead of reflexively suppressing the warning because it previously compiled cleanly. For example, confusion between vector’s empty() (an observer returning bool) and clear() (an action returning void) is common among beginning programmers, and will be detected by this warning. Even in our own compiler’s codebase, we encountered a case where an array was being given to is_sorted() and then the returned bool was discarded; the intention was to assert that the array was sorted.
  

Correctness Fixes:

• random_device::entropy() is now marked as const.
  
• map/multimap::value_compare’s constructor is now protected, following the Standard.
  
• Increased conformance by avoiding a non-Standard compiler extension (in-class explicit specializations) within the iostreams implementation.
  
• The STL now adapts to whether the compiler provides C++17’s behavior for noexcept (e.g. is_function detects noexcept-qualified function types). The STL also avoids throw().
  
• is_partitioned() was incorrectly calling the predicate N + 1 times, instead of N times as required by the Standard.
  
• atomic<T> no longer requires T to be default constructible.
  
• basic_string::npos is now available as a compile time constant.
  
• std::allocator now properly handles allocation of over-aligned types (whose alignment is greater than max_align_t) in C++17 mode (unless disabled by /Zc:alignedNew-). For example, vectors of objects with 16 or 32-byte alignment will now be properly aligned for SSE/AVX instructions.
  
• shared_ptr’s constructors now handle nullptrs with custom deleters, and unique_ptrs with fancy pointers and custom deleters.
  
• Fixed a bug in scoped_allocator_adaptor::select_on_container_copy_construction() with 3+ allocators.
  
• We constrained std::function’s converting constructor/assignment to avoid competing with copy/move construction/assignment. This avoids bizarre compiler errors in certain situations.
  
• (15.6) Fixed a regression that was introduced in VS 2017 15.5, where compiling with /clr and including STL headers within #pragma managed(push, off) (contrary to the documentation’s guidance) started emitting compiler errors. We now tolerate this scenario again, while still avoiding the extremely fragile non-Standard extension __if_exists.
  
• (15.6) ratio_less now avoids integer overflow with extreme inputs.
  
• (15.6) sort() now uses difference_type instead of size_t. Other algorithms now respect difference_types that aren’t ptrdiff_t.
  
• (15.6) Fixed a regression that was introduced in VS 2017 15.5, where including <numeric> with /fp:except emitted a compiler error.
  
• (15.6) The STL now supports over-aligned temporary buffers, and therefore supports algorithms on ranges of over-aligned types.
  

Performance/Throughput Fixes:

• Improved the performance of forward_list::empty() in debug mode.
  
• Heap algorithms that take logarithmic time no longer do a linear time assertion that the input is in fact a heap in debug mode.
  
• basic_string<char16_t> now engages memcmp()/memcpy()/etc. optimizations that basic_string<wchar_t> engages. Note that constexpr char_traits in VS 2017 15.6 partially reverts this work due to compiler limitations; see LLVM#35165 for more info.
  
• An optimizer limitation (which prevented function pointers from being inlined) that was exposed by our “avoid copying function objects” work in VS 2015.3 has been worked around, restoring the performance of lower_bound(iter, iter, function pointer).
  
• The overhead of iterator debugging’s order verification of inputs to includes(), set_difference(), set_symmetric_difference(), and set_union() was reduced by unwrapping iterators before checking order.
  
• inplace_merge() now skips over elements that are already in position.
  
• Constructing random_device no longer constructs and then destroys a std::string.
  
• equal() and partition() received a jump-threading optimization pass which saves an iterator comparison.
  
• When reverse() is given pointers to trivially copyable T, it will now dispatch to a handwritten vectorized implementation. This can increase performance by up to 8x (times, not percent).
  
• fill(), equal(), and lexicographical_compare() were taught how to dispatch to memset()/memcmp() for std::byte and gsl::byte (and other char-ish enums and enum classes). Note that copy() dispatches using is_trivially_copyable and thus didn’t need any changes.
  
• The STL no longer contains empty-braces destructors whose only behavior was to make types non-trivially-destructible.
  
• Slightly improved codegen size for dual-range, non-random-access equal().
  
• (15.6) Significantly improved compiler throughput when including <ppltasks.h>, which is included by our implementation of <future>.
  
• (15.6) Significantly improved the performance of find_end().
  
• (15.6) Improved the performance of dual-range mismatch() for random-access iterators.
  
• (15.6) Improved the performance of search() by calling memcmp() when possible.
  
• (15.6) Improved the performance of string/string_view’s find_first_of() family by using bitmaps.
  

Readability And Other Improvements:

• The STL now uses variable templates internally.
  
• __declspec(allocator) is now guarded for C1XX only, to prevent warnings from Clang which doesn’t understand this declspec.
  
• The STL now tolerates /Zc:threadSafeInit- which disables magic statics. (We attempted to tolerate this compiler option in VS 2017 15.3, but the attempt was incomplete.)
  
• We dramatically improved the experience of debugging into a std::function call. See our Nov 2017 post for more info. Note that this triggers LLVM#31944 (a Clang bug with PCHes) which has been fixed in Clang 6.
  
• The STL works with “Just My Code” in the debugger again.
  
• In release mode, marked forward_list’s default/move constructors as noexcept.
  
• (15.6) Strengthened noexcept on the constructors and assignment operators of containers and container adaptors to reflect their implementations.
  

C++20:

We’re working on finishing C++17 before starting C++20. For completeness, here are the rest of the papers that have been voted into the C++20 Working Paper. (While we’ve added many [[nodiscard]] attributes to our codebase, P0600R1 is not yet complete.)

Reporting Bugs:

Please let us know what you think about VS 2017 15.5 and 15.6. You can report bugs via the IDE’s Report A Problem and also via the web: go to the VS Developer Community and click on the C++ tab. For compiler and library bugs, it’s important to provide self-contained test cases.

Happy holidays from your C++ Standard Library implementers (and the rest of the Visual C++ team!):

• Billy Robert O’Neal III @MalwareMinigun
  bion@microsoft.com
  
• Casey Carter @CoderCasey
  cacarter@microsoft.com
  
• Stephan T. Lavavej @StephanTLavavej
  stl@microsoft.com
• Steve Wishnousky stwish@microsoft.com

The main international R user conference, useR!, is typically hosted in Europe every other year. Back in 2016 when useR! was held in the USA, an alternative conference was held in Poland. Next year (when the useR! conference will be in Australia) the tradition continues, and the 2018 eRum (European R Users Meeting) will be held in Budapest, Hungary on May 14-16.

Around 400-500 attendees are expected, and the program committee is sure to put together an excellent collection of workshops and talks. If you'd like to contribute, workshop proposals are due on January 14, and abstracts for talks and posters are due on February 25. You can submit your proposals here.

Conference registration will open in early January, but you can follow @erum2018 on Twitter to be notified or simply check at the URL below for ticket information.

eRum 2018: About the Conference

Learn what's new with Chrome debugging in Visual Studio Code

Read the full article

We keep enriching the breadth of connectivity in Azure Data Factory to enable customers to ingest data from various data sources into Azure when building modern data warehouse solutions or data-driven SaaS applications. Today, we are excited to announce that Azure Data Factory newly enabled copying data from the following data stores using Copy Activity in V2. You can always find the full supported connector list from supported data stores, and click into each connector topic there to learn more details.

• Amazon Marketplace Web Service (Beta)
• Azure Database for PostgreSQL
• Concur (Beta)
• Couchbase (Beta)
• Drill (Beta)
• Google BigQuery (Beta)
• Greenplum (Beta)
• HBase
• Hive
• HubSpot (Beta)
• Impala (Beta)
• Jira (Beta)
• Magento (Beta)
• MariaDB
• Marketo (Beta)
• Oracle Eloqua (Beta)
• Paypal (Beta)
• Phoenix
• Presto (Beta)
• QuickBooks (Beta)
• SAP Cloud for Customer (C4C)
• ServiceNow (Beta)
• Shopify (Beta)
• Spark
• Square (Beta)
• Xero (Beta)
• Zoho (Beta)

If you are using PowerShell or .NET/Python SDK to author, make sure you upgrade to the December version to use these new features. And for hybrid copy scenario, note these connectors are supported since Self-hosted Integration Runtime version 3.2.

You are invited to give them a try and provide us feedback. We hope you find them helpful in your scenario. Please post your question on Azure Data Factory forum or share your thoughts with us on Data Factory feedback site.

Fast SQL query processing at scale is often a key consideration for our customers. In this blog post we compare HDInsight Interactive Query, Spark, and Presto using the industry standard TPCDS benchmarks. These benchmarks are run using out of the box default HDInsight configurations, with no special optimizations. For customers wanting to run these benchmarks, please follow the easy to use steps outlined on GitHub.

Summary of the results

• HDInsight Interactive Query is faster than Spark.
• HDInsight Spark is faster than Presto.
• Text caching in Interactive Query, without converting data to ORC or Parquet, is equivalent to warm Spark performance.
• Interactive query is most suitable to run on large scale data as this was the only engine which could run all TPCDS 99 queries without any modifications at 100TB scale.
• Interactive Query preforms well with high concurrency.

About TPCDS

The TPC Benchmark DS (TPC-DS) is a decision support benchmark that models several generally applicable aspects of a decision support system, including queries and data maintenance. According to TPCDS, the benchmark provides a representative evaluation of performance as a general purpose decision support system. A benchmark result measures query response time in single user mode, query throughput in multi-user mode and data maintenance performance for a given hardware, operating system, and data processing system configuration under a controlled, complex, and multi-user decision support workload. The purpose of TPC benchmarks is to provide relevant, objective performance data to industry users. TPC-DS Version 2 enables emerging technologies, such as big data systems, to execute the benchmark. Please note that these are unaudited results.

HDInsight Interactive Query

HDInsight Interactive Query enables you to get super fast query results from your big data without ZERO ETL (Extract Transform & Load).

Interactive Query in HDInsight leverages (Hive on LLAP) intelligent caching, optimizations in core engines, as well as Azure optimizations to produce blazing-fast query results on remote cloud storage, such as Azure Blob and Azure Data Lake Store.

Comparative performance of Spark, Presto, and LLAP on HDInsight

We conducted these test using LLAP, Spark, and Presto against TPCDS data running in a higher scale Azure Blob storage account. These storage accounts now provide an increase upwards of 10x to Blob storage account scalability. Over last few months we have also contributed to improve the performance of Windows Azure Storage Driver (WASB,) which as a result has helped improve the performance for all HDInsight workloads. 

We picked a common external Hive metastore, Azure SQL DB S2, so that various engines could go against the same data and metadata. To learn more, please review the steps to generate data and to run TPCDS queries.

HDInsight configuration

For these tests, we used a similar cluster to run LLAP, Spark, and Presto. 

Note: Tests were performed using the default out-of-the-box configurations resulting in no optimizations, no special settings, and no query change for any engine. 

The table below uses 45 queries that ran on all engines successfully. As shown, LLAP was able to run many more queries than Presto or Spark.

As you can see with above run, LLAP with ORC is faster than all other engines. What’s an even more interesting observation is that LLAP with Text is also very fast. Even faster then Spark with Parquet file format.   

Fast analytics on Hadoop have always come with one big catch, they require up-front conversion to a columnar format like ORC or parquet, which can be time consuming and expensive with on-demand computing. LLAP Dynamic Text Cache converts CSV or JSON data into LLAP’s optimized in-memory format on-the-fly. Caching is dynamic so the queries your users run determine what data is cached.

HDInsight Interactive Query(LLAP) architecture

LLAP also utilized cluster memory DRAM and SSD to provide better performance. Cache pool is a joint pool made up of cluster DRAM and SSD. To give you an example, with D14V2 VM’s in Azure you an get 112 GB of RAM and 800 GB of local SSD, so just a couple of nodes are good enough to keep over a terabyte of data in memory for fast query performance.

Text caching in Interactive Query

Text caching in Interactive Query is a very interesting concept which has caused us to think about big data pipelines very differently. Traditionally, after ingesting data in raw form we needed to convert the data to an optimized file format such as ORC, Parquet, or Avro, as these file formats ensured users would receive good performance while querying the big data. With text caching, raw text and json performance is very similar to ORC which eliminates the need for having additional steps in our big data pipeline, resulting in cost saving as well as faster and fresher query results.   

Running Interactive Query on 100TB TPCDS data

As we see many benchmarks all over the web by different vendors, one thing we notice was that they focus on only a select set of queries where their respective engine will produce the best results. We decided to run all 99 queries at 100 TB scale, and only Interactive Query was able to run these unmodified. 41% of queries were returned under 30 seconds, and 71% of queries came back under 2 minutes. This benchmarks proves that Interactive query is fast, has rich SQL, and scales at much larger scale levels without any special efforts.  

Concurrency

With the introduction of much improved fine-grain resource management and preemption, Interactive Query (Hive on LLAP) makes it easier for concurrent users. With Interactive Query, the only limit to concurrency is cluster resources. Cluster can be scaled to achieve higher and higher levels of concurrency.

We used number of different concurrency levels to test the concurrency performance. For the dataset, we again used 99 TPCDS queries on 1 TB data with 32 worker node cluster with max concurrency set to 32.

Test 1: Run all 99 queries, 1 at a time - Concurrency = 1

Test 2: Run all 99 queries, 2 at a time - Concurrency = 2

Test 3: Run all 99 queries, 4 at a time - Concurrency = 4

Test 4: Run all 99 queries, 8 at a time - Concurrency = 8

Test 5: Run all 99 queries, 16 at a time - Concurrency = 16

Test 6: Run all 99 queries, 32 at a time - Concurrency = 32

Test 7: Run all 99 queries, 64 at a time - Concurrency = 64

Results: As outlined in the above results, Interactive Query is a super optimized engine for running concurrent queries. The longest time to finish the workload was with single concurrent query.   

Comparison with Hive and performance improvements over time

Its important that we compare Interactive Query (LLAP) performance with Hive. There has been a ton of work done to make Hive more performant in the community, as well as some of the work we have been doing to improve Windows Azure storage driver performance. Back in January 2017, it took 200 minutes to run the TPCDS workload with Hive 1.2, and with the storage driver improvements Hive can now run the benchmark in 137 minutes. With LLAP cached data, the benchmark completes in 49 minutes. These are impressive gains.

Integration with Power BI direct Query, Apache Zeppelin, and other tools

Power BI now allows you to connect directly to your HDInsight Interactive Query cluster to explore and monitor data without requiring a data model as an intermediate cache. This offers interactive exploration of your data and automatically refreshes the visuals without requiring a scheduled refresh. To learn more about how to get started, please watch the video HDInsight Interactive Query with Power BI.

HDInsight Interactive Query supports many end points. You can also use Apache Zeppelin , Visual Studio, Visual Studio Code, Hive View, and Beeline to run your queries

Summary

Azure HDInsight is a fully-managed, full spectrum, open-source analytics cloud service by Microsoft that makes it easy, fast, and cost-effective to process massive amounts of data. You can use the most popular open-source engines such as Hadoop, Spark, Hive, LLAP, Kafka, Storm, HBase, and R, and install more open source frameworks from the ecosystem. With Azure HDInsight, our mission is to provide a fully managed, full spectrum of open source technologies combined with the power of the cloud. Customers today are using these open source technologies to build a variety of different applications such as batch processing, ETL, data warehousing, machine learning, IoT, and more. The goal of this blog post is to share some of the intelligence on SQL query performance of various Open Source engines in the Azure HDInsight environment.

Do you have questions or comments? Please reach out to AskHDInsight@microsoft.com for more information.

This blog post is authored  by Dotan Patrich, Senior Software Engineer, Azure Security Center and by Yossi Weizman, Security Software Engineer Intern, Azure Security Center.

Earlier this year, Rob Mead wrote a great article on the techniques used at scale by Azure Security Center to detect threats. In this post, we’ll go into the details on one such example, enabling Azure Security Center to detect usage of backdoor user account creation.

Backdoor user accounts are those accounts that are created by an adversary as part of the attack, to be used later in order to gain access to other resources in the network, open new entry points into the network as well as achieve persistency. MITRE lists the create account tactic as part of the credentials access intent of stage and lists several toolkits that uses this technique.

While it might seem at first glance that detecting such malicious account creation actions is easy, it is not often the case as creation of new accounts are mostly part of a legitimate administrative operation. Therefore, security products usually won’t alert on it as most organizations will have hard time coping with the volume of alerts to be triaged. This makes the account creation tactic a powerful adversary tactic.

Earlier this month, Azure Security Center released a new analytic to detect suspicious account creation operations that might be used as backdoor accounts. This analytic includes several criteria to distinguish between benign administrative account creation and suspicious activities that need to be alerted on. Some of those are derived from indicators that are seen at scale across many tenants.

As with all security analytics that are released as part of Azure Security Center, it is being monitored and investigated to see its noise ratio, performance and correctness. Monitoring the user creation analytic revealed an interesting case, showing that account creation can also be a symptom of a system vulnerability when not done right by benign tools. That vulnerability would not be flagged by other kinds of security alert since there was not malicious action being taken on the hosts, however it is essential for users to know that they have a potential high-risk vulnerability in their environment.

A deeper look at such alerts recently raised by Azure Security Center, showed cases where a user account was created by a command line that included the user name and password in plain text. What made it even more interesting, is that a deeper look at those incidents showed that the user creation operations were not performed by an adversary, but by a technical support software coming from a well-known vendor.

Further investigation of that software revealed that not only does it use an identical user name across different installations, but it also uses an identical password.

A malicious adversary could potentially probe different machines and try to login into them using those credentials. In cases where the hosts are configured to allow remote management connections, using PowerShell, WMI or remote desktop, etc., that would enable entry point into the network. In cases where the malicious adversary already has a foothold on the network, he could use those credentials to move laterally across the network to any machine that have the support tool installed, thus exposing all information on those machines including any other account that were logged on to those machines. Given that this account was created by a support tool, it is most likely that an administrator would install it, thus these hosts would probably have cached credentials of high privileges account which might be exploited.

Moreover, when we installed the software on a machine which is a Domain Controller, the created account was set as a domain user. That means that is such scenarios, the installation of the software causes to a security vulnerability for the whole domain.

A key take-away from this is to make sure to review and assess any account creation operation within the network, including local accounts. In addition, evaluating the configuration changes that each tool installation makes is essential to assess and mitigate any risk associated with it.

Azure Security Center makes it easier to automate the process of evaluating account creation actions and detects anomalous configurations with its Anomalous User Creation alert. So, if you see such an alert in your Azure subscription be sure to look into it:

This blog post was co-authored by Kiran Madnani, Principal PM Manager, AIM India.

Alerts are an important mechanism for customers to get notified about issues early and to take automated actions to resolve them quickly. With Azure Monitoring Services, you can set up alerts to monitor the metrics and log data for the entire stack across your infrastructure, application, and platform. Given how integral it is to the monitoring experience, we are excited to announce the preview of a new re-imagined user interface to create and manage alerts for any resource from a single location in the Azure Monitor blade in the Azure portal.

You can access the new Alerts (preview) experience by visiting the Azure portal. You will see:

1. A single consolidated view with an aggregated summary of fired alerts triggered by metrics and logs at a glance.

2. A single consolidated view for viewing and managing the underlying alert rules across metrics and logs across multiple subscriptions.

3. A single simplified authoring experience for creating an alert across resources.

In addition to the new alerting experience, we are also pleased to announce the preview of alerting on log search in Azure. Log search is a powerful capability that allows you to view and analyze log files. We are adding the capability to allow you to set up log query-based alert rules in Azure Monitor.

You can start using the new Alerts in preview today. To learn more, visit our documentation and don’t forget you can provide us feedback by reaching out to azurealertsfeedback@microsoft.com.

In 2017, the Dev Center Team has been hard at work bringing new features and programs to the Windows developer community. Our goal is to deliver features that will help you, as a developer, attract new customers, engage with your current Windows 10 customers and monetize your apps and games on Windows.  Today, we want to share all the new and exciting things we’ve brought to the community within the past year. Below are just some of the improvements we’ve made:

The Dev Center experience:

• Experience a modern and efficient Dev Center dashboard

• Use the Import/Export feature to quickly create and update Store listings
• Schedule the precise date and time that your app will be available in Store
• Flexible sale pricing and configuration to help promote your app

Monetization opportunities:

• Xbox Live Creator’s Program – now any developer can integrate Xbox Live into their game and publish to Xbox One and Windows 10

• Offer In-app purchases subscriptions with automated recurring billing (Dev Center Insider Program feature)
• Desktop Bridge – bring existing apps and games to the Microsoft Store and UWP
  • See how Evernote used the Desktop Bridge to bring their app to Microsoft Store

Customer engagement:

• Create more engaging Store listings with video trailers that could drive more acquisitions

• Offer personalized content to specific segments of your customer using targeted offers
• Use search terms to help optimize how your app shows up in customer searches

App & game analytics:

• View near real time health analytics for your apps
  • Filter health data with new filters; OS release version, architecture, Sandbox and PRAID

• Download CAB files for app failures in the Health report that occur on a Windows Insider release
• See how many customers viewed you Store page, acquired, installed and used your apps by viewing the Acquisition funnel
• View your app reviews grouped according to categories with Review insight categories to see where you should focus improvement efforts

• See how your customers are engaging with Xbox features in your game with Xbox analytics
  • Understand the impact of any Xbox Live client errors through the Xbox Live service health tab
• View acquisition reports for your Office add-ins on Dev Center
• Health and Install reports for Windows desktop applications (available through the Windows Desktop Application Program)

Microsoft Ads Platform:

• Join the Windows Premium Ads Publishers Program which curates a list of best in class apps and games in terms of usage, engagement and experience

• Utilize the Microsoft Ad Monetization Platform that provides ad mediation service ensuring that ads from different networks are delivered to developers from a single SDK
• You can now use interstitial and native ads through the Microsoft Advertising SDK
• We’ve added new ad networks (Taboola, Outbrain, Revcontent, SpotX and Smartclip) to our platform to help increase fill rates and revenue

We would like to thank all the Windows developers, publishers and partners for continuing to invest in the Windows 10 ecosystem. We look forward to continuing our work to help make you successful in 2018!

The post Dev Center’s Year in Review: 2017 appeared first on Building Apps for Windows.

In case you missed them, we’ve posted the Azure Cosmos Database and Azure SQL Database webinars for on-demand viewing. The first webinar takes a closer look at Azure Cosmos DB, a globally distributed, multi-model database service that enables scaled throughput and storage across many geographical regions.  The second webinar shares how you can make the most of Azure SQL Database's machine learning features to deliver intelligent apps to your customers.

Azure Cosmos DB – Easily build globally distributed, highly scalable applications

Building successful apps depends on having well-indexed and formatted data—regardless of how or where data is stored. With Azure Cosmos DB, you can build globally distributed applications without the hassle of complex, multi-datacenter configurations.

Tune in to this webinar and learn how you can leverage Azure Cosmos DB to:

• Create lightning-fast globally distributed apps
• Model your app's data using familiar tools and APIs
• Easily distribute data across multiple regions
• Fine-tune performance based on your application's needs.

Register to watch this webinar on demand.

Build intelligent apps faster with Azure SQL Database

Applications benefit when machine learning intelligence is applied to its underlying databases to optimize performance. Intelligent apps can spot trends, react to unusual events, and make useful predictions or recommendations.

The Azure SQL Database webinar walks you through the services, code, and data your development team needs to make intelligent applications happen. In this session, you’ll see how Azure SQL Database continuously evaluates data to provide performance-improving recommendations tailored to your workload. You’ll learn how to implement instrumentation and telemetry and add intelligence in your app, such as user recommendations and performance insights.

Register for this on-demand webinar.

At Microsoft Ignite, we announced new adaptive applications controls that protect your applications from malware by using whitelisting rules. Today, we are excited to share that these capabilities are available for public preview in Azure Security Center. 

Application controls, such as whitelisting, can help limit exposure to malicious and vulnerable applications. Instead of trying to keep pace with rapidly evolving malware and new exploits, application control simply blocks all but known good applications. For purpose-built servers that typically run a fixed set of application, whitelisting can add significant protection. Application control solutions have existed for some time now, but organizations usually find it too complex and hard to manage, especially when unique rules are required per server or group of servers, and in large scale.

Adaptive Application Controls leverages machine learning to analyze the behavior of your Azure virtual machines, create a baseline of applications, group the virtual machines, and recommend and automatically apply the appropriate whitelisting rules. You can view, modify, and receive alerts for these rules in Azure Security Center.

Adaptive application controls are currently available for Windows virtual machines running in Azure (all versions, classic or Azure Resource Manager). To get started, open Security Center and select the application whitelisting tile.

Enable Adaptive Application Controls and apply policies

In the Adaptive Application Controls blade, you can easily enable Adaptive Application Controls for groups of virtual machines that you select. You can view a recommendation and create the policy that will determine which applications will be allowed to run, initially in audit mode, and receive alerts when applications violate the rules. Creating and applying your own policies reduces management complexity while increasing the protection of your applications.

Monitoring and editing an Adaptive Application Controls policy

In the Adaptive Application Controls blade, you can easily manage and monitor existing groups of virtual machines that are configured with an adaptive application controls policy. You can view and modify the whitelisting rules that are applied on the VMs within a specific group and be alerted on violations of those rules. In addition, you can change the mode in which a specific adaptive application controls policy is applied and start blocking unapproved applications using the enforce mode. Visibility into the security posture of your applications helps you stay in control.

These new capabilities are available within the standard pricing tier of Azure Security Center, and you can try it for free for the first 60 days.

See our documentation to learn more about Adaptive Application Controls.

Why IaaS on Azure Resource Manager

It has been more than 2 years since we launched IaaS on Azure Resource Manager. Since then, we’ve been busy adding awesome features to this new stack in addition to all the features of the classic stack. Below are some of the features and benefits you get by deploying your infrastructure on Azure Resource Manager:

Compute

• Managed Disks – Simplify your storage management by exposing disks as a top level resource. In addition, Managed Disks are designed to improve the availability of your virtual machines. Learn more about the other benefits of using Managed Disks.
• Virtual machine scale sets – Provide a great blend of IaaS like control with PaaS like manageability. Scale sets allow you to reliably deploy and update a large set of virtual machines at large scale.
• Availability zones – Have peace of mind knowing that your mission critical applications can withstand datacenter-level failures.
• Instance metadata service – Provides a RESTful endpoint that allows virtual machines instances to get information regarding its compute, network, and upcoming maintenance events from within the virtual machine.
• Reserved instances – Allows reservation of virtual machines in advance, and significantly reduce costs compared to pay-as-you-go prices.
• VM sizes for more cost-effective database workloads – Enables constraining the VM vCPU count to reduce the cost of software licensing, all while maintaining the same memory, storage, and I/O bandwidth.

Networking

• Accelerated Networking – Allows your virtual machines to get a maximum of 30 Gbps transfer rate while providing ultra-low latency and high packet per second rates for VM to VM traffic.
• Load Balancer standard – The next generation of our existing SDN Load Balancer that allows you to design your high-performance virtual data center and support any TCP or UDP application. Use standalone VM instances, or up to 1,000 instances of virtual machine scale sets in a back-end pool. Continue to use low forwarding latency, high throughput performance, and scale to millions of flows on a fully managed Azure service.
• Virtual network peering – Enables you to seamlessly connect two Azure virtual networks. Once peered, the virtual networks appear as one for connectivity purposes. The traffic between virtual machines in the peered virtual networks is routed through the Microsoft backbone infrastructure, much like traffic is routed between virtual machines in the same virtual network, through private IP addresses only.
• Virtual network service endpoints - Extend your virtual network private address space and the identity of your VNet to the Azure services, over a direct connection. Endpoints allow you to secure your critical Azure service resources to only your virtual networks. Traffic from your VNet to the Azure service always remains on the Microsoft Azure backbone network.
• Tags – Allow you to organize your resources by category. Each tag consists of a name and a value. For example, you can apply the name "Environment" and the value "Production" to all the resources in production.

Infrastructure management

• Management groups – Allows you to organize your subscriptions to help you manage access, policy, costs, and compliance across your subscriptions.
• Managed Applications – Enables you to offer cloud solutions that are easy for consumers to deploy and operate. You implement the infrastructure and provide ongoing support.
• Role based access control – Enables fine-grained access management for Azure. Using RBAC, you can grant only the amount of access that users need to perform their jobs.
• Resource locks – Give administrators the tools to lock a subscription, resource group, or resource to prevent other users in the organization from accidentally deleting or modifying critical resources.
• Resource policies – Enables you to establish conventions for resources in your organization. By defining conventions, you can control costs and more easily manage your resources. For example, you can specify that only certain types of virtual machines are allowed, or you can require that all resources have a particular tag.
• Infrastructure as Code – Azure Resource Manager templates allow you to express and easily deploy your infrastructure.

How to get to IaaS on Azure Resource Manager

To make it easy for our customers to adopt all these exciting features, we have released a no-downtime migration service. Since this release we’ve seen many customers migrate their productions environments ranging from a few VMs to hundreds of VMs. We are continually making improvements to this service and adding additional features based on the customer feedback.

For a great video overview of the migration process, please check out Corey Sanders in the below Microsoft Mechanics episode, Azure Classic to Azure Resource Manager migration.

New features from the last year

• Migrate a virtual network with Express Route gateway.
• Migrate a virtual network with Express Route and VPN gateway.
• Enhanced Validate operation now catches various migration blockers early. Validate operation now warns about insufficient compute and networking quotas which block migration.
• Validate operation now shows information about all the resources that will be migrated.
• Key Vaults created as part of the migration have the soft-delete feature turned on. This allows you to recover the Key Vault in case of accidental deletion.

Documentation

If you’d like to get started on migrating your VMs, please review the documentation set below

• Overview of platform-supported migration of IaaS resources from classic to Azure Resource Manager
• Technical deep dive on platform-supported migration from classic to Azure Resource Manager
• Planning for migration of IaaS resources from classic to Azure Resource Manager
• Use PowerShell to migrate IaaS resources from classic to Azure Resource Manager
• Use CLI to migrate IaaS resources from classic to Azure Resource Manager
• VPN Gateway classic to Resource Manager migration
• Migrate ExpressRoute circuits and associated virtual networks from the classic to the Resource Manager deployment model
• Community tools for assisting with migration of IaaS resources from classic to Azure Resource Manager
• Common errors during Classic to Azure Resource Manager migration
• Frequently asked questions about classic to Azure Resource Manager migration

Azure Backup stands firm on the promise of simplicity, security, and reliability by giving customers a smooth and dependable experience across scenarios. Continuing on the enterprise data-protection promise, today, we are excited to announce the support for backup and restore of Azure virtual machines encrypted using Bitlocker Encryption Key(BEK) for managed or unmanaged disks. This announcement augments the existing capability to backup VMs encrypted using Bitlocker Encryption Key(BEK) and Key Encryption Key(KEK). This support is available using Portal and PowerShell.

Key benefits

With this release, Azure Backup provides:

• Backup of VMs encrypted using BEK-only as well as BEK and KEK both: Azure Backup now supports backup of VMs encrypted using BEK along with the already supported scenario of BEK and KEK both. The BEK(secrets) and KEK(keys) backed up are encrypted so they can be read and used only when restored back to key vault by the authorized users.
• Backup of both managed and unmanaged disks in encrypted VMs: Application-consistent backup for both managed and unmanaged disks is supported now which gives user the freedom to create any kind of encrypted VM and then back it up using Azure Backup.

Value proposition

This feature provides:

• Simplified experience: With this release, the backup process seamlessly acquires access to the key vault without requiring user intervention leading to a smooth and simplified experience.
• Enhanced security: Since the BEK is also backed up, in scenarios where BEK is lost, authorized users can restore the BEK to the KeyVault and recover the encrypted VM. Since the keys and secrets of encrypted VMs are backed up in encrypted form, neither unauthorized users nor Azure can read or use these backed up keys and secrets. Only users with the right level of permissions can backup and restore encrypted VMs, as well as keys and secrets.

Related links and additional content

• Learn more about how to backup and restore encrypted Azure VMs.
• Getting started with Recovery Services vault.
• Learn more about Azure Backup.
• Want more details? Check out the Azure Backup documentation.
• Need help? Reach out to the Azure Backup forum for support.
• Tell us how we can improve Azure Backup by contributing new ideas and voting up existing ones.
• Follow us on Twitter @AzureBackup for latest news and updates.

It's that time of year when many people take pride in the resolutions they met, lament the ones they failed to keep, and make new ones to start afresh. Recently, I spoke with a friend and former colleague who is a software developer at a technology company in Virginia. As we shared our plans for 2018, he told me about an unmet resolution he had for 2017, which was to learn Azure. He recalled that this resolution originated back in 2013. As is the case with most abandoned resolutions, he had plenty of reasons at the ready to defend himself. He even joked that he’d keep the tradition alive by resolving to learn Azure in 2018.

I suggested that part of his problem was with the resolution itself (the other being procrastination). For me, the notion of learning Azure triggers the snowclone that it “is a journey, not a destination.” Instead of trying to learn Azure like it was something fixed and finite, I said he should make his resolution to just learn something new about Azure each day. If he implemented that one change, he could be successful with this year’s neglected resolution starting today.

Here are the tips I shared with him to help him keep his resolution to learn Azure:

1. Get the free eBook - Read The Developer’s Guide to Microsoft Azure, Second Edition. This eBook is only about 50 pages long, but it provides a quick technical overview of what Azure is for developers (and it was written by developers). When you're ready to try the three walkthroughs in Chapter 6, which will give you some hands-on time with Azure, you'll need to go to the next step below.
   
   

2. Create a free account - When you're ready to start getting hands-on, create a free account. This year, the free account got even better. The process requires a credit card for identity verification. Although there are many free services that you can use in Azure, the 30-day Azure Free Trial gives you $200 to spend during that period. When you sign up for the trial, the spending limit is turned on by default. The spending limit is $0. Although the limit can’t be changed (you either have one or you don’t), you can set up billing alerts to monitor spending and pin the Spending rate and forecast chart for your subscription to the Dashboard.

3. Pick a project to use - Azure is something that requires more than content consumption to become proficient. Eventually, you have to start building something. You’ll progress faster along your journey and enjoy better scenery if you have a project that you can take to the cloud. Perhaps you have a hobby app that you built to learn some other technology, or a personal website.

   If you’re at a total loss, explore the Azure Code Samples or find an app on GitHub to fork, such as ToDoListAzure or try the Explore Cosmos DB sample to see what's so fantastic about Azure Cosmos DB.

4. Get into the cockpit - Depending on your preference for GUI or command line, use the Azure portal or Cloud Shell to work with Azure.

   • The Azure portal is a web-based UI for doing just about anything you can possibly do with an Azure resource.

     Watch the Azure Friday episode about the Azure Portal

   • Azure Cloud Shell is another installation-free option with the power and flexibility of using either Bash (now generally available) or PowerShell (in Preview) to rule your world from the command line.

     Watch the Microsoft Mechanics Live episode about Azure Cloud Shell

Bonus tip - Thousands of engineers + DevOps means that Azure moves pretty fast. Here are some resources to help you keep up with Azure as it changes:

• Docs - The Azure documentation is the most comprehensive and current resource you’ll find. Many of the tutorials in the docs include the ability to launch Cloud Shell alongside the tutorial steps. This new site replaces the old MSDN Library and provides a vastly improved experience.

• Videos - Azure Friday is a video series I help produce. Originally a weekly series, we now publish 3 new episodes per week to keep up with how fast Azure is growing. Some other short-format video series to follow are: the Azure playlist of Microsoft Mechanics, Tuesdays with Corey, Cloud Tech 10, and Azure this Month.

• Blogs and email newsletters - Last week in Azure is a series I started for the Azure blog. It provides a weekly round-up of Azure news. There’s also some good community blogs, such as Azure Weekly and Build Azure. Subscribe to the Azure Newsletter to get Azure news delivered to your inbox each month.

• Audio - There’s also The Azure Podcast, which average about 30 minutes apiece.

Happy New Year!

The data.table package provides a high-performance interface for querying and manipulating data tables (a close cousin of data frames). In the video below (recorded at the H2OWorld conference), creator Matt Dowle gives a tour of the package and provides several examples of its use.

If you'd like to see the details on the example Matt presents at the beginning of the talk, you can find the post how the City of Chicago uses data.table for food safety, here.