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 235: C++26 Senders and Receivers Algorithms (Part 1)

May 23, 202533 minAudio

In this episode, Conor and Ben chat about algorithms / combinators in C++26 Senders and Receivers. Link to Episode 235 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP: The Podcast: Twitter Conor Hoekstra: Twitter | BlueSky | Mastodon Ben Deane: Twitter | BlueSky Show Notes Date Generated: 2025-05-13 Date Released: 2025-05-23 C++26 Senders and Receivers The Evolution of Functional Programming in C++ - Abel Sen - C++Online 2024 C++23 std::flat_map CppNorth 2023: Composition Intuition - Conor Hoekstra C++Now 2023: Applicative: the Forgotten Functional Pattern - Ben Deane C++Now 2019: Ben Deane “Identifying Monoids: Exploiting Compositional Structure in Code” C++ std::optional::and_then Haskell join 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.

ConorUh oh. So are we saying that in our different monadic verticals in C we are choosing different names for these?

BenYes.

ConorOh no. Yes. Is that something we should be sad about? Maybe. Maybe. Is that is that pun intended? Oh, I see. No, no, it wasn't. And then they also have and then, so it's not then and and then.

BenNo, it's transform and and then.

ConorOh my goodness. So you wait, wait, wait, wait, wait, wait. I mean, I asked if we should be upset. The answer is, folks, we should be very upset.

BenVisibly losing his cool.

ConorIf we're ADSP the podcast, episode 235, recorded on May 13th, 2025. My name is Connor, and today with my co-host Ben, we continue our conversation from a few episodes ago about senders and receivers. Today we focus on algorithms. Which makes this episode 235.

ConorAnd I think we are going to, unless if while we were having that last conversation, we want to um start a new undiscussed topic, we're going to revisit uh our last conversation about senders and receivers, which uh yeah, we had a lot of great uh feedback on. People seem to enjoy the topic and Ben's explanation. And we had said at the tail end of um that conversation that we were only scratching the surface and that there's a whole world of algorithms that live on top of this model, and so we would we would revisit it when we chatted sometime in the future, and that time I think has come now.

ConorSo where should we start? Should we just pick off right where we left off, or is there anything you want to uh say before we now there's nothing I want to preface with, so let's uh let's dive back in.

BenI will I will accept your praise for the explanation before, although I can't really remember what happened. Um and let's talk more.

ConorWell, it's uh I mean I enjoyed the conversation, but the praise I was referring to, it came from I believe uh I mean technically I I I do feel like we should do this more. Maybe we'll we'll actually look it up right now in real time, folks. I mean, I can't go to Twitter because I mean I could go to Twitter, but I'm not gonna spend time on Twitter. Actually, it would, I was gonna say because it would take time to hop around. Um, but that's not even true necessarily because you can just go to the episode and people comment. Um but if we go to the GitHub discussion, or actually maybe this wasn't uh praise necessarily.

ConorUh Paul, who is uh attendee of the virtual meetup that I run, says this is uh his feedback. Uh at CPP Online 2024, there was the evolution of functional programming in C by Abel Sen, hopefully I'm pronouncing that correctly, and two talks on coroutines and a talk on flat map that I first became confused and then disappointed to find that this is only talking about a new dictionary made from two vectors. Uh working out some good way into category theory for programmers that bind equals F map, then join was a great learning moment in my life.

ConorSo, yes, less praise and uh more of a comment that uh he was confused on the overloading of uh flat map, which we probably should have mentioned because I think we are both aware of the um the data structure.

BenWell, and this uh the perennial problem here is like what what to call the monadic characteristic operation. It's Haskell calls it bind. Some languages call it uh concat concat map also I think is in Haskell. You know, that's more specialized for for the listmonad, I think. Yeah. C doesn't have a good term. And then is used, but to my mind, I don't I don't I don't think and and then is not a natural term for me.

ConorSo I had seen in the proposal pipeline at some point too that I think transform join? Because that like we use transform for map. Yeah, that would make sense, I suppose. Yeah. And flat flat map, did that end up actually getting standardized? I don't I can't recall.

BenIt's flat the data structure? Yes.

ConorYeah. Is that and is that C plus plus 23, 26?

BenUh now you are asking. I think it's 26, but I I wouldn't bet on it. Yeah. Uh oh. No, it might be 23. Yeah, no, I think it's Yes, it's 23.

ConorOkay, C23. That got flat map. And I am now buzzing around Twitter. I went to the ADSP the podcast Twitter, and that had some reposts, but no comments, and now I'm trying to find my repost of the ADSP Twitter, and we have almost found it. And there's also retweets here. I can't find the comments, folks, but I definitely know. I feel like Steve Downey just mentioned on the last episode.

ConorUh I think he had a comment about it. Um where these happened, I don't know. Oh, you know what? That's the problem. Is it's bifurcated. It was definitely on Blue Sky or Mastodon.

BenOh.

ConorAnd I'm just conflating where commentary happened because um uh they're all, you know, in my head, I see a comment and I'm like, oh, it just happened on one of the social quote-unquote tweeting platforms.

BenAnyways, uh Well, okay, so so back to senders and receivers, the the interface and the algorithms.

ConorUm yes, algorithms. We didn't really talk much about the world of algorithms that live on top of senders and receivers. So maybe that's a good point to pick back up from.

BenYou know, it's interesting. I don't uh Eric refers to them as algorithms. I don't really they don't occupy the same space in my head as like the standard iterator algorithms do um for me. But but sure they're algorithms.

ConorUm what do you refer because and this is actually maybe we can take a step back, is I have in a couple of talks described my algorithm mental model uh where I ref I think of the C11 iterator algorithms, the C17 uh parallel iterator algorithms, the C20 range overloads of those algorithms, and then also the C20 and 23 and soon 26 uh views as also algorithms, even though technically in the standard they they are not referred to as algorithms, but all of those I think of as, you know, technically there is a transform in four different flavors the iterator, the parallel, the range overload, and uh the the view.

ConorUm and I kind of think of those as all as the same thing. Do you have the same mental model?

BenI would say yes. I think of those in the same category. For some reason I don't think of senders and receivers in the same category, but maybe I should. They are, you know, instead of doing synchronous function calls, they're doing asynchronous function calls, and their the algorithms are the same. But I think because I think because I came from already knowing Haskell, already mapping the concepts to monads and functional uh constructs, I d I tend to think of them that way.

ConorSo is when you think of the label on the bucket that these sit in, is it is it constructs? Is it operations? Do you have a word like algorithms that you use for them, or not really?

BenWell, you're not probably going to like this one, but I would mostly say combinators. Combinators.

ConorInteresting.

BenBecause most of them are working on their higher order functions, right? They're they're higher order asynchronous functions. They're they're composing together functions. And so I I use combinator as a generic term for anything that does that. Like a parser combinator would be another example that I would use. But in this case it's just a sender combinator. A higher order function that composes together more than one sender and gives you back a sender.

BenI would call it in general, I would call that a combinator.

ConorOkay, so now I have a couple questions and we'll we will do our best, folks, to keep this on topic about senders and receivers. Do algorithms qualify and when I say algorithms I mean the C algorithms we just spoke about, qualify as combinators as well?

BenProbably some do. But honestly, if we take any analogy too far, it starts to break down. I'm sure we could yes. I think the answer is yes. We could construct a valid mental model where yes, we could say they're all combinators under some definition. Um but ultimately this is just I don't know that it matters too much having different mental models.

ConorIt's just your mental model. It's a your labeling uh and and for the the listeners that have not memorized my composition intuition talks, combinators uh definitionally are functions that I'm not even sure if you're supposed to use the word functions, but we'll use the word function, functions that rely only on their inputs. Meaning that if you've got a function like, you know, my favorite example is a forex conversion rate that converts Canadian to US dollars and it hard codes, you know, some kind of currency rate in there.

ConorIf it if it you're hard coding a constant that isn't taken in as an argument, that's not a combinator. Um and so in Haskell, a lot of times they refer to reduces and scans as combinators because they're just higher order functions. Even the ones that take initial values, um, because there's your fold L and fold L1s, um, those are still technically all combinators, and it's one of my least, I mean it's not just combinators. It's we just talked about flat map. Overloading of these terms is pervasive in computer science.

BenWell, having said that, I think that most of the most of the things in the senders and receivers bucket do fit that category. Like, you know, so so well, so let's just talk about them. So so in in terms of the monadic operations, you know, um there's just just is lifting a value into sender's world. You you give it a value, and and it gives you back a sender which will produce that value. So that's the same as pure or return, is what Haskell would call it.

ConorOkay, yeah, that makes sense. And uh and I should uh interrupt to ask here because I in editing the last senders and receivers discussion, I was upset that I didn't ask this question at the time, maybe because I just didn't um I didn't think to ask it, but when you were saying monadic bind, and right now you said monadic operations, are you are you um using the word monadic to you to mean single argument, or are you using it to mean the second.

BenYes, I'm using the functional construct. I'm not using it in the uh array language sense of monadic, dyadic functions.

ConorWhich is probably only my problem because array languages use it to mean monadic and dyadic, one argument, two argument. But I remember s hearing monadic bind, and I wasn't thinking monadic from like has to monadic. Okay. I was I was thinking, yeah. So to be clear, when Ben or I for this episode use the word monad or monadic, we're referring to you know monads as uh category theory.

BenAnd and more than that, you know, again, through through for want of terminology, I sometimes when I say monadic, I'm actually including the functor, I'm including a functor, I'm including applicative functors, I'm including monads all under that same umbrella. Right. And in terms of, you know, the the so just is is is pure return or lifting a value into the into the sender's world. Then is the characteristic function of a functor.

BenSo it's fmap. Right? It's the same as transform on a vector, in the that would be in the listmonad. It's the same as transform on optional, that would be in the maybe monad. On senders it's called then. So you want to apply a function to something in the sender, change it in some way, you know, you use just to lift a value, and then you use then to change that value.

ConorRight. I think and I think that is one of the easier it might even be easier than just for some folks, because transform is something you use on a everyday basis, even if you don't get the idea of kind of putting the parentheses, or I shouldn't say parentheses, the brackets for you know the list monad or however you represent an option for a maybe monad. You're used to applying some kind of operation on a sequence or an optional or something like that. It makes intuitive sense, I I think.

ConorI you know the listener can send us feedback if it's not the case.

BenAnd then the next, so so then, if if if then is fmat, which is the characteristic function on a functor, then um uh letValue is bind, which is the characteristic function on a monad.

ConorRight?

BenAnd senders calls that let value. So so in if we think about std optional, std optional has transform and it has and then, right? And the difference between them, really the only difference between them from the outside is that you pass you pass a transform a sort of regular function, so a function that will return a value. You pass and then a function that will return an optional, right? So a a monadic value, because we're in the in the maybe monad in the optional monad.

BenRight. And so and then on optional is monadic bind. When in senders, let value is monadic bind. Right? So you pass again, you pass it not a function that returns a regular value, but a function that returns a sender.

ConorRight. And and then corresponds to flat map?

BenSo flat map is is is bind is what bind is sometimes called in the list monad, yes. Only in the list monad.

ConorPretty much, yeah. I see. I see. So and then equals bind equals flat map in specific contexts, aka the list monad. Right.

BenEquals let value in senders, which is the continuation monad.

ConorAnd so I guess what's is there a concrete example like if you've got an optional int, you know, if you're trying to do a plus operation, you know, you don't need to use bind or and then for this. You just use then. You just use transform, yeah. It's called transform and optional.

BenYeah, sorry, we have to navigate the.

ConorWell, I mean that's the problem, right? You know, it's every it's not it's it's not constrained just to the nomadic monadic inf interface world, you know, across array languages, they rename everything. Everything's got six different names, and it's just part part of the journey. Uh but if you're trying to do something, and I think you used this example last time, was like square root, you know. Um that's not something that is, you know, and ignoring kind of overflowing issues that I'm sure a certain couple listeners are being, well, if you're at the max int and you do a plus one, you know, it's not gonna ignoring that kind of stuff. Um, you know, square rooting when you have a negative is gonna potentially be something that you don't want to define.

ConorIt's a partial function, yeah. Exactly. And so in that case, you know, plus one is just int to int, whereas square root is gonna be int to optional int. And if you start with an optional int, you will end up with an optional int when you use bind. And so I guess what I guess you can't use, yeah, uh in a strongly typed language where your function signatures have to match, you can't use a square root function that goes into optional int with then. You'd have to use and then.

BenYeah. Yeah. So yeah, well, like and like we said, and so bind uh prevents you from getting the doubly wrapped thing. Right. Because it's fmap followed by join.

ConorRight. So we have let's so let's do the verticals. We have we have we've got pure slash return, uh fmap and bind. And then we've got in Cender land, just then and and then. And and let value. And let value.

BenYeah. And then doesn't exist in sender's land. And then is in optionals land. Uh-oh.

ConorSo are we saying that in our different monadic verticals in C we are choosing different names for these?

BenYes.

ConorOh no. Yes. Is that something we should be sad about? Maybe. Maybe. Is that is that pun intended?

BenOh, no, it wasn't. It actually, this was a topic of conversation at C now, and and some folks were doing something. Steve Downey included, they were doing some work to try and map, to try and produce the table for each, where where down the down down the sides of the table you have the different monads. You know, so optional is one, expected is another, vector is another, senders is another. Um, and across the top of the table you have the operations.

BenSo just, uh fmap, bind, etc. A Google translate for monadic uh combinators. So anyway, we can be a little bit sad about that. But yes, in senders we have just, we have uh then, we have let value. Now, the other thing that bind does, let value, what it's really for is a runtime choice, right? Because um you can choose based on the arguments that get passed to your function, you can choose what kind of sender to run next.

BenAnd that that's embodying this idea of there's a choice at runtime. If I get a certain value, I might want to do one thing, if I get another value, I might want to do something else. And that is that's a fundamental power of monads. Right? That that choice. That's that's if you like, that's what monads bring to the table above and beyond functors.

ConorIs let value is is there I don't know. I guess my my reaction to this is that it's I mean not that bind is necessarily a a better name, um, but let value, I don't know, it does not uh elicit any kind of intuitive um for like what it does, as you just described. Uh does it does it come from somewhere?

BenLike a I don't know. If it does, I don't know the origin. As far as I know, it's made up for senders. There's there's let value, let error, and let stopped to deal with the three different channels, I should say. I've just mentioned let value up till now because that's the happy path. Right. But because receivers have these three different channels, because senders have these three different channels, then you have a let over each one of them. And let value is of course the most interesting because in some sense that's what's that's embodying the thing you actually wanted to do, that's where you wanted the choice.

BenThe others exist to handle errors and cancellation, obviously, so. Right.

ConorOkay. I mean while I'm keeping up, hopefully the listener is as well. Um do you have feelings or thoughts about the names of these, or it's just it is what it is?

BenIn the documentation I uh I I wrote some for my in the documentation for my implementation, I wrote something like if you think these aren't good names, don't at me. You know, take it up with the Stands Committee. I'm just interested in not introducing yet another source of confusion by changing names.

ConorSo yet another source of confusion. What is that, YASOC as an acronym? Uh right. You should put that, yeah. Avoiding YASOC.

BenUh yeah. So interestingly, senders adds there is there is one more thing in the set in the sort of functional hierarchy of constructs that that doesn't really exist yet in other monads in C ⁇ , but we send us adds, and that is the characteristic function on applicative functors. Right? So that the the hierarchy in Haskell sort of goes functor, applicative functor, monad. Every monad is an applicative functor, every applicative functor is a functor, right?

BenBut in C we tend not to we've got we've got functors, we're happy thinking about those. We've got monads, we're happy thinking about those. We don't have a reification, an idea that's well formed in C of what's an example of an applicative functor. Um and so we also don't tend to use uh apply. Again, another terminology clash, but uh apply is the name given to the characteristic function on applicative.

BenUm but in senders we have when all. And when all is actually that characteristic function. It's it's the apply function.

ConorAnd is there a concrete extension? Is there an extension to our concrete example of optional ints with uh plus one for our map and a square root for our uh let value? What would apply be?

BenWell, apply would be like transform except a variadic transform that worked over multiple optional values. One of the problems we have is that we keep on defining member functions, and member functions are by their nature sort of unary because they have one object that they work on. But applicative, if we wanted it, if we wanted apply on optionals, we'd have to make a version of transform that worked across a variatic pack of optionals.

BenAnd I showed that in my talk last year, was it?

ConorYes.

BenWhere I talked about the forgotten functional pattern, applicative. Yeah.

ConorI I have two thoughts in my head. One is that I watched that talk and I feel like I'm just learning something for the first time here, so I clearly didn't grok what was in your talk. Although I do recall it was that in identifying monoids. Although I definitely will say the identifying monoids one was easier to grasp for me than the uh applicative talk. So that my first thought is that, okay, clearly I didn't understand I need to go re-watch that talk because I didn't understand it, uh, although I'm talking to you now, so maybe I won't have to re-watch it just via this conversation. My second thought is you said that um all monads are applicative functors, uh and all applicative functors are functors.

ConorSo I mean the applicative all applicative functors or functors make sense, does that mean that all monads are variatic by definition? Because in this way. If the differating if the um the differentiating feature between a functor and an applicative functor is that applicative functors are variatic and all monads are applicative functors, if my understanding is correct in my head, it seems that the logical conclusion is that all monads have to be variatic.

BenYeah, I would say so one way the natural way to sort of spell the function or structure of the function in C is to make it variatic. But if you look at Haskell, Haskell doesn't do that because Haskell doesn't have variadic functions. What Haskell has is partial application. So in Haskell, an N-ary function is really n-nested unary functions, right? So Haskell's able to sort of strip argument by argument, strip them off or bind them, and end up and and shrink down the the arity of the function that way.

BenRight. We we probably wouldn't do that in C, we would just make a variadic function. Um but they are equivalent. In in my talk I got asked the question, are these things actually equivalent? And I I wasn't able to give a good answer in the talk, but since then, in fact very soon after the talk, uh, I think David Sankel asked me that question, we satisfied ourselves that yes, they were, and the way you do that is you implement one in terms of the other both ways round, and it's perfectly possible.

ConorI see. Okay. I think this makes sense. And so that means now we are at we're at in the two verticals where I guess there's three. Although you're saying that this when all slash apply uh does not exist in the optional and other monadic verticals.

BenAs far as I know, it doesn't exist in any other of the monads we might point to in C.

ConorSo it's it's in Haskelland, pure slash return, fmap, bind, apply. And senders, it's just then, let value, and when all. And then an optional, and we'll forget the rest, even though it sounds like there's a table out there that Steve Downey and Friends constructed. It is um Oh actually, I guess we didn't cover the uh the pure returnal test. Just the constructor. Yeah.

ConorAnd then then transform. Or transform.

BenIt's called transform and optional, yeah.

ConorAnd then they also have and then, so it's not then and and then. No, it's transform and and then. Oh my goodness. So you wait, wait, wait, wait, wait, wait. I mean, I asked if we should be upset. The answer is, folks, we should be very upset.

BenSo now if we if visibly losing is cool.

ConorIf we if we ignore Haskelland for a second, just stick with C, folks. If you can visualize this table, we're gonna go left to right through each row. So it goes it goes just optional constructor. That's fine. Then we have then transform. And then on the next line we have let value and then. Yeah. Oh my goodness.

BenWhat are we uh Yeah, we put then into both columns now, in some form.

ConorAnd it seems like it would have made a lot of sense if there was a then that could have been called then and the next one was and then. I I don't know. Maybe they were trying to disambiguate so that you don't reach for and then when you want then. But oh boy, oh boy, oh boy. Yeah. Anyway, it's it is what it is.

BenAlright, we won't get upset about the naming. So let's draw a line under the functional stuff and and and and talk get back to talking, I think, more about like let's think of senders as just asynchronous operations again. Because that might be a bit easier.

ConorOkay, yeah. I mean that's the problem, is you're a ha you're a big fan of Haskell. I'm a big fan of Haskell, so yeah. As as soon as we start talking about this stuff, uh we're happy to stay in that land. But yes, ignore Haskell from now on and we're we're back to C ⁇ .

BenUh for for folks who are not okay with all of that, or it it it might and and indeed for us sometimes it's easier to think about these things as working on just just the the asynchronous functions. So when all when all's a good example. Like you can think like for all for all that you can put when all in that box of applicative, if that's lot not intuitive to you, you can equally think about it like when all it is what it sounds like it it you give it a bunch of senders, it gives you back a sender that completes when all of those senders have completed.

BenUm it's waiting for all of them and then moving on. You know, in that in that sense, its name is perfect.

ConorI mean that description totally makes sense. And um that's good. But when I try to uh map that back to the fact that if we stay in sender's land with uh then and let value, each of those take a lambda, we'll say. They can take other things, but they take lambdas. When all does when all doesn't take a lambda, it just takes senders.

BenIt takes senders, yeah. So imagine you have two separate computations going on, and you want to say I'm done when they're both finished. That's when all.

ConorYeah, okay. I mean like I said, it make when all makes sense as its behavior, but I guess yeah, we're we're trying to avoid the functional talk. But my brain is trying to map the you know, technically the hierarchy of, you know. Sure, sure. You know what I'm trying to say. We'll move on. The point being is that we're we're exploring uh alternative explanation staying just in C land. Um but yeah, that makes it makes a lot of sense um if we just think about it from that. When all takes senders as arguments, waits to for completion, and then and let value take operations that have slightly different signatures, but do the same sort of thing.

BenSo those four operations, just, then, let value, and when all, they give you a really nice set of basis functions that you can use to do a ton of things. Right? A ton of things. Most computations are expressible with just those things, in fact, I would say. But, you know, uh and in some sense at this point we move we move off script as far as standardization towards what the future holds. So more algorithms that aren't necessarily proposed for standardization yet.

BenThe existence of when all implies the existence of when any, for example. Right. Right, which you can think of instead of being the AND operation, it's the OR operation. Right.

ConorSimilar to any of and all of in C.

BenAnd and to, you know, to to bring it back, to just touch back to functional, when when any and when all, they're like, you know, they're like or and and. Um when any it forms a monoid over senders. Right? With the unit of the monoid would be the sender that never completes. When any, if when all is waiting for all senders to complete that you give it, when any is racing senders against each other. Right. Yes. And as soon as any one of them completes, you're done, and the others get cancelled.

ConorYeah. You can think of this as the same way as when you implement uh any of or all of with uh std accumulate, although short circuiting aside, which is important, you you pass it the std logical and std.logical or, but then the identity operations are true and false for their corresponding partners.

BenUm in terms of practical application, when any is is pretty important because you can model you can model races, right? I mean safe races, obviously, but you can you can race one computation against another. You can cancel something when it's been overcome by events. Um you know one one sort of simple idea here is um imagine you've got a UI and the user sets off some some long-running operation with a progress bar, and there's a cancel button, right?

BenEffectively, what how you can model that is you're racing the completion of the operation with the completion of the user hitting cancel. Right? The user pressing cancel is one sender, and the other sender is the operation that's completing asynchronously, and you're racing those against each other.

ConorRight, right. That's one example of many. Yeah, yeah, that's one example of many. Be sure to check these show notes either in your podcast app or at adsphepodcast.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. Thanks for listening. We hope you enjoyed and have a great day. I am the anti Bryce. Um

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

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 309: Default Construction & CppCon 2026 with Jason Turner

    Oct 23, 202629 minAudio

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

    • Apple Podcasts

    Credit the people on this episode