Hello and welcome to another episode of The Bike Shed, a weekly podcast from your friends at ThoughtBot about developing great software. I'm Stephanie Eman. And I'm Joelle Kinville. And together we're here to share a bit of what we've learned along the way. So Joelle, it's been a few weeks. What's in your world?
I recently finished working on a larger refactoring initiative that turned out to be a lot bigger than I initially thought. And I went back and was just sort of doing a little bit of a summary of what I'd done and some stats and some impacts. And I saw that I had done, I think it was like 25 or 26 PRs to get this whole refactor done. Wow. Yes. Refactors being longer or just bigger than you thought they were is an experience that I've also gone through. But 26 PRs is a lot.
I'm really impressed. I think I would have totally lost the plot if I were going through that process. Can you tell me more about just how that went? Yeah. So this was a bit of a change in the architecture of a certain subsystem of the app. And it was particularly tied to some performance issues that we were seeing. So the goal was to make things faster. And there was a way that the system was architected that was just not working. We had to change it out. I broke it out into a bunch of smaller chunks that could be shipped independently.
And so I was able to sort of continually ship something all the time and not feel like, oh, I've just got, you know, 5,000 lines of code in a refactor that's just ever growing sitting on my machine. So that helped me feel good. I think it helped the team feel good. So definitely breaking that down, I think, was the key thing that allowed me to keep momentum going on this and allowed me to actually ship something that worked. I'm curious, how are you keeping track of all the things that needed to be done as you were kind of working iteratively?
So I turned to one of my favorite tools, a dependency graph. And I started with my root nodes were what my ultimate goals were. You go to this page, you try to pop open this modal, and that is a fast action. It doesn't time out on you. And then it's sort of a multi-step process, and each step in that is fast, even under certain conditions where you have a lot of data. Working from there, there was some sort of like...
this cannot be fast under the current architecture with large amounts of data. These are the architecture changes that need to happen to get us fast. And then underneath that, there were a bunch of subtasks that are like, okay, these are the things that need to happen for us to get that architecture change. And then some pieces to allow us to do this in an incremental fashion. If you start from your sort of top level goal and just sort of like keep pulling on threads until it works, you end up having to do the entire thing, the 26 PRs worth of code all in one go. So by starting from the top and then mapping the whole thing out and then working from the bottom, I was able to have a picture of what I needed to do while also working in small chunks that could be merged to main and shipped. Did you find that even if when you were starting it, we thought was a leaf node, there turned out to be more dependencies from there as you were going along? One or two, but it wasn't too bad. Okay.
Cool. Yeah, that's really neat. I was just thinking about how cool it would be if our project management tools had a dependency graph view and you could start automating those things so that other people kind of know where your progress is and if you aren't available can kind of pick up from there kind of towards that top level goal, right? I don't know if that doesn't exist, someone should build it. I wonder almost if Dira might have a view like that because you can mark tickets as depending on other tickets.
And so with that, you should be able to, at that point, just a viewer saying, hey, we have this information encoded in all the tickets. Do we have a way to view these altogether? Yeah, that would be really fun. I think a very useful tool for all the dependency graph heads out there. I think a sort of kind of pithy takeaway from that for me is that dependency graphs are best designed from the top down, but they're best resolved from the bottom up. I have one more question, which is, is there anything you would have done differently? Ooh, I think I underestimated the size of this task, even from the beginning.
And it's kind of funny because I drew out the dependency graph and I shared it to the team. I was like, this is roughly how I think this work is going to break out. Don't worry. It looks really scary, but I don't think it's going to be that hard to do. It turns out it was a lot of work to get that done. Yeah. So it looked scary. Maybe rightfully so. Maybe rightfully so. Maybe I should have trusted the process a little bit more and not let my optimism carry me away. Cool. Well, I think that that is such an accomplishment. So that's awesome that you were able to, yeah, kind of wrap up that whole body of work. It sounds like it was a doozy. I felt really good about it. And at the end, I think it's always nice for a larger sort of subproject like that, putting together a mini report and saying, hey, this is sort of the...
Top level goals. This part of the code is faster. This part of the code is faster. This part of the code is faster from a user perspective. This many PRs were shipped along the way. Some refactors had to happen to allow us to make the changes. And as a bonus now, we have these things that are nicer for us to work with the next time we have to touch this code. A few sort of like side wins that were accumulated along the process.
So kind of putting it all together in like one little Slack post, like, hey, here's a summary of what I've done over the past few weeks. Here's what it got you. I think helped me look back and feel pretty good about the work I'd done and help the team be excited about that sort of arc being done and what we gained out of it. Yeah, that's a really great point that not only was it a really effective technical approach to delivering the work, it also as like kind of a byproduct was a great communication tool as well. So Stephanie, what's new in your world?
So I want to share about a production issue that I encountered this week. A lesson learned, I suppose, because I don't think I'll be forgetting it again anytime soon. But I was working on some legacy or just existing code that I wasn't really familiar with. And I came across this background job class that had a very kind of like strange name, I thought. It was called like Lambda Worker. And I realized later that it was called that because it had to do with kind of...
an AWS Lambda that they were using. But then as I was actually reading the code, I saw there was also a feature flag involved. And oh, wait, if this feature flag was turned on, we're actually not using the Lambda at all. And we're using a different thing now that they have implemented since, right? And so I was, I guess, putting my code archaeologist hat on a little bit and being like, oh, it looks like this feature flag is fully enabled. And we're no longer using my Lambda here in this class at all. So the name is misleading.
And I think someone was like, oh, yeah, it'd be nice if we could just kind of rename that so that it accurately reflects what the code is actually doing. I was like, great. Little nice little cleanup task for me to do. And so I did it. I just renamed it, deployed. And then suddenly I was getting yelled at via our monitoring service with a name error because it turned out that, you know, some people may have guessed already that the jobs that were enqueued during that time were still referencing the old name. And now that I had deleted that file, it couldn't find the class and couldn't process the job.
I don't know, I was also a little overwhelmed because it was retrying after failing. And so I had just like, you know, 10x the number of events in my error monitoring service than how many people were probably actually affected. So it was just very alarming. And yeah, I just had to like really quick revert because I was a little bit in panic mode and then had to think about how to handle that moving forward. But then the worst part was, is even after I reverted, I then got a new exception where during the time that my code was in production, it had enqueued jobs with the new name and now those can no longer process.
because I had yoinked to that code. So it was just, it was a mess. And I, like I said, a lesson learned. I don't think I'll ever forget. I forget not to just simply rename a sidekick class. And one really awesome thing that came out of it was, I was kind of venting about this to you, actually, in another Thoughtbot coworker of mine. And they had a really awesome suggestion of, I wanted to try this again. And having both.
classes live in the code base where the old class is basically just delegating to the new class name. And once those jobs are no longer being enqueued, that file can be safely deleted. So that's the route I'm going to go. And I was really happy with how kind of easy of a solution it ended up being, but you just kind of have to know to do that. Yeah, I guess the idea that renaming a class is effectively shipping a breaking change to your API. And I think we maybe intuitively know that if we're building, let's say, a JSON API and we rename an endpoint. We know that's a breaking change for our clients.
But in a sense, the same is true for class names where sidekick as a separate process that's pulling things from a queue is effectively a client. And so changing names is a breaking change. Yeah, yeah. I think that was a really good reminder about sidekick or just kind of background jobs being a type of boundary. And like you said, like a client. And again, I thought I had just done everything. I'd gotten, you know, found all the instances of the class name and everything and found all those dependencies, if you will. And I forgot the big one.
So, yeah, I hope if anyone out there who didn't know this before will remember the story. And next time they think that they want to rename me a sidekick worker, don't run into the same pitfall. Learn from my mistakes. I think there might be a more broad, interesting class of issues here in that the name of the class being used, I assume, is being turned into a string and then saved into Redis. More generally, anything that tries to save a name of something in your app to a string and then pass it elsewhere that then wants to use it, separate from app deploys, is probably vulnerable to this. So I could imagine some sort of situation where you're dealing with metaprogramming. And maybe you're storing some kind of token or something in a database column that isn't going to be used in your metaprogramming. If you update the class name of whatever's going to be...
evaled or classified or whatever in the app and you do deploy, that doesn't necessarily update the content in your database. You need to go and modify that. Yeah. I was just thinking, I ran into something kind of like that when I was thinking about using a polymorphic type because those types are stored as a column. Another example I can think of is caching as well, where sometimes you do store class names. So that's a really great point that it is a type of class of a problem. I feel like this is part of why something like the open-close principle is really valuable.
The idea that you can make changes to a system that's well-designed by adding new code to it and not necessarily modifying existing code. So by adding a new subclass somewhere or introducing a new strategy or a new component or something like that. Because those types of things tend to be non-breaking changes. Yeah, I like that a lot. I think, I guess this was maybe a...
Just a poor assumption on my end where almost feeling like our background job process was part of the system and not kind of a separate entity because it is so seamless, at least in Rails, that, yeah, it actually bit me this time. And when you're running locally, it might run in line and in tests and all this stuff. So yeah, it does feel like it's just part of the system. And if you did the name change correctly and not realizing that there's some state that's persisted outside. I can imagine you probably need a whole migration strategy if, take this a step further, you don't control anymore the clients that are holding onto that name.
So maybe these are tokens that you're storing on users' browser sessions or something, and you didn't put an expiration date on it or something like that. You could be getting API requests to a bad URL for a long time, or maybe some sort of native client or something that's holding on to the name of something that you're going to send up into an API that you're going to use with better programming, or maybe some sort of polymorphic association where you're sending up a table name. And you rename that, but you can't just do a migration to change it because it's stored in somebody's iPhone or somebody's browser. Oh, no. Now you have to be spiraling, thinking about all the different types of persistence that we work with that we don't, at least I don't think too much about, just thinking that it quote-unquote just works. But yeah, now when you are wanting to make changes, those things are sometimes, like you said, out of your control or not part of your system. And how do you manage that is a pretty challenging problem, I think. Yeah, well, especially once you start having more distributed systems.
you have to have that point of migration strategy. And some of that might be managing old code paths, sort of managing two code paths at a time, and then having some sort of sunsetting strategy for the old one that allows you to degrade gracefully. Yeah. And this is maybe a bit of a digression, but that I think is something that I've seen organizations struggle with where they end up supporting to like multiple of those code paths for a long time because it's really hard to kind of decide when to cut that off, right? And even though like, because like you said, distributed systems, I think there's a lot of things that...
aren't observable. So you don't have as much information on what are the proper conditions to be met in order to consider something migrated safely. Now you've got me thinking about the concept of connescence, which is a way to think about different forms of coupling, and specifically connescence of name, where two systems are coupled because they have to sort of know each other's name, or it might be a unidirectional. One system knows about the other system's name, which means that then if you change the name in one place, you have to update it in the other. And it feels like this is what we're running into, except now it's happening in a sort of like async distributed mode, which is where it gets really hard. Are there sort of refactors or ways that we can minimize our risk to that? If you're designing a system where, let's say you're interacting with Rails backend and some kind of JavaScript frontend, and you don't want to be vulnerable to a name change like that, are there ways we can design around that to make us less susceptible to that? Yeah. I guess kind of what I had mentioned earlier about what I ended up going with is I'm wrapping the new code.
with the old class, right? And so in some ways there is that seam. I am having a hard time thinking about some other strategies. Did any come to mind for you? And there are mitigation strategies saying, okay, well, we have this coupling. How do we make the name change in a way that is non-breaking? And I think that's where something like variations on the strangler fig pattern become really important. But are there ways we can design our systems to be resilient such that we don't even hit this problem in the first place?
so that I get a ticket that says, oh, go rename this class. And I know that I can rename it without affecting clients elsewhere because you did a great job designing it three months ago when we set up the original system. Yeah, wouldn't that be nice? Something that you mentioned was this is maybe extra susceptible when it comes to like asynchronous code because that is always a little hairy. And I similarly was thinking about like how now we have brought in that factor of time or asynchronosity or whatever. And it's an additional thing to juggle, right?
I think it's kind of ironic because I think our last episode, we were talking about Async Ruby with a guest. But maybe that is a bit of a consideration is what kind of complexity do you really need? Can you make things simpler so that you aren't having to deal with some of the tricky things that do come with something like using an asynchronous tool when you don't really need to, making some of those trade-offs with these kinds of issues in mind? I feel like in the back of my mind, I've got a hazy idea around trying not to expose internal names externally. And maybe something like Sidekick can be considered sort of internally, so that doesn't apply quite as much. But I'm thinking of if you're dealing with third-party clients, or even just we have a React app or something that's talking to us. Ideally, I would want to be able to rename a class in the Rails app, and that should never affect the React app. And maybe we have some sort of names that we agree on, things like the name of an endpoint or something like that. But these are all, at that point, sort of like API-specific names, and they're not tied to classes or things like that internal to the Rails app.
So we have a sort of internal vocabulary for the Rails app. We have a API vocabulary that the React and the Rails app can talk to each other. And those two are decoupled. Yeah, interesting. I'm trying to think about how that would be designed because I tend to start maybe with the...
just kind of using the same names at the beginning, right? Because I do want to maintain that consistency. And oftentimes, maybe you don't have to have super complex serialization yet when you're kind of sending your data to the front end. But as you were saying, I was thinking that, oh, I do think that serialization layer does kind of protect you from what you're mentioning, just keeping those things separate and then having that interface in between. But that is not normally how I tend to develop because I only introduce it once it becomes.
once we're getting to a point where maybe having something else to handle those responsibilities would be useful. But I'm sure there are ways that you could still have something lighter weight. I think one way is a bit of a mindset change and making sure that you design your API in a sort of restful fashion and emphasize controllers as their own thing. You're designing resources that can be interacted with in your API rather than thinking of them as like a very thin layer that allows a JavaScript app to talk to your database. Because if you do that, then you're sort of coupling your JavaScript app to your database. If your JavaScript app knows the name of your database tables or...
We were talking about Rails polymorphic associations, where it would need to know the names of those models. And controllers don't need to be one-to-one with database tables or with models. You can model things the way you want. And I think emphasizing that in your own head allows you to write at least an API layer, a controller layer, that's a little bit more decoupled from your business layer. And then you've got more freedom to change that, and in particular, the database tables, without that affecting on the JavaScript side.
ideally you're not leaking the name of those models for your polymorphic association down to javascript so that then if you rename one of those models now when you're passing in a type parameter oh no that's broken and we need to release a new version of the app yeah that makes sense i like that it's a mindset change right where react is a client and i'm sure has its own then like kind of domain models specific to the front end that it can kind of be its own little world that is definitely something that maybe we'll start seeing everywhere after this conversation. I've recently done some work on a project that has leaned very heavily into the dryRB suite of gems and moved most of their domain logic into the lib directory. I think the idea is you don't marry your framework. And the idea is that your active record models stay pretty bare and they're really just interfaced to the database. And then most of the business logic lives in sort of plain old Ruby objects in the lib directory that in theory could be ported to another web framework if you wanted to.
And I think that's been sort of maybe the other side of that wanting to say, hey, this code is a little bit more decoupled from the database and decoupled from some of these names and decoupled from the framework of Rails itself. Interesting. So does that mean that the active records were pretty much only dealing with persistence? Mostly persistence and like querying, things like that. I'm kind of surprised that they were put in the lib directory because I've always kind of interpreted that as a place for things that are not specific to your domain.
Yeah, it's kind of the opposite. I think the idea is that it could be sort of extracted out and then plugged into like a Sinatra app or a Hanami app or something like that. And it's sort of a self-contained business logic. So I'm wondering, how do you think that worked functionally? It gets awkward. Rails is a framework. It does a lot of really nice things for you. And when you don't follow the conventions as much, some of the sort of magic breaks down and you start to do a lot of things manually. I think an important distinction is your sort of web layer versus your business logic model layer.
The web layer needs to be tightly integrated into Rails. So this means anything that happens in your controllers, you want all your objects to be compatible with ActiveModel so that you can use URL helpers, so that you can, especially at the view layer, you can use different view helpers. You can use URL helpers, form helpers, everything that Rails gives you to interact with things at the web layer get really clunky if you have to fall down to doing it manually all the time. Once you're sort of, you know, if you take a bit of an iceberg approach where you say what's above water is the web layer, it's your controllers, but then beneath that there can be a ton of like model stuff if there's like very heavy business logic and not just inserting a row into a database. That can be its own, like do whatever there. And I think that can work nicely. But what I found is at the layer where I'm dealing with objects in the controller or where I'm rendering objects into the view, I really want them to be, to play nicely with Rails ecosystem. Yeah, that's interesting. I...
I was just thinking about, I wonder if it would be more effective if you then were kind of using a different frontend or like really leaning into that different frontend framework and you were just using Rails as an API. maybe not needing those kind of out-of-the-box helpers as much. But yeah, that would feel very iceberg-y or just with really clear layers that you could cut across. And maybe that would be effective. I'm not really sure. But it sounds like if you are still in some ways coupled to opposite ends of the iceberg and you don't have that middle layer, then you'd have to circumvent, I don't know, go around it, figure out how to circumnavigate the iceberg. I don't know. My metaphor is breaking down. But yeah, I can see how that would be quite annoying. I think in my mind, the waterline on this iceberg is anything that touches...
the web. So mostly the controller and view layers. Anything that's above that waterline, I want very much in the Rails ecosystem. I think there's room to negotiate about what you want below the waterline. But above that, I found that it just gets really painful to do everything manually. Speaking of the Rails ecosystem, I'm wondering about things that maybe we don't use as much or kind of opt for an alternative for things that...
you know, are available to us, but maybe we like something else. Yeah. So, you know, I've been experimenting a little bit or my team's been experimenting with dry RB. That's a sort of very different way of handling things. I'm curious for you, have you on a recent project deviated from sort of classic Rails standards or just sort of out of the box Rails new? I think, and not so much the project I'm working on, but sometimes I've heard some...
opinions about certain kind of features in Rails that people generally recommend avoiding, right? Things like callbacks, especially on active records. I hear oftentimes like, oh, like I try to avoid them. You know, they get really hairy. It's hard to know what's going on. And that got me thinking about like, oh, like that is kind of funny because I think they are kind of one of the first things that you learn that you can do with active records.
yeah, I'm not really sure how the community feels about them, but I generally sense kind of like an avoidance, at least just based on what conversations I've had in recent years. Are there things that you tend to prefer over callbacks? That's a good question. I find, okay, I was thinking about this and I almost wonder if like the way that we're using callbacks is just like not really how they were meant to be used. I suspect that kind of might be closer to the heart of it because when I've seen them be really troublesome, they end up doing like a lot of work. So you might have an after create like,
a whole method that maybe calls other methods that does a lot of that business logic. And now you are really coupling that to persistence when it may or may not need to be. And I found composing those kind of separately, especially when they also end up being a little more niche to a particular use case or problem. I saw, actually, I can think of an example in my current work now where I think they had kind of introduced a new... model that was associated associated to an existing model and wanted to make sure those things were always kind of created together but it was really meant to serve like the situation where they were trying to backfill data rather than kind of be like in perpetuity kind of coupled together and so now I think once that callback existed it was really hard to tease out like when or when you shouldn't have that coupling essentially because now it was just It was just there. And I think those are really hard to walk back in my experience. Yeah, I've definitely been burned by callbacks before. I think it's hard about them is that you often realize that there are some situations where you don't want them to run. And so then you start having to add a bunch of conditions on them, but there's always like weird exceptions. And then they run in situations where they shouldn't and that becomes problematic.
The classic one is you have something that sends email and you accidentally trigger that because you were playing around in the production console and you were just like saving a user somewhere and the system decides to send out an email because that's a callback. So I'm not going to say I never use them, but they're definitely something where I feel like I've been a little bit more. I tend to get burned by them more than I think I've found them to be useful. Yeah. I think the other bit of trickiness is when I feel like I've seen them used oftentimes, like I mentioned earlier, when you have two or more.
kind of models or domain objects that like are need to be kind of associated together right like have some kind of connection but then when you are enforcing them via a callback maybe it's it's not just it's not loosely coupled they become really tightly coupled together and especially to whatever model that defined the callback so i think that is challenging and i'm almost wondering if like maybe they really are useful to what we were talking about earlier where if you're thinking about active records really only being like like being concerned with database operations. And I can see when I've had use cases like that, I think they are a little more suited because even in the example you just shared, it's like, you know, maybe a user signs up and an email gets sent to them. Like those, even though it happens to happen on the creation of a user, they're not really the same.
There's a lot of context that matters. Yeah, that's a really great point. Context. We like it. A thing to keep in mind, I think, with callbacks, especially when you're using them to sync up data between tables or something, is that it can often be a smell for poor database table design, where you might be having multiple sources of truth. So maybe this data lives on two different tables, and you're using a callback on create to make sure that it gets copied over and the two tables stay in sync.
That might be awkward because the callback, the problem is not so much the callback itself, but the callback is revealing to you, hey, your database design has some redundancies in it. And if those two columns do get out of sync, now you don't have a way of getting a straight answer from your database about what is the count of these things? One of the tables has to win out. Yeah. Or God forbid, like someone inserts something directly to the database.
I feel like I always underestimate that actually happening, but people find a way or, you know, sometimes there's a genuinely good reason and then you end up being, like you said, very confused about the state of things. I'm going to throw another thing out that I do that's a little bit different than the Rails standard. And I think probably most of the community is with me on this. I test with RSpec and not with Minitest, even though Minitest is the default testing system that ships with Rails. Yes, I...
And the same, though I think it's just because I haven't had an opportunity to use Minitest, really. At least with most of the teams and organizations I've been on, we've always used RSpec. And I almost wonder, what's up with that? I don't really have an answer. But it seems like it's just one of those things that you can bring over the thing that you're familiar with. I think I have used Minitest once or twice. Have you used it as your primary testing framework on a Ruby project before? I have not. I use TestUnit, which is sort of the predecessor to Minitest.
I think Minitest has added a lot. So traditionally, TestUnit and Minitest were much more restricted in terms of what they could do. And our specs provide a lot of functionality. I think Minitest now is a little bit more featureful. It also has a spec style that mimics a little bit more of our spec with sort of nested blocks, as opposed to writing classes and every method in a class is a test. That always felt weird to me, but that's a stylistic thing. I think it's much more restrictive in terms of matchers. People mostly do assert equals.
And I honestly think a lot of people in RSpec will just expect something to equal and don't take advantage of the power of RSpec matchers. But I think if you do use them, they have the power to give you much better error messages to write tests that are more readable. So that's the thing that I like. I think RSpec has more powerful sort of mocking and stubbing, which can get you into a lot of trouble. But some of those features in RSpec are really nice when you're backfilling tests on really clunky code. And I think this is something, I think Jared Norman mentioned this when he was on our...
show a few episodes ago talking about the power of RSpec for testing code that is really clunky. Yeah, that's interesting. I'll have to experiment with trying many tests because I almost think it could be really fun to see how I would test things with maybe a more limited set of tools. Because like you said, RSpec is really powerful. With great power comes great responsibility. There's a lot of ways that you can do some funky things. And in some ways, I actually am almost feeling a bit more called to the simplicity of something that is more just like writing Ruby as opposed to
Kind of that fancy DSL. It's always more complicated. Exactly. So I, yeah, I think that could be a fun little thing I do. And I would love to report back if I try it out, but I can already think of a catchy blog post title, like learning mini test after five years of RSpec. I don't know. But I almost think it's kind of like you've mentioned when you like learn new languages and you bring something with you kind of from that. I'm really curious kind of what I might be able to take away from that. So, you know, I'm going to add that to things to do in my investment time. Nice.
I think we've been talking about different ways that we maybe have pushed outside the boundaries of what's traditional Rails or done things a little bit differently. I would like to make a pitch for the value of following some of the Rails conventions and following the defaults that are there. In particular, ActiveModel is really nice. If you are doing any sort of object that is not database-backed, it's probably worthwhile to see how it fits into the ActiveModel ecosystem, whether you inherit from any of the ActiveModel classes or modules. or whether you just write your own that is compatible with that interface. But writing objects that they kind of plug and play into the Rails framework, tie into all those helpers, I think is a really valuable thing. And if you read the documentation, there's a lot of stuff in ActiveModel. And sometimes you accidentally reinvent the wheel because you're like, oh, I want to write an object that does this, or I need custom attributes or things like that. And it's like, wait, ActiveModel already gives that to you. So I would recommend take some time, read through the docs for ActiveModel and familiarize yourself on what's there because you might be getting some things for free. That's a really good tip. Yeah, I...
I feel like I have a hard time knowing what is from Active Record and what's from Active Model, and I would love to be able to leverage some of those things more. I also want to plug, there's a blog post from 37signals called Vanilla Rails is Punty that was really helpful for me to see what you could do with concerns, which is something that I also think... I don't know, has kind of like lost favor, at least in the dev circles that I run. Maybe because it is kind of like, what is even a concern? It can really be anything. But I have, I've seen more that are just like, make your models richer. And especially ones that I think have really great naming, or maybe like named as adjectives, I think for your models. I find those to be really, really nice and really composable. And yeah, they, I think they can be, be used in a way to.
Yeah, just your typical Rails conventions. And I think that's really cool. So I really enjoyed that kind of... It's not even an alternative, right? It's like going back to the original intention. But kind of after seeing a few different iterations of what that has looked like in the past few years with different design pattern trends, I have liked integrating kind of the idea of some of the things that Rails offers in that way. I feel like now I want to do a deep dive into what makes for a good concern. How do you design a concern that is like...
joyful to use and you can just pull in and you're like, oh, that makes so much sense and it enriches my model, but I don't feel like I need to open up that file all the time to see exactly the implementation versus ones that are like, oh, you did that again and now I'm going to jump to another file and that's really annoying. So I think that would be a really fun topic to explore, but that's probably a topic for another episode. Cool. Well, I think we griped a little bit, but also, you know, some praises of things we liked about Rails, things that we do really like to stick to and things that maybe we are open to exploring different alternatives for. And yeah, I would love to know from our listeners what resonated with them, what kind of Rails defaults they love or hate that you'll, yeah, let us know your thoughts.
Show notes for this episode can be found at bikeshed.thoughtbot.com. If you enjoyed listening, one really easy way to support the show is to leave us a quick rating or even a review in iTunes. It really helps other folks find the show. If you have any feedback or questions, you can reach us at hosts at bikeshed.fm via email. Thank you so much for listening to The Bike Shed, and we'll see you next week. Bye!