CppCon 2021

THIS SESSION HAS BEEN CANCELLED

Come for bite size talks you'll want more of!

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Delayed broadcast

Modern best practices always recommend writing new code for testability and maintenance. However, most of us spend more time reading other people’s code and trying to find a place to put our change without breaking existing functionality. Rarely, if ever, does that code have tests; nor does the project timeline allow for large scale refactoring to make it testable. In this talk, we will discuss how to take the fear out of working on legacy code and start working toward not only adding a safety net so we can change with confidence, but also make it easier to understand what the code is actually doing. We’ll look at some techniques that can be implemented without requiring massive hits to your deadlines, and even address issues such as dealing with hardware and timing dependencies in embedded systems. Over time, both you and your team will be rewarded by increased reliability and productivity and no longer dread the word "legacy."

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Delayed broadcast

The Networking TS provides a framework for writing asynchronous and network-aware applications. A framework which also promotes reusable and testable code. These platonic concerns are only part of software engineering however, and only a small part of the motivation for a framework. When all is said and done one must not merely prepare to reuse code but actually use it, not just test it but deploy it.

How is an actual, deployed application using the Networking TS structured? How do the principles of reusable, testable Networking TS code compose as one writes an actual application rather than a test suite? How can one integrate components which exist outside the Networking TS’s ecosystem into an application based on the Networking TS?

This talk will take the listener on a guided tour of a deployed application written using the Networking TS, the techniques employed to maintain the promises of the Networking TS while fulfilling the needs of an actual application, and how this lays the foundation not only to maintain the current application but also to author additional applications going forward as the deployment and maintenance cycle continues.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Delayed broadcast

How would our code change if a member function could deduce the type and value category of the object ("this") it worked on?

Potentially a lot, and this talk will highlight some of those changes. Because with C++23, member functions will be able to do just that using a feature described in P0847, "Deducing this". Many patterns in C++ today could change, and new patterns will arise. This talk will explore those patterns, explain how "deducing this" works, and show how it solves the problems that originally motivated the paper.

Some sample effects on our code: CRTP is simplified; decorators become much easier and terser; recursive lambda expressions become straightforward. There are also implications for safely and efficiently moving values through computations.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/

Delayed broadcast

It is common practice to use defensive runtime checks, such as C-style assertions to help ensure program correctness, especially during testing. However, when thorough testing and beta releases bring confidence that production software is acceptably defect-free, redundant checks' value gradually decreases. With the value of redundant runtime checks diminishing, disabling them becomes more reasonable as doing so can often lead to measurable performance improvements. Although these assertions are disabled, they still carry valuable information which could assist the compiler's optimizer - namely, that for every defect-free program, the expression stated in the inactive assertion must hold. Most C and C++ compilers optimize code based on actively checked assertions; however, there is currently no standardized support for harnessing that very same information once redundant checks are disabled.

This talk explores the potential impact of the compiler assuming inactive C-style assertion predicates on runtime performance. We then share the result of our raw empirical research applied to real-world production software leveraging Bloomberg's BDE libraries, contrasting relevant metrics - such as compile times, run times, and binary sizes - across various categories of software libraries and applications. It will turn out that there are substantial opportunities to improve performance having relatively little impact on compile times. Moreover, if runtime performance is not improved, it is rarely, if ever, made measurably worse.

ALL TALK SESSIONS CAN BE ACCESSED FROM THE MAIN LOBBY: https://cppcon.digital-medium.co.uk/