In this episode, Conor and Bryce chat with Jared Hoberock about the NVIDIA Thrust Parallel Algorithms Library. Link to Episode 237 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP: The Podcast: Twitter Conor Hoekstra: Twitter | BlueSky | Mastodon Bryce Adelstein Lelbach: Twitter About the Guest Jared Hoberock joined NVIDIA Research in October 2008. His interests include parallel programming models and physically-based rendering. Jared is the co-creator of Thrust, a high performance parallel algorithms library. While at NVIDIA, Jared has contributed to the DirectX graphics driver, Gelato, a final frame film renderer, and OptiX, a high-performance, programmable ray tracing engine. Jared received a Ph.D in computer science from the University of Illinois at Urbana-Champaign. He is a two-time recipient of the NVIDIA Graduate Research Fellowship. Show Notes Date Generated: 2025-05-21 Date Released: 2025-06-06 Thrust Thrust Docs C++98 std::transform thrust::reduce MPI_reduce NVIDIA MatX CuPy RAPIDS.ai Thrust Summed Area Table Example ADSP Episode 213: NumPy & Summed-Area Tables 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.
Jared HoberockWhat did exist were the uh the old SGI uh documentation for uh the original STL. And at some point we came across that, and I didn't know what a reduction was at the time. So anytime I would come across those those documents about the the SGI STL, I thought it was just you know gibberish. I didn't know what they were talking about. I didn't know what an iterator was or a functor was, but I knew that like std vector was helpful, and I just sort of assumed that this other stuff to the side was kind of for nerds or something.
Jared HoberockBut eventually I learned what std transform did and realized, oh, that's exactly what that's the kind of thing that we need to do this this GPU parallelism stuff. And at that point, you know, I sort of had sort of had to get good with uh STL and figure all that stuff out. And it turns out that stuff is actually pretty useful and well designed, at least for the time.
ConorWelcome to 80 SP the Podcast, episode 237, recorded on May 21st, 2025. My name is Connor, and today with my co-host Bryce, we chat with Jared Hobarok, original author of the NVIDIA thrust parallel algorithms library. This is part one of a most likely four or five part series. And you you look like you're at like the edge of a national park with some I don't I don't actually know what your situation is, but it looks like a good situation.
ConorLike you've got windows behind your shelves and a window on the side. Walk us through uh maybe don't dox yourself if you don't want to, but uh it it I when Bryce said that I was also thinking, this is uh this is a setup that looks better than most CEOs in a keynote talk.
Jared HoberockWell, it's a Nvidia's salary goes a lot farther in Kansas City than it does in Silicon Valley, as it turns out.
BryceThat is true. Jared, do you live like out in the woods or like how how like rural is where you are?
Jared HoberockNo, I live in a I live in a suburb. Uh there's just, you know, a lot of greenery. So there's trees and there's trees and lawns.
BryceI do not have I do not have greenery.
ConorDo you have neighbors? I mean, I assume you definitely have neighbors, but it does look like you have a massive backyard or front yard, whatever that is in the background.
Jared HoberockUh yeah, I've got a neighbor. Uh well, I've got lots of neighbors. I live in a little actually, I live across the street from a Saturday Night Live uh cast member. Uh we live in a little uh cul-de-sac of uh mid-century modern um architecture. And uh we've all got lawns and um interesting looking houses.
BryceA man after my own heart. I did not know this. I'm a sucker for the mid-century modern architecture.
ConorSo we should talk to our boss about having our next research offsite in Kansas City, then, it sounds like we could have it downstairs.
Jared HoberockThat is that is right.
BryceYou two have the same boss. I forgot about that. That is uh well, I guess I knew that, but I did not I did not realize the possible podcast implications of that.
ConorYes. I mean we should probably now I feel like some of this banter is gonna make it onto the actual podcast. Let's introduce our guests, though. We have the man, the myth, the developer behind the library that we spend an immense amount of time talking about on this podcast, the Thrust Parallel Algorithms Library, Jared Hobrock from Kansas City. We spent a whole uh we we had our trip to Slovenia and to Italy where we were talking about unique count, an algorithm that I assume you personally authored back in the day, only to realize that it was a reduction uh with some zip iterators behind the scene.
ConorAnd anyways, we're now talking to the individual that I'm not I I don't actually know where Thrust originated, if it was with uh with your dissertation. Anyways, we'll throw it over to you now, Jared. We'll get some updates from Bryce because he's in the States, not in New York. Um before we do that.
BryceI'm home now.
ConorOh, are you home? All right, well, we'll we'll get a little update from Bryce later. But uh we both work on the same research team and throw it back to wherever you want. The first computer, the first time you encountered parallel programming, the first time you encountered a GPU. Take it back however far you want, and then bring us up to speed with where you are now, the thrust library. You're working on, you know, things that are uh bigger and better, hopefully, than the thrust library. But yeah, over to you.
Jared HoberockHopefully. Well, I'm always um surprised to see that thrust still gets talked about. I'm uh I'm surprised it could fill up enough content for uh I don't know, some some portion of your uh your podcast uh so far. But um yeah, I guess just to talk a little bit about where it came from, it did originate as part of some uh work I was doing in grad school. So I came from a computer graphics background, and in grad school I would I was working on things like um path tracing renderers um on the GPU around the time that CUDA was first released, and uh thrust sort of emerged from that uh renderer project uh because I needed something.
Jared HoberockIf you've ever written um CUDA kernels, you know that there's a lot of um well, at the time at least, not a lot of batteries were included with CUDA. So if you wanted to do anything with CUDA, it required a lot of effort, uh required a lot of labor. And during that project, while I was working on this render, I just noticed that I was you know repeating certain things I needed to do for a kernel launch over and over and over again, and it became clear that you know we needed some more code reuse.
Jared HoberockAnd eventually this uh library sort of came together for automating some of the stuff you do as part of writing kernels and and launching them. Um and that sort of evolved to become um the thrust library over time. At some point I learned about the standard template library and realized this is what uh we should be targeting, this is what we actually need. Uh and it sort of coalesced around uh this thing that already existed.
BryceSo interesting. So you you started off Thrust. Thrust was not originally inspired by the STL. You started off as just a collection of like common utilities, and then you learned about the STL and then took inspiration from it.
Jared HoberockRight. At some point, um so this was probably back in 2007 or eight, and things like cppreference.com didn't exist, right? Um Stack Overflow maybe didn't exist, but uh what did exist were the uh the old SGI uh documentation for uh the original STL. And at some point we came across that, and uh I didn't know what a reduction was at the time. So anytime I would come across those those documents uh about the the SGI STL, I thought it was just you know gibberish.
Jared HoberockI didn't know what they were talking about. I didn't know what an iterator was or a functor was, but I knew that like std vector was helpful. I just sort of assumed that this other stuff to the side was kind of for nerds or something. Uh but eventually I learned what std transform did uh and realized, oh, that's exactly what that's the kind of thing that we need uh to do this this GPU parallelism stuff. And at that point, you know, I sort of had sort of had to get good with uh STL and figure all that stuff out.
Jared HoberockAnd it turns out that stuff is uh actually pretty useful and well designed, at least for the time. Um but uh maybe originally wasn't presented in the most uh sort of it wasn't obvious why it might be useful at the time because C in like 2008-ish, it wasn't really in a state where you could use the STL in a productive way, right? That'd be before things like lambdas and uh so it all looked very alien to me um until eventually uh sort of figured out what the purpose was.
Jared HoberockAnd having the use case uh in uh GPU parallelism was sort of what made that uh made that click for me.
BryceDid um this work that you're doing on uh that that eventually led to thrust, was that was any of that pre-CUDA, or was it all like after the initial CUDA release?
Jared HoberockBefore CUDA came out, we would write they they had what was called GP GPU, right? So general purpose programming on GPUs. And in those days, that meant you were writing shaders in something like HLSL or uh whatever the OpenGL shading language was at the time. You're sort of trying to do what you wanted to do in a graphic sh in like a in a pixel shader, um, actually. So there was a bit of that going on, but um we really wanted like the surrounding code in a renderer was all C, and you just prefer to write it all in C and not have to switch between the renderer code in C and then the shader code in some sort of pseudo C like language.
Jared HoberockAnd anyway, uh before CUDA came out, that's sort of what we had to settle for. Um but once CUDA did come out, and C sort of kind of sort of worked um at the time, um, that was just like so much better than trying to do things in in shaders, in graphic shaders. Um so at some point I started uh working on a GPU ray tracer based on CUDA. Um and of course that would be a uh like the the renderer was a C application, and uh the CUDA stuff was close enough to C at the time.
Jared HoberockSo anyway, uh at some point uh Thrust sort of evolved um from that work when CUDA C actually become available. Before CUDA, there was um some people at Davis had uh sort of a thrust-like thing they were doing with um graphic shaders, sort of had the same same idea. You had these uh parallel primitives, and but they were sort of compiling them to graphic shaders, and we you know of course it didn't, it was just a research project.
Jared HoberockNo one was building products with it or anything like that, but um the idea has sort of been around for a long time. I think even Ian Buck's sort of work at Stanford was it was also targeting shaders and maybe had some of the same kind of flavor uh at the time. But this is all like a long time ago, you know, before um before CUDA you know ever existed.
ConorSo You said at one point that pre-discovering STL, you weren't really thinking about reduces, and you can correct me if I'm wrong, but like you know, the thrust reduce is you know a a I don't know what you call it, a paramount algorithm of the thrust library, like reductions are the bread and butter of parallel compute. And I know that I think it was 2003 or 4 that the Jeff Dean MapReduce came out. So when you're working on these repetitive CUDA kernel patterns and you're working towards this algorithm library, and then you discover the STL.
ConorI mean, it's both, you know, Bryce and uh my one of our favorite algorithms. What is were you aware of like reductions and parallel reductions at that point? Like what's the state of the academic literature? Because it you made it sound like you you stumbled upon the STL and that helped you crystallize it. Was that what led to like std reduce, or not std reduce, but like thrust reduce? Or was that like clearly a part of your algorithm library before then and it just kind of matched up well?
Jared HoberockNo, not at all. So uh this remember, this is in the context of a path tracing renderer. So um I needed to fire a bunch of rays, uh, you know, for each ray, trace array. There was no need for a reduction. I certainly didn't know what a reduction was at the time. I wasn't aware that Really?
ConorAnd that that's that's like to me, like I went to school 2008 to 2014, maybe didn't learn about it, but like functional programming was a thing while I was learning programming languages. So like reductions and folds, it's everywhere. Like you go to a language, they've got an algorithm. But at your time, you're saying you weren't even aware.
Jared HoberockThat wasn't like a Well, remember, it wasn't everywhere. We introduced the term into C ⁇ , so it wasn't in that language. Um I took one, uh I took a programming languages uh class in grad school, and that class was taught in OCaml, which is a functional language, and I didn't understand it. I didn't just I didn't get it. It didn't click for me at the time. Um now I sort of get I understand functional programming a lot better, but at the time I didn't I tried to write everything as if I was writing C code and it just never really clicked for me, and certainly wasn't exposed to something like a fold until much later in my career.
Jared HoberockSo uh no, at the time when uh thrust was coming together, um, you know, I probably didn't learn about a reduction until uh someone uh demonstrated how to probably until Mark Harris demonstrated how to do it in CUDA.
ConorUm That is That's both surprising and inspiring that the fact that it's such an essential part of Thrust and CUDA programming in general that you didn't discover that until so late. Um I would have just assumed it was like part of the genesis of Thrust.
Jared HoberockWell, uh parallel programming at the time was uh something that people did at national labs and they did it on Intel chips. Um and they I imagine everything they did was sort of ad hoc. It's not like there were libraries of um you know parallel primitives in 2005 or anything like that. Uh maybe the closest thing there was was thread threading building blocks. I don't know when that came out, but they TBB probably had a reduce um at the time, but I'd never used TBB.
Jared HoberockIt's not something I was experienced in. Uh I was uh I was just um like I said, my background was in uh GP GPU, and that meant doing stuff with pixel shaders. You couldn't do a reduction in a pixel shader uh at the time wasn't possible. Uh no communication was possible, actually, uh in um pixel shaders at the time.
BryceSo I do believe that like the original origin of the of the term reduce comes from like APL and Ken Iverson. And the then the question is when did it become a popular thing in parallel programming? So I I can think of a couple different places. So first of all, MPI, the message passing interface, which was created in the 90s, um, has a reduction primitive. Um I think that's certainly one of the places where the notion of a generalized, semi-generalized reduction would have come up as a as a basic parallel operation.
BryceUh TBB certainly came later. But I I do wonder, I I I asked Chat GPT in the background, so it's it's looking it's looking for answers. But I do wonder where is the first the first programming language uh that had a parallel uh reduction operation, a generalized parallel reduction operation. And by generalized I mean one where you could plug in different operators. I wonder which the first would have been.
Jared HoberockYeah, I have no idea. I'm uh I assume uh the term reduce comes from the It actually it comes from APL.
ConorYeah, I mean so APL, the book was written in 1962, the first implementation was 1966, but the term reduce comes from these array languages where when you perform a reduction on a matrix, you are reducing the dimensions by one. So if if on a matrix, if you do a column-wise or a row-wise reduction, you end up with a rank one array. If you are doing a reduction on a rank one array, you end up with a rank zero scalar. And so a lot of people think that the term reduce comes from that you're reducing a bunch of elements down to a single element, but that's actually not it.
ConorThe term comes from you are reducing the dimensions on an arbitrarily ranked array from n to n minus one. Interesting to think that it comes from a sequence down to a scalar. I mean, it's not wrong. It is technically a subset of the arbitrarily ranked array of n rank to n minus one rank. But uh I mean this is all very fascinating because I mean the state of thrust today is a very polished, usable parallel algorithm library, which as you mentioned earlier, like uh you said you're surprised that people are still squeezing so much usefulness out of it.
ConorBut like I think of thrust transform reduce and thrust reduce and thrust inclusive and exclusive scan as like very fundamental primitives that if I were to write the history for this algorithm library, like of course that is what you started with, but you're saying that that wasn't the case at all. Like uh you were working on ray tracing and these things evolved over time.
Jared HoberockYeah, and uh especially for something like transform reduce, uh that sort of you know, that evolved as a as a as a means to get fusion between uh you know something like a transform and a reduction, because you know you want to avoid the memory traffic that would occur if you applied those as two separate passes rather than uh one fused pass uh together. And um it wasn't obvious starting out, it wasn't obvious that uh, at least to us, uh that that's something uh that could be really useful to do.
Jared HoberockBut now you know, like you said, maybe it's one of the first things that you would reach for whenever you need to do something interesting.
BryceWhen, Jared, when did the um the notion of the fancy iterators of the the the lazy iterators come in? Like, or let me put it another way. When at what point did you realize that instead of having a a special transform reduce op, that you could have a reduce op and something like a transform iterator?
Jared HoberockUm well originally I think uh so at some point uh collaborator Nathan Bell came on uh to work on the project. Uh and it was sort of the two of us uh working. And before we had settled on the idea that the the SGI uh STL uh API was something that we needed to target, there was some like it wasn't clear what the inputs to the algorithm should even be, right? So it wasn't even clear that iterators were the sort of model to target. Uh and Nathan had a background in Python, um, so he was used to like NumPy.
Jared HoberockUh and he had suggested, I remember he has suggested, well, what if these the inputs to these algorithms were more like generators? Um so they're sort of just like black box functions that you call and they they give you, you know, they return something to you. And um at some point it was clear that like that was not going to work. Like C wasn't like Python, and uh that couldn't be made to work correctly. So iterators was probably something that we needed to understand really well and and target.
Jared HoberockAnd at that point, uh I realized I needed to uh like get get better at C because like the stuff going on in the Boost iterator library was pretty wild uh at the time. So um, you know, I started uh mining uh boost for ideas, and you know, they've got the iterator library, and um that's I mean, Thrust essentially cargo culted all that stuff um and and brought it all in. I don't remember exactly, I'm sure the release notes say exactly when those came in, but uh at some point it became clear that uh adopting that sort of model would be a good idea because it would allow things like fusion and transform reduce and and zip and uh all that sort of thing.
ConorDid transform iterator come before transform? Form reduce or did it come after, or do you recall?
Jared HoberockI don't remember.
BryceI I I believe from because I so a little piece of context here is that I had the unfortunate distinction of having to do a significant amount of version control engineering on Thrust because we had to we've had to migrate it between three different version control systems. And so I've looked through all the commits, at least all the commit messages, uh a couple times. Um and I I believe if I call recall correctly, that transform reduce came first, and that later transform, like the the current implementation where transform reduce is implemented as just reduce with transform iterators uh came later.
Jared HoberockJust in general, like um right now, at this point in its life cycle, you know, thrust is mature and it's sort of implemented in terms of itself, right? So like one algorithm can implement itself by lowering onto another. But you know, projects don't begin like that, right? They begin as like you put in this hack into this in this part of the code to make it work, but you know, you really you sort of know that it should sort of just use itself in a different way and be sort of self-similar.
Jared HoberockBut um so it doesn't surprise me that maybe transform reduce or transform came before transform iterator.
BryceSo so thrust has, I think it its architecture is in some ways elegant. In some ways there's some dark holes of it. But um I think by far the most beautiful part of Thrust is the uh what's called like the generic backend, the dispatch layer. So when you write a thrust backend, you can customize how each function uh in that backend, you can customize how reduce works, how transform works, how sort works, how unique works.
BryceUm but there's this generic layer where you at minimum your backend has to customize like five or six basis algorithms. And you can customize more if you want. But if you don't customize more, then all the rest of the algorithms are implemented in terms of those five or six basis algorithms. And those implementations in terms of the basis algorithms are in this generic layer. And I think that's the most beautiful part of thrust. And actually, if you're like it's one of the best places to like find examples of how to write good thrust code.
BryceUm, because like that's where you can go to find uh like the unique count implementation that that we've talked about on the podcast before in terms of reduce, or like the reduce implementation in terms of like transform iterators. It's a really it's a very elegant part of the code.
Jared HoberockI have to disagree. I uh I think it's a gigantic mess of uh spaghetti code. Uh so I know what you're talking about. Um like the idea is you want to call uh an algorithm and maybe get a default implementation if there's not a specialization in a backend somewhere. Uh I think we have better ways to do that in C in 2025, but at the time, uh I remember at the time we didn't there wasn't a good understanding of things like customization point objects and and how to make that stuff work.
Jared HoberockSo the way it does work to the dec to the extent that it does work was sort of uh implemented in what C3 made possible, because that was sort of uh constraints of the time. But uh what you get is this mess. Uh I know it's a gigantic mess of uh of spaghetti, uh, but it does work.
BryceIt is sometimes very subtle because it works on it works on the principle of ADL dispatch, and there's some amount of upcasting of execution policies. Um there's this tag, the execution policy, and that is used to route your call to the right you know place. And as it goes through all of these forwarding layers, the forwarding layers have to ensure that the execution policy is correctly casted or upcasted to the most derived execution policy so that it dispatches to the right place.
BryceAnd if any of that goes wrong, you end up with uh you know uh all sorts of things.
Jared HoberockI mean you don't you don't have to do that anymore. Um I mean a a lot of those uh a lot of the reasons it it does work like that is because there were no forwarding references at at the time. Yeah, you could do much better these days, I think, if someone were so inclined.
BryceSo it's very interesting to me to to hear that Nathan Bell, who one of the other founders of Thrust, was a Python person, was a and was a NumPy person. Because, Jared, do you know the the largest user by volume and compute of Thrust today?
Jared HoberockNo.
BryceSo I think I can give you a pretty accurate uh uh accounting of the the the top users of uh uh of thrust, specifically thrust. Um there's a there I I'm gonna exclude libraries that like use like a lot of Cub and like some Thrust. I mean just people that will heavily rely on Thrust. And by users, but by the metric I'm measuring by is not like lines of code written or number of developers um using it, but I mean like uh number of GPUs right this moment that are running that thrust code.
BryceAnd the I'm not sure which of these two is number one and number two, but I think number one is Coupie. And Koupie is just a CUDA accelerated version of NumPy. So I think there's something there's something very elegant here that back in the day Jared and this numpy fellow came and wrote Thrust, and Thrust has some of that NumPy DNA in it. And then like 15 years later, it is Thrust is the thing that powers uh Kupai, the GPU accelerated numpy.
BryceNow, you you asked that the other ones, the the the one that I think is probably number two, and again, this is by the metric I gave of uh like number of like uh amount of thrust code that's running right now would be PyTorch. And there's PyTorch is in more use than Koupy, but PyTorch uses Thrust in fewer places than Koupy does. Koupy uses Thrust very, very extensively to implement a ton of the different algorithms. It also uses Cub, but it uses it pretty extensively.
BryceAt least that's my understanding. Um so yeah, I would say Kupai, PyTorch are uh the the top two. Um Rapids is um probably like number three or number four. Um and then I think after that, uh I think it's hard to say. Um there's probably one or two more Python uh users, and then probably it's whoever the the largest C user is. But like definitely the top three or four users of the Thrust library today are uh Python frameworks.
Jared HoberockThat's interesting because around 2009, uh there was sort of a question of what's next for there was a question of like what was gonna be next for Thrust, and we had abandoned plans for doing a bunch of like numeric uh extensions, some very NumPy-like numeric extensions. And that would have been very valuable uh if we had actually done that. And like in hindsight, the landscape might be quite might might might have been quite different if had we had actually gone through and why did you abandon it?
Jared HoberockYou know, implement a bunch of uh Nathan ended up going to Google and uh Thrust was productized and uh sort of left left our control, so it became this product and um was sort of maintained by product folks. So uh it began as a research project, um and at some point was decided that we should um productize it, which meant finding someone in a product team to sort of own responsibility for it. Um and at that time that meant that you know the the research people that had been um working on it at that point would find something else to do.
Jared HoberockAnd uh that's essentially what happened. So we didn't get thrust numeric, uh unfortunately, uh uh because of that. It would have been something like um you know, like expression templates for numpy like things. Something like MATX. Maybe you said matx?
BryceYeah.
Jared HoberockSomething like that, probably. I don't know, you can probably still find it on my GitHub.
ConorWhat's interesting is that in the example uh subdirectory of the what is now cccl slash thrust slash examples, but at one point was thrust slash examples, there are several examples that are basically like array library examples. I'm not sure if Bryce added this, but we had an episode, I don't know if it was 10, 20, 30 episodes ago, where we talked about summed area tables.
ConorThere is an example in the Thrust example repository of a summed area table in Thrust, which you would think is pretty hard to make happen in Thrust, which is uh a rank one array library, basically, uh single sequence. But the way that they do that is they define a function called transpose, which makes use of a permutation iterator and a uh a gather algorithm, and it just it just calls transpose twice, and then it defines a horizontal scan, which is implemented in terms of uh inclusive scan, and so it calls that twice interleaved with a transpose algorithm.
ConorAnyways, the point being is that like technically you can do this with thrust. It's just non-ergonomic. And I don't know. Did you add this example twice?
BryceUh although I think it was it was one of the original examples, although I do plan on adding another.
ConorIt was one of the original examples.
Jared HoberockIt's called summed area table?
BryceYeah.
ConorIt's called summed underscore area underscore table dot cu. And it makes use of inclusive scan by key, uh, which is the where you can do your kind of row by row key algorithm, and then it has a transform iterator, which I believe uses a permutation iterator, which gets your kind of bicolumn indices and then does a gather at the end of the day to permute your sequence. Which is, I imagine, highly inefficient in the in the world of you know, array libraries, machine learning, deep learning.
ConorBut um I was very curious to stumble across that the other day, uh given that you said that um your co-author of the library, Nathan.
Jared HoberockUm looks like Nathan good to me, yeah.
ConorYeah.
Jared HoberockHe was always good at figuring out the way to do it. He was he was better than me at um figuring out how how to make the prefix sum do what you wanted.
BryceI've gotten better over time, but um Oh, I I don't I don't want to tease too much, but t towards the end of the Jared interview. Oh boy, do I have something I've been working on the past two days that I'm very excited to show you guys in that vein.
ConorBe 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. Thanks for listening. We hope you enjoyed and have a great day.
BryceLow quality, high quality, that is the tagline of our podcast.
ConorThat's not the tagline. Our tagline is chaos with sprinkles of information.
In this episode, Conor and Bryce chat with Zach Laine about C++26 Reflection vs CRTP, AI, kids & more. Link to Episode 313 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP:...
In this episode, Conor and Bryce chat with Zach Laine about the C++26 contracts fiasco. Link to Episode 312 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP: The Podcast:...
In this episode, Conor and Bryce talk with Zach Laine about his career and the career changes he has made. Link to Episode 311 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials...
In this episode, Conor and Bryce talk about Bryce's next chapter and where he is leaving NVIDIA for. Link to Episode 310 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP: The...
In this episode, Conor and Ben chat with Jason Turner about default construction in C++. Link to Episode 309 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Socials ADSP: The Podcast:...