Episode 77: C++ Algorithms & Profiling with Ben Deane (Part 3)
34 minAudio
In this episode, Bryce and Conor continue their conversation with Ben Deane about C++ Algorithms! Twitter ADSP: The Podcast Conor Hoekstra Bryce Adelstein Lelbach About the Guest: For Ben Deane, C++ wasn’t even among the first 10 languages that he learned on his programming journey, but it’s been the one that has paid the bills for the last 20-odd years. He spent most of that time in the games industry; many of the games he worked on used to be fondly remembered but now he’s accepted that they are probably mostly forgotten. These days he works in the finance industry writing high-frequency trading platforms in the most modern C++ that compilers can support. In his spare time he watches a lot of YouTube’s educational sector, practices the Japanese art of tsundoku, reads about the history of programming, avoids doing DIY, and surprises his wife by waking in the middle of the night yelling, “of course, it’s a monad!” before going back to sleep and dreaming of algorithms. Show Notes Date Recorded: 2022-04-19 Date Released: 2022-05-13 ADSP Episode 72: C++ Algorithm Family Feud! ADSP Episode 75: C++ Algorithms with Ben Deane (Part 1) ADSP Episode 76: C++ Algorithms with Ben Deane (Part 2) quick-bench.com Tyler Weaver Tweet C++ std::sort C++ std::nth_element C++ std::max_element C++ std::reduce C++ std::transform reduce C++ std::accumulate C++ std::shuffle C++ std::random_shuffle C++ std::iota C++ std::partition HyperLogLog Algorithm CppCon 2017: Nicholas Ormrod “Fantastic Algorithms and Where To Find Them” Algebird “Add ALL the things: abstract algebra meets analytics” by Avi Bryant (2013) Intro Song Info Miss You by Sarah Jansen https://soundcloud.com/sarahjansenmusic Creative Commons - Attribution 3.0 Unported - CC BY 3.0 Free Download / Stream: http://bit.ly/l-miss-you Music promoted by Audio Library https://youtu.be/iYYxnasvfx8
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.
Transcript
From the show. Tap a time to play from there.
Ben DeaneI mean stud shuffle got removed, so. Uh no no, random shuffle got removed.
BryceNo. Random shuffle got removed. Oh. Stud Shuffle's the replacement. You just got owned, my friend.
ConorYou're listening to three algorithm experts, clearly one of which is less of an algorithm expert than the other two. Boom. Welcome to ADSP the podcast, episode 77, recorded on April 19th, 2022. My name is Connor, and today with my co-host Bryce, we continue part three of our four-part interview with Ben Dean talking about C algorithms.
BryceI don't know how you're still alive given that you exercised more than me today.
ConorUh I'm wired. I'm wired. I mean uh we're talking about birds and combinators.
BryceYeah, the crash hasn't happened yet. It's coming. It's coming.
ConorI mean, you also have a way earlier bedtime than me, you know. I typically go to sleep at like midnight.
BryceNo, my my bedtime has been disrupted the entire winter. Not entirely because of winter, but because of my bring up the profiling.
Ben DeaneMake Bryce nice and angry so he stays awake. There are things wrong here, Bryce.
BryceAlright, there's no there's no error bars. So you know. It's using Quickbench. Alright. Whatever. I I have I have there is no there is nothing in this graph that tells me anything about the measurement uncertainty. Uh, so I have no idea whether or not I can trust these numbers.
ConorUm so so first of all, let's do a tiny bit better job. Uh the tweet that we are looking at is the first photo that Tyler tweeted out, and it's profiling five different solutions: sort, nth element, max element, uh, std reduce, and std transform reduce. And in order or would you like to say something now, Bryce?
BryceThis is like not even a graph. Like you gotta, you gotta, you gotta label both axes. No, I I look look look, Tyler, you've done great work. You've done great work. But here are my notes. What's the y-axis?
ConorI don't I think it's just a relative measure. I don't even think it is necessarily needs to have all this stuff. I agree.
BryceBut but these are notes I think less for Tyler and more for But if it's a relative if it's a relative measure, then you need to say what it scales. As a relative measure, we should say, I mean, some some things we can No, wait, wait, this is hundred percent not Tyler's fault. This is this is whoever writes.
ConorIsn't it fred I I don't want to say I I feel bad if I'm given the wrong credit about it, but is it Fred?
BryceYeah. Fred, you're coming on the contact.
Ben DeaneI have I have some there are constraints like probably how much computation time Fred wants to pay for for the site to devote to this kind of thing, but no, no, no, no, this is nothing about compilation time.
BryceLike, this is basic best practices of statistical uh performance analysis. Um Okay, alright, let's look at the actual code for what for what's uh for what's being done here.
ConorWell, so first we should, I mean, for the for the individual, the listener that is not gonna go and look at this. Yeah. From worst to best, uh, the sort is the worst.
Ben DeaneEyeballing it, it's about twice as bad as the next.
BryceYou know now the bottom of this graph says lower is faster. And any time that you produce a graph where you have to explain something that should be intuitive, that typically means that something has gone wrong. Instead of saying lower is faster, why don't you just change your visualization so that higher is faster, which is the intuitive reading of graphs.
ConorOh, well, actually, look here. We we do have the x and y axis. They're just not labeled on the x and y axis. It's cpu time.
BryceI know I yes, I noticed that, but they should have been labeled on the axis. And also, what is CPU time? What is no op time?
Ben DeaneOkay, what can we say that's useful here for the listener? One is that um uh after the very low numbers, basically all the graphs are linear. Um and sort is the outlier in terms of comparing the slopes of the graphs, sort looks to be about uh double the slope of the next the next highest, which is reduction.
BryceBut interestingly, there are there is um there's a data point at about 4k for all of it for all of these, but there's not um there's no data point for 8k for two largest sort, which is the the worst performing one. And I assume that's because like it just took too long.
ConorActually, I thought now I never looked at that, but now that you say that, nth element is actually the fastest at uh is it?
Ben DeaneOr is it just the the painter's algorithm that's happened to put it in front?
BryceYes.
ConorIt looks because like at this point, at the 1000 mark, it looks like they're definitely overlapping, but on my screen I can see.
BryceInstead of inferring things from lines, why don't you look at numbers? Because numbers don't lie except for these numbers, because we don't have uncertainty bars, so uh you can actually do that.
Ben DeaneOkay, quick quick benches, it is pretty cool that it does this like in real time, but what these numbers seem to say on uh you know, if we can say anything, is that sort is definitely the slowest uh in in in all cases after the very small numbers. And max element, i.e. I assume that's just get run max element, remove the the found and then run max element again seems to be marginally faster than wait let me see the code for that.
BryceLet's see the code for that for that.
ConorWe'll look at the we'll look at the code in a sec. Um but so this is this we should note just to to finish this narrative, this is for the original uh solutions that Tyler programmed, but I responded to this because he was basically asking, why is this the results? And uh and that maybe you'll have because I I might be wrong about what I initially posted back to him.
BryceYou may have quote tweeted.
ConorYeah, so there's two different ones that I ended up doing. So I I don't know why this is so small. Can I zoom in? Yeah, so I programmed uh accumulate, which ended up being slightly faster than the max element. And then I also ended up finding my initial transform reduce, which is hard to see here, but it's the purple that's underneath the green, so it's slightly faster than the accumulate. So now that we've said all the things.
BryceWait, what why why is why is yours okay? Uh let's look at his first, and then let's look at yours. The code. I want to see code now.
ConorUm well I think I included my quickbench, and my quickbench has all of the solutions. It's just that it's it's just that the you can only run on the web version four of them at a time, which is why I only four.
BryceYeah, I I want to see, I want to see.
ConorSo let me zoom in a tiny bit here because I'm sure this is not super.
BryceAlright, I want to see his max element one first.
ConorAlright, so now we're doing live code review.
BryceYes, we are doing live code review. We are doing live code review indeed. So he's not he's not randomizing the input, right?
ConorUm, no, it's just a modulus operation.
BryceWe should probably try. Let me tell you from my experience, benchmarking Cubs Rate extort implementation. You want to test with a few different input patterns for anything, any anything uh uh you know sorting or partial sorting uh related or any problem of this class. Um okay. Too larger sort, not surprised. Let me see the I want to see the the the max element.
ConorThis is the max element one.
BryceHe's erasing in the vector.
Ben DeaneUh did we we didn't ever get unstable arrays, did we? Yeah. If the thing's not sorted, you might as well swap it with the last element or well well okay.
BryceSo so so I wouldn't I actually wouldn't erase. I would just uh I would just change it to not be the largest. That's gonna be faster. You don't have to actually remove the element and move other things.
Ben DeaneYeah.
BryceTry try instead instead of doing the erase there, try just changing it to um to be zero and then rerun it. I wanna see. I want to see what happens. Alright, we're doing live coding, which we said we wouldn't do, but I believe we have been explicitly requested to not do this anymore, but you know what? It's a coding pod, it's a programming podcast.
ConorAnd let's get rid of because right now the ones we're profiling are the max element, my accumulate, my transform reduce, and then Tyler's transform reduce, but the Tyler's transform reduce is a lot slower than mine. Because I think it's because he's using a sort.
Ben DeaneI mean, slight slightly less destructively if you're worried about that, is just to do an iter swap with the end minus one and then run your max element on the n minus one, n minus one.
BryceAh, that's very clever!
ConorAn iter swap on the iterate the largest iterator in what iterator? The prev of the end.
BryceYes, that's very clever. Now we're cooking! Now we're cooking.
ConorOh yeah, that is nice. That is nice.
BryceOh boy. If this proves to be the fastest way to do this, then it's ridiculous, max.
Ben DeaneI mean the swap is doing a bit more work than just setting it to zero, admittedly, but it's you know slightly less destructive.
BryceIt's a difference of complexity class. Um uh and and these are the like this is the same as doing the assignment.
ConorAlright, this is gonna take potentially 30 seconds or 60 seconds to the same.
BryceOkay, so then while that's happening, I want to see his transform reduce and understand why it's we uh we made a compilation error less tier listener.
Ben DeaneSo is it a swap defined if you pass it the same iterator twice? I do not know the answer to that question.
BryceUh let's find let's find out.
Ben DeaneI mean because if you do that, uh I guess no matter what it does, it might trash that element because it might do a move assignment to self or something, but not in the case of integers, but um getting the second largest element will still work because you'll just do n minus one.
BryceYeah. Alright, so let's look at his reduce.
ConorSo his transform reduce. Is that actually I'm gonna zoom out a tiny bit just so you can see more of this? Is that okay? You can still read. What will what what embrace having problems reading? No, no, no. I think I I'm just trying to I think why are we so So that's he did mention in his video he's not sure if there's a better way to do this. If if we compare it to the way I did it, um I just used structured bindings and then did actually all of the you know cases.
ConorUm I I it is a bit laborious to write out those four different cases, like admittedly No, I actually I kinda I'm kind of liking his approach of cut basically he makes an array with um the left hand side and the right hand side, and then he does a sort of that array. So the profiling is done. Sorry to the listener for hopping around, but um the max element is still slower than both the Really what we need to do is we need we need to compare we need to compare the before and after of the max element.
ConorWould you like me to do that?
BryceCorrect.
ConorIt's easy that's easy enough to do. We'll just copy just like that.
BryceI I do have a feeling that in this case it may not matter much because well no, it really, I mean So we'll call this two, and what we had before was vec dot arrays largest it. And then how how large is n? Oh no, n is very bad.
ConorUm it's 10,000.
BryceI'm worried about the seed sequence and that.
ConorWe're gonna copy and pasta this, and we're gonna call two there. We're gonna call two here.
BryceSo two is the original it's it's like a which doesn't make any sense, but we're just hacking it. Can you show me the initialization code again?
ConorYep. So we're running now. Hopefully I got that right. Um compilers in a second here.
BryceOh no, times the input modulo 1000.
ConorFavorite algorithm, Ben, while you're on the podcast. Did we ask you that last time? I'm not sure.
Ben DeaneUh favorite algorithm.
ConorWell, two questions. Favorite algorithm in the standard, and then outside of the standard as well, if you want.
Ben DeaneUh that's really difficult to answer.
ConorI I thought you were gonna say the name of your guinea pig. Is that I was gonna say?
BryceYeah.
Ben DeaneWell, I I think it's a little bit min element.
BryceWait, you you have a guinea pig that you gave the name Min Element?
Ben DeaneYeah, I like Min for short. She's the largest of my pigs now. She was when we got her, she was tiny, and now she's like three times the size.
ConorIt's a self-fulfilling policy right there.
Ben DeaneLet's see. Yeah, I like uh what did I say? I IOTA's good. I I like a bunch of them. Partition is good. How is reduce not your answer? How is reduce not my answer? Well, for the same reason that uh, you know, reduce is an algorithmic atom, right? It's not, it's not I don't view it as the name of an algorithm at a at an application level. Sometimes it is, but often it's just the way an algorithm is implemented, sort of thing.
ConorThere's a there's a question, I mean, not to interject this question that we're already giving you, but is um what do you think about uh oh yeah, we haven't even I've totally forgot about our heap. Um the the difference between calling things algorithms and functions. I get a lot of flack sometimes from the array community for calling primitives algorithms. They're like, it's a primitive, it's not an algorithm, but like unique is a primitive and partition's a primitive, and a bunch of things that we think of as algorithms in C are primitives in APL.
ConorSo they think of it as if it's spellable with a single character and it's a primitive, that's not an algorithm. That's a that's a tool. That's it, that's a function that you use for building up algorithms. But I don't know, interested to get your thoughts.
Ben DeaneI suppose it's just a matter of where your head's at. Uh, you know, I think in C we tend to think of algorithms as things that work on sequences. Um if you view a sequence as a value, if you're if you're working in an array language, then a an array is a value to you. And so I can see how it'd be normal to think of what we think of as algorithms as functions. Interesting. It's context dependent, basically as well. Well, at least I that seems plausible.
Ben DeaneI'm not trying to say this is how people think I'm somewhat potentially.
BryceI'm somewhat concerned about um uh the initialization sequence that he's using because one of the the this like this sequence of modulos that he's doing. Um the the the maximum that any of these values is gonna get is gonna be 10,000. Um uh because he's moduloing by it.
BryceAnd using this initialization sequence, regardless of of input size, um like the 60th element or so um of this sequence is almost always gonna be one of the the answers. Um while while we're live coding, we should probably change this to you know to to use we're not gonna implement Mersane Twister. Um you can include random.
ConorUh I mean if you spell it out for me, maybe I'll type it. But um just while well before we do that, so we have gotten back the results for our two different max element solutions. And uh definitely the max element that does an iter swap uh with the last element and then does a max element up until this uh um up until the second last element inclusive is slower, is faster, sorry, in all cases than the original one. Um and actually interestingly, um that max element, so previously it went max elements that was doing the erase, then the transform reduce that I implemented, and then the accumulate that I implemented, and accumulate that I implemented is the fastest by far, or I shouldn't say by far in all cases.
ConorUm but now the max element that does the inner swap uh is actually basic, I won't say faster, it's it's slightly faster and slightly slower, so we'll just call it the same as the my uh the transform reduce that I wrote. So interesting. Um and while before we go and change the data here, uh one of the things that I had said to actually don't need to bring up the tweet that I had said to Tyler initially when he when he was seeing that transform reduce was slower is that he had done all that building up of the operators for the function objects and had the four overloads, and I said, uh without calling you know std reduce with the execution policy so that it's in parallel, you're sort of doing all that work for nothing.
ConorUm But like one, if you call std reduce with a non-ummutative and associative operator, but don't pass an execution policy, it's it's still like broken, correct? You always have to do that. Is that the case? Or is the non-execution policy version you can think of it as like a fold?
Ben DeaneI think it's still broken. Because I think commutativity is required for vectorization, I believe. Even without the parallelism.
BryceSorry, I wasn't paying attention because I was writing the initialization code.
Ben DeaneUm that's what I thought. The question, Bryce, was so the question is um reduce has a few overloads. There's the execution policy, parallelizable one, there's one without execution policy. Um does the commutative constraint apply to both or only to the parallel ones? I think it's both.
BryceIt applies to the non-parallel ones. And if you look at how it's implemented in um in GCC's standard library, they actually take advantage of this, of the fact that they know that it's non non-commutative to make it a to do a few fewer operations. Um uh that basically like each each pass of the loop, they'll do like two reductions and then they'll add them together. Um uh and so it will actually break. Um uh essentially it's a little bit of like you know, loop on manual loop unrolling.
BryceUm uh and it's a good optimization, I think.
ConorUm wait, so you said you said it because it's non-commutative, but I think you meant commutative.
BryceYeah, yes, that that's that's what I meant. Um what I meant really was it will break from for things that are non-commutative. Connor, I sent you the initialization or a snippet of of how it's very easy to to like to do this initialization using like stitch shuffle. It's like super easy to to like it's one line.
ConorI mean std shuffle got removed, so random shuffle got removed.
BryceNo. Random shuffle got removed. Oh, stitch shuffle's the replacement.
ConorBecause you're listening to three algorithm experts, clearly one of which is less of an algorithm expert than the other two. At least when it comes to the topic of the shuffle object. Just wait, let's let's finish this topic though, because I uh what I told Tyler is that basically all of that work of like building up that function object, if not parallelizing it, is sort of a waste, but like that's totally wrong because you need to do that no matter what, otherwise it's broken. And it shouldn't really be the case that that is slowing down the like would you or so?
ConorHere's the question because what we're staring at right now is a stdd accumulate that's faster than a transform reduce. So if you aren't using parallelization, is it the case that std accumulate, a left fold or fold left, is gonna be many times faster when you when you don't have a simple associative binary commutative and associative binary operation, like plus, because then you have to go and build up a function object. So like is it that really you should only be reaching for std reduced if you are able to parallelize it?
ConorOtherwise, you're just gonna be slowing your code down. Is that like a universally true?
BryceNo, no, no, no. I mean, I mean, uh, and uh st stdd reduce like if you have an operation that's commutative and associative, you should be using std reduce because your implementation can take advantage of it. Here's what I'm I'm showing you what um uh GCC's standard library, stdd reduce does here. And inside of the while loop that it does, so it does the the while loop um uh it does one while loop where it does um uh four elements in each uh uh iteration, so sort of vectorized, if you will.
BryceAnd then it has a finalized a finalization loop that takes care of any remainder. And so it does um within each iteration of this this loop that does four elements, it does a it does the binary op on um uh zero, the zeroth and one th element, then it does the binary op on the second and third element, and then it does a binary op on those two intermediate results here. And so this this one does some loop unrolling, and two, it saves you some operations and it gives you some vectorization potential.
Ben DeaneI don't think this is requiring commutativity though, from what I'm reading here. It's requiring associativity.
BryceYes, yes. So so yeah, yeah, yeah. Um yes, but an im but but this is just one example of how an implementation could optimize this. Another way that an implementation could optimize this would be to do vectorization inside this loop. And and that would um uh require the commutativity. But this this was this was just this was just for this is just a demonstration of one such optimization that this allows, and that's actually done in in the wild.
BryceThere's other, you know, you could also use that information to do the the vectorization. Well, well, you you if you're really being standards conforming, you couldn't like always like like say like like hey, we'll always vectorize this loop. Um, but you could give a hint to the compiler. Um uh because to actually do the vectorization requires some additional C standard um uh blessing.
BryceUm but it but an implementation could choose to do these like to do it, doesn't have to do these in like the order here. It could choose to do binary op on first on the the zero with element in the third element and then the first element in the second element if it so chose. I mean, not that there's like a particularly good reason to do that, but you could do it if you wanted to.
Ben DeaneSo I mean it's what I'm sort of thinking here is that um if you have just an array of floats um with this implementation, like accumulate could well give a different answer to reduce.
BryceYes, that is correct. That is correct. And actually, I think one of the reasons why so I'm sure that the GCC implementation did this because it gives you know some performance benefit and fewer evaluations. But another good reason to do this is that it it breaks the code of anybody that makes the wrong assumptions about reduce, which is a nice, a nice thing. Um uh okay, all right, Connor, put in my initialization code, let's rerun this thing.
ConorWe'll do that in three minutes. Uh so the question is then maybe it's not because it's gonna take three minutes to answer the question I'm about to ask.
Ben DeaneUm my favorite algorithm not in the standard.
ConorOh, yeah, there are six minutes on the clock. Oh, great one, yeah. Uh there's someone from Facebook that has uh a talk about four different algorithms, and that's what I'm talking about.
Ben DeaneFantastic algorithms and where to find them. Um cpcon 2017, I think.
ConorCan you re-say what the name was?
Ben DeaneHyperlog. Hyperlog. Come on.
ConorCome on.
BryceI I'm not sure.
Ben DeaneIt's a probabilistic algorithm, right? The the sort of poster child use case for it is counting unique logins, right? So you run a website, you have billions of logins over the course of a month, you want to know how many of them are unique. Hyperlog allows you to estimate this in a probabilistic way. And like many probabilistic algorithms, um, it has the characteristic that you can spend either computation power or memory to constrain and bound the error on your result.
Ben DeaneUm, and the way it basically works is the intuition for it is that you're gonna take each username and hash it, and and conceptually you're going to hash it a few different ways. Um and it's unlikely you're gonna assume that all of these hash functions are ideal. So it's uh it let's say you log in, Bryce, and Connor logs in, and under one of these hash functions your usernames collide, but it's unlikely they'll collide under all of them.
Ben DeaneRight? This is one of the intuitions behind um kind of probabilistic counting. You're using hashing to get that bounded space. And you're using um the there are there are the way it works is actually by using the hash as sort of a bit string. And um one of the insights is that um if I'm if I'm just seeing random numbers go by, i.e. ideal hashes, um when I've seen the odds that I will have seen a number ending in n zeros is correlated with the fact that I have seen two to the n numbers.
Ben DeaneRight? So if I've seen two numbers only, odds are one of them will have ended with a zero. If I've seen four numbers, the odds are higher that one of them will have ended with two zeros. Right? If I've seen eight numbers, the odds are higher that one of them will ended with three zeros. And so you keep track of effectively the longest string of trading zeros that you've seen. And this allows you to recover an estimate for the total number of logins that you've seen, a unique logins.
Ben DeaneThis is, you know, I'm I'm simplifying greatly, but that's the intuition.
BryceYeah. A lot of that reminds me a lot of uh quantum computing uh techniques for solving uh uh uniqueness uh counting.
Ben DeaneYeah, yeah. It's related to things like Bloom filters. Um there's a similar algorithm called count min sketch, um, which allows you not only to sort of count the number of things you've seen, but also um re remove things from from the set of things you've seen if you haven't, because uh uh underneath the hood it's uh it's keeping effectively several hash tables um and all of these functions.
Ben DeaneSo there's an another great talk I should um I want to plug, which is I think from Strange Loop 2013. It's called add all the things. Uh and it's by oh his first name's Avi, I think. I can't remember his last name. Avi Brandt. Come that you already have it in your list of talks in your spreadsheet.
BryceI'm almost positive you recommended this talk and I watched it, but unfortunately I lost We're looking at portfolio of words, which longtime listeners will know is the spreadsheet that uh uh basically tracks Connor's entire life.
ConorIt's it's weird. I mean, um, so I I don't have it in the list, but I recently realized that a talk that I watched uh There's a tab called Buddhisms. Oh yeah, yeah. I mean he's I mean he used to be an actor, and so I would write down things that are like Wait, whoa, whoa, whoa, take a step back.
BryceRepeat what you just said.
ConorI used to be an actor, professional actor in my youth. Childhood. You know this about me. No, I do not. Yeah, you said we gotta talk about it at some point, and then we Oh my god, were you in things? Uh I mean it was it was it was professional local theater, so it was not Broadway or anything. Um we do it's like people paid this. People paid to come and see me. Um, I was in a play called Lost in Yonkers, which um was a um was a movie.
ConorIt's Connor.
BryceI my mind is blown. How did I not know this about you?
ConorUh I don't know. Anyways, the point is that uh I when I would read things in books like uh flexibility of thought or palpable falsity or a jocular remark, I like to write them down and then because they sound they they roll off the tongue.
Ben DeaneThat's what witticisms at all the things is is a talk that um kindled my love of monoids. And in it, Avi Bryant talks about um uh he talks about statistical a statistical framework um for doing probabilistic things, among other things. Um and uh one of the points of the talk is that all of these things are monoids. Um hyperlog log in other words, having a monoid is one of the keys to being able to distribute the computation.
Ben DeaneRight? You can calculate you can you can split your logins, load balance your logins, and on each separate machine you can run this hyperlog log algorithm, and then you can combine the resulting uh data structures because they are monoidal, and you can get the same result as if it had been just one machine.
ConorI'm almost positive you told me about this talk at the same time you told me about um Algebird, Twitter's statistics framework.
Ben DeaneAlgebird.
ConorMore birds. Yeah, yeah. Yeah, so I I'm positive I watched it. I just clearly didn't update my spreadsheet. Um yeah, more birds. Birds are everywhere.
BryceWe should probably start wrapping up because Bryce is getting tired, but I want to see what happens when we when we uh when we use a proper pseudo random number sequence.
Ben DeaneConnor and I have to get in all the algorithm content but by the end of the the quickbench content. Because the quickbench content is keeping Bryce awake.
ConorThanks for listening. We hope you enjoyed and have a great day.
In this episode, Conor and Bryce chat with Zach Laine about C++26 Reflection vs CRTP, AI, kids & more. Link to Episode 313 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP:...
In this episode, Conor and Bryce chat with Zach Laine about the C++26 contracts fiasco. Link to Episode 312 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP: The Podcast:...
In this episode, Conor and Bryce talk with Zach Laine about his career and the career changes he has made. Link to Episode 311 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials...
In this episode, Conor and Bryce talk about Bryce's next chapter and where he is leaving NVIDIA for. Link to Episode 310 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP: The...
In this episode, Conor and Ben chat with Jason Turner about default construction in C++. Link to Episode 309 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP: The Podcast:...