This event has ended. Visit the official site or create your own event on Sched.
View analytic

Log in to bookmark your favorites and sync them to your phone or calendar.

•Software Evolution and Portability [clear filter]
Monday, September 25


Which Machine Am I Coding To?
When writing a C++ program, we tend to think of the strengths and weaknesses of our computer, just as we think of our algorithms, data structures, and probably of language features we want to use (or we want to avoid), and we code accordingly.

To some, it might be surprising to learn that C++ is actually specified in terms of an abstract machine, with its own characteristics. If this is indeed a surprise for you, then you might be interested in knowing more about this machine. It's been there for a long time, and it influences the way we program as well as the way the language was, and is.

The aim of this talk is to provide a practical overview of what the C++ abstract machine is, how it affects the way we program and how it affects language design itself. It will probably most interesting to intermediate audiences who would like a closer look to some of the abstract underpinnings of the language.

avatar for Patrice Roy

Patrice Roy

Professor, Université de Sherbrooke / Collège Lionel-Groulx
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 20 years. After a few years doing R&D and working on military flight simulators, he moved on to academics and has been teaching computer science since 1998. Since 2005... Read More →

Monday September 25, 2017 2:00pm - 3:00pm
Ferranti (403) Meydenbauer Center


Migrating a C++03 library to C++11 case study: Wt 4
In this talk, we will describe the effort of migrating the API of a reasonably large open source library to C++11. During the migration we wanted to benefit from as many new C++ features as possible, while preserving the semantics and features of the library. We will present various trade-offs in choosing a smart pointer strategy that was compatible with the existing object ownership model. The signal/slot mechanism, formerly based on boost.signals, was simplified and replaced by an implementation relying on lambdas, std::function and std::bind. Many smaller helper classes such as Boost.Any, Boost.Date_Time, and others were replaced by their standard counterparts.

The minimum requirements of Wt 4 are C++11, but we will describe how C++14/17 are used if the compiler supports them.

The main benefit of this transition is that the Wt API became more self-explaining, compilation times have been reduced, run-time performance improved, and the library's user requires less knowledge of boost. We will also discuss secondary consequences of the transition, such as simpler stack traces and the impact on compiler errors.

Wt is an open source widget-based web GUI library, first released in 2006. Before C++11 came around, Wt could be considered to be written in a modern style C++, relying as much as possible on the standard library and using boost libraries for missing C++ features. Wt 4 is the next major release of the library, fully embracing C++11.

Wt 4 is currently available at github, as a branch of our wt repository: https://github.com/emweb/wt/tree/wt4

avatar for Roel Standaert

Roel Standaert

Roel is a software developer at Emweb, the company that markets Wt, the C++ web toolkit. Roel holds a Master's degree in computer science from the University of Leuven.

Monday September 25, 2017 4:45pm - 5:15pm
Manchester (407) Meydenbauer Center
Wednesday, September 27


API & ABI Versioning: How to Handle Compatibility With Your C++ Libraries
Software keeps changing, but not always as fast as its clients. A key to maintaining a library in the long run is to ensure a proper versioning of the API and ABI. Not only does this gives a clear picture of both source and binary compatibility between the versions, but it also helps design by making breaking changes explicit to the developer.

In this talk I will define API and ABI in terms of impacts on compatibility, explain the difference between breaking and non-breaking changes and present a few techniques to handle them.

We will quickly explain what APIs are, with an emphasis on the notion of contracts. Then the usually lesser known notion of ABI will be explained, going over the concepts of call syntax, mangling and most importantly sizes, alignment and offsets in data structures. We will see how to use semantic versioning (semver) in C++ by considering not only changes to the API but also to the ABI and offer some advice on how to change API and ABI over time and how to minimize the impacts.

avatar for Mathieu Ropert

Mathieu Ropert

Senior Developer, Murex
Mathieu is a Senior Developer at Murex where he works as a C++ expert and animates internal workshops & events. A long term open-source enthusiast, he tries to make C++ more portable across platforms. He is also co-host of the Paris C++ Meetup.

Wednesday September 27, 2017 9:00am - 10:00am
Colossus Theater Meydenbauer Center


A Type, by Any Other Name
No offense to Shakespeare, but in C++ there is a lot in a type name. A name represents a set of data and behaviors, and changing names is an often difficult and painful process. This could be to reconcile some repeated logic into common functionality, upgrade a hand-rolled type to a standard type (or vice-versa), or just upgrade your interfaces to be easier to use.

When these types are widely used throughout a large codebase, conventional wisdom dictates that this refactoring is difficult or impossible -- changing every instance of a widesperead type would cause widespread merge conflicts, if all instances can even be found. In C++, however, it’s possible to refactor types non-atomically, in small steps which preserve invariants, without breaking any users of your code. Library teams at Google have refactored millions of lines of code this way -- this talk will outline common strategies for non-atomic renaming and refactorings, and antipatterns such as ADL use and forward declarations which complicate the process.   That is:

'Tis but thy name that’s not my namespace; 
Thou art thyself, though not a standard class. 
What's montague::? It is not base, nor parent, 
Nor member, typedef, nor any other part 
Belonging to a class. O, be some other name! 
What's in a name? that which we call a ::rose 
By any other name would std::move as swift; 
std::romeo would, were he not ADL call'd, 
Retain that dear perfection which he owes 
Without that title. ::Romeo, doff thy name, 
And for that name which is no part of thee 
Take all myself. 

avatar for Jon Cohen

Jon Cohen

SWE, Google
Jon Cohen is an engineer at Google, maintaining our core common C++ libraries. He spends most of his days directing Google's robot army to rewrite its own source code to be more readable and efficient, and has so far managed to do so without accidentally creating Skynet.

Wednesday September 27, 2017 4:45pm - 5:45pm
Manchester (407) Meydenbauer Center
Thursday, September 28


I Wish I Could Use C++ 1x/y/z :(
C++11, C++14 and C++17 provided a sensible amount of new libraries and language features. However, for some reasons ranging from inertia or even resistance to change, up to complicated customer demands or lack of good compiler support, using those new shiny tools can be out of the question. This tutorial will cover a selection of highly useful C++14/17 idioms and see how you can rebuild them in C++11/14 so you can use them in constrained contexts, or when the language support is there but the library support is not. We will also cover the actual state of popular compilers (GCC, Clang, Visual Studio) to see if they support what they claim to do, so the transition can be smoothed out.

A short list of points to be covered are: generic lambdas, if constexpr, tuple and typelist manipulation with integer_sequence, void_t, template-alias tricks, and fold operator emulation. For each of those, we'll introduce the feature, explain what kind of use cases they solve and how to reproduce them with an old compiler or a limited version of the language or standard library. The question will then be, how far back in time can we go for all of these.

avatar for Joel Falcou

Joel Falcou

CTO, Numscale
Joel Falcou is NumScale CTO. NumScale mission is to assist businesses in the exploration and subsequently the mastery of high-performance computing systems. | | He is also an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d... Read More →

Thursday September 28, 2017 3:15pm - 4:15pm
Colossus Theater Meydenbauer Center


How to break an ABI and keep your users happy
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.

avatar for Gennadiy Rozental

Gennadiy Rozental

Software Engineer, Google
Gennadiy Rozental is the long time contributor to Boost libraries and a developer and maintainer for Boost.Test library. After working on core infrastructure for financial markets data and quantitative research libraries he is now a member of the common libraries team in Google... Read More →

Thursday September 28, 2017 4:45pm - 5:45pm
Manchester (407) Meydenbauer Center


So, you inherited a large code base...
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.

avatar for David Sankel

David Sankel

David Sankel is a professional software developer/architect based in the USA and an active member of the C++ Standardization Committee. His prolific software developments have included CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at the C++Now conferences and is especially well known for his advanced functional programming in C++ talks... Read More →

Thursday September 28, 2017 4:45pm - 5:45pm
Berry Hall Meydenbauer Center