Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

ADSP: Algorithms + Data Structures = Programs

ADSP: Algorithms + Data Structures = Programs artwork

Episode 309: Default Construction & CppCon 2026 with Jason Turner

Oct 23, 202629 minAudio
  • Apple Podcasts

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: Twitter Conor Hoekstra: LinkTree / Bio Ben Deane: Twitter BlueSky About the Guest: Jason is host of the YouTube channel C++ Weekly, co-host of the podcast CppCast, author of C++ Best Practices, and author of the first casual puzzle books designed to teach C++ fundamentals while having fun! Show Notes Date Recorded: 2026-10-07 Date Released: 2026-10-23 CppCast Podcast List of All Jason's Talks [resize_and_overwrite](https://en.cppreference.com/cpp/string/basic_string/resize_and_overwrite) The worst programming language of all time itCppCon20 - My Least Favorite Anti-Pattern (Conor Hoekstra) Specialized algorithms Engineering Distinguished Speaker Series: Howard Hinnant Refactoring Techniques and Strategies (a Tale in Three Acts) - Dave Steffen - CppCon 2026 Escaping 1996: Meta-Modern C++ Techniques for Embedded Systems Expression-based Programming for Better Code? - Jason Turner - NDC Toronto 2026 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.

ConorI'm not saying that all functions that can't fit on a single screen are too long.

BenBut we've entered we've definitely entered the realm of this is outside the ordinary and deserves attention to justify itself. Yeah.

ConorBecause like some of the best code that I've seen, it's just it is like it's not even C it's like closure, and all of them are just these beautiful little concise composed, you know, everything, it's it's you know what when you hear Stepanov or Sean Parent or or you Ben talk about like the composability of Albert, you can see that everything was so beautifully crafted to fit together that you only ever need to invoke, you know, five, six, seven things, and you just read it and it's like it's like reading poetry. It's it's so nice. And and you never are asking yourself, is this too long? Because it's obvious that it's not.

BenYeah, well, we could talk a bit about default construction if you like. Sure, yeah. Steer the boat, Ben. Steer the boat. Well, I was thinking about this this morning some more. It occurred to me that default construction is really a poor term. The term that we've sort of had all these years, and it sort of confuses two ideas. It confuses the uh and and one of the one of the things that we inherited from C and one of the things that kind of the idea of regular types and Stepanoffian stuff try to do is to say, well, let's the great thing about C is you can make types that behave like the built-in types, right?

BenAnd and and so Gottmeier says, you know, when in doubt, do what the ints do. But actually, actually we don't like what the ints do. This this is kind of bad advice, right? Because we don't like interprotions, we don't we and we and we don't, you know, in recent years we've started to realize that we don't actually like uninitialized construction, right? Which is what the ints do. Yeah. That's not actually a good way to make your type to to to design your types, right?

Jason TurnerYeah, we don't we like very little things that the ints do.

BenAnd and so, you know, default construction conflates two ideas. One is uninitialized construction, doing what the ints do. And that I think is just a bad idea. The other applies for some types, and there's a reasonable idea, which is the idea of nullery construction, which is basically saying, okay, the author of the type was able to provide reasonable defaults, right? Nullery construction for some types is perfectly fine. Uninitialized construction is almost always a bad idea. Now there are certain now the and the reason why we've we've held on to it for so long, perhaps, is has been the performance argument, right?

BenWhich is that I don't want to initialize this whole array of zero things. And and interestingly, in in in recent years, we've seen things like resize and overwrite. We've seen effectively the expansion of the construction idea to cover these performance arguments, right? But but we still don't like uninitialized construction. That's still kind of a bad thing.

Jason TurnerYeah, so uh I had one student come back to I like I don't disagree with you, just for the record. I'll start with that. But I had one student once come back to me after a class and he's like, look, he said, one of our main performance bottlenecks right now, he's like, I need to be able to resize a vector of trivially constructible things, but Vector insists on initializing all the objects. And he said, one of my main performance bottlenecks right now is the initialization of those objects. And these are like people who work on like really large physics simulation engines, like you've got, you know, who knows, whatever, billions of particles or something, and you really, really, truly don't want to initialize that memory with zeros, because that's like a performance problem for you.

Jason TurnerAnd I've never encountered code like this in my own time. But whenever I think about this argument, I go back to this person and I'm like, what is a good answer there? And I've never come up with like what I think is like actually a good answer for this situation.

BenYeah, and you know, it that event that the the thinking here eventually leads us to things like, you know, how C defines lifetime and um all that kind of stuff. And indeed things like resize and overwrite for string, which I don't think exists for vector, right? Which might be another piece of but uh, you know, so the other thing is that Stepanovian regularity is defined as having the special member functions basically, being copyable, having a quality, in fact also having comparison.

BenAnd and also being default constructible, which again I think is a poor term to use, because actually it's not needed. It's not needed, I don't think, to define regular, and it's not really needed to even implement the standard library for the most part, you know. So so supplying default constructibility because we think that's what's needed for the code, actually, if we think about containers, it's only vector resize and and square bracket operator on on the map types that require default constructability.

BenThere are no other functions on containers that don't I I think.

ConorWhat were those two? The second one was the square brackets on map types, the first one was.

BenYeah, the indexing operator. And that arguably is a poorly designed API, right? Indexing into a map in C. Default constructs the object if it wasn't there.

ConorI just I just watched, it was it was on my list for a long time. There's a is it two-hour video called The Worst Language Ever?

BenOh, I've seen the title. I haven't watched the video, yeah.

ConorYeah, it's a clickbaity title. It's about C, but really it's like a master class in like, you know, becoming a language expert and finding all the different things. And that's in the first ten minutes, I think it talks about that being one of the biggest kind of warts of the container types is is that kind of behavior. And it it puts it up against Python and Java and a bunch of other languages, and it's like no other language does this because it's absurd. Like it's not at all what you expect.

BenDefault construction, I should say I'd like to stop using the term default construction and and indeed say non-initializing construction versus nullery construction, right? So non-initializing construction, which is what the language applies to built-in types, basically, that that leads us down the route of, oh, you know, we have to deal with it historically, so now we have erroneous behavior, for example, for reading from non-initialized built-in types. It also kind of flies in the face of, you know, one of the original things at C, one of the original kind of selling points, if you like, of C over C is that we don't have to declare all our automatic variables up front only to assign them later.

BenWe can wait till we need the variable to declare it. And at that point we know how to initialize it, presumably. And you know, this is certainly a best practice I know that Jason espouses, and then you can mark it const and all those good things, right? And and Connor, I know you've talked about the initialize, then modify anti-pattern. You know, so the idea of non-initializing construction just is anathema to to this kind of best practices worldview.

Jason TurnerYeah, I'm not gonna disagree with you for sure. And then there's fallback solutions if you really need them. Like you can make an optional of the thing and then uh fill it in later, which I don't love optional, but that is a good use case for optional, right?

BenYeah, it's it's the major use case I have, I think. Deferred construction.

Jason TurnerI just I feel like I just want to say out loud to anyone who just heard me say that. Still try to figure out if you don't need optional first, right? Don't just be like, oh, I'll just use optional here because I don't have a plan. You know, don't do that.

ConorWhat does I I don't use these algorithms? Or or sorry, go ahead, Jason. I was gonna say, I I don't use these algorithms, but I know that they were added. The uninitialized underscore operations. What does yeah, what does your commentary here, Ben, say about those? Like I'm this is a more of like because I like Oh, you're talking about the algorithms in memory.

BenI think it's copy uninitialized and move uninitialized, is that right?

ConorYeah, but I think they might have even come up I've never looked at I've I've seen them maybe even in Thrust or some other libraries, and and they are like for I think performance reasons, but like when I hear potentially like an argument for do we do we even obviously they're not gonna do this to C ⁇ , but we're talking hypothetically here, you know, do we even need quote unquote, you know, default construction? Like, does that I mean what does the existence of these uninitialized algorithms or operations like mean in in this kind of context?

BenLike I don't have the answer. I haven't used them a whole lot. I I tend to think something is telling me, I'm remember if I'm remembering right, they are often used in the implementation of types like vector. And they are for things like I I I ha I yeah, I I need to I need to do things which involve micromanagement of lifetimes.

Jason TurnerYeah. Constexpr in 26. Looking up the details here. I've never done I've never used them. This is like and this is officially going on a list for an upcoming C weekly episode. Perfect.

BenYeah. I I've I've only ever used them in things like implementing like my own containers, my own vector, for example.

Jason TurnerIt's clearly not necessary for the constexpr implementation of vector. Otherwise, it would have been constexpr in C20. That's how these things tend to fall out in the standard. So I am curious.

ConorYeah, I just I Googled uninitialized on CPP reference, and the set that comes up when you Google or Google that search that, is std uninitialized copy, uninitialized fill, uninitialized move, uninitialized value construct, unitialized default construct, and initi uninitialized construct use and then there's ranges versions of those also, it seems. Yeah, and they're they're all defined in memory, not algorithm, although it says specialized memory algorithm. Page and confusingly puts it under the algorithm, or it doesn't put it under, but to the left of the specialized memory algorithms is the algorithm library.

BenSo I'm gonna think of these things as specialist tools for managing lifetime in things like containers, like we said. I think if you find yourself using these in application quote quote application code, then then maybe take a step back and look at encapsulating it in.

ConorRight. No raw uninitialized algorithms. Not as catchy as uh Sean's no raw loops, but hey.

BenYeah, the the idea of uninitialized or non-initializing construction, like for ints, right? So if we think about this more, I think I was thinking about this like so and I and I looked inside elements of programming and it defines regular types in chapter 1.5, and it doesn't actually say that your default construction is required, it says construction is required, and then it goes on to say that default construction is when you have no argument. Uh but it's not necessarily true, I think, for a consistent view of of regularity that we require default construction.

BenThe the one axiom, if you like, of regularity is that if you copy a T, then the A and the B should compare equal after the copy. Right? That's that's the axiom that links copying and equality. And it and it presupposes that you have a T available. How that T was constructed, the we don't really care at that point, right? And it may be also be true that some of the containers in their internals from time to time require nullery construction.

BenRight. And that I'm not I'm not using deliberately not saying default construction. But if if we if we just say int x with with no initializer, right? So that the storage is there, the int is it alive? I think it's alive, but it has but but it's partially formed. And these are also the words of elements of programming, it's partially formed, which is to say that you can either destroy it or assign to it.

Jason TurnerAnd you cannot read it.

BenWhat it says in EOP. You cannot read it. That's erroneous behavior from from 26 onwards, right? Um Well, you know, part of me wants to ask, what what is the point of constructing an object that cannot be in any meaningful way used? It it seems to me like if the the the fact of the matter is like built-in types do not have class invariant, right? They're not class types, we don't think of them as having class invariants. But maybe we should. And if we were to do that, then we would naturally think, well, you know, if I'm constructing an int and not initializing it, then that's upholding none of its invariants.

BenIt can't be used in any meaningful way. And that is part of its interface, and therefore that is you know, I expect after I construct an int that I can use it.

Jason TurnerYeah, that's a fair argument.

BenAnyway, that's my soapbox.

Jason TurnerYeah, no. And I think adjacent to your soapbox is I've made a point of demonstrating this in a few talks, and I bring it up with students whenever it makes sense to. And it's it was one of the points that I end up making at the very end of this rule of n talk. Well, I don't whatever. I make the point somewhere in the talk. Depends on the version. If the thing does not have a default constructor, like if you must provide something to construct the thing, I have come to the conclusion personally that this object should not be movable under most cases.

Jason TurnerBecause the now, so can I ask a clarifying question?

BenDo you mean it should only be copiable?

Jason TurnerYes. Okay. Potentially, yeah. Copyable or I mean, yeah. So I made what I did was I was trying to illustrate the point. So I made a simple ring buffer type, and it's probably broken by the standards of many people's ring buffer notions, whatever. But it requires a size because it needs to know how much storage to create, right? Now, me in an alternate universe would have made that size a uh template parameter, but I didn't want to for the sake of this example. I made it a runtime parameter. So it you must provide a size.

Jason TurnerIf you provide a size of zero, it's gonna allocate an array of zero internally, but it's still a valid pointer, valid storage, right? So, or actually I might have even put a contract on it saying that the size is greater than zero because I was just trying to illustrate a bunch of different points. But regardless, I have something that holds a pointer to a thing. Think like unique pointer, but think a unique pointer that cannot be constructed with a null pointer. Like that is an invalid use case, a unique pointer that must be constructed with a valid pointer. If you move out from this unique pointer, the thing that is left behind, the moved from object, is now in effectively an unusable state, like you're talking about.

Jason TurnerLike I can, well, unique pointer is a tough one, because you can still get back the null pointer that was in it. Anyhow, in the ring buffer thing that I illustrated, I now have a function, I now have an object where the only meaningful thing I can do is assign to it again, like you're talking about with an integer. Right. And so I said, you know what? I am, for the sake of the argument, so that we can talk about it, I'm gonna delete the move operations here and say, if moving always puts this thing in a state where it is not usable in any meaningful way, then it shouldn't be movable.

Jason TurnerAnd I just want people to think about that also, right? And I think that's I know, I think it's related to what your argument is.

BenFor sure. And this line of thinking leads us to uh, you know, destructive move, right? Which is if we had destructive move, I think your argument might change and say, well, it is movable because move destroys the old thing, right? Right. Yeah. But we don't. And but many, you know, a certain a workable mental model, certainly a workable mental model is that after you move something, you should only assign or destroy assign to it or destroy it, right? Yes. That that is that is where many people start. That is how many people think of things, that is certainly a workable mental model.

BenIt happens that in the minutiae of C, that is not quite correct because it after it's moved from, it still is a member of the class. Its invariants still hold. Functions that don't have preconditions may still be called. And there are details of implementing some containers and or algorithms perhaps which rely on some of those things.

Jason TurnerAnd there's no way to know if the object has ever been moved from. If you ever pass anyone an immutable reference to this thing, it's possible they moved it. Right? Yeah. Like you you you pass an L you pat you think you're passing an L-value reference to a function. Haha, joke's on you. Internally inside the function, they still called stdMove. They cast it to an R value reference, they moved out the thing, and when your function is returned to you, you have an object that has now been moved from.

Jason TurnerThere's no way to enforce it. Right. So, yes. Like the ideal, but we but but it's still C. The ideals are great, but we're programming it C. Yeah, I know.

ConorWell, as as I've been listening to this, you know, just hanging on for dear life. I've had this little voice in the back of my head while you know Jason and the second part of this conversation is talking about the multidimensional extension to that Howard Hinnan table, and I feel like uh my my brain is vibrating.

BenBy the way, I think that table certainly one of the early talks Howard gave with that table in it was a criminally underviewed talk, which I think I can dig up the links, and it was a talk at Bloomberg, it was an invited that Howard gave up.

ConorAlright, I will definitely I mean I have already, because I've been trying to at least, if not, find the links, get the you know, type the name down in the future. I have the article that meant and in the bottom of the image there is a hyperlink to the talk that that Howard Hinnant gave. I'm not sure if it's the exact same one. That's a problem with images, folks, though. You know, you can't click on the hyperlink in a in a JPEG or a PNG, or at least not yet, you know, maybe some future uh photo format.

Jason TurnerUh send it to Claude and ask it to uh extract that URL for you, and then you could click on it.

ConorMaybe. I'm not sure that's the best you've uh you could just type it into the browser. Uh or you could just search for Howard Hinanth. I was also gonna say, we have we haven't actually reviewed uh, you know, maybe so yeah, talk a little bit about the other talk and we could talk about the comfort. Yeah, but like CPPCon, I I know Betton, you were only there for Friday, but uh Jason, uh I imagine you were there for the whole week. I mean you can tell us true or false, and and maybe you saw some talks while you were there. Like I always when I was a listener before I was a podcaster, I always liked getting like highlights of oh, I should definitely go watch this talk instead of having to sift through all hundreds of them to find the best one.

ConorSo if you have any recommendations, if you don't, that's fine. But yeah, over to you. All 17.

Jason TurnerI'm gonna say unfortunately, I don't really have anything intelligent to tell you about CBPCon because I was absolutely wiped out. I flew from Europe, as many people do. But um, and then I taught the workshop on Saturday and Sunday, and then I actually had to fly to another client on Monday night, and I got back on Tuesday. Oh wow. So I missed like, yeah, I missed basically all of Monday and Tuesday, and then I had my own talks on Wednesday and Friday and a book signing on Thursday, and it was just like I I I wasn't really present.

BenWell, in that case, I'm gonna plug a couple of talks. One, one by Dave Stefan, who is a regular at Denver Meetup, and it's called uh Refactoring in Three Acts or something of that. A Tale of Three Acts. I think that's a good talk. That is actually on YouTube, unlisted at the moment. But the actually it seems like the early access talks are free for everyone. I have no idea. I'm not sure. And the other talk I'm gonna plug is of course my colleague Michael Case's talk. That was on the Friday, so I did see it.

BenAnd he was showing, and now I've forgotten the name of the talk, but Connor, no doubt you could dig it up. He was talking about the thesis, the abstract of his talk said, you know, doing basically doing doing firmware slash bare metal firmware with with contemporary C. Bringing bringing firmware into the the contemporary practices rather than staying in escaping 1996 was I think one of the phrases in the abstract.

ConorAlright, I will link to both of those and yeah. Be sure to check those out. Jason, do you want to h highlight any of your other talks you've given? And I should say I I promised my wife I would uh change a diaper in in it, so we have to uh time box the uh the question is how did you how did you time the child is what the real question I have here.

BenOh, I mean I imagine the diaper just needs to be changed and oh yeah. In the first month it's like a dozen times a day at least.

Jason TurnerYeah. You know, without I you know what I'm gonna do? I'm gonna instead plug Dave's talk, which I have not seen yet. Because I have realized with side conversations with Dave plus seeing many of his talks, he he usually previews them at our meetup that he and I are coalescing, perhaps is the right term, convertible converging on on like how one actually goes about writing code that's maintainable, I think.

Jason TurnerAnd and so I am sure Tave's talk is good, and if Ben plugs it, then it's definitely good. And uh yeah, like you'll almost certainly I'm guessing that the average person who watches it will be slightly annoyed and say, I can't do that in my code, but then it's gonna bother you for the rest of your life because you're gonna wonder if you can pull it off in your code.

BenYeah. You're probably you're making me think certainly of the function length idea.

Jason TurnerYes. Functional length. And so another talk, yeah, function length.

BenThe line length of functions, the number of lines in a function.

Jason TurnerYeah. So they definitely asks in that talk.

BenSorry, Karen.

Jason TurnerAnd he oh no, he has. Very small numbers, what people most people would could think can to be impossibly small.

BenAnd we should ask Connor. What do you think is the outside of APL? Let's say you're writing. Yeah, yeah. Yeah, right. What do you think is a how small is small? Is or what would you can the slight slightly more focused question is what length of function would you be wary about okaying in the code review? You know, if you saw a thousand line function in the code review, would that be too long? No, yeah. I mean that's way past the threshold. That would be okay. So if you saw a hundred line function, it depends.

ConorIt depends, but like I uh in general, depending on the level that you're at, I really think my favorite functions are like, you know, five to ten. Like the grokkability and understandability of it is just like obvious. As soon as you as soon as I'm scrolling on GitHub in your PR, and I I do the the side by side, I don't do the unified, so it's like however many lines that is, then I then I'm asking. I'm not saying it's bad. I'm just saying I'm now asking myself, right to be this long? Sometimes it does. I'm not saying that all functions that can't fit on a single screen are too long.

BenBut we've entered we've definitely entered the realm of this is outside the ordinary and deserves attention to justify itself. Yeah.

ConorBecause like some of the best code that I've seen, it's just it is like it's not even C it's like closure, and all of them are just these beautiful, little, concise, composed, you know, everything. It's it's you know what when you hear Stepanov or Sean Parent or or you, Ben, talk about like the composability of Albert, you can see that everything was so beautifully crafted to fit together that you only ever need to invoke, you know, five, six, seven things, and you just read it and it's like it's like reading poetry. It's it's so nice. And and you never are asking yourself, is this too long? Because it's obvious that it's not.

ConorIt's obvious that you know it's just really well written code. C plus plus, I I don't find stum you stumble into that as often.

Jason TurnerNo. The talk I gave at NDC Toronto the expression expression-based C. That's what it was. Thank you. That was directly.

ConorIt is as of a couple months ago.

Jason TurnerIt should be online now. That one is. I created that talk because of the mindworm from Dave from years ago. Alright. So that talk. Watch one of Dave's recent talks, then go watch that talk and and maybe you'll see where I was coming from.

BenAnd Dave has practiced this in a decent sized codebase, you know, like in his in his production codebase, he is he has deliberately uh ratcheted up in CI the requirements for function length or function shortness, you know. And he's gone down from, you know, turning it on first and setting it something arbitrary like 100 and fixing those and then bringing it down over time to 50, below 50. I think he stopped. He, you know, like all of these things, he stopped before perhaps his complete ideal, but he stopped in a pragmatic sense at like 35 or something like that.

Jason TurnerAnd I've had students from Dave's teams many times, and that seems to be a process that's working. And I will say, last my last chat with him, we seem to agree that the only time where you can assume that this rule would be broken is if something where it's just naturally expressed in more lines of code. Like for some reason you're decoding a protocol and you naturally have a switch with like 50 case statements. Like, and and there's just there's no logical way to split this in half, right? Then yeah.

BenAnd you don't, you know, if the compiler could optimize an array lookup into function pointer as well, then maybe you could bring it down, but sometimes performance the case that you can't.

Jason TurnerAnd but also readability of the code. Like sometimes it's it's just it just makes more sense, I think, often, but not always.

ConorAnyhow. I had this talk I was I had this talk that I wanted to give years ago and have never given it, and it was called format-driven development, which sounds kind of like something that a lot of people would disagree with, but it's really more of like a design talk in that like when I think about the that long case statements, like I'm really I'm praying that it's like case, colon, return, you know, single thing, and semicolon. And like it, it like drives me not insane, but just like there's something about and and I've I've gone on a little in other talks, like I've given other speakers a hard time when they don't like use a monospace font and they don't use like formatting like that because there's oh it's just slideware.

ConorAnd I'm like, you're making it harder for people to like use the pattern recognition engine that is in all of our brains, and and so like when you see a case statement like that, and then only one of the case statements breaks into multiple lines and it's in the middle, it's just like, oh, like throw that thing in a function so that like even if all of it's raw code and then you have one function so that you can keep that kind of linear style and aligned style. Anyways, that's that kind of stuff I think leads to it goes hand in hand with keeping your functions short. Because when you when you try to reduce indentation, when you try to you know keep things linear and symmetric, you just naturally end up with shorter because the easier things to keep symmetric and readable and like and parallel with each other are short functions.

ConorWhen you have a big glob, you end up like with things that aren't at the same abstraction level. And and yeah, so anyways, I think if I had made the talk, people would have been like, this is stupid. You shouldn't you shouldn't be driving the writing of your code based on form. Like literally, I've done PRs where like some line was too long, and then I just refactored the whole function just to make it look more it didn't do anything different. It was just like reformatting, but at the end of it, it looks so much you would you would imagine I did something amazing there, but really it was just uh functionality. And I think that is my wife pinging on what's uh asking me to go.

BenSo you have more important things to do than talk to us. You do. Yes, well absolutely arguably, I guess, yeah.

ConorYou do raising a baby is more important. Indeed. Yes, it is, it's more important. Uh but thank you so much, Jason, for taking the time uh across the pond at a different time zone and uh to Ben as well. I guess you're in a different time zone as well. Yeah, thanks, Jason. Yeah, absolutely. Hopefully, we'll bump all the three of us uh in a conference in the next three hundred and sixty five days. Yeah. At some point. Be sure to check these show notes either in your podcast app or at adspthepodcast.com for links to anything we mentioned in today's episode, as well as a link to a GitHub discussion where you can leave thoughts, comments, and questions.

ConorThanks for listening. We hope you enjoyed and have a great day. I am the anti price.

BenUm

Open the transcript file

Hosts and Guests

Guests

  • Jason Turner Guest Inferred

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. Episode 313: C++26 Reflection vs CRTP, AI, Kids & More with Zach Laine

    Nov 20, 202647 minAudio

    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:...

    • Apple Podcasts

    Credit the people on this episode

  2. Episode 312: The C++26 Contracts Fiasco

    Nov 13, 202652 minAudio

    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:...

    • Apple Podcasts

    Credit the people on this episode

  3. Episode 311: Career Changes, GPUs & More with Zach Laine

    Nov 6, 202628 minAudio

    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...

    • Apple Podcasts

    Credit the people on this episode

  4. Episode 310: Leaving NVIDIA for... ?

    Oct 30, 202624 minAudio

    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...

    • Apple Podcasts

    Credit the people on this episode

  5. Episode 308: Rule of N with Jason Turner

    Oct 16, 202621 minAudio

    In this episode, Conor and Ben chat with Jason Turner about his Rule of N talk. Link to Episode 308 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP: The Podcast: Twitter...

    • Apple Podcasts

    Credit the people on this episode