Tired of overpaying for your cloud hosting? The good news is, you don't have to migrate to bare metal and become a DevOps engineer just to save a few bucks. Instead, you can stay on your current cloud host and cut your bill in half by using JudoScale, auto scaling that actually works. JudoScale monitors your web and worker services, making sure you only pay for the resources you really need. And when their traffic spike hits, no problem.
JudoScale scales you up faster than any other auto scaler. So request timeouts and backed up job queues are a thing of the past. JudoScale is a free plan you can use forever. So what do you have to lose? Visit judoscale.com slash bike shed for your special gift as a bike shed listener.
That's judoscale.com slash bike shed. 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 Kenville and today I'm joined by fellow ThoughtBotter, Sarah Jackson. So together we're here to share a bit of what we've learned along the way. So Sarah, what's new in your world?
Well, I recently picked up one of those Wubles kits for crocheting, those that know, no, but it is a learn to crochet by making like a small stuffed toy project kits. So I bought one recently. I'm a knitter. I've been knitting since high school, but crocheting, the ability to do it, has always escaped me. The instructions are always too confusing.
And I'm most of the way through this kit over the course of this week. And I feel like the heavens have cleared, have part, they've opened, the sky's clear. I can see clearly now how to crochet. And I've been pretty successful with this kit. Do you feel like this sort of kit approach makes it more accessible to a newcomer?
Absolutely. I had a little bit of hubris coming from already having experience with knitting to think that I could take on crocheting, learning to crochet by myself. Many times in the past. And some of the mistakes that I made then that are different compared to a kit is the material that I was using often. The kit provides a very easy to work with, yarn material.
That doesn't split or fray. The needle that they provide as well is a four millimeter needle, which is on the like medium side. If you start too small, it can be really difficult. So having the right tools, you never realize how having the right tools to learn a skill really impacts it. So what you're getting here is a little bit like the Apple experience, the everything has been handpicked to work together so that your experience as a whole feels very smooth.
Absolutely. It was very seamless. The instructions, they made a number of very short videos walking you through literally every single step, every single thing you're doing in the project. And you just click next, next, next, next in their own UI. And that with the tool, there's so much that put in.
I kind of scoffed at these kids. I was like, I know how to knit. I can crochet on my own. I don't need this kit. I don't know.
I was wrong. But also pick up new skills. So that's I think a win in your column. Absolutely. I made it in adorable plushie.
I'm going to give it to a friend. It's a good time. Exciting. Do you think that we might have something that's equivalent to a kit like that in software that makes maybe learning to code or learning a particular language or framework really accessible because everything's sort of curated and packed into one? Yeah, I think we do.
There's a number of tutorials that are wonderful in the text base. Millions, probably. That's relatively new that I'd love to share out for those that might not know. We at Thoughtbot, one of our Thoughtbotters, Steve Palito, championed this new project called BotCasts, which is a app that you would, as the individual, as a learner, build on your way to learning Hotwire. It's part of Hotwire Central's.
You would learn how to apply Hotwires, Turbo, and stimulus libraries to a podcast style app where you're searching for episodes. You're listening to the podcast in the app. And this is the kind of tutorial tool, whole experience, that I feel is very analogous, where it has a learning objective, but everything is packaged together neatly and presented in a way. You're not starting from scratch. You're not starting from, OK, I need to make the first stitch.
And I have no idea. It's just going to fall off of my needle. You already know maybe how to do a Ruby on Rails app. You've never used Hotwire before. It's built on the spaces that's already been provided and learned together.
I mean, knowing your audience already is a key part. I think of any project like this. So knowing are you trying to teach someone to code for the first time? Or are you looking to engage with people like you said who understand Rails but don't understand the new Hotwire stuff? Absolutely.
Do you have any tools like this or kits like this that you'd like to shout out or that you have found exceptionally accessible? I think a trend that has been really positive for the industry is for languages and frameworks to have a live playground on their official site. I remember back in the day when things like TriRuby came out. That was pretty groundbreaking. The idea that, oh, you don't have to figure out how to install the language on your computer, which can be really tricky and annoying and a kind of a different set of skills if you're new to all the software stuff and installing packages and all that.
Absolutely. So having the opportunity to just try out a thing on the website and get a sense for the language and build some skills without that skill floor of having to understand how to install something locally. I think that makes a big difference. It's kind of table stakes nowadays. Most languages have this.
But I remember it was a big deal. And that's the thing that I really appreciate. I remember that site. I enjoyed it. I think beyond that, just like a sort of a rebel, that you can try out having more of a playground style where you can try out things and maybe even link or embed examples can be really great.
I've used this a lot recently with TypeScript, where I want to just try out an idea in TypeScript. I don't want to start a project or configure a bunch of things and I'll just go to the TypeScript Playground, try it. It'll be a 10 line thing. Just like, does this thing type the way I expect it to? Does this logic work?
How I think it will. And maybe then I can link it to someone else if we're having maybe in the middle of a conversation with someone about how to structure something. And I guess we could get on a call and load up an editor and do some things. But also, for just going back and forth on Slack, we can, hey, let me try this. Paste this code snippet that you gave me into an editor.
Just make sure that this works. And maybe I can link it back to you and say, actually, there's a type error right there. And I don't know why. And then the conversation continues. So it's a great piece, I think, that allows you to engage with the language with a very low barrier to entry.
Yeah, I love those because it's one thing to hop on a call with someone. But maybe nobody has time being able to have that asynchronous communication of, here's a snippet that will work in this playground no matter what. You don't have to have the perfect setup to test it out. Super helpful. So you and I were recently talking about a little bit how different it is when you're working on a project that is greenfield, where you're writing code for the first time.
And a lot of the work that you're doing is deciding new features and then implementing them, oftentimes with a very tight deadline. So you might be having to make some difficult technical trade off decisions versus work where you're coming into a well-established app and you're doing work that maybe you're adding new features, but a lot of it can feel more like maintenance. Or oftentimes before you can add a new feature, you've got to do some cleanup. And that experience can be very different. Oh, yeah.
What would you say are some of the main distinctions between working in those two modes? Speed is going to be very different, I feel like, between those two. It's much faster to work in greenfield mode. Yes, that is the priority is speed to integrate, getting a tight feedback loop with stakeholders or customers if you have access to them and building up something new versus when you're maintaining or updating, you can still move fast, but it's not, I feel like it's not going to ever be at that breakneck speed. There's going to be more thought put into changes, how it fits into other things.
Does it break anything? You're probably going to have more eyes on it in terms of code review. So speed would be, yeah, my number one difference that I would see that I see between those two modalities. I guess like you're talking about the implementation code level. There's probably more speed as well, even at the product level, deciding on features.
I feel like when you have no other features that this has to be compatible with, you can do whatever you want. Sometimes it's paralyzing, right? It's the writer's block, the blank canvas effect. But on the other hand, when you have a large app and it's already got a lot of features, any new feature you have to add has to be compatible with what's existing there. And so at the sort of UI, UX side of thing, you want the experience to be compatible.
You don't necessarily want to just be introducing new patterns, but also the actual behavior that you're adding has to feel cohesive in the way that it plugs into existing functionality. Definitely. And so now you're not just adding a new feature out of the blue, you're having to think, how does it fit in the broader picture of what we've already painted? I think that also goes hand in hand with another aspect that I think about between these two, which is the ability to throw work out cheaply. Mm.
Is it cheaper in greenfield mode or in maintenance mode? I would say it is cheaper in greenfield mode because in some ways, the goal of building up your MVP is discovery. You have you have an open road in front of you and you have some signs along the way that have been laid out of, we want this feature, this feature. But oftentimes, customers don't know what they want until they're shown something else. And your changes should be quick and light enough.
The feedback loop should ideally be tight enough that you can throw away a feature and it's not going to break the bank. Right. Whereas an app that may be long running has a dedicated customer base, maybe is on the larger side or not even larger side, just an app that's established, right? It is going to take a lot of buy-in from different types of stakeholders to be able to just throw out a feature. Yeah.
And you were talking about how customers might expect you to change or they might not know what they want until you show them the thing they don't want. Oftentimes, with an established app, you have the almost opposite pressure. Your customer base have gotten used to the way it works and now they are resistant to change. 100%. And you change something and they push back and they send out an angry email and like, I like the old interface.
Yeah. This is a classic danger, not just in code. This happens with food even. You think of Coca-Cola. It's a different taste than Coca-Cola.
When they were able to develop a sugar-free zero-calorie soda that tasted more similar to regular Coca-Cola, they were not able as a company to then sunset Diet Coke because it had such an established user base, customer base, fan base. It is its own entity now. You can't go backwards. You can't take it away. It's mine, the customer.
I'm going to take this in a bit of a weird direction. And I'm thinking like, okay, so now they have three products. They've got the original Coke, they've got Diet Coke, they've got Coke Zero. Not sponsored. That's me of how products can sometimes end up with like three different versions of bootstrap.
Yeah. Everyone's got the one version that they're used to, the style that they're used to. You could, yep, I've seen that. So I guess like one of the things that you have to manage in a more established application is, I guess you could call it technical debt, but also just needing a much deeper knowledge of the system because there is so much of it out there and there are so many sort of variations on things. There's not always a single right way to do things anymore.
Yeah. Something as simple as adding a feature, adding a section, adding, I don't know, click and drag or taking away click and drag. You know, these are big decisions on an established app that might have a large customer base that it's going to affect their day to day going forward, these changes. So a lot of thought has to go into that. I'm thinking also, there might be a difference in terms of how intimately developers know the code base on an established app versus on a greenfield app.
Yes. If it's greenfield, you're the one building everything. You designed all the pieces or at least had conversations with your one or two other colleagues who built the whole thing. You probably fit the entire app and its sort of mental model of the world within your head. If you came in as an employee three, four, five years into the life of an app and maybe you've been there a couple of years, you still don't have that like perfect knowledge of everything in the system and the system is also much bigger now.
And so when you want to add a new feature and you're like, okay, so we want to do this sort of, you were talking about drag and drop components. What do I need to know about the system that already exists that I might want to plug into or that I might need to change so that this new feature can slot in? And sometimes you know that and you might have to ask around and sometimes that knowledge just doesn't exist. And if you haven't stumbled across that part of the code, you might not realize, hey, somebody already built a drag and drop system that we could use or they have something that we could build on top of. And so now you introduce yours.
And now the system has like two ways of doing drag and drop. Yep. This is this is classic. You get the people in the greenfield situation who like you said they all are all able to keep the whole app context in their head at once. But as it develops, it gets bigger and bigger.
No one person would be able to hold it. And maybe a bunch of those people that did have that information leave, new people join, it grows. This is I feel like so many companies, especially ones that have grown from maybe smaller leaner startups to more established applications. This is such a evergreen issue. I feel like everyone has this at some point to some degree.
The brain drain of that, the knowledge is gone now and it is on us to dig through and find it again else. We end up with three different styles of dragging and dropping five different button shapes with slightly different shades of blue. I think it is so valuable at the greenfield state. As soon as things start normalizing, you should be documenting the structure of your app. But even before that, I feel like it is so important to write down your decisions.
You're iterating, you're deciding on this feature, not this feature, this style, not this style. Why it's going to be so valuable to everyone in the future. I think here's where we get at some interesting sort of diverging sets of incentives for these sort of two modalities, right? When you are in the greenfield phase, the first six months, the first year of writing an app, writing all these things down is just going to slow you. Mm-hmm.
And then you're going to be doing this for the longer term or more mature app team that are going to be working on this two, three, five years down the line. And they are going to really value that documentation. But it kind of hurts you and your incentives right now, which are move fast, iterate quickly, be very agile and responsive to change. So this is sort of work that you can do that will benefit people in a different modality, but it's not really something that will benefit you as much in that greenfield modality. It's true.
And there's always often a lot of pushback on, well, why should we write it down now? It's going to change tomorrow. I love that concept that you brought of it's not for the you now. It's for the people in the future, which could be you as well. Five years from now, I look at this code.
And what was it doing? Why did I do this and not this? There are definitely methods of keeping track of what you've done and why that aren't so time intensive, that aren't the big, scary documentation, even making sure that you have well thought out commit messages. You could just do a Git log. I'm a fan of commit messages.
I often come in as a consultant on well established code bases. Most of my work tends to be a little bit more in that mature modality. And I think that I often have to do because the people who wrote the original code are no longer there. And I'll see some code that looks weird and be like, why is this done this way? And then I start doing sort of Git archaeology and I start digging into things.
And sometimes it's really frustrating. I'll get to a commit and it's just like a one line message that's like do the thing. And then you go to a PR and there's not any extra context on the PR either. At least I maybe I know who to talk to if that person's still at the company. Sometimes they're gone, but it might be, oh, I can get a second degree source.
Like I know a person who talked to that person or who overlapped with that person or maybe even the person who approved the PR. They didn't write the code, but they maybe have a little bit more context and I can talk to them if I'm lucky. But when you don't have anything, you're just kind of stuck and it's like, oh, this was such a great opportunity for someone to put low effort note that would have helped me. It's like shooting your future maintainers in the foot ahead of time. Yeah, yeah.
But again, you're not personally incentivized to do that as a green field developer because again, that slows you down a little bit. You might not even be brought up in the world of code to do that. Right. It can often feel sort of superfluous, right? We're just sort of doing this to feel good about the sort of discipline of programming.
But are there really any tangible benefits? Yep. I actually got called out on this myself recently in a PR where I was writing an expectation and I named, I committed one of the cardinal sense. Oh, no. I named one of my variables, art.
Okay. And the one of my co-workers commented and asked, is there a way that we could make this more descriptive? And Sarah, a year from now, know what this was. Mm. And it reminded me, oh, yeah, that is super important.
I'm looking at this code that somebody else already wrote and adding to it. I should be mindful about what I'm adding as well and make sure that the next person that looks at it is getting the full meaning that's living in my head. It's hard to find that right balance of how much do you sort of document make things good for the next person versus how much do you just move fast? Mm-hmm. And I think that because a lot of the work that I tend to do is more often in that mature modelli, I benefit a lot from someone leaving an explanatory comment like, hey, the code below is weird and does something you don't expect it to.
There's a good reason I'm doing that. Here's what it is. Really helpful. I love that. Having a good commit message.
I'm looking up commit messages probably every week. These are all things that benefit me. So I have a lot of empathy with that. The problem is that that solves. And so that makes me more likely when I'm writing net new code to do things like that, to have useful code comments, to write fuller commit messages, that kind of thing.
You know, I just thought of a way that this would benefit the person in the Greenfield project in the moment. Leaving yourself a good commit message on something, A means less communication needed necessarily between teammates that may be working on different parts of the app, even if it's small. But also, it means that if you're sick or something, you're out for a week, things change. You should be able to go back one, two, PRs, whatever, things may have changed a lot because it's Greenfield being able to look at that commit history and get caught up super quickly. Yeah, all of these things have benefits for everyone.
Some things benefit more, particular sort of persona. And I think they're also more incentivized to do that. I wonder if there are ways that we can have sort of both personas maybe build a little bit more understanding and empathy for each other in their needs. Because sometimes you have the opposite side, right? Someone who's in that more mature code persona, looking at code written by someone who's in the Greenfield modality and being like, wow, what trash?
Why is this person so awful? And you look not fair. It was actually them five years ago. That does happen too. But I think sometimes stepping back and realizing, wait, they're operating under a different set of constraints and made this decision hopefully sort of in a thoughtful manner to try to balance some of those constraints.
But understanding that the constraints are different for these two modalities and how that can help us from both perspectives, appreciate the other. Definitely. Once an app becomes something that's been maintained and maybe feature will slow down, it's so easy to forget that there was a time where this app was trying to get to market. It was trying to meet a deadline. It was trying to meet a promise to a future customer base.
And when you're in the exciting world of Greenfield, it's easy to get swept up into the unknown, into the sky is the limit freedom in a way of we want to make this the best we can. And sometimes that means throwing spaghetti at a wall and forgetting why we picked one piece over the other. So we've been talking a lot about documentation and helping people understand why things were done. But I think there are other things that can also differ between the two modalities. And one that I've run into has been building APIs.
Let's say you've got a backend in front end. For APIs where you're always just adding new endpoints but never going back and modifying the old ones, you can get away with a lot of things such as in your front end, maybe not validating the inputs. You just assume that they will come in one shape because that's sort of the shape that they were when we initially did it and will never change it or have never changed it so far. And it's faster. So let's just go with that and things will be fine.
And you don't have any kind of schemas happening on the backend or on the front end. You don't have any input validation, that sort of thing. And that's fine as long as you're always adding net new code. You're never doing any sort of breaking changes to the API. But eventually, you're going to want to go back and add a new feature that is not just adding a new section to the app, but it's modifying an existing section.
Now, maybe you're going to ship a bug to production because you didn't realize that under certain circumstances, they're now breaking changes in the API and your front end is not getting the data and the shape it expects and now it crashes. And I think someone who's in that more sort of maintenance or not maintenance is more a termodality where yes, we've maintained an existing set of endpoints and we expect that they will need to change. They might have a whole different set of practices around how they manage designing an API and maintaining it than someone who's in that green field of the alley. Absolutely. Often in the green field project, the person implementing both the API and the front end might be the same person.
Whereas it's very often a case that in more developed applications, you would have front end specialists who then you would need to communicate with diligently about any API changes. Do you think it's valuable for someone who's working in more of that green field modality to be thinking through a far ahead about some of these things? Or is that something where you've got to say, look, I know there are practices around, let's say API management where you might want to think about versioning, you might think about schemas, you might want to think about input validation, I think things like zod on the TypeScript side of things. Are those things that you might recommend that someone in the green field modality consider and think about?
Or is it okay to say, look, we are trying to move fast, everything's sort of append only, we're always adding new things and so that we can kick that problem down the road and sort of build something more robust in the future if we need it because we just need to get to market. In the classic consultant way, I will answer that it depends. Of course. I do feel that schemas are valuable immediately, but that is not realistic. I would say for a green field, it makes sense to move fast and to maybe push off a more formal schema until later.
But also, if you can get tools that will automate that for you and it's a low lift to incorporate them, I would do that. Something that will look at what you've written and extrapolate a schema for every change that you make without human interaction, I feel like that is something that would be valuable for you in the future, even a few weeks from now, as well as the maintenance folks down the road. Honestly, I think that's one of the things that I really appreciate about GraphQL. There are a lot of sort of quibbles around how GraphQL works, but having a sort of built in schema from the beginning and oftentimes being able to code gen the integration on the client side means that there's just a whole class of problems that you don't have to think about.
And the lift introducing GraphQL is not that high when you're in the green field stage where it's hard to justify. So I think you're really onto something in terms of tooling can help that. Now I'm wondering, we were sort of talking about these two modalities and how they can often feel very different in terms of incentives and maybe even the style of code that they write. When you touch on the idea of tooling, what are maybe some ways that tooling can help bridge that gap or maybe make that gap narrower so that maybe when you're in that green field phase because it's such a low lift, you tend to write code that will be more easy to work with when you're in that more mature phase. Things that will automate documentation, things that tooling that will run your test sweet and verify it.
So setting things up like CI and that kind of thing from the beginning. Yeah. When there's almost nothing there in some ways, it's almost trivial to set up those tools, those CI tools. And having that be a part of your process early is going to pay dividends down the road. How do you feel about code formatters for like standardizing the way that your code is written.
So that's standard for Ruby or prettier for JavaScript. Oh, you need it. Day one. I don't want to hear any more bike shedding decisions about where the brackets go. I think you're on the wrong show.
Having something like standard that can just auto apply fixes and it's not going to change the content of your code, how it runs, it's going to make it a uniform repo where you're not confused about what you're looking at. If you're looking at two files written by different people, the format will be the same. The mental load is so much lighter when you don't have to worry about those small things. And then if you find that formatting issues like that, if you find that there are questions that get written about, should we do it this way or this way, add it to your linter?
Add those rules. Don't argue about it in code reviews. Just add them and make it automatic. I love that. You mentioned the idea of reducing mental load.
And that got me thinking about one of the big selling points of Ruby on Rails is conventional reconfiguration. And I think that might be one of the selling points of the framework as a whole is it can bridge that gap between the greenfield modality and the established modality relatively well, because you're not jumping into an app and being like, okay, so how did the previous team handle things? What patterns do they use or make up? You already know where all the files are going to be. And it allows for a much smoother transition into modality where developers don't have to hold the entire context of the app in their head or the entire history of the project in their head because they didn't build it all.
Yes. I am a huge fan of this concept. And it's something that you don't see in a lot of other languages and frameworks, the idea of convention over configuration. It makes it so that somebody who's fresh out of college who's familiar with MVC can say, I know this is going to be that the controller's going to be in the controller's folder, but the model's going to be in the model's folder most of the time when you're working with Rails app. It is so nice to be able to carry that like a priori knowledge with you.
Right. Now I'm wondering in terms of things that might be sort of high value to do documentation on because you can't do perfect documentation, especially in that greenfield modality. But maybe the things that are highest value are patterns that you've introduced into the app. And I think it's a little bit harder to cross that between the modalities in a JavaScript app because every JavaScript app sort of does their own sets of patterns. There's a, you know, maybe it's a, there are 10 mainstream patterns that you pick three that are in your app that you just have to be aware of what were the patterns the last five or 10 years and which three did they pick.
But oftentimes you'll also come up with your own. And so getting a sense of which ones are there and sometimes you have multiple overlapping ones. So maybe that's a thing where having a, in your, in your wiki or maybe even just a docs directory in your project, here's a patterns directory. And we've got five or six short files and it's just like, here's our pattern for how we make that HTTP request in the background. We use this approach.
Maybe you link to a well-known blog post or documentation on the thing. If it's a standard pattern, if you've made your own, give a few examples and explain it. And that helps onboarding new people, but will probably also help you navigate that transition to establish that better. I love that. I don't know.
That's something that feels like might be worth the time because documentation is expensive. It is, but I absolutely love that. And I would go even further and say, you can just put it in a comment in one of the files where you're introducing or using these patterns. Have people extract the comments in the future, you know, push that down the road, but get it written down somewhere. I love that so much, especially like for JavaScript, as you were saying, because there's going to be future people, you as a greenfield project developer, you know your project is going to succeed.
It's going to be great. You're going to get more customers. You're going to need to grow. More people are going to be hired to join your team. And wouldn't it be nice to not have to argue with them about which patterns to use?
If it's already written down, that's the way the team works. I like that. As we wrap up here, I'd be curious to hear from you. If you could have sort of one thing that you would want greenfield developers to keep in mind for mature app developers who might come after them and vice versa, what would be one thing you'd want mature app developers to keep in mind about the greenfield developers that came before them? As a greenfield developer, I would hope I would love for those folks to keep in mind.
How hard is it going to be to change this? It doesn't mean thinking of every potential change that could happen. It just means making your code modular and clean. And that benefits the people coming after you, but it could also be beneficial in the very short term where you're trying to iterate very quickly. So that's the thing that I think if you don't over engineer things, oftentimes can help you move more quickly in the short term while also allowing that transition to another phase of the app to be successful.
Mm-hmm. Because one day you're using one third party tool that you pay for. Then you just go through the roof and then use another one. But, because you did the work right and you left it all modular, it doesn't cost as much to switch. So that's something that a greenfield developer might keep in mind, realizing that there will come a time where the app is more mature state and people are going to come in and build an app and that's a way to build them and understand them.
What about the other way around? What can mature app developers and maintainers keep in mind to feel that empathy for the green field developers that came before them? doing the best that they can at the moment and doing what they think is right. I don't know that I know of any developer who would competently say, I'm pushing the wrong thing with their full chest. So having trust that the folks that came before you, even if they were wrong, they were doing what they thought was right at the time.
And so you can almost step into their shoes and think five years ago, when this was a different size, what might their thought process have been given this thing that they did? So trying not to be too harsh or judgmental about the code that you see there or why it's making your life difficult right now. Yes, but also I feel like you can gain insight from the perspective of where the app might have been, what situation it might have been, what the priorities or features that were on the table might have been at the time. It can inform the direction they might have been going. I love that approaching through the past with curiosity and instead of being frustrated at whoever built the original version of the app, maybe asking, what do they have to teach me?
Yeah. Finally, I'm curious for yourself. I've done both Greenfield and sort of more mature established app development maintenance. Which one do you prefer? I was going to say that I would hope this would be obvious from how I've been talking this entire time, but I realize now it might not be.
I love a maintenance project. I love slowly adding features and making things better over time, the idea of finding a rusted tool in the ground and wiping off all the rust and making it shiny. I love those kinds of projects. What about you? I think I might be a little bit like you as well.
There's always something so exciting about Greenfield and getting to have that decision making power to set up the patterns and do it right this time. But also, I think sometimes the impact you have in an existing code base can just be so much bigger, even though it's smaller and more incremental. And I think it flexes a different set of programming muscles that I find really enjoyable. I agree. Well, on that note, let's wrap up.
Sarah, thank you so much for joining. Thank you for having me again. Thank you. Thank you.