Starting June 1^st, Xamarin University’s team of mobile experts – including special guest and author Charles Petzold – will host five new demo-packed webinars, designed to show you how to use Visual Studio Tools for Xamarin to deliver fully native mobile apps for iOS, Android, Windows, and more.

Join a new topic every Thursday. Topics range from learning how to get the most out of Visual Studio 2017’s latest features to building cloud-connected games to adding intelligence with Azure Machine Learning. You will get the training, samples, and advice you need to ship amazing apps using Visual Studio and C#. Every session is totally free, open to everyone, and Xamarin University experts will be on hand to answer all your questions live.

Sign up for the series now. Register even if you’re unable to attend a session, you’ll receive the recordings following each air date.

• June 1^st 9 am PDT: Introduction to Xamarin.Forms for Visual Studio 2017 – Learn how to take your .NET skills mobile with Visual Studio 2017 and Xamarin.Forms. Jesse Dietrichson, a Xamarin University instructor, will show you how to use the latest Visual Studio features to maximize code re-usage and design, develop, and test fully native apps for Android, iOS, and Windows, faster than ever.
• June 8^th 9 am PDT: Building games for iOS, macOS, and tvOS with Visual Studio and Azure – Create multiplayer games for the latest Apple devices, from iPhone to tvOS, with René Ruppert, Xamarin University instructor. He’ll teach SpriteKit basics, integration with cloud back-end services, and show you best practices for sharing C# game logic, UI, and infrastructure code cross-platform.
• June 15^th 9 am PDT: SkiaSharp Graphics for Xamarin.Forms – Get serious about graphics with special guest and popular author, Charles Petzold. You’ll learn how to use SkiaSharp, powered by Google’s Skia graphics library, to extend your Xamarin.Forms apps with compelling 2D graphics.
• June 22^nd 9 am PDT: Customizing Xamarin.Forms UI – Embed native Android and iOS controls into your Xamarin.Forms apps. Join Rob Gibbens, Xamarin University training manager, to see how to integrate native controls and adjust visual properties unique to each platform – while still sharing the majority of your code. You’ll get the step-by-step guidance you need to take full advantage of the latest OS-specific UI patterns and designs.
• June 29^th 9 am PDT: Introduction to Azure Machine Learning –  Start integrating intelligence and predictive analytics into your apps. Jason DeBoever, Xamarin University instructor, will introduce Machine Learning fundamentals, get you started with Azure Machine Learning Studio, and demo how to easily build your first “smart” mobile app.

Sign up today, bring your questions, and get ready to learn. We’ll see you soon!

Mark Smith, Principal Program Manager Mark leads Xamarin University, where he helps developers learn how to utilize their .NET skills to build amazing mobile apps for Android, iOS, Windows and beyond. Prior to his career at Microsoft and Xamarin (acquired by Microsoft), Mark ran a consulting business, specializing in custom development

We are delighted to announce the latest release of the SlowCheetah extension for Visual Studio. For those who are new to SlowCheetah, it’s an extension that lets you easily add transforms that enable different app settings, connection strings and more for different build configurations. You can read more here. In this release, we’ve made several improvements we’re excited to share with you.

Released from the Microsoft Repository

For the first time, SlowCheetah is being released from the Microsoft repository and all future updates will be coming from this repository. If you have any issues or suggestions, please file them in the Issues tab of this repository.

Added JSON Transforms and Support

In this latest update, we’ve added the ability to add JSON transforms, as this is a popular format for config files that weren’t yet supported in SlowCheetah. In Visual Studio 2015 and Visual Studio 2017, you’ll now be able to add both XML and JSON transforms to your projects. Additionally, SlowCheetah supports all project types that support NuGet.

Automatic NuGet Installation

Tired of having to install your NuGet packages manually to get SlowCheetah to work? We’ve added automatic NuGet installation to help streamline your process. All you need to install is the latest extension and SlowCheetah will take care of the rest. When you use SlowCheetah for the first time in a project, it will prompt you to install or update NuGet packages. Agree and you’re ready to go!

JSON Document Transforms

In adding JSON Transforms to SlowCheetah, we found that many existing processes to transform JSON files required learning a new syntax and new keywords, as well as creating a transformation file that looks quite different from your source file. To combat this, we decided to create our own process in the form of JSON Document Transforms or JDT. With JDT, you’ll use the same properties as your source file. Your transformation file will look like your source file, making it easy for you to add JSON transforms even if it’s the first time you’re trying it! Currently, JDT supports Rename, Remove, Merge, and Replace. However, it is possible to use JDT without any knowledge of its syntax, as it will use a default transformation of merging the two files if no advanced keywords are used.

Below, you’ll find an example using the default transformation, as well as Rename.

Default Merge

Source:

{
      "Version": 1,
      "Settings": {
            "Setting01" : "Default01",
            "Setting02" : "Default02"
      },
      "SupportedVersions" : [1, 2, 3]
}

Transform:

{
      "Version": 2,
      "Settings": {
            "Setting01" : "NewValue01",
            "Setting03" : "NewValue03"
      },
      "SupportedVersions" : [4, 5],
      "UseThis" : true
}

Result:

{
      // Overriden by the transformation file
      "Version": 2,
      "Settings": {
            // Overriden by the transformation file
            "Setting01" : "NewValue01",
            // Not present in the transformation file, unchanged
            "Setting02" : "Default02",
            // Added by the transformation file
            "Setting03" : "NewValue03"
      },
      // The array in the transformation file was appended
      "SupportedVersions" : [1, 2, 3, 4, 5],
      // Added by the transformation file
      "UseThis" : true
}

Rename

Source:

{
      "A" : {
            "A1" : 11,
            "A2" : {
            "A21" : 121,
            "A22" : 122
            }
      },
      "B" : [
            21,
            22
      ],
      "C" : 3
}

Transform:

{
      "@JDT.Rename" : {
            "A" : "Astar",
            "B" : "Bstar"
      }
}

Result:

{
      // Does not alter result
      "Astar" : {
            "A1" : 11,
            "A2" : {
            "A21" : 121,
            "A22" : 122
            }
      },
      // Independs on object type
      "Bstar" : [
            21,
            22
      ],
      // Does not alter siblings
      "C" : 3
}

For more information, check out our wiki on JDT.

Thanks for reading! We hope you have a transformative experience with the newest updated to SlowCheetah! If you’d like to report an issue or have a suggestion, please use the Issues tab on our GitHub to let us know. We always welcome your feedback! Allison Buchholtz-Au, Program Manager, Visual Studio Platform Allison is a Program Manager on the Visual Studio Platform team, focusing on streamlining source control workflows and supporting both our first and third party source control providers.

In case you missed it, Progress Telerik UI for Universal Windows Platform by Progress was released as free and open-source earlier this year. With more than 22 XAML controls, this news has made it easier than ever before to start building UWP apps. Rather than needing to rewrite many complex XAML controls spanning user scenarios across data management, data visualization, navigation and more, you can use Telerik’s controls for free. To get right to it, check out the Downloading and Using the Controls section in this blog post . Not only that, if you need to make modifications to the code, you can simply fork their GitHub repository and work independently.

Telerik has recently demonstrated their continued investment in providing the best possible UWP developer experience by updating their controls packages to opt into the new Visual Studio 2017 design-time experiences for XAML controls from NuGet packages. Read below to see what’s new and to learn how to try out the controls.

Design Time Tooling for XAML Controls in NuGet Packages

In the past, developers who consumed XAML controls from NuGet packages had limited design time tooling. To successfully use and discover the controls required hand editing the XAML file. With the latest version of Visual Studio 2017, we have introduced new features that controls authors can leverage to improve the design time experience for developers using their controls. Progress has partnered with us to update their Telerik UI for UWP controls packages to add Toolbox support to easily view and categorize their controls.

As soon as you reference the NuGet package in your UWP application, these new controls will appear in the Toolbox for you to use in your application. You can use these controls just like any other Toolbox control, with drag and drop support on the design surface.

Controls in Action

If you want to learn how to use Telerik UI for UWP controls in your application, download and try out their sample application. Not only is this a good way to see what the controls are capable of, but it acts as a learning tool with the code snippets available in the app itself.

Downloading and Using the Controls

If you want to use Progress’ Telerik UI for UWP controls in your next UWP application, you can do the following to get the controls in your app.

1. Make sure you are on the latest version of Visual Studio 2017 for optimal design-time experiences: https://www.visualstudio.com/
2. In your UWP app, right click on the project’s “References” node in the Solution Explorer and select “Manage NuGet Packages…”
3. Search for “Telerik.UI.for.UniversalWindowsPlatform”
4. Install the latest version of the package to get Toolbox support, and future updates
5. Open a .xaml file and observe all the controls available in your Toolbox

Feedback!

We’re constantly trying to improve the developer experience for UWP developers. If you have any feedback for us as you build UWP applications in Visual Studio, please let us know by using the Visual Studio Report a Problem feature found in the top right corner of the Visual Studio Installer, or Visual Studio itself. You can track your feedback on the developer community portal. If you’d like to provide a feature suggestion to the Visual Studio team, you can use the Visual Studio User Voice.

If you have any feedback specific to the Telerik controls, you can file an issue on their GitHub repository.

Daniel Jacobson, Program Manager for Visual Studio @pmatmic Daniel is a Program Manager on Visual Studio focused on tools for Universal Windows Platform developers and NuGet. He found his passion in software development after graduating with an M.S. in Mechanical Engineering from Case Western Reserve University in 2014.

You’ve built your web app. It’s running, and getting good traffic. Now you need to move on to solving the ‘good problems’ to have. You want to scale your app to support more users, but only at peak times. Or you need better hardware and simply don’t want to manage that hardware… or software, or even the network. What if you just want to improve your app’s reliability? Any of these may be reasons to look at hosting your app in Azure. Azure gives you a variety of hosting options so you can balance cost, performance, and ease of management; and Visual Studio makes it simple to deploy and manage your apps in Azure.

Visual Studio 2017 gives you options to publish your app directly from your desktop, or to use Visual Studio Team Services to setup a CI/CD pipeline. Need to add monitoring and diagnostics to your app? Right click to connect to the Application Insights service. Want to secure your app with Azure Active Directory? Right click and add. Need to add a SQL Database to your Azure app? You can easily make it part of your publishing process.

Publishing to Azure

Publishing your Visual Studio 2017 app to Azure is as simple as right-clicking your app’s project node and choosing to publish. From there you can choose to create new resources in Azure or select from existing resources to update your existing application. To make this work, you only need an Azure subscription, which you can set up for free with Visual Studio Dev Essentials (which will also get you access to training materials and other tools) or the free Azure trial.

Now that you are set to publish we can publish to existing resources, or we can create new resources. Choosing new resources is simple and straightforward, just find them in your subscription and you are all set. Follow the publishing steps, and in a few minutes your app will be deployed.

But what if you need to create new resources, how do you decide what resources to create? It all depends on you and your app, there is no right or wrong answer. Since the publishing steps are pretty much the same, let’s look at some of the capabilities of each hosting option:

Virtual Machines	App Service	Service Fabric	Docker & Containers
Infrastructure as a Service (IaaS) Supporting Linux and Windows VM’s Quickly move existing applications to the cloud, because you have full control over the configuration of the Virtual Machine See how to deploy your app to a Virtual Machine at: aka.ms/deployvm	Platform as a Service (PaaS) Supporting Linux and Windows OS’s Unified development and management experiences eliminate the confusion of disparate services and providers, resulting in less navigation and lower overhead See how to deploy your app to App Services at: aka.ms/deployappservice	Platform as a Service (PaaS) Build and operate always-on, scalable, distributed applications Deliver low-latency performance and efficiency at massive scale Download the Service Fabric SDK from aka.ms/servicefabricsdk See how to create your Service Fabric cluster at: aka.ms/createservicefabriccluster See how to deploy your app to Service Fabric at: aka.ms/deployservicefabric	Build and operate always-on, scalable, distributed applications Package dependencies with your apps in Docker containers for portability and predictability during development, testing, and production deployments See how to deploy your containers to Azure at: aka.ms/deploycontainer

Setting up a CI/CD pipeline to Azure

Publishing from your desktop works, but isn’t the best solution for every circumstance. For example, if you want to get your app published with every commit / check-in, or if you want to make sure every publish includes all the code from multiple developers, there is a simpler way to publish. In Visual Studio 2017 you can simply right-click on the solution and select Configure Continuous Delivery to setup that CI/CD pipeline in Visual Studio Team Services, and get your app flowing to Azure on a consistent basis.

Extending your app with Connected Services

Publishing an app is only part of the benefit of leveraging Azure. As a developer, you are concerned with things like application performance and storage. You also may want to do things like expand your app with Office 365 APIs. In Visual Studio 2017, Connected Services let you easily adopt key services in Azure by right-clicking and adding those services. These become a natural extension of your application, and configuration is completed as they are added – no need to bounce between the portal and IDE to get them setup. Keep an eye on the list of services as we are going to continue to add services and make it faster and easier to extend your app with Azure.

That’s all it takes

Publishing your app to Azure, or extending your app with Azure services is simple to do through Visual Studio 2017 or Visual Studio Team Services. Take a look at a cropped version of our infographic. You can also download the complete infographic.

Now that your app is running in Azure, you might need to do some troubleshooting. Check out the post from Dan Taylor on the Snapshot Debugger to see one of the powerful diagnostics experiences you can get when hosting your .NET app in Azure. Stay tuned for more great diagnostics experiences.

Let us know what you think. You can report problems via the Report a Problem option in the upper right corner, either from the installer or the Visual Studio IDE itself, and then track your feedback on the developer community portal. For suggestions, let us know through UserVoice.

Brian Moore, Senior Program Manager, Azure Tools Brian is a Senior Program Manager working on the Azure Tools Team in the Cloud & Enterprise Division.

Visual Studio for Mac was released just under two months ago at Build 2017, and already we’ve seen tremendous growth in .NET developers working on the Mac. Visual Studio for Mac enables you to build native apps for macOS, native mobile apps for iOS, tvOS, watchOS, and Android, using Xamarin and Xamarin.Forms; and web sites and services using ASP.NET Core. You can also use Unity to build cross-platform 3D games.

To help new Visual Studio for Mac developers get started, we’ve created some hands-on labs to walk through some of its exciting new features. The first two labs are available today, for Unity game development and connecting to Internet of Things (IoT) devices, and we’re planning to release 4 more in the coming weeks.

Lab 1: Building Games with Unity in Visual Studio for Mac

The first hands-on lab demonstrates how to build and debug Unity game projects. It guides you through 4 tasks:

1. Setting up a basic Unity project
2. Working with a 3D game scene
3. Debugging the game script
4. Exploring additional features that support game development.

Follow these instructions to download and install Unity, then use it with Visual Studio for Mac to script and debug a 3D game scene.

Lab 2: Targeting IoT Devices in Visual Studio for Mac

Our second lab shows you how to create apps that run on an IoT device – such as the popular Raspberry Pi – from Visual Studio for Mac. It guides you through 3 tasks:

1. Setting up your Raspberry Pi
2. Creating the IoT project
3. Extending your IoT app with Xamarin components to add additional features.

This functionality is currently in preview, but we’ll make sure to update the lab if any changes will be necessary when we ship it in a stable release.

Follow these instructions to write your first IoT code, then visit our IoT samples for more ideas.

Get Started

Download Visual Studio for Mac today, and visit our labs repo on GitHub to give game development a try or connect to an IoT device. With the Community Edition it is easy and free to get started. Keep an eye on this blog for more labs that demonstrate all the other great features of Visual Studio for Mac.

Craig Dunn, Principal Program Manager @conceptdev Craig works on the Mobile Developer Tools documentation team, where he enjoys writing cross-platform code for iOS, Android, Mac, and Windows platforms with Visual Studio and Xamarin.

The Visual Studio debugger is a magical beast that can save you loads of time while finding and fixing issues in your application. It is chock-full of tools that can make debugging easier… if you know they exist, and where to find them! Let’s look at 7 lesser known goodies you can use to help you #SuperChargeYourDebugging.

1. Click to Set Next Statement

Many of you may know about the context menu item Set Next Statement (Ctrl+Shift+F10) that moves the yellow arrow (the instruction pointer) to the target line of code. You may also know that you grab and drag the yellow arrow up and down in the gutter to move it. What you probably didn’t know is that as of Visual Studio 2017 version 15,3 Preview there is an even easier way to target a line and Set Next Statement.

1. Hover over the line of code where you want to move the yellow arrow.

2. Hold the CTRL key and notice the Run to Click (Run execution to here) glyph changes into the Set Next Statement glyph.

3. Click on that glyph and the yellow arrow will move to that line.

4. This line will be the next statement to execute when taking a step or pressing Continue (F5).

2. Break when a value changes

Have you been in a situation while debugging where you inspect an object’s property at one breakpoint and by the time you get to the next breakpoint that property has changed unexpectedly. You can set a breakpoint on the setter in the class, but this breaks for every instance of the object type! What if you only care about one problematic instance? When debugging C++ code, Data Breakpoints can help you out. If you are debugging managed code, you can use Make Object ID plus a Conditional Breakpoint to narrow your search for the problem area.

1. When you get to a breakpoint with the interesting instance right click on the object and select Make Object ID. This gives you a handle to that object in memory, referenced by “$1”.
2. Go to the setter of the property you care about and add a condition to the breakpoint,
   “this == $1”
3. Press Continue (F5) and now you will break in the setter when that property changes for that instance.
4. Look at the Call Stack and double click on the previous frame. This will take you to the line of code that is changing the property for this specific instance of the object.

Note: The object ID refers to the object’s address in memory and consequently will change with every new debug session. So, if you need to restart debugging, be sure to right click and re-create the object ID. The handle ($1) won’t change, so you can leave your breakpoint as is between debug sessions.

3. Reattach to Process

This is a true time-saver introduced in Visual Stuido 2017 that many of you have yet to discover. It is extremely helpful when you are working on a project where you need to use “Attach to Process” but you find yourself consistently attaching to the same thing session after session.

1. Start from the Attach to Process dialog (Ctrl+Alt+P) and select the process or processes that you want to debug and click “Attach”.
2. When you terminate that debugging session go to the Debug menu on the toolbar.
3. Click Reattach to Process or use shortcut key (Shift +Alt+P).

For more in-depth details about Reattach to Process check out this blog post.

4. Show Threads in Source

Debugging a multithreaded application is rarely easy, but when you can see in the editor what lines of code each thread in currently on, it gets a lot better.

1. In the debugger toolbar, toggle the button “Show Threads in Source”
2. A glyph will appear in the breakpoint gutter next to each line of code where at least one thread is currently stopped.
3. Hover over the thread marker icon to see the thread ids and names for all threads currently stopped on that line of code.
4. Right click on the thread to see available actions you can perform like freezing and switching the active thread.

Note: This functionality comes with some performance overhead and can feel like it slows down debugging. We recommend turning it off when you aren’t actively using it.

5. Step through one single thread without jumping around

How often are you debugging multithreaded code, when you hit your first breakpoint, take a step, and then suddenly you are stopped with the yellow arrow on another thread? The unexpected behavior comes from the breakpoint still being set and consequently being hit. By default, the debugger will stop on a breakpoint any time it is hit. This means that when you take a step, all threads are allowed to run, and one of your running threads hit this breakpoint before the step completes on your current thread. Next time you get in this situation try this:

1. Disable or delete the breakpoint that has been hit by the new thread the debugger switched to.
2. Press Continue (F5)
3. Observe how your first initial step on that first thread completes and now is the active debugging context.
4. Since your breakpoints are deleted or disabled, you can continue stepping on that single thread without interruption.

6. Debug.ListCallStacks -allThreads

When there are lots of threads, there can be lots of call stacks to figure out. You may need to inspect all of them to get a good picture of what state your application is in. You can always see a visual representation of the call stacks for each thread by using the Parallel Stacks window (Debug/Windows/ Parallel Stacks). You can also see a text based, copy/paste-able version of the call stack for each thread using the Command window.

1. Open the Command Window (View/Other Windows/Command Window).
2. Type “Debug.ListCallStacks – allThreads”
3. You can also use the popular WinDBG command “~*k”
4. See how each thread is listed with its call stack displayed in the window.

7. Side Effect Free Function Evaluation “, nse”

Have you ever innocently typed an expression into the Watch window or Immediate window, then had to deal with the side effects of a debug session where you changed the state of the application without meaning to? Often this can happen when trying to evaluate an expression that calls a function in your program and it causes side effects (state changes to the program without running the actual application). While this may be okay if you know what functions will be called, what if you’re not sure? Here is a way to evaluate expressions in C# without the risk of side effects corrupting your program.

1. You can add “, nse” (stands for “No Side Effects”) after any expression you type into the Watch window or Immediate window.
2. This will use a sandbox of sorts that will interpret the expression without causing any side effects.
3. If the expression can’t be interpreted and can only be resolved by an evaluation, it will show you an error in the window.
4. If you are sure that you want to evaluate it anyway, remove the “, nse” modifier and try again.

Learned Something? Let us know!

What is your favorite lesser known debugging feature? Comment below!

Kaycee Anderson, Program manager, Visual Studio Debugger, and Diagnostics @KayceeSue Kaycee is a program manager working on the Visual Studio Debugger. She is passionate about delighting developers with core debugging experiences to help them find and fix issues in their code faster. She wants to help you #SuperChargeYourDebugging.

We recently released the third Preview of Visual Studio 2017 version 15.3 and we would love to get your feedback! We’ve been working hard to polish up some features, address some of the issues you’ve reported, and make meaningful improvements in the product’s fundamentals such as reliability, performance, and accessibility. For details of all the goodness contained in this Preview, check out the Visual Studio 2017 version 15.3 Preview Release Notes. A few of the notable highlights include:

• Continuous Delivery Tools can now automatically build and deploy NET or ASP.NET Core projects to Azure Web App Services. This means that developers can create and configure a CI Build Definition and a Release Definition for their solution on Visual Studio Team Services without leaving the Visual Studio IDE.
• Increased visibility on extensions’ impact on Visual Studio reliability. Visual Studio has a rich ecosystem of tools and extensions that provide useful functionality to developers. But sometimes, extensions’ interactions with Visual Studio can have bugs. We already provide some diagnostics via an infobar that lets you know if an extension is slowing things down.  Now, the diagnostic system has been extended to let you know if an extension may have been involved if ever VS terminates unexpectedly.
• Lightweight solution load (LSL) has been extended to large C++ solutions, which means that these types of projects will load faster.

If you’re not familiar with Visual Studio Previews, please take a moment to read the brief Visual Studio 2017 Release Rhythm. Remember that Visual Studio 2017 Previews install side by side with released bits, so they should not impact your machine. Previews provide an opportunity for you to receive fixes faster and to try out upcoming functionality before it becomes mainstream. Similarly, the Previews enable the Visual Studio Engineering team to validate usage and detect flaws earlier in the development process. This means that we are highly attuned to feedback coming in through the Previews. It’s a virtuous win-win cycle.

Install the Visual Studio 2017 Preview today, exercise your favorite piece of functionality, and tell us what you think. You can log bugs via Report a Problem in the IDE or share a suggestion on UserVoice. You can track the bugs you log on the developer community portal.

Christine Ruana, Principal Program Manager, Visual Studio Christine is on the Visual Studio release engineering team and is responsible for making Visual Studio releases available to our customers around the world. Co-incidentally, she is celebrating her 25th year with Microsoft today.

Whether you are a full-time or occasional C++ developer, whether you are using an older Visual Studio version or are considering using Visual Studio for the first time, this blog post is for you.

In this post I share seven reasons why Visual Studio 2017 should be your first choice of IDE for C++ development (to quickly jump to each section of this blog post, follow the links below):

1. Take advantage of the latest compiler and Standard Library to write modern, portable C++ code
2. Leverage the binary compatibility for a pain-free upgrade from Visual Studio 2015
3. Be on the fastest path to the edit-build-debug inner-loop with the dramatic speedups in startup and project load
4. Enjoy the productivity enhancements in the developer inner-loop
5. Easily bring your non-MSBuild C++ projects to Visual Studio
6. Target any platform including Android, iOS, Linux, and Windows from a single IDE
7. Streamline your installation of C++ workloads

For those of you that prefer to learn more about this topic in video format, check out the 7++ reasons to move your C++ code to Visual Studio 2017 BUILD breakout session.

#1 Write modern, portable C++ code

There are multiple reasons why we choose C++ when we write code: code portability, runtime performance or low power consumption. At the end of the day, many of us also love writing C++, and it is our desire to better ourselves to write modern C++.

C++ Conformance

Visual Studio 2017 comes with a big update in terms of C++ language conformance. It supplies a close to complete list of new features in the C++11 and C++14 standards. Only three features remain unimplemented: two-phase name lookup from C++98, a conforming preprocessor, and a complete implementation of Expression SFINAE. Visual Studio 2017 also makes great progress towards C++17 with many new compiler and libraries features.

The C++ team will continue its work on C++17 and the C++ compiler rejuvenation effort will bring the missing C++98 features. In addition, Visual Studio 2017 comes with support for several C++ Technical Specifications:

• C++ Coroutines TS (with boost::asio, with libuv)
• C++ Modules TS (experimental)
• C++ Concepts TS (coming soon!)

I encourage you to try them all and provide feedback to the Standards body before they become part of the C++ standard.

C++ Core Guidelines, Checkers, and Support Library

If you are looking for guidance on how to write modern C++, a group led by Bjarne Stroustrup created the C++ Core Guidelines with the goal of helping people use modern C++ effectively.

To help with the adoption of the C++ Core Guidelines in your organization, Visual Studio 2017 ships with C++ Code Analysis tools (known as C++ Core Checkers) that validate your code against the guidelines, running bounds checks, type checks (including const checks) and resource management checks and then making suggestions on how to improve your code. The links in each suggestion point to the relevant parts of the guideline document that discuss the specific suggestion.

The C++ Core Checkers go hand-in-hand with the C++ Guideline Support Library, a header-only library that contains helper functions and types suggested by the guidelines to be used in your modern C++ codebase. This library is available as a GitHub repo, a NuGet package, and through VCPkg.

#2 Pain-free upgrade

Moving your C++ code between Visual Studio versions sometimes can create a bit of friction, especially if you are dealing with a large codebase or you depend on 3^rd party libraries that haven’t announced their support for the latest MSVC compiler yet. In fact, the primary migration blocker we hear from developers in our surveys is the fact that a 3^rd party dependency, either open-source or proprietary, has not yet been migrated.

VC Runtime binary compatibility with Visual Studio 2015

The single most important feature of Visual Studio 2017 if you are upgrading from Visual Studio 2015 is that the new VC Runtime is binary compatible with the VC Runtime shipping in Visual Studio 2015.

What this means in practice is that you can move your code to compile with the latest MSVC compiler and libraries even when your 3^rd party dependencies have not yet moved!

VCPkg – acquire and build hundreds of C++ libraries on Windows

If you are depending on an open-source library, chances are you will find it in VCPkg’s list of supported C++ libraries for Visual Studio 2017. VCPkg (video here) has more than 220 open-source C++ libraries readily available.

Acquiring and building a C++ library on Windows has never been easier:

REM Get VCPkg from GitHub

git clone https://github.com/Microsoft/vcpkg.git

REM Bootstrap VCPkg

.\bootstrap-vcpkg.bat

REM Install 3 libraries: curl, Boost, and GSL

.\vcpkg install curl boost ms-gsl

REM Integrate with Visual Studio

.\vcpkg integrate install

Install MSVC 2015.3 toolset with Visual Studio 2017

If you are only looking to use Visual Studio 2017 without upgrading your VC projects, that is now easier too. In previous releases, you had to install both the latest and the old Visual Studio versions, side-by-side, for the latest IDE to be able to build your projects.

You can now install just the MSVC toolset directly from the Visual Studio 2017 Installer by selecting the “VC++ 2015.3 v140 toolset (x86, x64)” option from the “Desktop development with C++” workload.

Migrating from Visual Studio 2013 or older?

If you are upgrading your C++ projects from Visual Studio 2013 or older, even 2003, you will find that we’ve put significant effort in making the Visual C++ migration documentation as complete and accessible as possible, documenting the compiler and linker errors you might encounter, explaining the reasons behind them and how to address them.

#3 Fastest IDE

When it comes to performance, Visual Studio 2017 brings dramatic performance improvements that vastly change the responsiveness of the IDE, making it truly feel faster:

• The IDE launches 3X faster than Visual Studio 2015
• C++ projects load faster (up to 17X faster) and consume up to 2.8X less memory
• C++ debug builds will see a 2-4X speed-up improvement by using the /debug:fastlink linker switch (video here)
• The C++ debugger starts 2X faster than in previous releases and uses less memory during symbol loading
• Git operations are 30% faster compared with previous Visual Studio versions and use less memory

The IDE now also monitors the performance characteristics of all VS extensions, notifying you in case of slowdowns originating from an extension during IDE startup, solution load, and typing.

#4 Productivity in the developer inner-loop

For many of you, productivity is the main reason you are using Visual Studio. The Visual Studio IDE saves you time in your everyday development when it comes to editing, building, testing, diagnosing as well as committing your code to source control.

Visual Studio 2017 includes a lot of new features as well as many user-suggested enhancements to existing functionality that will bring you unparalleled productivity to your C++ development inner-loop.

Editing & code navigation

The Find All References window has been redesigned from the ground-up to scale to larger result sets with incremental results display, better filtering, sorting, and searching within results. You can now also differentiate between reads vs. writes for fields/variables/parameters.

The Go To window (“Ctrl+,”, previously called Navigate To) becomes the central hub for code navigation by unifying several operations under one roof: ‘go to line’, ‘go to file’, ‘go to type’, ‘go to member’, and ‘go to symbol’.

Predictive IntelliSense uses contextual information to limit the number of results displayed by Member List or AutoComplete List to only those results that are the most obvious candidates for the current code location. This is an experimental feature that you will need to first turn on from Tools > Options > Text Editor > C/C++ > Experimental >> Enable Predictive IntelliSense = True

Before	After

Diagnostics

Compile-time /diagnostics:caret provides better warning/error messages by including column information as well as source context.

Exception Helper improves a common scenario of debugging and diagnosing a first-chance or unhandled exception by breaking on the line the exception is thrown, displaying summary info about the exception, and performing an access violation analysis (if applicable).

Run to Click makes it a lot easier to debug your code without the need to set temporary breakpoints or use the context menu (to invoke Run to Cursor).

Reattach to Process is a one-click shortcut to reattach to the previously attached process without having to navigate through the Attach to Process dialog every time.

CPU Usage Caller/Callee View allows deeper analysis of the cost of functions calls, directly while debugging.

C++ Unit Testing

Writing unit tests is the perfect way to validate individual components of your code and running them on an ongoing basis avoids regressions. But running the tests on the command line breaks your inner-loop productivity. Visual Studio’s goal is to make this experience as seamless as possible, enabling you to run the tests right after you make edits to your project.

Visual Studio 2017 adds support for Google Test (with Boost.Test coming soon) allowing you to easily create, enumerate and run tests, and optionally measure their code coverage directly from the IDE regardless of the unit test framework you choose to use.

Source control

In addition to the performance improvements for git operations mentioned above, Visual Studio 2017 allows you to do more of your end-to-end workflow without leaving the IDE. You can:

• perform a force push to complete a release or push an amended commit
• easily view the diff between two commits
• unset your upstream branch
• connect through SSH

In addition, with Visual Studio 2017 and the Continuous Delivery Tools for Visual Studio extension, you can subject every commit to higher scrutiny by reviewing your C++ Code Analysis results before committing.

#5 Bring your C++ sources to Visual Studio with Open Folder

Now, I know that not all of you reading this post are Visual Studio users considering upgrading to the latest version. Some of you may be using other C++ IDEs or editors, considering adopting Visual Studio. But you might think that your codebase (which doesn’t come with .vcxproj and .sln files) is not well suited for loading inside Visual Studio. You might believe that the productivity features that I just outlined for you above couldn’t possibly work with your CMake or makefile project. This next reason addresses exactly your concern.

Visual Studio 2017 supports opening folders containing any code without the need to create solutions or projects (video here). Via “Open Folder”, you will have a more natural way to manage your files regardless of the build system you choose to use or the environment/platform you choose to target. With very little configuration, you get access to all the powerful C++ code understanding, editing, building, and debugging capabilities that you come to expect from Visual Studio with MSBuild projects.

While the out-of-the-box experience today allows you to only target the Windows environment, Visual Studio 2017 will soon add support for MinGW and Cygwin environments as well. To see a sneak peek at the experience, check out this MinGW demo during the C++ Panel at BUILD 2017 (click to jump to 2:20m).

CMake support

If you have a CMake project, you will enjoy the built-in support for CMake in Visual Studio 2017. You can open any folder containing CMakeLists.txt and Visual Studio will automatically start configuring your CMake projects, discover all your CMake targets, and provide you with:

• accurate C++ IntelliSense when editing based on exactly how your files are being built
• C++ code navigation and refactoring (rename refactor, extract function, move definition location, change signature, etc.)
• CMake build integration through either Ninja or Visual Studio generators
• debugging of any CMake executable targets
• running CTest tests authored in your CMake projects
• leverage the latest CMake release 3.8

The experience of developing your CMake projects with Visual Studio should not be limited to only targeting Windows. With that in mind, Visual Studio 2017 will soon expand support to allow targeting Linux with CMake as well. To see a sneak peek at that experience, check out the CMake Linux demo at BUILD 2017 (click to jump to 42:00m).

#6 Target Windows, Android, iOS, and Linux from a single IDE

In addition to C++ development for Windows Desktop and Universal Windows Platform, Visual Studio also comes with support for targeting Linux, Android and iOS. Visual Studio 2017 is the one IDE that allows you to target any platform from a single IDE without having to switch your development box.

Linux targeting

Visual Studio 2017 has built-in support for Linux development, allowing you to very easily connect to remote Linux machines, local or Azure VMs running Linux, and even Windows Subsystem for Linux in Windows 10. The requirements for the remote Linux system are very low: you need an SSH server with gdbserver and a C++ compiler installed. You can also share your C++ code easily with projects targeting other platforms.

Android targeting

Visual Studio 2017 not only supports editing, building, and debugging of C++ code targeting the Android platform, but also editing, building, and debugging Java code. For more details, read our Android and iOS development with C++ guide.

iOS targeting

With Visual Studio, you can import your C++ Xcode projects, benefit from all the C++ productivity improvements Visual Studio 2017 provides, and if needed you can always reopen your projects in Xcode for specific operations like storyboarding or iOS localization that are not directly supported by Visual Studio today.

#7 Streamlined installation

All of this new functionality in Visual Studio 2017 can be acquired via a fresh new installer that organizes the Visual Studio installation options into specific workloads that you can easily choose from. The workloads that are most relevant to C++ developers are:

• Desktop development with C++
• Universal Windows Platform development
• Mobile development with C++
• Game development with C++
• Linux development with C++

This new approach has three major benefits:

• By only installing what you need, Visual Studio’s footprint on disk will be much smaller.
• With fewer bits to install, the installation time is greatly reduced (e.g. you can install the C++ Desktop workload in under 12 minutes on a good dev box with a good Internet connection).
• Additionally, you end up with less visual noise inside the IDE from components you usually don’t use.

#7++ You helped build it

And finally, the reason you should use Visual Studio 2017 for your C++ development is that you helped build it!

This release incorporates so many of your suggestions and bug reports that it is hard to imagine how the product would’ve worked without them. Thank you! Visual Studio 2017 addressed UserVoice items that amount to 1,540+ votes and fixed 980+ bugs reported via Connect and through the IDE.

Please report your feedback via UserVoice (for suggestions) and directly in the IDE via Help > Send Feedback > Report A Problem (issues reported are visible at https://developercommunity.visualstudio.com). The Visual Studio team spends a lot of time reading this feedback and incorporating it, one way or the other, into the upcoming releases, so keep it coming.

Get started today

Visual Studio 2017 is the one IDE that gives you the best C++ development experience regardless of the build systems you use (MSBuild, CMake, Ninja, make, etc.), regardless of the C++ libraries you depend on (see vcpkg library manager above), and regardless of the platforms you target (Windows desktop, Linux, etc.)

Download Visual Studio 2017 today and please share your feedback. We hope you’ll enjoy it. Happy coding!

Marian Luparu, Principal Program Manager, Visual C++ Team @mluparu @visualcMarian is a Product Manager in the Visual Studio team, focusing on C++. He joined the Visual Studio team 11 years ago, after being an avid user of Visual C++ and Visual Studio.

Since the release of Visual Studio for Mac we’ve been amazed by the number of Mac developers using it to build native apps for Mac, iOS, and Android, using Xamarin and Xamarin.Forms; web sites and services using ASP.NET Core; and games using Unity. We’re also excited by the number of developers trying it for the first time, and we want to make it easy to get started – no matter what type of app you’re interested in building. To help, we’re creating hands-on labs for all sorts of developer scenarios.

In my last post, I linked to hands-on labs for getting started with Unity 3D (Lab 1) and working with Internet of Things (IoT) devices (Lab 2). Today I’m excited to present two new labs, for building an ASP.NET Core web site, and building a cross-platform mobile app with Xamarin and an Azure App Service backend.

Lab 3: Build and Debug an ASP.NET Core Web Site

This is our first lab that focuses on the web, these instructions will help you create and host an ASP.NET Core web site, as well as understand some of the details of how it works. It’ll guide you through these 6 tasks:

1. Create a new ASP.NET Core web site
2. Review the solution structure
3. Understand hosting
4. Test and debug the web site
5. Review the startup configuration
6. Insert application middleware in the HTTP pipeline

To complete the lab, follow these hands-on instructions, which will walk you through the process of building a working ASP.NET Core web site using Visual Studio for Mac.

Lab 4: Create a Cloud-Connected Mobile App for iOS and Android

This lab takes you on an exciting journey: building a cross-platform app that runs on iOS and Android, and connects to an Azure-powered cloud backend. These 5 tasks explain everything in detail:

1. File > New cross-platform app
2. Create an Azure Mobile App backend
3. Configure Azure Easy Tables
4. Integrate the cross-platform app with Azure
5. Test and debug the app

Follow these instructions to create a new cross-platform mobile app using Xamarin, set up Azure App Service Easy Tables, and tie it all together!

Download Visual Studio for Mac today, and visit our labs repo on GitHub. Both this week’s labs result in fully working projects: a web site and a mobile app, which I hope inspires you to start building your own ideas. Don’t forget to go back and give game development a try or connect to an IoT device using last week’s labs.

With the Visual Studio Community edition it is easy and free to get started. Keep an eye on this blog for more labs that demonstrate some of the other great developer scenarios and check out the docs for more in-depth information on Visual Studio for Mac.

Craig Dunn, Principal Program Manager @conceptdev Craig works on the Mobile Developer Tools documentation team, where he enjoys writing cross-platform code for iOS, Android, Mac, and Windows platforms with Visual Studio and Xamarin.

Samsung has released the fourth preview of Visual Studio Tools for Tizen. Tizen is a Linux-based open source OS running on over 50 million Samsung devices including TVs, wearables, and mobile phones. Since announcing its collaboration with Microsoft on .NET Core and Xamarin.Forms projects last November, Samsung has steadily released preview versions of.NET support for Tizen with enriched features, such as supporting TV application development and various Visual Studio tools for Tizen.

The new key features released with the fourth preview are based on Tizen 4.0 M1 as follows:

• Support for .NET Core 2.0 Preview 1: The fourth preview is aligned with .NET Core 2.0 Preview 1 supporting .NET Standard 2.0. For more information of .NET Core 2.0 preview 1, see the .NET blog announcement.
• More emulator support: You can run Tizen .NET applications on the emulator without needing an actual target device. With the new release, more emulators are supported, such as x64 TV, x64 Mobile, and x86 TV.

• More Tizen platform-specific APIs: The fourth preview added a number of Tizen-specific APIs for IoT connectivity and voice control. For the full list, see Tizen Platform-Specific API.

The official release of Tizen .NET is scheduled for the end of 2017 as part of Tizen 4.0. For more information, see Samsung’s Tizen Developers Web site.

If you have any feedback or problems, we encourage you to share them through the Tizen .NET Forum.

Scott Hunter, Director of Program Management for .NET Scott Hunter works for Microsoft as a Director of Program Management for .NET overseeing the server frameworks, such as ASP.NET, MVC, Web API, Web Pages and NuGet. Before this Scott was the CTO of several startups including Mustang Software and Starbase, where he focused on a variety of technologies – but programming the Web has always been his real passion.

About two years ago, a group of developers at Microsoft crafted a service for distributing Apache Cordova, React Native, and Windows Mobile updates to applications in the wild. They called it “CodePush.” Since then, mobile app developers have deployed thousands of releases to in-production apps – deploying quick bug fixes, feature improvements and content updates via the cloud. In a world where updates submitted through the app store can sometimes take days, these developers have enjoyed a huge market advantage because they can respond to customer feedback more quickly with instant app updates to some or all of their end-users.

On June 2nd, CodePush became part of Visual Studio Mobile Center, taking its place among other services designed and built for Mobile Developers. Let’s take a tour!

How does it work?

Mobile apps written with Cordova and React Native execute at least some of their code as interpreted JavaScript. In the case of Cordova, JavaScript runs in a webview that displays HTML and CSS controls. For React Native, JavaScript runs in a background thread (i.e. JavaScript Core) that ultimately produces native UI and animations via the React Native framework.

Developers bundle this JavaScript and include it with their application prior to distribution. CodePush-enabled applications dynamically update their JavaScript code either automatically or on-demand, thus empowering developers to provide incremental updates at-will.

From a systems architecture standpoint, three different open source components make this possible: the SDK, CLI, and the Azure based service. The SDK is broken into platform specific implementations for Cordova and React Native. Developers use the CLI to release updates to the service which are then retrieved by the SDKs packaged with the customer’s app.

The CodePush Update Lifecycle

A typical CodePush update lifecycle works like this:

1. You publish your app to the store with both native and JavaScript code bundled together. We’ll call this version 1.0.0 (0) where the parenthetical represents the CodePush release number.
2. Your customer installs your app from the store.
3. After changing your JavaScript, you release update v1.0.0 (1) to the CodePush service hosted in Azure. Notice the CodePush release number has incremented to “(1)”.
4. On any app event (e.g. onresume), the app queries the CodePush service to compare the JavaScript bundle installed on the device to the most recent one available in the cloud.
5. If the cloud version is both higher and matches the native code version, then it downloads and installs the newer update.

Take it for a spin!

The best way to get to know any tool is to try it out; CodePush is no exception. For this example, we will use React Native. If you haven’t used React Native before: don’t worry it is absolutely painless to get started. This example assumes you’re already in the working directory of a simple “hello world” app.

After CodePush is installed into the application directory, all that is left to do is integrate the React Native SDK into the app; once this is done, you are ready to start using the CodePush CLI to make releases.

When releasing an update, you can choose from among a number of options. For example, you can release to only a subset of your users, force an update by making it mandatory or even revoke an update after its release. Although you can customize the user experience for any update, your app will display the following dialog by default when a new release is available:

Using the Mobile Center Dashboard

CLI tools separate functional concerns and make automation easy, but don’t succeed as well as rich GUIs when it comes to presenting information graphically and allowing for an easy flow between tasks.

CodePush is now integrated with Mobile Center’s dashboard to provide developers with a point-and-click interface for managing apps and deployments. To try it, create a React Native app in Mobile Center, hook it up to the sample app you created above, and check it out. Or watch us do it:

What’s next?

Currently we have a lot of plans for CodePush including but not limited to better integration with our crash service – which currently provides js stack traces for iOS – and bundle signing. In the coming months, we at Mobile Center will also be striving to provide further support for additional platforms both for CodePush and other services. Please check our blog and product roadmap for news and details but also let us know what you would like to see.

Ian Geoghegan, Senior Program Manager, Mobile Developer Division @mscodepushIan has been writing software for nearly twenty years across an assortment of domains. His interests include security, tools, and sustainable technology.

Today we’ve released a new alpha preview for Visual Studio for Mac in the alpha updater channel – our first preview for version 7.2. The major themes for this release are improving the performance and accessibility support.

Trying the Latest Version

If you’re already on the bleeding edge with the Alpha channel, simply check for updates within Visual Studio for Mac, or otherwise read the instructions on how to sign up for the Visual Studio for Mac Alpha updater channel.

Preview Capabilities

The Azure Functions support and IoT support were bundled as part of the IDE for our Build 2017 preview release. As we get ready for our final release, we have unbundled these capabilities from the core IDE and they are now available to be installed from the Extension Manager. To install them, simply click on Extensions in the top menu in the IDE to find the extensions under the IDE extensions node on the Gallery tab.

Hands-on labs

Make sure to check out the hands-on lab repo on GitHub to get started using the preview functionality offered, if you haven’t already.

Feedback

Help us make the product better by posting your comments in the Visual Studio Developer Community site or reporting a problem straight from the Welcome Page on Visual Studio for Mac.

Miguel de Icaza

Miguel de Icaza, Distinguished Engineer, Mobile Developer Tools @migueldeicaza Miguel is a Distinguished Engineer at Microsoft, focused on the mobile platform and creating delightful developer tools. With Nat Friedman, he co-founded both Xamarin in 2011 and Ximian in 1999. Before that, Miguel co-founded the GNOME project in 1997 and has directed the Mono project since its creation in 2001, including multiple Mono releases at Novell. Miguel has received the Free Software Foundation 1999 Free Software Award, the MIT Technology Review Innovator of the Year Award in 1999, and was named one of Time Magazine’s 100 innovators for the new century in September 2000.

In 2015, Satya Nadella updated the Microsoft mission statement to a single sentence. Our mission is to “Empower every person and every organization on the planet to achieve more.” In 2016, Satya and Scott Guthrie looked at the directors in Visual Studio and asked how we’re honoring that mission with respect to the word ‘every’. While accessibility has always been a priority for Visual Studio, Satya wanted to know how much confidence we had in our own assessment.

How accessible is Visual Studio?

In October of 2016, Visual Studio started the effort to really answer the question of how accessible the Visual Studio family of products and services were. We partnered with two independent testing agencies who were trained in the Trusted Tester program, a program established by the Homeland Security Agency of the United States of America to set out guidelines that define exactly what it means to be accessible. Effectively, the division wanted experts on accessibility to help shape and define our goals.

Visual Studio is a very large product with countless screens of UI. To get the level of detail that we wanted, the testing process took 6 months and it discovered hundreds of issues. Many of these were small issues like a name not being defined or certain UI Automation patterns not being implemented correctly. While many users wouldn’t be aware of these incorrect values, for Visual Studio customers who use assistive technologies like screen readers, they made Visual Studio a bit less usable.

Accessibility in Visual Studio 2017 version 15.3

Today’s update of Visual Studio 2017 includes over 1,700 targeted fixes to improve compatibility between Visual Studio and the Assistive Technologies that many of our customers use. Our testing focused heavily on screen readers and high contrast display themes, as well as manually inspecting the automation trees that allow assistive technologies, including refreshable braille displays and specialized pointing devices to work with Visual Studio. There are dozens of scenarios that are more compatible with screen readers, high contrast themes and other assistive technologies than ever before. The debugger, editor and shell have all gotten significant improvements that are worth emphasizing.

The Visual Studio debugger identified some windows that were previously inaccessible to screen readers. This meant that while many users found the Call Stack, Locals, Autos, Watch and Quickwatch windows useful, not all our users could take advantage of them. Now, screen readers can query the properties of these windows, making sure our visually impaired users could take advantage.

A first class code editing experience is the heart of any IDE, and we want to make Visual Studio’s editor work well for every developer – with this in mind we’ve improved the way the editor works for developers with low vision and those who need screen readers. We’ve gotten feedback that all the color encoding in the editor can help users identify the types of different tokens, but in some cases, those colors can make the text more difficult to read for folks with low vision. Visual Studio users now have access to the “Blue (Extra Contrast)” theme which will tweak some of those colors to make sure the color contrast will be more comfortable for users who want a bit more contrast as they code without needing the full “High Contrast” themes.

Visual Studio’s editor has a rich vocabulary of text adornments that let developers know about characteristics and features available at particular points on a line of code, such as breakpoints, lightbulbs, error and warning “squiggles”, bookmarks, and more. Customers can now discover and navigate between these adornments via the new “Show Line Annotations” command set, which you can find on the editor context menu.

Are we there?

These are just a few examples of the experiences that we’ve improved upon and with Visual Studio 2017, we now feel confident in giving Satya the answer to the question he asked. To be completely honest though, the answer to Satya is “Better than we were, but not as good as we’d like.” That’s why Visual Studio 2017 Update 3 represents the first significant step toward being the fully accessible development tool that we want to be completely proud of. Later this year, Windows plans to ship the Fall Creator’s Update which will provide some APIs that Visual Studio needs to be the accessible tool that we feel our customers deserve. Windows 10 with the Fall Creators Update and Visual Studio 2017 with its latest update will be a more accessible IDE than we’ve ever shipped before.

This journey that we are on does not stop when the checkboxes are ticked. Visual Studio now has a team dedicated to shaping tools for app developers so the apps they create will be accessible by default. We’ve also reached out to developers with a range of disabilities to come and use Visual Studio and give us direct feedback. We’re asking folks to continue to use the “Give Feedback” button in Visual Studio (Help -> Send Feedback -> Provide a Suggestion) to continue to provide this feedback. If you’re a user of assistive technologies and you’ve got something that you can’t get to work, or even if you have suggestions on how to get things to work better, please send us that feedback.

It’s not only Visual Studio that is getting our attention. We’re going through all of the tools in the Visual Studio family, like Blend for Visual Studio and making sure their compatibility is up to our standards. Visual Studio for Mac has also gone through our testing process, and the updates to make Visual Studio for Mac more accessible are well underway and will be released soon.

We’re very proud of today’s update of Visual Studio 2017, as it’s the first time our customers will get to see the fruits of this accessibility effort and our dedication to the mission to empower every person and every organization to do more.

Dante Gagne, Program Manager II, XAML Experiences @DanteGagne Dante was one of the first testers for Expression Blend and his love of XAML has never faded. When he’s not playing board games or walking in the sunshine, he’s designing features in Visual Studio. His passion lies in diagnostics, accessibility, and localization with an eye toward UX design and polishing.

Today we have several releases to talk about: there’s the release of Visual Studio 2017 version 15.3, the release of .NET Core 2.0, and a release of Visual Studio for Mac version 7.1. We’ll talk about them briefly in that order, but as always, there’s a lot more information in the release notes for each product. If you’d like to jump right in, download Visual Studio 2017 version 15.3, download .NET Core 2.0, and download Visual Studio for Mac.

Visual Studio 2017 version 15.3

For Visual Studio 2017 version 15.3, we focused on improving accessibility, particularly using Visual Studio with the most popular screen readers. We made over 1,700 improvements and still have some work to do, but if you are using Visual Studio 2017 in a low-vision or no-vision mode, a lot has improved. Dante has a blog post on everything we’ve done and what’s more to come, but here I’ll call out a couple of the more major things we’ve improved.

• Debugging is much more accessible. Debugger windows like the Call Stack, Locals, Autos, and Watch windows were inaccessible to screen readers. That’s now fixed.
• The VS editor’s text adornments let developers know about features available at particular points on a line of code, such as breakpoints, lightbulbs, and error and warning “squiggles.” Customers can now discover and navigate between these adornments via the new “Show Line Annotations” command set, which you can find on the editor context menu.

In addition to accessibility, we have many fixes for reliability issues to improve performance, many of which you reported through report-a-problem. Here are some of the more notable ones that had high votes that we fixed:

• A crash that could occur in C# and VB projects when editing linked files, files in Shared Projects, or files used in projects targeting multiple runtimes.
• A race condition when debugging C# or VB projects that could cause Visual Studio to crash when ending the debugging session.
• A crash in C# or VB projects when malformed metadata is encountered in the code file.
• A crash that could occur when compiling a local function in C#.

We also improved many other experiences:

• Azure Functions Support. We added the tools for developing C# Azure Functions to the “Azure development” workload. The main feature change is that this update enables you to create pre-compiled C# Azure Functions, which start faster than script-based functions. For details see the Visual Studio 2017 Tools for Azure Functions blog post.

• Broad Azure sign-in support. VS 2017 15.3 also supports logging into not just Azure, but Azure Government and Sovereign cloud offerings, and Azure Stack.
• Improved container support. This release now supports the breadth of container development across existing .NET Framework apps with Windows Containers, to .NET Core with Windows, and Linux Support. Recent additions include support for your .NET Core applications in containers running Nano server, as well as debugging improvements for .NET Framework applications in containers.
• Continuous Delivery Tools now included. We’ve moved the Continuous Deliver tools extension into the main product. You can configure continuous delivery for ASP.NET and ASP.NET Core projects targeting Azure App Service. This tooling will configure your continuous integration build using Visual Studio Team Services and configure your deployment to Azure App Service. Once configured, you can modify and extend the build and deploy process, customizing it to meet your exact needs.

For the full list of improvements check out the release notes for Visual Studio 2017 version 15.3.

.NET Core 2.0 Released

.NET Core 2.0 is also released today. This is the second major version of .NET Core and this release focuses on performance improvements and expanding the set of APIs available via .NET Standard 2.0. It includes the runtime and libraries for .NET Core as well as the tools for building, debugging and running .NET Core applications. There are some notable changes from .NET Core 1.1. There’s a full blog post on .NET Core 2.0, but here are some highlights: blog post on .NET Core 2.0, but here are some highlights:

– Live Unit Testing. You can use Live Unit Testing for .NET Standard, .NET Core, and ASP.NET Core projects. (Visual Studio Enterprise SKU only)

– References. You can now refer to .NET Core/.NET Standard libraries from .NET Framework projects and vice versa. No need to manually add interop NuGet packages – Visual Studio does this for you automatically.

– Containers with .NET Core and Windows Nano. Support for containerizing ASP.NET Core apps as Windows Nano images has been added and you can now select Nano as the container platform. You can do this under File->New Project for ASP.NET Core projects. For your existing projects, it can be added using the Project Context Menu

– Support in Visual Studio for Mac. VS for Mac supports building .NET Core 2.0 applications, including libraries, console apps, as well as web applications and services with ASP.NET Core.

Note that the .NET Core 2.0 SDK needs to be installed via a separate download to enable .NET Core 2.0 development in Visual Studio 2017 version 15.3. You can get it at www.dot.net/core. Visual Studio enables side-by-side support of multiple .NET Core SDKs. This also means you can experiment with the latest daily build of the .NET Core SDK, while also developing with the latest public releases. See blog post for details.

Watch the .NET team demonstrate the new features of .NET Core, Visual Studio 2017 and Visual Studio for Mac! Learn what’s new and how to use the new tools.

Visual Studio for Mac version 7.1

Visual Studio for Mac version 7.1 is also available today. It adds support for .NET Core 2.0 targeting in console apps, web apps, and web services. It also enables creating .NET Standard 2.0 in library projects, to share more code across projects. Like Visual Studio 2017, a lot of the improvements in this update center on reliability. We’ve made strides in decreased memory usage, better performance, and decreased crashes. Many of these fixes have been made possibly by your feedback, so please keep that coming through the Developer Community.

Share Your Feedback

As always, we welcome your thoughts and concerns. For issues, let us know via the Report a Problem tool in Visual Studio. You’ll be able to track your issues in the Visual Studio Developer Community where you can ask questions and find answers. For suggestions, share with us through UserVoice.

John Montgomery, Director of Program Management for Visual Studio @JohnMont John is responsible for product design and customer success for all of Visual Studio, C++, C#, VB, JavaScript, and .NET. John has been at Microsoft for 17 years, working in developer technologies the whole time.

We are looking to improve your experience on the Visual Studio Blog. It would be very helpful if you could share your feedback via this short survey that should take less than 2 minutes. Thanks!

Visual Studio sources community suggestions from the Visual Studio UserVoice site, where thousands of users have logged and voted on community ideas from small to large. With each release we try to balance improvements to our existing capabilities with new innovation. The team looks for at top- voted requests and popular suggestions that align with other work we’re already doing for a release. Visual Studio 2017 version 15.3, has several new capabilities that came right out of community suggestions in the IDE & Editor, Performance, Project, and User Interface categories.

The changes described in this post are available either in Visual Studio 2017 version 15.3 which you can download today, or in extensions that are also available for download now (see links in the relevant sections). Please note that this is not an exhaustive list; if your favorite topic is not mentioned here, head over to UserVoice for more updates and keep the conversation going, with votes and discussions on those topics.

Web.config transforms for any file in any project (SlowCheetah)

Our top voted suggestion is in the Project category, and is around support for web.config style transforms. SlowCheetah is a popular extension used by many developers for transforming configuration files in their applications, for instance when moving from staging to production environments.

In the latest update to the extension, we’ve added support for Visual Studio 2017 as well as the ability to add JSON transforms; a popular format for config files. Additionally, SlowCheetah now supports all project types that support NuGet, and, we are excited to announce that Microsoft has taken ownership of the code base and will continue to maintain it going forward.

We haven’t closed this item yet because we are continuing to look at more we could do here, so we look forward to hearing your feedback on UserVoice about other file types you’d like to see SlowCheetah support.

Faster solution load

Faster solution load is a highly voted suggestion in the Project category.

Many solutions contain a large number of projects, which affects the time taken to load those solutions. However, we have observed that most of you typically do not use all the projects in these large solutions as you generally work on a different subset of those projects from your colleagues. This insight led to the lightweight solution load (LSL) feature in the Visual Studio 2017.

In lightweight solution load (LSL) mode, Visual Studio 2017 loads a small subset of projects instead of loading all the projects in a large solution. For large solutions with more than 30 projects, overall solution load is faster by roughly a factor of 2. In Visual Studio 2017 version 15.3, most of the highly-used features will work under LSL mode, as it still provides the ability for you to build, search and debug on the entire solution. The main exception is currently “edit and continue”. If any feature requires all the projects to be loaded, Visual Studio will automatically load the entire solution. Refer to this doc on optimizing Visual Studio startup time for more details on LSL and those features that continue to work in this mode.

The engineering team is excited about LSL and actively reviews customer feedback, e.g. the team addressed build issues with .NET core projects and added support for C++ projects under LSL. Any additional feedback can be sent to lslsupport@microsoft.com.

Hyperlinks open in the system default browser

Sometimes it’s the little things that matter. More and more features in Visual Studio 2017 are moving to using the system’s browser, instead of the built-in browser to display web content. Visual Studio 2017 version 15.3 now opens all links that appear in the Editor and the Output window using the system default browser. You’ll see this more often as we continue upgrading other parts of Visual Studio 2017, in line with your highly-voted feedback in the IDE & Editor category.

Color theme editor

In response to your feedback, we’ve upgraded the Visual Studio Color Theme Editor to work with Visual Studio 2017. The Visual Studio Color Theme Editor is a popular extension for users who like to change the colors of the Visual Studio environment beyond the standard Light/Dark/Blue themes that ship with the product. It provides additional predefined themes: Green, Red, Purple, Tan, Solarized (Light), Solarized (Dark), Dark with Light Editor and Light with Dark Editor. It also provides tooling to help you create new themes or change existing ones.

We’ve also added theming support for the new features in Visual Studio 2017, including the redesigned Visual Studio 2017 Start Page with Developer News.

The Visual Studio 2017 Color Theme Editor is available for download from the Visual Studio Marketplace. Feel free to ask questions or leave feedback about the extension in the Q&A and Rating & Reviews sections.

Changing the default location for Visual Studio project folders

Visual Studio creates folders under the “My Documents” location for each new version. We’ve started to address this highly-voted problem by first moving the Projects folders into C:\\USERPROFILE\Source\Repos. We are currently investigating moving the other folders currently placed into My Documents into more appropriate places. We appreciate any feedback you have around where you believe these items should live in the future.

Asking before moving files in solution explorer tree

In response to your feedback, and to avoid unwanted file movements via drag and drop actions, we now prompt you before moving files inside the Solution Explorer. We also added the ability to disable and enable the prompt via the “Prompt before moving files to a new location” option under the “Tools > Projects and Solutions” menu.

Integrated JavaScript debugging in Firefox and Google Chrome browsers

With Visual Studio 2017 version 15.3, you can now debug your client-side code in the Chrome browser when you launch an ASP.net project, in line with your feedback. You’ll be able to set breakpoints, step and inspect your client-side JavaScript, or TypeScript, just as you can using Microsoft Internet Explorer. You can also continue to use Chrome’s Developer Tools by launching them from the browser, which will then disconnect the Visual Studio debugger.

To read more about debugging using Chrome, refer to the blog at: https://blogs.msdn.microsoft.com/webdev/2016/11/21/client-side-debugging-of-asp-net-projects-in-google-chrome/.

Please continue to share your feedback!

As you can see, your feedback has led to a number of important updates to Visual Studio 2017 and we want to encourage you to continue to provide valuable feedback for the team. Please raise any issues you see via Report a Problem, and let us know about things you’d love to see us address via voting up or starting new issues on UserVoice

Mark Wilson-Thomas, Senior Program Manager, Visual Studio IDE Team @MarkPavWT Mark is a Program Manager on the Visual Studio IDE team, where he’s been building developer tools for nearly 10 years. He currently looks after the Visual Studio Editor. Prior to that, he worked on tools for Office, SQL, WPF and Silverlight.

We are looking to improve your experience on the Visual Studio Blog. It would be very helpful if you could share your feedback via this short survey that should take less than 2 minutes. Thanks!

Visual Studio Tools for Xamarin gives you everything you need to build amazing native mobile apps for Android, iOS, and UWP – and Xamarin University is making it even easier for desktop developers to learn how to apply existing skills, experience, and practices to do mobile development.

At Xamarin University, our team of mobile experts have taught thousands of developers of all skill levels and backgrounds, and, we invite you to join us for “Xamarin University Presents: Desktop Developer’s Guide to Mobile with Visual Studio Tools for Xamarin” on Tues, August 29^th at 9 am PT / 12 pm ET / 4 pm UTC.

[REGISTER]

As a long-time desktop developer, I’ll share my personal experiences and provide step-by-step guidance to ease the jump to native Android and iOS development.

During the session, you’ll learn how to:

• Use Visual Studio Tools for Xamarin and C# to design and build native apps for lots of devices and platforms
• Map common desktop paradigms to mobile, including comparing desktop and mobile APIs
• Optimize the UX / UI when porting your desktop apps to tablets or mobile devices

You’ll get best practices, see practical examples, and we’ll have several Xamarin University instructors and mobile experts available to answer your questions throughout the session.

Register now, and get ready to learn how to extend your desktop expertise to all things mobile.

We encourage all registrants to attend the webinar live, as we will be answering questions throughout the event. However, we will share recordings with registrants after the session. So please sign up even if you cannot join us that day. You can view an assortment of past sessions here.

Mark Smith, Principal Program Manager Mark leads Xamarin University, where he helps developers learn how to utilize their .NET skills to build amazing mobile apps for Android, iOS, Windows and beyond. Prior to his career at Microsoft and Xamarin (acquired by Microsoft), Mark ran a consulting business, specializing in custom development

We are looking to improve your experience on the Visual Studio Blog. It would be very helpful if you could share your feedback via this short survey that should take less than 2 minutes. Thanks!

You may have heard the industry buzzword “serverless computing.” Whether you are already a serverless ninja, or still on the fence about the bizarre name, read on! How does it work? Why should you care? Is it just a fad, or a real trend in computing?

Serverless computing defined

Serverless computing generally encompasses three things: 1) abstraction of servers, 2) event-driven scale and 3) micro-billing.

1. Abstraction of servers. Serverless computing is fully managed. Users never explicitly reserve server instances; this is handled by the platform. Each function execution could run on a different compute instance, and this is completely transparent to your code.
2. Event-driven scale. Serverless is an excellent fit for workloads that respond to incoming events. Events include timers (e.g., run this function everyday at 10 am), HTTP (API and WebHook scenarios), queues (e.g., order processing), and much more. Instead of writing an entire application, you author a “function,” which contains both code and metadata about its triggers and bindings. The platform automatically schedules your function to run and scales the number of compute instances based on the rate of incoming events. Triggers define how a function is invoked. Input and output bindings provide a declarative way to connect to services from within your code. For example, suppose you want to write a new file to Azure Blob Storage every five minutes. You would use a Timer trigger and a blob output binding:

3. Micro-billing. In traditional computing, there is a notion of per-second billing, but that’s often not as useful as it sounds. Even if you have a website that gets only 1 hit a day, you must still pay for a full day’s worth of availability. With serverless, you pay only when your code is executing. If there are no active function executions, you are not charged. For example, if your code runs once a day for 2 minutes, you are charged for 1 execution and 2 minutes of computing. For more details on billing, see Azure Functions pricing.

Together, these features enable you to focus on apps, not servers. That means you’ll have reduced DevOps and a more productive computing environment. Customers have found that they are able to deploy solutions much more quickly than before. Projects can now be completed in days or weeks, rather than months.

Azure Functions is Microsoft’s serverless computing platform. Serverless involves more than just computing; it includes databases, messaging, and workflows. To learn more about the entire Azure serverless platform, see azure.com/serverless.

Why serverless matters

More so than any other cloud computing paradigm, serverless frees you from managing infrastructure and enables you to focus on your business problem. Though serverless is still in its infancy, there are now many vendors who offer serverless platforms.

Serverless is not just a fad or buzzword. Rather, serverless represents a dramatic shift in how developers think about cloud computing. With serverless, you need only worry about your code and how it is triggered. The platform takes care of the rest.

Serverless and tooling

When most cloud vendors launched their serverless offerings, there were many barriers to developer productivity. There was no support for debugging, there was no local development experience, and monitoring functions was hard. Despite this, the new programming model was so productive that serverless become a popular trend.

As you might expect, Azure Functions included productivity features from the start. We have a tooling and local development experience that is unique among vendors. You can run the Azure Functions runtime on your local machine. Aside from the scale-out, it’s the same runtime as in the cloud. You can even trigger off events in Azure, enabling a hybrid debugging experience.

For monitoring, Azure Functions provides Azure Application Insights integration, an unparalleled monitoring experience. You can connect to a live event stream, see runtime metrics, and log your own custom metrics. Application Insights supports a rich query language, and you can create automated alerts.

.NET support on Azure Functions

Since its initial preview, Azure Functions has had first-class C# support. We now support C# and F# scripting as well as C# class libraries. The Function portal focuses on the scripting experience, while the Visual Studio tooling is based on class libraries.

The Visual Studio Functions project is a regular .NET class library that references the Functions NuGet package Microsoft.NET.Sdk.Functions. All standard Visual Studio features are supported, such as unit testing, debugging, and publishing to Azure.

Azure Functions also supports other languages, such as JavaScript, PowerShell, and Python.

Try it out

We’ve recently released the RTW version of the Azure Functions tools in Visual Studio 2017 Update 3. Azure Functions tooling is included in the Azure workload. Follow this tutorial to get started in 5 minutes: Create your first function using Visual Studio.

Learn more

Check out the following videos:

• Cloud Cover: Azure Functions Local Debugging and More
• The Xamarin Show: Azure Functions for Mobile Apps
• Microsoft Mechanics: Build apps faster with Azure Serverless
• BUILD 2017: A day in the life of an Azure serverless developer
• Tuesdays with Cory: Azure Functions Proxies extravaganza

Connect with us:

• For product news, follow @AzureFunctions.
• For technical questions, post on the MSDN forums or StackOverflow. The entire Functions engineering team monitors these questions, so you’re sure to get an expert answer.
• To report bugs or file feature requests, open an issue on the Azure-Functions GitHub repo. Include “Visual Studio” in the issue title.

Donna Malayeri, Program Manager, Azure Functions @lindydonna Donna Malayeri is a program manager on the Azure Functions team, where she is responsible for the developer experience and the Visual Studio tooling. She previously worked on products such as Azure Mobile Services, Reactive Extensions (Rx), Visual F#, and Scala. She holds a PhD in programming languages from Carnegie Mellon University.

We are looking to improve your experience on the Visual Studio Blog. It would be very helpful if you could share your feedback via this short survey that should take less than 2 minutes. Thanks!

In the earlier post “Committing with Confidence: Getting Code Quality Information at Commit Time” , we introduced the new Build and Code Analysis Results panel, which gives you a heads-up reminder at commit-time of issues detected by any code analysis tool that puts results in the error list. This means you can take care of those issues before they propagate into your team’s CI/CD process, and commit with confidence.

The panel shows results both for live edit-time analysis (e.g. C#/VB Analyzers) and, via the Refresh Analysis button, for batch-style static analysis (e.g. C++ Static Analysis tools). It is supported on Visual Studio 2017 Enterprise. At present it supports code being committed to a Git Repo.

Focus on the issues that relate to your changed files

In response to your feedback, we have just released a new version of the Continuous Delivery Tools for Visual Studio extension which updates the panel to show issue counts only for files that are changed in the set of files you are committing, so that you can focus only on the issues related to your changes.

The View Issues link will take you straight to a view of the Error List filtered to just the changed files too:

Please continue to share your feedback!

Please download and try the Continuous Delivery Tools for Visual Studio extension, try out the updated Build and Code Analysis Results panel and let us know what you think of the change, as well as the overall experience.

Tell us more about what you think about this by filling out a short survey

We’re always looking for feedback on where to take this Microsoft DevLabs extension next; features from the extension have already been refined using that feedback and incorporated into the core Visual Studio product in updates. There’s a Slack channel and a team email alias vsdevops@microsoft.com where you can reach out to the team and others in the community sharing ideas on this topic.

Mark Wilson-Thomas, Senior Program Manager, Visual Studio IDE Team @MarkPavWT Mark is a Program Manager on the Visual Studio IDE team, where he’s been building developer tools for nearly 10 years. He currently looks after the Visual Studio Editor. Prior to that, he worked on tools for Office, SQL, WPF and Silverlight.

We are looking to improve your experience on the Visual Studio Blog. It would be very helpful if you could share your feedback via this short survey that should take less than 2 minutes. Thanks!

At //BUILD 2017, we shipped an update to the Continuous Delivery Tools for Visual Studio with support for configuring a Continuous Integration and Continuous Delivery pipeline for ASP.NET Core projects with container support to an existing Azure App Service on Linux directly from Visual Studio 2017. With the latest update to the extension we introduced the ability to create a new Azure App Service On Linux while configuring continuous delivery.

To configure continuous delivery to App Service on Linux, create or open an existing solution with an ASP.NET Core project. Add Docker support to the project and ensure that the solution is under version control on VSTS or GitHub. Right click on the solution in Solution Explorer and select Configure Continuous Delivery.

Then, select App Service (Linux) as the Target Host type and use the default newly created app service or select an existing Azure App Service to act as a target for continuous delivery.

You can click the “Edit…” link beside the App Service field to edit the new App Service configuration. You can change the Location, Resource Group, App Service Plan and Service Plan size using the “Edit App Service” dialog.

If you are not using an existing App Service as your target host, the registry settings for that App Service should match your selected container registry as the VSTS release definition only updates the image name and tag, not the full container registry settings. With the latest update to the extension, you now get an error that the container registry settings must change for continuous delivery to work successfully.

Clicking “Allow App Service settings change to a private registry”, will enable the Configure Continuous Delivery Dialog to update the selected App Service settings when you click OK to configure continuous delivery

Please keep the feedback coming!

Thank you to everyone who has reached out and shared feedback and ideas so far. We’re always looking for feedback on where to take this Microsoft DevLabs extension next. There’s a Slack channel and a team alias vsdevops@microsoft.com where you can reach out to the team and others in the community sharing ideas on this topic.

Ahmed Metwally, Senior PM, Visual Studio @cd4vs (https://twitter.com/cd4vs) Ahmed is a Program Manager on the Visual Studio Platform team focused on improving team collaboration and application lifecycle management integration.

We are looking to improve your experience on the Visual Studio Blog. It would be very helpful if you could share your feedback via this short survey that should take less than 2 minutes. Thanks!

I’m happy to announce that the first Preview of Visual Studio 2017 version 15.4 is now available! You can either download it from here, or if you already have Preview installed, you’ll receive a notification that the update is available. This latest Preview contains new tools and features in several key workloads such as Universal Windows Platform (UWP) development, .NET desktop development, and Mobile and Game development. It also continues our drive to improve and polish the fundamentals such as productivity and reliability and address customer-reported bugs. Read the feature highlight summary below, and check out the Visual Studio 2017 version 15.4 Preview Release notes for a detailed description of the new functionality contained in this Preview.

Universal Windows Platform Development – Windows Fall Creators Update

First, Visual Studio 2017 version 15.4 brings first class support for UWP developers targeting the upcoming Windows Fall Creators Update. To start building apps against this new Windows update, first, make sure you are enrolled in the Windows Insider Program. Once you are enrolled, install the latest pre-release version of the Windows Insider Preview SDK.

.NET Standard 2.0 Support

With the release of the Windows Fall Creators Update, you will be able to leverage the power of .NET Standard 2.0 when building UWP applications. .NET Standard 2.0 brings an additional 20,000+ .NET APIs to Windows 10 UWP developers – many of which will be familiar to Windows Desktop (WPF, Windows Forms, etc…) developers. .NET Standard 2.0 also allows for easier sharing of code between various .NET project types as project-to-project references, or as NuGet packages. We are starting to see a variety of NuGet packages show up on NuGet.org with support for .NET Standard 2.0, all of which will be available for consumption inside UWP projects.

To build UWP apps using the new .NET Standard 2.0 APIs, make sure you have the Windows Fall Creators Update Insider SDK Preview installed, and set the minimum version of your project to this version of the SDK.

Windows Application Packaging Project

In Visual Studio 2017 version 15.4 Preview, you will get the first peek at a new project template that enables Classic Windows Desktop apps created with .NET or C++ to be packaged inside an .appx package for easier distribution via side-loading or submission to the Windows Store. These templates work for both new Classic Windows Desktop projects, as well as for existing projects.

XAML Edit & Continue Improvements

You can edit or remove XAML resources using XAML Edit & Continue. In addition, you can also add ControlTemplates to your XAML while using XAML Edit & Continue. To leverage these new features, make sure you are running the Windows Fall Creators Update Preview.

Mobile and Game Development

Unity

In Visual Studio 2017 version 15.4 Preview we have made improvements and bugfixes in the tooling for Unity. There is better support for the latest released Unity 2017.1 runtime. This Preview also supports user-defined managed assemblies, a feature coming in Unity 2017.2 that helps to drastically minimize script compilation times of projects. To help with debugging, you can now “Set Instruction Pointer”, which allows you to which moves the execution point and sets the next statement of code to be executed.

Xamarin

The Xamarin Live Player is also included in Visual Studio 2017 version 15.4 Preview. This enables developers to develop, test, and debug mobile apps directly on their iOS and Android devices using only Visual Studio and a device. It’s meant to simplify getting started with mobile development. For instructions on how to try it out, please refer to the Preview Release Notes and, of course, please tell us what you think!

The Fundamentals

Installer Behavior and Acquisition Experience.

Visual Studio 2017 version 15.4 Preview contains some notable install experience improvements. For example, if you encounter any installation errors, we now provide better assistance in discovering solutions. If some component fails to install and someone else had already reported a similar issue, then the installer error message will link back to the Visual Studio Developer Community and point you to info that should help you diagnose and resolve the problem.

Productivity Improvements

There are a handful of new productivity features that will help you be more efficient and effective as you develop your code. For example, with this Preview, if you’re a C#, VB, or Python developer, you can navigate around your project faster because Ctrl+Click will now Go To Definition. We’ve continued to improve performance and memory usage as compared to earlier releases. Lastly, we’ve refined Live Unit Testing by making it easier to initiate with a start command in the right click context menu as well as in the Team Explorer window. Live Unit Testing is better integrated with MSTest for use in manual mode.

C++ Development

You can now use CMake for Linux C++ development in Visual Studio, which allows you to use CMake based projects that target Windows, Linux, or both. Simply open a folder with your CMake project, select Linux as your target and upon connecting to your Linux machine your sources are synchronized for you. Once the CMake cache generation is complete you’ll have full IntelliSense for your project and targets for building, running and debugging within Visual Studio.

In addition to CMake support for Linux C++ development, with Visual Studio 2017 version 15.4 Preview you can now benefit from CMake version 3.9 and improved support for projects with multiple CMakeLists.

Data Science Tooling

If you’re a Data Scientist using R, we’ve added some great new features to Visual Studio 2017 version 15.4 Preview. Now you can use the full power of Visual Studio to connect to an R session running on a remote computer that is running on Linux or Windows. We support running against on-premise and cloud (Azure) computers as well. In the IDE, we’ve added error squiggles (inline underlines) that will highlight places where you can improve your R code. Finally, we’ve added Live RMarkdown editing, which gives you a live preview of your markdown edits as you type.

Try it out today!

If you’re not familiar with Visual Studio Previews, take a moment to read the Visual Studio 2017 Release Rhythm. Remember that Visual Studio 2017 Previews will install side by side with released bits, so they should not impact your machine. Previews provide an opportunity for you to receive fixes faster and try out upcoming functionality before it becomes mainstream. Similarly, the Previews enable the Visual Studio Engineering team to validate usage, incorporate suggestions, and detect flaws earlier in the development process. We are highly responsive to feedback coming in through the Previews and look forward to hearing from you.

Please Install the Visual Studio 2017 Preview today, exercise your favorite workloads, and tell us what you think. You can report issues or send feedback to us via Report a Problem in the IDE or you can share a suggestion on UserVoice. You can also track your bugs, learn from others, and receive helpful information on the developer community portal.

Christine Ruana, Principal Program Manager, Visual Studio Christine is on the Visual Studio release engineering team and is responsible for making Visual Studio releases available to our customers around the world.