As part of standardization, a proposal for Structured Concurrency (http://wg21.link/p2300) will be discussed. The proposed components are a bit abstract, and it requires some explanation of how things fit together. This presentation will discuss and demonstrate the implementation of a simple networking application using sender/receivers. In particular, the presentation will show:
- How to build asynchronous tasks using senders/receivers.
- How cancellation is integrated.
- Some aspects of the underlying implementation.
- Highlights of the proposed standard's positive properties.
---
Dietmar Kühl
Dietmar Kühl is a senior software developer at Bloomberg L.P. working
on the data distribution environment used both internally and
by enterprise installations at clients. Before joining Bloomberg
he has done mainly consulting for software projects in the
finance area. He is a regular attendee of the ANSI/ISO C++
standards committee, presents at conferences, and he used to
be a moderator of the newsgroup comp.lang.c++.moderated. He
frequently answers questions on Stackoverflow.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Binary Object Serialization with Data Structure Traversal & Reconstruction in C++ - Chris Ryan - CppCon 2022
https://github.com/CppCon/CppCon2022
This talk will describe a minimally intrusive technique to add serialization to a set of classes, traversing hierarchical and non-hierarchical data, persisting in a binary format and dynamic reconstruction
When storing, it can deduce the data types using Template Argument Deduction (TAD) and safely protects against recursive reentrancy.
When loading, it uses a reflection type technique for dynamic object creation using an automatic serializable type registration mechanism.
Reflection as a language feature will be unavailable until at least C++26. This serialization technique can dynamically recreate a persisted complex data structure/structure network. This is a platform agnostic technique.
Not everybody is yet able to migrate to C++20, so this is using a C++14 compliant SFINAE/std::enable_if＜＞ mechanism. We will also explore optimizations and what it takes to convert this technique to use C++20 concepts.
The serialized data can be persisted to a disk file, shared memory for IPC or using network streams for live remote data sharing like HPC or gaming.
This is not trying to sell you on the use of the library but rather sharing metacppcon.digital-medium.co.uk/tag/programming/">programming techniques you can add to your toolbox.
---
Chris Ryan
Chris Ryan was classically trained in both software and hardware engineering. He is well experienced in Modern C++ on extremely large/complex problem spaces and Classic ‘C’ on Embedded/Firmware devices (large & small). Chris has no interest in C#/.,Net, Java, js or any web-ish tech.
---
Videos Streamed & Edited by Digital Medium: http://online.digital-medium.co.uk
Parallelism Safety-Critical Guidelines for C++ - Michael Wong, Andreas Weis, Ilya Burylov & Christof Meerwald - CppCon 2022
https://github.com/CppCon/CppCon2022
There are many C++ safety guidelines, including the C++ Core Guidelines, MISRA, AUTOSAR, JSF, CERT, High Integrity C++. But most of these either have no coverage of parallelism and concurrency safety or very little.
Part of this is due to the lack of experts that cover both the parallelism and concurrency domain, where high performance is the key focus, as well as the safety domain, which often can be counter to performance.
The next revision of MISRA C++ is heavily anticipated, with the first batch of rules being moved into public review in 2022. What you may not know is that there is also a group working on C++ parallel concurrency safety rules to be issued alongside the next MISRA C++.
C++ Core Guidelines also has a small section on parallelism and concurrency but it is small compared to the guidelines on sequential execution. Last year, we announced our intention to divide some of the rules found in this Misra parallel C++ safety group into both C++ CG and MISRA.
As many in the industry head towards multicore, manycore, and heterogeneous architectures, especially the case in the automotive, medical, and engineering industries, there has been increasing demands for these kinds of guidelines. However, most safety rules tend to focus only on sequential code. This WG within MISRA C++ in cooperation with C++ Core Guidelines is attended by safety experts with a parallelism background attempting to unify these guidelines.
This talk will take a look into the future and speak of some of the challenges we see with newer parallelism features from C++20 and beyond, analyzing potential issues in the context of safety-critical software and how they could be addressed by future rules. We will also summarize the latest progress of the group, reviewing the rules that have the potential of entering MISRA NEXT, or C++ CG covering parallelism features up to and including C++17.
---
Michael Wong
Michael Wong is a Distinguished Engineer at Codeplay Software, a Scottish company that produces compilers, debuggers, runtimes, testing systems, and other specialized tools to aid software development for heterogeneous systems, accelerators, and special purpose processor architectures, including GPUs and DSPs. For twenty years, he was the Senior Technical Strategy Architect for IBM compilers. Michael is also Chair of the Khronos C++ Heterogeneous Programming language SYCL, Editor for the Concurrency TS and the Transactional Memory TS, Canadian Head of Delegation to the ISO C++ Standard, Founding member of the ISO C++ Directions group, Director and VP of ISOCPP.org and Chair of al Programming Languages for Canada’s Standard Councils.
---
Andreas Weis
Andreas Weis has been writing C++ code in many different domains, from real-time graphics, to distributed applications, to embedded systems. As a library writer by nature, he enjoys writing portable code and exposing complex functionalities through simple, richly-typed interfaces. Both of which C++ allows him to do extensively. Andreas is also one of the co-organizers of the Munich C++ User Group, which allows him to share this passion with others on a regular basis.
He currently works for Woven Planet, where he focuses on building modern software for use in safety critical systems.
---
Ilya Burylov
Ilya is an architect of C++ software solutions for autonomous driving market. He is working on contribution into functional safety standard MISRA and C++ standard bodies in threading and vectorization.
Ilya has contributed into various Intel software products such as Intel DAAL and Intel MKL.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Algorithmic Complexity, Data Locality, Parallelism, and Compiler Optimizations, Seasoned with Some Concurrency - A Deep Dive into C++ Performance - Avi Lachmish - CppCon 2022
https://github.com/CppCon/CppCon2022
In C++, efficiency is usually the name of the game, so what can we do to make sure we are ahead of the game?
In this talk, we will focus on the selection of algorithms and data structures and analyze their effect on program performance.
We will discuss the importance of data locality, proper data structures, and using the stack vs. heap for our runtime efficiency.
Taking into consideration tradeoffs such as space complexity vs. time complexity and setup-time vs. run-time.
We will present benchmarks that would widen our perspective on those considerations.
Concurrency and parallelism will also be added to the mixture, making sure to conclude also for a multithreaded environment.
---
Avi Lachmish
Avi is an expert in Web and networking technologies, operating systems, and software development methodologies. Avi has extensive experience in C++, object-oriented analysis, design and distributed architectures.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Breaking Dependencies - The Visitor Design Pattern in C++ - Klaus Iglberger - CppCon 2022
https://github.com/CppCon/CppCon2022
The extensibility of code with new functionality is essential for long-term maintenance of a code base. However, when using dynamic polymorphism there is always a choice: either easily add types, or easily add operations. For instance, by means of inheritance hierarchies it's easy to add new types, but it's difficult to add new operations.
But there is a common workaround to overcome this weakness: the Visitor design pattern.
In this talk, I’ll explain the design properties of Visitor, including its benefits and shortcomings. I’ll also talk about different kinds of visitors (cyclic and acyclic) and show when to reach for a Visitor and when to avoid it. Additionally, I’ll demonstrate the different implementation strategies (classic and modern) and address their individual benefits and problems.
---
Klaus Iglberger
Klaus Iglberger is a freelance C++ trainer and consultant. He has finished his PhD in Computer Science in 2010 and since then is focused on large-scale C++ software design. He shares his expertise in popular advanced C++ courses around the world (mainly in Germany, but also in the rest of the EU and the US). Additionally, he is the initiator and lead designer of the Blaze C++ math library (https://bitbucket.org/blaze-lib/blaze/), one of the organizers of the Munich C++ user group (https://www.meetup.com/MUCplusplus/), and the organizer of the Back-to-Basics track at CppCon.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Quantifying Dinosaur Pee - Expressing Probabilities as Floating-Point Values in Cpp - John Lakos - CppCon 2022
https://github.com/CppCon/CppCon2022
Like most cppcon.digital-medium.co.uk/tag/programming/">programming languages, C++ can be used effectively for numerical calculations. Some expressions, especially those involving very low or very high probabilities, can be problematic. In particular, floating-point expressions — even those of type long double — can present representational barriers when crafted unartfully. In this lighthearted yet mathematically and computationally informative talk, we’ll begin by briefly reprising the birthday problem and, to elucidate a subtle potential numerical pitfall, together attempt to design a corresponding function that, given a non-negative integer (number of persons), returns a probability (i.e., between 0.0 and 1.0, inclusive).
We’ll then turn to the main topic of this talk, which is to answer — once and for all — four of humankind’s most pressing questions pertaining to the proportion of water on this planet that, at one time, might have been inside a dinosaur. The correct answer to each of these questions will turn out to be one of five possibilities: (a) 0, (b) almost 0, (c) in the middle, (d) almost 1, and (e) 1. The audience will be asked to predict these answers up front. We’ll then proceed to verify these answers using a variety of scientific assumptions and mathematical approaches that all lead to the same conclusions. Along the way, we’ll identify the same subtle, numerical pitfall with floating-point representations that we encountered with the birthday problem and, perhaps, even crispen our understanding of probability versus expected value.
---
John Lakos
John Lakos, author of Large-Scale C++ Software Design (Pearson, 1997), serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide. He is also an active voting member of the C++ Standards Committee’s Evolution Working Group. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytical financial applications at Bear Stearns. For 12 years prior, Dr. Lakos developed large frameworks and advanced ICCAD applications at Mentor Graphics, for which he holds multiple software patents. His academic credentials include a Ph.D. in Computer Science ('97) and an Sc.D. in Electrical Engineering ('89) from Columbia University. Dr. Lakos received his undergraduate degrees from MIT in Mathematics ('82) and Computer Science ('81). He is the author of the multi-volume book Large-Scale C++, the first volume of which, Volume I: Process and Architecture (Pearson, 2020), is currently available, and subsequent volumes are forthcoming. He is the coauthor of Embracing Modern C++ Safely (Pearson, 2021) along with Vittorio Romeo, Rostislav Khlebnikov, and Alisdair Meredith.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Rules for Radical C++ Engineers - Make a Difference in Your Code, Team, and Organization - David Sankel
https://github.com/CppCon/CppCon2022
Frustrated with a code base that doesn't ever seem to get better? Finding it impossible to get your team or manager to prioritize quality or infrastructure? This talk draws lessons from the unlikely discipline of political activism and provides practical ways to convince your stakeholders to effect change.
We'll be discussing the kinds of changes typically needed in the context of a software engineering team, the strategies that work, and those that don't. Wrapping it up we'll look at the evolution of the C++ cppcon.digital-medium.co.uk/tag/programming/">programming language and how these lessons apply in that context.
---
David Sankel
David Sankel is a Principal Scientist at Adobe and an active member of the C++ Standardization Committee. His experience spans microservice architectures, CAD/CAM, computer graphics, visual cppcon.digital-medium.co.uk/tag/programming/">programming languages, web applications, computer vision, and cryptography. He is a frequent speaker at C++ conferences and specializes in large-scale software engineering and advanced C++ topics. David’s interests include dependently typed languages, semantic domains, EDSLs, and functional reactive cppcon.digital-medium.co.uk/tag/programming/">programming. He is the project editor of the C++ Reflection TS, Chair of the Boost Foundation, and an author of several C++ proposals including pattern matching and language variants.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Val: a safe language to interoperate with C++ - Dimitri Racordon - CppCon 2022
https://github.com/CppCon/CppCon2022
Val is a cppcon.digital-medium.co.uk/tag/programming/">programming language based on two of the best ideas behind C++: generic cppcon.digital-medium.co.uk/tag/programming/">programming and first-class value semantics. Unlike C++, however, Val is a safe-by-default cppcon.digital-medium.co.uk/tag/programming/">programming language, meaning that many guarantees that are enforced by convention in C++ are proven by induction in Val.
Val follows strict mutable value semantics, which allows in-place mutation, including across function boundaries, but forbids pointers and references. Instead, objects are independent entities that can never be accessed mutably via different names. Val also checks generic definitions at declaration to ensure that algorithms never rely on unspecified properties of their inputs.
Nonetheless, if we look carefully, we realize that Val and C++ are actually very close. Both are zero-cost abstraction languages that fully acknowledge the physical constraints of computer architecture, yet manage to build efficient generic abstractions. Perhaps they could become friends so that, one day, developers can write fast-by-definition and safe-by-default Val code that seamlessly calls into C++, and vice-versa. Perhaps their relationship could even grow stronger, who knows?
This talk will refer to some of contents presented by Dave Abrahams in his talk titled: "Values: regularity, independence, projection, and the future of cppcon.digital-medium.co.uk/tag/programming/">programming". https://youtu.be/QthAU-t3PQ4
---
Dimitri Racordon
Dimitri is a researcher at Northeastern University, in the US.
He might a bit of an outsider at CppCon. He's never been a real software developer. He doesn't have clients or a product owner to satisfy so he can get away only writing proof of concepts. He has a Ph.D. in computer science, but only because he bribed his jury members with Swiss chocolate. He used to work on model checking for concurrent programs before getting into cppcon.digital-medium.co.uk/tag/programming/">programming language design. Now he writes formal proofs for a living and has yet to prove someone else reads them. He also likes coding very, very much.
Because he knows he's not so good at writing correct programs, though, Dimitri thought he'd better write cleverer compilers. The bar wasn't so high but the quest led him to interesting research questions. Eventually, he developed a true passion for type-based approaches to memory safety. Further, because he constantly falls into the traps of premature optimization, Dimitri believes that languages should offer transparent abstractions with predictable costs that free the user from thinking about performance all the time.
Dimitri likes generic cppcon.digital-medium.co.uk/tag/programming/">programming, because it looks like math. He also likes low-level cppcon.digital-medium.co.uk/tag/programming/">programming languages. Since he's not good enough to write C++ and thinks he's too cool for Rust, he decided to focus his research on yet another cppcon.digital-medium.co.uk/tag/programming/">programming language. He says he's "discovering" a core calculus to build a "safe by default" and "fast by definition" language that interoperate with C++.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
A Success Story in Implementing Understandable World Class Hash Tables in Cpp - Eduardo Madrid and Scott Bruce - CppCon 2022
https://github.com/CppCon/CppCon2022
We present a success story about implementing one of the most important data structures, hash tables, with world class performance.
C++ allowed maintaining the Robin Hood hash table invariant (abbreviated RH) with the performance of parallel computation, even using only normal integer operations:
1. The execution costs of maintaining this invariant were minimized
2. The benefits are realized beyond other implementations
3. The actual code is easier to understand than alternatives in the performance S-tier
RH is a powerful invariant that allows implementations to unlock non-obvious and substantial benefits including cache locality.
Our solution for this challenge is to use parallel computation techniques that require only normal integer processor operations, and can be scaled up to "SIMD" operations (SIMD means "Single Instruction Multiple Data").
The parallel programming abstraction layer is composable, programmer understandable, and friendly to the optimizing compiler. We will prove these assertions with real source code, benchmarks and Compiler Explorer disassembly.
This will illustrate how specifics of RH and the scalable SIMD-based implementation gives not-seen-before improvements: using the bits devoted to "Probe Sequence Length" not just for cache locality but also reducing false matches exponentially.
These examples gives us confidence that fully realizing the powers of this invariant will outperform alternative schemes.
---
Eduardo Madrid
Tech Lead at Snap, Inc., helping performance on augmented reality of the Snapchat app. Author of open source libraries and components such as the Zoo type-erasure framework. Prior experience at Fintech, including automated trading. Several times presenter at CPPCon, C++ Now, C++ London
Scott Bruce
Scott has been writing software professionally for 20+ years.
He's been entranced by performance and efficiency at least 15 of those 20+ years.
He worked in distributed systems, Search, Adwords, Adsense and ML at Google for 13 years. He worked 4.5 years at Snapcht, on monetization systems, performance, and advanced mobile telemetry systems. He is currently an engineer at Rockset, working on distributed system performance and real time analytics. Presenter of a production software talk at Google, Snap, UCLA, USC, Caltech and others over the last ten plus years.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
Cute C++ Tricks, Part 2.5 of N - More Code You Should Learn From and Never Write - Daisy Hollman - CppCon 2022
https://github.com/CppCon/CppCon2022
During the COVID-19 global pandemic, as we all searched for ways to stay connected to the C++ community, these 25-line or less C++ snippets of counterintuitive C++ code called the "Cute C++ trick of the day" started to appear on Twitter. The amount of attention these tricks got was surprising, and as more were posted, it became clear that these counterintuitive snippets of C++ code offer pithy and memorable ways to teach people some intermediate or advanced aspects of C++ (that often come up in real code!).
This talk builds on part 1 (of N), presented last year at CppCon 2021. In this presentation, I will dissect a few more of the most popular "Cute C++ tricks" to a level of detail not possible on social media platforms like Twitter. I'll talk about how and why these tricks work the way they do, talk about the dark corners of C++ they touch upon, and talk about what you should actually do if you need to produce the same effect in production code. While not targeted at beginners, these tricks span the gauntlet from features that most intermediate programmers are aware of (but never thought to use in a particular way) to dark corners of the language that many of my C++ committee colleagues were surprised to learn about. Throughout it all runs a common thread: learning how to exploit your own curiosity to expand your toolbox, gain a better grasp of the fundamentals of C++, and ultimately, become a better programmer.
---
Daisy Hollman
Dr. Daisy S. Hollman began working with the C++ standards committee in 2016, where she has made contributions to a wide range of library and language features, including proposals related to executors, atomics, generic cppcon.digital-medium.co.uk/tag/programming/">programming, futures, and multidimensional arrays. Since receiving her Ph.D. in Quantum Chemistry in 2013, her research has focussed primarily on parallel and concurrent cppcon.digital-medium.co.uk/tag/programming/">programming models, though a broader focus on general accessibility of complex abstractions has become her focus in more recent years. She currently works on C++ language and library design at Google, where she continues to focus on providing broad accessibility of cppcon.digital-medium.co.uk/tag/programming/">programming models and abstractions, with a particular focus on design for diversity and inclusivity.
---
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
YouTube Channel Managed by Digital Medium Ltd https://events.digital-medium.co.uk
