Hello, and welcome to another episode of The Bike Shed, a weekly podcast from your friends at ThoughtBot about developing great software. I'm Joel Kendall, and today I'm joined by a fellow ThoughtBotter, Adji Slater. Howdy. And together, we're here to share a bit of what we've learned along the way. So, Anji, what's new in your world? Yeah, I think the most exciting thing that's new in my world is on a personal project. I've been playing a little bit with Ruby 2D. Do you know anything about that? No. Is that like a graphics library to do like 2D graphics? Yeah, it is. So I had been watching and looking to folks doing computer and generative art with things like processing, which is a Java platform, and p5.js, which obviously runs in the browser, and was getting super jealous that there wasn't anything like that with my favorite language, Ruby.
so i first went to dragon ruby which is a game engine but it is very specifically for creating games and the community around that like everything is built up around building games and some really great projects are coming out of there but it's also a subset of ruby so it's not the entire language because it's a new interpreter all its own to do what it has to do so i started looking around for other alternatives ruby not really known for creating images and animations. But there is a project, Ruby2D, that has a drawing loop in the same way that processing does. And I can interact with it with Ruby. And it's been a lot of fun kind of exploring that. And I'm looking forward to keep playing with it and seeing where the limits are and where it can push them. So we typically write Ruby in the context of a web server. And the web is sort of unique in that you're tied to that request response cycle. The requests are typically very short-lived. How is working with Ruby in a two-dimensional graphics setting maybe change the way you think about a program? Getting used to the idea of a game loop.
or an animation loop in Ruby was really different. Like you said, we're usually thinking about a request response or maybe it's a script. It runs something from beginning to end to completion instead of looping over again and again and again to update a canvas sort of situation. So that was definitely something to wrap my head around, the use of things like more global variables, even if they aren't specifically global variables, but having a global state and these other things that are generally a no-no in the web world that are... just sort of table stakes or how it works in that sort of idea. Ruby 2D is a little different than DragonRuby in that the state isn't passed in to the looping method. So everything kind of lives above the main loop in the files. But yeah, it's a completely different paradigm. Is the documentation from Ruby 2D pretty good to learn some of those more foundational concepts? Or are there other places that you went to to level up in these areas? Yeah, the documentation is all right to set you up with what the basic sort of building blocks of the environment are.
There's not a ton around what best practices and kind of what patterns have evolved out of people experimenting with and using this. There is a Discord that has like spikes of activity that has been super helpful. People on there are really friendly. But it's been a lot of kind of experimentation and using my intuition about like, does this feel Ruby-like? Does this feel weird? Or is this just feel like the Ruby way to do this different situation? Do you have any fun projects or demos that you've built that are public that you would like to share with the audience today?
Not today. I don't actually, but I'm really hoping to share a lot of these. I started a repo for Ruby Playground, but there's nothing in there yet. I want to not only be a resource for other people that are playing around with Ruby 2D, but also maybe use it as a way to talk about using Ruby in a way that's abstracted away from Rails and maybe helping folks that are still trying to get their head around those fundamentals and then definitely highlight where it's different too. Do you think that a tool like this might be a gentler introduction to Ruby or maybe even programming for...
a newcomer than jumping into some kind of web program? I think it could be. What it feels like a lot is something that I was doing in fourth and fifth grade. I'm pretty sure this is the name of Logo with the little turtle that you would program and it would draw out on the screen. I really think that something about the web platform that makes it accessible for people is the speed with which you can get something on the screen, something visual, something familiar, something interactive. And that requires browser and all this kind of peripheral things. But a lot of that is paired away when you've just got Ruby code and a window shows up. And if you say,
square.new, it'll draw a square, that kind of thing. So I think that, yeah, there's a lot of potential there. Exciting. So for any listeners who want to check this out, this library is called Ruby2D. Yeah, it's just a ruby2d.com. I guess we'll put a link in the show notes. Something that's been, I think, new-ish for both of us is that we've recently been staffed on projects that are not using Ruby. They're using TypeScript. And that's a bit of a different paradigm than a lot of what we write day to day.
What has been your sort of first impressions of TypeScript? I think there's a lot there. I have a general sense of why I might like type systems and I'm kind of like sold, like the buy-in work doesn't have to be done, at least at the level that I'm kind of coming into it at. The issue that I tend to have is that I work in this typed world so infrequently that I will kind of build up an intuition. I will learn what the ins and outs of and kind of the mannerisms of this language are.
then I don't get staffed on a TypeScript project for two years. And all of that intuition goes away. So it's always a little bit of a struggle, even though I'm here for it. It takes a while to ramp back up on it. What are some of the typed mindsets or mental models that you find maybe foundational for you every time you come back to something like TypeScript? I think it fits really well with the sort of mental model I have just of object-oriented programming in general, of programming to an interface, having very explicit public versus private kind of thinking, wanting to know what your inputs and your outputs are.
So I think the mental model isn't too much of a shift, at least at the level that I'm operating. It's often more like the syntax, the nitty-gritty of it that is a stumbling block for me. You know, I found that ChatGPT is really good at that sort of problem. So either, here's a task I want to do. What is the TypeScript syntax for it? And then sometimes some follow-ups on, you included this little bit of syntax. Is it really necessary? Or can we do this without typecasts? So sometimes you've got to go through multiple iterations. But at the very least, it surfaces the things that I need to have.
And it's pretty good at holding onto that context so that I can ask it questions about the solution that it proposes. So I really like that. Yeah, I've actually found, I'm a Claude user myself, but I have found that much like BashScript, which feels like this kind of esoteric, ancient incantation language that these LLMs are very good at helping me through the syntax of, yeah, I have found a lot of help from Claude with those kind of syntactical issues when there's something that just looks completely foreign to me. And it's like, I know that there is structure and concept behind. the way this is written out, I just don't understand it. That kind of like explained to me is really good at giving me the words that I need to kind of hook into and look into further. There was an article that Avdi Grim put out this last week on how do I know to do that? And talking about the idea that when you're one of the biggest advantages of pairing with someone is oftentimes not just that, oh, they did this cool thing, but trying to understand from them that how do they even know that that was a cool thing that was available to them? Or how do they even know to like start searching down this path to find this cool solution?
Because I, as a newcomer, just don't even know that these paths are available to me or sometimes don't even have the words to search. And so there's a footnote in that article that Avdi mentions that this is one of the really good use cases for LLMs, giving you the words to then feed into something like a Google search. Yeah, 100%. I've definitely felt that and used to that and 100% agree. Yeah. Are there any neat little trails that you've discovered pairing with your LLM partner? I've used it a lot for almost dialogue, have conversations about a topic.
It's been really interesting to explore typecasting in TypeScript and what are the limitations and use cases for it. TypeScript is interesting in that it allows you to cast a value as a type that you claim it is. You're kind of overriding what the type checker thinks it knows about the data. Within some limitations, you can only cast as either a subtype or a supertype of what TypeScript thinks it is. So you can't turn a string into an integer and just say, hey, I know you think it's a string, but trust me, it's an integer. That's not going to be allowed.
But you could take a value that's a generic JavaScript object, a key value pair, and say specifically it is going to be something with a name key and an age key. It's a user. And TypeScript will allow that. Now that can be dangerous because what if the object has not those keys? And now it's going to blow up on you. So it's generally considered bad practice, but it's also very current. People do this all the time because it's an easy way to just sort of move on with your code. And I found that the LLM often recommends solutions that involve, I believe the technical term is a type assertion.
And have you found that by the end of working on a chunk of work or a feature that those typecasts are still there? They're still what you kind of rely on to do what you're doing? Or is it a tool to when you're still figuring out what you want to be doing? I tend to avoid the typecasts pretty heavily. I'm willing to put a decent amount of work to not typecast anything. Sometimes I'll use it as a placeholder to sort of scaffold things. But in general, I tend to like more sort of...
type driven approach to developing my code and so if my code is not type checking then that is something that gives me pause to think about well how am i modeling this how am i structuring my logic A common case for code not type checking is basically there are a bunch of edge cases that I need to handle, such as verifying that an object has certain keys or maybe verifying that a particular value is not null or something like that. And sometimes when you are developing, you just want to sort of YOLO down the happy path. And so, yeah, sometimes then you can just be like, yeah, no, trust me, for the purpose of this exercise, it will not be null.
But then I go back and remove them because a lot of the value that I get from the type checker is, yeah, please do remind me of all the places where I need to, where I forgot to null check. Those are really valuable. Yeah, absolutely. In the situation where I'm in, the project also uses Angular, which is also new to me. So luckily I've got a Rails backend with GraphQL and like I'm familiar there that can move forward, but it takes a little bit more exploration to sort of get something done on the front end. I found that kind of type assertion or a little trick that Copilot taught me, which just feels...
awful every time i do it but you say as unknown as what you want and then you can just you can change it into anything so that's always kind of something that i can reach for when it's like i don't even know how angular thinks of this thing but i want to make sure that this request comes back it's like okay great i'm on the right path now i'm gonna go back and i'm gonna understand the thing that i'm using because i know the thing i'm using is what i'm supposed to be using is how i'm gonna get there and so sometimes there's that really out in the weeds just kind of learning the boundaries of what tools are available to me that that kind of heavy overriding just gets my foot in the door basically that as unknown as some other type is both brilliant and kind of horrifying. Yeah. Because that limitation that you can only upcast to a super type and downcast to subtypes. If you want to go for like a cousin type, I guess what you do is you upcast up to like a shared ancestor and then you can downcast down the other chain. And unknown is the shared ancestor of everything. Yeah, it's wild. It's clever. I'm impressed. And also...
That's awful. Yeah, definitely grepping the code for as unknown before I commit and push because that's not something that should be used lightly and definitely not something I want to add to a code base. It's a tool for me to figure out where I am. And that's about it. That being said, I think that using just as unknown rather than as unknown as something else is a really valuable thing to do in many places, particularly in situations where the standard API will give you something like any. So something that has come up for me a lot is
any use of JSON parse or the JSON method on a response object for a third-party API call. By default, those come in as any. And then you get to just call whatever methods you want on it, which is the point. It's supposed to be easy to sort of layer TypeScript on without having to redo all of your code. But you just have given up type safety for anything downstream from that, because any of those assumptions could be wrong. So by casting that any as unknown, now the type checker is going to know based on what you try to do with it afterwards. You say, well, I want to read a name property off this object.
And TypeScript's going to know to tell you, wait a minute, if you want to read a name property off this object, you're going to have to do some validation for me. And it helps you sort of go from that delta of what I have to what I want. Yeah, I really like that. That kind of matches with how I feel about reading something from another system anyway. Like, yes, sure, I might know fairly confidently what is going to be coming in, but I don't really know. So I like being shepherded towards doing the extra work to be sure about it and not pass something that...
maybe you thought was a response, but is an error object and starts cramming into the machinery that thinks it has a response, that's obviously not going to work. So putting up those guards and like you were saying before, forcing you to handle the different edge cases that, yeah, that part's really valuable. I think that can be really common for situations where maybe you have an API that doesn't return data with sort of semantic HTTP codes where everything returns a 200 and then you have to read error objects out of that and realizing that it's quite possible. And in fact, likely that your server will return a payload that's not what you expected and that will crash for you. I think something that I've been coming to realize with types is that a lot of what they do for me is find code I forgot to write. And that might be, hey, you've got this response here, and you're immediately treating it as if it's successful and as if that successful response has a body of the shape. But did you consider that the data might come in a different shape? Did you consider that the response might be a failure? Did you consider that the response might be a different type? Maybe it's not JSON. Maybe you're getting HTML back, which is absolutely a thing that has crashed my system before. Endpoints that return JSON on success, but HTML on 404.
I really like that framing of it, that it's reminding you about code that you forgot to write or haven't written yet. I think that's, for me, that's a new sort of way of looking at that benefit of a type checking compiler. I think when we think of what a type checker does, the sort of initial thought is, oh, it's a type checker, it checks types. What are the things it does for me? It finds places where I was going to pass a string and the function required integer, and it's going to tell me, hey, you meant to pass a string here, so please do that. Which is nice, I guess, but...
How often do you make that mistake? Yeah, yeah, for sure. It's one of those, it's not really like an emergent property or anything, but it's like, that's what it's doing at the face of it. But that's not where the benefit, the usefulness, the kind of structure and concepts it can provide stops. So I've been digging a little bit into the idea of mental models for what is a type checker. And one that I have is that a type checker is a program for verifying consistency. So it just wants to look through your entire function graph and make sure that all the Lego bricks click into each other correctly.
which is a pretty basic thing to do. So that is checking the types, but also making sure that you're calling functions with the right name, that they exist, making sure that you call them with the right number of arguments, that kind of thing. Just the really basic structural things does the system as a whole click. It's almost like a smoke test that you get for free. But what's really interesting, you call this an emergent property, is that there are a lot of other potential bugs, requirements, business modeling, invariants that can be represented as types. Now these bugs in your code have been turned from sort of
like just bugs in the code that are invisible to the type system. And we've turned them into consistency problems that are catchable by the type checker. So it's just a little bit of creativity sometimes. Some of these don't come for free. You have to do a little bit of encoding of the problem into your types. And all of a sudden, then a type checker, which does a really basic task, is able to surface a pretty broad array of bugs in a system. Yeah, one of the parts that I find super valuable is when it levels up from, like you were saying, just finding bugs in the code to finding misconceptions about the system.
maybe missed requirements because these types all of a sudden telling you this doesn't actually work together or like you haven't thought of this whole different thing when it becomes less syntactical and more conceptual right that's really powerful yeah it has at times helped me to discover that i needed to ask a few more questions about a requirement about a ticket or that we hadn't considered something that a user could legally do but we had never thought about a user using it that way but because the types are both correct and they fit together in this way that we hadn't considered You know someone is going to, you have hopefully thousands, millions of people using your thing. Someone is going to find a way to jam those two things together. And it could be correct, but you just hadn't considered handling it at all. And then that user is going to, well, probably their mental model is going to break. They're going to be frustrated. They're not going to be able to do the thing that they needed to do. That's always interesting to me when the type checker tells me, hey, you don't have a branch to address this scenario. You should consider adding one. And then I get to sort of scratch my head and be like, huh, I hadn't even considered this scenario might exist.
should it exist? Maybe I need to rethink what I want to do here. And the nice thing about a type checker is it's able to kind of crawl the entire problem space and all the combinations in a way that I don't have to keep in my head. I think about it the same way that you hear research scientists talk about the edge of the unknown, right? Like when you find something that might exist that you didn't think of before, that's exciting. That's not like a problem. That's exciting. Either you need to wrap that up and then you know more about the way that you're...
different parts interact, or you've opened up an entire new avenue of using the concepts, the models, the objects, the things in your system, and potentially creating something new that, of course, is less frequent than the, whoops, I need to shut this down. But there is always potential there for discovering something new that you wouldn't have otherwise. I think you're going to get something really interesting here, which is a bit of a mindset shift in terms of how we consider a type checker. I think it's very easy to think of it as like a taskmaster to be appeased, right? Oh, it's constantly just like...
telling me all the ways I'm wrong and I need to just do something to get it off my back so I don't get the red squiggles in my editor or I don't get a crash in my command line. Let's do what I can to just get it off my back. And rather, now this is almost a partner that I can have a conversation with and who's helping me discover aspects of my program that I didn't realize were there. So we're reframing a negative interaction into a positive one. Yeah, absolutely.
Now we've kind of set up this little world where we've got two little robots pairing with us. We've got the LLM and we've got the type checker and compiler. And there are two little robot companions that are helping us navigate the code. I really like that. How do you fit in that? Isn't that the question we're all asking right now? Have me back in a little while. I've got some thoughts about that that haven't coalesced completely yet. But the idea of the type checker, the compiler being more of a companion to have a conversation with makes me think of another compiler that I know is close to your heart is the Elm compiler.
that definitely feels like a little friend. I think the Elm compiler takes a lot of these ideas that we're talking about in TypeScript and just sort of takes them to the next level. Its error messages are much friendlier than TypeScript's. They're much easier to work with. It gives you a lot of things out of the box you need a little bit more work for with TypeScript. And part of that is because Elm is sort of built from the ground up this way and doesn't have to be backwards compatible with JavaScript. It's not meant to be a gradual type system. So a lot of the things that you maybe don't get because of writing TypeScript are because of strategic choices to say, well,
We're going to not have that feature because we need to allow people to gradually work into this. So null safety by default. Elm will not let you write code that's potentially nullable and not check for that case. And wow, you start writing code in Elm and you realize there are so many places it might be nullable. You want to read the first item in an array? What if that array is empty? That first item might be null. You have a check for that? There's a potential crash right there. You read a key off of a dictionary.
Well, what if that key is not present? Did you write a check for that? The Elm compiler is going to make you write that. So many different things where, I don't know, I was sort of used to just, again, YOLOing it in Ruby. And the Elm compiler is a little bit more in your face about, well, that's possibly null. That's possibly null.
It really made me aware of just how much uncertainty there is in a program. I think you're touching on something that is really sort of foundational to the differences in these different things. And the TypeScript type checking in particular is that gradual layering in that backwards compatibility. It is built so that someone could know JavaScript and then gradually transition into TypeScript. Whereas Elm, that's where you're starting. You're learning Elm. You've got that with you. And that gradual...
nature of TypeScript is really a double-edged sword because it can help you onboard to it. It will start to level up your program. It's easier to convert a code base from JavaScript to TypeScript because you can ratchet that up as you go. That's huge. Yeah. Otherwise, you want to add a full strict mode TypeScript to even a spolish program that's like 10,000 lines or something. That's a lot of fixes you can make before it'll even type check. Yeah.
The project that I'm in right now has a great little after commit hook or maybe before commit hook, where if you modify a file and if you change a file, but you didn't convert it to strict mode and be like, hey, you changed this file, but you didn't completely change it to strict mode. And so I'm coming into this. I didn't hear from anyone on the team. I didn't read any documentation or something, but I can immediately tell, oh, they are ratcheting up the type safety of their application. And it's just a nice little reminder. Usually that change is not very difficult because it's sort of one file at a time and a lot of other work has already gone into it.
Yeah, that's a nifty little way to help people remember to do the rule of leaving it better than when you found it. And for those who are unfamiliar with strict mode in TypeScript, that's basically turning on some of the null safety features. So if you have code that is potentially going to trigger a null error, with strict mode on, the type checker will force you to fix that potential bug. Whereas with strict mode off, it will accept it just, yeah, trust me, it won't be null. this array will always have elements in it yeah i think one of the other issues with the kind of gradual nature or gradual potential of typescript is a team adopting it and learning it well, not to say that I know what well is, but something that I've seen in other projects that I've come to that are gradually layering in types, even back to things like flow, that was layering types into JavaScript is when a team is making that move and still dealing with the compiler at the entry level of first meeting the compiler. And it's that nasty thing that's telling them they're wrong all the time. And so types will be put in there, but they'll be pretty loose. Lots of any's, things like that. And
then you're putting a type system in, but sort of in name only. And that just increases the level of the compiler nitpicking you and yelling at you. And so it sort of bakes in and it's a vicious cycle that snowballs that a team just dislikes the type system more and more and more and more. I don't know that I have a strategy or anything for helping a team through that particular area, but it is something that when I come in as an outsider, I can notice is happening in a way that a team that has been just sort of seeping in that situation for a while might not see the change that they've gone through. So it might feel like a tool that's been added to the code base just because, I don't know, the internet thinks it's the best practice, but really it's just kind of annoying. Do you ever feel like you encounter similar dynamics with teams that have adopted TDD or maybe even testing in general on Ruby projects? Yeah, absolutely. I hadn't really made that connection before, but you're right.
Someone coming from not testing and things working out fine, I can see how that would be a very easy step to like, why are we doing this? Nothing's changed. The program still works. And not seeing the benefits that might not be thrown in your face the same way that the errors or the extra work is. Yeah, there's a strong correlation there. What would you do if you came into a team then that is just picking up testing for the first time and they're kind of grumbling about it? Honestly, I think you need to sort of sell the team on it. I'm not a huge fan of eat your vegetables style leadership for a team. You need team buy-in and you need sort of quantifiable.
benefit from it. And if our team is not getting benefits from testing, maybe we need to rethink why that is. And also maybe the, is it reality that we're not getting benefits or are we just not seeing them? And if so, how can we surface that? Has our defect rate gone down? Are we fixing fewer bugs? Are fewer people getting paged on the weekend because production is down? And if so, that's something we should celebrate. And we should also make clear to the team that give them visibility and some of the impact of their work.
I think with all these techniques, they're sort of asymptotic. You can, at some point, put in a lot more effort for marginal improvement. And then you can put even more effort for an even smaller improvement and kind of keep going. So at some point, you're never going to have the perfect test suite. You could be spending significant amounts of time on your tests for not a whole lot more benefit than you would for spending half that time. And I think types work the same way. You can try to encode every single invariant and modeling into your types and get really fancy. And at some point, it's not worth the payoff anymore.
both in the upfront time investment and the sort of maintenance cost of having so much complexity. Yeah, I've found that kind of an example of that is when types do get super fancy, not necessarily in just being very explicit, but like using a lot of the features of the syntax of the type system in creating these really powerful or specific types that are then unreadable by the people who didn't write it or aren't incredibly familiar with the inner workings of what TypeScript is able to do. that is magnified for my situation when again i have forgotten all of the intuitiveness of typescript syntax in between projects and i'm coming in and encountering something that is full of generics has 15 pointy brackets around these types that is just impossible to understand so yeah there's absolutely a limit where it can become more of a hindrance than a benefit and that's a fuzzy line it's straight off all the way down the answer is always
Sometimes. I've been sketching out a sort of rough hierarchy of how people use types as they sort of upgrade to fancier and fancier things. And some of that requires fancier features from the type system, but not always. I'd love to get your feedback on it. So level one is you're using a type checker just for consistency. So it really is like a sort of minimal and smoke test, and you're just making sure that all of your Lego pieces snap together. You get that for free just by dropping in a type checker. Maybe you lose some of it if you're like...
putting in some innies or type assertions, things like that, where you're sort of breaking that continuity. So you're saying like, prove like this branch and everything downstream from it. type checker ignore. But for the most part, for free, you get type checking. You get used to that. Now you move a level up. You say, OK, it's not just for checking consistency. I want a type checker to help me find edge cases. So these are things like null and undefined. But it could also be, what are situations where I'm forgetting to do error handling? What are situations where I'm forgetting to handle empty cases? I think you can get that sometimes for free. You might need to turn strict mode on, things like that. Sometimes you need to start writing your types a little bit differently. But you're still in the realm of, I think, pretty cheap to implement.
But then you can go another level higher. You start thinking of types as a domain modeling tool. And now you're trying to express business requirements in types. You're maybe working less with primitives and you're trying to create richer domain types that represent concepts in your app. And maybe even using that to flesh out your ideas. And then sort of the final level here is I think what you and I were talking about earlier, the idea of a type checker as a pair programmer. That's an assistant that you get to have a conversation with. And type checkers speak the language of types. So types are how you speak and respond to your type checker.
And I think that's where trying to get fancier and fancier in what you can communicate to your type checker, that's where you can really go off the deep end. Any thoughts on that rough progression of maybe journeying through type systems and seeing their value? Yeah, I think that makes a lot of sense to me. I think there might be value in finding some more incremental steps because like two to three feels like a bit of a jump. But where I see that being super useful is someone who is...
trying to get buy-in with a team someone who has the familiarity is at the level where they feel like the compiler is a pair and is trying to impart that benefit that maybe a team isn't seeing because they're of course starting at the first level knowing what level is the next easiest to reach. Oh, I like that. And kind of what exemplifies those can help you lead, like understand where someone's conception of this whole idea is growing. And also being able to know what some end results that will inspire that adoption might look like. And so demonstrating some of the great benefits of higher levels while still interacting with the team at the level where they are, but showing off what it could be so that they're motivated.
to climb that ladder with you. I love that. So sort of just a little bit of maybe wow factor from multiple steps higher up, but don't skip any steps with your team. Try to work through this ladder one step at a time. Yeah. I like your idea of having this more granular. I could even imagine a situation where it's maybe not quite a linear ladder, but maybe there are sort of branching paths. Yeah, I think there's probably a balance between those different concepts where more linear, to say that way, would be helpful for that kind of moving concepts along and working with another person. And then those branching paths could be for
when someone is bought in and they're like, what can I learn next? And you don't want to take them to the next level because that might be like too much, but you can say, hey, there's some branches from where you are. Go play around in those. I wonder if this approach to introducing types plays really nicely with something like TypeScript's gradual approach to typing, where if you just want that level one of trying to check for consistency, you bring it on like no strict mode, like a lot of that check's disabled. And you're just making sure that your function names are correct and that all the Legos snap together.
Maybe you even go like a 0.5 where you've got a bunch of innies in there where you're saying, hey, this entire subsection of the program, we're just going to ignore types in. And then you sort of slowly bring in types for everything as people see a little bit of value. And then once you sort of hit that level one, you're like, all right, we're feeling pretty comfortable. It's nice to have like a smoke test a little bit just to make sure I don't have a dumb typo in an object property or something like that. But it's not that valuable.
And now you can say, all right, we're going to do a big jump. What if we didn't have to get that pager message about a null or an undefined error? Wouldn't that be nice? Let's turn on strict mode and go fix those null bugs. During work hours. Yes. That's a good point to tack on there. During work hours, we can fix these things. I love that we've built up a concept of the compiler being a pair programmer for us as we're working with the code. But now it's kind of pairing with us at a pedagogical level and pairing with us to help bring a team along who might be newer to a type system.
Yeah, I think that's taking the best advantage of TypeScript's gradual nature right there. Now I want to come up with what is a similar concept or similar sort of terrain that I would take someone through testing. Yeah, for the ladder of testing or the pedagogical testing, or maybe even TypeScript is a gradual type system. Is there a gradual testing? I have to think on that. Bring me back on for another episode to talk about that. Yeah.
Well, thank you so much for joining me and riffing on all things TypeScript and introducing types and the value of types. I know I have a lot to think about coming out of this conversation. Yeah, absolutely. Me too. On that note, let's wrap up. Sounds good.