Today, we released a new Windows 10 SDK Preview and the associated Windows 10 Mobile emulators (Build 10563), to be used in conjunction with Windows 10 Insider Preview (Build 10565). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 10563 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview. The Preview SDK can be downloaded from the Windows 10 Developer Tools page.

We do recommend any uninstalling any preview SDK and emulators if you have it installed. This will prevent UI clutter in Visual Studio when choosing what emulator to target.

Start developing and @WindowsDev would love to see what you create. If you find bugs or issues, please leverage the Windows Feedback tool or MSDN forums.

What is new in SDK 10563

Emulator:

• Updated the OS image included with the Windows 10 Mobile Emulator

SDK:

• Corrected the signing of the Microsoft General MIDI DLS for Universal Windows Apps Extension SDK
• Corrected the “No .natvis files found” error when you run Debugging Tools For Windows (WinDbg)” issue with WinDbg. See https://support.microsoft.com/en-us/kb/3091112 for more details.
• Corrected the Windows Performance Analyzer crashes when ResidentSet graph is used
• Corrected problem that prevented trace capture on pre-Windows 8 OS releases using xperf.exe and wpr.exe.
• Corrected Windows Performance Analyzer crash when trying to modify the symbols inclusion/exclusion list in the Load Settings tab of the Configure Symbols dialog.
• Improved Intellisense documentation for a large number of APIs.

Updated tests in the Windows App Certification Kit:

• The “App prelaunch” test was enabled. This test proactively prelaunches and keeps apps in the background, verifying that the app handles the prelaunch scenario correctly.
• The “App resources” test now runs correctly against UWA apps. This could result in failures not previously seen but for which the apps were always expected to pass.
• The “Supported APIs” test no longer fails the app if the app invokes approved APIs by ordinals.

Changes in the Universal Windows Platform – Added

namespace Windows.ApplicationModel.Calls {
  public sealed class CallAnswerEventArgs
  public sealed class CallRejectEventArgs
  public sealed class CallStateChangeEventArgs
  public struct CallsVoipContract
  public sealed class MuteChangeEventArgs
  public sealed class VoipCallCoordinator
  public sealed class VoipPhoneCall
  public enum VoipPhoneCallMedia : uint
  public enum VoipPhoneCallRejectReason
  public enum VoipPhoneCallResourceReservationStatus
  public enum VoipPhoneCallState
}

namespace Windows.Devices.Printers {
  public sealed class Print3DDevice
  public struct PrintersContract
  public sealed class PrintSchema
}

namespace Windows.Foundation.Metadata {
  public sealed class PreviousContractVersionAttribute : Attribute {
    public PreviousContractVersionAttribute(string contract, uint versionLow, uint versionHigh);
    public PreviousContractVersionAttribute(string contract, uint versionLow, uint versionHigh, string newContract);
  }
}

namespace Windows.ApplicationModel.Activation {
  public enum ActivationKind {
    DevicePairing = 1013,
    Print3DWorkflow = 1011,
  }
  public sealed class DevicePairingActivatedEventArgs : IActivatedEventArgs, IDevicePairingActivatedEventArgs
  public interface IDevicePairingActivatedEventArgs : IActivatedEventArgs
}
namespace Windows.ApplicationModel.Background {
  public sealed class SensorDataThresholdTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Chat {
  public sealed class ChatConversation {
    bool CanModifyParticipants { get; set; }
  }
}
namespace Windows.ApplicationModel.Contacts {
  public sealed class ContactCardOptions {
    IVector ServerSearchContactListIds { get; }
  }
}
namespace Windows.ApplicationModel.DataTransfer {
  public sealed class DataPackageView {
    void SetAcceptedFormatId(string formatId);
  }
  public sealed class OperationCompletedEventArgs {
    string AcceptedFormatId { get; }
  }
}
namespace Windows.ApplicationModel.Email {
  public enum EmailCertificateValidationStatus
  public sealed class EmailMailbox {
    IAsyncOperation> ResolveRecipientsAsync(IIterable recipients);
    IAsyncOperation TryCreateFolderAsync(string parentFolderId, string name);
    IAsyncOperation TryDeleteFolderAsync(string folderId);
    IAsyncOperation TryEmptyFolderAsync(string folderId);
    IAsyncOperation> ValidateCertificatesAsync(IIterable certificates);
  }
  public sealed class EmailMailboxCapabilities {
    bool CanCreateFolder { get; }
    bool CanDeleteFolder { get; }
    bool CanEmptyFolder { get; }
    bool CanMoveFolder { get; }
    bool CanResolveRecipients { get; }
    bool CanValidateCertificates { get; }
  }
  public sealed class EmailMailboxCreateFolderResult
  public enum EmailMailboxCreateFolderStatus
  public enum EmailMailboxDeleteFolderStatus
  public enum EmailMailboxEmptyFolderStatus
  public sealed class EmailMailboxPolicies {
    bool MustEncryptSmimeMessages { get; }
    bool MustSignSmimeMessages { get; }
  }
  public sealed class EmailMeetingInfo {
    bool IsReportedOutOfDateByServer { get; }
  }
  public sealed class EmailMessage {
    IRandomAccessStreamReference SmimeData { get; set; }
    EmailMessageSmimeKind SmimeKind { get; set; }
  }
  public enum EmailMessageSmimeKind
  public sealed class EmailRecipientResolutionResult
  public enum EmailRecipientResolutionStatus
}
namespace Windows.ApplicationModel.Store {
  public static class CurrentApp {
    public static IAsyncOperation GetCustomerCollectionsIdAsync(string serviceTicket, string publisherUserId);
    public static IAsyncOperation GetCustomerPurchaseIdAsync(string serviceTicket, string publisherUserId);
  }
  public sealed class ListingInformation {
    string CurrencyCode { get; }
    string FormattedBasePrice { get; }
    bool IsOnSale { get; }
    DateTime SaleEndDate { get; }
  }
  public sealed class ProductListing {
    string CurrencyCode { get; }
    string FormattedBasePrice { get; }
    bool IsOnSale { get; }
    DateTime SaleEndDate { get; }
  }
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
  public sealed class AppInstallItem {
    void Cancel(string correlationVector);
    void Pause(string correlationVector);
    void Restart(string correlationVector);
  }
  public sealed class AppInstallManager {
    void Cancel(string productId, string correlationVector);
    IAsyncOperation GetIsAppAllowedToInstallAsync(string productId, string skuId, string catalogId, string correlationVector);
    void Pause(string productId, string correlationVector);
    void Restart(string productId, string correlationVector);
    IAsyncOperation> SearchForAllUpdatesAsync(string correlationVector);
    IAsyncOperation SearchForUpdatesAsync(string productId, string skuId, string catalogId, string correlationVector);
    IAsyncOperation StartAppInstallAsync(string productId, string skuId, bool repair, bool forceUseOfNonRemovableStorage, string catalogId, string bundleId, string correlationVector);
    IAsyncOperation UpdateAppByPackageFamilyNameAsync(string packageFamilyName, string correlationVector);
  }
}
namespace Windows.ApplicationModel.UserDataAccounts {
  public sealed class UserDataAccount {
    string EnterpriseDataIdentity { get; }
    bool IsDataEncryptedUnderLock { get; }
  }
}
namespace Windows.Data.Json {
  public static class JsonError {
    public static JsonErrorStatus GetStatus(int hresult);
  }
}
namespace Windows.Devices.Bluetooth {
  public enum BluetoothAddressType
  public sealed class BluetoothDevice : IClosable {
    DeviceInformation DeviceInformation { get; }
    public static string GetDeviceSelectorFromBluetoothAddress(ulong bluetoothAddress);
    public static string GetDeviceSelectorFromClassOfDevice(BluetoothClassOfDevice classOfDevice);
    public static string GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus connectionStatus);
    public static string GetDeviceSelectorFromDeviceName(string deviceName);
    public static string GetDeviceSelectorFromPairingState(bool pairingState);
  }
  public enum BluetoothError {
    DisabledByUser = 7,
  }
  public sealed class BluetoothLEAppearance
  public static class BluetoothLEAppearanceCategories
  public static class BluetoothLEAppearanceSubcategories
  public sealed class BluetoothLEDevice : IClosable {
    BluetoothLEAppearance Appearance { get; }
    BluetoothAddressType BluetoothAddressType { get; }
    DeviceInformation DeviceInformation { get; }
    public static IAsyncOperation FromBluetoothAddressAsync(ulong bluetoothAddress, BluetoothAddressType bluetoothAddressType);
    public static string GetDeviceSelectorFromAppearance(BluetoothLEAppearance appearance);
    public static string GetDeviceSelectorFromBluetoothAddress(ulong bluetoothAddress);
    public static string GetDeviceSelectorFromBluetoothAddress(ulong bluetoothAddress, BluetoothAddressType bluetoothAddressType);
    public static string GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus connectionStatus);
    public static string GetDeviceSelectorFromDeviceName(string deviceName);
    public static string GetDeviceSelectorFromPairingState(bool pairingState);
  }
}
namespace Windows.Devices.Bluetooth.Rfcomm {
  public sealed class RfcommServiceProvider {
    void StartAdvertising(StreamSocketListener listener, bool radioDiscoverable);
  }
}
namespace Windows.Devices.Enumeration {
  public sealed class DeviceInformationCustomPairing
  public sealed class DeviceInformationPairing {
    DeviceInformationCustomPairing Custom { get; }
    DevicePairingProtectionLevel ProtectionLevel { get; }
    IAsyncOperation PairAsync(DevicePairingProtectionLevel minProtectionLevel, IDevicePairingSettings devicePairingSettings);
    public static bool TryRegisterForAllInboundPairingRequests(DevicePairingKinds pairingKindsSupported);
    IAsyncOperation UnpairAsync();
  }
  public enum DevicePairingKinds : uint
  public sealed class DevicePairingRequestedEventArgs
  public enum DevicePairingResultStatus {
    Failed = 19,
    OperationAlreadyInProgress = 15,
    PairingCanceled = 14,
    RejectedByHandler = 17,
    RemoteDeviceHasAssociation = 18,
    RequiredHandlerNotRegistered = 16,
  }
  public sealed class DeviceUnpairingResult
  public enum DeviceUnpairingResultStatus
  public interface IDevicePairingSettings
}
namespace Windows.Devices.Perception {
  public static class KnownPerceptionFrameSourceProperties {
    public static string DeviceId { get; }
  }
  public sealed class PerceptionColorFrameSource {
    string DeviceId { get; }
  }
  public sealed class PerceptionDepthFrameSource {
    string DeviceId { get; }
  }
  public sealed class PerceptionInfraredFrameSource {
    string DeviceId { get; }
  }
}
namespace Windows.Devices.Printers.Extensions {
  public sealed class Print3DWorkflow
  public enum Print3DWorkflowDetail
  public sealed class Print3DWorkflowPrintRequestedEventArgs
  public enum Print3DWorkflowStatus
}
namespace Windows.Devices.Sensors {
  public interface ISensorDataThreshold
  public sealed class Pedometer {
    IMapView GetCurrentReadings();
    public static IVectorView GetReadingsFromTriggerDetails(SensorDataThresholdTriggerDetails triggerDetails);
  }
  public sealed class PedometerDataThreshold : ISensorDataThreshold
  public sealed class ProximitySensorDataThreshold : ISensorDataThreshold
  public sealed class SensorDataThresholdTriggerDetails
  public enum SensorType
}
namespace Windows.Devices.WiFiDirect {
  public sealed class WiFiDirectAdvertisement {
    IVector SupportedConfigurationMethods { get; }
  }
  public enum WiFiDirectConfigurationMethod
  public sealed class WiFiDirectConnectionParameters : IDevicePairingSettings {
    IVector PreferenceOrderedConfigurationMethods { get; }
    WiFiDirectPairingProcedure PreferredPairingProcedure { get; set; }
    public static DevicePairingKinds GetDevicePairingKinds(WiFiDirectConfigurationMethod configurationMethod);
  }
  public enum WiFiDirectPairingProcedure
}
namespace Windows.Gaming.UI {
  public static class GameBar
}
namespace Windows.Graphics.Display {
  public sealed class DisplayInformation {
    IReference DiagonalSizeInInches { get; }
  }
}
namespace Windows.Graphics.Holographic {
  public struct HolographicAdapterId
  public sealed class HolographicCamera
  public sealed class HolographicCameraPose
  public sealed class HolographicCameraRenderingParameters
  public sealed class HolographicFrame
  public sealed class HolographicFramePrediction
  public enum HolographicFramePresentResult
  public enum HolographicFramePresentWaitBehavior
  public sealed class HolographicSpace
  public sealed class HolographicSpaceCameraAddedEventArgs
  public sealed class HolographicSpaceCameraRemovedEventArgs
  public struct HolographicStereoTransform
}
namespace Windows.Management.Orchestration {
  public sealed class CurrentAppOrchestration
  public sealed class SingleAppModeContext : IClosable
}
namespace Windows.Media.Capture {
  public sealed class AppCapture
}
namespace Windows.Media.Core {
  public sealed class MediaBinder
  public sealed class MediaBindingEventArgs
  public sealed class MediaSource : IClosable, IMediaPlaybackSource {
    MediaSourceState State { get; }
    event TypedEventHandler StateChanged;
    public static MediaSource CreateFromMediaBinder(MediaBinder binder);
    void Reset();
  }
  public enum MediaSourceState
  public sealed class MediaSourceStateChangedEventArgs
}
namespace Windows.Media.DialProtocol {
  public sealed class DialDevice {
    string FriendlyName { get; }
    IRandomAccessStreamReference Thumbnail { get; }
  }
}
namespace Windows.Media.Playback {
  public sealed class MediaPlaybackItem : IMediaPlaybackSource {
    public static MediaPlaybackItem FindFromMediaSource(MediaSource source);
  }
  public sealed class MediaPlaybackList : IMediaPlaybackSource {
    IReference MaxPrefetchTime { get; set; }
    IVectorView ShuffledItems { get; }
    MediaPlaybackItem StartingItem { get; set; }
    void SetShuffledItems(IIterable value);
  }
  public sealed class MediaPlayer {
    void AddAudioEffect(string activatableClassId, bool effectOptional, IPropertySet configuration);
    void RemoveAllEffects();
  }
}
namespace Windows.Media.Protection {
  public sealed class ProtectionCapabilities
  public enum ProtectionCapabilityResult
}
namespace Windows.Media.Streaming.Adaptive {
  public sealed class AdaptiveMediaSource : IMediaSource {
    AdaptiveMediaSourceAdvancedSettings AdvancedSettings { get; }
  }
  public sealed class AdaptiveMediaSourceAdvancedSettings
}
namespace Windows.Perception {
  public sealed class PerceptionTimestamp
  public static class PerceptionTimestampHelper
}
namespace Windows.Perception.People {
  public sealed class HeadPose
}
namespace Windows.Perception.Spatial {
  public sealed class SpatialAnchor
  public static class SpatialAnchorManager
  public sealed class SpatialAnchorRawCoordinateSystemAdjustedEventArgs
  public sealed class SpatialAnchorStore
  public struct SpatialBoundingBox
  public struct SpatialBoundingFrustum
  public struct SpatialBoundingOrientedBox
  public struct SpatialBoundingSphere
  public sealed class SpatialBoundingVolume
  public sealed class SpatialCoordinateSystem
  public enum SpatialLocatability
  public sealed class SpatialLocation
  public sealed class SpatialLocator
  public sealed class SpatialLocatorAttachedFrameOfReference
  public sealed class SpatialLocatorPositionalTrackingDeactivatingEventArgs
  public sealed class SpatialStationaryFrameOfReference
}
namespace Windows.Perception.Spatial.Surfaces {
  public sealed class SpatialSurface
  public sealed class SpatialSurfaceMesh
  public sealed class SpatialSurfaceMeshBuffer
  public sealed class SpatialSurfaceMeshIntersection
  public sealed class SpatialSurfaceMeshOptions
  public sealed class SpatialSurfaceObserver
}
namespace Windows.Security.Authentication.Web.Core {
  public sealed class WebTokenRequest {
    IMap AppProperties { get; }
  }
}
namespace Windows.Security.Authentication.Web.Provider {
  public static class WebAccountManager {
    public static IAsyncAction PullCookiesAsync(string uriString, string callerPFN);
  }
}
namespace Windows.Security.Credentials {
  public sealed class KeyCredential {
    IBuffer RetrievePublicKey(CryptographicPublicKeyBlobType blobType);
  }
}
namespace Windows.Services.Maps {
  public static class MapService {
    public static string DataAttributions { get; }
  }
}
namespace Windows.Storage {
  public static class DownloadsFolder {
    public static IAsyncOperation CreateFileForUserAsync(User user, string desiredName);
    public static IAsyncOperation CreateFileForUserAsync(User user, string desiredName, CreationCollisionOption option);
    public static IAsyncOperation CreateFolderForUserAsync(User user, string desiredName);
    public static IAsyncOperation CreateFolderForUserAsync(User user, string desiredName, CreationCollisionOption option);
  }
  public enum KnownFolderId
  public static class KnownFolders {
    public static IAsyncOperation GetFolderForUserAsync(User user, KnownFolderId folderId);
  }
  public sealed class StorageLibrary {
    public static IAsyncOperation GetLibraryForUserAsync(User user, KnownLibraryId libraryId);
  }
}
namespace Windows.System {
  public static class MemoryManager {
    public static bool TrySetAppMemoryUsageLimit(ulong value);
  }
}
namespace Windows.System.Profile {
  public enum PlatformDataCollectionLevel
  public static class PlatformDiagnosticsAndUsageDataSettings
}
namespace Windows.UI.Composition {
  public sealed class ColorKeyFrameAnimation : KeyFrameAnimation
  public enum CompositionAlphaMode
  public class CompositionAnimation : CompositionObject {
    void SetColorParameter(string key, Color value);
    void SetQuaternionParameter(string key, Quaternion value);
  }
  public enum CompositionBackfaceVisibility
  public sealed class CompositionBatch : CompositionObject
  public sealed class CompositionBatchCompletedEventArgs : CompositionObject
  public enum CompositionBatchTypes : uint
  public enum CompositionBitmapInterpolationMode
  public enum CompositionBorderMode
  public class CompositionBrush : CompositionObject
  public sealed class CompositionColorBrush : CompositionBrush
  public enum CompositionColorSpace
  public enum CompositionCompositeMode
  public sealed class CompositionDrawingSurface : CompositionObject, ICompositionSurface
  public sealed class CompositionEffectBrush : CompositionBrush
  public sealed class CompositionEffectFactory : CompositionObject {
    HResult ExtendedError { get; }
    CompositionEffectFactoryLoadStatus LoadStatus { get; }
    CompositionEffectBrush CreateBrush();
  }
  public sealed class CompositionEffectFactoryLoadResult
  public enum CompositionEffectFactoryLoadStatus {
    Other = -1, // used to be 2
    Pending = 2,
  }
  public sealed class CompositionGraphicsDevice {
    event TypedEventHandler RenderingDeviceReplaced;
    CompositionDrawingSurface CreateDrawingSurface(Size sizePixels, DirectXPixelFormat pixelFormat, CompositionAlphaMode alphaMode);
  }
  public class CompositionObject : IClosable {
    void ConnectAnimation(string propertyName, CompositionAnimation animation);
  }
  public sealed class CompositionPropertySet : CompositionObject {
    void InsertColor(string propertyName, Color value);
    void InsertQuaternion(string propertyName, Quaternion value);
    CompositionGetValueStatus TryGetColor(string propertyName, out Color value);
    CompositionGetValueStatus TryGetQuaternion(string propertyName, out Quaternion value);
  }
  public sealed class CompositionSurfaceBrush : CompositionBrush
  public sealed class Compositor : IClosable {

    CompositionColorBrush CreateColorBrush();
    CompositionColorBrush CreateColorBrush(Color color);
    ColorKeyFrameAnimation CreateColorKeyFrameAnimation();
    QuaternionKeyFrameAnimation CreateQuaternionKeyFrameAnimation();
    CompositionBatch CreateScopedBatch(CompositionBatchTypes batchType);
    SpriteVisual CreateSpriteVisual();
    CompositionSurfaceBrush CreateSurfaceBrush();
    CompositionSurfaceBrush CreateSurfaceBrush(ICompositionSurface surface);
    CompositionBatch GetCommitBatch(CompositionBatchTypes batchType);
  }
  public sealed class QuaternionKeyFrameAnimation : KeyFrameAnimation
  public sealed class RenderingDeviceReplacedEventArgs
  public sealed class SpriteVisual : ContainerVisual
  public class Visual : CompositionObject {
    Vector2 AnchorPoint { get; set; }
    CompositionBackfaceVisibility BackfaceVisibility { get; set; }
    CompositionBorderMode BorderMode { get; set; }
    CompositionCompositeMode CompositeMode { get; set; }
    bool IsVisible { get; set; }
  }
}

namespace Windows.UI.Core {
  public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
    event TypedEventHandler PointerRoutedAway;
    event TypedEventHandler PointerRoutedReleased;
    event TypedEventHandler PointerRoutedTo;
  }
  public interface ICorePointerRedirector
}
namespace Windows.UI.Input {
  public sealed class KeyboardDeliveryInterceptor
}
namespace Windows.UI.Input.Spatial {
  public sealed class SpatialGestureRecognizer
  public enum SpatialGestureSettings : uint
  public sealed class SpatialHoldCanceledEventArgs
  public sealed class SpatialHoldCompletedEventArgs
  public sealed class SpatialHoldStartedEventArgs
  public sealed class SpatialInputSource
  public sealed class SpatialInteraction
  public sealed class SpatialInteractionEventArgs
  public sealed class SpatialNavigationCanceledEventArgs
  public sealed class SpatialNavigationCompletedEventArgs
  public sealed class SpatialNavigationStartedEventArgs
  public sealed class SpatialNavigationUpdatedEventArgs
  public sealed class SpatialPathCanceledEventArgs
  public sealed class SpatialPathCompletedEventArgs
  public sealed class SpatialPathDelta
  public sealed class SpatialPathStartedEventArgs
  public sealed class SpatialPathUpdatedEventArgs
  public sealed class SpatialPointerDevice
  public enum SpatialPointerKind
  public sealed class SpatialPointerLocation
  public sealed class SpatialPointerPose
  public sealed class SpatialPointerProperties
  public sealed class SpatialPointerState
  public sealed class SpatialPointerStateEventArgs
  public sealed class SpatialRecognitionEndedEventArgs
  public sealed class SpatialRecognitionStartedEventArgs
  public sealed class SpatialTappedEventArgs
}
namespace Windows.UI.StartScreen {
  public sealed class JumpList
  public sealed class JumpListItem
  public enum JumpListItemKind
  public enum JumpListSystemGroupKind
}
namespace Windows.UI.Text.Core {
  public sealed class CoreTextEditContext {
    event TypedEventHandler NotifyFocusLeaveCompleted;
  }
}
namespace Windows.UI.ViewManagement {
  public sealed class ApplicationViewTransferContext
}
namespace Windows.UI.WebUI {
  public sealed class WebUIDevicePairingActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IDevicePairingActivatedEventArgs
}
namespace Windows.UI.Xaml.Automation {
  public sealed class AutomationElementIdentifiers {
    public static AutomationProperty LandmarkTypeProperty { get; }
    public static AutomationProperty LocalizedLandmarkTypeProperty { get; }
  }
  public sealed class AutomationProperties {
    public static DependencyProperty LandmarkTypeProperty { get; }
    public static DependencyProperty LocalizedLandmarkTypeProperty { get; }
    public static AutomationLandmarkType GetLandmarkType(DependencyObject element);
    public static string GetLocalizedLandmarkType(DependencyObject element);
    public static void SetLandmarkType(DependencyObject element, AutomationLandmarkType value);
    public static void SetLocalizedLandmarkType(DependencyObject element, string value);
  }
}
namespace Windows.UI.Xaml.Automation.Peers {
  public enum AutomationLandmarkType
  public class AutomationPeer : DependencyObject {
    AutomationLandmarkType GetLandmarkType();
    virtual AutomationLandmarkType GetLandmarkTypeCore();
    string GetLocalizedLandmarkType();
    virtual string GetLocalizedLandmarkTypeCore();
  }
}
namespace Windows.UI.Xaml.Controls {
  public class MenuFlyoutPresenter : ItemsControl {
    MenuFlyoutPresenterTemplateSettings TemplateSettings { get; }
  }
  public class RichEditBox : Control {
    RichEditClipboardFormat ClipboardCopyFormat { get; set; }
    public static DependencyProperty ClipboardCopyFormatProperty { get; }
    IAsyncOperation> GetLinguisticAlternativesAsync();
  }
  public enum RichEditClipboardFormat
  public class TextBox : Control {
    IAsyncOperation> GetLinguisticAlternativesAsync();
  }
  public enum WebViewPermissionType {
    PointerLock = 3,
  }
}
namespace Windows.UI.Xaml.Controls.Maps {
  public sealed class MapActualCameraChangedEventArgs {
    MapCameraChangeReason ChangeReason { get; }
  }
  public sealed class MapActualCameraChangingEventArgs {
    MapCameraChangeReason ChangeReason { get; }
  }
  public enum MapCameraChangeReason
  public sealed class MapControl : Control {
    event TypedEventHandler MapRightTapped;
  }
  public enum MapLoadingStatus {
    DataUnavailable = 2,
  }
  public sealed class MapPolygon : MapElement {
    IVector Paths { get; }
  }
  public sealed class MapRightTappedEventArgs
  public sealed class MapTargetCameraChangedEventArgs {
    MapCameraChangeReason ChangeReason { get; }
  }
}
namespace Windows.UI.Xaml.Controls.Primitives {
  public sealed class ComboBoxTemplateSettings : DependencyObject {
    double DropDownContentMinWidth { get; }
  }
  public sealed class CommandBarTemplateSettings : DependencyObject {
    double OverflowContentMaxWidth { get; }
  }
  public sealed class MenuFlyoutPresenterTemplateSettings : DependencyObject
}
namespace Windows.UI.Xaml.Hosting {
  public sealed class ElementCompositionPreview {
    public static Visual GetElementChildVisual(UIElement element);
    public static Visual GetElementVisual(UIElement element);
    public static CompositionPropertySet GetScrollViewerManipulationPropertySet(ScrollViewer scrollViewer);
    public static void SetElementChildVisual(UIElement element, Visual visual);
  }
}
namespace Windows.UI.Xaml.Media {
  public class FontFamily {
    public static FontFamily XamlAutoFontFamily { get; }
  }
  public sealed class PartialMediaFailureDetectedEventArgs {
    HResult ExtendedError { get; }
  }
}
namespace Windows.Web.Http.Filters {
  public sealed class HttpBaseProtocolFilter : IClosable, IHttpFilter {
    HttpCookieUsageBehavior CookieUsageBehavior { get; set; }
  }
  public enum HttpCookieUsageBehavior
}

 namespace Windows.Graphics.Printing3D {
  public sealed class Print3DManager
  public sealed class Print3DTask
  public sealed class Print3DTaskCompletedEventArgs
  public enum Print3DTaskCompletion
  public enum Print3DTaskDetail
  public sealed class Print3DTaskRequest
  public sealed class Print3DTaskRequestedEventArgs
  public sealed class Print3DTaskSourceChangedEventArgs
  public sealed class Print3DTaskSourceRequestedArgs
  public delegate void Print3DTaskSourceRequestedHandler(Print3DTaskSourceRequestedArgs args);
  public sealed class Printing3D3MFPackage
  public sealed class Printing3DBaseMaterial
  public sealed class Printing3DBaseMaterialGroup
  public struct Printing3DBufferDescription
  public enum Printing3DBufferFormat
  public sealed class Printing3DColorMaterial
  public sealed class Printing3DColorMaterialGroup
  public sealed class Printing3DComponent
  public sealed class Printing3DComponentWithMatrix
  public sealed class Printing3DCompositeMaterial
  public sealed class Printing3DCompositeMaterialGroup
  public struct Printing3DContract
  public sealed class Printing3DMaterial
  public sealed class Printing3DMesh
  public enum Printing3DMeshVerificationMode
  public sealed class Printing3DMeshVerificationResult
  public sealed class Printing3DModel
  public sealed class Printing3DModelTexture
  public enum Printing3DModelUnit
  public sealed class Printing3DMultiplePropertyMaterial
  public sealed class Printing3DMultiplePropertyMaterialGroup
  public enum Printing3DObjectType
  public sealed class Printing3DTexture2CoordMaterial
  public sealed class Printing3DTexture2CoordMaterialGroup
  public enum Printing3DTextureEdgeBehavior
  public sealed class Printing3DTextureResource
}

Changes in the Universal Windows Platform – Removed

namespace Windows.Foundation.Metadata {
  public sealed class PreviousContractVersionAttribute : Attribute {
    public PreviousContractVersionAttribute(Type contract, uint versionLow, uint versionHigh);
    public PreviousContractVersionAttribute(Type contract, uint versionLow, uint versionHigh, Type newContract);
  }
}

namespace Windows.Data.Json {
  public static class JsonError {
    public static JsonErrorStatus GetStatus(int hresult);
  }
}

namespace Windows.Management.Orchestration {
  public sealed class CurrentAppOrchestration
  public sealed class SingleAppModeContext : IClosable
}

namespace Windows.UI.Composition {
  public sealed class AnimationEndedEventArgs : CompositionObject
  public enum AnimationEndReason
  public sealed class CompositionEffect : CompositionObject
  public sealed class CompositionEffectFactory : CompositionObject {
    IAsyncOperation CompleteLoadAsync();
    CompositionEffect CreateEffect();
  }
  public sealed class CompositionEffectFactoryLoadResult
  public enum CompositionEffectFactoryLoadStatus {
    Other = 2, // now -1
  }
  public sealed class CompositionGraphicsDevice {
    CompositionImage CreateImageFromUri(Uri uri);
    CompositionImage CreateImageFromUri(Uri uri, CompositionImageOptions options);
  }
  public sealed class CompositionImage : CompositionObject, ICompositionSurface
  public sealed class CompositionImageLoadResult
  public enum CompositionImageLoadStatus
  public sealed class CompositionImageOptions
  public enum CompositionImageProgressStage
  public class CompositionObject : IClosable {
    CompositionPropertyAnimator ConnectAnimation(string propertyName, CompositionAnimation animation);
  }
  public sealed class CompositionPropertyAnimator : CompositionObject
  public sealed class Compositor : IClosable {
    CompositionGraphicsDevice DefaultGraphicsDevice { get; }
    EffectVisual CreateEffectVisual();
    ImageVisual CreateImageVisual();
    SolidColorVisual CreateSolidColorVisual();
  }
  public sealed class EffectVisual : ContainerVisual
  public sealed class ImageVisual : ContainerVisual
  public sealed class SolidColorVisual : ContainerVisual
}

Changes in the Windows Desktop Extension – Added

namespace Windows.Media.Capture {
  public sealed class AppCaptureAlternateShortcutKeys {
    VirtualKey ToggleMicrophoneCaptureKey { get; set; }
    VirtualKeyModifiers ToggleMicrophoneCaptureKeyModifiers { get; set; }
  }
  public sealed class AppCaptureSettings {
    bool IsMicrophoneCaptureEnabled { get; set; }
  }
}

 
namespace Windows.Security.EnterpriseData {
  public enum DataProtectionStatus {
    AccessSuspended = 5,
    LicenseExpired = 4,
  }
  public enum EnforcementLevel
  public static class FileProtectionManager {
    public static IAsyncOperation IsContainerAsync(IStorageFile file);
    public static IAsyncOperation LoadFileFromContainerAsync(IStorageFile containerFile, IStorageItem target, NameCollisionOption collisionOption);
    public static IAsyncOperation SaveFileAsContainerAsync(IStorageFile protectedFile, IIterable sharedWithIdentities);
  }
  public enum FileProtectionStatus {
    AccessSuspended = 9,
    LicenseExpired = 8,
  }
  public enum ProtectedImportExportStatus {
    AccessSuspended = 7,
    LicenseExpired = 6,
  }
  public sealed class ProtectionPolicyManager {
    public static bool IsProtectionEnabled { get; }
    public static event EventHandler

Changes in the Windows Desktop Extension – Removed

namespace Windows.Devices.Printers.Extensions {
  public sealed class Print3DWorkflow
  public enum Print3DWorkflowDetail
  public sealed class Print3DWorkflowPrintRequestedEventArgs
  public enum Print3DWorkflowStatus
}

namespace Windows.Devices.Printers {
  public sealed class Print3DDevice
  public struct PrintersContract
  public sealed class PrintSchema
}

namespace Windows.Graphics.Printing3D {
  public sealed class Print3DManager
  public sealed class Print3DTask
  public sealed class Print3DTaskCompletedEventArgs
  public enum Print3DTaskCompletion
  public enum Print3DTaskDetail
  public sealed class Print3DTaskRequest
  public sealed class Print3DTaskRequestedEventArgs
  public sealed class Print3DTaskSourceChangedEventArgs
  public sealed class Print3DTaskSourceRequestedArgs
  public delegate void Print3DTaskSourceRequestedHandler(Print3DTaskSourceRequestedArgs args);
  public sealed class Printing3D3MFPackage
  public sealed class Printing3DBaseMaterial
  public sealed class Printing3DBaseMaterialGroup
  public struct Printing3DBufferDescription
  public enum Printing3DBufferFormat
  public sealed class Printing3DColorMaterial
  public sealed class Printing3DColorMaterialGroup
  public sealed class Printing3DComponent
  public sealed class Printing3DComponentWithMatrix
  public sealed class Printing3DCompositeMaterial
  public sealed class Printing3DCompositeMaterialGroup
  public struct Printing3DContract
  public sealed class Printing3DMaterial
  public sealed class Printing3DMesh
  public enum Printing3DMeshVerificationMode
  public sealed class Printing3DMeshVerificationResult
  public sealed class Printing3DModel
  public sealed class Printing3DModelTexture
  public enum Printing3DModelUnit
  public sealed class Printing3DMultiplePropertyMaterial
  public sealed class Printing3DMultiplePropertyMaterialGroup
  public enum Printing3DObjectType
  public sealed class Printing3DTexture2CoordMaterial
  public sealed class Printing3DTexture2CoordMaterialGroup
  public enum Printing3DTextureEdgeBehavior
  public sealed class Printing3DTextureResource
}

Changes in the Windows Mobile Extension – Added

namespace Windows.ApplicationModel.Calls.Provider {
  public sealed class PhoneCallOrigin {
    string DisplayName { get; set; }
  }
}

Changes in the Windows IOT Extension – Added

namespace Windows.Devices {
  public interface ILowLevelDevicesAggregateProvider
  public sealed class LowLevelDevicesAggregateProvider : ILowLevelDevicesAggregateProvider
  public sealed class LowLevelDevicesController
}
namespace Windows.Devices.Adc {
  public sealed class AdcController {
    public static IAsyncOperation GetDefaultAsync();
  }
}
namespace Windows.Devices.Gpio {
  public sealed class GpioController {
    public static IAsyncOperation> GetControllersAsync(IGpioProvider provider);
    public static IAsyncOperation GetDefaultAsync();
  }
}
namespace Windows.Devices.Gpio.Provider {
  public sealed class GpioPinProviderValueChangedEventArgs
  public interface IGpioControllerProvider
  public interface IGpioPinProvider
  public interface IGpioProvider
  public enum ProviderGpioPinDriveMode
  public enum ProviderGpioPinEdge
  public enum ProviderGpioPinValue
  public enum ProviderGpioSharingMode
}
namespace Windows.Devices.I2c {
  public sealed class I2cController
}
namespace Windows.Devices.I2c.Provider {
  public interface II2cControllerProvider
  public interface II2cDeviceProvider : IClosable
  public interface II2cProvider
  public enum ProviderI2cBusSpeed
  public sealed class ProviderI2cConnectionSettings
  public enum ProviderI2cSharingMode
  public struct ProviderI2cTransferResult
  public enum ProviderI2cTransferStatus
}
namespace Windows.Devices.Pwm {
  public sealed class PwmController {
    public static IAsyncOperation GetDefaultAsync();
  }
}
namespace Windows.Devices.Spi {
  public sealed class SpiController
}
namespace Windows.Devices.Spi.Provider {
  public interface ISpiControllerProvider
  public interface ISpiDeviceProvider : IClosable
  public interface ISpiProvider
  public sealed class ProviderSpiConnectionSettings
  public enum ProviderSpiMode
  public enum ProviderSpiSharingMode
}

namespace Windows.System {
  public static class ProcessLauncher
  public sealed class ProcessLauncherOptions
  public sealed class ProcessLauncherResult
}

Moving your projects forward

After installing the new Windows 10 SDK, update your projects with the Visual Studio Release Candidate to use the new SDK.

First, update the Project file (.csproj, .jsproj, .vcxproj) by:

1. Opening the project in Visual Studio
2. Right clicking on the project in the Visual Studio Solution Explorer, and choose “Properties”
3. Depending on your project type, the UI will look a little different but click on the dropdown that says “Target Version”. The below screenshot is from a C# Project. Note: If you’re using a Javascript project, open the .jsproj and find a replace the TargetPlatformVersion with 10.0. 10563.0.
4. Select Windows 10 Insider Preview (10.0; Build 10563).

Now that you have updated the project file, find the application’s Package.appxmanifest and do the following:

1. Open that file (it should present you with an XML Editor)
2. Find the Element, Dependencies and its child element, TargetDeviceFamily
3. Modify the MaxVersion Tested Attribute from “10.0.10240.0” to “10.0.10563.0.”
4. Save and close the file.

Known Issues

SDK Backwards compatibility: Do not install this preview SDK on your production machine. If you do so, any applications you submit to the Store after installing this SDK will fail validation because this SDK will update some of the build tools used to preview versions of those tools.

If you have other issues, please post to the forums and include the following [UWP][SDK] in the title if it is a Windows 10 SDK install or uninstall issue.

Now you’re ready to use the new SDK. Start developing and @WindowsDev would love to see what you create. If you find bugs or issues, please leverage the Windows Feedback tool or MSDN forums.

In two earlier posts (Visual Studio Customer Feedback Channels and A Day in the Life of Visual Studio Send a Smile Feedback) we talked about the different ways you could send us feedback for Visual Studio 2015 and I shared what happens with your Send a Smile feedback once it gets to Microsoft. In this post, I’ll talk about how we’re thinking to make it easier to provide actionable feedback. We’ve also received all your input from the survey in the first post, and what you told us resonates with what we’ve heard from other customers. You also provided some great new thoughts about where to go next. Thank you!

Here’s what we’ve learned from your feedback:

1. What happens to feedback is a black box. The system could use better status updates, more ongoing contact, etc.
2. There are a lot of ways to give feedback. Although developers use all the feedback channels (Send a Smile, Connect and User Voice), it can be a confusing or bad experience.
3. Developers usually give contact information. Most of you provide an email address for follow-up, and many of you also send a screenshot (both really help us to resolve your issues)
4. Some folks dislike the smiley face. Among other comments I can’t share here, you’ve saidit’s distracting with the dark theme and doesn’t feel professional.

Here are also the top five important or must-have improvements we heard about giving feedback:

Other useful suggestions include:

1. Send my Project option
2. Easy to start profiling on my project or issue
3. Notification via Notification center of feedback status changes
4. Dashboard with trending feedback

In short, having the ability to browse feedback, vote on feedback items, add data to them, and discover workaround and other solutions would provide the most benefit to you.

What we’re thinking about for future Visual Studio Updates

We are still in the planning stage, of course, and we don’t have any release dates to share, but here’s a list of our top ideas for collecting feedback:

1. Search and voting for all your feedback: Although you can currently search for any bugs you have submitted via Connect, you can’t do this for Send a Smile feedback. We’re looking at allowing you to search for existing feedback first so you can add your vote, add additional information (comments, files, etc.), and see available workarounds or fixes.
2. Updated status and links to fixes or published workarounds for issues: We want you to see what is happening as we work on items, and easily find and download workaround or fixes once they’re available.
3. Simplified feedback channels: We want have one place to provide feedback without having to login to Connect or decide where to provide input. We are testing feedback options to make this simple.
4. Make it easy to record repro steps for a problem and collect the right files and logs automatically. You all know how important repo steps are, so we’ll make it easy to record the repro for a problem and to do that even if Visual Studio is hung or a dialogue is open. We’ll automatically attach the right files so you wouldn’t need to figure out those details.
5. Notification of status changes on your feedback or when a problem is fixed: This would appear in the notification hub potentially and would let us contact you if we need more data to resolve your issue
6. Automatically detect when there is a problem on the system, collect the right data and ask you if you want to report the problem. This would let you decide if you want to report an issue without requiring you to turn on tracing and capture the data. This would also let you know of problems that you might not be aware of.

What’s next?

The list above is pretty big and we want to get it right. We’re planning and prototyping some of this functionality and setting priorities. Your feedback has immensely helped this process, and we’ll continue to ask for your input as we move forward on the feedback tools.

As always, if you have any questions or problems with giving us feedback or suggestions, you can reach us by emailing the Visual Studio Feedback Team, vscet (at) microsoft.com. Thanks so much for taking the time to help!

Earlier in the year, we announced that we will be building nested virtualization so that people could run Hyper-V Containers in Hyper-V virtual machines.

In preparation for the first public preview of Hyper-V Containers, we are releasing a preview of nested virtualization. This feature allows you to run Hyper-V in a virtual machine (note that this is Hyper-V on Hyper-V only… other hypervisors will fail).

Although Hyper-V Containers have not been released yet, for now you can try out this feature with Hyper-V virtual machines.

Build 10565 -- It is a very early preview

Yesterday, we announced the release of build 10565 to Windows Insiders on the Fast ring.  This build contains an early preview of nested virtualization.

When I say it is an “early” preview, I mean it – there are plenty of known issues, and there is functionality which we still need to build. We wanted to share this feature with Insiders as soon as possible though, even if that meant things are still rough around the edges.

This post will give a quick overview of what nested virtualization is, and briefly cover how it works. The end of this post will explain how to enable it, so you can try it out. Please read the “known issues” section before trying this feature.

What is nested virtualization?

In essence, this feature virtualizes certain hardware features that are required to run a hypervisor in a virtual machine.

Hyper-V relies on hardware virtualization support (e.g. Intel VT-x and AMD-V) to run virtual machines. Typically, once Hyper-V is installed, the hypervisor hides this capability from guest virtual machines, preventing guests virtual machines from installing Hyper-V (and many other hypervisors, for that matter).

Nested virtualization exposes hardware virtualization support to guest virtual machines. This allows you to install Hyper-V in a guest virtual machine, and create more virtual machines “within” that underlying virtual machine.

In the image below, you can see a host machine running a virtual machine, which in turn is running its own guest virtual machine. This is made possible by nested virtualization. Behold, three levels of Cortana!

Under the hood

Consider the diagram below, which shows the “normal” (i.e. non-nested) case. The Hyper-V hypervisor takes full control of virtualization extensions (orange arrow), and does not expose them to the guest OS.

Contrast this with the nested diagram below. In this case, Hyper-V has been configured to expose virtualization extensions to its guest VM. A guest VM can take advantage of this, and install its own hypervisor. It can then run its own guest VMs.

Known issues: important!

Like I said earlier – this is still just a “preview” of this feature. Obviously, this feature should not be used in production environments.  Below is a list of known issues:

• Both hypervisors need to be the latest versions of Hyper-V. Other hypervisors will not work. Windows Server 2012R2, or even builds prior to 10565 will not work.
• Once nested virtualization is enabled in a VM, the following features are no longer compatible with that VM. These actions will either fail, or cause the VM not to start:
  • Dynamic memory must be OFF. This will prevent the VM from booting.
  • Runtime memory resize will fail.
  • Applying checkpoints to a running VM will fail.
  • Live migration will fail.
  • Save/restore will fail.
• Once nested virtualization is enabled in a VM, MAC spoofing must be enabled for networking to work in its guests.
• Hosts with Virtualization Based Security (VBS) enabled cannot expose virtualization extensions to guests. You must first disable VBS in order to preview nested virtualization.
• This feature is currently Intel-only. Intel VT-x is required.
• Beware: nested virtualization requires a good amount of memory. I managed to run a VM in a VM with 4 GB of host RAM, but things were tight.

How to enable nested virtualization

Step 1: Create a VM

Step 2: Run the enablement script

Given the configuration requirements (e.g. dynamic memory must be off), we’ve tried to make things easier by providing a PowerShell script.

This script will check your configuration, change anything which is incorrect (with permission), and enable nested virtualization for a VM. Note that the VM must be off.

Invoke-WebRequesthttps://raw.githubusercontent.com/Microsoft/Virtualization-Documentation/master/hyperv-tools/Nested/Enable-NestedVm.ps1 -OutFile ~/Enable-NestedVm.ps1 
~/Enable-NestedVm.ps1 -VmName

Step 3: Install Hyper-V in the guest

From here, you can install Hyper-V in the guest VM.

Step 4: Enable networking (optional)

Once nested virtualization is enabled in a VM, MAC spoofing must be enabled for networking to work in its guests. Run the following PowerShell (as administrator) on the host machine:

Invoke-WebRequest https://raw.githubusercontent.com/Microsoft/Virtualization-Documentation/master/hyperv-tools/Nested/Get-NestedVirtStatus.ps1 -OutFile ~/Get-NestedVirtStatus.ps1 
~/Get-NestedVirtStatus.ps1

Set-VMNetworkAdapter -VMName -MacAddressSpoofing on

Step 5: Create nested VMs

Give us feedback!

If you discover any issues, or have any suggestions, please consider submitting feedback with the Windows Feedback app, through the virtualization forums, or through GitHub.
We are also very interested to hear how people are using nested virtualization. Please tell us about your scenario by dropping us a line at VirtualPCGuy@microsoft.com.

FAQ and troubleshooting

My VM won’t start, what should I do?

First, make sure dynamic memory is OFF. If this was not the issue, run this PowerShell script on your host machine from an elevated prompt. This script reports whether your host and VMs are configured properly for nested.

Go build VMs in VMs!

Cheers,

Theo

PASS Summit 2015 is nearly upon us. With less than three weeks until the big event, the SQL Server team caught up with Denise McInerney, PASS VP of Marketing, about the world’s largest gathering of SQL Server and BI professionals.

Can you tell us in a few short sentences what PASS Summit 2015 is and why people should be excited to attend this year?

DM: PASS Summit 2015 is three days of networking, professional development, technical sessions and fun! Every year I attend I’m still amazed to see this huge global SQL community come together in Seattle for the world’s biggest SQL Server event, to share ideas, develop their careers, expand their professional networks, and stay at the forefront of technical advances. Last year, PASS Summit saw over 5,000 attendees, so it really is the biggest event on the global SQL Server calendar.

How will this year’s Summit be different to previous years?

We’re very excited about the new Microsoft Foundation sessions. These are in-depth sessions from Microsoft leaders that delve into new features and products, and detail leading technologies. The sessions will cover Advanced Analytics, Big Data and Data Warehousing, Business Intelligence, and Designing Modern Applications on Azure.

Can you detail some of the event highlights that will take place?

T.K. 'Ranga' Rengarajan, Corporate Vice President - Data Platform, Cloud & Enterprise, Microsoft, will open PASS Summit 2015 with the keynote “Accelerating your Business with a Modern Data Strategy”, which will focus on how data professionals can use the next-generation SQL Server to maximize data platforms and manage data to better predict outcomes.

On day two, Microsoft Keynote presenters David DeWitt, Technical Fellow and Rimma Nehme, Principal Research Engineer, both of Microsoft Jim Gray Systems Lab, will present “Data Management for Internet of Things”.

Another highlight will be the Women in Technology Luncheon, which always proves to be very popular. This year, Angie Chang, Vice President - Strategic Partnerships, Hackbright Academy, will detail how Hackbright Academy, the leading engineering school for women, is working to increase female representation in the technology sector through education, mentorship and community.

Are there any particular themes in the sessions this year, any key topics that are being covered that you’d like to highlight to attendees or those still considering attending?

As with previous years, there are a number of sessions that discuss transitioning to the cloud, Microsoft Azure and other leading technologies. There are also sessions on new features and advanced technologies in SQL Server 2016. There are 10-minute Lightning Talks, 75-minute General Sessions, three-hour Half-Day Sessions, and full-day pre-conference workshops. With more than 220 technical sessions on offer, there is literally something at PASS Summit for all data professionals, from beginners to those more advanced in their careers.

You mentioned beginners. What will this year include for first-time attendees?

The First-Timers Program includes an orientation meeting and a fun speed networking session. This is a similar concept to speed-dating, except attendees will use it as an opportunity to network with their peers and further develop professional relationships.

In addition, in our Get to Know Your Community sessions, longtime PASS members share how to get involved with PASS and the worldwide SQL community, including encouraging those new to PASS to connect with their local SQL Server communities through PASS Chapters. First-timers can also continue their learning through Virtual Chapters, SQLSaturdays and other free professional development opportunities.

What practical technical skills development will be available?

As with previous years, attendees will also get the opportunity to work through technical issues with top Microsoft technical support staff and get architectural guidance from the Azure CAT, SQL CAT, and CSS teams at the Azure CAT & CSS Clinic.

What is one piece of feedback you’d give to attendees this year?

Take advantage of all the learning and networking opportunities we have available and if you want a deeper dive or more intensive training in a particular area, consider adding a day or two of the Pre-Conference sessions to your schedule, go to one of the Microsoft workshops, and visit the SQL Server Clinic.

Where can you register for PASS Summit?

To register, just go to Register Now – and remember to take advantage of the $150 discount code from your local or Virtual PASS Chapter. We also have a great group discount for companies sending five or more employees. And don’t forget to purchase the session recordings for year-round learning on all aspects of SQL Server.

Once you get a taste for the learning and networking waiting for you at PASS Summit, we invite you to join the conversation by following us on Twitter (watch the #sqlpass #summit15 hashtags) and joining our Facebook and LinkedIn groups. We’re looking forward to an amazing event, and can’t wait to see everyone there!

Please stay tuned for regular updates and highlights on Microsoft and PASS activities planned for this year’s conference.

A little while ago we announced that - in order to help people run Hyper-V Containers on their existing infrastructure - we would be adding support for nested Hyper-V.

Well - yesterday we flighted the first build with this capability in it:

Now, this is very early functionality - and there are plenty of caveats.  You can read all about it here: http://blogs.technet.com/b/virtualization/archive/2015/10/13/windows-insider-preview-nested-virtualization.aspx

Cheers,
Ben

In our final post of the Windows 10 by 10 development series, we’ll talk about the feature introductions and enhancements in Windows 10 that help you create more secure apps. When we think of security, we can split it up in these three main areas: authentication, data-in-flight and data-at-rest. With Windows 10, a number of improvements have been made to lessen the effort for developers in the authentication and data-at-rest areas, specifically around protecting sensitive data on the device and moving away from using passwords. Additionally, Azure API Management can help simplify exposing app APIs securely.

From passwords to Microsoft Passport

Dealing with user credentials for authentication and authorization is something that users and administrators have been doing for quite some time. The problems with traditional user credentials: credential theft, reuse, password complexity and reset mechanisms can make creating secure apps more complex. With Windows 10, Microsoft addresses these problems with two new technologies: Windows Hello and Microsoft Passport. Working together, these technologies help create a more secure, yet convenient way to manage authentication for both end-users and developers.

Windows Hello is the biometric framework built into Windows 10. The three types of biometrics currently supported with Windows Hello are: facial recognition, fingerprint recognition and iris scan. Microsoft Passport is the component that provides strong two-factor authentication, replacing reusable passwords with the combination of a specific device and a user defined PIN or the biometric modalities of Hello. This combination can be used to authenticate users directly with Windows and apps can use the Universal Windows Platform (UWP) APIs offered to implement this authentication. For more information on Windows Hello and Microsoft Passport, check out the extensive Microsoft Passport guide on TechNet, but for now let’s dig into the APIs to use in your UWP apps.

The first thing to do is check whether or not the user is set up for Microsoft Passport in Windows. This can be done with the KeyCredentialManager.IsSupportedAsync method:

var keyCredentialAvailable = await KeyCredentialManager.IsSupportedAsync ();

if (keyCredentialAvailable != true)
{
   // Key credential is not enabled yet as user, prompt user to
   // set up a PIN by visiting Settings->Accounts->Sign-in options->Pin->Add
   return;
}

The next step is to call the KeyCredentialManager.RequestCreateAsync method to generate a private and public key pair. This generation is performed by the Trusted Platform Module (TPM) chip on the device, or by Windows when there’s no TPM-chip available on the device:

var keyCreationResult = await KeyCredentialManager.RequestCreateAsync(AccountId, KeyCredentialCreationOption.ReplaceExisting);

The private keys are opaque to the caller, but the public key should be stored on your identity provider server, together with the user’s unique identifier (e-mail address, username, etc.).

With subsequent uses of the app, the KeyCredentialManager.OpenAsync method is used to prompt the user to authenticate with Microsoft Passport and get the KeyCredential on successful authentication. In the case below the server sends a challenge the client needs to sign with the private key.

var openKeyResult = await KeyCredentialManager.OpenAsync(AccountId);

if (openKeyResult.Status == KeyCredentialStatus.Success)
{
  var userCredential = openKeyResult.KeyCredential;
  var publicKey = userCredential.RetrievePublicKey();
  var signResult = await userCredential.RequestSignAsync(message);
  
  if (signResult.Status == KeyCredentialStatus.Success)
  {
    return signResult.Result;
  }
}	

As you can see above, after we get the KeyCredential, we use that to sign a message with the RequestSignAsync method. The message is signed with the private key and sent back to server. The server can check if the message is signed by validating the signature with the stored public key of the user:

This high-level overview of Windows Hello and Microsoft Passport should give you an idea of how this can be implemented in your app. We’ll have a full sample and developer whitepaper to share soon, taking you through the end-to-end approach for implementation in new apps or moving an existing solution from using passwords to Microsoft Passport.

Connecting securely to your web services

Connecting with your back end in a secure way is important for making sure that data does not get intercepted while in flight. The basic requirement of using Secure Sockets Layer (SSL) to establish and maintain secure connections to servers supporting the Secure Hypertext Transfer (HTTPS) protocol is essential in ensuring this message confidentiality. Simply relying on SSL, however, still leaves the possibility for malicious third parties to sit between the client and server, for example by offering insecure “free Wi-Fi” to users and intercepting all traffic. To prevent this, you can validate the SSL certificates that are used by the server by using a technique commonly referred to as “SSL pinning”.

There are a few different ways to implement SSL pinning, each with their own pros and cons. The easiest way to implement it is via the Certificates declaration in the app’s manifest. This declaration enables the app package to install digital certificates and specify exclusive trust to them. This means SSL connections are only allowed from the app to servers with the corresponding root certificate on the server.

For some more flexibility (when communicating with various web servers over SSL, for example), validating the thumbprint(s) of the certificate(s) the server returns when sending an HTTP request might be a better option. One thing to be aware of is that this method requires sending a request and inspecting the response, so be sure to add this as a validation before actually sending sensitive information in a request. The C# code will look similar to this:

private async Task DemoSSLRoot()
{
    // Send a get request to Bing
    HttpClient client = new HttpClient();
    Uri bingUri = new Uri("https://www.bing.com");
    HttpResponseMessage response = await client.GetAsync(bingUri);

    // Get the list of certificates that were used to validate the server's identity
    IReadOnlyList serverCertificates = response.RequestMessage.TransportInformation.ServerIntermediateCertificates;
    // Perform validation
    if (!ValidCertificates(serverCertificates))
    {
        // Close connection as chain is not valid
        return;
    }

    PrintResults("Validation passed\n");
    // Validation passed, continue with connection to service
}

private bool ValidCertificates(IReadOnlyList certs)
{
    // In this example, we iterate through the certificates and check that the chain contains
    // one specific certificate we are expecting
    for(int i=0; i
In the above example, the DemoSSLRoot method uses the HttpClient class to execute an HTTP request. When the response is given by the client, the RequestMessage.TransportInformation.ServerIntermediateCertificates collection can be used to inspect the certificates returned by the server. This way, the client can validate the entire certificate chain with the thumbprints it has prepopulated. Be aware that this requires the thumbprints of all certificates to be updated in the app, once the server certificate expires and is renewed.
Providing secure access to your back end web APIs can prevent unauthorized use of your APIs. With the growing popularity of RESTful services, however, this becomes increasingly difficult, as data should be accessible through basic HTTP GET/POST requests. The use of API keys for securing RESTful services is a common practice and, while you can implement this yourself, Azure API Management provides a way to publish an API securely, while also being able to monitor, throttle and analyze it.
Securing data on the device
A third place where you need to pay attention to app security is when the data arrives on the device. Storing data securely on the device is something Windows and its app model already helps you with. By default, UWP apps are isolated in their own container, so their data won’t be accessible by other UWP apps. This benefits both reliability and security, as there is no risk of any UWP apps locking, accessing or modifying data, other than the app itself.
While securing data on the device by ways of encryption is usually a good practice, for example with BitLocker, it doesn’t prevent data from being shared to unauthorized third parties by users. That’s why Windows 10 introduces a new capability for enterprises that prevent data leaks by encrypting and classifying data as business data, so it can no longer be accidentally shared outside of a company. This not only protects data at rest on the device, but also data in flight and in use. To implement this capability in your internal apps, you first need to enable the enterpriseDataPolicy capability in your app’s manifest:
Be aware that this is a restricted capability, which means your app will not be eligible for Windows Store publication unless your organization has been specifically approved for it. This does not prevent you from using the capability internally within an organization or when sideloading.
This enables a number of data protection scenarios, including file protection, and application sharing restrictions, that lets work and personal data be used safely in the same application. For example, if you want to show the user some non-corporate data while the application places some enterprise-owned text on the clipboard, and restrict that text to be pasted only in corporate apps that are also allowed access to enterprise data, you’d use the following code:
var dataPackage = new Windows.ApplicationModel.DataTransfer.DataPackage();
dataPackage.SetText(MyTextBox.Text);
dataPackage.Properties.EnterpriseId = yourEnterpriseID;

Windows.ApplicationModel.DataTransfer.Clipboard.SetContent(dataPackage);
In the above example, we create a DataPackage instance, which contains an EnterpriseId property. We can then use the ProtectionPolicyManager to verify if the app is allowed to access the content it’s trying to retrieve from the Clipboard using the Clipboard.GetContent method:
var dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
    var response = await dataPackageView.RequestAccessAsync();
    if (response == ProtectionPolicyEvaluationResult.Allowed)
    {
      // Allowed access to clipboard
    }
    else
    {
      // Blocked access to clipboard
    }
}
For more scenarios, take a look at the Enterprise Data Protection sample on GitHub.
Wrapping up
While security remains a complex topic, we’re hoping the description of these new features in Windows 10 give you some ideas on how to harden your UWP apps without having to write large amounts of code. Relying on these Windows 10 features will allow you to focus on the things your app does best, without having to compromise on security.
That brings us to the end of our Windows 10 by 10 development series. We thank you for diving into the 10 compelling Windows platform capabilities over the last 10 weeks and hope the information has inspired you to create great new apps.
The “Know Your Options When it Comes to Storage, Backup and Roaming” quiz is now available on DVLUP to get points and XP for getting up to speed on this week’s topic. Let us know what you think about the series and this week’s topic via @WindowsDev on Twitter using #Win10x10.
Resources
Build 2015: Microsoft Passport and Windows Hello: Moving Beyond Passwords and Credential Theft
Build 2015: Enterprise Data Protection: Building Universal Windows Apps That Keep Work and Personal Data Separate and Secure
GitHub: Enterprise Data Protection sample
The Security Development Lifecycle Developer Starter Kit

Do you want to easily troubleshoot performance issues in your environment? Wished you could collect Near-Real Time Performance Data from all your servers into one single place?

We heard this ask from many of you, and now we are proud to announce the availability of the Near-Real Time (NRT) Performance Data Collection in OMS. With this new feature, you can now collect any performance counter with a sampling interval as small as 10 seconds, and visualize any of the metrics that helps you easier troubleshoot performance issues.

Enabling the performance data

In order to enable the NRT performance data collection,  in the Setting page, click on the Logs tab.  In this page, you can search for any performance counter to get collected. There is also a list of suggested counters that you can add right away. In this example, I will be adding the suggested performance counters plus one other that I’m interested in.

Once you click on the Add button, here is the list that would see. All the sample intervals are defaulted to 10 seconds, but you can choose a different interval if you want to.

In order to add more counters, you can use the search bar to enter the exact counter name. OMS will give you autosuggestions for some of the common counters. For any custom counter, you need to specify the exact name. You can use any of the following formats: 

All instances of a counter:

Object name\Counter name
Object name(*)\Counter name

A specific instance of a counter:

Object name(Instance name)\Counter name

 In this example, I’m also interested to add the Free Megabyte counter.

I select the counter, and then click +. I also want to collect this counter every 30 seconds. Finally I click on Save button to save all the new changes.

Configuring this for the first time, it takes about an hour for the data to be accessible through Search. Once the initial configuration is done, the data will be sent at the sampling intervals. 

Using Search to visualize the data

To view this data, I go to search, and type the following query:

Type = Perf

 This will return all the performance counters that are being collected. There are two perspective views for this search. The first one (Logs) will return the 30 minute aggregate values for all the performance counters, and the second one (Metrics) will return the visualization of the raw results for each of the returned counters.

Currently, the raw data is stored for 14 days. The 30 min aggregates will be stored based on your data plan with OMS.

In this example, I want to look at the counters for one of my servers which has been running slowly lately. Here is how my query looks like:

Type=Perf Computer=”MycomputerName”

Clicking on the + button on the right side of the chart will expand the view to give you more details on any given metric. In this example I’m looking at the Disk Read/sec counter for the last 7 days in more details by clicking on the expand button.

Another common query is to look at a given counter across all you computers. The following query returns the “Current Disk Queue Length” Counter for the past 2 hours across all my servers.

Type=Perf CounterName=”Current Disk Queue Length”

I can now look into all instances of this counter across one of my computers. I also expand all the graphs to see them in more details and be able to compare their values.

 Type=Perf CounterName=”Current Disk Queue Length” Computer=”MyComputerName”

Viewing the Live data

You can also hover on the chart to find out the values for any of the samples. If  you make your time range small enough (6 hours or less), the charts will show you live data. In this example I’m looking at the last 1 hour data for the Logical Disk(C:) Disk Writes/sec from one of my computers. As you can see the light blue color is showing the live data coming in for the %Processor Time.

Other Queries

With the 30 min aggregate data,  you can do different aggregate queries. Here are few examples:

 Average CPU Utilization across all computers

Type:Perf (ObjectName=Processor) CounterName="% Processor Time" InstanceName=_Total   | measure Avg(Average) as AVGCPU  by Computer

 Maximum CPU Utilization across all computers

Type:Perf (CounterName="% Processor Time") | measure max(Max) by Computer

 Average Current Disk Queue length across all  the instances of a given computer

Type:Perf ObjectName=LogicalDisk CounterName="Current Disk Queue Length" Computer=”MyComputerName” | measure Avg(Average) by InstanceName

95 Percentile of Disk Transfers/Sec across all computers (What is the Disk Transfers/Sec of all computers 95% of the time)

Type:Perf CounterName:"DiskTransers/sec" |measure percentile95(Average) by Computer

*Note that you can do any percentile calculation by replacing the "95" in the above query with any number between 1 to 99 (e.g., percentile1, percentile50,percentile99)

70 Percentile of Current Disk Queue Length across all instances of a given computer (What is the Current Disk Queue Length of all instances of a given computer 70% of the times)

Type:Perf ObjectName=LogicalDisk CounterName="Current Disk Queue Length" Computer=”MyComputerName” | measure Percentile70(Average) by InstanceName

Estimated Usage

 If you like to start using this feature, but don’t know the estimated usage for performance counters, this example may help you.

For a particular computer, a given counter instance (e.g., Processor(_Total)\% Processor Time) with 10 second sample interval will send ~1MB per day (~1MB/day/counter instance). You can multiply this number by the number of computers that you have to get an estimate usage per counter instance across all your computers.

Hope you enjoy this new feature in OMS. Please post any feedback or questions on UserVoice.

 Thanks

We are excited to announce the following set of features that are available in this week’s Power BI service update

1. Full screen mode to display your dashboards & reports on big screen TVs
2. ‘Fit to screen’ support in full screen mode to display your entire dashboard in the available space
3. In-focus mode to get more details on dashboard tiles
4. Ability to view last update time for each tile
5. Ability to view the source for each tile in In-Focus Mode

Full Screen Mode

Power BI lets you create personalized dashboards and reports to monitor the key metrics of your business, at-a-glance. All you needed to do was to fire up your browser and navigate to your Power BI dashboard. Today we’re making this even better.  

With today’s update, we have enabled Full Screen Mode for Power BI dashboards and reports. What does this mean for you? If you have big screen TVs or projectors in your office, you can display Power BI dashboards and reports on those screens without the distraction of menus, buttons etc. You get an unadulterated, full view of your business at a glance, all the time.

This mode is also very useful when you are presenting your dashboards and reports. You can have discussions on the metrics and the charts without being cluttered by the different menu elements.

You can activate this mode with a single click. Navigate to your dashboard and press the “Full Screen Mode” button on the top right.

You will see the surrounding menu and application elements disappear and your dashboards will take up your full screen space. To go back to the standard viewing mode, click the full screen button on the top right again.

You also do not need to worry about accidentally moving around tiles or editing them in the middle of a presentation - Full Screen Mode prevents you from editing/moving tiles.

Fit to screen support in Full Screen Mode

In the previous image, you can see that the bar chart and the tree map at the bottom of the dashboard get cut off because of the lack of screen space. You would need to scroll to see the rest of the dashboard. This can be especially problematic for dashboards that are larger than the browser window.

You can now use the ‘Fit to screen’ option that is available in Full Screen Mode to see your full dashboard in the available space. To use this feature, activate your Full Screen Mode and press the ‘Fit to screen’ button on the top right.

Power BI will automatically scale the tiles to fit your entire dashboard in the available screen space.

In-Focus Mode for Dashboard Tiles

This mode lets you see a particular tile in full focus. The additional space will be used to show more information when possible.

For an example of how you would use this functionality, take a look at the dashboard below. We have a dashboard showing the Gross Margins trends of different executives among other things.

Lets’ see how In-focus mode will help us to investigate Tina’s Gross Margin Trend tile.

We start by hovering over the tile and clicking on the In-focus mode icon.

We can now see Tina’s Gross Margin trend in a full screen view. The Y-axis is much more granular in In-Focus mode than in the actual dashboard tile.

Now let’s see how Tina did last year. In In-Focus mode, we can pull open the Filters area to see all the filters applied on the dashboard tile when it was created. Lets’ change the filter on the year column to see how Tina did in 2013. We can see that she had a pretty good year in 2013.

Note: Currently In-Focus mode is not available for tiles pinned from Q&A and map tiles.

Last Updated Time for Each Tile

We’ve also added the last update time for the underlying tile data.  This makes easy to identify how recently the data was updated for the specific data displayed in this tile. To see this, open your tile in In-Focus mode and look at the top right. The last updated time is visible there.

Source for Each Tile in In-Focus Mode

From the bottom left of the In-Focus mode of your tile, you can also see that the Customer Profitability Report is the source for this visual. You can also simply click on this information and you will navigate to the specific report page.

Hope you like the new features that we released today. Try out the features and let us know what you think!

• Try Power BI
• Follow @MSPowerBI on Twitter
• Join the conversation at the Power BI Community

The next stop on our tour was Seoul, Korea. Today it was my honor to join Brian Kwon, President of LG Home Entertainment Company, for a panel discussion on Windows 10 and LG devices.

Windows 10 is off to a great start in Korea, with the fastest adoption the market has ever seen for Windows – five times faster than Windows 8. In Korea, there are over 22,000 different types of devices already running Windows 10 with over 1 billion hours spent on Windows 10 since launch. We’re seeing strong share growth and see great potential to grow our Windows business in Korea, while working closely with partners to increase distribution of Windows 10 devices around the world.

We were proud to join LG as they announced their new Windows 10 devices, which deliver hardware innovation and help enable new experiences made possible by Windows 10, including the Gram 13”, Gram 14”, Tabbook Duo (10.1” Tablet), and 21:9 Curved AIO. We’re also excited to share that the LG Gram will be available to purchase in Microsoft Stores this holiday.

LG gram 13″

LG PCs can be easily upgraded to Windows 10 and Brian shared that all LG PCs will be running Windows 10 by December. We’re working together to deliver their best products, including the ultrabook Gram 13” and Gram 14”, with Windows 10 around the world. These devices became available in North America last month and we look forward to bringing them to other markets, including Latin America, where LG will focus on introducing new all-in-one PCs.

We look forward to continuing to work closely with LG to deliver new and innovative experiences. For example, in August, LG shared in collaboration with KT, the world’s first Windows-based IPTV, “Olleh TV All-In-One”. This is a convergence device with a new concept, bringing the PC from individual rooms in households to the living room. U+ IPTV customers can enjoy this new device starting this month and we’ll continue to partner with LG to use Windows 10 as an IoT hub for households in the future.

Terry

Each week Bing Predicts picks the winners of every professional football game. Every Wednesday, for the rest of the season, we’ll update our prior week’s results, share our upcoming week’s predictions on Bing and provide insights into how we make our picks.

Week 6 Predictions:

For Week 6, the Bing Predicts models show that most of the undefeated teams will maintain their status with Atlanta, Cincinnati, Denver, Green Bay and New England expected to win. However, Seattle will put an end to Carolina’s undefeated season as they continue to be the dominant force between these two teams. Head-to-head, Seattle has been 5-0 since the 2010 season, including a 31-17 playoff win in Seattle last year after 3 straight road wins in the 2012, 2013 and 2014 regular seasons.

Here’s the breakdown for the other 8 games:

• Arizona travels three time zones again to win in Pittsburgh as the latter is coming off of a short week, returning from a Monday night game in San Diego.
• Baltimore wins a rematch of the big game three seasons ago, beating San Francisco in a game between two 1-4 teams, neither of which resembles the finalists from February 2013.
• Detroit will become the last team to secure a win when they beat division rival Chicago.
• Houston has beaten Jacksonville 7 of the last 9 times including a season sweep last year. The extra rest from having the prior Thursday night game will also help them.
• Minnesota will prevail at home against an unfamiliar foe in Kansas City, a team they last played more than 4 years ago (10/2/2011).
• New York comes back from a week off to beat visiting Washington.
• Philadelphiabuilds on the 29-point 2^nd half from Sunday with another win against division rival New York.
• Tennessee, recovering from back-to-back home losses which totaled a mere 3 points, beats Miami at home.

Week 5 Results:

Bing Predicts was 10-4 in Week 5, starting the week strongly with an Indianapolis upset in the Thursday night game. Sunday also turned out reasonably well (9-3). Of the four incorrect picks, two games were decided by one point each (Kansas City and Tennessee), one lost in overtime (Baltimore), and the fourth was decided on the final play of the weekend (San Diego). The 10-4 record from Week 5 brings Bing Predicts to 48-29 for the season.

– Walter Sun, Bing Predicts Team Lead

It’s never been more important to be able to get work done and collaborate with others from anywhere—be it participating in an important meeting while traveling or sending a quick message during a coffee run. We’ve been working hard to ensure Skype for Business can make you productive on any device. Since we announced the Skype for Business for iOS preview, we’ve received great response, and today we are excited to announce that the new Skype for Business app for iOS devices is now publicly available.

Along with the following features, the new app also resolves the sign-in issues that some of you experienced with Lync 2013 on iOS 9.

Join a meeting in one touch

An updated dashboard brings the contact search bar, your upcoming meetings and most-recent conversations to one place. The contact search bar allows you to search your Global Address List by first name, last name, email alias or phone number. Your recent conversations are at your fingertips, no matter which device you had the conversation on. You can also easily glance at your upcoming appointments—simply tap on the left for the meeting details or on the icon on the right to join immediately.

Enhanced in-meeting experience

Full-screen video makes for a more immersive meeting experience. Larger buttons to mute and the ability to add participants and manage your call make it a lot easier to meet while you are on the move. Simultaneous viewing of the content being shared and speaker’s video means that you never miss a moment.

Watch for the ability to view PowerPoint slides in a meeting in a future update. In the meantime, you can view a PowerPoint presentation via desktop sharing.

Additional authentication and security options

Office 365 customers can now take advantage of Active Directory Authentication Library (ADAL)-based authentication. This enables your IT admin to configure multi-factor authentication for the Skype for Business iOS app, increasing the security beyond just a user name and password. With multi-factor authentication, users are required to acknowledge a phone call, text message or an app notification on their device after correctly entering their user name and password. Other Office applications also support ADAL-based authentication, which allows for consistent authentication across your organization. Learn more about setting up multi-factor authentication using ADAL.

How you can upgrade to the new app

The new Skype for Business iOS app is now available as a Universal app in the iTunes Store. iPhone users with Lync 2013 will automatically get updated to the Skype for Business app. iPad users with Lync 2013 need to download the new Universal app from the iTunes Store. If you are an IT admin, use the Skype for Business iOS productivity guide to learn more and prepare your users.

What’s next?

We are iterating rapidly to enrich the feature set on iOS and bring them to you as quickly as we can. Later this year, we will also make Skype for Business app for Android publicly available. Join the Skype for Business IT Pro Yammer community to subscribe to the upcoming product updates, interactive Skype broadcast sessions with the product team, and learn from the community. We look forward to hearing what’s on the top of your mind.

Start using the new app today to stay connected and productive while on the go!

—Praveen Maloo, product marketing manager for the Skype for Business team.

The post Skype for Business iOS app now available appeared first on Office Blogs.

In September 2016, Microsoft Ignite is headed to Atlanta, Georgia. Pre-register now and get ready for —

• 1,000+ hours of content, 700+ sessions, and a multitude of networking opportunities 
• Insights and roadmaps from industry leaders
• Deep dives and live demos on the products you use every day
• Direct access to product experts
• Interactive digital labs
• Knowledge and answers direct from the source
• Smart people talking tech everywhere you look

Pre-register now for the lowest price, and claim your spot in Atlanta, September 26–30, 2016.

If you want to learn more about Microsoft's event line up in 2016, check out Chris Capossela's blog post

In September 2016, Microsoft Ignite is headed to Atlanta, Georgia. Pre-register now and get ready for —

• 1,000+ hours of content, 700+ sessions, and a multitude of networking opportunities 
• Insights and roadmaps from industry leaders
• Deep dives and live demos on the products you use every day
• Direct access to product experts
• Interactive digital labs
• Knowledge and answers direct from the source
• Smart people talking tech everywhere you look

Pre-register now for the lowest price, and claim your spot in Atlanta, September 26–30, 2016.

If you want to learn more about Microsoft's event line up in 2016, check out Chris Capossela's blog post

For this post, we are glad to host Thomas Roettinger, Program Manager in Microsoft’s ECG CAT Team focusing on Cloud Solutions. Thomas announces the availability of automation solutions for centralized desktops on Microsoft Cloud Platform System.

Today we announce the availability of two new automation solutions for desktop centralization: we have just posted new samples that enable the automation of Microsoft Virtual Desktop Infrastructure (Personal and Pooled Virtual Desktops) and also of Citrix XenDesktop and Provisioning Services on CPS.

In a previous blog post, we announced self-service deployment of session-based desktops, the Remote Desktop Session Host (RDSH) functionality of Windows Server. With the availability of the new automation solutions, we are completing our support for the Microsoft Remote Desktop family, and we are also adding support for the popular Citrix solution.

Similar to our other available workload examples, you can deploy those service templates in any other Windows Azure Pack (WAP) cloud by adjusting the service templates to your environment.

1. Microsoft Virtual Desktop Infrastructure for Personal and Pooled Desktops

Microsoft Virtual Desktop Infrastructure (VDI) offers IT pros flexibility in choosing the right mix of technologies to deliver a VDI solution so they can customize the implementation to meet their organization’s needs. IT pros can deploy the appropriate type of VDI solution for their users, all from a single platform. Microsoft VDI can host personal and pooled virtual machine desktops, session-based desktops, and RemoteApp programs. See Table 2 in this TechNet article for a complete explanation of differences between personal and pooled virtual machines.

The example that is available via the Web Platform Installer enables Personal and Pooled Desktops for the needs of enterprise users. It does not enable a multi-tenant hosting scenario.

Please note that unlike the other workloads this is not a self-service deployment experience provided through WAP. Instead a consistent fabric deployment experience is provided through VMM Service Templates. In addition to the service templates, various Automation runbooks and scripts have been authored to streamline the deployment end-to-end.

The download package comes with the following VMM service Templates:

· Active Directory (optional).

· SQL Server Guest Cluster.

· Remote Desktop Virtual Desktop Infrastructure (2 Tiers).

· File Server (optional).

Deployment Overview

The workload can either leverage an existing Active Directory that contains all user identities, or a new Active Directory can be created. For the deployment, the so called “customer network” is used. The customer network is a virtualized network (NVGRE) that connects with a forwarding gateway to route into existing customer networks.

Each component is deployed with high availability through either guest clustering or load balancing using the hardware load balancer which is included with CPS.

One CPS rack supports four customer networks where each is a /23 (CIDR) subnet size. This will theoretically allow provisioning up to about 2,000 virtual desktops, depending on the desired VM sizing.

The following diagram shows the high level architecture:

Validation

The architecture and Service Template deployments (VM Sizes) have been validated using Login VSI (a performance benchmark). A “knowledge worker” workload (defined by Login VSI) has been executed with a goal to have at least 500 VDI desktops become active. In the test scenario, each virtual machine was using a VM Profile Size equal to an Azure A2 VM (2 CPUs, 3.5 GB Memory). As you can see, we are not hitting Login VSI Max and CPS has the capacity to support more than the tested number of virtual desktops.

2. XenDesktop and Provisioning Services

We have been working closely with Citrix to enable XenDesktop and Provisioning Services on CPS. The scenario that we have enabled on CPS addresses the enterprise scenario; it does not enable a multi-tenant hosting scenario.

Citrix has been doing a great job creating a VMM Service Template to deploy XenDesktop and Provisioning Services via Virtual Machine Manager.

Those service templates have been taken as the foundation and the required adjustments have been made to leverage the CPS hardware load balancer. In addition, various scripts have been authored to streamline the end to end deployment, for example, creating the VM Networks, VIP Templates, VMM Run As Account and many more.

The download package includes the following VMM service templates and can be download via the Web Platform Installer (see the link below, in the Resources section):

• Active Directory (optional)
• SQL Server Guest Cluster
• XenDesktop
• Provisioning Server

You should also be aware that with the VMM updates in System Center UR7, which is part of CPS Update 2, we introduced a new capability that is required to enabled this particular workload. The required feature enables support for VMM DHCP Extension PXE/TFTP Forwarding. For details see the VMM UR7 release notes.

Deployment Overview

The workload can either leverage an existing Active Directory that contains all user identities or a new Active Directory can be created. For the deployment the so-called “customer network” uses a virtualized network (NVGRE) that connects using a CPS forwarding gateway to route into existing customer networks.

When Provisioning Server is used, an additional streaming network gets created that will be used for the initial PXE boot of the Virtual Machine to stream the virtual hard disk. This streaming network is a virtualized network as well, but it is not routed since it is not connected to a NVGRE Gateway.

Each CPS rack can support four customer networks, where each is a /23 subnet. This will allow provisioning up to about 2,000 machines depending on customer VM sizing.

All components can be scaled out to achieve high availability using the load balancer.

The following diagram shows the high level architecture:

Next Steps

Samples

The usual reminder: these are examples for you (the service provider/enterprise private cloud admin) to customize to best suit your customers’ needs. To modify them will require an understanding of how Service Templates work, how the multiple scripting engines process scripts, and how to edit the automation artifacts. An understanding of PowerShell is also going to be a prerequisite. Pay particular attention to networking considerations.

See the Building Clouds blog and the rest of the resources at the end of this post for useful resources to guide you in the installation and customization.

Resources

Cloud Platform System

Introduction to CPS

Ignite Sessions:

•  Overview of the Microsoft Cloud Platform System
• Operating the Microsoft Cloud Platform System
• Architectural Deep Dive into the Microsoft Cloud Platform System
• Deep Dive into the Microsoft Cloud Platform System Networking
• Automating Workload Provisioning: SQL, Exchange, SharePoint and RDS on CPS.

Windows Azure Pack

• Windows Azure Pack
• Web Platform Installer

• VMM feed

• WAP Virtual Academy– you will find a whole day of WAP training here.
• Hands on Lab: Introduction to Virtual Machine Roles
• VM Role Authoring Tool
• SMA training

Remote Desktop Services

• Remote Desktop Services Overview
• Azure Desktop Hosting - Reference Architecture and Deployment Guides
• Remote Desktop Services Blog

Earlier today Microsoft announced an updated date and location for Microsoft Ignite 2016 – Atlanta on September 26-30!

For those of you not immediately familiar with this city, it’s likely that you consume at least 3 things that originate from Atlanta every day, for example: Coca-Cola, CNN, Delta Airlines, Home Depot, UPS, Chick-fil-A, Rubbermaid, etc. This all makes Atlanta the 16th largest metropolitan economy in the world– right between Sydney and Hong Kong.

I think Atlanta is going to be a very fun place to spend five very important days. And, of course, no announcement is complete without the option to pre-register right now!

The lineup for Ignite 2016 is simply incredible; you can look forward to:

• 1,000+ hours of content, 700+ sessions, and countless networking opportunities
• Insights and roadmaps from industry leaders
• Deep dives and live demos on the products you use (or want to use!) every day
• Direct access to product experts
• Interactive digital labs
• Knowledge and answers direct from the source
• Really.  Smart.  People.  Everywhere.

Take advantage of this early announcement by pre-registering now for the lowest price. I can’t wait to see everyone there! And, for those globetrotters out there who just don’t want to wait 11 months for the next Ignite, come to my keynote at Ignite Australia in just four weeks!  :)

In July, we kicked off our 12-month initiative to #UpgradeYourWorld as part of the launch of Windows 10 by celebrating people and organizations who do great things. We are thrilled about the engagement we have seen from millions of people sharing their stories and supporting nonprofit organizations around the world.

As part of our $10 million investment to amplify amazing work being done around the globe, 10 partners in 10 countries received $50,000 each. During the month of September, people in 10 countries voted for thousands of nonprofits to receive this monetary donation to continue their efforts to #UpgradeYourWorld. After calculating the final number of votes, we are thrilled to announce the five winners from each of the countries who will join the five preselected partners in each market:

We admire the dedication nonprofit organizations have to their respective causes. Last week, for example, an out-of-control fire in Australia led Edgar’s Mission founder Pam Ahern and her staff to quickly find a way to take the 200+ homeless, abused animals they provide shelter for out of harm’s way, as the fire trajectory threatened their farm. The diligence of firefighters and the persistence of those who work in this small organization ultimately managed to bring all animals to safety before the risk receded. This is just a glimpse of the hurdles that nonprofits face daily in order to fulfill their mission.

Edgar’s Mission is one of the fifty organizations chosen, in addition to the fifty nonprofits that were pre-selected in each of these countries to participate in #UpgradeYourWorld. The work that these organizations are doing is inspiring. For example:

• Empowering young women in Japan
• Innovating the way people donate money through a mobile app to fight hunger in China
• Setting up services and support for thousands of refugees in Germany
• Fighting discrimination and homophobia in France
• Securing prenatal care and early childhood health services in India
• Providing digital literacy for children living in rural and underserved communities in Kenya
• Delivering integral support for children with cancer and their families in Mexico
• Protecting the environment by promoting the reuse and recycle of goods in the United Kingdom
• Working towards suicide prevention and mental health awareness in the United States

Photo Credit: Tanya Malott

It is great to celebrate the amazing work being done by all of these organizations, but we aren’t done yet. October also marks our Upgrade Your World global partnership with the Malala Fund. Throughout the month we have been supporting their global efforts to empower girls through quality secondary education, so they can continue to have a positive impact on the communities they live in. And during the rest of the year we will continue to highlight the amazing work done by all of these organizations that are helping #UpgradeYourWorld.

Photo Credit: Malin Fezehai/HUMAN for Malala Fund

Remember to follow along here for more information on the Upgrade Your World initiative and all of our big plans to come.

Please continue to share your stories about how you are working to #UpgradeYourWorld by using the hashtag.

One of the things I forgot to mention in my post about TFS 2015 Update 1 RC is that we have also shipped a preview of our new TFS Office Integration Installer.  This new installer addresses a couple of scenarios:

1. People like project managers, BAs, etc that wanted to use our Microsoft Office integration capabilities used to have to install our Team Explorer package.  It was uncomfortably large and included a VS Shell instance that most of them really didn't want.  This new installer just includes the Office integration component (Excel, Project, etc) and is therefore lighter weight.
2. We announced with the release of TFS 2015 the intent to make our PowerPoint storyboarding tool available without VS Enterprise/Test Professional but we didn’t provide an easy way to acquire it.  We’ve now included it in this Office Integration Installer, making it very easy to get with the rest of the Office integration tools.

The PowerPoint storyboarding tool is a really nice way to mock up user experiences quickly and easily.  You can leverage the PowerPoint skills you already have to build nice walk throughs of user flows before you invest in building them.  In building TFS and VSO, we use is all the time.  Here’s an example PowerPoint mockup from one of our walk-throughs of our new dashboarding feature that’s in progress.

Right now, it’s buried on the VS 2015 Update 1 RC download page but we’ll add a new page to make it easier to find, understand what’s in it and download.

Like most things we release, it will also work with previous releases on Team Foundation Server (you don’t have to be on TFS 2015 to use it).  I don’t recall the precise requirement but it certainly works back to TFS 2012.  And, of course, it works with VS Online.

I hope this makes your TFS experience even better.

Brian

v7.8 of the calculator introduces support for Exchange 2016! Yes, that’s right, you don’t need a separate calculator, v7.8 and later supports Exchange 2013 or Exchange 2016 deployments. Moving forward, the calculator is branded as the Exchange Server Role Requirements Calculator.

When you open the calculator you will find a new drop-down option in the Input tab that allows you to select the deployment version. Simply choose 2013 or 2016:

When you choose 2016, you will notice the Server Multi-Role Configuration option is disabled due to the fact that Exchange 2016 no longer provides the Client Access Server role.

As discussed in the Exchange 2016 Architecture and Preferred Architecture articles, the volume format best practice recommendation for Exchange data volumes has changed in Exchange 2016 as we now recommend ReFS (with the integrity feature disabled). By default, for Exchange 2016 deployments, the calculator scripts will default to ReFS (Exchange 2013 deployments will default to NTFS). This is exposed in the Export Mount Points File dialog:

The DiskPart.ps1 and CreateDag.ps1 scripts have been updated to support formatting the volume as ReFS (and disabling the integrity feature at the volume level) and enabling AutoReseed support for ReFS.

This release also improves the inputs of all dialogs for the distribution scripts by persisting values across the various dialogs (e.g., global catalog values).

For all the other improvements and bug fixes, please review the Release Notes, or download the update directly.

As always we welcome feedback and please report any issues you may encounter while using the calculator by emailing strgcalc AT microsoft DOT com.

Ross Smith IV
Principal Program Manager
Office 365 Customer Experience

Uh oh. You are probably thinking to yourself, here comes another one of those incredibly long blog posts about sizing. Thankfully, it’s not. If you want to fully understand the sizing process for Exchange 2016, you are certainly welcome to read the previous post that I did for Exchange 2013, as the overall process is effectively the same with one major caveat. Since we have eliminated the CAS role in Exchange 2016, you must follow the process for multi-role deployment sizing.

Overall, the inputs to our sizing formulas stay the same from Exchange 2013 to Exchange 2016. This means that our IOPS requirements, memory requirements, and all of the other values provided in the Exchange 2013 sizing guidance should continue to be used for Exchange 2016. We are changing one set of inputs, however.

Processor requirements

We are slightly increasing the processor requirements for Exchange 2016 (compared to Exchange 2013) as this is a very new release, and we are still learning how it performs in production. This slight increase in CPU provides some additional headroom for unanticipated issues, and may be changed in the future as we learn more from our internal deployments as well as customer feedback. The same SPECint_rate2006 baseline value described in the Exchange 2013 guidance should continue to be used (33.75 per-core).

These changes are reflected in v7.8 and later in the calculator.

System scalability

The previously released guidance on maximum recommended cores and maximum memory size for Exchange 2013 also applies to Exchange 2016. As we continue to evolve the hardware platform that we use for Exchange Online, we will update this guidance, but for now you should be planning deployments around these existing recommendations.

Summary

If you are at all familiar with the process for sizing the last couple of Exchange releases, you will be very comfortable with Exchange 2016. As with any new release, you should plan to roll-out in stages and monitor the health and performance of the solution carefully. We do expect that our performance and scalability guidance for Exchange 2016 will evolve over the lifespan of the product so watch the Exchange team blog for future updates.

Jeff Mealiffe
Principal PM Manager
Office 365 Customer Experience

This week’s episode of the “Lunch Break” series is part 2 of my discussion with Rajesh Jha, the Corp. VP responsible for Office 365 and Exchange.

In part two of our convo we discuss:

• Rajesh’s first job out of college 25 years ago.
• Why the importance of managed e-mail is becoming such a popular topic.
• The arguably tense first meeting we had together.
• How to balance user empowerment and data security.
• The advice Rajesh would give himself today on the first day of college.
  

Next week, I ride with Prof. Ed Lazowska from the University of Washington’s Computer Science & Engineering department.  Prof. Lazowska is a genuine pioneer in the computer science community, and it was an honor to get to spend some time together.

You can subscribe to these videos here.