Back

Microsoft Build 2018 Retrospective

Neil McAlister • Software Developer

Every year, Futurice sends developers to events all around the world, so that we can keep ourselves up to date on new and upcoming technologies. One shindig we try to attend every year is Microsoft’s Build. This year, that particular privelege was mine!

dsc 0103-e18f1d52-2505-426e-9df1-66f0f2030ff3 s1800x0 q80 noupscale

It's quite the hike from Helsinki to Seattle, and between that and the schedule conflict with Google IO, I traveled alone. Fortunately, I’d been to Seattle before, so I wasn’t completely lost and confused!

In General

So, details. This year’s Build was heavily focused on AI, Machine Learning and Azure. There was also a significant focus on new and upcoming Windows features, and my own personal conference route ended with a focus on Xamarin and .NET. As such, I’ll try to group my takeaways by category, rather than by day.

Before we really get started, I have a few small observations that don’t really fit anywhere else.

Accessibility

One thing that really impressed me was that Microsoft is making a very real and concerted effort to improve accessibility in its products. One great example is that they’ve been investing in their development frameworks: for example, every update to the UWP SDK has included significant changes to allow for development of accessible apps, and the UWP docs have included comprehensive accessibility design guidelines since the Anniversary update. Another standout example of such is the Seeing AI app, explicitly designed as a companion for blind or low-vision people. The recently-released Visual Studio Live Share is an excellent example of all this--it allows pair-programming without demanding that any developer leave a development environment that’s comfortable and accessible to them.

Diversity

Another thing that stood out was that Microsoft seems to be making a real effort at diversity in its corporate culture. From little things like preferred-pronoun badge stickers being available in a central location, to larger things like a prominent Women & Nonbinary event during the conference, I was very impressed. While I’m only speaking as an outsider, it certainly felt like more than just lip service.

Machine Learning and AI

Machine Learning and AI were definitely the stars at this year’s Build. I came in very skeptical of this, believing it to be just another fad (who remembers 3D TVs?). However, after seeing some applications of machine learning in action at Build, I think I’ve been converted.

The basic idea is: a) you have a need to classify things somehow, except b) it's difficult (or even impossible!) to codify the exact business requirements in a way that you can turn into an algorithm. So, c) you take some sample data, feed it to a magic box, tell it which criteria to use, and d) it spits out an algorithm that can do classification for you. Obviously a lot more careful consideration and iteration and training are necessary, but that’s the thousand-foot view.

By way of example, Scott Hanselman did a great demo on stage with the .NET Core repo. They sort issues by the namespaces of the classes that influence the described issue. Classifying issues was a slow, manual process. So they took a big .csv file of all the historical, already-classified issues, fed it to the machine learning service, and it spat out a model that they then used to classify new issues into the correct namespaces.

Powering this demo was ML.NET, a .NET SDK that makes generating and interacting with ML models easier. It allows you to feed in training data, then tell it how to generate a model, and then use that generated model to predict things. It even works in offline scenarios once the model has been generated!

One really cool example of all this is how they used a customized implementation of the Speech to Text Cognitive Service. All the talks at Build had a little scrolling window on the presentation screens with real-time(ish, it was delayed by 2-5 seconds) speech to text. On Day 1, for the keynote, I actually thought it was a human doing standard closed captions, until I realized it was present for all talks. It worked extremely well, especially for certain speakers who they’d clearly trained it on.

C# and .NET

Some cool stuff here--a few pieces of speculation, some cool stuff for Windows developers eyeing .NET Core, and some nice quality of life improvements.

C#’s Future

Most of the stuff coming in, or proposed for, C# 8.0 is viewable in the open on GitHub, so I won't repeat it here. Some of this was talked about at Build, but since it’s all in the open anyway, I skipped out. I did, however, have an opportunity to chat with one of the Roslyn/C# devs on the exhibition floor about my favorite pet feature: discriminated unions! In a happy coincidence, it was also one of his favorite pet features, and he’d been working on getting it included in the language. There’s a tracking issue for it on GitHub and, while of course there are no promises to be had anywhere, it does seem possible that we’ll see this land in C# 9.x. Fingers crossed!

.NET Core 3

WPF and WinForms will be able to run on .NET Core 3. I think the writing on the wall is pretty clear--the Windows-only Big .NET Framework is being gently packed off to a tropical coast for retirement somewhere. Meanwhile, its cooler, younger brother .NET Core will be the way forward for the foreseeable future.

One neat little feature that seems to have gotten lost in the shuffle is that these .NET Core 3 WinForms and WPF applications will be able to be distributed as self-contained executables--single, chunky executable files that include the WinForms or WPF runtimes with them. Still Windows-only though.

.NET Core 3 will also include a turbocharged debugging experience for ASP.NET Core. Scott Hanselman and Scott Hunter demoed this on stage. There are two major improvements here: First, a CLI-like debugging experience that allows you to see available routes, and hit them with sample data, no browser necessary. Second, Swagger will be included and enabled by default.

czaz9bikqw1wi1gzhlracg-835b0dba-4634-4d18-85c4-5eba3a2414a7 s1800x0 q80 noupscale

UWP

Some really neat flagship features here. It feels like now that the framework is in a reasonably featureful state, they're spending a lot of time polishing it to a fine sheen. They're addressing a lot of common requests, and giving people paths to migrate old apps forward.

They finally caved on making UWP more desktop-friendly by making it default to a 20% more compact view. You also have the option to switch to a more "classic-desktop-compactness" sort of appearance with platform-provided ResourceDictionaries you can merge into your project's global ResourceDictionary, which then adjusts all the default margins and padding.

UWP controls can now be used in WPF and WinForms apps through the use of so-called "XAML Islands". This will work for both first-party controls, and user-written custom controls. Currently, the feature is only barely available, but the promise is that once complete, you’ll be able to host any UWP control in a WinForms or UWP application.

Future UWP controls will be released with a support shim that allows them to be used on previous versions of Windows 10. This will probably be in the form of NuGet packages. They're not sure how far back each control will support, but their current thinking is N-2 versions of Windows. This would mean that something like the NavigationView, which was only introduced in the Fall Creator’s Update, would be available as far back as the Anniversary Update. Supposedly, it would gracefully degrade the further back you go, so that you’d get the same API surface and functionality, and only lose out on cosmetic features.

They're doing a fair amount of work on simplifying lots of really common tasks. In particular, they went over some neat {x:Bind} improvements that cover all the use cases of ye olde MultiBinding from the WPF days. For example, {x:Bind} to methods will now track property changed notifications for those methods--so you can fire a PropertyChanged event with the name of the method, and anything {x:Bound} to that method will re-evaluate itself.

Custom XAML markup extensions got added back in the Fall Creator's Update, and now they're improving it by (re)introducing IServiceProvider as one of the parameters in the ProvideValue() method! This should make a lot of Silverlight and WPF developers very happy. I've heard more than one story where this was one of the last things blocking them from making the jump to UWP.

dsc 0127-6485bdd7-9a41-4be3-a5f5-e184bb9d8b63 s1800x0 q80 noupscale

They're also adding XAML support for Implicit Composition Animations, which is super cool. I managed to snap a picture of one of the example slides:

implicit-xaml-15f93948-5fc8-4707-983e-69af265921dc s1800x0 q80 noupscale

Which means that you'll be able to define Visual States, and not need to painstakingly define transitions between them, as long as they're not too compex! Hooray!

Xamarin

I spent a fair bit of time at the Xamarin booth, and learned all kinds of things about upcoming new stuff.

Xamarin Forms 3.0 went live, and includes lots of cool new features. My personal favorite is the inclusion of a Visual State Manager. Other pieces of goodness include CSS support, and a FlexLayout control that acts a lot like the web’s FlexBox.

One of the really exciting things that I learned was that there are lots and lots of plans in the near-to-medium-term future for API cleanup and performance improvements. There are plans to completely rewrite the Xamarin Forms ListView, and an experimental effort to allow unified styling and templating, instead of delegating those things to the underlying platforms. There was also some rumbling of unifying things along a shared navigation model, and an in-progress effort along those lines. In addition, there’s also some possibility of a unified drawing API, which would allow some of the unified styling and templating I mentioned above, and would make the Skia backend do the drawing instead of the platforms, similar to what Flutter does. I was able to see a sneak-preview of some of these things, but unfortunately can't share more.

Xamarin Forms 3.0 also supports Xamarin Live Reload, which is meant to be a more robust successor to the Live Previewer. I haven’t had a chance to try it yet, but it certainly sounds promising, especially after I was somewhat disappointed in the Live Previewer. It currently only listens to XAML files changing. Changing C# code will require a redeploy. However, it's said to support {StaticResource} lookup, and data binding.

And as a final, fun little note, it turns out there’s a cool library that bundles together a lot of cross-platform plugins into a one-stop-shop: Xamarin Essentials. Definitely using this in the future.

Windows

I didn’t pay a lot of attention to these particulars, as most of our clients aren’t interested in Windows-specific development, but as a Windows user, I kept an eye out for interesting things.

Sets

An upcoming feature for some as-yet-undetermined future version of Windows. This feels like it’ll be a pretty fundamental change to the way UI works--it’s basically Tabs for All The Things. By default (almost) all windows will have a tab strip along their top, and you’ll be able to dock (almost) any window into that tab grouping (called a Set). This is available in a limited rollout now, for Windows Insider builds.

It’ll work out of the box for any UWP app, and any Win32 app that doesn’t modify its title bar.

It also integrates with…

Timeline

This went live with the Windows update that came out earlier this April. In short, it’s a way to sync user activities between devices via a Microsoft Account. It works between Windows PCs natively, and with Android devices via the Microsoft Launcher, and iOS devices via Edge. Today, it syncs “activities”--developer-definable units of work that define “this app, in this state”. Just looking at my current timeline on my work machine, it looks like it doesn’t even necessarily need developer intervention for basic support; I’m seeing Notepad++ instances showing up in timeline, and I’d be shocked if it had actually updated to include timeline support already.

In the future, it’ll also allow the syncing of Sets, which is very interesting. It’d be nice to be able to persist a “dev” Set between machines, for example. I can also guarantee that Office is going to be the headliner for this feature--people being able to sync editing progress between devices is going to be a hit for lots of people.

Windows on ARM

Windows on ARM devices were released to little fanfare late last year, and are still in a fairly larval state. They work with any UWP app (as those support ARM natively), x86 app (by way of emulation), and ARM-compiled Windows applications. I asked about the lack of x64 support, and was told that a) most apps still have a 32-bit version, and that b) any app that doesn't have a 32-bit version probably doesn't fit the usage profile of the kind of person this machine appeals to anyway. It's something they could do, but it's not actively on their roadmap. I imagine that if 64-bit app adoption spikes, they'll revisit it, but it doesn't sound like it'll be any time soon under current conditions.

Interestingly, OEMs seem eager to try to make it work: HP, Asus, Lenovo, and now HP all have devices either on the market or in the pipeline, and Qualcomm just announced the Snapdragon 850, a chipset apparently designed for this sort of workload.

Also, after a long delay, it looks like the MSVC ARM64 compiler is finally shipping in Visual Studio 2017, so that’s one less barrier to getting applications for those machines working.

Mixed Reality

I didn't spend much time on this subject at Build, but I did learn one thing of interest. They're working on expanding UWP's XAML framework to be able to straddle a middle ground between flat billboard "traditional" 2D and full 3D. The framework will soon have a concept of depth and Z-layering, as well as a global light source. This lets you create some interesting depth and parallax effects. In addition, they're exploring the ability to display 3D models with the same ease as 2D controls are displayed now.

Given how inexpensive Windows MR headsets are compared to a HoloLens, Vive or Oculus Rift, this might be a cheaper and simpler alternative to creating a full Unity application. This would be especially beneficial for applications that don't need the power of a full 3D environment, but still want 3D-like effects.

Wrapping Up

I'm very intrigued by the things I saw this year. Machine Learning and AI seem to be ascendant, and (much to my surprise) not snake oil. Windows is making baby steps toward multi-device handoff, with Timelines and Sets. Xamarin looks like it's making a serious effort at addressing many of its criticisms, and is only going to get easier to recommend. UWP seems to be finally addressing many of its criticisms as well, and is making real inroads into becoming a worthy successor to WPF. C# and .NET both continue their march to excellence, to basically nobody's surprise.

I had a blast visiting, and I met a lot of smart and interesting people. I hope to be able to visit again in the future!

If you have any questions or feedback on all the shiny newness in this post, feel free to drop me a line at neil.mcalister@futurice.com, or @pingzingy on Twitter!