Marc Gregoire’s Blog

On September 22th, 2016 I gave a presentation titled “Mobile App Development for Multiple Platforms with Visual C++, 2016” at CppCon 2016.
The slides of my presentation can be downloaded below:

Looking forward to next year’s edition of CppCon, which has been announced to be on September 25th-29th in Bellevue, Washington 🙂

The C++ Standard Library in the Visual Studio 2015 Update 2 release is C++11, C++14, and C++17-so-far feature complete. This includes all features from C++17 that are currently in that standard proposal: SFINAE-friendly result_of, improvements to pair and tuple, shared_mutex, removal of deprecated iostreams aliases, variable templates for type traits (is_same_v, …), as_const(), logical operator type traits (conjunction, …), owner_less<>, variadic lock_guard, and additions to <chrono>: floor(), ceil(), round(), and abs().
More information, including a detailed list can be found here.

On September 22th, 2015 together with Ankit Asthana from Microsoft I gave a presentation titled “Cross-Platform Mobile App Development with Visual C++ 2015” at CppCon 2015.
The slides of our presentation can be downloaded below:

Looking forward to next year’s edition of CppCon 🙂

The CppCon 2015 program is almost complete. The program contains over 100 one-hour sessions by over 80 speakers. This year, the opening keynote will be given by C++ creator Bjarne Stroustrup on Writing Good C++14.

I’ll be giving a presentation myself titled “Cross-Platform Mobile App Development with Visual C++ 2015” on Tuesday, September 22 (3:15pm – 4:15pm).

The next meeting of the Belgian C++ Users Group is planned for Wednesday December 17th, 2014 at 18:00 at TOMRA.

TOMRA ( http://www.tomra.com/ ) is sponsoring this event by providing the location, drinks and catering

The agenda is as follows:

• 18:00: Sandwiches.
• 18:30: Session 1: What’s new in VC++2015? (Marc Gregoire) An overview of new features and functionality in Microsoft Visual C++ 2015.
• 19:30: Break
• 19:45: Session 2: Move semantics && rvalue references, part 1 (Bert Rodiers) In this presentation we will be going deeper into move semantics and rvalue references. A large part of the presentation will talk about how to enable move support, discuss under which conditions it is applied and will point-out some potential pitfalls. We will also discuss Lambda generalized capture, which can be used to capture variables in a lambda expression using move semantics.
• 20:45: Presentation and/or guided tour of the TOMRA facilities for interested people followed by a drink.

The event is free for everyone, but you need to register for it.

There are 50 seats available for this event.

Note: The deadline for registrations is December 15th, 2014!

Ankit Asthana published an interesting blog post on the Visual C++ Team Blog about Speeding up the Incremental Developer Build Scenario.
The developer incremental scenario is one where a developer changes a single or multiple source files (while fixing bugs) and builds. This scenario for Visual C++ is roughly equivalent to the amount of time spent in linking the executable (.dll or .exe).
The blog post discusses the following new features:

• Incremental Linking for Static Libraries (/incremental linker switch)
• /Zc:inline and Algorithmic improvements (/Zc:inline compiler switch, 2X Faster Links)
• Fast Program Database (PDB) generation (/debug:FASTLINK linker switch, 2X Faster Links)
• Incremental Link Time Code Generation (iLTCG) (/LTCG:incremental linker switch, 4x faster links)

It’s definitely worth reading his post, it includes some impressive benchmarks 🙂

Visual C++ 2015 includes a general purpose solution to implement resumable functions based on the concept of coroutines. A coroutine is a generalized routine entity which supports operations like suspend and resume in addition to the traditional invoke and return operations.
These resumable functions are being proposed for inclusion in ISO C++17.
For the VC++ 2015 Preview, the feature only works for 64-bit targets, and requires adding the /await switch to your compiler command-line.
Such resumable functions have several use cases:

• Asynchronous operations
• Generator pattern
• Reactive Streams

Here is a simple example demonstrating an asynchronous operation:

#include <future>
#include <thread>
#include <experimental\resumable>

using namespace std; 
using namespace std::chrono; 
  
// this could be some long running computation or I/O
future<int> calculate_the_answer() 
{ 
    return async([] { 
        this_thread::sleep_for(1s); return 42; 
    }); 
} 
  
// Here is a resumable function
future<void> coro() { 
    printf("Started waiting... \n"); 
    auto result = __await calculate_the_answer(); 
    printf("got %d. \n", result); 
} 
  
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    coro().get(); 
}

The important line here is line 17. The function calculate_the_answer() is an asynchronous function which immediately returns by returning a future. Thanks to the __await keyword on line 17, the rest of the coro() function can be implemented as if you are simply programming synchronously! No need anymore to mess around with task continuations or what not. This makes asynchronous programming much easier 😀

Read the full explanation here.

Microsoft has released a preview of Visual Studio 2015.
There are a lot of C++ changes included in this preview. You can read the full release notes here.

Here is a short version quoted from a blog post from Eric Battalio from Microsoft:

• C++ Cross-Platform Mobile Development. C++ is attractive because it offers portability and a chance to reuse the same code on different platforms. With Visual Studio 2015 Preview, modern application developers can use the Visual C++ tool chain (c1xx, c2) to target Microsoft Windows Platforms and Clang / LLVM for targeting Android (with plans to support iOS in the near future). This makes it even easier to re-use existing C++ libraries to target multiple platforms (Android/Windows/iOS), share cross-platform code, and create high-quality Xamarin Native Android and Native-Activity applications using all of the power of Visual Studio. For a closer look, see Cross-Platform Mobile Development with Visual C++.
• C++11, C++14, C++17 (proposed) compatibility. Standards support across compilers improves portability. With Visual Studio 2015 Preview, Visual C++ is even more compliant with user-defined literals (C++11), generic lambdas (C++14), and await (C++17 proposed). For a view of VS conformance in table form, see this post by Stephan Lavavej (STL). Also check out Details About Some of the New C++ Language Features, Improvements to Warnings in the C++ Compiler, and Resumable Functions in C++.
• Enhanced productivity & build-time improvements. “Productivity” and “C++” are not often used in the same sentence except to criticize some aspect of the IDE, build process or diagnostics. Friction in any of these areas slows down the development process. With Visual Studio 2015 Preview, you get improvements in each including refactoring for C++ and improved IntelliSense database buildup and simplified QuickInfo for template deduction (IDE); incremental linking for static libs, new fast PDB generation techniques, multithreading in the linker (build); and dedicated space for analyzing graphics space using the Visual Studio Graphics Analyzer (VSGA) and you can view the impact of shader code changes without re-running the app (diagnostics). For more details about incremental build, see Speeding up the Incremental Build Scenario.
• Improved performance. Most of the C++ developers we spoke with needed code to run fast, often as part of intensive data transformation or analysis or real-time control. Visual Studio 2015 Preview builds on the AVX2 support in Visual Studio 2013 to bring more general optimizations like loop-if unswitching, Vectorization of control flow, and increased support for Vectorization (including when optimizing in favor of smaller code). In addition we have a number of ARM32 compiler code generation improvements.

 
See Eric’s blog post here for a couple more links.
Download the Visual Studio 2015 Preview.