Absolutely good idea. Divide the videos into multiple topics 🙏

As a newbie programmer in C/C++, I use const references all the time, but I never truly understand when or why I should pass by const reference or by value. I learned a lot from today's video and am looking forward to seeing short films that focus on specific topics. Huge thanks!

A completely agree with you that passing primitive data types by reference is not a great idea. It will most likely prevent compiler optimizations. However, I think its probably a good idea to pass custom types by reference, even if they are small. The reason being that their size (and internal behavior) can easily change in the future, without the programmer later realizing that these function parameters all need updated to reference types. After 20 years of programming, one thing I've learned is to treat everything I've touched as unstable and dynamic.

I heartily approve of doing the code reviews by topic. If it tells you anything, this is the very first one of your code reviews I've ever watched--specifically because it wasn't ridiculously long, and I could see in the title that it was about something I might find useful. You might get fewer views per individual video this way, but I have a feeling you'll get *way* more total views overall.

That "it gots darker here" got me 😂

This was definitely more easily digestible and focussed than 40 minutes of code review that goes in five different directions. I smashed like so hard on this that I almost dropped my phone.

Divide by multiple topics, that will help your channel on the long term as more videos will popup on KZfaq search. And that will help less skilled programmers(like me) to learn specific topics.

this is absolutely a better format, not only because my attention span is garbage but also it really helps to build a library of "advice" video that's easily searchable even without the context of the code review this kind of advice is quite rare in a normal beginner tutorial and StackOverflow can be quite asinine about it this way your video can reach a broader audience who just need specific advice

This format is a good idea, and you could also add this video to the C++ series as it covers a pretty interesting topic that fits into it ! Cheers

I like the idea of splitting the code review video by topic! It taught me a lot. Hope to see you sharing more videos like this in the future.

I really like the short, by topic code review!

100% love the shorter videos. Recently I haven't been able to find the time watch longer code review videos, so breaking them down makes it much easier

9:43 yes! this is a fantastic idea. I only clicked on this because the title was interesting. I never click on code review videos

Great Idea go for it. That is the exact reason why I watch long code review videos. At any random time in a video, you give a specific knowledge for a specific situation that normal learning seriea doesn't even think about to teach us. For example this video enlighten me about r and l-values. Thank you for that. Learned C++ with your C++ series years ago and now I can develop custom tools for the games I make with Unreal Engine.

I love this video format!

As you said, a big video on this would be really cool. Thanks for all your work :)

Making small videos for certain topics is very good idea. Never watch your code review videos before, but watched this video because of intresting topic. Often was asking myself the same question, and now I have an answer. Thanks a lot!

Very insightful as always Cherno thanks!

Love these series!

Such a good idea! Please, more of these short videos!

Yes!!! Please do that! Splitting it into parts and explaining different topic on each video would be so much helpful!

I look forward to your bigger video on this :) I also enjoy this style of code review more, it's more descriptive to what the video goes over

Just look at the assembly code my friend, I bet you will get a couple of surprises, particularly with private methods. Hint: the compiler does not always honour the argument passing convention you specified

love seeing this short and sweet!!

Fantastic topic, helps a lot about programming futures. Nice video

thank you for clearing this confusion on my part!!

I just want to join all those that have said that it is an excellent idea to divide the code reviews into smaller videos focusing on one concept. It is super useful!!! Also, you get the opportunity to explain the same concept in multiple and different code sets which will greatly help understand better the concept, you know, by looking at it from different angles and use cases.

Really valid topic! Varies in a lot of things - threads and coroutines make things slightly trickier, but nice video

This is one of the few times when I actually agree with the design of C++. Since references are mostly transparent you can start with just passing by value and should you change to a more complex object in the future merely change the signature to include a const reference and have little trouble. Some languages make the boneheaded decision of either removing pointers and explicit reference documentation and everything is a reference. Some make the equally boneheaded decision of making references explicit all around which basically means they're just pointers. C++ actually did it right here.

making short code review responses that address very specific topics would be perfect for...well, shorts! I've seen a couple channels try out short "tips & tricks" videos around code and they've been very useful!!

This video is good advice, it's basically F.16 in the cpp core guidelines: For “in” parameters, pass cheaply-copied types by value and others by reference to const. F.15 has a really good diagram that illustrates all the choices. IMO it's a good idea to keep your argument definitions 'const', even when receiving value types. Especially in larger methods it's useful to know for certain that a given argument hasn't changed. Also, don't use 'new', 'array'/'vector' would trivially give you the all-important move constructor for that buffer.

very deep video about basics , thx

Splitting a long code review into more specific and shorter videos is a fantastic idea. As you said anyone could focus on particular topics that may be intersted in and understand a topic better without being overwhelmed

Go for it man!

Definitely prefer this format more than a longer video as it is easily digestible. It could also be more useful for people who just need information on a specific topic

Very good idea - the fact to show more shorted (but specific) videos is (imho) more interesting and more appealing than big review videos.

Multiple topic videos per review would be great!

i really liked this one. It's short and it's about one specific topic.

fwiw, the "built-in C++ type" is std::uint32_t. uint32_t is a C alias that most (all major) C++ std library implementations happen to provide, but isn't part of the std

By topic sounds (and works in this instance) great!

So happy I'm not coding in C++ anymore. I use Nim and it checks the size of what you pass and chooses by reference or value at compile time. So if you pass an object, it gets sent as reference if it's above a certain threshold. Ints gets passed by value unless you use "var" (mutable reference).

Good idea. Shorter videos but more specific targeting a given concept or issue. It 's gonna be more interesting.

new idea is great!

Explaining the "why" of anything is extremely valuable, at least imho. throughout all of your content that I have watched, the most enjoyable is when you explain quite trivial things but explain the reasoning at a really low level.

Splitting it up into smaller more specific videos does seem like a good idea. Really liked this one and got a pretty in depth explanation. Unlike general code review videos where you probably wouldve just said a few things and then kept going.

Holy shit I searching for something like this just a day or two ago. Chreno-sama smiles upon me 🙏

It's also nice to understand the difference between passing by value as 'const uint32_t' or 'uint32_t'. Assuming the argument is in a register, for 'const uint32_t' compiler is safe not to create a copy, while for 'uint32_t' it might allocate another register as this argument might be changed inside a function. For example: uint32_t sum(uint32_t n) { uint32_t sum = 0; while (n > 0) sum += n--; return sum; }

Great video as always! The short form videos I think are a lot better because, as you said, the video is more on-topic but not all over the place. However, I think for every code review you should first make a video to overview the project and show the improvements that you would do, maybe explaining briefly (not focus on just one improvement, like the flying dog game video) and then make separate videos on every important topic, explaining it in detail (just like you did in this video).

Another thing to consider is that unnecessary passing by pointer/reference can also prevent the compiler from making certain microoptimizations

I think, at least for me, it'll be easier to learn and digest your videos in a smaller chunks format like how you use to do C++ tutorial. It'll also be easier to see what specific topic you're covering specifically and if later I need to come back to it, it'll be easier to search as well. Just my thought though. You're still one of my best mentor for programming :)

This format would indeed be better than the massive code reviews, i skip those but this had a title that described what was being talked about and interested me and turned out to be useful.

Good idea to split the review up👍

Never thought of this whenever using passing by const reference. Cherno sir 👌

I agree. Good idea.

Very real and useful advice going on here

Good idea Cherno! Clicked on this vid because it was not 01h and 40min long for example =)

I agree that dividing the videos will make them more "digestable" but your content is so good that I wouldn't mind to watch hours of video... I work with C++ nowadays and there some videos that I have watched several times... Thanks for the sharing your amazing knowledge.

finally a c++ video :)

I also like the idea of splitting the code review into shorter videos. This let‘s one pick the topics of interest quickly and it‘s also easier to „digest“ ;-).

The part of the video where you said you should probably make an entire video about, I think it was around 2:15, that would be very helpful. The CPU is still very much unknown to me. And individual videos would be great especially as a playlist too.

Hi Cherno. Love your work! Could you please do a c++ video on implementing a finite state machine?

I found it useful, and I am more willing to watch a short video about a specific problem/thing in the code.

I liked this format, short videos are better to be referred later too

nice video. Anyway I watched a lot of your videos and one think that i will remember for sure is "kind of", "kind of", "kind of"

Personally, both formats (longer video with timestamps) as well as short formats that are just focused on one part are fine. I'd say make the choice based on what gets more views (without having to resort to click-baity titles / screencaps with those "shocked face" looks).

I like your idea to divide videos

I like the idea of splitting up the code review my topic.

static_assert(std::is_trivially_copyable_t); Type trait can be used to test if your type is trivially copyable.

As someone who was actually wondering about this thing in particular I very much aprove the idea of making code reviews as by topic rather than long format they used to be.

I think dividing code review based on topics would be great!

Honestly surprised this isn't handled by the compiler.

Hi, can you please make a detailed video of how virtual table works in the context of virtual functions?

yep split the reviews up!

Yeah, that sounds like a good idea ^^

Man you are God to me!

Oh, my dear Cherno. 1. Roughly at 1:20 you said that const reference is converted to ptr. Actually, not just a "ptr *", but "ptr * const". 2. Passing argument to a function depends on ABI. If your ABI declares that all arguments must be passed via stack - then yes, small types converted to pointer will take more memory. In old ABIs agruments was always passed via stack (see Intel x86 ABI as an example). In modern ABIs arguments mostly are passed via registers which always have same size. Only data with sizes higher than register size always passes via stack. The main difference here is number of accesses to a memory holding the value and it will be "long" if variable located in different memory page, which will have to be kept in RAM. 3. At ~4:59 you saying that "type is not trivially copyable" is an issue of passing by value. This is not the sole reason. If your type is trivially copyable, but is a big sized (too many members/fields) - this is also an issue for passing by value, because you'll eat all the stack.

Well, you only need to use a const if that reference or data type is needed else ware in the code file. If not then go the value type route if it is not used anywhere else but once to declare a value. Dynamic vs static values used once or more. Depends..

4:10 what if someone adds something big(like a bunch of strings) later in this CustomType? I don't think you want to fix every pass by value after this

Love this style of broken-up code review, but it would be nice if there was some indication that this is actually a code review, like maybe on the thumbnail

I would pass a custom struct of two 32 bit ints but not a 64 bit int as const ref. Conceptually you are right about the pointer argument, but especially if you make it const, the compiler figures it out to be the same. The custom struct might be 8 bytes now, but could be expanded. It's also just more consistent to have built in types by value and custom stuff const ref. If you use that pattern, passing a custom small type by value will look jarring. Also, as you mentioned yourself, const ref can take an rvalue. This means it doesn't actually have to treat the value as a pointer. Does 2 have a memory location? Not until the compiler decides what to do with it. In fact, const ref tells the compiler to do what is most optimal actually. It might just in place the argument as value wherever it is used for instance.

Have you ever seen a case where passing by reference was better due to the reduced set of memory pages being used? I could imagine a case where it would help with TLB hits in the CPU?

I like the Qt style: pass c++ (std)types by value, Qt objects by reference, and Qt objects where you transfer ownership by ptr

Yes good idea to split!!

Also shallow copy have very interesting thing to do with.

На современных процессорах объекты размером до 8 указателей (32/64 байта) можно смело передавать по значению. Без глубокого копирования указателей на кучу, естественно.

Thanks, yes better format.

Please do the small talks about this topics 🥺🙏

Wow! Finally my decade long question has been answered :-)

As pointers of course! ;o) 😄

I listen to your videos as I drive. I like that the signal to noise from your talks is quite high. I’m not talking about static here. I feel like I’ve learned a lot from just listening to you. Some CppCon presentations are very useless to just listen to.

multiples short videos rocks!!!!!!!

maybe you could divide the video by topics, but also upload the full one later. I actually enjoy watching the full video

Regarding monolithic code reviews vs snippets about specific coding issues, I vote for the latter. Bits of info about specific topics seems better (IMHO).

So an aspect that was forgotten here was the speed of the compiler. In large project or large engines it's very important to forward declare things. So if it's a large file that gets pulled to include a variable in an it's not the hotpath seriously consider using a reference so the type can be forwarded declared instead... of course if you are not working with code that is likely to get very big don't worry o much. However c++ compilers can get very slow very quickly if everything is being included in headers which will mean less time for the dev to spend optimizing code that matters.

Yes!

I like that idea

Would love if you did that

So, if we can efficiently pass stuff by value that is

9:45 like the new idea :)

I think the 'const' is a key part. If the function doesn't need to modify it, then passing by value is fine. (and if the function is const-casting the const away to modify the value, well take that programmer out back and have a talk with them about why they made a function interface that lies) If the function had to modify, then a reference/pointer would be necessary. And if you can pass by value, there should be a bit of performance since each time the function accesses it, it doesn't have to dereference the ptr type over and over again. But that would depend just how often it accesses the parameter.