Episode 181: The C++0x Concepts Story with Doug Gregor (Part 2)
33 minAudio
In this episode, Conor and Bryce chat with Doug Gregor from Apple about the history of C++0x Concepts (part 2). Link to Episode 181 on Website Discuss this episode, leave a comment, or ask a question (on GitHub) Twitter ADSP: The Podcast Conor Hoekstra Bryce Adelstein Lelbach About the Guest: Douglas Gregor is is a Distinguished Engineer at Apple working on the Swift programming language, compiler, and related libraries and tools. He is code owner emeritus of the Clang compiler (part of the LLVM project), a former member of the ISO C++ committee, and a co-author on the second edition of C++ Templates: The Complete Guide. He holds a Ph.D. in computer science from Rensselaer Polytechnic Institute. Show Notes Date Recorded: 2024-04-29 Date Released: 2024-05-10 C++20 Concepts Swift Programming Language Elements of Programming Tecton: A Language for Manipulating Generic Objects Generic Programming by David Musser and Alexander Stepanov Original paper on concepts for C++0x (Stroustrup and Dos Reis) C++ Concepts vs Rust Traits vs Haskell Typeclasses vs Swift Protocols - Conor Hoekstra - ACCU 2021 Paper on the implementation of concepts in ConceptGCC (Gregor, Siek) C++0x Concepts proposal that explains the model (Gregor, Stroustrup) Language wording for concepts that went into C++0x Doug’s last-ditch effort to bring back a simpler C++0x Concepts model using archetypes for type checking Jeremy Siek’s extensive C++0x Concepts writeup Type-Soundness and Optimization in the Concepts Proposal 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.
Doug GregorI I certainly agree with you that given all of the time that was spent on concepts, what we got, I think, is a little un is unfortunate. I was rereading the 2003 paper to see what our goals were. And separate type checking is the one goal. That is the one thing that if we had it, you could even throw out concept maps. If you had separate type checking, it would have made generic programming in C an order of magnitude easier, right? It would no longer be the domain of experts to use templates and use them well.
Doug GregorIt would be something that every programmer just does because they need the abstraction.
ConorSo Joe Coder killed C OX concepts.
Doug GregorI think projections of the thinking onto a mythical Joe Coder is the main thing here. There were other complaints, so there was concern about the compile time performance of the concept GCC prototype. Because it was doing all this template definition checking for the algorithm setter.
BryceTrevor Burrus, but there's always going to be some compile time cost. I mean, there's a compile time cost to C20 concepts. Um people had done benchmarks on it. Like there's there's always going to be some compile time cost to checking versus not checking, right?
Doug GregorI fully agree with you. It seemed like a strange complaint. I it hadn't come up before, it hasn't come after.
BryceI recall hearing some some uh, I think not particularly well substantiated concerns or claims of the that the the not about the the prof compile-time performance of the type checking or the definition checking, but that it was somehow an insolvable problem, that that that the definition checking could not be done. Um and that that was uh why con uh C OX concepts uh did not succeed.
Doug GregorSo it depends on whether you demand perfect checking or not. So if we walk back a little bit to what separate type checking means, you are type checking the implementation of a template against the constraints that it that it states. Now, C has all sorts of ways in which you can uh make a template behave differently. So imagine, for example, my template definition, you know, over some template type parameter t uses a vector of t.
Doug GregorNow, what happens when t becomes bool? You've kicked over to the partial specialization of vector. The partial specialization of vector could be completely unrelated to the generic primary template for vector. And so if you have a language that has something like partial specialization, or where you want to be able to do overloading in sort of an ad hoc manner at template instantiation time, you cannot actually fully type check a template definition and be certain it's going to work in all cases, because someone can just drop in an explicit specialization or a partial specialization of one of the types it template types it uses, and things can break.
Doug GregorSo C OX concepts were able to do template definition checking using the primary templates and doing overload resolution essentially based on what knowledge it has of the template arguments and their capabilities. Now, throughout the C OX concepts process, we actually loosened the constraints on template instantiations a little bit. So this is a deliberate uh decision in reaction uh in reaction to move semantics, actually, the addition to move semantics into the language, where the original definition of C OX concepts would say when you pick an overload at template definition time for any operation, that is the overload that you use at instantiation time no matter what.
ConorOkay.
Doug GregorThe change we made is that we redo overload resolution with the actual template arguments types that come in, the concrete ones at instantiation time. This is treated as a performance optimization because it meant, for example, that you know, if you're passing an R value here and an L value here, you could pick up an overload that took an R value on the right side and an L value on the left side, and that would have better performance than if you always pushed it through the const L value path. Right. We can we can cite that for you in the show notes to see that the decisions.
Doug GregorBut that that's a very explicit. We gave up some of the separate type checking to maintain the C performance model.
ConorRight.
Doug GregorAnd so it's true that you don't have perfection, but this kind of overloading is pretty rare, and it's pretty rare that it actually breaks anything. So you still had the property that you had almost no instantiation time failures. They only really came in when you're doing funny overloading or partial specializations that don't line up with the primary templates.
BryceSo but but is there a reason could couldn't you just check all of the partial specializations? Wouldn't it just be like is there's no way to like exhaustively check it out?
Doug GregorIsn't that trivially exponential?
BryceUm I suppose so.
Doug GregorAnd there's other constraints here too, of for example, what if you haven't seen the partial specialization at the time you check the template definition? Do you not consider it at instantiation time or do you admit the failures again?
BryceAaron Ross Powell Yeah. I mean I I I I or I suppose maybe hmm I suppose like good partial specializations shouldn't uh shouldn't differ differ from the primary. Um it would just be nice if we'd had a language way to enforce that. Right.
Doug GregorWe could have done that. So that you know it would be possible to say, okay, the primary template is itself like a concept, right? It describes an abstract interface, and every specialization, whether partial or full, of that template needs to match that interface. Right. That would be completely reasonable direction for the language to take that would help with this kind of problem.
ConorRight.
Doug GregorThe other answers don't allow specialization, which is what Swift does, for example.
BryceYeah, I think I think you probably could have um probably could have done that uh too. Um I mean you might need different tools uh than what C ⁇ has to be able to do, you know, partial specialization is just one of C ⁇ 's many, you know, uh janky versions of uh of a pattern matching engine. Um and there could have been other ways to to have handled that. Um but we may have had different may have needed different tools than we would have had.
BryceAnd and as you said, so you have the same problem for uh for a uh for an overload set too, for right for like a uh yeah, like if you have some some weird overload that returns something different. Um Okay, I mean it's it's it's uh I I I do in in I have seen plenty of sp of partial specializations that do something different than the primary in some way, and and overload sets in which you know uh that that do quirky things. Usually usually it's mostly implementation details are not particularly um uh important.
BryceI mean I'm sure I can think of some cases where it's mattered, but I I could see how people could have that that concern and could uh conflate that to claims that uh that the checking is not uh not suitable. I think it's a little uh or I I I can see how that narrative got born, I guess is a way to put it. I don't agree with the narrative, but I could see how the narrative got born.
Doug GregorYeah, I I I think to that partly this is a the perfect is the enemy of the good. Right. Right, right. Because for the vast majority of generic code you write, the separate type checking that C concepts had would probably work. And the vast majority of like template instantiation backtraces that you get from something blowing up deep in the stack would have gone away. Because partial specializations, you could do them. We have them in some obvious places, but you know, vector bool sticks out because it's kind of the only weird one in the entire standard library.
Doug GregorRight. And most programmers don't do this, they have the one definition and they use it. And so I think the benefits would have been common. Template instantiation backtraces would have become a very rare thing. Possibly made even rarer once people embrace the notion of, well, I'm using concepts, I'm getting all these benefits from it. I would have to give those up to do partial specialization here. I'll find another way.
BryceAnd it's the it's those back tra those instantiation backtraces is really the root of all of the problematic diagnostics that we have. Um the separate checking, I think, um uh would have eliminated much of much of that pain and suffering that we experience today. And uh and I mean you you make a good point that the failure mode of uh uh of the checking that you just described is not one of uh uh you know you get bad code or a program that does quirky things.
BryceIt's simply that the failure happens at a different point in the compilation uh process and that you maybe get a worse diagnostic, which seems very, very tolerable to me. Yeah. And and so um so what happened after C11, um, so it's it's it sounds like, in and if I remember the history more or less correctly, um, and based on uh the the snippet I wrote you from read you from iso cpp.org, um which for for for anybody who may have influenced, that probably needs to be uh uh updated or that page can be deleted because it seems like it was written in like 2012 and talks about uh things that have already happened.
BryceBut um it sounds like the it wasn't just that the decision was made to take it out of C OX, but that the committee was like we want to do something different. And and uh that that they rejected the design and it wasn't like we're gonna take it out and come back to it. It's like we're gonna take it out and we're gonna do this concepts light thing. Is that more or less correct? Or was there ever was there ever really an effort after C OX to um uh to move forward with the C OX model?
Doug GregorSo I don't think it's reasonable to characterize it as the committee giving that level of direction. You know, the committee decided to remove it from C OX based on these concerns. I think what really happened is the people that were pushing for C OX concepts, like myself, I'm first author on pretty much every one of these papers that I talked about, weren't interested in pursuing it further after it got removed. Um, you know, from personal history standpoint, Connor gave a pretty good approximation, but you know, by this time, I had joined Apple to work on this thing called Clang, which was barely a C parser with no code generation at the time I joined Apple.
Doug GregorAnd my my mission was go make it a good C compiler. And that is what I worked on. So I got to implement overloading and templates and initialization and everything. But the the idea of going back and revisiting C OX concepts was not terribly appealing at the time. And, you know, just a handful of years later, Clang was succeeding. We were rolling it out through Apple's ecosystem, and Google picked it up and was doing tons of work with it.
Doug GregorUh, we made the decision to start working on Swift, a new language.
BryceRight. And and uh and so uh uh at some point the uh a different group of people started working on the Concepts Light uh uh model. Um well let me ask you this. Um so I I'm just assuming that you were uh a a strong there's five different ways of voting on things. Um I'm assuming you were a strong against on on removing C O X concepts from uh and the the reason I ask is that is that sometimes with you know big controversial features like this, sometimes the authors decide like, yeah, okay, um we should take more time on this.
BryceAnd so sometimes the answer isn't isn't that the author is opposed to this, but I had a feeling that in this case, no, you've you you thought we should have shipped it.
Doug GregorI thought we should have shipped it. Yeah. I thought we I thought it was a very good model. All all the programming we have done with that model at the time of updating the various algorithms to use it and playing around with like the Boost Graph library conceptified were very positive. It was a very nice model to work with. Since then, we took something very much like that model, and it became the Swift Generic System, where we got to clean up even more rough edges, and it's a wonderful model to work with. I think we should have shipped it, and any issues we could have ironed out uh over time if if that was needed.
Doug GregorSo yeah, I was strongly against. I also had decided that if I lost the vote, I wouldn't come back with concepts, even though I was still working on C full-time as a professional compiler developer for several years after that.
BryceUm do you think it do you think C would have ended up any better positioned if concepts had if C OX concepts had shipped in uh uh in 11?
Doug GregorA better position with respect to what?
BryceUm uh with respect to uh sort of the next generation systems programming languages and like overall trends of the day and the the general um you'd look at C's evolution versus um uh other languages, and it's maybe not moving quite as fast. Um uh it's not you know it had this resurgence after C11, but um uh do you do you think that the the landscape of programming languages or the popularity of C would be drastically different today if we'd shipped concepts in 11?
Doug GregorI don't expect it would be drastically different. I I mean I do think that the newer languages have generic systems that were possibly inspired by C OX concepts and do a lot of the things that it did well. Like it is easier to write generic code in a language that has separate type checking for its generics. And a number of languages have proven this out for us. In that regard, yes, C ⁇ would have been in a better place. But it seems like right now, you know, the concern around C is really around memory safety.
Doug GregorAnd concepts would have done nothing there. Nothing at all. Yeah. Right.
BryceBut I but I um, you know, a lot of the a lot of the primaries that um spent 10 years of their lives or 10 plus years of their lives working on concepts um are the same people who are the primaries on the C ⁇ contracts efforts and the same people who are the the people who think about safety in C ⁇ . And so I wonder if if concepts had shipped in 11, maybe their efforts would have switched to modules and contracts earlier.
BryceMaybe we would have gotten something like contracts in a like by now, and maybe C would be in a better place. Uh maybe we would have been better positioned to respond to the growing need for memory safety than than we are instead of this uh this long redesign effort and then missing 17 and barely making it into 20.
ConorThis is actually a it's a you know parallel universe mental exercise. But it is, I understand what Bryce is saying. Like it's it's also I you haven't explicitly used these words, but it does seem like out of C OX failing to get in. And I also, on a side thought, on a little tangent, when you were talking about all this, it does strike me as unique to the C OX story of being kind of voted out. I don't know of any other proposal, because there's been others like contracts that were, you know, 11th hour going in and then there was a vote and they weren't, that required uh an immense amount of work to kind of um back out all of these changes that had been made to the standard library.
ConorLike I don't I don't know of any other proposal that necessitated that. And I think that that's actually like a unique property to this is that if it had just been, okay, we're not gonna put this in, but it doesn't necessitate a bunch of work, there's gonna be less like fallout. And that kind of ends the tangent to me, adding to what Bryce was saying, is that like I don't think it was just I don't want to you know throw people's names out there, but definitely there was more that it was more than just you, Doug, that left sort of the C initiative. And like you said, you were still working on C, you just didn't have the the desire to um go and go back to the committee with this.
ConorAnd then eventually, you know, another opportunity arose with a brand new language that you know obviously a colleague of yours, uh Chris, was working on, and uh, and then you know, Dave Abrahams as well uh joined sort of that. And so then you've got this all-star cast. A lot of who you know used to spend a lot of time and energy working on C. So it is it is interesting to think like, what if concepts went in in 11 in the form that they were initially proposed? A bunch of energy wasn't spent on, you know, the next decade getting it into C20.
ConorAnd on top of that, the folks that are now working on other things that used to work on C, what if they were still there? Like the combination of the time and energy spent on an extra decade getting concepts in, if that was able to be put towards something else, and the people that were a part of C back then, you know, it's it's all just gonna like, we don't live in that world. So, you know, it's more of a fun exercise than it is actually like nothing's gonna come of uh of thinking what what could have happened in this parallel universe. But it it's the same thing when I like, what if what if Bill Gates had implemented uh, you know, his APL interpreter and put it on the PC?
ConorWe'd be living in this world where you know every language was inspired by APL and not basic. You know, we don't live in that world, but it is fun to think about what would have happened if that was the decision Bill Gates made.
BryceUh Microsoft, Microsoft would have been bankrupt. Sorry, Connor.
ConorWe'll never know.
BryceSo one one of the reasons that I that I mentioned is hypothetical is so uh C11 uh went long uh because it was a feature-based release, not a schedule-based release. After C11, uh, you know, famously called C O X because they expected it to ship in the earlier decade. Um and it was a feature-based release, which means that we did we said these are the things we want to ship, and we'll ship the standard when those things are ready. And after that, we moved to a schedule-based release where we shipped every three years. And I'll I'll I'll read again. I my my reading of that quote from isoccpp.org was very intentional earlier.
BryceThe last part of that was and a radically simplified version, concepts light, will be part of the C 14 wave of deliverables as a technical specification. So after C11, we did a few things. We moved to this schedule-based cycle of releasing every three years, and we got all excited about technical specifications. And we also, this was the uh the big library era where we put out a call that we want a giant standard library. Everybody come bring your proposals to the committee. Um, and that period from like 2011 to 20 uh 16 or 17 was sort of like this this C renaissance, um, where the committee uh you know called it grew orders of max order of magnitude and size.
BryceC became very popular because C11 had all these new features in it. Um the committee was inundated with proposals. Um uh and uh we started shipping all these technical specifications, and a lot of good things came out of that that era. Um, but uh that era I think was also um uh uh a defining characteristic of that that era was unchecked enthusiasm. Um and and uh and it was followed by the uh what I like to call like the era of small library, um, which was the like post-C17 um uh period where the committee had like a two-year backlog on processing things and features missed that kept missing the boat.
BryceUm, and we spent tons of time on technical specifications that we shipped that nobody really implemented, and we never really got the field experience that we wanted from technical specifications, and they just became a way to fast track forcing your thing into the standard. Um and it took us a while after C11 to learn uh like what's a good cadence for us to ship at, and like how should we prioritize and focus on things. And I'm not claiming that the committee's figuring.
BryceThat out yet, because I I still have said many times in this podcast, I don't think we have a good uh evolution model. Um, but uh we certainly have a better evolution model today than we had in that period of time. Um and one characteristic of that is that you know we we didn't ship concepts in OX, we did, and then we didn't ship it in 14, and then we didn't ship it in 17, and then we just barely shipped it in 20. Um and uh uh that you know additional decade um was really unfortunate uh for C.
BryceUm I mean the the schedule-based release cycle was really great. It it's been one of the things that has saved C ⁇ . Um uh one of the the the the you know the great innovations that Herb uh has has brought to the process was that. Um but uh the the period of time that it took for the committee to adapt to that and that sort of unchecked enthusiasm uh really did hurt us in in some ways.
BryceUm and I don't I don't think that uh uh it it needed to take that long uh to ship it. Like I don't think that the concepts needed to go to a TS. Um uh I think if like we concepts like could have been done and shipped it, like if we were doing it today, uh I think we would have shipped done it and shipped it in 14 or 17 um and and not in 20. Um But yeah, it it's an interesting hypothetical that like like as we said before, like the the perfect is the enemy of the good.
BryceI think C would have been far better off if we just shipped um OX concepts and moved on to do other things because we had a lot of other work to be doing. Um uh and um I also think the the feature that we got um is so watered down um that it doesn't feel like it was worth the energy that we invested in it. Um and like I I guess I I would have been willing for the committee to have spent the amount of time that it did on concepts if we'd got something closer to C OX concepts.
BryceUh but because we got something that doesn't really give me much of what I want, um, and I think has a syntax that's far harder for me to understand and teach to people, and that makes me just want to avoid the feature other than just as a fancy form of Sphin. Um and I don't get any of the diagnostic or checking benefits out of it, it it doesn't feel like it was a good use of the time. And and that's unfortunate because I do think that C really could have benefited from a proper generic programming interface.
BryceYeah.
ConorI don't know how many questions were in the last like 15 minutes of Bryce then me then Bryce, but I feel like we should let Doug respond to whatever questions you do recall from the last 15 minutes.
Doug GregorUh I'm not even sure where to pick up the thread here. So I I certainly agree with you that given all of the time that was spent on concepts, what we got I think is a little un is unfortunate. I was rereading the 2003 paper to see what our goals were. And separate type checking is the one goal. That is the one thing that if we had it, you could even throw out concept maps. If you had separate type checking, it would have made generic programming in C an order of magnitude easier.
BryceYeah.
Doug GregorRight? It would no longer be the domain of experts to use templates and use them well. It would be something that every programmer just does because they need the abstraction. And we have seen it work in other languages, and it it could have been there in C. And whether it still can be, I was I was thinking about this is can it still be fixed? And it depends. It's an interesting question of whether the whether it can. So uh I did actually write a paper 10 years ago. It was my my last attempt at trying to get separate type checking into concepts light that said basically take the concepts and your constraints, generate some archetypes from them, and try to instantiate the template.
Doug GregorAnd if it fails, show the error messages. So that the I don't know, this archetypes thing came out of uh a boost, boost concept checked library. I should explain that.
BryceI was about to say, because there were two there were two things that we haven't covered yet, and it was archetypes and uh uh axioms, and maybe archetypes is a good thing to start with.
Doug GregorArchetypes is a good one. So an archetype is essentially a fresh concrete type, and the only operations that are on that concrete type are the operations that are explained by the concept requirements for it. So if you were to say, hey, I have an algorithm that takes an arbitrary container, and that element is uh equatable. Now, you could create an archetype for the container that is just a plain old class, has no state, has no operations other than what the container type says it needs.
Doug GregorSo it needs to have a begin and an end, maybe. Let's keep this simple. So it has begin and end, those return iterators. It creates a fresh archetype for an iterator. What's that? Well, it has the dereference operator, the plus plus operator, it's equatable. And so you build this little set of types that are completely minimal. They only match the requirements that are placed in the requires clause for that one specific constrained template. Now, when you go, then you go try to instantiate the template with those archetypes.
Doug GregorIf your template definition is good, if it's only using the operations that are specified in your requirements, and it's only calling into other templates that have the same set of requirements or a subset of them, then your instantiation will succeed. Great. You have now separately type checked your template definition. The reason I propose this is it is a reasonable simplification to the C OX model. It takes away all of the nice things that you get out of concept maps, for sure.
Doug GregorRight. You can no longer do cool remapping syntax to say, ooh, you know, I can I can make the matrix type from this library work as a graph type for this library, right? Which is my favorite example of cool things you can do with concept maps. You don't get to do any of the fancy things, but you get separate type checking. You get the simplification that comes from having separate type checking. And it's a lot easier to specify and implement because all you have to say is how do I map the requirements of my concept over to an archetype? And that's a mechanical translation. It's a little easier with pseudo-signatures than it is with uh usage patterns, but like we could define what it means for usage patterns.
Doug GregorSo maybe that model, maybe you could retrofit that. It's hard. You would break all the code that uh has concepts now, because I guarantee you nearly all of it has some subtle bug. Every template definition that has a concept constraint on it has a subtle bug. But you could possibly get to that model where you have separate type checking in a in a much more limited form.
BryceYeah. Sadly, I think that that ship has sailed. Um but uh oh, axioms. You should uh you should explain the axioms.
Doug GregorAxioms, yes. Uh axioms were a feature in the C Ox concepts design that essentially uh the idea was you could describe semantic constraints on your concepts. And so this might be things like, for example, uh if you have an equatable concept, right? Let's you just compare two t's whether they're equal, you would have an axiom inside that concept that said, well, if you have a value x, x is equal to x.
Doug GregorAnd if you have two values, x and y, then x equals equals y is equivalent to y equals equals x. The standard standard properties you'd expect. You also have the transitive property that's you know, x is y and y is z, therefore x is equal to z. And in C concepts, you could actually write axiom, it was a new keyword, and write out these semantic properties. The uh the idea and the hope behind uh axioms is that this would provide valuable information to both users to understand what their types need to do to actually conform to the concept, and that it could be used by static checkers and optimizers and so on to go and make sure that the code was more correct or to improve performance by letting you do high-level optimizations.
BryceIt was almost uh uh in the family of things that contracts might be in.
Doug GregorYes, absolutely.
BryceYeah. Because one one perhaps important thing that uh that uh wasn't captured. I don't know if we've captured thus far, is that um concepts have both syntactic and semantic requirements. And the language feature that we have today can only check the syntactic requirements. But that does not mean that the semantic requirements are not important. Like we talked a little bit before about like, you know, the uh the view concept is something that has uh semantic requirements that are very important, like that it has 01 uh, you know, uh copying um and a bunch of other operations have important uh complexity requirements that essentially mean that these things are cheap to copy around and to pass around.
BryceUm and that's what like that's what distinguishes a view from a range. And that's not something that we can syntactically um uh uh distinguish. And that's why you have to opt in, your your range has to opt into being a view using some trait. Um yeah, i i I do it does amuse me the how frequently I see people having to define C20 concepts um using some trait mechanism or uh just using like uh the new things like alias templates.
BryceThere's a bunch of I just saw a talk the other day by Gaspar where he was showing some trick using some alias templates to define a concept or the concepts that have to be defined in terms of type traits. Um uh surely a a true sign of our success.
Doug GregorAaron Powell Traits have been used since the early STL as the way to opt into behavior and state, you know, this is what concept maps did. You can think of concept maps as essentially formalizing the notion of traits with some bells and whistles and actual language integration rather than being a specialization-based template trick.
BryceAaron Powell Right. And so for anybody who might be thinking like, oh, this concept map thing sounds heavy-handed, like I don't have to want to like like with the concepts we have, we don't have to explicitly opt into um to things. Well, you know, you look at how many concepts are written in a lot of libraries, there are still a lot of cases where you have to explicitly opt into something. There's just no formalized way to do it. Concepts maps would have given us that, and with the auto concepts, uh, you would have gotten all of the implicitness that you want.
ConorBe sure to check these show notes either in your podcast app or at adsphepodcast.com for links to anything we mentioned in today's episode, as well as a link to a GitHub discussion where you can leave thoughts, comments, and questions. Thanks for listening. We hope you enjoyed and have a great day.
BryceLow quality, high quality, that is the tagline of our podcast.
ConorIt'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:...