Skip to content
491: Influences that shaped our thinking episode artwork

Jan 27, 2026 40 min

491: Influences that shaped our thinking

from The Bike Shed Hosted by thoughtbot

Joël and Aji reference their personal bibliographies as they compare the different influences that have shaped their programmer world view. Our hosts discuss their most influential programming material, from books, talks and video, and how it’s impacted the way they write code, Joël hones in on the importance of confidence and dealing with uncertainty of objects in a project, while Aji dips into his knowledge of RailConf talks to find his biggest inspiration. — Take a leaf out of our hosts book and discover some of the material that influenced them and their work for yourself - POODR - Confident Ruby - RailsConf 2014 Talk - Take Smart Notes - Working Effectively with Legacy Code Your hosts for this episode have been thoughtbot’s own Joël Quenneville and Aji Slater. If you would like to support the show, head over to our GitHub page, or check out our website. Got a question or comment about the show? Why not write to our hosts: [email protected] This has been a thoughtbot podcast. Stay up to date by following us on social media - YouTube - LinkedIn - Mastodon - BlueSky © 2026 thoughtbot, inc.

Episode details come from the podcast's RSS feed.

Embed this episode

Ready to play

491: Influences that shaped our thinking

0:00 40:16
of matches

Transcript Auto-generated, may contain errors

Hello and welcome to another episode of the Bike Shadow weekly podcast from your friends at Thoughtpond about developing great software. I'm Ajis later. And I'm Joel Kimville. And together we're here to share a bit of what we've learned along the way. So Joel, what's new in your world?

Long time fans of the show will know that in addition to being a software nerd, I am also a bit of a D&D nerd and have a lot of fun playing colleagues and friends on a pre-regular basis. And recently, a group of friends have gotten me to try a different tabletop RPG system, one that's based off of the novels of Brandon Sanderson. Amazing. I'm a really big Brandon Sanderson and Kazmier fan myself. How's that experience been for you?

It's interesting because my friends are big into the books and know all the lore in the backstory. I have not read any of the books. So I'm really figuring out the mechanics and things and I'll do some small mechanical thing and then they're like, oh, that's so cool because it's like this thing in the book or it's like this character. And I have no clue. I've been looking at that and trying to drum up some people who are interested in playing.

And that was something that I was a little concerned about. Someone coming into this world and not knowing any of the lore. So it's still been fun for you and it's been easy to dive into even without being steeped in the stories. Yeah. Yeah.

I was taking some getting set up with the DM to make sure that my backstory is sort of kind of consistent. I do think that the system is a little bit more tied narratively to the world. I feel like D&D, you know, a few fantasy tropes and you can just sort of get going. You're like, oh, yeah, I'm an elf and I do magic. And I don't know.

My parents were killed at birth and now I'm in orphan traveling the world being awesome. I don't know. You throw a few tropes out and that's your story and you can just roll with it. Because this one, you have to be a little bit more tied into the world. What's been interesting for me is learning a whole new 2D RPG system.

And while there are things that are similar, like rolling a 20-sided die and adding a modifier to it, there are a lot of things that are different. And learning the implications of that, not just for play, but also for character design, has been interesting. And it feels a little bit to me like learning a new programming language where all of a sudden you know some things, you know how to do loops, you know how to do conditionals. But maybe they're done a little bit differently in this language and there might be some implications to the choices that you don't realize that you're like, oh, but in this language, if you do this thing, it will have very different effects. Right?

So I feel like a very similar journey to that. Yeah. Yeah, it's a really understandable feeling. I've thought often about when I'm writing the language that isn't something I'm really steeped in, I find myself thinking about is this the idiomatic way in this language? Is this something that people who are in this language a lot would think is completely backwards or anything like that?

And I could see how that's really similar to the idea of either being in a situation where you've done something and not knowing the reference that you've just stepped upon for the RPG or having to do maybe a little bit of extra work, like getting together with the DM2, see how well the way that you want to play kind of aligns and that sort of thing. That's really interesting. Have you ever had to pick up a new game system? And if so, are there strategies you've found have been helpful for you? I've kind of had to go in the other way because a system that I picked up really early and love playing with and have had to introduce other people to is Shadowrun.

And it is by far my favorite fantasy world universe setting. And it sort of throws together Cyberpunk and that kind of Tolkienesque generic fantasy of elves and magic and things like that. And there is a little bit of kind of knowing the world a little beforehand or kind of getting the gist of the setting going in that I usually have tried to find a couple of short stories or just a couple of page descriptions of the world and kind of giving them a little bit as homework in a way beforehand, but trying to keep it light and just be like, hey, read this and you'll get kind of the feeling of what this setting is before we get started.

And that's been really helpful to kind of convey because it's not necessarily so important that you get the, you know, all of the history of this world or anything like that. But if you get the vibe and you get the kind of story that this system tells well and kind of lends itself to a cross, then I find playing it can be a lot easier. The mechanics are really different from something like Dungeons and Dragons. So there's always a lot of stumbling over that and helping each other through in the very beginning. But yeah, I think most of the other systems I've played are pretty similar to D&D.

So there hasn't been too much of a learning curve there. So what has been you in your world? A little bit along the same lines about gaming and how these kind of things relate to our work. I am reading a book called Blood, Sweat and Pixels by Jason Schreier. The triumphant turbulent stories behind how video games are made.

And I am really continuously struck by the differences in the approach to work that kind of on the surface, it is similar enough to what we do. You are putting code, you're building a project with people, you are working cross disciplines and you have a very large task and disparate team working towards this goal, right? But the kind of constraints and requirements being so different lead to a very, very different approach to work. And there is kind of a glorification of crunch in that industry and different things like that.

So it's fascinating because I do really like hearing processes and stories and experiences quote unquote from the trenches. Really in any industry, but this one because I really enjoy video games and it is so similar in a lot of ways to what we do. But it really reinforces to me that that is not an industry that I really want to work in because it doesn't mesh with the way that I want to live in relationship to my work. Yeah, yeah, I think for a lot of developers, building a game is a bit of a dream and that there's a strong pull towards the games industry. And from what I hear though, that is maybe a little bit exploited where it's a you get to do fun things for work.

So you can totally work more hours and that's fine or we'll pay you less than you would doing more boring corporate stuff because you're doing games. So you should be happy to work more for less or do a lot of crunch time. Yeah, yeah, for sure. I think there are definitely places that will take advantage of that. And I think there are situations where the team involved doesn't necessarily feel like they're being taken advantage of, even if from the outside observer that might be how we interpret it.

But there are certainly a lot of companies that are people who come together and are aligned on the way that they want to work to and are maybe built a little more equitably. But yeah, I think it very easily trips into that sort of exploitive role. I know that there's been a lot in the news lately. There's a local game company here in Edinburgh that has had some strife back and forth with unionizing their employees and things like that. So it is a heightened relationship with your work because you're making an art form that you generally have a lot of strong passionate love or good feelings for.

And then you still have to deliver a thing for money and these other restrictions are going to run headlong into that all the time. So yeah, it leads to some extreme moments sometimes is what it seems like. Do you ever watch the YouTube channel Extra Credits? I do. I love that channel.

For those who haven't seen them, this is a channel on YouTube where they talk about a lot of things around creating video games. A lot of their content is more on the design side of things, talking about mechanics, things like that. But they also talk about the process of building and what the life of being a game developer can be. And so that's also a fascinating window. They also have a spinoff where they do historical stuff, which is my personal entrance into their world.

And they're like, oh, they also do gaming stuff. That's fun. Extra history. The name of that. My nighttime wind down YouTube channel as of late.

So one of these days, maybe we should do an episode where we compare the educational, like educational YouTube channels that we watch. I imagine a lot of overlap and a lot that we take away and informs our worldview of how we work and things like that. It's diff the two subscription lists or something. Yeah. I guess that probably shapes a lot of the worldview that we have around broader topics.

But what about more on the professional side? Are there any particular works that have influenced you disproportionately in the way that you think about writing software? Well, I think probably just to get it out there and maybe get it out of the way, if this is a topic that we're going to be talking about, practical objects oriented to design in Ruby has got to be really high up there for I know myself and probably a lot of other folks who write Ruby themselves often gets recommended as one of the first books that if you're getting into Ruby that gets thrown out there, not sure if it's great when you're just getting into Ruby because it does kind of start at a really high level or not high level.

It gets in there really quickly. But yeah, yeah. Is that near the top of your list too, if you would have to come up with one? I have not read that book. Whoa.

I need to. Okay. Wow. This is I did not expect this right off the top here. Okay.

That said, Sandy Matt's the author, great communicator on a lot of object oriented topics. I've watched several great talks from her at various conferences over the years. I'm a huge fan of her material. Absolutely. I just haven't read this book in particular.

Okay. That's really interesting. What would you say is the maybe one or two big ideas from that book that has maybe shaped the way you think about how you write Ruby in the years after you've read that book? Yeah, I think it really underpins my thinking of structuring classes, objects, instances, just that really OO fundamentals of having small little objects sending messages. That's a big one, the idea of sending messages between different collaborators in your architecture and kind of the makeup of your software.

It really has kind of settled in as a really a foundational aspect of my, as we've been saying in my world view of how these systems are made, the mental model and framework of what this text is doing as a system that operates is really kind of informed by my experience and all these different things. But that is shaped around the models that the book has given me about object oriented software and kind of the metaphors involved. I do feel that for as much as we like to talk about object oriented software as an industry, we're pretty bad at it. There's very much a pull towards like, yeah, but what if we didn't do that and just made this into a giant procedure and invoke that?

I don't know if that's just the natural way of thinking. Is it because procedural is the way that you're sort of first taught to code? But you see that even with things like service objects in Rails projects. It's the moment you need something that's not going to be just a controller action or a basic model database interaction. People just want to say, eh, what's the model of the arbitrary code wrapping in a class and call it a day?

Yeah. I think the way that Sandy breaks down some problems or some kind of approaches in Pooter could really help sort of inform how to break those things apart and how to make it a little bit more easy to reason about how an object oriented system can not only sort of make your life a little easier when you're doing that sort of thing and give you the reasons why you might want to put in what effort is going to feel like a little extra effort to do something in object oriented way as opposed to just writing something very procedurally that it can be really instructive or really eye opening about the sort of missed opportunities if you're not at least thinking a little bit about the way that the language Ruby kind of thinks about how to do these things too.

Right. Because if not just dive into O theory, it's also very grounded and then also very much tied to Ruby's flavor of OO. Yeah. Yeah, it is. It's right there in the title, right?

It's object oriented design in Ruby. So you can take away a lot of how object oriented systems are meant to be built and all those kind of abstractable away from Ruby ideas, but it is done through Ruby as the medium. So if you haven't read the Pooter Practical Object Oriented Design in Ruby, do you have something that you would put at the top of that list that would be a core to your programmer world view? I think I have something that functions a little bit like maybe what Pooter does for you and that's the Design Patterns in Ruby book. I think sort of helped ground a lot of my sort of OO thinking working with objects.

In terms of I think having a big impact in the way that I think about writing code, I might not lean into so much of the OO side of things and instead pick Avdi Grem's confident Ruby thinking a little bit more in terms of how to deal with nil values, how to deal with uncertainty. There are a lot of ideas there that I think were interesting when I read the book and I maybe didn't quite grasp all of them. And then later on when I started learning Elm and was digging into a lot of sort of statically type things where the compiler would just really get on my case when I had all these unhandled effectively nills.

And then all this I was like, oh, all these ideas from that can apply here because the compiler forced me to address those issues. And then having had to do it explicitly in a type language going back to Ruby and being like, oh, now I can I really get what Avdi was trying to say here. So I think it was a little bit of a multi-phase thing for me. There's an initial of like, oh, yeah, these are some good ideas that improves my code. And then going to another language, it helped me with this other language and then coming back, I really leveled up.

That's really interesting. It's a little bit, it makes me think of how learning another human spoken language can really inform your understanding of your native language that maybe just comes more natural to you. I don't know if Ruby was your first language or anything like that, but I've done a few before that. I've done some PHP, I've done a little bit of JavaScript. I've done some C++, a lot of sort of C-style languages.

So Ruby's very almost like literate programming approach was very new to me. The fact that you didn't have to do a for loop to iterate through collections was mind-blowing, seeing each for the first time, not having to worry about tracking indexes and all the off-by-one errors that Junior Joel was getting burned with a lot. I was like, oh, that's really nice. Was there anything you mentioned checking for nil values? Were there any other patterns or what was it about maybe checking for nil values that you took away from Confident Ruby?

I think the biggest idea I took away from Confident Ruby is push uncertainty to the edges. Uncertainty can have a few different sources, but a lot of uncertainty comes from outside your program. User input, other APIs, even talking to the operating system. All information that comes from outside your system, which may or may not be present or might be formatted wrong or all these things. And if you sort of let that potentially bad data just move throughout the entire program and everybody has to always be checking, oh, do I have good data, it turns into a mess.

And so writing codes so that the edges of your system check for uncertainty and then everything beyond that can more or less assume that things are present is I think a really powerful way to code. And it's sometimes not as obvious as you would think. How so? What is in in City As Way that can kind of slip by? I think oftentimes there are things that we think of maybe not necessarily as inputs, so things like relying on the system clock or relying on any form of randomness.

Those things have different values all the time and might behave in unexpected ways. And oftentimes it can make your code easier to write, easier to handle certain types of edge cases. If you take the sort of weird bits of those, the actually generating the random value or the interacting with system clock, pull them out of your object and pass that in separately. I also do this a lot with the HTTP because that can fail and you have no response body and now you have a null and you have to handle things like that. If I'm interacting with a third party service, I often like to have a separate object that deals with just handling HTTP and then a separate object that will handle more of the domain stuff.

Separating the responsibilities between handling that uncertainty and dealing with that uncertainty versus moving forward with the domain work after that uncertainty has been figured out by someone else. Correct. So I think that, and this is not a certainty that will come from within your program where you just do a thing that will potentially be uncertain and there's no good way to push that out to the edges. But oftentimes there is, and sometimes when you start pushing that uncertainty to the edges, you start realizing, oh, there are interesting objects that we're hiding here. Maybe the sort of object that was trying to do it all has multiple responsibilities and by separating things out, now I see that there are actually two different things.

In my HTTP example, I often like to split things into what I call a client and a driver, or the client is all about more of the domain specific things and the driver is about the network layer and handling the HTTP. And when you compose them in theory, you could then swap things out so that maybe you use a different driver for a different type of interaction. Maybe you're reading from a cache or from a file or something rather than over the network, but all the domain stuff stays the same. It doesn't care whether you fetch it over the network or fetch it from a cache or fetch it from a database record or something like that. And so now all of a sudden you have this sort of clear separation of what can change and what stays the same.

And that design emerged from just wanting to keep some of that uncertainty separate from the things that are certain. I can't remember if it's talked to in sort of those terms, but I think that's something that comes up a lot in pewter is encapsulating those things that can change or can't be relied on in the same way that not even necessarily the domain logic and things that are written for your program, but even things that are core to a language or anything like that being aware of how much change is going to happen or is possible in a certain slice that you're paying attention to. And if there are different levels of change that might occur to a certain part of a system, making sure that those sections stick together with other parts that might change for the same reason, might change with the same frequency, and as a little bit of encapsulating that uncertainty not only in what data there is, but also uncertainty of the stability of a certain object or process.

Yeah, so there's an encapsulation bit and then there's the almost a cohesion part. The things that change for the same reasons should be together and the things that change for different reasons maybe should be apart. I think this sort of thinking, and again, I think some of this is sort of pure off-degree and then some of this is also my own thinking as I've gotten into more functional programming, but the two really mesh nicely has really impacted the way I think about conditional code. And I think of way that this is founded expression, maybe most darkly for me is dealing with multi-step forms, wizards. A common way that I'll see is, let's say you have a rails happen in multi-step form and they all are submitting the same controller action.

It just has a bunch of independent conditionals that say, if this field is present in the params, do this thing, then keep going. If this field is present in the params, do this thing. And you can't tell by just reading the code what step you're on or what bundle of fields go together because it's just a bunch of conditional things that might happen, some of which might happen on multiple steps because all of these conditionals can compound with each other. So what I've tended to do is to sort of try to push decisions conditionally further up to the top of the decision tree and say, let's group all these things by condition. And so what I often end up with is a sort of a flat case expression that just says, if you are on step one, do thing two, thing three, thing four, if you're on step two, do a different set of steps.

And then branches can share code. You can extract private methods and things. Now you can see the structure of the behavior just by looking at the code. And that's the thing where I've had to do that at kind of a surprising amount of times. I wasn't a project once that had, this has gotten out of control and it was the scary part of the code that no one wanted to touch.

And then one day someone was like, hey Joe, well you're the consultant here. Why don't you go fix our multi-step form thing? Because we need to add more code there and it's kind of impossible to add new steps to it. And I was like, all right. I sat down and started refactoring and applying some of these principles.

I was like, oh, you know what? I think it's a pattern here. I've done this a few times and sort of always maybe not seeing the bigger picture. Just being like, oh, this is sort of how it feels right. And based on these principles.

And I think after that time in particular, I sat back and introspected a little bit more. And I was like, oh, I think there's a pattern now in the way I like to refactor multi-step forms in particular influenced by all of these other ideas. Yeah. So I think that the edge of the, this phrase pushing and certain to the edges, and it doesn't necessarily have to be the edge of your software completely. It can be the edge of your focus, right?

Of the, this can be an interface wizard. Yeah. So it could be the edges of your object, if that's sort of the abstraction you're working with. It could be the edges of the subsystem. Yeah.

It's great that the edges can stand in as a, as a phrase or as an identifier for this process at a lot of different levels. Yeah. And I guess, you know, it's a sort of phrase that sounds really simple. But once you add a little bit of nuance to all of the pieces, like what is uncertainty? Is it just nulls?

Is it exceptions and errors? Is it weirdly shaped data, is it validation? All these things, you might want to explore and figure out how you handle those as they come into your system. Like you said, edges is also something interesting. It doesn't have to be your system.

And maybe now that forces you to think about what are the boundaries of this, do I need to encapsulate better? Do I need to make a boundary between these two parts of my system? Do I need to split something into two objects? And so it's the kind of thing that I think can get really profound. I think uncertainty can also find its way outside of what to go with the ones and zeros and can also be the parts of the project that are most influx.

They are where you have most questions about requirements or like needs from a user base and thinking about how you can sort of protect those unknowns from getting into the parts that are sort of solid and, you know, are probably going to be sticking around for a lot longer than those uncertain things so that you can keep those designs able to change while not having to open up the gods and change something that should or could be a lot more stable and not need as much churn. Yeah. So at that point, now you're talking about like churn and complexity and some of those ideas as well. I want to say the idea of like foregrounding churn as a thing to think about, is that from the working effectively with legacy code book?

I don't think I read that one. I've not read it either. I've just heard it quoted a lot. Well, I had that to our reading lists. I always like hearing those from different folks of what sort of shaped their sort of worldview and what books and resources have stuck with them and had an impact because those are the ones that I want to kind of go seek out, right?

If they have had a lasting and inspired some ideas that people have carried through a career, right, as opposed to just being something about a particular technology or something that's going to, you know, not be viable next year, next month. Because we carry, you know, all these ideas from our previous languages, previous projects, previous life experiences into our next projects and those shape how we approach the way we code. So you've talked about a bunch of books. I know that you recently watched every RailsCon keynote. I can't escape it.

Yep. Before you'd watch it, because now you've seen them all and those probably are going to influence you moving forward. So prior to that, had you seen a conference talk keynote or not that you felt really shaped your thinking as a developer? I think it was a Sandy Metz talk, actually. I think it was called All the Little Things.

I always want to call it All the Small Things, but that's the Blink-182 Lyric is going through a basically a code cotta and kind of refactoring and thinking about and turning it into a more object-oriented implementation. I think because it gave sort of live examples of the things that had been sort of percolating because of practical object-oriented design and Ruby in much the same way you were experiencing some thoughts and then having a different experience with Elm, like my seeing this in a different kind of medium or whatever sort of help crystallize and align some of the concepts that were maybe a little more nebulous for me after reading a book.

Yeah, I think I'm very Sandy Metz-coded, if anything. This one was not a keynote, right? It was not. Yeah, I didn't watch that one live either. I think it was RailsConf, maybe Atlanta, something like that, but no, it was not one of the keynotes.

I mean, Sandy is a phenomenal speaker. Absolutely. If you get a chance to hear her speak, it's absolutely worth it. 100% could not agree more. But by yourself, is there something that isn't to be a book or?

Well, I know actually you recently did an exercise that was kind of similar for a conference talk to me that you looked at influential blog posts kind of along the history of Rails. Is there any short form reading that has contributed to your worldview or maybe that you knew that you were going to bring this one blog post into it because it meant so much to you? I think when talking about Rails, the one that from that list of the talk that I gave that I already knew from the beginning, that's going to be on the list, is the Code Climate Seven Patterns for Refactoring Active Record Models. This is a hugely influential at the time. I think in that sort of vein of like, let's think about things in a more 00A, got people to maybe rethink a little bit of how they want to destruct your code within a Rails app.

That said, I think if I look more holistically over my career, I think it's probably a toss up between a couple of articles. One is Constructive versus Predicated Data by Hillel Wayne, which sort of talks about different ways of enforcing correctness in data. That's one where a contrast of two broad strategies, either designing data types that are sort of correct by construction. You can't even instantiate that object or create that database row if the data is invalid. Or maybe the structure allows invalid values, but you have some sort of validation code that runs beforehand to prevent it from getting into that invalid state.

Both are valid approaches that have their strengths and weaknesses, so we talk a little bit about when one is better than the other. That's a pretty simple concept, but I think the more I find connections to all sorts of other parts of programming. And so I think that applies to the types versus tests debate. Tests are a bit more of a predicated approach. You have to sort of write this validation and then you run it against your code to make sure that it behaves correctly.

Whereas types, the compiler will just like start up failure if you write something that has the wrong structure. And they're not one with each other. There's some types of things that cannot be verified using types. You must use tests. But there are also some advantages to types and that they're in some ways almost free.

They can be a lot less work than writing tests for a lot of things, especially around things like handling nulls. But also you can code a lot more fancy things there. So it applies to that. It applies to think about database schemas. Do you want to enforce things at a schema level versus using maybe database triggers to banish things versus maybe using a Rails validation?

How important is it that the schema requires your data to be in a correct shape and that just anybody accessing the database will be guaranteed to have valid data? So a relatively simple idea that I think again has impacted how we think about a lot of different areas of software. Yeah, I think that's really kind of at the core of what this sort of conversation is about like what are different materials or influences that have implanted a little seed in your mind that you have then connected to your work in a lot of different places. Yeah, and it's the often times the connections that are more important. Yeah, yeah.

Sometimes you get like an idea and like the idea on the face of it is pretty simple or has like a very obvious application in one area. But then if you start making connections to that all sorts of other things, then the idea becomes really powerful because it's tightly connected and helps you navigate a lot of other topics. Even if it only makes sense for you, it doesn't have to be universally good, really like those connections make sense to everybody else. But as long as it makes sense for you and they help you make sense of other ideas and that is a really powerful idea. Yeah, I think it's like you're saying that it doesn't have to be necessarily universally applicable for everyone who reads the idea or comes across the idea but those connections and that web of how those different things are interconnected, what's involved, what connects to what is kind of your own personal, world view or approach at the end of the day.

And yours will be different from mine, different from everyone's. And then the in collaboration, finding more connections between those different webs is something that makes a team stronger, makes a product and work kind of flow better. And then of course, those moments where some of your connections overlap with someone and you can have that sort of shared language or a little bit of like shared thought almost can make for really satisfying moments in getting things done. Yeah. The finding that we both watch extra credits moment.

I think you're talking about the idea of a web and that I think was made much more concrete for me when I read the book, How to Take Smart Notes, which was sort of the genesis of me getting into the sort of zettled castany note-taking systems where you create effectively a web of ideas. And the book emphasizes that for this type of note, capturing information is not the value of a note-taking system like that. It's partly the processing, helping you to like think through ideas as you have to write them down and especially the connections. The web is what's important, not so much the individual pieces in it. Yeah, I haven't read that book in particular, but around the, you know, just want to fit one more little influence of mine in here because we haven't gone for a good time here.

That is sort of about working about thinking about things, but not maybe a programming book is the Checklist Manifesto by Atul Gawande was a surgeon that examined some other fields like flying, so pilots and sort of the processes that they used in bringing in the approach of Checklists into the operating theater and how that kind of revolutionized and really drastically affected the outcomes of surgical procedures. And that's another one that has kind of stuck in my head and I find myself looking for checklists, they're kind of looking for processes like that a lot.

So that's definitely another one that I think is really wedged into my brain. Have you ever heard of, I forget what this concept is called, but when you look at academic people who like write papers and you think it's a rebuild a web of their citations and then you can sort of figure out who they tend to cite a lot, I feel like that's a little bit what we're doing right here on our lives. Comparing our bibliographies. Yeah, that's a little bit what we're doing, right? And I think for people who have read a lot of the blog posts that I've written or maybe just long time listeners of the show, I've mentioned all of these things before.

You've heard me quote these books, these blog posts, these talks before, probably similarly for you for a lot of these things. Yeah, I was thinking if I should say it or not, but something that definitely shaped my programmer worldview is listening to the bike shed when I was a young early career developer. The first, I don't know, 200 episodes or so were my mentorship in a way, like hearing more experienced developers talk about things that were way over my head at the time, but just by kind of being adjacent to those ideas and those words and those concepts as much as I was able to be because of this show actually is really, really influenced and stayed with me and kind of shaped how I look at bits and bytes.

Now we have a recursive reference in our bibliography. Oh, oh. Well, maybe before we implode the whole world here, this might be a good time to wrap up. Yes, let's do that.

Frequently asked questions

How long is this episode of The Bike Shed?

This episode is 40 minutes long.

When was this The Bike Shed episode published?

This episode was published on January 27, 2026.

Is there a transcript available for this episode?

Yes, a full transcript is available for this episode. You can read the complete transcript on the episode page.

Can I download this The Bike Shed episode?

Yes. Use the download control on the episode player to save the publisher-provided media file.