CppCast Episode 60: Visual C++ Conformance with Andrew Pardoe

By robwirving | Jun 17, 2016 07:44 AM | Tags: None

Episode 60 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Andrew Pardoe to discuss Visual C++ conformance progress as well as experimental features like Modules.

CppCast Episode 60: Visual C++ Conformance with Andrew Pardoe

by Rob Irving and Jason Turner

About the interviewee:

Andrew started working at Microsoft in 2002. He worked for the C++ team for exactly five years, first on testing the Itanium optimizer and then on the Phoenix compiler platform. He left in 2007 to become a PM on the CLR team (the C# runtime). Andrew left that job about two years ago and through the magic of corporate reorgs ended up as the C++ compiler PM.

In his role at Microsoft Andrew pays attention to pretty much everything without a GUI: the compiler front end/parser, code analysis, and a little bit to the optimizer. He also owns the tools acquisition story—such as the VC++ Build Tools SKU and updating to latest daily drops through NuGet—and Clang/C2. The Clang/C2 work is what ties Andrew into the Islandwood team, and the code analysis work focuses mostly on the C++ Core Guidelines checkers.

CppCon 2015 Haskell Design Patterns for Genericity & Asynchronous Behavior--Sherri Shulman

By Adrien Hamelin | Jun 15, 2016 01:50 PM | Tags: experimental community

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Haskell Design Patterns for Genericity & Asynchronous Behavior

by Sherri Shulman

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

The paper explores some of Haskell's support for genericity through type classes, Functors, Monads, and Continuations and their impact on lanugages such as C++, Scala, and Rust. We explore these language features and consider alternatives that have been proposed to existing language features, including Object Algebras, GADTs, Open data types, open pattern matching, and extensions to Haskell's type system that impact the type inference algorithm and decidability. We use a number of case studies to demonstrate what proposed solutions look like in the target languages, considering how easy they are to use and how well the solutions integrate with existing linguistic features.

GoingNative 50: New Visual C++ Code Optimizer--Eric Battalio, Steve Carroll and Augustin Popa

By Adrien Hamelin | Jun 13, 2016 12:53 PM | Tags: performance community

The new GoingNative is out!

GoingNative 50: New Visual C++ Code Optimizer

by Eric Battalio, Steve Carroll and Augustin Popa

From the video:

Happy 50th episode! This episode covers our new, more advanced code optimizer for the Visual C++ compiler back-end. It provides many improvements for both code size and performance, bringing the optimizer to a new standard of quality expected from a modern native compiler.

This is the first public release and we are encouraging people to try it and provide suggestions and feedback about potential bugs. The official release of the new optimizer is expected to be Visual Studio Update 3, while the release available today is unsupported and mostly for testing purposes.

Read our blog post to get the details!

CppCon 2015 constexpr: Introduction--Scott Schurr

By Adrien Hamelin | Jun 13, 2016 12:41 PM | Tags: intermediate c++14

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

constexpr: Introduction

by Scott Schurr

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

I'm excited about constexpr. It's probably my favorite C++11 feature and it's gotten even better with C++14. This talk will introduce constexpr to the uninitiated. We'll start with C++11 and continue into the improvements introduced with C++14. We'll look into useful ways to think about constexpr code. We'll also cover some tips and tricks with writing constexpr code.

CppCon 2015 Live Lock-Free or Deadlock (Practical Lock-free Programming)--Fedor Pikus

By Adrien Hamelin | Jun 10, 2016 01:09 PM | Tags: efficiency advanced

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Live Lock-Free or Deadlock (Practical Lock-free Programming)

by Fedor Pikus

Part 1: (watch on YouTube) (watch on Channel 9)

Part 2: (watch on YouTube) (watch on Channel 9)

Summary of the talk:

Part I:

Introduction to lock-free programming. We will cover the fundamentals of lock-free vs lock-based programming, explore the reasons to write lock-free programs as well as the reasons not to. We will learn, or be reminded, of the basic tools of lock-free programming and consider few simple examples. To make sure you stay on for part II, we will try something beyond the simple examples, for example, a lock-free list, just to see how insanely complex the problems can get.

Part II:

having been burned on the complexities of generic lock-free algorithms in part I, we take a more practical approach: assuming we are not all writing STL, what limitations can we really live with? Turns out that there are some inherent limitations imposed by the nature of the concurrent problem: is here really such a thing as “concurrent queue” (yes, sort of) and we can take advantages of these limitations (what an idea, concurrency actually makes something easier!) Then there are practical limitations that most application programmers can accept: is there really such a thing as a “lock-free queue” (may be, and you don’t need it). We will explore practical examples of (mostly) lock-free data structures, with actual implementations and performance measurements. Even if the specific limitations and simplifying assumptions used in this talk do not apply to your problem, the main idea to take away is how to find such assumptions and take advantage of them, because, chances are, you can use lock-free techniques and write code that works for you and is much simpler than what you learned before.

 

CppCast Episode 59: foonathan/memory and standardese with Jonathan Müller

By robwirving | Jun 10, 2016 06:44 AM | Tags: None

Episode 59 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Jonathan Müller to discuss some of his recent blog posts, as well as the foonathan/memory library and the standardese documentation generator.

CppCast Episode 59: foonathan/memory and standardese with Jonathan Müller

by Rob Irving and Jason Turner

About the interviewee:

Jonathan is a CS student passionate about C++. In his spare time he writes libraries for real-time applications and games. He is mainly working on foonathan/memory which provides fast and customizable memory allocators that are easily integrated into your own code. Jonathan tweets at @foonathan and blogs about various C++ and library development related topics at foonathan.github.io. The blog posts are well received and often shared in the cpp subreddit or ISO C++.

CppCon 2015 C++ in the Audio Industry--Timur Doumler

By Adrien Hamelin | Jun 8, 2016 11:57 AM | Tags: performance advanced

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

C++ in the Audio Industry

by Timur Doumler

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Sound is an essential medium for human-computer interaction and vital for applications such as games and music production software. In the audio industry, C++ is the dominating programming language. This talk provides an insight into the patterns and tools that C++ developers in the audio industry rely on. There are interesting lessons to be learned from this domain that can be useful to every C++ developer.

Handling audio in real time presents interesting technical challenges. Techniques also used in other C++ domains have to be combined: real-time multithreading, lock-free programming, efficient DSP, SIMD, and low-latency hardware communication. C++ is the language of choice to tie all these requirements together. Clever leveraging of advanced C++ techniques, template metaprogramming, and the new C++11/14 standard makes these tasks more exciting than ever.

CppCon 2015 Advanced Unit Testing in C & C++--Matt Hargett

By Adrien Hamelin | Jun 6, 2016 01:19 PM | Tags: intermediate

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Advanced Unit Testing in C & C++

by Matt Hargett

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This session goes in-depth into advanced techniques to isolate and unit test C++ classes, especially those in legacy code that isn't easy to change. This builds on the Pragmatic Unit Testing in C++ talk from last year, with live code examples of safe refactorings, injecting mock objects, and potential pitfalls across different platforms and toolchains.

C++ Weekly Episode 14: Standard Library Gems: `next` and `exchange`—Jason Turner

By Jason Turner | Jun 6, 2016 11:59 AM | Tags: c++14 c++11 basics

Episode 14 of C++ Weekly.

Standard Library Gems: `next` and `exchange`

by Jason Turner

About the show:

In this episode Jason discusses two somewhat obscure and surprisingly helpful C++ standard library functions, std::next which was introduced in C++11 and std::exchange which was introduced in C++14.

 

CppCon 2015 Variadic Templates in C++11 / C++14 - An Introduction--Peter Sommerlad

By Adrien Hamelin | Jun 3, 2016 02:26 PM | Tags: c++14 advanced

Have you registered for CppCon 2016 in September? Don’t delay – Early Bird registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2015 for you to enjoy. Here is today’s feature:

Variadic Templates in C++11 / C++14 - An Introduction

by Peter Sommerlad

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Writing class templates and functions accepting a variable number of arguments has been a burden before C++11. With variadic templates, both class templates with a variable number of arguments as well as functions can be formulated much easier and more type safe way.

Nevertheless, the authoring of variadic templates can be challenging for the uninitiated. Even the interpretation of variadic template code can be a problem, as Olve Maudal's famous pub quiz shows.

This session will build up understanding and the ability to use and author variadic template functions and variadic template classes from easy examples up to more complicated applications such as employing std::forward correctly, std::integer_sequence and other upcoming language features such as a template UDL operator that bridges the gap between string literals and std::integer_sequence.

Understanding pack expansion, sizeof... and other hard to get on first sight issues are my goal. In the end you should have seen guidelines that help you avoid the template instantiation trap from the pub quiz and correct usage of std::forward in your variadic templates.