CppCon 2016: Make Friends with the Clang Static Analysis Tools--Gabor Horvath

By Adrien Hamelin | Jul 14, 2017 02:17 PM | Tags: community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

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

Make Friends with the Clang Static Analysis Tools

by Gabor Horvath

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This talk is an overview of the open source static analysis tools for C++. The emphasis is on Clang based tools. While this talk is not intended to be a tutorial how to develop such tools I will cover the algorithms, methods and interesting heuristics that are utilized by them. Understanding these methods can be really useful as it helps us write more static analysis friendly code and understand the cause of false positive results. It will also help to understand limitations of the currently available tools. I will also present some guidelines how to make a library static analysis friendly, to make clients interested in such tools happy. I will also give a short tutorial on how to use these tools and how to integrate them into the work flow.

CppCast Episode 109: CopperSpice with Barbara Geller and Ansel Sermersheim

By robwirving | Jul 14, 2017 07:50 AM | Tags: None

Episode 109 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Barbara Geller and Ansel Sermersheim to talk about the CopperSpice C++ GUI Library.

CppCast Episode 109: CopperSpice with Barbara Geller and Ansel Sermersheim

by Rob Irving and Jason Turner

About the interviewees:

Barbara is an independent consultant working as a programmer and software developer for over 25 years. She has been a featured speaker at more than a dozen trade shows and computer conferences in the US and on two separate occasions Barbara taught an extended class in software architecture and GUI design for the Panama Canal Commission in Panama.

Ansel has been working as a programmer for over 15 years. Ansel worked for 8 years at a communications company designing scalable, high performance, multi-threaded network daemons in C++ and he is currently a software consultant for RealityShares in San Francisco.

CppCon 2016: C++ Coroutines: Under the covers--Gor Nishanov

By Adrien Hamelin | Jul 12, 2017 12:05 PM | Tags: experimental efficiency

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

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

C++ Coroutines: Under the covers

by Gor Nishanov

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Coroutines feel like magic. Functions that can suspend and resume in the middle of the execution without blocking a thread! We will look under the covers to see what transformations compilers perform on coroutines, what happens when a coroutine is started, suspended, resumed or cancelled. We will look at optimizations that can make a coroutine disappear into thin air.

CppCon 2016: std::accumulate: Exploring an Algorithmic Empire--Ben Deane

By Adrien Hamelin | Jul 10, 2017 12:04 PM | Tags: stl intermediate

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

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

std::accumulate: Exploring an Algorithmic Empire

by Ben Deane

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

What is the most powerful algorithm in the STL? In the world? There are many cases to be made. But this talk explores what I think is a pretty good candidate, which C++ calls std::accumulate(). Tucked away in ＜numeric＞, perhaps relatively unregarded when compared with workhorses like std::find_if() and std::partition(); nevertheless, std::accumulate() is in some sense the ur-algorithm on sequences.

Let’s explore the result of looking at code through an accumulate-shaped lens, how tweaking the algorithm for better composability can unlock many more uses, and how it can be further genericized with applications to parallelism, tree structures, and heterogeneous sequences.

std::accumulate(): it’s not just for adding things up!

CppCon 2016: Improving Performance Through Compiler Switches...--Tim Haines

By Adrien Hamelin | Jul 7, 2017 01:47 PM | Tags: performance community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

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

Improving Performance Through Compiler Switches...

by Tim Haines

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Much attention has been given to what modern optimizing compilers can do with your code, but little is ever said as to how to make the compiler invoke these optimizations. Of course, the answer is compiler switches! But which ones are needed to generate the best code? How many switches does it take to get the best performance? How do different compilers compare when using the same set of switches? I explore all of these questions and more to shed light on the interplay between C++ compilers and modern hardware drawing on my work in high performance scientific computing.

Enabling modern optimizing compilers to exploit current-generation processor features is critical to success in this field. Yet, modernizing aging codebases to utilize these processor features is a daunting task that often results in non-portable code. Rather than relying on hand-tuned optimizations, I explore the ability of today's compilers to breathe new life into old code. In particular, I examine how industry-standard compilers like those from gcc, clang, and Intel perform when compiling operations common to scientific computing without any modifications to the source code. Specifically, I look at streaming data manipulations, reduction operations, compute-intensive loops, and selective array operations. By comparing the quality of the code generated and time to solution from these compilers with various optimization settings for several different C++ implementations, I am able to quantify the utility of each compiler switch in handling varying degrees of abstractions in C++ code. Finally, I measure the effects of these compiler settings on the up-and-coming industrial benchmark High Performance Conjugate Gradient that focuses more on the effects of the memory subsystem than current benchmarks like the traditional High Performance LinPACK suite.

CppCast Episode 108: Teaching Concepts with Christopher Di Bella

By robwirving | Jul 7, 2017 07:45 AM | Tags: None

Episode 108 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Christopher Di Bella to talk about his experience teaching C++ and his proposed changes to Concepts.

CppCast Episode 108: Teaching Concepts with Christopher Di Bella

by Rob Irving and Jason Turner

About the interviewee:

Christopher Di Bella will soon be a Runtime Technology Engineer at Codeplay, and was previously university tutor (teaching assistant) for the course 'Advanced C++ Programming', at the University of New South Wales, Australia. He is an avid C++ programmer, and also enjoys film, board games, and snowboarding in his spare time.

5 years of Meeting C++

By Meeting C++ | Jul 6, 2017 08:16 AM | Tags: performance meetingcpp intermediate experimental efficiency community c++14 c++11 boost basics advanced

Meeting C++ exists now for 5 years, lets celebrate on the blog:

5 years of Meeting C++

by Jens Weller

From the article:

Just a little bit more then 5 years ago, Meeting C++ went public. Since then, it has been a wild ride and huge success. Today, Meeting C++ reaches over 50k in social media, the conference it self has grown from 150 to 600 in its 5 editions...

Meeting C++ live: C++17 with Tony van Eerd

By Meeting C++ | Jul 6, 2017 03:31 AM | Tags: meetingcpp c++17

A really great new episode about Tony van Eerd was live on YouTube, watch the recording:

Meeting C++ live: C++17 with Tony van Eerd

by Jens Weller & Tony van Eerd

Watch on YouTube:

CppCon 2016: C++14 Reflections Without Macros, Markup nor External Tooling..--Antony Polukhin

By Adrien Hamelin | Jul 4, 2017 01:08 PM | Tags: c++14 advanced

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

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

C++14 Reflections Without Macros, Markup nor External Tooling..

by Antony Polukhin

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

C++ was lacking the reflections feature for a long time. But a new metaprogramming trick was discovered recently: we can get some information about POD structure by probing it's braced initializes. Combining that trick with variadic templates, constexpr functions, implicit conversion operators, SFINAE, decltype and integral constants we can count structure's fields and even deduce type of each field.

Now the best part: everything works without any additional markup nor macros typically needed to implement reflections in C++.

In this talk I'll explain most of the tricks in detail, starting from a very basic implementation that is only capable of detecting fields count and ending up with a fully functional prototype capable of dealing with nested PODs, const/volatile qualified pointers, pointers-to-pointers and enum members. Highly useful use-cases will be shown a the end of the talk. You may start experimenting right now using the implementation at https://github.com/apolukhin/magic_get.

CppCon 2016: Embracing Standard C++ for the Windows Runtime--Kenny Kerr & James McNellis

By Adrien Hamelin | Jul 3, 2017 11:03 AM | Tags: intermediate community

Have you registered for CppCon 2017 in September? Don’t delay – Registration is open now.

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

Embracing Standard C++ for the Windows Runtime

by Kenny Kerr & James McNellis

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Believe it or not, avoiding language extensions and embracing modern C++ will make it easier for you to write code for Windows. The Universal Windows Platform in Windows 10 provides the ability for developers to write apps for many devices in many languages. To achieve this goal, it uses the Windows Runtime platform technology to expose functionality from the operating system into languages, including C++. Microsoft wants to make the Windows Runtime naturally and easily available to standard C++ developers. "C++/WinRT" (formerly moderncpp.com) is a standard C++ library and toolset currently under development at Microsoft. It includes a standalone compiler, which converts Windows Runtime metadata into a header-only library. The source code uses standard syntax consumable by any C++ compiler, making it easier for developers to use Windows Runtime APIs from C++.

We will begin this session with the goals of the "C++/WinRT" project. We'll look at the primitives of the Windows Runtime ABI and how this C++ library provides a natural projection of those primitives. We'll look at how C++11 and C++14 language features make it easier to encapsulate the COM infrastructure that underpins the Windows Runtime. Finally, we'll look at how we've optimized the implementation and discuss how a handful of compiler optimizations can make this C++ library efficient and effective for building a wide range of applications.