Cumulative Update rolling out to Insiders in Slow ring

Hello Windows Insiders,

If you are in the Slow ring, we’ve released KB4022716 to keep you up to date with the latest Windows 10 Creators Update fixes as we prepare to release a new Windows 10 Fall Creators Update build in the coming weeks. As a result of receiving this update, your PC will be required to reboot to complete the update.

With the forth coming release of a new Windows 10 Fall Creators Update build to the Slow ring, we are testing a new update targeting framework and will be delivering the build in staggered phases. This will simulate the rollout process we use when we release major Windows 10 feature updates to retail customers.

When we release a new Windows 10 Fall Creators Update build to Insiders in the Slow ring, they can wait to be targeted to install the new build, or instead of waiting Insiders can manually check for updates via Windows Update to get the new build. We know this is different from our usual “everyone at once” model to the WIP rings, however this testing will provide invaluable insights to ensure this new targeting framework is functioning as expected.

We thank you for your patience while we complete this testing!

Keep hustling team,
Dona <3

How can IT put PowerShell Integrated Scripting Environment to use?

PowerShell Integrated Scripting Environment is a tool that can benefit all levels of users, which is why many developers and administrators use it almost exclusively when working with PowerShell — often skipping the original console altogether.

With PowerShell ISE, which provides a graphical user interface (GUI) for writing and fixing PowerShell scripts, IT administrators and developers can write, edit and run PowerShell scripts and commands. It provides a more user-friendly way to work with the wide range of features available for creating and testing PowerShell codes.

For example, PowerShell ISE includes IntelliSense for autocompleting commands and for matching cmdlets, variables, parameters and other language elements. The GUI also provides quick access to a variety of snippets that make it easier to construct command logic, such as looping structures. In addition, admins get multiple execution environments, selective code execution and the ability to run commands from either the PowerShell script or the console pane.

What else can PowerShell ISE do?

PowerShell script development

PowerShell Integrated Scripting Environment provides many other features to support PowerShell script development, such as drag-and-drop editing, tab completion, block selection, syntax coloring, keyboard shortcuts and Unicode support. Plus, admins can open PowerShell script files by dragging them from Windows Explorer to the PowerShell ISE GUI. They can even extend the PowerShell Integrated Scripting Environment object model to customize the deployment and add functionality.

Troubleshooting

Admins can also use PowerShell Integrated Scripting Environment to troubleshoot and debug PowerShell scripts. Although this goes hand in hand with script development, sometimes admins must fix an existing script and want to use PowerShell ISE’s debugging capabilities. Not only do they get features such as selective execution and multiple execution environments, but they can also set up breakpoints, step through code, check variable values and display call stacks. In addition, PowerShell Integrated Scripting Environment displays parsing errors as admins type.

PowerShell Integrated Scripting Environment is also useful as a learning tool.

Running complicated commands

Admins might also use PowerShell Integrated Scripting Environment when they want to run complex ad hoc commands and prefer to avoid the inherent clunkiness of the PowerShell console. With PowerShell ISE, they can type all their code in the script pane and then, when they’re ready, run part or all of the code. This also makes it easier to tweak the script if admins need to run it multiple times, incorporating slight modifications with each execution.

Learning

PowerShell Integrated Scripting Environment is also useful as a learning tool. Someone new to PowerShell can benefit a great deal from built-in features, such as IntelliSense, snippet access and parse error displays.

Powered by WPeMatico

Tricks and tools to prevent data loss in Office 365

online service, instead of wrestling with day-to-day tasks. This doesn’t mean that IT teams can ignore the possibility of data loss in Office 365.

While there is a sense of security that comes with a cloud service, organizations need to develop their own data retention plans for some Office 365 features.

Businesses rely on their email systems to stay in touch with employees, clients and suppliers. SharePoint remains an integral component for enterprise content management in many organizations. Companies that shift these workloads — and their data — to Microsoft’s cloud platform should be aware that email and content stored in SharePoint or OneDrive are not, by default, protected against accidental or intentional deletions.

With a move to Office 365, some in IT have abandoned disaster recovery (DR) and business continuity plans (BCP) that were required to recover on-premises email and SharePoint platforms. IT teams only need redundant connectivity to the cloud and must trust that Microsoft’s infrastructure, data centers and systems will provide necessary data protection from hardware and software failures.

In Exchange Online, IT teams can only restore an entire mailbox within 30 days after deletion; after that point, they can ask Microsoft for an additional 14 days for a 44-day window of data recovery. SharePoint and OneDrive face similar challenges, as they do not offer easy or efficient ways to restore site collections or lists that have been deleted and removed from the recycle bin.

Filling Office 365’s DR and BCP gaps

Many companies have gaps in their DR plans; an inability to restore data from a specific point of time can lead to risks. While Microsoft offers service-level agreements of 99.9%, Office 365 has limited capabilities around backups — even though some suggest that on-hold features and retention or preservation policies can prevent data loss in Office 365. These options, however, are limited and do not offer easy ways to recover or restore data.

There are several tools on the market – based both in the cloud and on premises — for Office 365 data protection and DR, including SkyKick, Datto, Spanning and AvePoint. These tools offer automated backup of emails, calendars, OneDrive and, in some cases, SharePoint site collections — without the need for any on-premises infrastructure.

Many of the third-party tools can help IT address some of their backup needs around the Office 365 workloads — email, SharePoint and OneDrive. Admins can be confident that some of their digital assets are protected and that their DR plans are complete. But, in reality, as more users expand into other Office 365 services — such as Planner, Office Groups, PowerApps and Flow — Microsoft or other third-party tools need to play catch-up to protect data stored in those services. Currently, those services don’t offer any backup methods.

When evaluating Office 365, plan for Office 365 backups and implement them immediately after going live. Skipping that step would lead to serious risks and an incomplete DR plan. Those organizations that make the switch without the use of backup services put themselves at risk for data loss in Office 365.

Powered by WPeMatico

Smooth Interaction and Motion with the Visual Layer in Windows 10 Creators Update

The Composition APIs come with a robust animation engine that provides quick and fluid motion running in a separate process from your Universal Windows Platform (UWP) app. This ensures a consistent 60 frames per second when running your app on an IoT device as well as on a screaming gaming machine. It is, quite simply, fast. This is an essential capability for implementing the Fluent Design System which calls on us to create a sense of cinematic motion in our UWP apps.

The Composition APIs also provide something you probably have never had access to before: the ability to create high-performing, low-level manipulation-driven custom animations like the one shown above.  In the same way that we that want our visuals to be fast and smooth, we want our touch interactions to be sticky and responsive. Moving a visual with a finger or a digital pen should result in the visual element clinging to us no matter how fast we push and pull it across the display.

Even if a motion looks good, it also needs to feel good under the finger. It needs to maintain the illusion that we are interacting with a real object. It ought to possess the proper physics so that when we drag a visual across the screen and let go, it continues with the proper inertial movement. Similarly, user controls should provide the right amount of resistance when we pull and release them.

A fast and fluid animation system

The Visual Layer supports both keyframe animations as well as expression animations. If you have worked with XAML animations before, then you are probably already familiar with how keyframes work. In a keyframe animation, you set values for some property you want to change over time and also assign the duration for the change: in the example below, a start value, a middle value and then an ending value. The animation system will take care of tweening your animation – in other words, generating all the values between the ones you have explicitly specified based on the easing function you select. Whether Linear, or a Cubic Bezier, the animation system will use that to determine the values when interpolating.


CubicBezierEasingFunction cubicBezier = _compositor.CreateCubicBezierEasingFunction(new Vector2(.17f, .67f), new Vector2(1f, 1f));
ScalarKeyFrameAnimation blurAnimation = _compositor.CreateScalarKeyFrameAnimation();
blurAnimation.InsertKeyFrame(0.0f, 0.0f);
blurAnimation.InsertKeyFrame(0.5f, 100.0f);
blurAnimation.InsertKeyFrame(1.0f, 0.0f);
blurAnimation.Duration = TimeSpan.FromSeconds(4);
blurAnimation.IterationBehavior = AnimationIterationBehavior.Forever;
_brush.StartAnimation(&amp;quot;Blur.BlurAmount&amp;quot;, blurAnimation);

A keyframe animation is a fire-and-forget mechanism that is time based. There are situations, however, when you need your animations to be coordinated and driving each other instead of simply moving in synchronized fashion.

In the animation above (source code), each gray gear is animated based on the animation of the gear preceding it. If the preceding gear suddenly goes faster or reverses direction, it forces the following gear to do the same. Keyframe animations can’t create motion effects that work in this way, but expression animations can. They are able to do so because, while keyframe animations are time based, expression animations are reference based.

The critical code that hooks up the gears for animation is found in the following code sample, which uses the new Expression Builder Library—an open source component released alongside of the Creators Update to construct expression animations. The expression below says that the animation should reference and be driven by the RotationAngleInDegrees property of the Visual that is indicated by the parameter “previousGear”. In the next line, the current Visual’s RotationAngleInDegrees property is finally animated based on the value referred to in an expression.


private void ConfigureGearAnimation(Visual currentGear, Visual previousGear)
{
    // If rotation expression is null then create an expression of a gear rotating the opposite direction

    var _rotateExpression = previousGear.GetReference().RotationAngleInDegrees;

    // Start the animation based on the Rotation Angle in Degrees.
    currentGear.StartAnimation(&amp;quot;RotationAngleInDegrees&amp;quot;, _rotateExpression);
}

But if an animation can be driven by another animation, you may be wondering, couldn’t we also drive an animation with something more concrete like user input? Why, yes. Yes, we can.

The beauty of the ScrollViewer ManipulationPropertySet

Driving an animation from a ScrollViewer using XAML-Composition interop is fairly easy. With just a few lines of code, you can enhance the visuals of a pre-existing ScrollViewer control with a CompositionAnimation by taking advantage of the GetScrollViewerManipulationPropertySet method on the ElementCompositionPreview class. Using an animation expression, you can tie your animation to the Position of your ScrollViewer component.

You would use this technique if you wanted to add a parallax effect to your XAML or to create a sticky header that stays in place as content scrolls beneath it. In the demo illustrated below (source code), a ScrollViewer is even used to drive a parallax effect on a ListView.

Adding parallax behavior to a XAML page can be accomplished in just a few lines.


// Note: We're not using the ScrollViewer's offset values directly. Instead, we use this PropertySet which holds the position values of the ScrollViewer in real-time.
var scrollPropSet = _scrollProperties.GetSpecializedReference&amp;lt;ManipulationPropertySetReferenceNode&amp;gt;();
var startOffset = ExpressionValues.Constant.CreateConstantScalar(&amp;quot;startOffset&amp;quot;, 0.0f);
var parallaxValue = 0.5f;
var itemHeight = 0.0f;
var parallax = (scrollPropSet.Translation.Y + startOffset - (0.5f * itemHeight));
_parallaxExpression = parallax * parallaxValue - parallax;
_parallaxExpression.SetScalarParameter(&amp;quot;StartOffset&amp;quot;, (float)args.ItemIndex * visual.Size.Y / 4.0f);
visual.StartAnimation(&amp;quot;Offset.Y&amp;quot;, _parallaxExpression);

The even more beautiful InteractionTracker

Driving expression animations with a ScrollViewer is extremely powerful, but what if you want to drive animations using touch gestures that aren’t limited to a pan/zoom gesture? Additionally, when using the ScrollViewer’s manipulations, your animations are linked to the UI thread responsiveness and can lose that buttery-smooth feel when the UI thread gets bogged down.

What if you want to pull items toward you with your finger, as in the demo below (source code), or animate multiple flying images across and into the screen as happens in the demo at the top of this post (source code)?

In order to achieve these effects, you would use the new InteractionTracker and VisualInteractionSource classes. InteractionTracker is a state machine that can be driven by active input. InteractionTracker also maintains a series of properties like Position and ScalePosition as part of maintaining the state. This is what you hook up to your animations. The VisualInteractionSource class, on the other hand, determines what kind of input you will use to drive your InteractionTracker and also when to start handling input (touch in particular).

The following sample code demonstrates a basic implementation of an InteractionTracker. The viewportVisual is simply the backing Visual for the root element on the page. You use this as the VisualInteractionSource for the tracker. In doing so, you specify that you are tracking X and Y manipulations. You also indicate that you want to track inertial movement.


_tracker = InteractionTracker.Create(_compositor);

var interactionSource = VisualInteractionSource.Create(viewportVisual);

interactionSource.PositionXSourceMode = InteractionSourceMode.EnabledWithInertia;
interactionSource.PositionYSourceMode = InteractionSourceMode.EnabledWithInertia;

_tracker.InteractionSources.Add(interactionSource);

Hooking the tracker up to an expression animation works basically the same way as hooking up a gear Visual to another gear Visual, as you did earlier. You call the CreateExpressionAnimation factory method on the current Compositor and reference the Position property of the tracker.


ar positionExpression = _compositor.CreateExpressionAnimation(&amp;quot;-tracker.Position&amp;quot;);
positionExpression.SetReferenceParameter(&amp;quot;tracker&amp;quot;, _tracker);

contentVisual.StartAnimation(&amp;quot;Offset&amp;quot;, positionExpression);

This code uses the InteractionTracker’s position to produce a smooth animation for the Offset of the Visual. You can also power your Blur and Opacity animations for your other Visuals as well. This will have a result where all three animations work together, with values based on how far the user dragged their finger, to result in an amazingly fluid visual experience. Run the demo and try it for yourself (source code).

Those are the basics of driving any animation from any input. What you do with this amazing new power is entirely up to you.

Wrapping up

Expression animations and Visual Layer Interactions are both topics that can become very deep very fast. To help you through these deeper waters, we highly recommend the following videos and articles: