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 224: Flux Updates & Internal Iteration

Mar 7, 202529 minAudio

In this episode, Conor and Ben chat with Tristan Brindle about recent updates to Flux, internal iteration vs external iteration and more. Link to Episode 224 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 About the Guest Tristan Brindle a freelance programmer and trainer based in London, mostly focussing on C++. He is a member of the UK national body (BSI) and ISO WG21. Occasionally I can be found at C++ conferences. He is also a director of C++ London Uni, a not-for-profit organisation offering free beginner programming classes in London and online. He has a few fun projects on GitHub that you can find out about here. Show Notes Date Generated: 2025-02-17 Date Released: 2025-03-07 Flux Lightning Talk: Faster Filtering with Flux - Tristan Brindle - CppNorth 2023 Arrays, Fusion & CPUs vs GPUs.pdf Iteration Revisited: A Safer Iteration Model for C++ - Tristan Brindle - CppNorth 2023 ADSP Episode 126: Flux (and Flow) with Tristan Brindle Iterators and Ranges: Comparing C++ to D to Rust - Barry Revzin - [CppNow 2021] Keynote: Iterators and Ranges: Comparing C++ to D, Rust, and Others - Barry Revzin - CPPP 2021 Iteration Inside and Out - Bob Nystrom Blog Expanding the internal iteration API #99 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.

Trinstan BrindleUh effectively uh compilers can generate really, really, really good code. Optimizers just seem to absolutely love this uh this this style of doing things. That's it's kind of what I've what I've discovered is that this is this is just amazing for performance.

ConorWelcome to ADSP the podcast, episode 224, recorded on February 17th, 2025. My name is Connor, and today with my co-host Ben, we continue our conversation with Tristan Brindle. In today's episode, we chat about updates in Tristan's library flux, internal iteration versus external iteration, and more. And now we're starting episode 224, and and we so we haven't even talked about flux.

ConorUh so a part of the goal was to bring Tristan on because I mean it's been a while now, but back in August, I told this story twice on the podcast. Uh, we met up a couple times. Taylor Swift uh delayed us meeting up by an hour or so at one point because she was performing at Wembley. And uh I said at that point that we were gonna have you back on, get some updates about Flux, and then I had some follow-up questions about fully understanding the internal iteration model of Flux because I actually don't think I tweeted this.

ConorUm it is I I I I know it's public somewhere, and that somewhere is for sure in the PDF slide deck of the talk that I gave at C Under the C, which was called Fusion Arrays and CPU versus GPU, something like that. I just it was a bunch of things because I couldn't figure out a good title, so I just put some commas in between it. In there, it shows a highlight of uh rankings of a bunch of different quote unquote backends to this tool I wrote with three different Code Unquote libraries.

ConorFlux is one of them, range v3 is another one, and then the standard C20, 23 ranges, and then Swift's there, Rust is there, there's a few different GPU backends like uh Koopie, uh CUDA thrust, etc. There's a few others. And at least on the lower uh end of the sizes that I tested, so I think that was like a thousand elements and vectors up to a hundred thousand, uh flux, hands down one uh in every single one. So it beat ranges, it beat range v3, it beat Swift, it beat Rust.

ConorI mean, the other range's implementations were right behind Flux. Um but this echoes, I mean, you gave a lightning talk at I want to say C North 2024, um which was called filtering filtering fast with flux, something like that. Faster filtering with flux, I think it was, yeah. Faster filtering with flux. Where it was a five-minute uh lightning talk, link in the show notes, and you showed how this double d reference issue can get in the way of compilers optimizing code to what you could write with a hand-rolled folder loop.

ConorAnyways, I'm gonna throw it over to you. So I've got questions, but first give us an update for folks that haven't listened to episode 126 and 127, where I think it wasn't the last time you were on, but it was the last time you were on that we talked about um flux. Because I think you came on in between to do the one algorithm to rule them all episode at some point, I think.

Trinstan BrindleUh oh yeah, the we were supposed to I was supposed to argue with Ben and then we ended up agreeing about yes.

ConorSo, yeah, what's the state of flux? What are the updates and then and then we can get to the state of flux?

Trinstan BrindleThat's a great uh I should that's what I should call like the updates, right? The state of flux. Why didn't I think of that?

ConorI was gonna say, and also too, give a little like uh summary of just what the I mean I I've compared it to ranges already, so maybe people have uh an idea.

Trinstan BrindleBut in case they started listening since then and and this is the first time they're hearing about flux, maybe give them uh just a little background so that we're not gonna Okay, so Flux is uh a library for doing uh what we might call collection-oriented programming or sequence-oriented programming, right? So it's similar in spirit to things like uh C20 ranges, uh range v3, the Rust iterator library, the uh like Python iter tools, d ranges, uh all those sorts of things. Um so the idea is that you uh you have algorithms that operate on uh sequences, as we call them in in Flux, uh, and uh you can have sequence adapters that you can chain together to uh build up kind of a view of your data, and then uh call some algorithm that operates on that data.

Trinstan BrindleSo as I say, this is um pretty much every language I think uh you know you can do you can do this sort of thing. So flux is uh it's kind of an alternative to C20 ranges. The way it works is a little bit different because it doesn't use uh STL iterators. So standard ranges they're built on uh iterators that are effectively a generalization of pointers. Raw pointers are like the most general or sort of the most powerful kind of iterators, they're contiguous iterators.

Trinstan BrindleAnd the the STL takes these and uh and kind of generalizes backwards to kind of bidirectional iterators and forward iterators and eventually uh input iterators. That's uh you can only have single paths. Flux, rather than using pointers, takes the idea of indices and generalizes backwards from there. So uh slightly different approach, uh, but we end up being kind of uh we we can do the same things as you can do with ranges, just the way that you do them is slightly different.

Trinstan BrindleAnd the goal with this is because uh was originally anyway, that being pointer-based, indices uh sorry, iterators, STL iterators share the same downsides as pointers in that they can quite easily be invalidated, they can quite easily end up dangling, it's just not a very safe abstraction. Whereas with indices, or we the generalized version we call them cursors in flux, rather than like an iterator can advance itself, it can dereference itself, right?

Trinstan BrindleIt's uh whereas a cursor just purely represents a position in some sequence. And in order to advance the cursor, you have to have the sequence object available to say, please will you give me the next position after this? Or in order to uh retrieve the value corresponding to that position, you have to ask the sequence, please will you uh give me, you know, uh read the the cursor position and give me that value. Uh so it means that if you ever end up with a dangling cursor, you know, you're you're holding on to the cursor and the the sequence has has vanished, uh you you know it's perfectly safe because there is literally nothing you can do with this cursor because you know you you can't just try and dereference it like you would be able to with a with a dangling iterator.

Trinstan BrindleSo the initial goal of Flux, what I set out to do, was to you know do something that's pretty much the same as as ranges but uh less prone to um to to dangerous dangling things.

ConorI think actually that's one of the titles you get you gave, I think, the same talk uh a couple different times in 2023. Once at C ⁇ on C, once at C North, I think it's CPPCon, and I think the C on C one, it retitled the talk to a safer there's the safe is in the title, even though the actual title of the talk is Iteration Revisited. So you might see different titled talks, but they're they're all versions of the same one. And so Flux is a safer version, but as I mentioned before, it ends up performance-wise, uh beating ranges and range v3.

ConorAnd in the episode 126 discussion, we talked about these two different models of internal iteration and external iteration. And to this day, I don't think I've fully grasped what the difference is. And I actually, in preparation, because I went and re-watched that talk, I went and re-listened to the episode. I didn't re-watch Barry Revson's talk, which we'll also link. He's given it a couple times, where he compares the various models across uh programming languages, D, Swift, C, C sharp, Python, etc. But I now we live in the age of LLMs, and so I figured I'll go, they got these reasoning models.

ConorI'm not sure if this is O3 or O1 Mini on ChatGPT, but I went and I asked, I said, explain internal iteration as it exists in libraries like C Flux and also the issue of double dereference. And this is what it said. It reasoned for 18 seconds. That's a reasonable amount of time for me to wait. It says, in many traditional C designs, you iterate over containers or ranges using external iteration. That is, you write a loop that pulls values out via iterators. With internal iteration, on the other hand, you pass a function, often a lambda, to an algorithm, and the algorithm internally, in quotations, iterates over the data, applying your function to each element.

ConorThis means control. The library's algorithm controls the loop rather than the collar optimization. The library can optimize the iteration process, potentially fusing multiple operations together, a technique often called loop fusion and even parallelizing work and abstraction. Users work at a higher level of abstraction, you chain operations together without managing the low-level mechanics of looping. So before I throw this over to you, uh, and we'll ignore the double dereference exclamation answer that it gave us, my first thought when I hear this is, okay, I mean I agree with this loop fusion thing, but uh explaining it as like passing higher order functions to these operations and letting the algorithms manage the iteration, my first thought is like, that's what doesn't like ranges, you like the if I call a uh you know uh std colon/views transform versus a flux.map, uh, you're passing a lambda to both of those.

ConorSo like that that explanation of handing over this kind of callback that then enables the algorithms or the the adapters to control the iteration doesn't fully check out. I did ask a follow-up question that said, okay, so what does C ranges and range v3 use? And it did say this uses external iteration because you can use this with for loops. Where and then I asked, well, can you can you not use flux with for loops? And it says typically no, you can't. So, anyways, how much of that is right and wrong, and uh where it's wrong, please uh elaborate and correct.

Trinstan BrindleUh okay, okay, right. So um it is uh correct uh apart from the bit about flux, um not using external iteration. So flux, uh the cursor model that I described is a form of external uh iteration. So what we mean by that is that you have some uh or typically you have some sort of uh like external, some sort of object that represents your iteration state, and then you can uh as the as the caller you can request like the next value of the sequence.

Trinstan BrindleSo typically we will call this thing uh this state like an iterator, right? So um this is the way that it works uh in C. In in Flux, our iteration state is this cursor object, um, you know, Python. Uh almost all languages, in fact, you use these uh external uh, you know, this external iteration model. But as an optimization, and at the moment we might get into how I'm planning to change things, but at the moment it's purely an optimization in uh in flux, is that we can we can turn this around for certain algorithms and we can just as a uh as the uh uh as you described it, we can instead say to the sequence, okay, here is uh a function.

Trinstan BrindleI want you please to call this function for uh like every one of your elements. And it turns out that if by turning things inside out like that, instead of uh kind of uh requesting elements one at a time, by saying, here is a function, please will you do the iteration for me? Uh effectively uh compilers can generate really, really, really good code. Optimizers just seem to absolutely love this uh this this style of doing things.

Trinstan BrindleThat's it's kind of what I've what I've discovered is that this is this is just amazing for performance.

ConorSo wait, just to clarify, so you're saying actually that Flux doesn't use internal iteration? It's X.

Trinstan BrindleNo, no, it it does. It uses it as an optimization. So with so if you are if you're doing like a basic for each uh algorithm, uh it will attempt to if it can, it will attempt to use an internal iteration code path. Um if it can't do that, if one of your adapters or your source doesn't support internal iteration, it will use regular uh uh external iteration using uh using cursors.

ConorInteresting. So if it can, it internally iterates. If it can't, it externally iterates. That is the current situation. And and so how is that I mean, not that we want to get into implementation details, but like what does that look like from an implementation? Because I actually took a look at like the map adapter. But I I don't know. It's uh it's a lot of templates and std.invokes and stdforwards, and it's hard to make sense of like, you know, how how does it determine? Is it just basically like every single one of the adapters is tagged with like whether or not it can do this and it dispatches based on that or something?

Trinstan BrindleOr okay, so um imagine that uh the like the the there's a function called well, do you not have to imagine because there's a function called for each, right? Um and you can write the foreach algorithm, uh which is uh you know, in terms of the uh uh of cursors, you just say, okay, well give me a cursor to the start, like the star cursor, and while it's not equal to the end, I'm gonna read a value, I'm going to call the function, the the given function with that value, I'm gonna increment the cursor, and then eventually it's equal to the end position, and then we finish.

Trinstan BrindleOkay, so that's that is a like just just how we how we write the uh for each in terms of uh uh excellent iteration. However, you could also, and this is the way we do it, allow uh sequences to provide a specialization of the for each algorithm. So something like a vector uh or or uh a C range, uh you could just uh use a for loop, like like a like a language for loop, and within this loop you would uh call uh just call the function.

Trinstan BrindleAnd then you think about well, okay, what about a map adapter? Can we uh provide a specialization of for each uh on a map adapter? And the answer is yes we can. So what we do is uh we take the the mapping function and we apply that uh first so we get the adapted value, and then we pass the we pass that adapted value to the user called function. So we can compose uh mapping and filtering inside of this for each.

Trinstan BrindleAnd uh the way that this works, and it's quite hard to describe, um, it's much easier if you can sort of see it in in code, the way that these these lambdas all sort of nest inside each other, but they're all completely transparent to the compiler, and it can um you know uh just see right through them and and do an amazing job of optimization because we can specialise this for each function. Um, and that's that's sort of uh at the heart of of what we mean by internal iteration. And so, yeah, in terms of algorithms, pretty much anything that is uh a fold or a scan can end up using internal iteration.

Trinstan BrindleEverything anything that where you begin at the beginning of a sequence and run linearly uh until a certain point can almost always be written in terms of internal iteration. And that is the vast majority of things people tend to do uh with sequences. So it ends up uh like like I said, the goal with Flux really was um was to have something that was safer than the status quo, but it turns out that most people have noticed that it also because of this internal iteration uh optimization ends up generating uh really good code as well.

Trinstan BrindleSo yes.

BenSo is there this technique of providing specializations, is is there a reason this can't be applied to standard ranges?

Trinstan BrindleIt could be, right? So um in fact there was a proposal by uh Jonathan Mueller and Barry, I think Barry Resin, um I can't remember the paper number, we'll have to look it up. But they there was a proposal for uh exactly this this kind of of thing. So yeah, uh it didn't succeed because it it kind of uh I think it was probably a little bit too ambitious for uh initially, but uh it could in theory be applied to um to ranges as well.

ConorSo you're saying the reason it failed wasn't technical, it was just that it they were trying to land too much stuff at once.

Trinstan BrindleI uh it's a while since I since I read it, but uh yeah, I think they were kind of proposing to the changes to the way range for loops work and things like that, which was probably made people a bit nervous. I I yeah, I'm not really I I can't remember the not necessarily just touching library stuff, like touching language stuff as well.

ConorYeah, yeah. Interesting. Interesting. So there's nothing actually that yeah.

Trinstan BrindleYeah, in principle, uh we could uh have the uh the Ranger's algorithms um uh perform this optimization as well.

ConorYeah. I do know that they're I mean I don't really pay attention to it, but I I do know there's like a a year-long filter view saga happening right now where I see talks from people about uh the brokenness and uh yeah. I I don't I don't follow the committee papers closely anymore, but I do know at some point papers were being written. Uh so yeah, I don't really know what the status of of that stuff is.

BenUm Of course this kind of thing it's interesting you can say we can apply that to to standard ranges because this kind of thing always the question in the back of my mind whenever we talk about things like this is is the question of did did we standardize something too early? Right? Ranges got standardized with several implementations, but without this internal iteration design, it hadn't been discovered yet, maybe, or you know. And so the question to ask is like which doors have we closed by by standardizing as early as that?

BenWas it would it have been would it have been worth waiting? Do you have do you have thoughts on that?

Trinstan BrindleI mean uh people have have kind of said, well, you know, do would you propose flux for standardization? I was like, well no, because it's it's the overlap with ranges is too much. But on the other hand, range uh no flux wouldn't exist without um without without ranges, without kind of what I learned from from studying that. So it's like you can always wait for the next thing because I have changes I now want to make to flux, which which uh because I think I can do it better, and you can always there's always a way to do something better, right?

Trinstan BrindleThere's always a next thing. Uh so at some point you've got to go, well, let's just let's let's put this in there.

ConorSo well I mean I mean technically there's an argument that you don't have to. Like if we had a better story for package management, arguably it would have been range, range v2, range v3, then flux, you know, flux two, and then you can just reach for stuff easily, right? But the problem is that unless if you have your build system configured or worked for a company like you know, all the major companies have some solution for this, right? It's not as easy as going cargo install whatever for your for your library. Like these days, I think I've said this on this podcast, I just do the like fetch uh command and make scripts, and like I just, you know, every single time I have a new project, I copy my make file and I just pull from the latest whatever uh GitHub repo.

ConorUm I don't use any of the package repo like uh what are they um the frog frog has one, the frog company coming in. J JFrog. Yeah, JFrog, thank you. Um and then there's VC package. So like I don't use any of that stuff. I just I just point at GitHub repos, and luckily m almost all of the libraries that I want to use.

Trinstan BrindleUh f uh has recent versions of CMake have this fetch content, which I found to be pretty good for just like I use uh CPM, which is a wrapper around fetch content.

ConorIt's entirely business. Someone told me about that recently and said I should switch switch to CPM. But the thing is once you have something that works and all you have to do is change a GitHub URL. Yeah.

BenYeah. Well you should switch to CPM because it's a wrapper around fetch content, because it works the same way, it's just a better API. It's just easier. It has all the things you like, I think, is what I'm saying.

ConorNext time we record, I will I will report back. Although I don't even know if there's any C projects that I actively am working on. Mostly these days I'm in Python land. Um But yeah, I mean so anyways, back to the uh you know, at some point you have to put it in uh uh to the standard. Uh arguably, you know. Well, yeah yeah, exactly. Do you?

BenYeah, if if we had a better story for it. Um and this is very much like there's lots of things going into the standard, and people have different opinions about whether they should maybe. Like like the poster child for this maybe is is formatting, right? Most of the people I talk to are probably sticking with libfmt. Even though std format exists. Um libfmt is is better featured and uh it's what they were already using. And uh you would probably you know, therefore they therefore they want to stick with it and they wanna and and and it's still it's still being developed, still being maintained, and it's it's very stable and nice.

BenNow the counter is the counter argument of course that always gets brought up is well, what about the regulated industries that where where regulation is a big deal and they can regulate against the standard but but regulating against third party is is a big deal, right? Expensive or whatever. So I don't know what the answer there is. But but I d what I do know is that almost everyone I talked to wants to use slibfmt rather than std format. Interesting.

Trinstan BrindleI think in the in the particular example of format like that is important enough like we we should be able to have a good way of just printing stuff out that comes with the language. That particular example I think yeah that's something that's reasonable for the standard library. However there are other things that uh linear algebra being a recent example that I I'm not sure for me personally whether I think that's a good senders receivers library is one for me.

BenLike I've implemented senders receivers a a version of them. I don't know if what's being standardized will will fit all my use cases. I I I hope it will. I believe that the people working on it want it to but I think with the best will in the world it might take another decade before it supports all the use cases required. Right? So in the case of libfmt I agree that we should have good ways to standardly format things.

BenThe the extra benefit that LibfMT provides for me is largely in the constexpr space. And and this is something where the standard continually disappoints me. We still standardize things without making them properly constexpr. Yeah um I don't to the point where I don't I I think that might be a a tactic now. Like like that that is just a process right first we standardize something then we make it constexpr in some cases maybe not in other cases but it's it's it's almost always disappointing when you come up against something that that you want to use at compile time and to all intents and purposes it should be usable at compile time and the only reason it isn't is that it was not standardized with that constexpr keyword in front.

BenIt still happens.

ConorYeah. Speaking of the time that the committee spends on stuff that arguably I would prefer if they just had like a good package management story. Then I feel like at least 50% of the stuff the committee spends time on trying to get into the standard where you just be like up you know modulo the regulatory you know companies that have to deal with that stuff. But uh and then if you took all that extra time and put it towards like language uh some types like a nice tuple a nice language variant and pattern matching like that is that was actually a question I was going to ask you I uh Tristan I I asked uh Phil Nash this at C under the C.

ConorI said there was a project that I wanted to build uh that for reasons um would have been easier to do in C and I said I want to use flux but like it's just so hard for me coming from languages now that all have really nice you know algebra algebraic data types and sun types and pattern matching to like come back to like library variant land and you know is alternative it's just it's so cumbersome and I said what's your suggestion if I want like that experience in C you know you're you're uh someone who's been doing this for a while and his answer was use Swift.

ConorSo what is there uh I guess I can open this up to you Ben like is there what is the best experience in C if I want to do some kind of functional programming esque so either reaching for ranges or range v3 or flux. But then I I I want I want the the sum type pattern matching that almost all languages these days have.

BenYou're asking me?

ConorI'm not sure I'm the best person to ask I I think Circle has a pattern match I did actually consider uh going to Circle and then programming in like a C variant that has you know uses choice types and uses pattern matching but then like you're not programming in a you're programming in not just like a dialect but I would almost argue like a a different language at that point, right?

Trinstan BrindleBecause you can't then go to a GCC or Clang and it's it's not going to work right yeah I I think I mean that there's been a a a pattern matching proposal um that's been in in flight for a long time for yeah Michael Park. But I think it's just going to miss the boat.

ConorYeah for C is breaking news C 26 looking like it won't. We don't know for sure. I mean the dust or it has the dust settled? I think the last meeting was the It's supposed to be feature complete.

Trinstan BrindleIt's just the reason I'm I'm wavering is because I can't remember off the top of my head whether I'm pretty sure let me just see if I can find the um yeah I I think in the last week meeting um it looks like pattern matching is going to miss 26.

ConorAnd I honestly too like even pattern matching it would make it nicer but really you need you need the language support in my opinion to really get the full first class experience. I mean I was talking I was talking to Sean Baxter the other day about you know he was asking me if I you know if there was some new language on the block, what are the things that you would want to support array programming and I said forget array programming I just need because he said it it needs to be like a C like language. And I was like I need some types and pattern matching he's like oh circle already has that so you know choose another feature and I was like well C doesn't have it so um sorry Tristan you were going to say something.

Trinstan BrindleI was just gonna say I I found that there's a thing here said pattern matching does did not get consensus but was extremely close. Tendees felt that it wasn't quite ready for C26.

ConorInteresting. I wonder what that means like with more details it was extremely close but didn't make it in um in terms of like just people didn't agree on the design. Oh well I mean it is coming at some point.

BenI don't know if it's the I don't know if we can say it's the design at this point, but something. I don't know I wasn't at the meeting.

ConorYeah this is why you this is why uh you to be in the inner circle you gotta be at the meetings in order to I mean I'm sure uh I guess CPPcast hasn't come out with an episode in a while but um usually Phil and Timur they they'll have someone on to talk about the the committee meeting.

Trinstan BrindleUm I think uh Timo's been so busy with the contract stuff because he's uh you know that that that's his his thing so uh he's probably been been too busy being part of the action to like do the podcast about the action if you see what I mean.

ConorBe sure to check these show notes either in your podcast app or at adspthepodcast dot 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 brace

Open the transcript file

Hosts and Guests

Guests

  • Tristan Brindle 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 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