Видео

54:37 Sean Baxter: Safe C++: ruclips.net/video/5Q1awoAwBgQ/видео.html

6:33 Sean Parent on std::find on a range with NANs: ruclips.net/video/2FAi2mNYjFA/видео.html

5:18 A similar talk about UB in std::sort: ruclips.net/video/cMRyQkrjEeI/видео.html

23:54 Reminds me of the “simple made easy” talk: ruclips.net/video/SxdOUGdseq4/видео.html and many great talks by Tony Van Eerd about value oriented programming

Refactoring in general very common problem. Richard makes a good point about the importance! I have collected a couple of book ideas that I need to read. Thank you, Klaus, Andreas and David(R&S), for publishing the talk.

*Unveiling the Power of Type Erasure: A Deep Dive into Emerging Behavior and Simplified C++ Design* * *0:00:03** Introduction:* The speaker begins by acknowledging the complexity of discussing type erasure and its connection to design patterns, setting the stage for a philosophical exploration of emerging behavior in C++. * *0:01:06** Augmented Reality at Snap:* The speaker reveals they work on augmented reality at Snap, highlighting the need for expressiveness and performance in their software, which C++ provides. * *0:01:52** Embracing Emerging Behavior:* The core concept is introduced - how simple rules and principles can lead to complex and intelligent behavior in software, analogous to design patterns and generic programming concepts. * *0:03:55** The Essence of Simplicity:* Simplicity in C++ is linked to the Single Responsibility Principle, while clarity of purpose is tied to established design patterns. * *0:06:54** Generic Programming Concepts:* The discussion shifts to generic programming as a means to achieve abstraction and composability, referencing Alexander Stepanov's work and the Standard Template Library (STL). * *0:07:45** Defining Emerging Behavior:* Emerging behavior is defined as the phenomenon where simple components interact to produce complex outcomes not achievable by individual parts, a key concept for robust C++ libraries. * *0:09:48** Templates and Unanticipated Use:* The speaker emphasizes that C++ libraries, especially those using templates, are often used in unforeseen ways, demanding careful consideration of future, unpredictable use cases. * *0:12:29** The Ghost of Good Templates:* The "ghost" of a template is its underlying concept, with examples like destructors and exception safety guarantees, highlighting the importance of understanding these concepts for effective template design. * *0:13:56** The Vector Debate:* An anecdote about a debate on vector::push_back's exception safety illustrates the importance of considering unanticipated uses when designing even fundamental data structures. * *0:16:30** The Value of Move Semantics:* Move semantics, along with noexcept and swap, are presented as a system enabling optimistic programming and improved performance by facilitating failure-oblivious coding. * *0:17:42** Emergence in Software Engineering:* The concept of emergence is further elaborated, emphasizing the interaction of simple software components to create complex, intelligent behavior, essential for tackling intricate problems in domains like image processing and AI. * *0:19:17** Wave Function Collapse:* The Wave Function Collapse algorithm is presented as a real-world example of simple rules leading to complex and aesthetically pleasing outcomes, demonstrating the power of emergent behavior in procedural content generation. * *0:21:53** Expressiveness and Efficiency in C++:* C++'s expressiveness, allowing for paradigm shifts and efficient code through libraries like the speaker's type erasure framework, is highlighted as crucial for managing complexity. * *0:23:49** Maximizing Simplicity, Leveraging Complexity:* The goal is to maximize simplicity in design while leveraging emergent behavior to achieve complex, sophisticated solutions, with type erasure as a prime example. * *0:25:57** Runtime Polymorphism and Type Erasure:* The discussion transitions to runtime polymorphism, covering substitutability, inheritance, virtual overrides, and the use of std::variant for bounded polymorphism. * *0:28:53** Type Erasure as a Design Pattern:* Type erasure is presented as a powerful design pattern that combines external polymorphism, strategy, and value management to achieve flexible and efficient runtime behavior. * *0:33:26** Subtyping Without Subclassing:* A key point is made that subtyping in C++ can be achieved without inheritance through type erasure, offering a more flexible and powerful approach to polymorphism. * *0:38:55** Type Erasure as Annotation:* Type erasure is reframed as a form of annotation, declaring that a type satisfies a particular subtyping relationship without modifying the type's source code. * *0:39:55** Contradictions and Benefits of Type Erasure:* Type erasure is presented as a powerful yet seemingly contradictory tool, offering both strong typing and flexibility, implemented as a library rather than a language feature, and outperforming traditional polymorphism in some cases. * *0:40:55** Evolution of the Speaker's Type Erasure Framework:* The speaker outlines the development of their type erasure framework, highlighting the importance of clear concepts and design patterns, culminating in a third generation aimed at usability and broader adoption. * *0:48:11** The Impact of Klaus Iglberger's Work:* Klaus Iglberger's work on external polymorphism and strategies is acknowledged as a major influence, providing the clarity needed to improve the speaker's framework. * *0:50:33** Live Demo:* A live coding demonstration showcases the framework's capabilities, including dynamic affordance addition and removal, compile-time error detection, and the use of policies to configure type-erased containers. * *0:56:54** Exploring Affordances:* The concept of "affordances" is further explained, demonstrating how to add new capabilities (like a custom "process" method) to type-erased containers. * *1:05:57** Practical Application and Production Use:* The speaker confirms that the framework is used in production at Snap, highlighting its stability and importance in a real-world, large-scale application. * *1:08:45** Encapsulation and Public Interfaces:* The speaker addresses a question about encapsulation, clarifying that the framework respects encapsulation from the user's perspective while employing a more open internal design for flexibility. * *1:11:09** Adherence to C++ Standards:* The framework's strict adherence to C++ standards is emphasized, ensuring portability and preventing unexpected behavior. * *1:11:30** Conclusion:* The presentation concludes with an invitation for further discussion and a call to action for the community to explore and contribute to the framework. I used gemini-1.5-pro-exp-0827 on rocketrecap dot com to summarize the transcript. Cost (if I didn't use the free tier): $0.10 Input tokens: 75780 Output tokens: 1309

*A Deep Dive into Type Erasure Techniques* * *0:00:03** Introduction:* The speaker introduces their interpretation of type erasure, inspired by Klaus, Archer O'Dwyer, and others. * *0:00:24** Core Concept:* The demonstration involves two independent classes, `Cat` and `Dog`, with no shared superclass or interface. Each has unique strategies for getting treats. * *0:00:37** Strategies:* * `Cat` uses `meow` and `scratch` (Strategy 1). * `Dog` uses `sit` and remembers the number of hairs shed (Strategy 2). * *0:01:08** Smart Strategies:* Strategies track the number of treats spent to avoid running out. * *0:01:20** Goal:* Create a vector of stateless, type-erased objects, matching each pet with a strategy (e.g., Rover with Strategy 2, Sleepy with Strategy 2), and call `get_treat` and `get_petted` for each. * *0:01:49** Stateless Type Erasure Implementation:* * Uses a "pimple" - a unique pointer to an interface. * The interface has a virtual destructor and pure virtual functions (`get_treat`, `get_petted`). * A templated `Implementation` class stores a copy of the object (Cat/Dog) and its strategy. * The constructor forwards the pet and strategy to the `Implementation` type. * `get_treat` and `get_petted` are forwarded through the pimple to the `Implementation`. * *0:04:05** Philosophy:* Similar to Smalltalk's "do as little as you can and know as little as you can." * *0:04:22** Stateless Type Erasure in Action:* * The `StatelessTypeErasure` class calls `get_treat` on the pimple. * The pimple, pointing to a vtable, calls the appropriate `Implementation`. * The `Implementation` uses the stored strategy and object. * *0:06:31** Question and Answer:* Clarifies that `StatelessTypeErasure` is the single point where independent classes are linked, and it makes copies of the objects and strategies. * *0:07:25** Limitation:* The original objects (e.g., Rover) don't participate directly in type erasure; their copies do. This prevents querying the original objects' states after they're part of the type-erased vector. * *0:08:19** Stateful Type Erasure:* * Introduces a `StatefulTypeErasure` to allow interaction with the original objects. * `Implementation` now stores shared pointers to the object and strategy. * `get_treat` and `get_petted` dereference these pointers. * A constructor macro determines if the input is a shared pointer and handles it accordingly. * *0:11:44** Stateful Type Erasure Issues:* * Three levels of indirection (one extra). * Objects must be created on the heap. * Passed objects cannot be shared pointers themselves (unless passed as a shared pointer to a shared pointer). * *0:12:43** Advantage:* Objects don't need to be copied or moved, useful for complex or uncopyable objects. * *0:13:12** Question and Answer:* * "Stateless" means the original object's state isn't tracked after type erasure. * Pimple is used to point to the vtable of any class, not necessarily a templated one. * "Interface" and "Implementation" were chosen for clarity over "Concept" and "Model." * The third indirection is the reference to the object. * *0:17:22** Stateful Type Erasure Conclusion:* The constructor either passes shared pointers directly or copies/moves objects into shared pointers. * *0:18:02** Universal Type Erasure:* * Aims to combine stateless and stateful approaches. * Copies non-shared pointer objects and uses shared pointers directly. * Uses a compile-time macro `shared_pointer` to differentiate. * Defines `object` and `strategy` functions to return a reference to the actual object, dereferencing shared pointers if necessary. * `get_treat` and `get_petted` use these functions. * *0:20:54** Performance:* The speed of the universal approach needs to be tested against stateless and stateful versions. * *0:21:27** Q\&A:* Discusses the possibility of shared pointers within strategies and clarifies the evolution from two to three type erasure kinds. I used gemini-1.5-pro-exp-0827 on rocketrecap dot com to summarize the transcript. Cost (if I didn't use the free tier): $0.05 Input tokens: 32940 Output tokens: 1086

*A Deep Dive into Type Erasure: A Better Alternative to Inheritance* * *0:00:02** Introduction to Type Erasure:* The speaker introduces the concept of type erasure as a solution to the problems caused by traditional inheritance. * *0:00:39** The Problem with Inheritance:* The speaker uses an example of cats and dogs to illustrate the complexities and limitations of inheritance, especially when dealing with multiple, orthogonal behaviors (like getting petted and receiving treats) and external libraries. * *0:01:29** Multiple Inheritance Issues:* As new requirements and libraries are introduced, the inheritance hierarchy becomes increasingly complex, leading to issues like: * *0:08:18** Many Derived Classes:* An excessive number of classes with confusing names. * *0:08:36** Deep Inheritance Hierarchies:* Difficult to understand and maintain. * *0:09:01** Duplication:* Violating the DRY (Don't Repeat Yourself) principle. * *0:09:24** Artificial Coupling:* Coupling unrelated concepts, violating the Single Responsibility Principle. * *0:09:53** Inflexibility:* Difficulty in extending the hierarchy. * *0:10:05** Performance Issues:* Overhead from virtual functions and memory fragmentation. * *0:10:42** Inheritance is Rarely the Answer:* The speaker emphasizes that inheritance often leads to more problems than solutions, citing "The Pragmatic Programmer." * *0:11:16** Design Patterns as a Solution:* The speaker suggests design patterns like Strategy, External Polymorphism, and especially Type Erasure as better alternatives. * *0:12:05** "Inheritance is the Base Class of Evil" - Sean Parent:* The speaker references Sean Parent's influential talk highlighting the problems with inheritance and introducing type erasure as a solution. * *0:13:18** The Inventor of Type Erasure - Kevlin Henney:* The speaker credits Kevlin Henney as the inventor of type erasure, mentioning his paper "Valued Conversions" which introduced the concept of `std::any`. * *0:14:15** Benefits of Type Erasure:* * *0:14:22** No Explicit Inheritance:* Classes don't need to inherit from a common base class. Error: Couldn't find 687 * *0:14:49** Non-Intrusive Design:* Functionality can be added externally without modifying existing classes. * *0:15:02** Open/Closed Principle:* Easier to extend functionality without modifying existing code. * *0:15:08** Externalized Polymorphic Behavior:* Virtual functions are not needed in the original classes. * *0:15:31** Loose Coupling:* Unrelated concepts are not coupled. * *0:15:36** Single Responsibility Principle:* Each class has a clear, single responsibility. * *0:15:45** DRY Principle:* Easier to avoid code duplication. * *0:16:00** Easier Extension:* Adding new functionality is simpler. * *0:16:08** Value Semantics:* Supports value semantics, which can be more efficient and easier to reason about. * *0:16:30** Introduction of Speakers:* The speaker introduces two experts on type erasure, Nicholas Jose and Eduardo Madrid, who will further discuss the topic. I used gemini-1.5-pro-exp-0827 on rocketrecap dot com to summarize the transcript. Cost (if I didn't use the free tier): $0.04 Input tokens: 26964 Output tokens: 749

Awesome video ! great content.

This is SO WRONG! Cats are smarter!!! :)

About the Barriers example - won't the Fulltime Worker threads be blocked after the "Afternoon work is done" at the "arrive_and_wait point" because the barrier never reaces 0 for the second time? Counting down in the Part Time Worker threads before leaving the thread may be the solution in this case.

Rainer, I'm totally heartbroken seeing you like this but at the same time I have enormous respect for you, for what you do and for your passion. You've done tremendous job educating C++ developers and it will never be forgotten. I sincerely wish you all the best and I keep my fingers crossed for you, hoping you will get better. A huge thank you for everything!

37:18 Walter Brown seminal talk where void_t was presented ruclips.net/video/a0FliKwcwXE/видео.htmlm9s

Speaking English is not so easy, actually. You've done a great work👍

Composition Intuition - Conor Hoekstra - ruclips.net/video/JELcdZLre3s/видео.html

Thank you a lot for such a great talk!

1:02:53 here’s a recent talk from EuroLLVM about an LLVM optimizer component for detecting and merging similar functions in large codebases: ruclips.net/video/rh2ApiBQQks/видео.html

Thank you for taking the time to take us through the stdlib. Really appreciate your time!

Great showcase of how flexible things are.... Thanks.

I love Mr. Kalb. Excellent teacher. Thank-you sir!

4:55

The two referenced talks at the end: ruclips.net/video/QgMQPqVc6JE/видео.html and ruclips.net/video/6XZ5m0Q54jU/видео.html 17:22

May I suggest whilst speaking a foreign language one do so w/ the foreign accent and try not to mumble also . I am finding this audio almost incomprehensible .

48:44 More on optimizing binary search in: ruclips.net/video/1RIPMQQRBWk/видео.html. Great talk as always, Timur.

Very nice talk. I really like this high expressive power of ranges. I would personally implement sliding means as the difference (subtraction) of two partial sums - but that’s just me, and the general notion of composing range adapters should still apply

Your video is very beautiful. I like it a lot. I have been trying to talk to you for a long time. I am waiting for your response. Please give me a chance to talk to you. I am a professional digital marketer and RUclips marketing expert. I can help you.👌

Sick man.

Nice talk, very inspiring. Thanks for sharing.

Too bad Klaus does not finish trying the -ffast-math test. -ffast-math allows to do the same unrolling he does manually. On my computer, the original routine without the explicit unrolling becomes slightly faster than the manually unrolled one.

Wonderful talk indeed. STL containers are not polymorphic, which makes public inheritance more attractive, but I personally find it risky. People interested in the full details of making a class that really acts like a container might like Zach Laine’s work on boost STLContainers. A talk by him is ruclips.net/video/JByCzWaGxhE/видео.html

Great Video!!

This made me happy!! Crush your competition with P r o m o s m!

56:50 ruclips.net/video/RVvVQpIy6zc/видео.html

06:00 ruclips.net/video/KGX6zhOWGAc/видео.html

Apologies for the choppy audio on this one. Apparently Skype changed their audio handling in a recent update which causes some issues with the audio quality. We hope that this will be fixed in the near future.

Thank you! I like it.

C++ EH is just wrong. Use EH = bad i have to say that. I am not for eh safety issue. It just sucks. add 50kb of runtime to my binary of EH is just completely unacceptable + not usable in environments wasm. Only losers use EH Yes to p0709. Death to current C++ EH.

Compared to all the other videos you referenced, imo, this is the best in explanation of type-erasure and strategy. I watched all those others first, but it didn’t click until this video. Thank you.

Great talks. same topic in Golang would be interesting. It seems to me that C++ and all the patterns are too complicated, too many codes, therefore too diffuclt to learn. I am wondering if someone can redo all those examples in Golang, to compare morden C++ and Golang. I would expect much simpler implementations.

This is great guys !!! Thanks alot for insights as always

38:00 the reason the round-robin is the worst is that it is the "worst case" for LRU: it USES the least-recently used item (in this case type). It is most likely that the vtable for that type is not in dcache AND that the code for the methods for the type are not in dcache

Great, assembly-phobia reducing talk! Thanks Matt for presenting and Klaus (and the Muc++ team) for organizing!

57:16 - The dog returns!!

44:44 - The dog got tired of hearing about compiler optimizations!

Assembly is fun like poetry if someone like Matt teaches you how to recite ❤❤. Lot's of useful information in one video . I was searching for a tutorial like this for a long time. Can't appreciate enough. 💙💙💙

the last one is way more complicated than traditional OO or visitor

Where was this presentation 2 years ago when I started implementing very similar problem? :) Thank you for the comparisons.

I wonder how all of this could be much simpler if C++ had proper Algebraic data types/sum types.. :)

This was a great demonstration, but I think it could use a title that better describes it. Here's my suggestion. "A comparison of different implementations of polymorphism in C++"

It is worth to mention that void foo(int) { } and void foo(const int) { } are in fact the same function. const is ignored here as parameter is passed by value, so if you have both functions it is redefinition error.