This post was written by Gabriel Dos Reis, Phil Christensen, and Andrew Pardoe

The Visual C++ Team is excited to announce that the compiler in Visual Studio 2017 RC will feature a mode much closer to ISO C++ standards conformance than any time in its history. This represents a major milestone in our journey to full ISO C++ conformance.  The mode is available now as an opt-in via the /permissive- switch but will one day become the default mode for the Visual C++ compiler.

Got a minute? Try Visual C++ conformance mode

The Visual C++ Team is previewing a compiler mode whereby longstanding non-conforming C++ constructs are rejected.  This includes fixes to pre-C++11 non-conformance bugs that affect a significant amount of existing code.  Examples are as simple as

typedef int default;  // error: ‘default’ is a keyword, not permitted here

or as advanced as the following.  Consider:

template
struct B {
    int f();
};

template
struct D : B {
    int g();
};

template
int D::g() {
    return f();  // error: should be ‘this->f()’
}

In the definition of D::g, the symbol f is from the dependent base class B but standard C++ does not permit examining dependent base classes when looking for declarations that satisfy the use of f. That is an error in the source code that Visual C++ has long failed to diagnose. The fix is to prefix the call with this->. This fix works in both non-conformance and conformance modes.

The issue in this code sample might sound like a “two-phase name lookup” problem, but it is not quite that. In fact, two phase name lookup is the big missing piece from the first iteration of this standard conformance mode.  Visual C++ does not support two-phase name lookup in VS 2017 RC but we expect to complete it early next year. When we do, the definition of /permissive- will change to include two-phase name lookup. This is an important point: /permissive- is not a completed feature in VS 2017 RC. You will have to keep your codebase clean as we complete our conformance work in Visual C++.

Opting into the conforming mode, /permissive-, during the series of VS 2017 update is a commitment to keeping your code base clean and to fixing non-conforming constructs we fix conformance issues in Visual C++. If you make your code compile with /permissive- today you may still have to make changes when VS 2017 releases, and again with updates to VS 2017 because we may have added more bug fixes for non-conforming behaviors.

The good news is this first release contains most of the big issues. With the exception of two-phase name lookup we don’t expect any major changes. See How to fix your code for a complete list of non-conforming constructs implemented under /permissive- today and how to fix them. We’ll update this list as we complete the changes.

From the Visual Studio IDE

In Visual Studio 2017 RC there is no setting in the project properties page for /permissive-. You’ll need to enter the switch manually under “Configuration -> C/C++ -> Additional Options”.

When compiling with /permissive-, the IDE compiler disables non-conforming Visual C++-specific behaviors and interprets your code following the C++ standard. You’ll notice that these language conformance features are now reflected in the areas of IDE such as IntelliSense and browsing features. In this example, setting /permissive- causes IntelliSense to flag default as an illegal identifier.

There are currently a few places where the IntelliSense in the IDE will conform better to the C++ standard than the Visual C++ compiler.  For example, when relying on two-phase name lookup during overload resolution the compiler will emit an error.  IntelliSense, however, will show that the code is conforming and will not give any red squiggles in the editor.  You can see that happening in the screenshot below:

Why is that? You may know that Visual C++ uses a separate compiler for IDE productivity features. Since around 2009 we’ve used a compiler front-end from the Edison Design Group (EDG) to drive IntelliSense and many other features. EDG does a fantastic job at emulating other compilers–if you use Clang in Visual Studio (either through Clang/C2 or  when targeting Android or iOS) we put EDG into “Clang mode” where it emulates Clang’s bugs and vendor-specific behaviors. Likewise, when using Visual C++, we put EDG into “Visual C++” mode.

While EDG emulates most VC++ features and bugs faithfully, there still might be some gaps due to the implementation being separate or how we integrated their compiler in the IDE.  For example, we’ve implemented some features such as ignoring names from dependent base classes, but we haven’t yet implemented others, such as two-phase name lookup (“two-phase overload resolution” on this page) that are both implemented in EDG. Thus EDG shows the “complete” results IntelliSense even though the Visual C++ compiler doesn’t compile the code correctly.

Any differences you see in the IDE and the compiler are temporary. As we complete our conformance work the IDE and the compiler behaviors will match on all code.

Is there any relation to /Za?

The compiler switch /Za was an effort started decades ago to carve out a strictly portable behavior across several C++ compilers. The effort was stalled and we no longer recommend it for new projects. The switch /Za does not support certain key Microsoft SDK header files. By contrast /permissive- offers a useful conformance mode where input C++ code is interpreted according to ISO C++ rules but also allows conforming extensions necessary to compile C++ on targets supported by Visual C++. For example, you can use /permissive- with C++/CLI. The compiler switch /Za rejects a few non-conforming constructs; however the compiler switch /permissive- is our recommendation going forward for conforming code.

The road ahead

We know that conformance changes can be impactful to your code. In order to provide the best experience we’re splitting the development of /permissive- into three stages: the development stage, the adoption stage, on-by-default.

Development stage

The initial preview of /permissive- allows you to try out the switch and make most of the changes that will be required in your code. At this stage there will be some inconsistencies in the experience: the feature set under /permissive- will grow slightly, and editor features like IntelliSense may not match exactly. But all the changes you make to your code in this stage will work with and without /permissive-.

Adoption stage

The Visual C++ team will continue to add new conformance behavior under the /permissive- option throughout the Visual Studio 2017 release cycle. But we know that you rely on libraries and that those libraries also need to work with /permissive- in order for you to opt-in. Our first priority is to ensure that all public headers from our team, and those from Microsoft as a whole, compile cleanly with the /permissive- option. For example, the standard library headers compile correctly both with /permissive- and without. We are also working with the community to make changes to existing open source C++ projects (this typically involves removal of Visual C++-specific workarounds.)

On by default

When developers have had time to migrate their code to conform more closely to the C++ standards we will flip the default so that the compiler applies full ISO C++ standard rules when interpreting your source code. This won’t happen immediately–it’s a long-term goal for our conformance work. Until we make this switch—and at least for the entire Visual Studio 2017 cycle–you will have to opt-in to /permissive-. When we do switch it on by default your existing projects won’t change, but VS will make new projects opt-in to conformance.

Call to action

We encourage you to try the new option /permissive- in your projects. Please add this option to your build settings–either in the IDE or in your build scripts. If your code is already used cross-platform (i.e., it compiles with multiple compilers on many platforms) and does not contain Visual C++ specific workarounds, the chances are that the code will compile just fine with /permissive-!

If you do use Visual C++ specific, non-conforming constructs in your code, chances are that your code won’t compile the first time with /permissive-. There’s a list of patterns below of non-conforming C++ code, the typical error message/number you’ll see, and how to fix the code.  The good news is that the fixes work both in the conforming mode and in the permissive mode. Therefore, if you try to compile with /permissive- and you correct issues, the corrected code will be good for the permissive mode too. This enables you to migrate your code to /permissive- incrementally, rather than making all of the changes at once.

How to fix your code

Here’s a list of behaviors that are affected by the permissive option today. Note that this list is incomplete because the /permissive- switch is incomplete. As we add new conforming behaviors the potential breaking changes protected by /permissive- will expand. This means even if you fix your code to work with /permissive- today you may still have to make fixes in the future as we make Visual C++ conform better to the standard. Again, these changes will only affect your code if you opt-in by using the /permissive- switch.

Lookup members in dependent base

template  struct B {
  void f();
};
template  struct D
    : public B // B is a dependent base because its type depends on the type of T.
{
    // One possible fix is to uncomment the following line.  If this were a type don't forget the 'typename' keyword
    // using B::f;
void g() {
      f(); // error C3861: 'f': identifier not found
           // change it to 'this->f();'
    }
};
template  struct C
    : public B
{
    C()
      : B() // error C2955: 'B': use of class template requires template argument list
               // Change to B() to fix
    {}
};
void h()
{
   D d;
   d.g();
   C c;
}

Use of qualified names in member declarations

struct A {
    void A::f() { } // error C4596: illegal qualified name in member declaration
                    // remove redundant 'A::' to fix
};

Initializing multiple union members in a member initializer

union U
{
  U() 
    : i(1), j(1) // error C3442: Initializing multiple members of union: 'U::i' and 'U::j'
                 // Remove all but one of the initializations
  {}
  int i;
  int j;
};

Hidden friend name lookup rules

// Example 1
struct S {
friend void f(S *);
};
// Uncomment this declaration to make the hidden friend visible
//void f(S *); // this declaration makes the hidden friend visible
using type = void (*)(S *);
type p = &f; //error C2065: 'f': undeclared identifier

/*--------------------------------------------------------*/

// Example 2
struct S {
friend void f(S *);
};
 
void g() { 
    // using nullptr instead of S prevents argument dependent lookup in S
    f(nullptr); // error C3861: 'f': identifier not found
    
S *p = nullptr;
f( S ); // hidden friend can be found via argument-dependent lookup.
} 

Using scoped enums in array bounds

enum class Color 
{ 
    Red, Green, Blue 
};
int data[Color::Blue];// error C3411: 'Color' is not valid as the size of an array as it is not an integer type
                      // Cast to type size_t or int

Using ‘default’ as an identifier in native code

void func(int default); // Error C2321: 'default' is a keyword, and cannot be used in this context

‘for each’ in native code

void func()
{
   int array[] = {1, 2, 30, 40};
   for each( int i in array) // error C4496: nonstandard extension 'for each' used: replace with ranged-for statement
                             // for( int i: array)
   {
       // ... 
   }
}

Defaulting conformance switches

The compiler switches /Zc:strictStrings and /Zc:rvalueCast are currently off by default, allowing non-conforming behavior. The switch /permissive- turns them on by default. You can pass in the /Zc flags after /permissive- to override this behavior if needed.

See these MSDN pages for more information:

• /Zc:strictStrings https://msdn.microsoft.com/en-us/library/dn449508.aspx
• /Zc:rvalueCast https://msdn.microsoft.com/en-us/library/dn449507.aspx

ATL attributes

We started to deprecate attributed ATL support in VS 2008. The /permissive- switch removes support for attributed ATL.

// Example 1
[uuid("594382D9-44B0-461A-8DE3-E06A3E73C5EB")]
class A {};

// Fix for example 1
class __declspec(uuid("594382D9-44B0-461A-8DE3-E06A3E73C5EB")) B {};

// Example 2
[emitidl];
[module(name="Foo")];
[object, local, uuid("9e66a290-4365-11d2-a997-00c04fa37ddb")]
__interface ICustom {
HRESULT Custom([in] long l, [out, retval] long *pLong);
[local] HRESULT CustomLocal([in] long l, [out, retval] long *pLong);
};
[coclass, appobject, uuid("9e66a294-4365-11d2-a997-00c04fa37ddb")]
class CFoo : public ICustom
{};

// Fix for example 2
// First, create the *.idl file. The vc140.idl generated file can be used to automatically obtain *.idl file for the interfaces with annotation. 
// Second, add a midl step to your build system to make sure that the C++ interface definitions are outputted. 
// Lastly, adjust your existing code to use ATL directly as shown in atl implementation section

-- IDL  FILE -- 
import "docobj.idl";
 
[object, local, uuid(9e66a290-4365-11d2-a997-00c04fa37ddb)] 
interface ICustom : IUnknown {
HRESULT  Custom([in] long l, [out,retval] long *pLong);
[local] HRESULT  CustomLocal([in] long l, [out,retval] long *pLong);
};
 
[ version(1.0), uuid(29079a2c-5f3f-3325-99a1-3ec9c40988bb) ]
library Foo {
importlib("stdole2.tlb");
importlib("olepro32.dll");
 
[version(1.0), appobject, uuid(9e66a294-4365-11d2-a997-00c04fa37ddb)] 
 
coclass CFoo { interface ICustom; };
}
 
-- ATL IMPLEMENTATION--
#include 
#include 
class ATL_NO_VTABLE CFooImpl : public ICustom, public ATL::CComObjectRootEx {
public:
BEGIN_COM_MAP(CFooImpl)
COM_INTERFACE_ENTRY(ICustom)
END_COM_MAP()
}; 

Changes not present in VS 2017 RC

Here are some changes to /permissive- that we expect to enable in future releases and updates of VS 2017. This list may not be complete.

• Two-phase name lookup
• Error when binding a non-const reference to a temporary
• Not treating copy init as direct init
• Not allowing multiple user-defined conversions in initialization.
• Alternative tokens for logical operators (‘and’, ‘or’, etc…)

In closing

As always, we welcome your feedback. Please give us feedback about the /permissive- feature in the comments below or through e-mail at visualcpp@microsoft.com.

If you encounter other problems with Visual C++ in VS 2017 RC please let us know via the Report a Problem option, either from the installer or the Visual Studio IDE itself. For suggestions, let us know through UserVoice. Thank you!

Throughout the VS 2015 cycle we’ve been focusing on the quality of our expression SFINAE implementation. Because expression SFINAE issues can be subtle and complex we’ve been using popular libraries such as Boost and Microsoft’s fork of Range-v3 to validate our implementation and find remaining bugs. As we shift the compiler team’s focus to Visual Studio 2017 release we’re excited to tell you about the improvements we’ve made in correctly parsing expression SFINAE.

We’ve been tracking the changes and improvements to our parsing of expression SFINAE throughout the Visual Studio 2015 and 2017 cycle. Please see this blog post for a list of expression SFINAE improvements in Visual Studio 2017.

Visual Studio 2017 RC is an important release when it comes to its support for CMake. The “Tools for CMake” VS component is now ready for public preview and we’d like to invite all of you to bring your CMake projects into VS and give us feedback on your experience.

For an overview of the general Visual Studio CMake experience, head over to the announcement post for CMake support in Visual Studio that has been updated to include all the capabilities discussed in this post. Additionally, if you’re interested in the “Open Folder” capability for C++ projects that are not using CMake or MSBuild, check out the Open Folder for C++ announcement blog.

The RC release brings support for:

• Editing CMake projects
• Configuring CMake projects
• Building and debugging of CMake targets

Editing CMake projects

Default CMake configurations. As soon as you open a folder containing a CMake project, Solution Explorer will display the files in that folder and you can open any one of them in the editor. In the background, VS will start indexing the C++ sources in your folder. It will also run CMake.exe to collect more information about your CMake project (CMake cache will be generated in the process). CMake is invoked with a specific set of switches that are defined as part of a default CMake configuration that VS creates under the name “Visual Studio 15 x86”.

CMake configuration switch. You can switch between CMake configurations from the C++ Configuration dropdown in the General tab. If a configuration does not have the needed information for CMake to correctly create its cache, you can further customize it – how to configure CMake is explained later in the post.

Auto-update CMake cache. If you make changes to the CMakeLists.txt files or change the active configuration, the CMake generation step will automatically rerun. You can track its progress in the CMake output pane of the Output Window.

When the generation step completes, the notification bar in editors is dismissed, the Startup Item dropdown will contain the updated list of CMake targets and C++ IntelliSense will incrementally update with the latest changes you made (e.g. adding new files, changing compiler switches, etc.)

Configure CMake projects

Configure CMake via CMakeSettings.json. If your CMake project requires additional settings to configure the CMake cache correctly, you can customize these settings by creating a CMakeSettings.json file in the same folder with the root CMakeLists.txt. In this file you can specify as many CMake configurations as you need – you will be able to switch between them at any time.

You can create the CMakeSettings.json file by selecting the Project>Edit Settings>path-to-CMakeLists (configuration-name) menu entry.

CMakeSettings.json example

{
  "configurations": [
   {
    "name": "my-config",
    "generator": "Visual Studio 15 2017",
    "buildRoot": "${env.LOCALAPPDATA}\\CMakeBuild\\${workspaceHash}\\build\\${name}",
    "cmakeCommandArgs": "",
    "variables": [
     {
      "name": "VARIABLE",
      "value": "value"
     }
    ]
  }
 ]
}

If you already have CMake.exe working on the command line, creating a new CMake configuration in the CMakeSettings.json should be trivial:

• name: is the configuration name that will show up in the C++ configuration dropdown. This property value can also be used as a macro ${name} to specify other property values e.g. see “buildRoot” definition
• generator: maps to -G switch and specifies the generator to be used. This property can also be used as a macro ${generator} to help specify other property values. VS currently supports the following CMake generators:
  • “Visual Studio 14 2015”
  • “Visual Studio 14 2015 ARM”
  • “Visual Studio 14 2015 Win64”
  • “Visual Studio 15 2017”
  • “Visual Studio 15 2017 ARM”
  • “Visual Studio 15 2017 Win64”
• buildRoot: maps to -DCMAKE_BINARY_DIR switch and specifies where the CMake cache will be created. If the folder does not exist, it will be created
• variables: contains a name+value pair of CMake variables that will get passed as -Dname=value to CMake. If your CMake project build instructions specify adding any variables directly to the CMake cache file, it is recommended that you add them here instead.
• cmakeCommandArgs: specifies any additional switches you want to pass to CMake.exe

CMakeSettings.json file IntelliSense. When you have the JSON editor installed (it comes with the Web Development Workload), JSON intelliSense will assist you while making changes to the CMakeSettings.json file.

Environment variable support and macros. CMakeSettings.json supports consuming environment variables for any of the configuration properties. The syntax to use is ${env.FOO} to expand the environment variable %FOO%.

You also have access to built-in macros inside this file:

• ${workspaceRoot}– provides the full path to the workspace folder
• ${workspaceHash}– hash of workspace location; useful for creating a unique identifier for the current workspace (e.g. to use in folder paths)
• ${projectFile}– the full path for the root CMakeLists.txt
• ${projectDir}– the full path to the folder of the root CMakeLists.txt file
• ${thisFile}– the full path to the CMakeSettings.json file
• ${name}– the name of the configuration
• ${generator}– the name of the CMake generator used in this configuration

Building and debugging CMake projects

Customize build command. By default, VS invokes MSBuild with the following switches: -m -v:minimal. You can customize this command, by changing the “buildCommandArgs” configuration property in CMakeSettings.json

CMakeSettings.json

{
  "configurations": [
   {
     "name": "x86",
     "generator": "Visual Studio 15 2017",
     "buildRoot": "${env.LOCALAPPDATA}\\CMakeBuild\\${workspaceHash}\\build\\${name}",
     "cmakeCommandArgs": "",
     "buildCommandArgs": "-m:8 -v:minimal -p:PreferredToolArchitecture=x64"
   }
 ]
}

Call to action

Download Visual Studio 2017 RC today and try the “Open Folder” experience for CMake projects. For an overview of the CMake experience, also check out the CMake support in Visual Studio blog post.
If you’re using CMake when developing your C++ projects, we would love to hear from you! Please share your feedback in the comments below or through the “Send Feedback” icon in VS.

With the Visual Studio 2017 RC release, we’re continuing to improve the “Open Folder” capabilities for C++ source code. In this release, we’re adding support for building as well as easier configuration for the debugger and the C++ language services.

If you are just getting started with “Open Folder” or want to read about these capabilities in more depth, head over to the Open Folder for C++ introductory post that has been updated with the content below. If you are using CMake, head over to our blog post introducing the CMake support in Visual Studio.

Here are the improvements for the “Open Folder” C++ experience in the new RC release for Visual Studio 2017:

• Reading and editing C++ code
• Building C++ projects
• Debugging C++ binaries

Reading and editing C++ Code

Environment variables and macros support. CppProperties.json file, which aids in configuring C++ IntelliSense and browsing, now supports environment variable expansion for include paths or other property values. The syntax is ${env.FOODIR} to expand an environment variable %FOODIR%

CppProperties.json:

{
  "configurations": [
    {
      "name": "Windows",
      "includePath": [ // include UCRT and CRT headers
        "${env.WindowsSdkDir}include\\${env.WindowsSDKVersion}\\ucrt",
        "${env.VCToolsInstallDir}include"
      ]
    }
  ]
}

Note: %WindowsSdkDir% and %VCToolsInstallDir% are not set as global environment variables so make sure you start devenv.exe from a “Developer Command Prompt for VS 2017” that defines these variables.

You also have access to built-in macros inside this file:

• ${workspaceRoot}– provides the full path to the workspace folder
• ${projectRoot}– full path to the folder where CppProperties.json is placed
• ${vsInstallDir}– full path to the folder where the running instance of VS 2017 is installed

CppProperties.json IntelliSense. Get assistance while editing CppProperties.json via JSON IntelliSense when you have the full-fledged JSON editor installed (it comes with the Web Development Workload)

C++ Configuration dropdown. You can create as many configurations as you want in CppProperties.json and easily switch between them from the C++ configuration dropdown in the Standard toolbar

CppProperties.json

{
  "configurations": [
    {
      "name": "Windows",
      ...
    },
    {
      "name": "with EXTERNAL_CODECS",
      ...
    }
  ]
}

CppProperties.json is now optional and by default, when you open a folder with C++ source code, VS will create 2 default C++ configurations: Debug and Release. These configurations are consistent with the configurations provided by the Single File IntelliSense we introduced in VS 2015.

Building C++ projects

Integrate external tools via tasks. You can now automate build scripts or any other external operations on the files you have in your current workspace by running them as tasks directly in the IDE. You can configure a new task by right clicking on a file or folder and select “Customize Task Settings”.

This will create a new file tasks.vs.json under the hidden .vs folder in your workspace and a new task that you can customize. JSON IntelliSense is available if you have the JSON editor installed (it comes with the Web Development workload)

By default, a task can be executed from the context menu of the file in Solution Explorer. For each task, you will find a new entry at the bottom of the context menu.

Tasks.vs.json

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskName": "Echo filename",
      "appliesTo": "makefile",
      "type": "command",
      "command": "${env.COMSPEC}",
      "args": ["echo ${file}"]
    }
  ]
}

Environment variables support and macros. Just like CppProperties.json, in tasks.vs.json you can consume environment variables by using the syntax ${env.VARIABLE}.

Additionally, you can use built-in macros inside your tasks properties:

• ${workspaceRoot}– provides the full path to the workspace folder
• ${file}– provides the full path to the file or folder selected to run this task against

You can also specify additional user macros yourself that you can use in the tasks properties e.g. ${outDir} in the example below:

Tasks.vs.json

{
  "version": "0.2.1",
  "outDir": "${workspaceRoot}\\bin",
  "tasks": [
    {
      "taskName": "List outputs",
      "appliesTo": "*",
      "type": "command",
      "command": "${env.COMSPEC}",
      "args": [ "dir ${outDir}" ]
    }
  ]
}

Building projects. By specifying the “contextType” for a given task to equal “build”, “clean” or “rebuild” you can wire up the VS build-in commands for Build, Clean and Rebuild that can be invoked from the context menu.

Tasks.vs.json

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskName": "makefile-build",
      "appliesTo": "makefile",
      "type": "command",
      "contextType": "build",
      "command": "nmake"
    },
    {
      "taskName": "makefile-clean",
      "appliesTo": "makefile",
      "type": "command",
      "contextType": "clean",
      "command": "nmake",
      "args": ["clean"]
    }
  ]
}

File and folder masks. You can create tasks for any file or folder by specifying its name in the “appliesTo” field. But to create more generic tasks you can use file masks. For example:

• “appliesTo”: “*”– task is available to all files and folders in the workspace
• “appliesTo”: “*/”– task is available to all folders in the workspace
• “appliesTo”: “*.cpp”– task is available to all files with the extension .cpp in the workspace
• “appliesTo”: “/*.cpp”– task is available to all files with the extension .cpp in the root of the workspace
• “appliesTo”: “src/*/”– task is available to all subfolders of the “src” folder
• “appliesTo”: “makefile”– task is available to all makefile files in the workspace
• “appliesTo”: “/makefile”– task is available only on the makefile in the root of the workspace

Debugging C++ binaries

Debug task outputs. If you specify an output binary in your task definition (via “output”), this binary will be automatically launched under the debugger if you select the source file as a startup item or just right click on the source file and choose “Debug”. E.g.

Tasks.vs.json

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskName": "makefile-build",
      "appliesTo": "makefile",
      "type": "command",
      "contextType": "build",
      "command": "nmake",
      "output": "${workspaceRoot}\\bin\\hellomake.exe"
    }
  ]
}

What’s next

Download Visual Studio 2017 RC today and please try the “Open Folder” experience. For an overview of the “Open Folder” experience, also check out the “Open Folder” for C++ overview blog post.

As we’re continuing to evolve the “Open Folder” support, we want your input to make sure the experience meets your needs when bringing C++ codebases that use non-MSBuild build systems into Visual Studio, so don’t hesitate to contact us. We look forward to hearing from you!

Visual Studio 2017 comes packed with several major changes to the core developer productivity experience. It is our goal to maximize your efficiency as you develop applications, and this requires us to constantly refine our features and improve on them over time. For Visual Studio 2017, we wanted to improve code navigation, particularly for larger solutions which produce many search results. One big focus for us was Navigate To (now known as Go To). The other was Find All References, described in a separate blog post.

We rebranded our Navigate To feature to Go To, an umbrella term for a set of filtered navigation experiences around specific kinds of results. We recognized that large searches sometimes produced cases where the desired search term is quite far down the list. With our new filters, it is easier to narrow down on the desired result before the search process has even begun.

The new Go To experience with added filters

You can open Go To with Ctrl + ,– this creates a search box over the document you are editing. “Go To” is an umbrella term encompassing the following features:

1. Go To Line (Ctrl +G)– quickly jump to a different line in your current document
2. Go To All (Ctrl + ,) or (Ctrl + T)– similar to old Navigate To experience, search results include everything below
3. Go To File (Ctrl 1, F)– search for files in your solution
4. Go To Type (Ctrl 1, T)– search results include:
   • Classes, Structs, Enums
   • Interfaces & Delegates (managed code only)
5. Go To Member (Ctrl 1, M)– search results include:
   • Global variables and global functions
   • Class member variables and member functions
   • Constants
   • Enum Items
   • Properties and Events
6. Go To Symbol (Ctrl 1, S)– search results include:
   • Results from Go To Types and Go To Members
   • All remaining C++ language constructs, including macros

When you first invoke Go To with Ctrl + ,Go To All is activated (no filters on search results). You can then select your desired filter using the buttons near the search textbox. Alternatively, you can invoke a specific Go To filter using its corresponding keyboard shortcut. Doing so opens the Go To search box with that filter pre-selected. All keyboard shortcuts are configurable, so feel free to experiment!

You also have the option of using text filters to activate different Go To filters. To do so, simply start your search query with the filter’s corresponding character followed by a space. Go To Line can optionally omit the space. These are the available text filters:

• Go To All – (no text filter)
• Go To Line Number – :
• Go To File – f
• Go To Type – t
• Go To Member – m
• Go To Symbol – #

If you forget these text filters, just type a ? followed by a space to see the full list.

Another way to access the Go To commands is via the Edit menu. This is also a good way to remind yourself of the main Go To keyboard shortcuts.

Other notable changes to the old Navigate To (now Go To) experience:

• Two toggle buttons were added to the right of the filters:
  • A new button that limits searches to the current active document in the IDE.
  • A new button that expands searches to include results from external dependencies in search results (previously was a checkbox setting).
• The settings for Go To have been moved from the arrow beside the textbox to their own “gear icon” button. The arrow still displays a history of search results. A new setting was added that lets you center the Go To search box in your editor window.

We hope the new Go To feature with its set of filters provide a more advanced and tailored code navigation experience for you. If you’re interested in other productivity-related enhancements in Visual Studio 2017, check out this additional content:

• C++ IntelliSense Improvements – Predictive IntelliSense & Filtering
• Find All References re-designed for larger searches
• Video: C++ Productivity Improvements in Visual Studio 2017

Send us your feedback!

We thrive on your feedback. Use the report a problem feature in the IDE to share feedback on Visual Studio and check out the developer community portal view. If you are not using the Visual Studio IDE, report issues using the Connect Form for reporting issues. Share your product improvement suggestions on UserVoice.

Download Visual Studio 2017 RC to try out this feature for yourself!

Visual Studio 2017 comes packed with several major changes to the core developer productivity experience. It is our goal to maximize your efficiency as you develop applications, and this requires us to constantly refine our features and improve on them over time. For Visual Studio 2017, we wanted to improve code navigation, particularly for larger solutions which produce many search results. One big focus for us was Find All References. The other was Navigate To, described in a separate blog post.

Find All References is intended to provide an efficient way to find all usages of a particular code symbol in your codebase. In Visual Studio 2017, you can now filter, sort, or group results in many different ways. Results also populate incrementally, and are classified as Reads or Writes to help you get more context on what you are looking at.

Grouping Results

A new dropdown list has been made available that lets you group results by the following categories:

• Project then Definition
• Definition Only
• Definition then Project
• Definition then Path
• Definition, Project then Path

Filtering Results

Most columns now support filtering of results. Simply hover over a column and click the filtering icon that pops up. Most notably, you can filter results from the first column to hide things like string and comment references (or choose to display them, if you prefer).

The difference between Confirmed, Disconfirmed and Unprocessed results is described below:

• Confirmed Results– Actual code references to the symbol being searched for. For example, searching for a member function called Size will return all references to Size that match the scope of the class defining Size.
• Disconfirmed Results– This filter is off by default for a reason, because these are the results that have the same name as the symbol being searched for but have been proven not to be actual references to that symbol. For example, if you have two classes that each define a member function called Size, and you run a search for Size on a reference from an object of Class 1, any references to Size from Class 2 appear as disconfirmed. Since most of the time you won’t actually care for these results, they are hidden from view (unless you turn this filter on).
• Unprocessed Results– Find All References operations can take some time to fully execute on larger codebases, so we classify unprocessed results here. Unprocessed results match the name of the symbol being searched for but have not yet been confirmed or disconfirmed as actual code references by our IntelliSense engine. You can turn on this filter if you want to see results show up even faster in the list, and don’t mind sometimes getting results that aren’t actual references.

Sorting Results

You can sort results by a particular column by simply clicking on that column. You can swap between ascending/descending order by clicking the column again.

Read/Write Status

We added a new column (far right in the UI) that classifies entries as Read, Write, or Other (where applicable). You can use the new filters to limit results to just one of these categories if you prefer.

We hope the changes to Find All References, designed to help you manage complex searches. If you’re interested in other productivity-related enhancements in Visual Studio 2017, check out this additional content:

• C++ IntelliSense Improvements – Predictive IntelliSense & Filtering
• Introducing Go To, the successor to Navigate To
• Video: C++ Productivity Improvements in Visual Studio 2017

Send us your feedback!

We thrive on your feedback. Use the report a problem feature in the IDE to share feedback on Visual Studio and check out the developer community portal view. If you are not using the Visual Studio IDE, report issues using the Connect Form for reporting issues. Share your product improvement suggestions on UserVoice.

Download Visual Studio 2017 RC to try out this feature for yourself!

Recap of the Visual C++ Build Tools

Last year we introduced the Visual C++ Build Tools to enable a streamlined build-lab experience for getting the required Visual C++ tools without the additional overhead of installing the Visual Studio IDE.  We expanded the options to include tools like ATL and MFC, .NET tools for C++/CLI development, and various Windows SDKs.

There was also an MSBuild standalone installer for installing the tools needed for building .NET applications called the Microsoft Build Tools.

The new Visual Studio Build Tools

For Visual Studio 2017 RC, we are introducing the new Visual Studio Build Tools which uses the new installer experience to provide access to MSBuild tools for both managed and native applications.  This installer replaces both the Visual C++ Build Tools and the Microsoft Build Tools as your one stop shop for build tools.  By default, all of the necessary MSBuild prerequisites for both managed and native builds are installed with the Visual Studio Build Tools, including the MSBuild command prompt which you can use to build your applications.  On top of that there is also an optional workload for the “Visual C++ Build Tools” that provides an additional set of options that native C++ developers can install on top of the core MSBuild components.

These options are very similar to those found in the Visual Studio 2017 RC “Desktop development with C++” workload, which provides a comparable set of options than those available in the Visual C++ Build Tools 2015.   Note that we also include CMake support in the Visual Studio Build Tools.

Just like the installer for Visual Studio 2017 RC, there is also an area for installing individual components to allow for more granular control over your installation.

Command-line “Silent” Installs

The build tools can be installed using the installer from the command-line without needing to launch the installer UI.  Navigate to the installer’s directory using an elevated command prompt and run one of the following commands.  There is also an option to use the “–quiet” argument to invoke a silent install if desired, as shown below:

• To install just the MSBuild tools

vs_buildtools.exe –quiet

• To install the MSBuild tools and required VC++ tools

vs_buildtools.exe –quiet –add Microsoft.VisualStudio.Workload.VCTools

• To install the MSBuild tools and recommended (default) VC++ tools

vs_buildtools.exe –quiet –add Microsoft.VisualStudio.Workload.VCTools;includeRecommended

• To install the MSBuild tools and all of the optional VC++ tools

vs_buildtools.exe –quiet –add Microsoft.VisualStudio.Workload.VCTools;includeOptional

The –help command will be coming in a future release.

Closing Remarks

Give the new Visual Studio Build Tools a try and let us know what you think.  We plan to evolve this installer to continue to meet your needs, both native and beyond.  Your input will help guide us down this path.  Thanks!

Visual Studio 2017 RC (previously known as Dev “15”) is now available. There is a lot of stuff for C++ to love in this release:

• Give Visual C++ a Switch to Standard Conformance. Use the opt-in /permissive switch to compile your C++ code in a mode much closer to ISO C++ standards conformance. Watch the video C++ Standards Conformance on Channel 9.
• We’ve been focusing on the quality of our expression SFINAE implementation using popular libraries such as Boost and Microsoft’s fork of Range-v3 to find remaining bugs.
• Use /Debug:fastlink to observe 2-4x link improvements for your C++ code, learn more with Faster C++ Links with Visual Studio 2017 on Channel 9.
• CMake support in Visual Studio is ready for primetime! Load your CMake projects directly into VS and start coding now. Watch the video CMake support in Visual Studio on Channel 9.
• “Open Folder” C++ experience has been improved for RC – so bring your source code to VS without the need to create any VS solutions and projects. Watch the video Open Folder for C++ Developers on Channel 9.
• IntelliSense now includes a set of filters that narrow down displayed list of results and includes an experimental mode called Predictive IntelliSense that helps narrow the list of IntelliSense results to provide a more tailored, context-aware experience. Watch the video C++ IDE Performance Improvements in Visual Studio 2017 on Channel 9.
• Navigate To is now known as Go To, an umbrella term for a set of new navigation filters which together make it easier to find the right results, especially in larger code bases. Watch the video C++ Productivity Improvements on channel 9.
• Find All References has been re-designed for larger searches and includes information about whether we are reading from or writing to a variable in the results for C++ code.
• We have updated the C++ workloads in the lightweight Visual Studio Installer and there is now the ability to install individual components — including the C++ Build Tools for Visual Studio 2017— outside of a workload. Watch the video Visual C++ and the Visual Studio Installer and the Visual Studio Build Tools on Channel 9.
• Spend a few minutes learning about the C++ extension for Visual Studio Code and Visual Studio 2017 Linux development with C++ on Channel 9.
• VCPkg now supports static linking and supports a catalog of more than 90 libraries. Watch the video Vcpkg a tool to build open source C++ libraries on Channel 9.

For more details, visit What’s New for Visual C++ in Visual Studio 2017 RC. Going Native over on Channel 9 also has a good overview including a look at VCPkg.

We thrive on your feedback. Use the report a problem feature in the IDE to share feedback on Visual Studio and check out the developer community portal view. If you are not using the Visual Studio IDE, report issues using the Connect Form for reporting issues.  Share your product improvement suggestions on UserVoice.

Thank you.

Hello everyone. This is Keiko again. We’ve got such a great response on the Container solution that we’ve extended this effort into Azure Container Service. As you are aware, Azure Container Service provides a pre-built container deployment infrastructure platform with the choice of an orchestrator that includes DC/OS and Docker Swarm. For our initial effort with Azure Container Service, we’ve integrated our solution as part of the Mesosphere Universe on DC/OS.

More benefit to customer using Azure Container Service DC/OS

Because containers can be created and destroyed any time, monitoring Docker containers has been a pain. This monitoring issue gets even more painful as you scale your environment and increase containers.

With Operations Management Suite (OMS) Container solution residing along with Azure Container Service DC/OS on Azure, Docker containers in Azure Container Service DC/OS can be monitored in a centralized location. It provides customers with the container performance metrics, logs analysis, container image inventories, and events.

This can be done with very few steps. All you have to do is select the package in DC/OS Universe as you see in the following screenshot.

Containerized OMS Agent for Linux instance gets installed on every private and public agent when you configure. This monitoring instance can scale as the Azure Container Service DC/OS environment scales, so you do not have to install it each time.

Currently, we support both Azure Container Service DC/OS 1.7.3 and 1.8.4 versions.

For details about how to set up OMS on Azure Container Service DC/OS, see Setting up OMS to monitor container applications on ACS DC/OS.

More feature enhancements

In addition to Azure Container Service DC/OS support, we have added more features.

• Enriched Container Solution user interface
  • Container Lifecycle view from create, start, and finish
  • Efficient Container Monitoring Image Tag view
  • Container Computer and Memory Usage view
• Enhanced log collection using journald
• Simplified Installation – universal setting for log-driver is no longer required.

We will progressively add new features and are open to feedback. For more information about our features, please go to the Container Solution documentation and Release Notes.

How do I try this?

Get a free Microsoft Operations Management + Security (#MSOMS) subscription so that you can test the Container Monitoring Solution features. You can also get a free subscription for Microsoft Azure.

I invite you to follow me on Twitter and the Microsoft OMS Facebook site. If you want to learn more about Container Solution and OMS, visit the Hey, Scripting Guy! Blog.

How can I give you guys feedback?

There are a few different routes to give feedback:

• UserVoice: Post ideas for new OMS features to work on.  Visit the OMS UserVoice page.
• OMS Forums: Good general discussion of OMS.  Visit the OMS Forums.
• Email: OMScontainers@microsoft.com Tell us whatever is on your mind.
• Survey: Take a survey.

Your feedback is most important to us. If you see any features you like that are not here, we like to hear that from you as well.

Keiko Harada
Program Manager
Microsoft Operations Management Team

This blog post was contributed by the Azure Stack Team.

Today, we are excited to announce preview releases of Azure PaaS services for Azure Stack TP2. Specifically, this release includes Azure App Service (includes Web Apps, API apps, and Mobile apps) and updated versions of SQL/ MySQL database. Download and deploy these capabilities. Once deployed, you can build powerful web and mobile applications between Azure and Azure Stack, enabled by true hybrid cloud consistency.

Based on your feedback, we’ve also updated the TP2 bits to streamline the deployment experience. Updated bits are available here. TP2 has many new capabilities that will enrich your Azure-consistency experience, including new Azure services such Queue Storage and Key Vault.

You will need to redeploy TP2 using the updated bits above before deploying the Azure PaaS services.

Visit our technical documentation page to guide your deployment efforts.

You can learn a lot more about the innovation in these releases by watching this video.

Visit the Azure Stack forum for troubleshooting help or if you’d like to provide feedback.

We’d love to hear from you!

The Holiday season is coming, which means it’s list making season and Cortana has a new list skill* to help you out. With the new list skill, Cortana can now easily and conveniently help you manage your lists and keep track of the things you need to do so you don’t have to.

Whether it’s planning a holiday meal, buying gifts, getting things done before you head out for vacation, or keeping track of who’s naughty or nice, you can use your voice or type to quickly create a new list, add to an existing list when inspiration strikes, and pull up your lists just when you need them on any device. Cortana will automatically start a Grocery, To Do and Shopping list for you so it’s easy to get started. The list skill will also be available through Cortana on your mobile phone**.

For deeper lists functionality, Cortana can also work with Wunderlist, one of the most loved list-making apps, to give you even more ways to make lists and stay organized. You can connect Cortana to your Wunderlist account or set up a new account for greater functionality and access to the lists you already have if you’re a current Wunderlist user.  Connecting to Wunderlist gives you the ability to add due dates to your To Dos and create shared lists from the Wunderlist app.

Check it out for yourself by saying “Hey Cortana, create a Holiday list”. The list skill is just one of the ways that Cortana remembers, so you don’t have to. We’re always adding new Cortana skills so keep checking back at the Windows Blog for the latest.

*Available in English in US only 
** Cortana only available with Android 4.4 or later, iPhones with iOS 8.0 or later and Windows 10 in the US.  

SQL Server 2016 Analysis Services delivered numerous performance improvements over previous releases, such as better modeling performance thanks to the new 1200 compatibility level for tabular databases, better processing performance for tables with multiple partitions thanks to parallel partition processing, and better query performance thanks to additional DAX functions that help to optimize the client/server communication. And with SQL Server 2016 Service Pack 1 (SP1), Analysis Services can deliver even more performance and scalability improvements through NUMA awareness and optimized memory allocation based on Intel Threading Building Blocks (Intel TBB), helping customers to lower Total Cost of Ownership (TCO) by supporting more users on fewer, more powerful enterprise servers.

SQL Server 2016 SP1 Analysis Services features improvements in these key areas:

• NUMA awareness– For better NUMA support, the in-memory (VertiPaq) engine inside Analysis Services SP1 maintains a separate job queue on each NUMA node. This means that the segment scan jobs run on the same node where the memory is allocated for the segment data. Note, NUMA awareness is only enabled by default on systems with at least four NUMA nodes. On two-node systems, the costs of accessing remote allocated memory generally doesn’t warrant the overhead of managing NUMA specifics.
• Memory allocation– Analysis Services SP1 uses an Intel TBB-based scalable allocator that provides separate memory pools for every core. As the number of cores increases, the system can scale almost linearly.
• Heap fragmentation– The Intel TBB-based scalable allocator is also expected to help mitigate performance problems due to heap fragmentation that have been shown to occur with the Windows Heap. For more information, see the Intel TBB product brief at https://software.intel.com/sites/products/collateral/hpc/tbb/Intel_tbb4_product_brief.pdf.

Microsoft internal performance and scalability testing shows significant gains in query throughput when running SQL Server 2016 SP1 Analysis Services on large multi-node enterprise servers in comparison to previous Analysis Services versions. Please note that results may vary depending on your specific data and workload characteristics.

Download SQL Server 2016 SP1 from the Microsoft Download Center at https://www.microsoft.com/en-us/download/details.aspx?id=54276 and see for yourself how you can scale with Analysis Services SP1. Also, be sure to stay tuned for more blog posts and white papers covering these exciting performance and scalability improvements in more detail.

Today’s post was written by Koen Timmers, web design teacher and Microsoft Expert Educator Fellow at the Cvo de Verdieping School.

I was invited to the Maverick Teacher Global Summit 2016 near Bangalore, India. We worked in groups on seven United Nations sustainability goals. As I spoke to the Indian teachers, I discovered nobody in India thinks about drinking tap water, except for the poor people who even seem to have become immune for diseases. It inspired me to set up a global project about water.

I choose countries based on three criteria:

• Combined, they represent nearly every continent of the world, having different religions, cultures, languages and habits.
• They all have inspiring water-related places (Dead Sea, Amazon, Ganges, desert, Mississippi, etc.).
• They deal with very different water-related issues, like water shortage, lack of clean water and spoilage of water.

I contacted teachers from around the world and ended with nine schools participating from six continents: Argentina, Belgium, Brazil, India, Israel, Kenya, New Zealand and the U.S. (California and Minnesota)—and the Global Water Project was born.

To me, setting up a new project means creating a new OneNote Notebook. It allows me to brainstorm, to collect links and phrases while doing research, to sketch, note ideas and bring structure to abstract data. Once I had a final draft of the project, I shared the document with some schools who already decided to participate. While we were collaborating in this shared OneNote Notebook we could finalize the document.

One teacher involved in the project stated:

“Water is such a precious resource and vital commodity. I am thrilled that we are involved in the Global Water Project, so my students not only learn from their peers about the challenges of getting clean water in other parts of the world, they also learn to appreciate the water they have here and how important it is to take care of it.”—Tammy Dunbar

Planning the weekly topics in OneNote.

The goal was to make the project student-centered and interdisciplinary. We wanted students to discover, create, collaborate, present and share—keeping 21^st-century learning skills in mind. Students turned into journalists and classrooms into newsrooms. The weekly topics were related to Science, Geography, ICT, Literature, Biology, History and Health. I believe that computers need to be in the classroom for every subject, as this allows students to automatically and instinctively learn how to use computers while immersed in the subject.

The 21^st-century learning design offers a perfect framework by:

• Providing real-world problem solving. What better way to learn about issues in other countries, like water scarcity, than by talking with people from these countries?
• Offering collaboration. Collaborative learning is key. Knowledge created in a group has higher value than knowledge offered by a teacher.
• Extending Information and Communication Technology (ICT) for learning.
• Delivering knowledge construction. Students had to be creative and find solutions to existing problems and went beyond knowledge reproduction to generate ideas.

Behaving as real journalists the students did research and developed ideas. They gathered and analyzed information and used multimedia—both articles and videos—to address the audience.

Students from New Zealand went on an excursion to take and test water samples.

Time to bring more structure to the OneNote Notebook. I created one section for each participating country, which contained pages to track ideas, note research, add links and stories in pipeline and to publish the results.

Over five weeks, the students were presented five topics. As part of an introduction they had to present water-related places in their area. In a later stage, they needed to write reports and articles about the quantity, quality and use of water. Every weekly topic was introduced by a flyer I created.

The weekly topics were introduced via flyers.

Global reach

This project needed to be global. What’s better than learning about another culture, religion and habits than speaking to these people in person? By looking at their presentations, the students began to create in small groups. Every country used different approaches. In some schools, students created one specific slide in one PowerPoint presentation. In other schools, students collaborated in small groups while each group made their own PowerPoint presentation. After presenting the outcomes to their peers, the presentations were sent to every participating country so students could learn directly from students with very similar interests in very different countries.

The teacher became a guide rather than an instructor. Here are two examples of the results:

Belgian students creating articles in groups.

Israeli students creating articles in groups.

Collaborative learning is key

Knowledge constructed by students in group has a greater value than knowledge offered by a teacher. By putting students in the journalist role, they learn to create, present and share content with a critical eye. All students worked in one shared OneNote Notebook, which allowed them to structure, collaborate and share content. It also allowed teachers to guide their students when needed.

OneNote offers a canvas that allows to users to insert text and hyperlinks, multimedia and handwriting. Once projected on a wall, it can be a whiteboard—an easy alternative for expensive smart boards—without any limitations.

OneNote can also be used as a photo gallery since it allows to insert many pictures.

Students doing research about the Mississippi River.

What followed was simply amazing. The innovative teachers involved sent impressive photos and stories. Some spontaneously started using Minecraft to recreate some geographical spots, others went on an excursion to lakes and created their dream pool in Legos. Students created stop-motion videos and created Sways. Some used Lifeliqe to demonstrate the water cycle and others created videos using a green screen, to overcome the language barrier.

We never had live contact with each other during the first weeks. We only sent emails and collaborated in ONE OneNote Notebook. At the end of the project we set up Skype meetings with one another to “meet” each other in person.

Students inking and collaborating in a OneNote Notebook.

But we tried to go further than scenarios in which students were discovering and sharing facts. We wanted them to find solutions to help bring change in the students’ homes. Some schools invited the students’ parents to speak about water spoilage and water conservation. In our project, the aim was to prevent students and their parents wasting water and at the same time bringing them to drink more water—instead of soft drinks—and live healthier in general.

Students interviewing their parents about wasting water and noting solutions in OneNote.

For the water wastage topic, I put the participating schools in two different groups. Each group got access to another OneNote Notebook. To bring a small competition between both groups, they were asked to create the longest list of tips to prevent water spoilage. They used Skype to collaborate live. They drew and created messages for their peers which were discovered a few hours later because all participants live in different time zones.

So, could we possibly have conducted this global project about water without ICT? No. The students needed tools to find, analyze, structure, present and share information and to communicate with students from very different countries in different parts of the world. The students eagerly turned their classroom into a newsroom and only wanted their time in the classroom to this project.

—Koen Timmers, in collaboration with Jennifer Verschoor (Argentina), Olivier Dijkmans (Belgium), Neeru Mittal (India), Karina Batat (Israel), Hannington Ochieng (Kenya), Nikkie Laing and Jodi Hill (New Zealand), Tammy Dunbar (California, U.S.) and Luke Merchlewitz (Minnesota, U.S.)

The post Students becoming journalists in Global Water Project appeared first on Office Blogs.

For the first time in history there are five generations in the workforce. Watch the latest episode of Modern Workplace to understand how to turn this challenge into an opportunity by creating cohesive teams that take advantage of the diversity of multiple generations.

Learn from experts Haydn Shaw, speaker and author of “Sticking Points,” and Asha Sharma, COO of Porch.com, as they discuss their experiences in creating organizational cultures that thrive using diverse workforces.

Here are some of the key insights you’ll gain:

• Having a multi-generational workforce is needed to reach multi-generational customers.
• Make an active effort to intermingle generations.
• Focus on strengths and opportunities with a diverse workforce.
• Make sure your leadership team is multi-generational.

Also, hear from Jamie McLellan, CTO of J. Walter Thompson, about how his organization is using technology to take advantage of generational diversity. McLellan discusses his organization’s use of Microsoft Teams—a new capability in Office 365.

Microsoft Teams helps bridge the generational divide with a chat-based workspace for collaboration. It combines the structure of email with the network approach of social networking to deliver a collaboration solution for all generations. And it delivers the security and compliance capabilities you have come to expect from Office 365.

Watch the Modern Workplace episode to learn more.

Get the free e-book: “5 Tips for Improving Collaboration.”

The post Managing a multi-generational workforce appeared first on Office Blogs.

Today at Connect() we announced the release of the Visual Studio Tools for Unity 3 Preview. VSTU is Microsoft’s free Visual Studio add-on that enables a rich programming and debugging experience for working with the Unity gaming tools and platform.

VSTU 3 Preview is part of the «Game Development with Unity» workload that you can install from the Visual Studio 2017 RC installer. With this workload, Unity developers can install just what they need to write and debug cross-platform Unity games with Visual Studio 2017 RC.

VSTU 3 Preview is also available for Visual Studio 2015 Update 3 on the Visual Studio Gallery at the following link:

• Visual Studio 2015 Tools for Unity

VSTU 3 focuses on improving on the fundamentals of an IDE: code editing and debugging. The highlights of this release include:

Code Coloration for Unity messages: Unity messages (or event functions) now stand out from other methods in the editor. By default, they’ll be colored like keywords, but you can change them to your liking. In this screenshot they’re configured to be colored in bright orange.

IntelliSense: VSTU 3 Preview plugs into Visual Studio’s C# IntelliSense engine to provide code completion for Unity messages. Just start declaring a method, and if you’re in a class that supports Unity messages, our IntelliSense will kick-in and show you the list of Unity messages your script can implement.

Improved Expression Evaluator: The expression evaluator is responsible for displaying the values of the Locals and the results of the expressions you input into the Watch and Immediate Window. We’ve improved our expression evaluator to behave closer to the .NET debugger that C# developers know and love.

If you have any suggestion or encounter any issue with VSTU 3 Preview, please report it via Report a Problem either from the installer or the Visual Studio IDE itself. Track your feedback on the developer community portal. For suggestions, let us know through UserVoice. Please share your feedback and help us ship a great VSTU 3!

Jb Evain, Principal Software Engineer Manager @jbevain Jb runs the Visual Studio Tools for Unity experience He has a passion for developer tools and programming languages, and has been working in developer technologies for over a decade.

Hello Windows Insiders!

Today we are excited to be releasing Windows 10 Insider Preview Build 14971 for PC to Windows Insiders in the Fast ring.

What’s new in Build 14971

Read EPUB books in Microsoft Edge: The reading experience will get even better with the Windows 10 Creators Update! In addition to providing a great reading experience for PDF files – you can now read any unprotected e-book in the EPUB file format with Microsoft Edge. When you open an unprotected e-book in Microsoft Edge, you will be taken into a customizable reading experience where you can change the font and text size and choose between 3 themes: light, sepia, and dark. As you read, you can leave bookmarks. To navigate through an e-book, you can use the table of contents or seek bar at the bottom of the browser. And you can also search for words or phrases and use Cortana to define specific words.

You can download and read unprotected e-books from places like Feedbooks, Project Gutenberg, Free eBooks (requires sign-up), ePubBooks (requires sign-up), Open Library and even our own Microsoft Press. Try out reading an e-book in Microsoft Edge and let us know what you think!

Bringing 3D to Everyone via the Paint 3D Preview app: Starting with this build and going forward, the Paint 3D Preview app is now included as part of Windows 10. Opening Paint from Start will now take you to the Paint 3D Preview app. Please try it out and let us know what you think we should improve or add next! Currently, Paint 3D Preview is only available in English (aka, regardless of your display language, the text will be in English) – support for other languages will be coming soon. Remix 3D Preview, the community counterpart to Paint 3D Preview, is expanding to Austria, Belgium, Denmark, Germany, Ireland, Netherlands, Norway, Sweden, and Switzerland for Windows Insiders today! Remix 3D Preview is currently only available in English but we will continue to expand our region and language support. You can check it out at Remix3D.com and from within the Paint 3D Preview app.

PowerShell in the Shell: In an effort to bring the best command line experiences to the forefront for all power users, PowerShell is now the defacto command shell from File Explorer. It replaces Command Prompt (aka, “cmd.exe”) in the WIN + X menu, in File Explorer’s File menu, and in the context menu that appears when you shift-right-click the whitespace in File Explorer. Typing “cmd” (or “powershell”) in File Explorer’s address bar will remain a quick way to launch the command shell at that location. For those who prefer to use Command Prompt, you can opt out of the WIN + X change by opening Settings > Personalization > Taskbar, and turning “Replace Command Prompt with Windows PowerShell in the menu when I right-click the Start button or press Windows key+X” to “Off”.

Fun fact! It’s PowerShell’s 10 year anniversary this week. Hop over to Channel 9 to see some of the videos we’ve been sharing about it. If you’re looking to learn more about unleashing the “power” in PowerShell, this page is a great resource.

Improved Typing Experience with Japanese and Chinese Input Method Editors (IMEs): This build includes many improvements in this space – here are some of the highlights:

• Improved Chinese IME reliability. In particular, we fixed an issue where the IME might crash due to an incompletely downloaded or corrupted dictionary file
• Improved Conversion Accuracy for the Japanese IME. We also fixed various issues, in particular, when conversion was used mixed with prediction, and an UX issue when trying to change phrase segmentation.
• Improved resource usage when typing with the Japanese IME. In particular, we fixed an issue that could result in unexpected graphic glitches after using the IME for an extended period of time.

Get Office (Beta): We’ve heard your feedback about the Get Office app, and today we’re happy to announce Get Office version 2.0 for Insiders in the Fast ring! (Well, technically, version 17.7614.2377.0). Whereas before Get Office was largely a collection of links to help you get started with Office, the new and improved app will help you explore and manage your Office experience. Easily discover and launch apps and see all your recent Office documents in one place! We still have the familiar help links, but we’ve redesigned the experience to make easier to find what you’re looking for. As you try out the new app, please log feedback – we’d love to hear your thoughts!

Other changes, improvements, and fixes for PC

• First introduced to Insiders in Build 14926, the experimental “Snooze” action on a tab in Microsoft Edge which provides you with a way to set a Cortana reminder on the website you are viewing is no longer available. Based on data we gathered and feedback we received, we decided to remove it from the product and re-evaluate the feature for a future release.

• The cursor will no longer be shown while inking – we believe this makes the experience feel even more like pen on paper. Try it out and let us know what you think!
• We’ve improved reliability when using the protractor and inking in Sketchpad.
• We’ve updated some of our desktop wizards (including “map a network drive” and “extract from zip”) to now be proportionally sized when moved across monitors.
• We fixed an issue where Magnifier’s keyboard shortcuts sometimes wouldn’t work on the Lock screen.
• We fixed an issue that could result in sometimes not being able to completely remove files in the Windows.old folder using Disk Cleanup.
• We have enabled OAuth support for Yahoo Mail accounts. This will improve sync reliability for those accounts, and provide a more secure experience in the Outlook Mail app.
• We fixed an issue where trying to shut down the PC while certain Device Manager dialog boxes were open would result in the PC being stuck at the “Restarting…” screen.
• We fixed an issue where, as closing multiple tabs with middle click in Microsoft Edge, the width of the tabs might change, resulting in potentially unexpectedly closing the wrong tab.
• We fixed an issue where the copy link option when right-clicking a hyperlink in Microsoft Edge wasn’t work.
• We fixed an issue where, if you changed the size of the Microsoft Edge window, and then closed the app by closing the final tab, the next time Microsoft Edge is launched it would once again be the default size, rather than retaining the preferred window size.
• We fixed an issue where pinned tabs in Microsoft Edge were not being restored.
• We’ve made a number of translation improvements, including for Chinese speakers fixing a translation error in the dialog that appears when installing multiple fonts at once, as well as one in Settings > System > Battery. If you see any other translations that aren’t as you’d expect, please log feedback – we’re listening!
• We fixed an issue where, if you already hand a notification expanded in the Action Center, clicking the chevron to expand a second notification would result in it expanding then immediately closing.
• We fixed an issue where preferred Start menu width might not be preserved after rebooting.

Known issues for PC

• Navigating to Settings > System > Battery will crash the Settings app.
• Using keyboard monitor hotkeys to adjust brightness won’t work as expected. Desired brightness change could be done via the Action Center or by going to Settings > System > Display.
• Apps such as Store, Photos, and People may launch on their own after your PC has been inactive for a period of time. To stop these apps from launching on their own, un-maximize the app before closing it.
• As we have previously announced we are working on the Windows Holographic Shell that is going to be included in the upcoming Windows 10 Creators Update. In today’s flight you will see the Windows Holographic First Run app. While you will be able to launch the app and walk through the first few screens, it won’t detect any hardware. This app and the Windows Holographic Shell is still under active development here at Microsoft and with our partners.

Team Updates

Last week, the Windows Insiders team had several sessions as part of the MVP Summit as well as a #WindowsInsiders dinner. It was awesome to hear everyone’s passion for the future of Windows products!

We love seeing our Windows Insiders organize #WINsiders4Good events on their own! This is exactly why we created the DIY kit and we love seeing you all use it to build relationships and solve problems in your communities.

There is an event happening on London on 12/15 hosted by Michael Gillett, so please register if you are able to attend.

Please note that we will not be releasing any new builds next week. Next week is the Thanksgiving holiday here in the U.S. and much of the team is taking some well-deserved time off to celebrate the holiday with their families.

Thank you everyone and keep hustling,
Dona <3

With the release of Visual Studio 2017 RC this week, we’re introducing you to the latest and greatest release of the Visual Studio Tools for Apache Cordova (TACO). In this release, we’re tackling the big problems – the issues we know you face every day as mobile developers. They fall into two major themes:

1. Fast, reliable builds. The new Visual Studio Installer, combined with offline installation of a fully validated toolchain of 3^rd party components, provides for faster builds that are also easier to troubleshoot and fix.
2. Incredible edit-debug speed. A new browser-based simulator enables you to code fast and see the results immediately in the browser. Live reload, plugin simulation and support for Ionic Framework give VS the fastest developer workflow on the market.

Fast, reliable builds

When we talk with Cordova developers, by far the most common issues are around environment setup and building applications. This makes sense, because building is what Cordova is all about – i.e. building a native application using the native target platform SDKs. Our data indicate that 26% of developers using TACO encounter an error during their first build due mostly to issues with NPM and network firewalls. In this release, we set out to fix that.

A fast install that just works

With the new Visual Studio Installer, we created a Mobile development with JavaScript workload that is designed to give you a quick install that “just works.”

For this workload, we trimmed the total number of toolchain dependencies and applied an extra layer of testing. Using our new validated “toolsets”, mobile developers get all the components required for pre-release development – including open source packages like Cordova – so even those of you who require offline installation are good-to-go! In early trials, most developers could go from “download” to “code” within 15 minutes.

As your app moves from prototype to production, Visual Studio will prompt you to install any missing dependencies. For example, if you’re missing the Android SDK when you try to deploy to a device, Visual Studio will offer to grab it for you. Isn’t that nice? This lets you start simple and progressively install more complex toolchain dependencies as your app grows.

Toolsets

In addition to streamlining installation, we’ve worked hard to make sure builds are reliable in a wide variety of environments. Most build issues reported to us are related to a combination of npm failures, network firewalls and incompatibilities in the local toolchain. To help you get (and stay) on the right track, we’re introducing the concept of TACO “Toolsets.” A Toolset combines a set of validated tools into a single package which can be used by Visual Studio. For example, the default Cordova 6.3.1 toolset includes Cordova 6.3.1, Node 4.4.3, and NPM 2.15.0. Regardless of what else is installed on your computer, TACO will use a sandboxed toolset when building your application. By using a known combination of tools, you can be confident that builds will work as expected. If you’re more of an independent tinkerer, there’s also an option to use the Global instance of any toolchain dependency, so you maintain total control.

To configure the toolset your project will use, open config.xml and go to the Toolset section of the editor. Toolsets are built, maintained and distributed by Microsoft. Our team will release new toolsets shortly after new versions of iOS, Android and Windows become available, so make sure to check Visual Studio for updates often.

Making it easier to understand build errors

Finally, to help troubleshoot build errors when they happen, we’ve made a small and important change to make it easier to wade through build output. We’ve color-coded errors in the build output pane for easier reading and have added headers to call out steps in the build output to help you identify where in the build process there was a failure.

Beyond being helpful, it’s also a fun excuse to use some ASCII art.

Incredible edit-debug speed

This release introduces to Visual Studio a popular feature from our Visual Studio Code Cordova Tools extension: Cordova Simulate. For those that have been using TACO for a while, Cordova Simulate replaces the Ripple emulator that we have been using for in-browser simulation of mobile apps. It provides for a local, fast, browser-based workflow that fits with modern web developer practices that lets you do almost all your mobile development without touching an emulator or device.

Like Ripple, Cordova Simulate will empower you to:

• Test at varying devices sizes.
• Simulate geolocation, compass, and accelerometer settings.
• Live reload for images, stylesheets, JavaScript, and HTML.
• Use browser developer tools like a DOM explorer and JavaScript debugger, all from within Visual Studio.

Going beyond Ripple, Cordova Simulate then lets you:

• Simulate even more plugins like Camera, Contacts, File, Media, and more (see the documentation for details).
• Simulate your app in a dedicated browser window rather than an iframe.
• Save API responses for custom or uncommon plugins.

Look for an upcoming deep-dive post on this blog which will take you through all the details of this new tool.

Try out Visual Studio 2017 RC and let us know what you think

Beyond the features highlighted here, we’ve also fixed numerous bugs in the product and re-written the build process to increase stability and decrease heavy build times. If you’re interested in trying out Cordova to build mobile apps, please try out this release and let us know what you think!

As you work with the tools, share your thoughts: send us direct emails, talk with us on Stack Overflow, send us a tweet on Twitter, or provide feedback for our documentation directly on our documentation site.

To get updates about future pre-release software, consider joining our TACO insiders, we’d love to work with you.

Jordan Matthiesen (@JMatthiesen) Program Manager, JavaScript mobile developer tools Jordan works at Microsoft on JavaScript tooling for web and mobile application developers. He’s been a developer for over 18 years, and currently focuses on talking to as many awesome mobile developers as possible. When not working on dev tools, you’ll find him enjoying quality time with his wife, 4 kids, dog, cat, and a cup of coffee.

We are continuously working on improving and simplifying the deployment experience to Azure from Visual Studio Team Services. As a part of that effort, we are excited to announce preview of the Continuous Delivery feature we have added for App Services in the Azure portal.

Continuous Delivery simplifies setting up a robust deployment pipeline, you can setup a pipeline right from the Azure portal that builds, runs tests, and deploys to staging slot and then to production for every code commit/batch of code commits.

Later, you can easily extend this deployment automation to handle any other operations your application nee ds to do during deployment. For example, provision additional Azure resources, run custom scripts, or upgrading database. You can even choose to deploy automatically or setup manual approval for any deployment going to production.

You can start using this feature by navigating to your app’s menu blade in the Azure portal and clicking on APP DEPLOYMENT > Continuous Delivery (Preview).

Setting up continuous delivery is a four-step wizard. In the first two steps, we ask you to choose the source code repository and fill in the framework details. This helps us build and package the application for deployment. Currently we are supporting Visual Studio Team Services and Github as source repositories and we have plans to expand this list. Similarly on the application types we are starting with ASP.NET and ASP.NET core and we will enhance to other web applications as well.

The last two steps are optional and you can choose to opt in for setting up a load test and staging environment.

If you choose to setup a load test environment we will create a new Azure App Service (you can also choose an existing App Service) and setup a load test with 25 virtual users concurrently accessing the Azure App Service for a duration of 60 seconds.

Similarly, if you opted in for setting up a staging environment then we will publish your latest changes first to staging slot and then promote to production. You can either choose an existing Azure App Service slot or create a new one.

As a part of the Continuous Delivery setup The following sequence of events occurs:

• Azure Continuous Delivery creates a build and a release definition in the Team Services account you specified, together with a service endpoint to connect to Azure.
• If you chose to create a new Azure App Service instance for load tests, and/or a new slot for staging, these are created in your Azure subscription.
• After setup has completed successfully, a build is triggered that builds and packages the application for deployment.
• After the build has completed successfully, a new release is created and the deployment triggered.
• If you chose to include a load test, the latest changes are first deployed to the Azure App Service you selected, and then the load test is executed after the deployment succeeds.
• If you chose to use a staging slot, the latest changes are deployed to the staging slot and then a slot swap is performed to complete the continuous delivery workflow.

After all these actions have completed, the Azure portal shows the logs.

In the “Successfully set up Continuous Delivery…” item, choose the Build Definition link to open the project containing your app in Team Services, and see the summary for the build definition. Choose Edit to see the tasks that have been added and configured.

You can verify that continuous deployment is occurring from the repository containing your app by pushing a change to the repository. Your app should update to reflect the changes shortly after the push to the repository completes.

Refer to documentation to learn more about Continuous Delivery to Azure App Services.

Try out Release Management in Visual Studio Team Services.

For any questions, comments and feedback – please reach out to Gopinath.ch AT microsoft DOT com.

Thanks

Gopinath

Release Management Team

Twitter: @gopinach

This post is by Nagesh Pabbisetty, Partner Director of Program Management.

Since we released Microsoft R Server on HDInsight in preview in March 2016, customers have used it for predictive modeling, machine learning, and statistical analysis. With the general availability of R Server for HDInsight customers will be able to leverage the largest portable R-compatible parallel analytics and machine learning libraries in production environments with 99.9% SLA. The combination of R Server and HDInsight provides the following:

• Terabyte-scale machine learning that is 1,000x larger than in open source R
• Up to 50x faster performance using R Server for Apache Spark and optimized vector/math libraries
• Enterprise-grade security and support backed by a Microsoft SLA
• Run distributed parameter sweeps and simulations with existing R functions
• Support for Spark 2.0
• Support for Hive and Parquet data sources
• Support for Spark dataframes
• Easy setup for fast results

You can find more details here:
https://azure.microsoft.com/en-us/services/hdinsight/r-server/
During the past year, we learned a lot from customers using Microsoft R to bring intelligence to where their data lives and we will continue the momentum by releasing the next version of Microsoft R Server and R Client on all platforms in December.