CppCon 2017: How to break an ABI and keep your users happy--Gennadiy Rozental

By Adrien Hamelin | Aug 15, 2018 12:01 PM | Tags: community

Have you registered for CppCon 2018 in September? Registration is open now.

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

How to break an ABI and keep your users happy

by Gennadiy Rozental

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Technical debt is the bane of most established libraries, whether it is standard library or boost or local library developed in house. Paying this debt is expensive and in many cases seems infeasible.

As a result of several (justified at the time) decisions Google accumulated serious technical debt in how we use std::string. This became a blocking issue in our effort to open source Google’s common libraries.

To fix this we needed to break libstdc++ std::string ABI. This is the story of how we survived it kept Google still running.

CopperSpice: Thread Safety

By Ansel Sermersheim | Aug 14, 2018 01:39 PM | Tags: None

New video on the CopperSpice YouTube Channel:

Thread Safety

by Barbara Geller and Ansel Sermersheim

About the video:

This video covers concepts like thread safety, conditional thread safety, and reentrancy. We discuss the differences between these terms, the vital role that documentation plays in designing thread safe code, and how to effectively and clearly communicate the level of thread safety a particular function provides.

Please take a look and remember to subscribe!

CppCon 2017: My Little Object File: How Linkers Implement C++--Michael Spencer

By Adrien Hamelin | Aug 13, 2018 11:38 AM | Tags: community

Have you registered for CppCon 2018 in September? Registration is open now.

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

My Little Object File: How Linkers Implement C++

by Michael Spencer

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Ever wonder how the linker turns your compiled C++ code into an executable file? Why the One Definition Rule exists? Or why your debug builds are so large? In this talk we'll take a deep dive and follow the story of our three adventurers, ELF, MachO, and COFF as they make their way out of Objectville carrying C++ translation units on their backs as they venture to become executables. We'll see as they make their way through the tangled forests of name mangling, climb the cliffs of thread local storage, and wade through the bogs of debug info. We'll see how they mostly follow the same path, but each approach the journey in their own way.

We'll also see that becoming an executable is not quite the end of their journey, as the dynamic linker awaits to bring them to yet a higher plane of existence as complete C++ programs running on a machine.

CppCon 2017: So, you inherited a large code base...--David Sankel

By Adrien Hamelin | Aug 10, 2018 12:18 PM | Tags: advanced

Have you registered for CppCon 2018 in September? Registration is open now.

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

So, you inherited a large code base...

by David Sankel

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This is a talk about solving the most difficult problem a software engineer ever faces, converting a large codebase with antiquated designs and spotty quality into a state-of-the-art, modern system. We'll be covering clang-based refactoring, mnemonic reasoning methods, safe rewrites, coding standards, and, oh yes, migration paths.

If you've ever been tasked with making a legacy codebase the best-in-class, or think you might, then this talk is for you.

CppCast Episode 162: The Art of C++ Libraries with Colin Hirsch

By robwirving | Aug 10, 2018 09:14 AM | Tags: None

Episode 162 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Colin Hirsch to discuss his work on The Art of C++ collection of libraries including PEGTL, json and more.

CppCast Episode 162: The Art of C++ Libraries with Colin Hirsch

by Rob Irving and Jason Turner

About the interviewee:

Dr. Colin Hirsch studied Computer Science at the University of Technology in Aachen, Germany in 1993 and later got a PhD in Mathematics from the same university. He worked for two years as a consultant for T-Mobile, developing back-end server applications in C++ and Lua. Later Colin moved to Italy, opened his own business and continued working for T-Mobile (now Deutsche Telekom) as well as working for some other interesting projects like Greenpeace and the Austrian ministry of ecology.

In his free time he enjoys photography, being in nature, science fiction and spending time with his daughter.

CppCon 2017: Practical Techniques for Improving C++ Build Times--Dmitry Panin

By Adrien Hamelin | Aug 8, 2018 12:39 PM | Tags: efficiency

Have you registered for CppCon 2018 in September? Registration is open now.

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

Practical Techniques for Improving C++ Build Times

by Dmitry Panin

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

Slow builds block all C++ developers from the work being done. At Facebook we have a huge codebase, where the time spent compiling C++ sources grows significantly faster than the size of the repository. In this talk we will share our practical experience optimizing build times, in some cases from several hours to just a few minutes. The majority of the techniques are open sourced or generic and can be immediately applied to your codebase.

Facebook strives to squeeze build speed out of everything: starting from a distributed build system, through the compiler toolchain and ending with code itself. We will dive into different strategies of calculating cache keys, potential caching traps and approaches to improve cache efficiency. We tune the compiler, specifically with compilation flags, profile data and link time options. We will talk about the benchmarks we use to track improvements and detect regressions and what challenges we face there. Finally, you will learn about our unsuccessful approaches with an explanation of why they didn't work out for us.

CppCon 2017: Enough x86 Assembly to Be Dangerous--Charles Bailey

By Adrien Hamelin | Aug 6, 2018 01:39 PM | Tags: community

Have you registered for CppCon 2018 in September? Registration is open now.

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

Enough x86 Assembly to Be Dangerous

by Charles Bailey

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This tutorial is an introduction to x86 assembly language aimed at C++ programmers of all levels who are interested in what the compiler does with their source code.

C++ is a programming language that cares about performance. As with any technology, a deep understanding of C++ is helped by knowledge of the layer below, and this means knowledge of assembly language. Knowing what the compiler does with your source code and the limitations under which it operates can inform how you design and write your C++.

We learn how to generate, inspect and interpret the assembly language for your C++ functions and programs. We take a short tour of common assembly instructions and constructs, and discover why extreme caution should be exercised if we are trying to infer performance characteristics from a simple inspection of assembly code.

Starting with a simple `operator+` for a user-defined class, we take a look at how interface and implementation choices affect the generated assembly code and observe the effect of copy elisions and related optimizations that compilers commonly perform.

CppCast Episode 161: Expectations and Exceptions with Simon Brand

By robwirving | Aug 3, 2018 08:01 PM | Tags: None

Episode 161 of CppCast the only podcast for C++ developers by C++ developers. In this episode Rob and Jason are joined by Simon Brand to discuss his upcoming CppCon talks covering exceptions, value wrappers, debuggers and more.

CppCast Episode 161: Expectations and Exceptions with Simon Brand

by Rob Irving and Jason Turner

About the interviewee:

Simon is a GPGPU toolchain developer at Codeplay Software in Edinburgh. He turns into a metaprogramming fiend every full moon, when he can be found bringing compilers to their knees with template errors and debating undefined behaviour on the C++ Slack channel. He co-organises the Edinburgh C++ user group and contributes to various programming standards bodies.

Outside of programming, he enjoys experimental films, homebrewing, and board games.

CppCon 2017: How to Write Effective Documentation for C++ Libraries...--Robert Ramey

By Adrien Hamelin | Aug 3, 2018 01:18 PM | Tags: community

Have you registered for CppCon 2018 in September? Registration is open now.

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

How to Write Effective Documentation for C++ Libraries...

by Robert Ramey

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

With the success of GitHub, everybody and his brother is a library developer. Programmers love to create code, upload it to GitHub and hope for immortality. Most projects get only the most cursory examination before being passed over by users. Why is that? GitHub considered the problem.

GitHub just published its 2017 Open Source Survey. The popular social coding service surveyed over 5,500 members of its community, from over 3,800 projects on github.com. It also spoke to 500 coders working on projects from outside the GitHub ecosystem. The Open Source Survey asked a broad array of questions. One that caught my eye was about problems people encounter when working with, or contributing to, open source projects. An incredible 93 percent of people reported being frustrated with “incomplete or confusing documentation”. see https://thenextweb.com/dd/2017/06/02/...

Even the most experienced and dedicated software developers can't do it. This can be confirmed by looking over recent reviews of Boost libraries. The most common complaint is that the documentation isn't useable.

Programmers love their stuff and hope to get people to use it, why don't they fix their documentation? The reason is simple: They don't know how.

Problems

a) It's tedious and boring to write
b) Developers don't know what to include and what to exclude
c) Tools make things harder
d) Regardless of the amount of effort invested, the end result is usually of little or no value.

This presentation will present a "Cookbook" and demonstration for creating documentation. Using this method will

a) Much diminish the tedium of the task.
b) Help improve to the quality of library design and implementation
c) Create something that is useful to the library user.

We will touch upon tools like Doxygen, etc. But this is only a small portion of the presentation. We use them so they deserve mention. But they don't cause the problem, and they don't solve it either.

CppCon 2017: How to Write a Custom Allocator--Bob Steagall

By Adrien Hamelin | Aug 1, 2018 12:54 PM | Tags: stl performance

Have you registered for CppCon 2018 in September? Registration is open now.

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

How to Write a Custom Allocator

by Bob Steagall

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

You'd like to improve the performance of your application with regard to memory management, and you believe this can be accomplished by writing a custom allocator. But where do you start? Modern C++ brings many improvements to the standard allocator model, but with those improvements come several issues that must be addressed when designing a new allocator.

This talk will provide guidance on how to write custom allocators for the C++14/C++17 standard containers. It will cover the requirements specified by the standard, and will describe the facilities provided by the standard to support the new allocator model and allocator-aware containers. We'll look at the issues of allocator identity and propagation, and examine their implications for standard library users, standard library implementers, and custom allocator implementers. We'll see how a container uses its allocator, including when and how a container's allocator instance propagates. This will give us the necessary background to describe allocators that implement unusual semantics, such as a stateful allocator type whose instances compare non-equal. Finally, the talk will provide some guidelines for how to specify a custom allocator's public interface based on the semantics it provides.