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 214: Advent of Code in BQN (vs Python)

Dec 27, 202432 minAudio

In this episode, Conor and Ben chat about different approaches to solving Advent of Code problems in BQN, Python and more. Link to Episode 214 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: 2024-12-16 Date Released: 2024-12-27 Advent of Code 2024 Conor's AoC Video Playlist APL BQN Python functools.cache To Mock a Mockingbird CppNorth 2024 Keynote: Advent of Code, Behind the Scenes - Eric Wastl BQN ‿∘ (Computed Reshape) BQN •ParseFloat BQN •BQN BQN ⍟ (repeat) C++20 std::views::iota Haskell iterate Python Counter collection BQN /⁼ Indices Inverse Histogram Idiom BQN AoC 2024 Leaderboard 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.

BenI solved that with recursion. And you solved it in BQN with generating the permutation of the functions plus and multiply, and then applying that to the list of numbers.

ConorInverse of indices, that is a BQN idiom for basically giving you the histogram of a list of numbers. Welcome to ADSP the podcast, episode 214, recorded on December 16th, 2024. My name is Connor, and today with my co-host Ben, we discuss the different algorithmic approaches to solving Aventive Code problems in different programming languages.

ConorAnyways, how's it going? We're getting close to um the holiday season.

BenYeah, Christmas is really uh coming up fast.

ConorYeah. It's it's incredible that we're already halfway through December. Um oh my god, nine days away. Yeah, I didn't even read it.

BenIt's really coming up. I did I did all my present wrapping yesterday, so that was done. Uh I put up my tree, did Christmas decorations.

ConorOh yeah, you I guess yeah, you're living the life of uh someone who owns a place and can fit a tree.

BenYeah, I suppose so.

ConorI haven't hit that stage of my life yet where uh we there's technically a tiny Christmas tree sitting on uh the dining table.

BenBut well your background looks great.

ConorWell, yes, thanks to thanks to Google and their virtual I don't know, technically, this is an augmented reality. What would you call this? It's just a virtual background. Yeah, I suppose. Yeah. Anyways, how have things how have things been? It's been uh a couple weeks since we chatted.

BenUh good. Yeah. Um nothing much to report. I I wanted to spend this time to ask you some questions about APL, about AOC.

ConorUm, I think that's we were we were initially, that was the topic that we had slotted for the astute listener. I think we referenced it at the end of the two-part board games episode that we were intending to uh uh have a conversation about APL where you as a C dev asked me some questions. We we failed to talk about that, but now we're back with uh, you know, we haven't been derailed yet. And now that we're in the middle of December, we might tie in some Advent of Code uh stuff as it goes.

ConorSo yes.

BenYeah, so I've I've watched your Advent of Code uh code report videos. Uh I think all of them up to this point. Um of which there are what we're we're up to day sixteen or sixteen today, and you have probably ten videos. I think maybe nine, ten, something like that.

ConorSomething like that. I have finished all of 14 days. I read day 15 and just I've been super busy the last couple days, and I've made, I think it was day one through six or seven, then I skip to day ten, and once I have some more, you know, there's a couple holidays coming off. So I plan to make some more videos, but there's yeah, close to upwards of ten, I think. And I'm doing them all in BQN, which is APL 2.0 if you if you want.

BenRight. Um so I've been doing a few of them. I've done the first three Advent of Codes and uh days, and uh I did date seven and I did day eleven. And uh I've been noticing, and also from previous years, I've you know, uh Advent of Code, the first days are generally easy, and I think the first days lend themselves to 10-minute videos, right? And in particular with Advent of Code, some of the early ones are fairly algorithmically explainable in 10 minutes, right?

BenAnd and and your BQN videos reflect that somewhat. Um so I wanted to ask you like I so I noticed um a couple of the days um on day on day 10 you use recursion. On day, you know, like you you as we get later on in Advent of Code, what what I think of as BQN or APL, I think of it as a language that is really good at highly mathematical things, like like arrays of any dimension, just you know, filtering, reducing, all that kind of stuff.

BenWhen it comes so and reading through some of these problems in Advent of Code, a couple of them I solved in like my approach to Advent of Code, I have in previous years done it to ostensibly to learn languages like one year I did it in Haskell, um, one year I I did it in Orc. These days, I think the best approach to Advent of Code is to for each day find the language that fits the find the tool that fits the job. Right? So there are a couple of days, like one of the early days was like totally I did it on the command line in a one-liner.

BenI think I sent you that. It was like day three or so. Um one of the later days, uh which one was it? Oh, the the the day where you had to uh it was day seven, I think, um, where you had uh a number and and and a bunch of numbers that could you could put plus or multiply in between them to make and and the the question was for every line of numbers, can you can you make the sum by combining the others with plus and multiply in it in any of the places?

BenI solved that with recursion, and you solved it in BQN with generating the permutation of the functions plus and multiply, and then applying that to the list of numbers. That was fine. I'm interested to know what you did for day 11, because day 11, I used Python, and the key to day 11 was dynamic programming, was was um memoizing one of the functions. And in Python that is super simple, you just put a decorator on, which is why I thought Python was a good tool for that day.

BenSo I'm interested if you've tackled day 11 in BQN and and what you did for that.

ConorSo let me refresh my memory. Luckily I have the VS Code instance, so I can just type day 11. So this was Oh yeah, this was the one where it's kind of one of those like it's similar to is it the collats conjecture? I might be totally off, where it's like if it's even you divide by two, if it's odd, you multiply by three and add one or something like that. Uh I can't.

BenYeah, well, it's a sort of a finite automata in one dimension, right? It's a finite automata where you look at the value in the cell and you do something. Uh and one of the things you can do is split the cell in two, and so it becomes this exponentially growing thing.

ConorYes. Yeah. And then parts A and B. And so I I think the rules, and I'm doing this just by looking at the code, is that if your num so you're giv you st you're given an initial list of numbers, and there's I think three different rules. And I'm I'm just reading, I'm translating for BQN code. So this is a test of how easy is it for me to read BQN code. Yeah. And I I can actually I'm not sure if I should I can share my screen, and we will hopefully not completely destroy the listener's ability.

BenUm but you know uh if I if I get to So I am very much like probably one of our regular listeners when it comes to reading BQN and APL. I I've read Iverson's paper on it, um, but you know, Connor here has written a master's thesis about about combinators. And uh the last time I have never used a APL or BQN, even really to solve an advent of code problem. Um I've read Raymond Smollian's book, and that's that's it.

BenSo I'm please explain.

ConorYeah, so we we'll do our best to not lose both Ben and the listener here. So I think hopefully we'll we'll be successful on the first one because you can just stop me at any point. But if uh if we lose the listener, we do apologize. So I mean, there's three rules that we're gonna walk through in a sec, which is all in this blink function. I typically skip the first three or four paragraphs of every problem because it's it's in a it's unessential, inessential to solving the problem. But it had to do with like every time you blink, this list of numbers is gonna is gonna morph.

ConorAnd part A is just um, I think is it uh what's the sum of the numbers after 25 blinks and the second one is after 75 blinks? Uh and we'll come to why it becomes tricky because basically the size of your list is gonna explode.

BenIn typical Advent of Code style, you've said we've both seen Eric's keynote. He gave a keynote at CPP North last year, and he's I think he's given that same keynote in a c in a couple of conferences where he talks about Advent of Code, very worth the watch. Um and one of the things he says is that it tends to contain Advent Code tends to contain these exponential style problems because one of the interesting things is you don't want to make a problem where someone can solve it in C and not in Python, for instance, right? So the language doesn't, you know, the the the cost of doing these um exponential part twos is too big, even if you're using a compiled language.

BenWithout finding without well, I mean these days you might have like a whole farm, a whole cloud, you could pay lots of money to do it. But but it does I'm I'm gonna say for this problem, even in BQN, like you can't brute force it. And if you think you're brute forcing it, it's probably that BQN internally has something which is which is working to your advantage, right?

ConorThe reason I say sometimes is I think, and I've been rather surprised with this year's Avenue Code, which is 2024, in case you're listening to this years in the future. I think only one or two of the problems I actually had to do something, and this was actually one of the problems where my first solution, I couldn't just increase the number or change the thing. Like literally, I'm I can't remember which day it was. I I think it was the day where you had to find the number, the trail heads from zero uh to nine increasing by one. Yeah. That was a single character difference in my solution.

ConorRight. Because it was just can you get to it and how many different ways? And I was already deduplicating, I was already calculating all the paths and then just like looking at the position. And so the solution was just delete the deduplication and count how many ways did you get there. And and deduplicate as a single character and APL. So I just deleted it was either adding it or deleting it. And I was shocked because usually you expect like, oh, I hope I did this problem.

BenYeah. In preparation for talking to you, Dad, I watched your code report videos last night.

ConorSo yes, it was maybe we can get we can get to feedback uh uh afterwards.

BenUm Well, you have a bug in one of them, which we'll come to.

ConorOh, well, it's a bug that uh well we'll we'll we'll save that for later. So, anyways, we're we're on day 11, part A, part B, 25 iterations versus 75 iterations, and you're given a list of numbers. If I can get this uh tooltip to disappear. And here are the rules. So this blink function basically uh is gonna be what performs this action. So it says here uh if it's equal to zero, and then you're just this is basically a ternary expression.

BenYeah. So you've got a you've got a one just to set up, you've got a one-dimensional array of numbers, right? And for each number, each cell in that array, you are doing this operation. It's like a finite automaton. The array changes with every blink, and each cell of the array does something to change.

ConorYeah. And so if if it's equal to zero, you change your number to one. That's the first rule. If it I and so what this reads is if mod two equals zero. So if divisible by two, uh you just want to uh what does this say? You want to take or no, so it's if the length I missed out the first part of this. If the length of system function reper, which means convert this to a string, is divisible by zero. So if you have an even number of digits. If it's decimal representation has an even number of digits.

ConorYeah. Then what you want to do, this is uh the second uh uh operation, is you want to what I have written in my code is uh I'm I'm doing sort of some redundant work here. I'm converting it to a string twice. So technically I could have assigned this to a local, but for the purpose of this, it uh it didn't really matter. So you're converting it to a string and then you're cutting it. And what does a cut mean? A cut means to basically slice it in two. So I'm making use of a very beautiful thing in BQN where you give it a shape, which is uh two, and then I'm not actually filling in the final dimension, and this is just saying give me a two-row matrix with the correct number of columns that will uh split that um so you're you're going from a rank one array, aka a vector, to a matrix of two rows, which is gonna basically have the two digits in each row, and then I'm calling a function called parse float, which takes a string and then converts that to an integer, and I'm doing that on a row-wise basis.

ConorSo I'm basically taking this matrix of characters and treating each row as a string and then converting it back into an integer. So this is just a very cute way of converting a number with an even number of digits into two uh two numbers.

BenSo in in English, you're you're cutting the number in half textually. So 1234 becomes 12 and 34.

ConorYeah. For example. And it's uh it's quite nice. And in fact, actually, you can do this a little bit slower with the system BQN function, which just takes any arbitrary BQN expression and evaluates it. But I I can't remember if it was this day, but one of the days I ended up running into like uh runtime problems, and I discovered by looking at other folks' solutions that if you know your expression is is just an integer or a float literal, it's way faster to use this parse float because that's gonna be uh much simpler than uh evaluating just any arbitrary BQN expression.

ConorAnyway, so condition one is zero, change it to one. Condition two, even number of digits, split it in half. And condition number three, which is just the else case, so there's nothing to check for, you multiply by tw 2024.

BenUm which is just Okay, so there are three things you can do for those three cases. And it's the splitting one, it's the cutting the it's the one cell becoming two that, as you can appreciate, over time makes the array grow and grow exponentially.

ConorYeah. And for part A, I don't actually think I even needed this step function. So I have this extra step function which uses blink. But for part A, I basically just called Blink with the repeat operator, which is uh I don't know if it's what do you call it, morally spiritually equivalent, but it's it's kind of like a for loop without the indices. You just pass it a function and you perform that that function that many times.

BenRight. So it's like Haskell, is this like Haskell's iterate? Or it's it's the general I think if it if it is, so it's like you're well you the scan of it, if you like, it the repeat operator is like an accumulation. But if that were expanded out to a scan, it would be you'd be getting x, f of x, f of f of x, f of f of f of x. It just so happens that the repetition is giving you the end of that sequence, so you're you're getting f of x applied f applied to x twenty-five times iteratively.

ConorYes, there is de definitely a symmetry between scan and repeat. Except I would compare this more to a reduction, because scan outputs the uh intermediate state. The key here is that there's only one input to your function.

BenUm I think of it as the generalization of IOTA. IOTA is repeat with the function being plus one.

ConorRight. Basically you have a start state and a unary function, and it applies that unary function n number of times, in this case twenty-five. Right. Uh whereas like reductions and scans, they technically take new not state, but like they take a new value and have a binary operation where they're taking the state that it's carrying along plus the new information typically in the form of a list or something. But yeah, very similar to the the Haskell I I can never remember. There's iterate and then there's another one that are both somewhat similar.

BenBut yeah, so anyway, you iterate this function 25 times, you repeat it, and that gives you the array after 25 blinks.

ConorYep. And you'll you'll see that there's a bunch of what we'll call a ceremony around this, like this tack reduce. This is a two-character way of spelling last. And that's because of the modifications to this solution that we had to do for part B. So part A was much simpler. It just had a blink function, repeat 25 times, add those up, you're done. It didn't have this extra tack reduction, which is uh, like I said, a two-character way of spelling last.

BenRight. So because tack is take the thing on the right. Exactly. And then so if you reduce that over an array, you get the thing on the far right, which is the last thing.

ConorFor a and for a in this case, we just have a two-element array, it's a painful way of spelling like second, SND and Haskell, or even even uh dot dot second and C on on your pair. And it's actually one of my largest complaints. Uh if I had to make a list of the top ten things about array languages and BQN, I don't actually think any of them have a last primitive. They all have first, but they don't have last. And I think that there's a bunch of other primitives that have been added that are used way less frequently than last.

ConorAnd you always end up, especially when you're building up forks, which are things that are beautiful when they're symmetric, you have a single glyph for first, and then a two-character glyph, not even glyph, a two-character expression that is really the application, like this is kind of a trick, like the tack reduction. The first time you see this, it's like, what is that? Because it's it's not the intuitive way to get the last thing. You might want to reverse and take the first thing of that. That was how I used to spell it when I started programming in APL.

BenIs there a performance implication here? Is that like because first is you know, constant time. Tac reduction sounds like linear time, but would it be possible to have a primitive that returned last in constant time? Or does something happen in under the hood to make it?

ConorYeah, most, if not all, the array implementations that I know of have an idiom recognition for this. So it's a constant time operation. But if it if it didn't have idiom recognition, it would be linear, and it still would be preferable to the re first on reverse because that's actually gonna Because that's moving things around as well as yeah. And I think actually I should say that cap is uh lazy it has lazy evaluation built into it. So in that case, if you do a first reduce, it's actually gonna be the fastest because it's gonna perform some kind of view transformation similar to C 2023 views, reverse it, and then just it needs the first and it's gonna short circuit right there.

ConorSo arguably uh cap actually has the constant time without idiom recognition. But to get to part B, the modification that's made, and I actually borrowed this, you can see that I I have this heavily inspired by uh JH Franklin is the GitHub username. Because I I wasn't actually sure what to do here. And it has this very cute trick that uses one of my favorite BQN idioms that basically it does a deduplication and stores your current list in the form of a the array equivalent of a hash map or uh the counter collection in Python, where you keep track of the number of values and the number of times that value shows up.

ConorAnd so every single time So it's like a histogram operator. Exactly, exactly. And and so this well, the the two characters uh I because I skated over it without explaining for the listener. Uh if you have the inverse of indices, that is a BQN idiom for basically giving you the histogram of a list of numbers. So indices, if you're given basically in the in the simple case, um zeros and ones, it'll give you the indices that correspond to the ones.

ConorSo for instance, if I have the sequ and and BQN is a zero index language, so if if you have one, zero, one, zero, one and you perform indices, which is just a slash on that, it'll give you back zero, two, and four because those are the indices that correspond to ones. However, that's the a subset of what indices is. Technically, it will give you two of every index, or three of every index, or in general, n of every index, where n is the number that corresponds to that index.

ConorSo if I changed my sequence from one zero one zero one to one zero two zero three, I'd get zero, two, two, four, four, four. If that makes sense.

BenOkay. Okay.

ConorSo some people refer to indices actually as copy. Because you c you can think of instead of taking the indices that correspond to ones, you're copying the indexes n times for the n that corresponds to that index.

BenRight. So the oh, so this is m now making me think of the the disk defragmenting day for event of code which was like the input was like an RLE string. Sounds very similar to to kind of what indexes might might do.

ConorIn fact, I can't remember the name of that, but almost uh surely that is what I did. I think I used a indices or replicate or copy or whatever you want to call it to create that. If you're if you can basically take that, it'll auto-generate. I think it's a little bit trickier because I solved that problem incorrectly. I I didn't realize you could have more than a single digit number and that totally breaks, right? Like you can you can have a two digit number which means you can't just look at the individual things. And so now that I've explained what indices does indices inverse or technically undo is the operator in in BQN its technical name.

ConorIt will take a list of numbers it technically does a little trick for this idiom and it sorts it first and then it gives you the quote unquote mask that would give you that list of numbers. So if if I have the list of numbers 0, 2244 and imagine that those could be rearranged.

BenSo it's the inverse of indices so it gives you one zero two zero three. Exactly.

ConorWhich is like right there, that is probably we lost a few listeners, but like this is two characters on screen and inside basically indices like we have I like to think of it 90% of the time as just the Boolean mask version. It's it's it's your equivalent of a filter. And actually technically I think I'm I've I've totally messed up my explanation of this the monadic version is is the one that we've been talking about where you just apply it to a a a list of numbers but then there's a dyadic version where you actually give it a mask so one that takes two arguments.

ConorAnd I guess that's the one that typically is called replicator copy. So I've been I've been mixing up my words but like in this single operation we've got the indices on like zeros and ones, the indices on numbers and then you can invert it to get the histogram which is basically how this problem starts out. So this is all building up to the fact that whereas for when I was just solving part A, you can just work on your list of numbers and then it'll it'll work. But for part B, I had to basically re-architect the solution a little bit, add this step function that is this boilerplate of every single time you perform the blink function and on the initial input you basically need to like histogrammize um each iteration and then that's why for part A and part B now you have this last because you're you're needing to um get the counts of these actually wait a second how does that actually make sense right?

ConorBecause you need to multiply them in order to get the total sums at the end of the day. Is that what did dip the part B? What did it actually ask for?

BenWhat it's asking for yeah this is day 11 part B or rather as Ben and I are both reading the uh oh it's asking for the length of the sequence.

ConorOkay. Yeah yeah so that's why it's getting the last because I was like I was gonna say if this was supposed to be the sum of each of the numbers this would be wrong. Uh but what it's doing is it's getting the counts which is technically the value in these key value pairs and then just summing up the counts uh which then it is correct. So uh anyways I'm not sure and then also too like this is I'm not gonna walk through this but in the step function I tacitized aka like I made the whole expression tacit probably to the it it harmed the readability of this because there's a there's a lot of I don't want to say line noise but to someone who's not used to BQN this is not readable.

BenI can see some I can see if I can see a few things in it.

ConorYeah some ads so you know it's it's definitely recognizable but it's it's it's typical as to what the functions end up like in your videos I think we could say well I mean sometimes uh sometimes I'll make something tacit and then after the fact be like ah this is not more readable but I went through the process of making it tacit so I'll just leave it there. It's Aventive code, not production system stuff, right?

BenSo I'm not sure what what are your thoughts after after having been walked through is is this uh it's interesting you know because um it's very different so part A you know uh avent of code problems are set up like this so so so that in part A you can implement the naive solution right and the naive solution is just to apply the apply the automaton function to every cell and just expand the array and 25 steps later you count how many you've got.

BenAnd that I think is originally what you did and what I did in Python and what probably everyone did. And but then part B requires you and you know there's a sort of thing here where if if part B is just a one-liner we perhaps we should be afraid.

ConorYes because it's like I did not set myself up for success for part B.

BenYeah and part B, you know, you'd be waiting years if not centuries with a naive solution um even if you had the amount of memory required. So your approach to part B in BQN was very different to my approach to part B. And I don't want I I don't know what Eric was going for, but I suspect the approach Eric was hoping to lead people towards was the dynamic programming approach, the memoization approach.

BenAnd it's interesting to see that this one was attackable by BQN in this different way by changing the representation of the output, right? Okay, okay. Well how I did it in Python was to add uh a memoirization decorator to the function that that generates the like the the the stone expansion.

ConorAnd and curiously that was actually my initial thought as well is that caching is the and memoization is the solution to Part B. And I actually went and there is a a BQN leaderboard of sorts that folks that want then can s submit their you know GitHub repo and it tracks who's doing them. So you can go and take a look very easily at other folks' solutions for inspiration. And I would say it was 8020 80% being folks that were making use of memoization using something I had no idea existed.

ConorThere's a system hash map that you can reach for if you need it. It's very I would say unarray um idiomatic in that you're using uh updating like a hash map and methods on this kind of object and so you can basically do what what you did painfully like there's no decorator you can call and be QN that like oh it memoises you have to go and manually do the oh I've got a a hash map of already pre-calculated stuff and whenever I see that something's in there.

BenThere's no automatic memoisation in C either I think I saw some folks like um Cy or Tristan have been have been have been putting out their solutions um on Blue Sky. And and for the days like to like day seven where memoization was important or at least a sort of obvious way to do day two we might say yes they've had to they've had to pull in things like hash maps and things yeah exactly. Yeah or an order map whatever it might be.

BenSo it's interesting you said like like some of these days um require you to do things in BQN which are tricky and and also in C ⁇ and also which is why I've come to the like we said at the at the beginning of the conversation which is why I've come to the idea that to to begin with if if you're doing AOC at all there is there is no there is no cheating there is no like you know like any route to the solution is valid.

BenThere's no there's no gatekeeping here there's no you must be a purist do it in this language this language wherever in my view any route to a solution is valid. I mean you're not learning if you're looking up someone else's solution except that you might be learning even in that case right like if you if you just can't think of a way how to solve like a part B and you look up someone else's solution you learn from it that's valid too. When you sit down and do BQN do you feel there are other days where you did there's no there was another day where you did a there was a loop you actually wrote a loop in BQN a while loop and uh I'm looking at that code and I'm thinking that doesn't look like idiomatic BQN that's not the kind of thing I normally see on Connor's videos.

BenSo you know and there's a we uh we could we're not picking on BQN here because it's the same I think for every language like like dealing with regular expressions in in C is painful too. Or you know we could pick random days and say this is really easy in this language is as hard in this other language. So the question behind this observation is like what is BQN for in your opinion? What is it good at? What does it solve well and what is its typical application?

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

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