Speaker: Denis Yaroshevskiy

Audience level: Intermediate

From time to time, library and application developers are faced with a common refrain: “this low-level component needs to run faster.” This is especially challenging for generic algorithms because of limitless possibilities and considerations. This talk will cover some ways to approach this problem, using some standard algorithms as examples.

Speaker: Martin Šmarda

Audience level: Beginner | Intermediate | Advanced

Software engineering in C++ is hard. I want to share practical examples on mitigating bugs and improving code quality. I will review some recommended best coding practices (almost always auto, DRY (don't repeat yourself), commenting/documentation, error handling), their implications for modern development and propose some alternatives.

Speaker: Clare Macrae

Audience level: Beginner | Intermediate

You've inherited some Qt GUI code: it's valuable, but it doesn't have tests, and it wasn't designed to be testable, so you need to start refactoring. But you can't refactor safely until the code has tests, and you can't add tests without refactoring! How can you ever break out of this loop?

Speaker: Jon Kalb

Audience level: Intermediate

So if you’ve covered the basics of template syntax for types and functions, but you're not quite ready to dive into template metaprogramming yet. Then this session's for you.

Speaker: Jonathan Müller

Audience level: Intermediate | Advanced

C++20 adds the "spaceship operator" <=> for three-way comparison, fundamentally changing the way we implement comparison. But there are a lot more changes: Comparison categories will give more structure, and the new operator rewriting rules will massively reduce boilerplate. And like most C++ features, there are a couple of caveats we need to be aware of.

Speaker: Conor Hoekstra

Audience level: Beginner | Intermediate

At C++Now 2019, I gave the first installment of this talk entitled Algorithm Intuition, which went on to win Best Overall Talk of the conference. The talk covered the 11 algorithms in the <numeric> header. This talk will have the same goal, to develop algorithm intuition - but for algorithms in the <algorithm> header.

Speaker: Fabio Fracassi

Audience level: Intermediate | Advanced

C++20 is feature complete, and nearly ready for ratification.

You might already have heard about the big 5 features Modules, Concepts, Coroutines, Contracts and Ranges. But what about everything else? The small helpers that make your daily coding more productive, the improvements that make the language easier and more fun?

This talk will be fast-paced. Blink and you might have missed a feature. Let yourself be soaked with information, and gain a good overview of the features that C++20 will have in store for you.

...

Speaker: Daniela Engert

Audience level: Intermediate

Modules are one of the big new language additions which will be part of C++20. Seemingly new, modules were actually available for quite a few years in Microsoft's Visual Studio compiler, serving as some form of a reference implementation of the so-called 'Modules TS'. The other root of C++20 modules is the clang compiler, incorporating ideas from engineers (mostly) at Google with their idea of how a implementation of modules should look like. Eventually the developers of gcc also arrived at the party with a fresh look at modules. After joining forces of all three major players, a common vision of a matured specification of modules was agreed on and voted for inclusion into the next C++ standard.

With...

Speaker: Peter Muldoon

Audience level: Beginner | Intermediate

“The worst part of this whole topic is that the people who hate singletons rarely give concrete suggestions for what to use instead.”

In this talk, we will explore just such an approach for replacing the singleton. 

It is easy to slip into the pattern of creating singletons - particularly in large legacy code bases - where low level functions need to propagate side effects - database updates, IPC etc. Passing parameters down long function call chains can be daunting in terms of scope of change required. Additionally, users calling a long established API in legacy code are frequently unwilling to change their calls to supplement the current data being passed in. 

After reviewing a classic singleton approach to a typical problem ñ sending requests to a server ñ and it associated drawbacks. 
We will rework the example by replacing the internal calls to the singleton with calls to an explicitly passed in wrapper class. The extra information required for production use is injected via a custom default instance of the wrapper. This wrapper can now be mocked out which allows for unit testing of the users calling code. 

This alternative approach has been successfully employed in multiple areas in Bloomberg where developers believed there was no other feasible choice. 

...

Speaker: Fabian Renn-Giles, Dave Rowland

Audience level: Intermediate | Advanced

“Real-time” is a term that gets used a lot, but what does it really mean to different industries? What happens when our “real-time” system doesn’t perform in real-time? And how can we ensure that we don’t get in to this situation?

Speaker: Miłosz Warzecha

Audience level: Beginner | Intermediate | Advanced

Coroutines are now happily a part of C++20, after a long time of discussions and deliberations. What is their purpose though, and how do they accomplish the task at hand? It's not obvious, that they can become a crucial part of your code, so in this talk, we will talk about their strenghts, their potential, and what their presence in the new standard can mean for the future.

Speaker: Boguslaw Cyganek

Audience level: Beginner | Intermediate | Advanced

Computers are about computations and every day we do additions, multiplications, etc. using the ubiquitous floating-point (FP) representation. I do computations for years and sometimes I’m surprised by some of the results. Not only because my ideas do not work as expected, but sometimes because I was not careful enough to choose the best algorithm or to protect some computation steps. Because of these I prepared a number of FP recipes for myself and my students which I will present.

In...

Speaker: Boris Schäling

Audience level: Beginner

Boost.MPL, Boost.Mp11, Boost.Fusion, Boost.Hana ... lots of metaprogramming libraries in Boost to confuse newcomers. With constexpr functions since C++11 it begs the question of whether metaprogramming libraries are still necessary at all. This talk is an overview on metaprogramming libraries in Boost with lots of examples why you might want to use which Boost library.

Speaker: JeanHeyd Meneide

Audience level: Intermediate | Advanced

It's 2019 and Unicode is still barely supported in both the C and C++ standards. From the POSIX standard requiring a single-byte encoding by default, heavy limitations placed in codecvt facets in C++, and the utter lack of UTF8/16/32 multi-unit conversion functions by the standard, the programming languages that have shaped the face of development from operating systems, embedded devices and mobile applications has pushed forward a world that is incredibly unfriendly to a world of text beyond ASCII.

Yet we exist in a world where people have already rolled their own solutions. Even with char8_t coming, char has already been chosen in many codebases as the canonical UTF8 code unit type and std::string has made rounds on many Linux environments as a UTF8 encoded string. There is a lot to be backwards compatible with; how do we make sure to keep current investments relevant while guiding people to the new age?

This talk is going to dive into the details of a new Text Library that is coming for potential inclusion into C++23. It is going to discuss what Study Group 16 -- the Unicode Arm of C++ -- is doing about the problems with text handling. A demonstration of some of the interface and flexibility goals behind the new additions to text in the Standard Library will be shown. And, finally, the talk will explore fundamental reasons behind the library's choice of container adaptors over new containers as well as the core power behind Encoding Objects and their ability to convey compile-time information to library maintainers.

This talk will build off of a previous talk (https://www.youtube.com/watch?v=BdUipluIf1E).

...