Entertaining and informative, thank you.

Loved it

I laughed SO HARD when constexpr popped up. I haven't laughed that hard in awhile. Thank you for that.

Dave. Can you do me a favor. I'll even donate 100cad to a charity of your choice. In the fastled library there's a udl in the tetris game written by Aaron liddement. I for the life of me do not understand the bitwise based udl code he has written to define the tertris blocks. I get what he's doing but can't find any other similar cases of the bitwise code using hex to and unsigned long data like the way he's done it. Scott Manley made a wearable matrix using his code years ago which made me see what was going on under the hood. I don't like using code I don't understand and it's driven me nuts ever since. I too am on the spectrum and have a software degree I never used until I had to medically retire a while back. I love your channel and have been around since the beginning and even if you could have a quick look and reccomend a book or something if you don't have the time to make a video. It's one of those things that gets stuck in my head from time to time and it kills me that I do not understand what he's doing fully. I suspect it's intentionally obfuscated and as someone who spends his retirement doing charity work and learning it's been a thorn in my side. I am 45 and plan on using my past credits toward a compsci or ee degree (as a bucket list item and to help me tutor programmers and develop free courses for a local non-profit makerspace). I've googled, bought books, stopped short of chatgpt because I don't want the info handed to me on a silver platter because I prefer to learn hands on. I understand how transistors perform math using different binary rules because I like to do things by coding and then trying the same wirh passive circuit components. He rewrote the sprite class so it no longer uses the udl but it still drives me nuts that I can't figure it out. I'm also a fellow Canadian but I hail from the ns side od the nfld ferry. I'm waiting for approval for funding for a 7 week inpatient program for how to live with ptsd and I'd like to spend my free time coding c++ while I'm away. I was going to bring a guitar but I'd rather work on a skill that I'm not as good at as I'm deciding which degree to pursue. I have a year and a half of credits which transfer to compsci or ee but I don't want to drag around my overpriced ee lab when I could write code instead with a decently powerful laptop. I plan to travel to Utah this summer to camp under the milky way before I hit the books again. I've spent the last 4 years donating half my disposable income from my pension to others so they can learn and put a proper electronics section in the local makerspace. My ptsd keeps me from being able to leave the house and teach there in person or attend the labs I'll have to attend when I go back to school. Sorry. I ramble. I figured you'd get what I mean when something is stuck in your head and can't move past it. I could link the git repository if you like. Id be extremely thankful and would make good on my donation.

Omg, my sides 😂, that intro was so good

😂

I was wondering about that, but sticking my head in the thumbnail seemed weird... maybe I should at first?

@@DavesGarage Yeah, the lack of your mug is why I didn’t immediately click on the video.

​@@DavesGaragequick work!

@DavesGarage it's much better than sticking your head in other places.

Thumbnail was pretty good as well.

Agreed!!!

Its from "Better call Saul" if you didnt know. Good show!

@@DM-qm5scso, Steven Ogg (I think I got “Trevor”’s real name right) had a guest bit? My wife used to watch Sol, but I only sampled a few episodes.

Thank you for pointing that out! I'm sure many are aware of this, yet there are just as many who aren't and for those who are new to it, this is really good information to be aware of. As a side note, this could also potentially be compiler dependent (implementation defined). I'm not 100% sure on this based on the literature of the standard so don't quote me on it. However, using MSVC vs Clang, vs GCC, vs Intel, vs MingW, etc... may provide the same results if they support and implement this feature of the language which by now I'm sure all major compilers do. Yet their methods of doing so can and will vary which also depends on the various compiler flags that are being used during compilation. It all depends on how each compiler parses, tokenizes and analyzes or handles the source code it is given to compile as well as how the programmer - user instructs the compiler or gives hints to the compiler to do its job. For simple expressions I would assume that almost all compilers would generate the same assembly, binary results. However for more complex expressions, the results may and can vary. Again, this is a really good and underrated comment. It is truly good advice to give!

It is guaranteed if you just constexpr the result. That is guaranteed to calculate at compile time or be a compile error.

@@ColinBroderickMathsSure when the assignment operator is involved for a specific type. Now as for the evaluation of an expression, mileage may vary.

thank's for sharing practical example

this is not an optimization, this is meta programming. Your algorithm doesn't become faster because of the constexpr. It runs just as slow, but during compilation.

​@@sergeykolesnik1171That was my takeaway

​@@sergeykolesnik1171Precomputation absolutely is an optimization. You don't tend to compile as often as you run.

@@sergeykolesnik1171 Algorithms don't have "speed", only complexity. "Fast" algos merely trade time complexity in exchange for space complexity and shit themselves the moment you start to hit RAM limits. I.e. a typical hash table has assumptions about the maximum size of the key storage and upon hitting this limit in best case scenario crashes, in the worst case rears its ugly side effects.

😂 Doesn't speak highly of grading in classes.

Yeah typical unclear requirements... It should have been more generic. Something like: Having an 8bit input N, handshake start/result_rdy interface, clk, reset and an output 31 bit... Calculate the N! when start is asserted and then assert result_rdy when the correct value is done.

🤣🤣@@Divine_Evil

don’t ask stupid questions if you don’t want stupid answers

@@pilotashish Actually, there was nothing stupid in this question. The question was to compute a factorial of 32, not to make a function that computes a factorial for any given integer number (32 in particular case), and the program did exactly that.

Nice

Doesn't that just mean that compiling now takes just as long as running the actual test would?

very cool and pretty well explained, thanks!

​@@ThePC007That was implied in the latter part of the comment: "if it compiles, it is correct". So instead of running compile && test you just run compile.

@@AnttiBrax But then, what do you gain from doing that? Since unit tests are compiled once, and the run once, there shouldn’t really be much of a performance differnce. I guess you might benefit from your IDE showing the error right inside your code, though, assuming it can actually catch such bugs.

Nope, just constexpr variables not expression/function. So it's not that useful. Also C doesn't have "if constexpr" like C++ to make compile time code path decisions.

@@aniketbisht2823 Nope what? It would have taken you much less time to go to google and type "c23 constexpr".

@@aniketbisht2823 macro magic can do this in c

Aren't they always? I've been doing this for 10+ years and every single time I think of something clever, somebody has usually already made it (to one degree or another).

There's a reason NASA doesn't allow it in their coding though. Error-prone & hard to debug.

You're missing the most important part of recursion: They are FUN! Nah, but seriously I often solve problems by recursion because it is easier for me to think that way. The benefit when you write something recursively is that you through smart use of parameters can easily control the data in every context, that is in every call in the recursion. I understand, however, that they are more complicated to debug for others who aren't used to thinking recursively. Therefore it is, as always, extremely important to properly test your recursive functions for all possible inputs that can come through the public interface, and never, ever, have them read or write data not in the input parameters.

@@NinjaRunningWild No, that's not why. Recursive solutions in fact tend to be much easier to understand and debug than iterative solutions. The problem is that they don't fail gracefully: try to solve too big a problem and you'll get a literal stack overflow, whereas an iterative solution would typically run just fine.

Recursive solutions generally use up a lot more memory than iterative ones due to each function call adding memory to the stack

Big shots in that show

That's a great example of a use for that, feel like I just understood the practicality a lot better now. Thanks!

Well I wouldn't necessarily say that. I created my own meta templates before they became part of the standard. It was quite fascinating at the time and a very productive learning experience. The introduction of 'constexpr' was an extension of what some people were doing with templates already. It just allows you to write them in a more easily understood manor.

@@johnshaw6702 It's true, templates were already Turing-complete so there was nothing you couldn't do before that you can now. But template metaprogramming is very hard to teach, and the syntax makes the code rather difficult to understand and debug. It's also purely functional (excepting the stateful template instantations thing which IMO should not be used in serious code), which is a completely different paradigm to normal C++. So constexpr stuff, while not giving any strictly "new" capabilities, makes the existing capabilities easy enough to use that I can convince my team to use them, for example, and be confident that people will "get it" and continue to get it over time. I don't shy away from template metaprogramming myself and there's some great tricks you can still only do using it, but the more that can be done using familiar syntax and patterns, the better.

Only if your compile environment has the requisite resources 😂

Yep, it's a cheat. Trading compile time for run time.

Well that finonacci implementation is horrible. A simple iterative one can get you O(n), a smarter one O(log n) and an aproximate one (using the formula for the nth finonacci number) runs in O(1). Also constexpr is not really needed, if you run the compiler with optimizations activated (O3) it will probably do this by itself.

Yes, but you can get O(1) both for runtime and compile time by calculating the value once on the side and putting it in manually in the code. So if it actually never changes, you'll have paid for the computation only once, and not at every compilation.

​@@ObscuraiIt sounds like a cheat if you only concentrate on the drag race example. The benefits to constexpr were really badly sold in the vid I think. There are a lot of better examples of great real world applications in the comments.

constexpr can never be as powerful as a python script that generates some code called in your makefile. It's dirty but it works.

print(“hi”)

Even on a 486 (with hardware FPU support for SIN/COS), which is some order of magnitude faster than the C=64, there was a lot of speed to gain by using lookup tables. But at least we could do LUT + interpolation instead of fully pre-calculated paths :P

This makes me chuckle a bit, thinking about how people used to look up the trig tables in the back of their math book to evaluate something, and I grew up thankful I never really had to beyond an exercise, because we have computers to evaluate those for any value for us... only to know realize that in some cases the fastest way for a computer to do so is sometimes to make a table ahead of time it can look up to get the answer! (or part of the answer at least) 😅

Nice! I regard C++20's Concepts more as *declarative* type constraints (so I prefer `constexpr` for this case). In essence, you are suggesting something similar to Rust's procedural macros, if I'm not mistaken.

I concur! I've wanted to learn C++ for ages. I started to try to grok the low-level details of systems programming years ago as a teen, but modern OS UIs abstract away so much of what is really happening that any program seems like a miracle to me.

@@theograice8080Try game programming & write your own engine in DirectX, OpenGL, or SDL. You'll learn all you need to know along the way.

@@theograice8080, get the book Beginning C++23 by Ivor Norton and start there.

@@theograice8080 if you actually want to learn C++, use learncpp. It is a good tutorial that is suitable to teach you about software development in C++ from zero prior knowledge about programming. If you already know some programming languages you can still use it and just skip a few of the first chapters.

there's constexpr young brother too, consteval.

Using tail recursion massively speeds things up. I wonder if I can paste code __int64 Fibtail(__int64 n, __int64 p = 0, __int64 c =1) { if (n == 0) return p; else if (n == 1) return c; else return Fibtail(n - 1, c, p+c); }

Forth could do that in the 1980s .. a brilliant langauge .. but that sort of 'refine the language' trick creates write-once-read-never code.

I thought the same - if you want fib(35) hard coded why bother even using a constexp "function" but just put the value in directly - you are just as likely mistype the functional code as you would type the exact number in from google or calculator. The only upside would be if you are unsure at the time of writing the main program what fib number you want to use - and hence easy to change to say fib(22)

​@@bretthunter2828it's a lot easier to review code for errors than a magic number

⁠@@bretthunter2828what you experience is what is called a failure of imagination. I also thought like you, but when I saw what kind of sorcery people came up with I was shocked. For example I saw a compile time regex parser library, if you know regex it can construct state machine at compile time which is an incredible speed up. And it was simple to use!

To give a concrete example to what M-FeD was saying, if you have a string and you need to know which of one possible values it contains, you can switch on the runtime-calculated hash of the string and have case statements of compile-time calculated hashes of possible strings to compare against. The alternative would be a ton of if...else if... statements and a bazillion string compares. E.g.: switch( hash( str )) { case hash( "colour" ): break; case hash( "size" ): break; //etc... } All you need is a couple of hash functions that can hash strings or string literals, and you're good to go.

Exactly my thought. Why doesn't he just hard-code the result of the function, this way we don't even need to bother the compiler. "Hey folks, I optimized the program so it runs 1000000 times faster when you call factorial(1e7). How? I hard-coded the constant with the result."

@@diogeneslaertius3365 Because then you have hardcoded magic values in your code. If that magic value is incorrect how will you know? If it's done with code you can fix errors more easily.

Yeah in a complex program you'll just hold every possible result in memory? What...

@@AelfricLake Not every possible result, only hardcoded results for specific constant inputs given at compile time. It's of limited usefulness because most inputs won't be known at compile time.

Sure, but it's still a useful tool no?

constexpr is very useful for code obfuscation, string encryption etc. enjoy doing that in C

If you can throw constexpr in front of a function, you turn it, potentially, into a lookup table without having to find and replace all the code where the function is called.

@@mgancarzjr or just re-code the function to do the lookup rather than compute the result. The calling code wouldn't need any changes.

@@strehlow how do you propose letting each instance of the function know where to look for the lookup table? Genuinely curious. I can only think of static class members being able to automatically access the same memory.

@@mgancarzjr The function definition has the lookup table. The calling code doesn't know or care how the function produces the result. It doesn't need direct access to the lookup table. This is no different than refactoring a function with a more efficient algorithm, or any other optimizations. As long as it still produces the same mapping of input to output, why would the calling code need any changes?

no constant expressions are evaluated at compile time the point is that the expression is constant and thus won't need to be calculated during runtime as it was already evaluated and baked in during compilation

in other words, phi and 1-phi where phi is defined as phi = 1+1/phi (or phi^2 = phi+1) and is known as golden ratio and 1-phi is known as a golden ratio conjugate (1-phi = -1/phi) phi can be declared as a constant phi = 1.6180339887498948482045868343656 whereas 1-phi = -0.6180339887498948482045868343656 so due to how floating point numbers work, it's best to instead define apc = 0.6180339887498948482045868343656 (absolute phi conjugate) and then apply that by doing 1.0+apc (instead of phi) and -apc (instead of conjugate)

You need a machine with multiple CPU sockets to enable it. Each CPU has it own directly connected memory, although both CPUs can access the entire shared address space. For CPU1 to access CPU2's memory, it goes through a high speed processor to processor interconnect (called QPI or UPI on Intel), but this adds overhead, so typically the OS favours affinity between CPU and its directly connected memory when allocating memory to threads. Logically access is transparent to the application. There's also the issue of cache coherency for the OS to consider, as each CPU has its own cache.

NUMA stands for Non Uniform Memory Access, it exists to deal with computers that either have multiple sockets or that for other reasons have one portion of memory have a different access time than another, (for example it takes longer to move data across sockets). some single socket cpus also perform better with NUMA enabled as they have some memory channels more closely integrated to some core than others (like 1st threadripper generation)

If you do some tricky stuff with arena allocators, even that's not necessarily impossible either. You can absolutely have a constexpr function returning pointers into an rodata segment of the compiled binary.

No.. it DOES take longer to compile, but then the answer is put in where the code would otherwise go, so it's tiny. But of course, it only works for things that CAN be figured out at compile time... but it's surprising what can!