Autoscaling is a simple concept. Automatically add resources when needed, and automatically shut them down to avoid paying for excess capacity. How hard could that be? If you've set up Autoscaling yourself, you know it's not that easy, especially using the native Autoscalers on platforms like AWS and Heroku. That's why you need JudoScale.
JudoScale is Autoscaling as a service, and they make Autoscaling simple and easy, as it should be. You can use JudoScale on AWS, Heroku, Render, Fly.io, and more. It's free for low traffic apps, and unlimited plans start at $25 per month. Autoscale on Easy Mode at judoscale.com. Hello, and welcome to another episode of The Bike Shed, a weekly podcast from your friends at the thoughtbot about developing great software.
I'm Joel Kinville. And I'm Anjouslator. And together we're here to share a bit of what we've learned along the way. So, Haji, what's new in your world? What is new in my world is that this weekend I'm going to be speaking at ExoRuby.
Have you heard about this event that's going on? I have not. Tell me more about it. Yeah, it's put together by Jim Remzik and collaborators. It's small, single-track, one-day Ruby conferences that I ease basically taking on the road around the country.
Oh, I have heard of this. Austin, Atlanta, Chicago is this weekend. And it sort of ties into his strong feeling that these in-person events are super important for keeping up community and different things like that. And so I'm really looking forward to participating in that. Speaking, seeing what the current Chicago Ruby community looks like because they've had some meetups, but I haven't been able to attend yet.
And so this will be my first post-pandemic big Chicago regional event. And so I'm super excited to reconnect with some folks. And yeah, I love these little regional conferences. Yeah, did you say you were speaking of this one? I am, yeah.
Are you talking about test-driven development? It's a perennial favorite. Yeah. You talked on that topic in the past? Yeah, absolutely.
Do you have any conferences talks coming up or anywhere that you're attending? No, I'm done for the year. I know there's still a bunch of European ones happening in the next few weeks that people are really hyped for, but I'm taking a slightly quieter year in terms of conferences. Nice. Yeah, I know that tiny Ruby is coming up.
There's also fast approaching as Rocky Mountain Ruby. So that's the beginning of October, and that's in Boulder, Colorado. And it's really great to see all of these regional events coming back. Of course, we all stayed at home for a couple of years there, and I think the momentum is really picking back up. Yeah.
Yeah. From seeing the big national conferences come back to now the more regional ones, I found that when I have attended smaller ones, the sense of community there is stronger. They're often more like single track. You get a chance to talk to most of the people that are there. It's a little bit more intimate.
I found that they're just a really fun experience. Yeah, absolutely. I agree more. What's up in your world, though? I've been doing a lot of fun and code.
And recently I had to build out a React view that had just a lot of different states within it. So it's a page, and the page is a whole requires some initial data to load. So the page is a whole has a loading status. And then based off of the user that we've loaded, a bunch of attributes on it, there are a variety of cards that we can show in the UI. Some of these cards you decide whether or not to show them based off of user attributes.
Others, you show them, but there are variants of the card. You show different variants depending on attributes. Some of these are dependent. Some of these are independent. So it's a lot of interesting state to track.
And I had to implement this. It was partially built out. And I was struggling to follow the logic. It was one big chunk of JSX. And in the local, like every little bit of UI code is like, all right, this is conditionally if these variables are set or this data set on your user who we've already checked if it's loaded, then you can show this little chunk of UI.
But as a human, that doesn't scale for my mind. I was struggling to get a sense of what cards can show up in combination. And knowing that helps me to know what I can abstract out if I need to, where to go for logic, things like that. And so I reach for a tool to get unstuck there that I'm familiar with from more functional languages, element Haskell. I reach for an algebraic data type.
And that's just sort of a combination of unions and intersections. Data can either be in one of one, two, three, four shapes, but sometimes data can be a combination of data one and data two. So sort of a combination of a ands and ors to build up a more complicated data structure, we say it's one of either this or that and this. And you can nest this arbitrarily deep to create a sort of a tree structure. And so I was able to use that to model basically what could show on the page, like each variant of the card is a sort of an or, and anything that can show up where this card and all of its variants and this card and all of its variants both show up, those get ended together and so on.
And you end up with something that's really concise, but that nicely demonstrates how things compose on the page. Yeah, I can see how something like that would really organize or compartmentalize the different branches that you're having to kind of like keep track of at any given time. What was the sort of like the JSX structure, the component structure that sort of falls out of a data structure like that? So the interesting thing here is that this data structure is not anywhere in our code. I've used this purely as an analysis tool to help me understand what was going on.
So this is sitting in my notes somewhere just as a, hey, here's how I think this thing is structured. It's not actually in the code. I see. What I found is like, okay, now I found each of the individual pieces and the parts that can vary and the parts that don't. And I ended up wrapping most of those in little components.
And when you do that, the sort of logical way to lay out your conditionals ends up more or less mirroring exactly that data structure because you either have a conditional says, Hey, this card can be one of four variants. So based off of, you know, just condition one, condition two, condition three, condition four, render one of the four variants. And if you want both card one and card two, then that's just render two components next to each other by pulling most things out very aggressively into components rather than just having conditionals sprinkled throughout my JSX. It meant that the sort of core view of the page ends up looking a lot more like it's derived from that type that I sketched out, even though I don't actually use that type anywhere in the code.
Okay, I see. I like how you describe that to a sort of aggressively pulling out components in that because that would be my approach as well. I've had a couple of components that I've had to add to recently that were, I'm pretty sure literally hundreds of lines of just conditional rendering for an element that wasn't sort of wrapped up into its own component. And I would have needed the techniques that you're talking about here plus 10 more if I needed to actually wrap my head around that entire section of the page. So yeah, I tried to add and add to those, but eventually it wouldn't fit anymore and I just had to write my own component and it went much quicker.
How aggressive do you tend to be in pulling out components when you're writing React? Do you tend to sort of like every little thing is its own component and everything's in very sort of high level constructs? Or do you tend to have, I don't know, maybe a hundred lines of JSX with a few conditional sense? I think I would air more towards more components. I've found the effort of that bites me less often, I think.
But a little bit more effort to start up a new component is not as much trouble as having to pull something apart a lot later. It's kind of the opposite of the wrong abstraction. Oh, yeah, duplication is worse than the wrong abstraction. Geez, wow, I couldn't pull that up. That's usually lives right at the front of my brain.
Yeah, was that mentioned in a RailsConf keynote at some point? See, that's the problem. It wasn't. Yes, Andy Matt said some great RailsConf talks, but they weren't keynotes. Yeah, that's maybe failure on the committee.
Couple of RubyConf talks though, I think. Yeah, where do you fall on that? I tend to like to pull things out and components a little bit more aggressively. And that varies, I think, a little bit by framework. It doesn't really do components so much, it just does functions.
But I'll pull out functions very aggressively. I have this sort of mental model or like set of principles that I call the triangle of separation. I have a whole article thing into them, so we'll link to that in the show notes. But it's basically about structuring complex code. And one of the things that I do is try to write code in a single layer of abstraction.
And so it's much easier to say, oh, this page consists of three cards, each of which can be in two or three possible variants. I'm looking at it at a very high level. That's what you want to see when you're reading, trying to get a sense of what this particular page looks like, what this dashboard is. As opposed to just like, oh, here I've got 300 lines of JSX soup and I've got to sort of work my way through. And I go, OK, there's a conditional here, but it's not exclusive with this other branch.
So do these two sometimes happen together? Are these all just one card that has a bunch of variants? Is this potentially two cards that can show up? And if so, which variants can show up together? So I think that writing code in a single layer of abstraction really shines when you're writing fine code.
Yeah, absolutely. And the other principles of that trying to also sort of I think push you in the same direction. Those are pushing conditionals up the decision tree and separating branching and doing code. Yeah, I guess. So that's less where I think about maybe abstracting classes, different objects and things like that and more like methods level I find most often.
Yeah. Is I think the same kind of decision process that leads to me breaking out new components. So as often as I'll make a new method and review, I'll make a new component and react that kind of thing. React does allow you to do sort of almost like private components. You can pull out something from your main to return blocks.
It has just all of your JSX and pull that out to a private function within your component. And hey, now you've got a sort of a mini sub component inside. You didn't have to create a separate file. You didn't really have to create a whole interface. You can share state.
And so that's a really cheap way to split things up just when you're getting started. And then if you say, hey, there's some things I want to reuse in multiple places, then maybe it makes sense to pull them into a separate file. But this is the case where I'm mostly extracting for readability and structure, not for reuse, which I think is the common case people love to extract. Yeah, but I'm definitely a big proponent of extraction, whether it's a class, a method, a component for readability and that kind of mental overhead of working at a single point in the tree of an application, especially UI. I find that sort of as programmers, typically we're writing code, we're optimizing for something.
When you're writing fun in code, do you think that optimization is typically your readability? You're sort of your default optimization? I think that's at least the first step in the optimization for a lot of how I'm thinking about code. I'm sort of thinking about someone is going to have to come to this maybe years later, maybe a week later after I've forgotten everything that I've done and is going to need to be able to jump back into it without spending the entire day. That's where I start my optimizations, I think.
I've found that I think optimization is a thing that most developers really take pleasure in. Sometimes I'll also like perverse pleasure and we really want to optimize this code to be as cursed and as short as possible. And oftentimes maybe that has negative side effects, right? We really like to abstract as much as possible and then we end up with the wrong abstraction. We're trying to get the most of the can in these micro benchmarks that don't have any impact and then the user experience is still bad.
So we're looking for not to turn into optimizing. I love that, but we often optimize the wrong ones. I've found that often carries over into something else that a lot of developers enjoy and that's board games. Because I think most especially kind of strategy board games are really deep down optimization problems. I like where this thought is going.
I do think that there's something about that that attracts the same sort of mindset or at least the maybe the same skills that we've built up at work and it's nice to be able to use those skills in another arena like board game night at RailsConf, which has really taken off in the last couple of years. It's been one of the things that you don't want to miss going to a review central event. Always a lot of show up for that. You play a new game at all at this last RailsConf? I missed the last RailsConf's board game night.
I went to the one before and it was a really great time. I finally got to play the Mistborn deck building game. Because the manual was not optimized for readability. Let's put it that way. But having someone walk me through it was a lot better.
And I, as I'm thinking through the last couple of times that I've played it through the lens of this optimization problem, I can see my refinement of what I'm optimizing for each playthrough. Right? There's several layers of things that you need to accomplish in the cooperative version. That all need to happen some in order, some not, but kind of need to come together to complete the thing. And so the first time through Lost Terribly and the thing that needed to be optimized for that one pillar of the completion state was the thing I was optimizing for the next game.
But then that was too simplistic of an optimization. And so it needed to get refined and strategize out. And it took multiple times through before the groups I've been playing with were able to complete the objective. Is that sort of cycle of failure and trying again something that's interesting and exciting? Or does that become just frustrating?
For me, it's definitely interesting and exciting. Something that I lean on a lot is an idea I picked up from video game design that is probably pretty prevalent in game design as a whole is that exploration and that failure and multiple attempts shouldn't be punishing. That should be fun to do anyway. And I think this game is good at that, another game that is really fun to lose is pandemic. That one's very difficult, but you can adjust as much fun losing that game as winning it.
I feel like there's got to be a metaphor here for TDD, right? You're getting red and your cycle is not, we call it a failure, but it's not a, oh, you're being punished for your, your bad at code. You're doing things wrong. It's every little step moves you forward in building your program and you learn something new at every step. And green is really just the final stage.
I like that. I like that. I think where it does sort of fall apart as all metaphors and similes do is that green isn't really the final final state, is it? I mean, I guess you can then go to the next red and keep going or, you know, refactor. Yeah.
That's what I was saying. Yeah, absolutely. I think it's really important in your workflow to treat those steps where you know it's not going to be done, where you might have a lot of possibility for a new failure or a new wrong optimization to kind of creep in and that can't be something that's going to throw you completely off. It's not the end. It's not going to demotivate you.
And part of that is your own mindset and part of that is going to be the external stimuli, right? I feel like that comfort with, we can call it failure, although I think in all these cases it's not true failure is something that is really useful for developers. So we're talking about TDD, but you could also imagine all sorts of other automated tools that give you a success or failure on your code. So it could be a linter. I guess sometimes it's annoying to not pass a linter, but oftentimes it's an opportunity to learn and grow about the language you're working with, especially if it's something you're new to.
You can do a lot of that leaning into a type system. I think many people feel of a type system as a sort of a taskmaster to be appeased. So I said, oh no, I wrote my program. I know it works. And the type system won't let me ship this.
What do I need to do to just get it off my back? And we get where you start, right? But to get value out of a type system, you can go so much further. Now you're treating its output less as a, oh, that's annoying and more of a, oh, maybe I found some like edge cases I haven't considered or my design needs to be refined a little bit and becomes more of an assistant. Is that like the friend around the table that is constantly pulling up the rule book and keeping everybody online or in line more than it is the game stops working?
And the friend pulling out the rule book can get really annoying sometimes. I guess if you're like playing like you're saying a co-op game and you're just sort of, hey, how does this work? And they're like, I got this. That's good. And I think that sometimes it gets annoying.
Are the rules lawyer? Yeah, there's definitely something in the delivery there. But I think there's probably a lot of good in complicated games and we code is not often not complex like the sentence. The sentence is hard to parse. There's a bit more in violation there somewhere.
Because the game designers have spent so much time, hopefully spent so much time play testing and working out all of these different rules. There are usually good reasons for a different rule to influence the gameplay in a certain way to keep things moving or to add some kind of flavor or experience to the game a little bit like a linter sometimes they can, you know, they can be ignored, you can house rule or whatever like that. But sometimes there are kind of fundamental rules that will let the game keep going but make it punishing. Just make it not fun to play like monopoly when you don't auction off the property after someone has landed on it the first time. Friends don't let friends play monopoly.
That's what I'm saying. Have you ever tried to debug an issue in production while switching between your error tracker, log viewer and APM tool? Maybe you know how painful it is when you can see the error but can't find the relevant logs. Or when you see slow performance but it can't connect to the root cause. Scout monitoring is all in one platform built to make your life easier with log management, performance tracking and error monitoring coming soon.
All of your data will be together at last. You'll go from bug to fix in one place. The result? Less context switching, faster debugging and monitoring that actually helps you ship code instead of distracting from it. No DevOps team?
No problem. Scout works with your existing stack and gives you insights in five minutes, not hours. From bug to fix in one place at ScoutAPM.com. I know you've got a whole tower board games behind you. I do.
Do you have a favorite in there? I have different favorites at different moments. Things that have been interesting to me at the time. But one of my most favorite is one that I don't hear people talk about all that much. It's a escape the curse of the temple.
It's a co-op game where you're exploring the Indiana Jones style, overgrown jungle of temple and you're trying to get in and find your relics and make it out. It's a cooperative game where everyone plays all at once. There are no turns. So everyone is madly rolling dice taking their turn quote unquote. One after another, all at the same time, it is absolute chaos and it is maybe the most fun 15 minutes of board game playing that I certainly own but maybe have played.
And the interesting thing there is where I might normally be taking this kind of approach to find this optimization problem. I don't know that I have time to think that hard while playing that game. And it ends up being nothing in the rules is what's driving the strategy and it's more like it's optimizing communication between the different players because you still do need to work together. But it's not necessarily, it definitely isn't one of the resources that the game kind of puts in front of you. It's how you play.
So maybe sometimes the fun part of the game is that it allows you to turn off that optimization part of your developer brain that's otherwise always on. Or maybe it encourages it to think about a different turning that skill on another part of the work quote unquote or the game that you wouldn't normally be paying attention to. Like I'm often thinking about resources and victory points or like whatever the game is trying to the rules are trying to get you to think about and balance and manage. But this one sort of makes you focus on the people at the table with you and the experience of it. And I think that's it's a really fun really powerful experience.
And I'll give you a tip. It helps if there's one person who's playing as like coordinator. Ah, so it doesn't actually have a piece on the board and that can make it easier to accomplish the victory condition but also just a lot less shouting at people without them hearing. Did we just reinvent corporate management? Anything with more D six is just like a fistful of D six for corporate management.
I'm into it. Also clearly you occasionally play D and D when you refer to a diet as a D six. Absolutely. Yep. The little subtle tells.
Do you have a favorite game that you find yourself going back to? And right now it's D and D which I guess you know some ways you're doing optimization stuff but because oftentimes you're leaning more into the role playing and the trying to stay true to a character and often leads you to play in a non optimal way and that can be really fun as well. It's a little interesting that we started this conversation with board games have a similarity to our jobs in that they are optimization problems and that's something that we're often doing with the code but both of the games that we're talking about now are sort of break that right. They're either talking about communication between the team or they're thinking about the ways in which you might break that convention or that rule in order to get a better result.
That's interesting and another is probably something there. Yeah. I go back and forth and do you the kind of game that if you want to play it where you're referred to it as like min maxing your characters? You can go all out and just say can I create the like perfectly tuned characters with all the right attributes it's going to be like absolutely the strongest or most flexible in every situation and just see how far you take that. The problem is just if you do that at a table where no one else is now you're half a standard deviation off from everybody else in terms of power level and that just breaks in the dynamics.
Is that a little bit like that archetype of the cowboy coder? Like you've min maxed it, you're not focusing on communication, you're trying to quote unquote win the game but in D&D there's no winning the game. The game is to have fun with the people you're playing with and that just makes me think that that's just another reinforcement to my belief that it's never really a code problem. It's all about communication about other people. You need that person who doesn't have a piece on the board but who's actually coordinating everyone else.
Oh, we should start calling that role in Escape from the Temple Master. There you go. Now I'm just imagining Project Manager on the project as programming DM and that entertains me. I do like that to get a little Project Manager screen that they can sit behind and just every now and then you hear your Project Manager rolling dice from behind the screen like oh no. Maybe that's how we should assign points to the stories in our backlog.
You're just rolling D20. Yeah, we were looking at the wrong game all along. It's not planning poker. It's everybody roll initiative. Yeah.
But when we're looking at more sort of classic strategy games, how do you find that you tend to approach that? Because oftentimes if you're like playing for the first time or one of your firsts, there's a lot of new rules, there's a lot of complexity and you want to find your footing. How do you tend to approach a new rule system? That's a good question. I think especially if it's something that I know playing through is pretty short.
I will try and just latch onto the first concept or resource or whatever that is. And in a way sort of min-max on that. You're like, what would playing look like if this was the way that I was optimizing for? This is the thing that I am kind of taking on as my strategy and sort of simplifying the game a little bit in the process of that, especially if it's a new game because there's probably a lot of things going on, a lot of moving parts and I want to just, yeah, I want to simplify the whole construct for myself. And then you can fail on that and iterate.
What's your usual approach? I have sort of two broad mental models that I like to approach the games. One is finding what is your limiting resource? What is the bottleneck? And that's maybe something I've taken from optimizing a lot of things in software, right?
There's a lot of things that maybe you're using inefficiently that you can try to optimize. But if that resource is not your bottleneck, you're not going to see any rewards from optimizing that. So identifying the bottleneck. And in some games, like, oh, I've got to make more goals so I can do more things. But maybe it's a game where there's only like five turns in which you do things before the game ends.
And that might be your sort of real bottleneck. And now everything becomes gold per turn or other resource per turn or actions per turn because turns are the things that are going to bottleneck everything else. So identifying that bottleneck is one of the first questions I ask when I'm facing a new board game. The other is going to be around my strategy as a whole. I tend to view most strategies as falling into one of two buckets.
They're either linear strategies where a sort of fixed amount of effort input gives you a fixed amount of victory points output that you sort of consistently do throughout the game. Or an exponential one where you might be building a lot of things to start a combo. And initially, there might be zero payoff. But as things compound on each other, you start to run away. And maybe that's a little bit like looking at a classic big O notation for an algorithm, linear versus an exponential.
And like, oh, you always want in software, maybe the linear one over the exponential because that's better. That's not necessarily true for small values of N. You don't need memoization or anything fancy if you're iterating through a list and there are only three elements in the list. And in fact, the overhead of those things, even though you're saying, oh, but this one is a much better algorithm complexity for small values of N, it might actually be more expensive. And so when you're looking at the game, if you're working with a linear strategy rather than an exponential one that compounds, which you're effectively playing as a rush game, you want to end the game early so that you can win while you're ahead before that exponential growth from your competitors catches up to you and then surpasses you.
And so that's either by trying if the game has not a fixed N, but an N that's dynamic, you can try to make that N happen sooner. Or if it has a fixed N, what you can try to do is sort of delay your opponent's compounding. So you're playing more of a disruption game at that point. And what you're trying to do is to say, hey, every turn they get to compound, say they double their victory points. It's never quite as simple as that.
But if I can delay their compounding for one or two turns, that might significantly alter the outcome of the game, where my slowing study can still win. And vice versa, if I'm playing the exponential game, then countering those things from the linear players and knowing that the sooner I get my compounding online, the much bigger of an impact it has. But also maybe I'm trying to lengthen the game that gives me more of a chance to win. And so in that situation is the resource, like you were talking about the limited resource, the rounds again, that's the time of the game and you're trying to control that in your favor one direction or the other based on your strategy. Again, that will depend on the game.
There might be other things that you're trying to optimize for. But the ending of the game, the rounds is definitely a variable you have to play with. And if it's dynamic, then you can sort of create more or less of a resource-rich environment for everybody to play. So I guess you could say that a linear strategy is a little bit more lean and mean. It thrives in a low resource environment, whereas the compounding one is one that requires a little more abundance.
But in that abundance it will always win. Requires a bigger data set to see the advantage come back from the linear algorithm complexity. So it's interesting talking here because I feel like as much as I've seen like, oh yeah, there's some connection between board games and software. I don't think I had such a direct mapping between what I do in software and some of these approaches I use to break down complexity in games. And just now talking to you, like, oh no, this is exactly what I'm doing here.
I'm writing a big O analysis of a board game strategy where I'm not quite analyzing a flame graph, but I'm looking for bottlenecks in a board game strategy. That is absolutely what I do in my day job. And I don't think I made that direct of the connection before. I think in this conversation I've sort of not pulled away from the similarity between work and board games, but had a widening of my perspective where maybe you made some deep connections there. I was thinking, I think, very much about the code and kind of CPU cycles or different things like that.
Now I'm also thinking about gameplay and the interaction between players and different things that's kind of this meta game and what does that mean for team communication and how we work together. So this might be a richer topic than we ever thought. Have you ever played the board game diplomacy? No, I don't think so. This is sort of an old school game from maybe the 60s, the models were one and everybody trying to take over the map kind of risk style, but instead of everybody taking a turn and moving armies around, instead everybody writes down the orders that they want for their army.
So what they will do on their turn and everybody reveals simultaneously and some actions will just effectively like toner each other to the point where you've both wasted your turn. So you've got a little bit of like prisoners dilemma going on there, but just to make things more kind of game theory-ish, you get to talk to each other in between turns. You can make promises to each other. You are not beholden to those promises. And so it is absolutely a game of backstabbing.
But if you overdo it, everyone's going to hate you. It is a little bit king of the hill where whoever's, you know, big guy on top tends to get ganged up on, but then there's also sort of pseudo alliances that form among players. So there's a really strong social component to manage in addition to just the kind of more risk-like strategy of moving armies on the map. Is that something that you think is explicitly built into the mechanics of the game or is that something that just emerges out of people and playing it? I think it's built into the mechanics of the game.
There's at least one addition of the game that I've seen where the image on the box is like a cartoon player getting backstabbed. So they're trying to set people up to sort of fight amongst each other and like string each other long and backstab each other. Excellent. Yeah, that sounds like it would be the most interesting part of the game. Yes, yes.
And there's less, I think, strategic depth than something like risk. I think every territory has an army on it that you can move. The meta game is where this game is played. It's all about the meta game. Similar to things like Blood on the Clock Tower, these other kind of social games.
Some of these where you give like truths and lies and you try to catch people out on inconsistencies. I don't know if you ever played something like a coup where you've got a car that gives you powers and you claim to be able to do certain things, but you may not actually be able to do that. Yeah, usually I despise those kind of games. They don't often have enough structure for me to latch onto, especially if they're played in a group of people that I don't know very well. Yeah.
I own social anxiety. It comes into it as well. But I've found that there is, I don't know if it's a new crop, it's new to me. But things like Blood on the Clock Tower that have enough board gaminess to them that it makes it a lot more comfortable to play that social game to lie about what powers you have or what abilities or what information you know about the other players and things like that. Because you're still kind of working within this system.
And you again are trying to like hold the levers, move the dials that are kind of given to you by the mechanics of the game. Do you find that given a set of facts that people have given you and finding the logical inconsistencies in them is something that you find enjoyable or something that you're able to maybe do efficiently in the back of your mind? Yeah, I'm not sure. I don't know. I've shied away from this type of game.
And so maybe thinking about it that explicitly is not familiar to me. Do you feel like you have a preclivity one way or the other with that kind of challenge? I think I enjoy the for the processing of that to say, okay, given these things, I think these facts, one thing leads to another leads to another. Oh, now we're in a contradiction. I enjoy that sometimes less so than making a convincing case for my own lie.
But the analysis part is fun. Yeah. In some ways I think that lines up almost with a mental model I have for what a type checker does, which is it's all about given a input program is trying to find is it logically consistent. Does one all the claims that you make throughout it sort of lead one to another every function that calls another one can actually make that call. It doesn't tell you if your program is correct, but it will tell you if it's consistent.
So in a sense, I'm running my own sort of mental type checker on other people's assertions. And that's kind of fun. Yeah, I think separating, like you said, there the making case for your own lie or something like that and the sort of deduction of taking those pieces and finding what falls out of that is an important distinction because there's one of those that I do enjoy and one of that I don't. I feel like my takeaways from this conversation are sort of twofold. One is if I'm ever at a conference that is hosting the board game night, that is not to be missed event should absolutely show up for that.
And two, I should lean a little bit more the crossover between the two, try to use more software skills the next time I play board games and maybe if I'm feeling stuck in a software problem, shift my mind a little bit and see can I treat like a board game problem? Maybe solve it that way. Maybe we need to update the mascot of development from the rubber duck to the people. I love that. On that note, shall we wrap up?
Let's do it.