Category: Science & Technology

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
Many advanced data processing paradigms fit incredibly well to the parallel-architecture that GPU computing offers, and exciting advancements in the open source projects such as Vulkan and Kompute are enabling developers to take advantage of general purpose GPU computing capabilities in cross-vendor mobile and desktop GPUs (including AMD, Qualcomm, NVIDIA & friends). In this talk we will provide a conceptual and practical insight into the cross-vendor GPU compute ecosystem as well as how to adopt these tools to add GPU acceleration to your existing C++ applications.

In this talk we will show how you can write a simple GPU accelerated machine learning algorithm from scratch which will be able to run on virtually any GPU. We will give an overview on the projects that are making it possible to accelerate applications across cross-vendor GPUs. We'll show how you can get started with the full power of your GPU using the Kompute framework with only a handful of lines of C++ code, as well as providing an intuition around how optimizations can be introduced through the lower level C++ interface.

As part of the more advanced example, we will showcase some optimizatiosn that can be leveraged through the hardware capabilities of relevant graphics cards, such as concurrency-enabled GPU queues which allow us to introduce 2x+ performance improvements into advanced data processing workloads. We will dive into the GPU computing terminology around asynchronous & parallel workflow processing, cover the core principles of data parallelism, explain the hardware concepts of GPU queues & queueFamilies, and talk about how advancements in new and upcoming graphics cards will enable for even bigger speedups (such as the AMD architectures or NVIDIA Ampere GA10x architecture which will support up to 3 parallel queue processing workloads).

---
Alejandro Saucedo

Alejandro is the Chief Scientist at the Institute for Ethical AI & Machine Learning, where he leads the development of industry standards on machine learning explainability, adversarial robustness and differential privacy. Alejandro is also the Director of Machine Learning Engineering at Seldon Technologies, where he leads large scale projects implementing open source and enterprise infrastructure for Machine Learning Orchestration and Explainability. With over 10 years of software development experience, Alejandro has held technical leadership positions across hyper-growth scale-ups and has delivered multi-national projects with top tier investment banks, magic circle law-firms and global insurance companies.

---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
In this lecture, we will discuss some of the most painful issues faced by developers attempting to consume C++ libraries from a non-C++ application. These issues are typically first confronted by the non-C++ developer and then more experience interop stakeholders must be brought in. Issues arising during initial consumption are notoriously difficult to diagnose, debug, and understand often requiring some reverse engineering skills. This talk is designed around bridging the gap between C++ library author and the library consumer who is often not a C++ application developer.

---
Aaron R Robinson

Aaron Robinson currently works at Microsoft on the .NET Interop team. He previously worked at The MathWorks helping developers interop their C/C++, Fortran, C#, Java, and Ada code via MEX functions. Aaron took an unusual path to software and graduated with a degree in Social Work - which he declares has provided more long term value than any other aspect of his education - prior to attending grad school for Computer Science.

---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains: http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
This presentation is a tutorial covering multiple metaprogramming topics. It builds upon last year's "Template Metaprogramming: Type Traits." That talk walked you through template metaprogramming fundamentals by implementing some basic type traits. This tutorial demonstrates how to build upon these basic building blocks to solve real world problems.

For example, we will explore how to manage types as plain lists and associative collections. However, we will not just demonstrate how to sort a collection of types, but also some practical use cases where such techniques provide significant advantages, both in representation and runtime performance.

We will look some explicit real world examples where we trade an upfront compile time cost for faster runtime performance. We will also explore ways to measure the compile time costs so that we can make educated decisions about how to improve the compile time performance, and determine if that cost is worth the runtime gain.

Thus, the tutorial will walk through a number of metaprogramming techniques and tricks, but with the goal of applying them to solve several explicit real world problems, all the while being very aware of the compile time costs.

---
Jody Hagins

Jody Hagins first compiled "C++" code in 1984, and wrote a specialized LisP editor using Zortech C++ for senior project in 1988. However, he didn't truly start programming in C++ until 1992, when he read The Greatest C++ Book Ever Written, "Advanced C++ Programming Styles and Idioms" by Jim Coplien. That book, combined with cfront, which generated C code from C++ source, gave him the joyful task of writing SVr4 Streams drivers in C++. Ever since, he has been hooked on writing C++ code for kernel modules, large telephony applications, and, since the late 1990s, applications in what is now known as the high frequency trading industry.

---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains: http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
In this talk, we will present a new open-source library of cursors. Cursors are inspired by functional lenses and reactive streams to provide composable and modular facades to "single atom" value storages. We will see how this can be used to navigate the tension between object-oriented and value-oriented design, and build an example interactive application using Qt and QML against a value-based data-model.

Value-oriented design reconciles functional and procedural programming by focusing on value semantics. Like functional programming, it promotes local reasoning and composition — it is, however, pragmatic and can be implemented in idiomatic C++. In previous talks, the speaker has discussed how immutable data-structures help use value semantics at scale, and how the Unidirectional Data-flow Architecture (Redux, Elm) provide a solid foundation for designing interactive software based on values and functions.

However, we rarely have the luxury of starting from scratch. We are often embedded in legacy codebases with Frankensteinian designs crystalized over decades of multi-paradigm evolution. Also, it's hard to build serious interactive software without frameworks like Qt or Juce that, with all its power, also impose a Javaish object-oriented approach at the boundaries of our system. In this talk we will learn how novel abstractions and design methodologies can help modernize real world code-bases, incrementally migrating them to a value-oriented design.

---
Juan Pedro Bolivar Puente

Juanpe is a Berlin based freelance software engineer, with a focus on interactive software, modern C++, functional programming and open source strategy. Before he worked for Ableton and he has been involved in various music technology projects. He has also developed for the GNU project and cofounded a Hacklab in Granada.

---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
This is the Closing Keynote of the Back to Basics Track.

Many Stack Overflow questions are straightforward - "How do I do sort a vector in decreasing order?" for example. But some of them are subtle, and the more you look at them, the more different possible answers appear.

In this talk, I will show a few SO posts, and discuss possible solutions. These will involve tradeoffs between different data structures and algorithms, complexity guarantees, algorithm design, performance measurement, and testing alternatives.

This talk requires moderate familiarity with the standard library and the contents of the STL.

---
Marshall Clow

---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
In applications such as video games and audio processing, a program has to not only produce the correct result, but to do so reliably in a deterministic amount of time. The code needs to satisfy real-time constraints, complicated by the fact that it will typically run on a non-real-time OS kernel. Writing code for such constraints significantly differs from writing code that maximises for bandwidth or overall performance.

How well suitable is the C++ standard library for such scenarios? In this talk, we will go through many of its facilities in detail. Which are safe to use in (near-)real-time contexts? Which should be avoided, and why? We will discuss well-established utilities and useful patterns as well as some less commonly known details.

This talk is a different kind of tour through the standard library – and afterwards, you will be more confident in using it!

---
Timur Doumler is the Developer Advocate for C++ at JetBrains. As a developer, he specialises in audio and music software. Timur is an active member of the ISO C++ standard committee, co-founder of the music tech startup Cradle, and conference chair of the Audio Developer Conference (ADC). He is passionate about building inclusive communities, clean code, good tools, low latency, and the evolution of the C++ language.

---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
An essential aspect in designing C and C++ systems is to validate the execution flow and resource contention of a proposed approach in the contexts of symmetry and orthogonality.

The role of symmetry is to provide some level of notional understanding without requiring direct inspection (using “similarity” to enable greater scaling and management of design complexity). The role of orthogonality is to remove edge cases and coupling by making things unrelated (thereby making whole system scaling to be simpler, more efficient, and more adaptable).

These roles establish symmetry and orthogonality as useful tools to define our systems by leveraging different aspects of “knowing” many things about our system components and their possible interactions intuitively, and without tedious scrutiny. Symmetry allows us to “know” things we should not otherwise know; while orthogonality grants simplicity to dismiss as a possibility some behaviors or component interactions within the resulting system.

In practice, we use C and C++ language guarantees to implement design choices. But, these design choices come from integrating: (1) the problem to be addressed; and (2) exploiting symmetry and orthogonality to fabricate a system that is logical, implementable, scalable, and unsurprising.

---
Charley Bay

Charley is a software developer with over three decades of experience using C++ in multiple regulated and high-performance fields focused on large-scale and distributed systems in performance-sensitive environments including time-sensitive processing of large data sets, performance visualization, real-time processing, low-latency, embedded, and system status and control.

---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
FPGA (Field-Programmable Gate Arrays) are electronic devices which are programmable with a configuration memory to implement arbitrary electronic circuits. While they have been used for decades to implement various adaptable electronic components, they got some traction more recently to be used as generic programmable accelerators more suitable for software programmers.

There are already HLS (High-Level Synthesis) tools to translate some functions written with languages like C/C++ into equivalent electronic circuits which can be called from programs running on processors to accelerate parts of a global application, often in an energy-efficient way. The current limitation is that there are 2 different programs: the host part, running the main application, and the device part, glued together with an interface library without any type-safety guaranty.

Since the C++ standard does not address yet the concept of hardware heterogeneity and remote memory, the Khronos Group organization has developed SYCL, an open standard defining an executable DSL (Domain-Specific Language) using pure modern C++ without any extension. There are around 10 different SYCL implementations targeting various devices allowing a single-source C++ application to run on CPU and controlling various accelerators (CPU, GPU, DSP, AI...) in a unified way by using different backends at the same time in a single type-safe C++ program.

We present a SYCL implementation https://github.com/triSYCL/sycl targeting Xilinx Alveo FPGA cards by merging 2 different open-source implementations, Intel’s oneAPI DPC++ with some LLVM passes from triSYCL.

For a C++ audience, this presentation gives a concrete example on why the C++ standard does not describe detailed execution semantics (stack, cache, registers...): because C++ can be executed on devices which are not even processors.

While this presentation targets FPGA and a SYCL implementation from a specific vendor, the content provides also:
- a generic introduction to FPGA which should be interesting outside of Xilinx or even without the use of SYCL;
- how C++ can be translated in some equivalent electronic circuits;
- a generic introduction to SYCL which should be interesting for people interested to know more about heterogeneous programming and C++, beyond only FPGA.

---
Ronan Keryell

Ronan Keryell is principal software engineer at Xilinx Research Labs, where he works on high-level programming models for heterogeneous systems, such as FPGA and CGRA, with the open-source https://github.com/triSYCL/triSYCL SYCL implementation.

He is the specification editor of the SYCL standard, member of the SYCL, SPIR & OpenCL standard committees from Khronos Group & ISO C++ committee.

Ronan Keryell received his MSc in Electrical Engineering and PhD in Computer Science in 1992 from École Normale Supérieure of Paris & University of Paris Sud (France), on the design of a massively parallel RISC-based VLIW-SIMD graphics computer (a Jurassic GPU ancestor...) and its programming environment. He spent some time in the academia teaching and working on automatic parallelization, compilation of PGAS languages (High-Performance Fortran), high-level synthesis and co-design, networking and secure computing. He was co-founder of 3 start-ups, mainly in the area of High-Performance Computing, and was the technical lead of the Par4All automatic parallelizer at SILKAN, targeting OpenMP, CUDA & OpenCL from sequential C & Fortran. Before joining Xilinx, he worked at AMD on programming models for GPU.

---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains: http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
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.

---
Parsa Amini

---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/

https://cppcon.org/
https://github.com/CppCon/CppCon2020
---
std::format is a very convenient and very fast text formatting interface added in C++20. This session looks at the internals of how std::format works, and why it works that way. We'll cover how and why argument types are erased (along with the basics of type erasure in general), how to customize format for your own types, precisely what happens when you do, and how format optimizes copying to its output without generating excessive amounts of code. No knowledge of std::format is required to understand this session.

While the primary goal of this session is to understand some std::format internals, many of the techniques described may help you make your own generic libraries smaller and faster.

---
Charlie Barto

Charlie works on the Visual C++ Standard Library. He and open source contributors implemented ＜format＞ for msvc, based on {fmt}.

---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk

The CppCon YouTube Channel Is Sponsored By:
JetBrains : http://jb.gg/cpptools
SonarSource: https://www.sonarsource.com/