Відео

so where to find these algorithms origin?

Can someone explain the difference between void_t and enable_if and when to use each?

I stop use smart pointer, instead we make pointer as in C. We have another code manage to collect all this and making analyze where we must freeing resource.

Great talk!

So where's the drum? :)

C++ needs to be called C++++++++ nowadays

This talk was LAME the guy spent firts 15 minutes playing trivia ... I mean this was more of a Come lets play trivia than a talk ...

Reminds me of Fortran.

Yes and c++ itself sucks now

C++ libraries like std::chrono are the biggest argument for C++ against C. All the safeties and convenience without any loss of performance.

I think every developer instinctively has felt that the "virtual functions are slow" claim is overly generalized. Virtual functions have a practical purpose, and that practical purpose can outweigh a need for performance. And given a proper context, the correct implementation of virtual functions will also yield performance gains. What is surprising here is that compiler optimization and cpu management seems to be a decade or two ahead of what developers are thinking.

crowd is dead but good talk no mention of using rundll32 to just run the dll though?

This is big...

at 4:06, std::array is in cpu memory. How GPU can access it in kernel function? It not use cudaMemorycpy copy memory from host to device.

I used to really love Herb's talks until I realized the talk was usually the only thing to come out of them :( maybe a prototype on godbolt.

this is by far my favoirite C++ talk!!

Your talks are very clear. Thanks for educating a new generation of CPP users.

(all?) inline-able functions should be "device" automatically, for that matter. Not sure what the limitation is.

Im not sure about the "right" answer. Whatever that looks like. I do believe inheritance can get in the way of code reuse. I guess type erasure (external polymorphism) solves this. Whats you guy's approach to interface abstraction?

I may actually go constexpr my stuff now... this also made me think of how that is also better for perf on the CPU (which is the main reason that I would do it since most of the code that I write is not anything that would be run on the GPU anyway...)

Thank you!

wow, i read his book. really nice.

if you are unsure if you have copies or moves and their optimization, you have probably factored wrongly. That said, you act as if const/auto& is not a thing. Furthermore, the amount of contrived invention required to proceed to create this talk seems to be a systemic problem

Are we still going to have a header file and a library file concept? Isn't it possible to do away with these? Why can't c++ export functions and variables like the way other languages do? I can see some ppl creating header only code becaust of this eccentric problem.

nice

I don't see how this can be called very little overhead. What is being kept here to keep track of all this? Or are you stringing together some linked list of pointers over the stack through these objects

"prvalues are [...] things returned from the function"? A function can return a reference, hence an lvalue, which you can get the address of. If he said "values returned from the function", it would sound a bit more accurate (as opposed to "references returned from the function"). Ok, I kept listening and noticed other things, which are already pointed out in other comments, and I find the explanations a bit handwavy. But a good presentation overall!

shame the c++ gods didn't call the stop token thingies like its called in c#, much better fitting name imho... TaskCancellationSource/CancellationToken (std::task_cancellation_source/std::cancellation_token if you want). NIH is a problem :)

WEN??!?

Talk of entropy has a high likelihood of turning into "woo", but this is easily avoided by starting from the definition at 1:22. Start by considering the number of "ways" that something could occur. In this case, we might consider the number of ways something could be implemented, or the number of ways that an error could occur, or the number of ways that a developer could make a mistake, or maybe something else entirely. If it's fair to assume the ways are equiprobable, then the most likely design/error/issue that emerges is the one with the greatest number of ways of occurring. There are at least two ways to deal with this. An approach that's common in mathematics is to try to find a "universal property" where there is only one possible way that something could be implemented to satisfy some desirable property, and if implementations differ in any way, then at least say that those implementations are fundamentally the same thing. This could be interpreted as developing abstractions so that they satisfy some desireable property, and then eliminate ways that implementation details could prevent one implementation from being swapped with another. The second approach is to embrace the randomness, but engineer the situation so that the favorable outcome is the one that has the most possible ways of occurring. I'll have to leave it to the reader to interpret how this could be done, but maybe it could be considered a weaker form of the first approach?

I would really love to have msvc on my CI to get access to additional analysis This scared me xD

he's absolutely correct that safety is not just type safety and security is not just memory safety, also completely irrelevant, the compiler and tooling should help on what is possible helping

A lot of the data oriented design people who swear up and down how bad C++, abstraction, and object-oriented programming are, would probably end up implementing this with a struct that takes function pointers, and a static array of function pointers to switch between behaviors for different devices. You see this a lot in C code, and it's pretty clever. Unfortunately for them, it incurs the *exact same* "runtime overhead" as polymorphism does (in fact this is how polymorphism is implemented under the hood), except with none of the benefits. People always compare the "overhead" of an abstraction vs having code that does nothing, and never the overhead of the abstraction vs being forced to re-implement the same patterns without abstractions, the compiler, or the type system to help you.

This is super exciting. I'm a Rust engineer & I love Rust, but I would also love to see C++ become modern & safe so that we can all build better software with less headaches.

Without numbers this talk was beyond useless. The conclusion was something we already knew and what you already stated in your intro "polymorphism has some overhead". Ok?? How much overhead? Did using "final" help? What was the point of this talk exactly?

The Hardware/Communication/Robots example was too specific, thus hard to follow Nevertheless, I liked the talk! There are too few people telling you "it's fine to use the naive approach, unless you know you need something different "

Interesting talk. I'm very curious if he's just mentioning the overhead of polymorphism because it's generally assumed, or if they were actually able to measure it. Because after watching ua-cam.com/video/i5MAXAxp_Tw/v-deo.html , I'm more weary of just assuming virtual functions will be slower.

Petition to all c++ programmers: PLEASE FOR THE LOVE OF GOD dye your hair blue and become rust cultist, so the humanity doesn't have to deal with this mess anymore

Very concise and straight to the point, love it!

Powerpoint link on Github points to the visitor design pattern document.

Very interesting and useful. Thanks.

Instead of moving value between registers directly, ``` move eax, edi ``` Why the compiler first moves the value to memory then copy to the register like below? ``` mov dword ptr [rbp-4], edi mov eax, dword ptr [rbp-4] ```

very useful video

Really interesting talk, I learned a lot and I will recommend it to anyone learning about hardware architecture and how atomic operations work. I would just add that knowing hardware architecture is not mandatory to use C++ atomics correctly (really good to know though). That’s exactly what the C++ memory model is for: to wrap the complexities of real hardware into an abstract machine that is easier to reason about.

Thank you for this concise talk!

For the 110th time, I hope I get an answer this time 😢. Why does ISO C have getenv and setenv but ISO C++ has only std::getenv?

Does an audio engineering C++ job pay enough to afford a trichologist? One can expect people presenting good technology to also look tidy.

Aren't his interfaces missing a virtual destructor? Edit: should have listened for five more seconds before posting xD

Ok, so I have a collection of Shape objects including shapes like Circle, Square and Triangle. Now I want to find the average radius of all the Circle objects. How do I do that? I'll need to loop over all the Shape objects in the collection. I don't want to have to put a GetRadius() function in the ShapeConcept class because it's irrelevant to the Square and Triangle classes. Some functions are common to all Shapes like draw() and serialize() but some are specific to a particular Shape. I may want to use those functions. Not easy to do with this type erasure pattern.

I would be interested to know what is the happy path overhead for ExContext compared to try catch