The Bike Shed: 317: Burn The Ships!

0
50
To the Left, to the Left


Steph gives an update about RSpec focus and how she often forgets to remove the focus feature from tests. She figured out two solutions: one using Rubocop, and the other from a Twitter user, suggesting using a GitHub gist. She also suggests that if you’re one of those people who misses being in an office environment, you check out soundofcolleagues.com for ambient office noise selection.

Chris has been struggling to actually do any coding and is adjusting to doing more product management and shares some strategies that have been helping him.

They answer a listener question about dealing with large pull requests and how it’s hard to recognize a good seam to break them up when you are in the thick of one.


This episode is brought to you by ScoutAPM. Give Scout a try for free today and Scout will donate $5 to the open source project of your choice when you deploy.



Become a Sponsor of The Bike Shed!

Transcript:

CHRIS: One day, I’ll grow up. It’s fine. I look forward to that day. But today, I don’t think it’s that day.

Hello and welcome to another episode of The Bike Shed, a weekly podcast from your friends at thoughtbot about developing great software. I’m Chris Toomey.

STEPH: And I’m Steph Viccari.

CHRIS: And together, we’re here to share a bit of what we’ve learned along the way. So, Steph, what’s new in your world?

STEPH: Hey, Chris. Well, in some fun news, Utah started his professional training as of this morning, which I’m very excited about. Because we’ve been working with him to work on being good with walking on a leash, FYI, he’s not, [laughs] and also being good about not jumping on people. And essentially, being a really good roommate. And he started training today, and we are using an e-collar, which initially I was really hesitant about because I don’t want it to hurt him in any way. But now that I have felt the e-collar myself and we’ve had a first day with it, it’s going super well. I’m very excited for where this is headed.

CHRIS: That’s very exciting. When does he start paying rent?

STEPH: Ooh. I’ll have to check with him, or I guess I have set those boundaries. That’s my job.

CHRIS: I just figured that’s a core part of being a good roommate. But maybe we’ve got baby steps or doggy steps to get there. But that’s exciting. I’m glad [laughs] that the first day of training is going well.

STEPH: Yeah, it’s going great. And the place that we’re going to the trainer they have horses, and mules, and goats. And so now I have a very cute video of him trying to play with a goat, and the goat was having none of it. But it’s still all very cute.

In tech-related news, I have an update for when you and I were recently chatting about the RSpec focus and how I mentioned that I often forget to remove the focus feature from tests. And so then that goes up to a PR, and I have to rely on a kind human to let me know, and then I remove it. Or worst-case scenario, it gets merged into the main branch. And for anyone that’s not on Twitter, I just wanted to share an update because I also shared something there.

But the resolution for what I was looking for there’s already a rule that’s written into Rubocop, but it’s specifically written in the Rubocop RSpec codebase. And with that rule, you can essentially just say, hey, let me know anytime that a test is using the focus metadata, and then make sure to let me know and fail.

And then if you don’t want to actually include all of Rubocop into your project because Rubocop is pretty opinionated, you can still add Rubocop to your project, but you can specifically add Rubocop RSpec, and then you can say, hey, all other rules disabled by default, but then you can enable that specific rule. So then, that way, you will catch all of your focus tests.

There’s also another approach that someone on Twitter shared with us recently from Marz Drel. And Marz shared specifically a really nice simple GitHub Gist that documents or exemplifies that you can add an environment variable that checks to say, hey, if we’re in CI mode, then add a before hook. And then that before hook will look for any examples that are using that focus metadata, and then it’s going to raise. And then if we’re not in CI mode, then don’t do anything, don’t raise, and carry on. And that’s just a really nice simple addition if someone didn’t want to pull in Rubocop into their project.

CHRIS: Both of those definitely sound like great options. I don’t think we have Rubocop on the current project that I’m working on. But I think the RSpec focus thing, the metadata one, seems like it’ll work great. More generally, I just want to thank folks out there who listen to the show and then write back in like, “Hey, this is probably what you want.”

There was a similar thread that someone shared around the RSpec::Retry stuff that I was talking about recently and the failure mode there and trying to get that into the Junit Reporter. And so they had some suggestions around that. Jason Rudolph on Twitter reached out, sharing just his initial exploration and thoughts on how it might be possible to extend the XML reports that are generated and capture a flaky test in that way. So that’s really interesting.

And again, just really love that folks are listening to the things that we say and then even adding on to them and continuing the conversation. So thanks to everybody for sharing those things.

STEPH: Yeah, it’s incredibly helpful. And then one other fun thing that I’d love to share, and I found this out from someone else at thoughtbot because they had shared it recently. But it’s a neat website called soundofcolleagues.com. And I know you’ve got your laptop in front of you. So if you’ll go visit it, it’ll be neat to see as we’re talking through it. For anyone else that wants to pull it up, too, we’ll include a link in the show notes.

But it’s a neat project that someone started where you can bump up the sounds that you would normally hear in an office. So maybe you want to bump up background noise of people or an open window. There’s one specifically for printers and a coffee machine, and keyboards are on there as well. [laughs] I have discovered I am partial open window and partial rain, although rain is just always my go-to. I like the sound of rain for when I’m working.

CHRIS: Gentle rain is definitely nice white noise in general. I’ve seen this for coffee shops, but I haven’t seen the particular one. Also, yes, I definitely know how to spell the word colleague on the first of three tries. Definitely didn’t have to rely on Google for that one. But yeah, nice site there. I enjoy that.

STEPH: I tried the keyboard option that’s on there because I was like, oh yeah, I’m totally going to be into this. This is going to be my jam. I don’t think it is because I realized that I’m very biased. I like the sound of my own keyboard. So I had to shush the other one and just listen to the rain and the open window. But that’s some of the fun things that are going on in my world today. What’s new in your world?

CHRIS: I’m just now spending a moment with the keyboard sound. It’s a very muted keyboard. I want a little more clackety.

STEPH: A little more clackety?

CHRIS: I was assuming it would be too much clackety, and that would be the problem. But it sounds more mushy. Maybe we can pipe in some of the sound here [laughs] at this point. Or we can link to these sounds, and everyone can dial up the keyboards to 100. But I, too, am partial to the sounds of my own keyboard.

But what’s new in my world? This past week and I think probably even a little bit more of the prior week, I’ve been noticing that I’ve been struggling to actually do any coding, which has been interesting to observe. And again, trying to observe it, not necessarily judge it, although if that’s not the thing that we want to be doing, then try and improve that. But mostly trying to observe what’s going on, what is taking my time. A lot of it is product management type work. So I am spending a good amount of time trying to gather the different voices and understand what is the work to be done, and then shape that into the backlog and make sure that that’s clear and ready for the team to pick up.

And then, thankfully, the other two developers that are working on the project are fantastically prolific. So they’re often very quickly working through the work that has been set up in front of them. And so I’m trying to then be proactive and respond to the code. But there’s almost a cycle to it where I’m just staying out in front of them, but they’re catching up with everything that’s going on. So it’s something that I’m trying again to be intentional about, name, share some of that back up with the group. If there are things that I’m doing that I don’t uniquely need to be doing, then let’s share as much of that knowledge as possible.

But one thing that I will say is the product management, shaping the backlog work is exhausting. I am astonished by just how drained I am at the end of the day. And I’m like, I don’t even really feel like I did anything. I didn’t write any code, but I am just completely spent. And there really is something to when the work is clear, just doing the work, I can actually find energizing. And it’s fun, and I can get in flow state. And sometimes, I’ll be drained in a certain way.

But the work of taking a bunch of different slack threads, and communications, and meetings, and synthesizing that down, and then determining what the work needs to look like moving forward, and providing enough clarity but then not over constraining and not providing too much clarity. And there are so many micro-decisions that are being made in there. And I’m just spent at the end of the day, and I have so much…I’ve always had a lot of respect for product managers and folks that are existing in that interstitial space and trying to make sense of the noise, especially of a growing company, but all the more so this week as I’ve been feeling some of that myself.

STEPH: I totally agree. I have felt that having a strong product manager really makes or breaks a project for me where even though having technical leadership is really nice, I’d prefer someone that’s really strong at the product knowledge and then helping direct where the product is headed. That is incredibly helpful. Like you mentioned, the work is exhausting.

There’s someone that joined the thoughtbot team fairly recently, and I was chatting with them about what type of projects they would be interested in working on. And one of their responses was, “I’d love to work on a project with a strong product manager because I have been doing that a fair amount for recent years. And I would love to get back to just focusing on coding.” And so I think they enjoyed some of the work, but they just recognize it’s exhausting. And I’d really like to just get back to writing code for a while.

CHRIS: Yeah, I’m definitely in that space. And I think there’s a ton of value to spending a little bit of time, like having any developer at some point in their career spend a little bit of time managing the backlog, and you will learn a bunch from that. But I’m also in the space of I would love to just turn on some music and code for a while. That sounds fun. There’s a lot of work to be done right now. I’d love to just be in there doing the work. But sometimes, out of necessity, the defining of the work is the thing that’s important.

And so, I think I’ve been correctly assessing the most important thing. And that that has consistently for a while now been the defining and responding to the work that’s in process as opposed to doing it myself. But, man, I really hope I get to dive back into the code sometime and use my clackety keyboard to its fullest extent.

STEPH: Have you found any particular strategies that really help you with the product management work?

CHRIS: I will say that I think this is a competency. This is a skillset and a career path that…again, I’ve been at plenty of organizations that I don’t think respected the role as much as it should be. But it’s an incredibly hard role and multidisciplinary communication at the core of it. And so I don’t think I’m great at it is the thing that I’ll say. So everything that follows is just to be clear; I’m not saying that I’m great at this, but I have been doing some of it. So here are some thoughts that I have.

I think a lot of it is in reaction to where I felt like the work was clear. So I have a sense of what it looks like when I can go to the backlog, trust that it is in a roughly solid priority order, pick up a piece of work and immediately go to work on it. And understand what are the end-user implications of this piece of work? Where would I start on it like, how technically? What’s a rough approach that I would have? And getting that level of specificity just right. So it’s not overconstrained, but it’s not under constrained. So having experienced that on the developer side, I try and then use that to shape some of the guidance that I’m putting into, say, the Trello tickets that I’m writing up here.

We recently introduced Trello epics, which is I want to say like an add-on. And that allows us just the tiniest bit of product management, like one level up. So instead of just having cards and a list that is like, here’s the work to be done, we now have an epics list that is separate to it, and it links between a card and its associated epics. So it’s like project and action within that project.

And just that little touch of structure there has been really, really useful to help look at like, okay, what are the big pieces that we’re trying to move? And then how do they break down into the smaller pieces? So a tiny, tiny bit of fanciness in our product management tool, not Jira-like not going in that direction yet for as long as I cannot. But that little bit of structure.

And then thinking about what has been useful to me as I pick up tickets. And then, as always, trying to just always be cognizant of what is the user’s experience here? What problem am I trying to solve for them? What is their experience going to be? How will they know how to work with this feature? And just always asking that and then framing the work to be done in the context of that.

STEPH: I like how you’re adamant about a little bit of fanciness but not all the way to Jira-like. I also like how you highlighted end-users. All of that, I think, is awesome when developers are able to expand their role to experience all the other facets of building software.

CHRIS: Yeah, definitely. I think that whole list of all of the different facets of where our work interacts with different groups. The more empathy or, the more experience that you can have there, the better that you’ll be able to understand how to communicate there, how to express things in terms, et cetera, et cetera. So a huge fan of all of those ideas. I am ready to just get back in the code for a few minutes, though. But for now, for as long as necessary, I’ll do some of this work. But I am trying to find my way to other things.

In terms of actual feature work that we’re working on, one of the things that we’re doing right now is restructuring our onboarding. So when a user comes and signs up to the website and then subsequently has to fill out a handful of other forms, there’s actually an external system that we’ve been working with that houses some of the core data of our application. And they have a hosted application form. So we can send the user over to them, and the user fills out the rest of the application on this other system’s site. And then they get redirected back to us. And everything’s got nice DNS entries for a particular subdomain and whatnot. So it looks roughly consistent. There’s some branding. But it’s still someone else’s UI, essentially.

And we were feeling enough pain from that experience. We were like; you know what? It’s time. We’re going to bring this back in-house. We’re going to do all the forms ourselves. We’re going to do a nice progressive little progress bar. You can see all the steps as you’re going through onboarding. We’re just going to own that more because that’s a core part of the experience that we’re building here. So biting the bullet, deciding to do that.

But there’s an interesting edge case that we run into, which is we are using Devise for authentication. Totally makes sense. We’re in Rails context; there we go. It’s the thing to use. But Devise exists in truly the Rails world. So like HTML ERB templates, the controllers have certain expectations as to what’s going on. So thus far, we’ve just let that exist in that world and everything else we’re building in Inertia and Svelte. But we’re just now starting to feel enough of the pain, and that Devise exists in this other context. And for a while, we just kept saying, “You know what? It’s not worth the effort to port it over. It’s fine.”

Because we’re using Tailwind, we have a consistent design language that we can use across them. That said, the components are drifting a little bit. And it’s like, oh, this one’s got a rounded corner like this, and that one’s got this color. And we don’t have the disabled style. But it is nice that it’s not completely distinct. But we have finally decided it is time. We need to port this thing over because we feel like the onboarding and authentication type flows; they’re actually a big part of the user experience or at least the first run user experience when someone’s signing up to our site. So we want to own that a little bit more.

One of the things that I ran into as I was trying to introduce Mailcheck, which is a library that I’ve talked about, I think in a previous episode…but basically, you can have it observe a field and if someone types in like, [email protected], you can like, did you mean gmail.com? And then go from there. And I think there’s more subtlety. They can maybe even look up MX records and things like that. But basically validate an email address heuristically and offer the nice, very friendly to a user, “Hey, did you mean this instead?” So not a full validation that says, “No, you cannot put your email address,” because maybe you have a weird one that sounds like Gmail but isn’t. But that’s a little bit trickier to implement both on the Devise side and then in any other place that we have an email input.

And so what we want to do is port over to Inertia and Svelte, and then everything’s in our nice, happy context with all our components and all the other work that we’re doing. And it really does just highlight how much I’ve come to enjoy working with Inertia and Svelte. They are fantastic technologies. And now I just want absolutely everything to be in them. So we’re finally going to bite the bullet, and I think port those over a little bit after we get the current batch of work done. But soon, soon, that’s the goal.

STEPH: I’m having a bit of déjà vu where I feel like there was a project that you were working on that was using Devise, and then removing Devise and replacing it with something else was a challenge. Does that ring a bell?

CHRIS: Yes, that is accurate. So I had a project that I worked on where we had both Devise and Clearance was actually what was going on. There were basically two different applications that existed; one was using Clearance, the later one used Devise. But then we folded those two applications back together. And by virtue of that, I tried to unify the authentication schemes, and it was like, nope, not going to happen. And then we didn’t.

STEPH: And then we didn’t. [laughs] I like that ending.

CHRIS: Well, sometimes you don’t. [laughs]

STEPH: Yeah, I love that ending because it reflects reality. Sometimes that just happens. In fact, I’m going to segue for just a moment because you’re reminding me that there’s something I don’t think I’ve shared with you yet. On my previous project, there was a particular feature. It was a big feature that someone had picked up and worked on.

And at one point, we were essentially playing hot potato with this feature because we hadn’t gotten it to the point that it was merged. There was too much that was happening in that pull request, although then we ended up merging it. But then we found lots of bugs. And it was just one of those features that we couldn’t really get across the finish line. There was always something else that was wrong with it or needed to be done or needed to be considered.

And we’d reach that point where Chad Pytel, who is on the project, was like, “We’re either going to finish this, or we’re going to throw it away.” And I felt a little guilty saying this, and I was like, “I vote we throw it away. I have lots of concerns about this. We are essentially reimplementing another complex workflow. But now, we are implementing it pretty differently in another portion of the application. It’s going to be hard to manage. The cost of adding this and maintaining this is a really high concern.” And so he talked with the rest of the team and came back, and he’s like, “Yep, we’re going to throw it away.” And so then he issued a PR, and we removed it.

And it was one of those moments of like; this isn’t great because then we have invested hours into this, and now we are taking it away. But it also felt really good that that’s always an option. And that was the better option because it was either we’re going to continue sinking more time into this, or we can stop it now. And then we can move on to more important work.

CHRIS: Sunk costs and all that.

STEPH: Yeah. I feel like it’s so rare when that really happens because then we just feel dedicated to like, well, we’re going to make this valuable to somebody. We’re going to keep this. And in this case, we just threw it away. It’s very nice.

CHRIS: There’s a similar anecdote that I remember. Actually, I think it’s happened more than once. But very particularly, we were working on a system. And this was with our friend, Matt Sumner, a friend of the show, as well been on a few times. And Matt was working on the project. And we got to a point where we had two competing implementations of a given workflow, and we were opting to go with the new one.

But there were folks that were saying, “Let’s keep the code around for the old one.” And Matt was like, “Absolutely not. If we do that, we might go…no, this will be bad. Then we have to maintain that code. We need to burn the ships,” as he said. And he actually named the pull request burn the ships where he just removed all the code. And I was like, I like your style, man. You made a decision here. We collectively made a decision. And then this is a classic Matt Sumner move. But he did the thing that we said we were going to do. And he just held that line. And I really appreciated it.

And it’s a voice that I have in the back of my head often now, which is just like, no, burn the ships. If we need it, it’ll be in Git history. We can recover it. But it’s going to need to be handled in the interim. We don’t want to have to support that code right now and for however long until we actually decide to remove it from the codebase. So let’s get rid of it. And if we really need it, well, then we’ll resurrect it, but for now, burn the ships. And I like that.

STEPH: I like that too. I think it’s one of those areas where it takes experience to feel that pain too. If you’re pretty new to writing code, you’re going to think, well, we can keep it around. There’s no harm. And so it often has to be that sage, that person who’s been around long enough and felt some pain from making that decision in prior centuries or years. And he’s like, “No, we’re not going to do this.” The WE collective of developers who have experienced the pain from this understand that that’s not a good choice. And so we’re going to burn the ships instead. But it is one of those that if you’re newer, you won’t think that way. And I think that’s totally reasonable that you wouldn’t think that immediately.

CHRIS: I think that tacit knowledge that oh, I’ve gone through this before, and I’ve experienced the pain, and now let me tell you about that. And let me try and share that with you because there’s always the cost-benefit trade-off. Because if that code stays in the codebase, then we know it works because we’ve kept it around for that whole time. And so there’s a nicety to that, but there’s a cost, that maintenance cost. And being able to express that well and being able to say, “I’ve been here, and let me tell you a tale,” but do it in a way that doesn’t sound overly condescending or explainy or things like that. I think that’s a very subtle skill and a very important one, and frankly, really hard one to get right.

I’m not sure I always hit the mark on that where I’m just like, “No, can’t do it. It’s bad.” I think it’s very easy to end up in a space where you’re just like, “No, it’s bad.” And they’re like, “But why?” And you’re like, “Because it’s bad. Trust me.” It’s like, well, I feel like you do need to be able to explain the stories, the experiences that you’ve had in the past, the anecdotes that you’ve heard, the blog posts that you’ve read that have really informed your thinking. But I think that is a big part of what it means to continue on in this profession and be able to do the work and make those subtle trade-offs, and the it depends because, at the end of the day, it all depends.

STEPH: Or you just issue a pull request and title it burn the ships. [laughs]

CHRIS: Burn the ships. Indeed, that is, in fact an option. And actually, while we’re on the topic of pull requests, this might be a perfect segue into a listener question that we have.

Mid-roll Ad

And now a quick break to hear from today’s sponsor, Scout APM.

Scout APM is leading-edge application performance monitoring that’s designed to help Rails developers quickly find and fix performance issues without having to deal with the headache or overhead of enterprise platform feature bloat. With a developer-centric UI and tracing logic that ties bottlenecks to source code, you can quickly pinpoint and resolve those performance abnormalities like N+1 queries, slow database queries, memory bloat, and much more.

Scout’s real-time alerting and weekly digest emails let you rest easy knowing Scout’s on watch and resolving performance issues before your customers ever see them. Scout has also launched its new error monitoring feature add-on for Python applications. Now you can connect your error reporting and application monitoring data on one platform.

See for yourself why developers call Scout their best friend and try our error monitoring and APM free for 14 days; no credit card needed. And as an added-on bonus for Bike Shed listeners, Scout will donate $5 to the open-source project of your choice when you deploy. Learn more at scoutapm.com/bikeshed. That’s scoutapm.com/bikeshed.

CHRIS: As always, thanks to everyone who sends in listener questions. We so appreciate getting them. They help direct the conversation and give us something to chat about. So this question comes in from Bryan Robles. And Bryan writes in about large pull requests. And Bryan writes in with, “My toxic trait is large pull requests. Any tips on when you get into a place where you’re fixing or refactoring something, and it ends up cascading to many more changes than you want it to? I sometimes can go back and break it up. But it’s hard to recognize a good seam when you’re in the thick of it.” So, Steph, what do you think? Large pull requests and finding yourself in them after [laughs] certain amounts of time.

STEPH: Yeah, speaking of that knowledge that often comes from experience, this is something that I’m certainly always striving to get better at. I think it does take practice. There are some things that I do that I can share. And I categorize them really into a before, and I guess midway. So there’s the before I set sail and set off to deeper waters list that I will think through as I’m starting a new task, and then there’s the I’m lost at sea. And then, I need to figure out how I’m going to organize this change.

So in the first category, when I’m first starting off a task, I consider what sort of changes need to be made, and are there any obvious roadblocks? So an obvious roadblock may be changing or updating a model that has one relationship, and I need to change it to has many relationships. Or perhaps there’s a part of the application that is untested. And before I make any changes, I need to document that existing behavior. And that really falls neatly within Kent Beck’s advice where he said, “First make the change easy (warning: this might be hard) and then make the easy change.”

So I try to think upfront what are some of the small, incremental changes that I can make first that will then make the final change easy? And then I separate that mentally into PRs. Or I may separate it into tickets, whatever is going to help me stay organized and communicate how I’m breaking up that work.

And then the other thing that I’ll do is I’ll consider what’s my MVP? So what’s my minimum viable pull request? What set of changes include just enough changes to be helpful to users or to other developers? Which, by the way, is also a helpful mindset to have when you’re breaking down work into tickets. So, as an example, let’s say that I need to fix some bad data that’s causing a site to error. So my first step could be to write a task to fix the bad data. And then, step two, prevent bad data from being created. And then probably step three, I need to rerun the task to fix data that was created during step two. But I can think through each of those steps and separate them into different pull requests.

And then there may also be the question of well, how small is too small? Like you’re saying, what’s a minimum viable pull request? How do I know if I am not delivering value? And that one gets a little trickier and vague. But ultimately, I will think, does it pass CI? Is this change deployable? And then I do have to define what value I’m delivering. And I think that’s a common area that folks struggle because we’ll think of delivering value as delivering a whole new feature or adding complete test coverage for an untested interface.

But delivering value doesn’t have to represent that end goal. It may be that you added one test for an untested interface. And that’s still delivering really great value to your team, same for delivering a feature to a user. You may be able to speak with that wonderful product manager and find what’s the smallest bit of value that you can deliver instead of the whole feature set? I think the smallest PR I can think of that I’ve issued is either fixing a typo or removing a focus metadata from an RSpec test. So that’s my starting point. That’s the before I set sail. Those are some of the things I think about. I have more for the I’m lost at sea. But what are your thoughts?

CHRIS: First, that was a great summary that you gave. So I totally agree with everything that you just said. I think part of the question I would have…So Bryan wrote this in and described this as his toxic trait. So he’s identifying this as something that seemingly consistently plagues him.

So I would ask, is there a way that you can introduce something? Like, are there natural breaks in your day? And can you ask the question at those breaks? Like, hey, I’ve been working on a thing for a little while. Is there a version that I could…like, could I close off a body of work at this moment? When you break for lunch, if you go grab coffee in the morning, when you’re leaving at the end of the day, use those natural breakpoints.

I’m not sure exactly what you mean when you say large pull requests. But if those are spanning multiple days, in my mind, if anything starts to span more than a day, I will start to ask that question to myself. And that’s a reflex that I built up over time by feeling the pain of large pull requests and putting it up, and feeling apologetic. And then having my colleagues gently, professionally kindly ask me to break it down into smaller pieces. And me saying, “I really don’t want it. All right, fine, fine, fine, I’ll do it.” And then I do it.

And it’s one of those things that I never want to do in the first place, but I’m always happy to have done after the fact. But it is work. And so, if I can get better at pulling that thinking and pulling that question earlier in the process, that I think is really useful. Similarly, I will try to, again, as friendly as I can; if I notice someone mentioning the same body of work at stand up for a few days, I might gently ask, “Hey, is there a way that we can find a shippable version of a portion of that of a subset? Can we put it up behind a feature flag and get something out there just to try and keep the PR small, et cetera?” And so gently nudge in that direction.

And then I think the other side of that is being very okay with one character PRs. Like, that’s it. We changed one character. It turns out we need to pluralize that word, or we need one-line changes are great. That’s fine. And more pull requests, in my mind, are better than fewer, larger pull requests. And so really embracing that and having that be part of the core conversation and demonstrating that throughout the team is a way to share this idea. So that’s perhaps more in the process or person point of view on this as opposed to the technical, but that’s part of the consideration that I would have. I am interested, and I’ll bounce back to, Steph, what you were saying of now that you’re out at sea, what do you do?

STEPH: So I need to react positively to some of the things that you just said because you made me think of two things. One of them is I’ve never had someone say, “Hey, Steph, that PR is too small. Could you add some more changes to it? Could you do some more work?” I have had people say, “Hey, that PR was hard to review.” But even then, sometimes getting that feedback from folks is hard because nobody really wants to say, “I had a hard time reviewing your PR.” That’s something that, over time, you may become really comfortable saying to someone.

But I think initially, people don’t want to say, “Hey, that was hard to review,” or “There were a lot of changes in that. Would you break it down?” Because that’s a lot of complex emotions and discussion to have there. But yeah, I just figured I’d share that I have never had someone complain that a PR is too small, and I’ve issued a single character change.

And then I love, love how much you asked the question of what’s the problem we’re trying to solve? And so there’s this ambiguous idea of a large PR. But what does that mean? What are the pain points? What are we actually looking to change about our behavior? And then how is that going to impact or benefit the team or benefit ourselves? And so, going back to the question of how do we measure this? How do I know I’m starting to break up my changes in a helpful way? We may need to circle back to that because I don’t have answers to it. But I just really like asking that question.

As for the I’m lost at sea part, or maybe you’re not lost at sea, but you’ve caught too many fish, and the fish warden is going to fuss at you if you bring too many fish back to dock. I don’t think this is a real nautical example. But here we are.

CHRIS: Was that the fish warden?

STEPH: Yeah, the fish warden. You know, the fish warden. [laughs]

CHRIS: Sure, I do, yeah. Yeah, I know about that, well-versed in fish law.

STEPH: [laughs] Got to know your fish law. If we’re going to talk about pull requests, you got to introduce fish law. But I’m actually going to quote Joël Quenneville, a fellow thoughtboter, because they shared a thoughtful thread on Twitter that talks a lot about breaking up your changes and how to break up your pull requests and your commits. And I’ll be sure to include a link in the show notes because it’s really worth reading as there’s a lot of knowledge in that thread.

But one of the things that Joël says is get comfortable with Git, and it makes a world of difference. In particular, you want to get really good at git add –patch, git reset, and git rebase interactive. And that is so true for me. Once I have gotten really good at using those commands, then I feel like I can break up anything.

Because often when I am helping someone break something up, it’s often they want to, but they’re like, “I don’t know how. And this is going to take so much of my time. It doesn’t feel efficient and the right thing to do.” And they’re probably right. If you don’t know how to break it up, then it may take you too long. And maybe it’s not worth it at that point.

But if you can ask a friend, and they can help walk you through this process, or if you can learn on your own, that’s going to be a game-changer because you will start to think about how can I separate these commits? And I can reorder them, and then issue separate PRs, or just keep them in separate commits, whatever process you’re looking to improve.

In fact, there’s a really great course on Upcase called Mastering Git written by someone who is co-host of this podcast. And it has a lot of great videos and tutorials that will help you get really good at these Git commands and then will help you split up your commits.

CHRIS: Oh yeah, I did do that. Warning: it’s like three and a half hours long. But it is broken up into, I believe, 10 or 11 videos. So you can find just the ones that you want. There’s a couple in the middle that I think are particularly useful talking about the object model of Git. Git is weird, unfortunately. And so I spent a bunch of time in that course. Also, thank you for the kind words, Steph. [laughs]

But I spent a bunch of time in that course trying to make Git less weird or understandable. If you look under the hood, it starts to make more sense. But if you really want to get comfortable with manipulating Git history, which I think is a really useful skill for this conversation that we’re having, that’s the only way I found to do it, just memorizing the steps.

It’s always going to feel a little bit foreign. But once you understand the stuff under the hood, that’s a really useful thing for being able to manipulate and tease apart a pull request and break it into different things, and port things from one branch to another, and all those fun activities. Yeah, man, that was a bunch of years ago too. I wonder what I look like in it. Huh.

STEPH: I really liked that episode, the one you just mentioned, the Git Object Model. Now that you’ve mentioned it, I remember watching it, and it’s very interesting. So yeah, thank you for making all this helpful content for folks. There’s also a blog post that we can include in the show notes as well that is a really nice overview of using git interactive, and rebase, and squash and amend those types of behaviors as well. So will be sure to include both so folks can check those out.

And then to round things out, one of the other things that I will do is I will ask a friend. I will ask someone for help. So we’ve talked about some of these behaviors, or some of these processes that we have are really built up from experience and practice. And you can watch a lot of helpful content, and you can read blog posts. But sometimes, it really just takes time to get good at it. I know, as I’d mentioned earlier, I am always still looking to improve this particular skill because I think it’s so valuable.

And one of the ways I do that is I will just phone a friend. And I’ll say, “Hey, can we chat for a bit? I would like to show you my changes. I want to hear from you if you see something in here that’s valuable that you think can be shipped independently, so that way we can get it delivered faster.” Or it may be a change that’s just like a test improvement or something. And we can go ahead and get that immediately released to the team, and it will benefit them.

Or you may want to do this at the start of a ticket. If I am new to a project or when I am new to a project, I will often ask someone to break down a ticket with me if I’m feeling a little bit uncertain. Or just say, “Hey, do you see any clean lines of division here? I feel like there’s a lot in this ticket. You’re more familiar with the codebase. What would you ship? How would you ship this incrementally?” and have someone else walk through the process with you.

CHRIS: Yep, the phone a friend and/or, as always, pairing is a wonderful tool in these sorts of situations. The one other thing that comes to mind for me is part of the question was about sometimes it’s difficult to find a clear parting line within a larger body of work, within a larger change. And that can definitely be true.

I think there are certain standouts of like is this a refactoring that can be shipped separately? Is this a test change that would be useful on its own? Is there a model change that we could break out and have just that go out? So there’s a bunch of mechanical questions that we can ask and say; here’s categories of things that might fit that bill.

But to flip this to the other side, the question was asked by Bryan very much as an I struggle with this thing. This is my toxic trait is the phrase that he used, which I thought was really interesting. And that can be true. This can be something that if you’re consistently and uniquely within the team producing these giant PRs and then folks find that difficult to review, then I think that is absolutely something to work on.

But if this is something that is happening between members like, other members of the team are also finding that they keep ending up with PRs that are bigger than they expected and taking longer and harder to review, there is a question of is the codebase actually in a shape that makes it harder to do small changes? There’s the phrase shotgun surgery, which refers to a codebase that is so entangled and coupled that any change requires modifying ten files just to make one small alteration.

And I think that’s a worthwhile question to step back and ask, actually, is it not me? Is it actually the codebase? It could be both certainly. But there is a version of your codebase is coupled in a way that means that any even small, tiny change requires touching so many different places in the code. And if that’s true, that’s at least worth naming and worth highlighting and maybe talking about in retro and saying, hey, this feels like it’s true. So maybe we start to get intentional about refactoring, and breaking out, and starting to add those dividing lines within the code such that hopefully, down the road, small changes can, in fact, be small changes. So that is the one last thing that I would consider here.

Also, anecdotally, this is just a thing that came to mind. As I’ve worked with strongly-typed languages, systems that have a compiler, and have a type system, and the ability for the compiler to keep an eye on the whole codebase, I’ve noticed that it’s very easy to do this sort of thing where I just start with one small data model change, and then the compiler is like, oh, you got to go fix it here, and here, and here, and here.

And I found that because the compiler is your friend and will just point you to all the places you need to make the change, it is very easy to just keep going because some of that mechanical work is happening on your behalf. And it’s a wonderful facet of typed languages and of having a compiler and being able to have that conversation with the compiler.

But I found that for me, it is much easier to end up in this mode where I’m like, oh no, this PR is way too large. When I’m working in a system that has types, that has a compiler, that frankly makes it a little bit easier to chase down all the places you need to make a change. So that’s also a consideration. It’s not necessarily a good or a bad thing, just something that I’ve observed that feels like it’s adjacent to this conversation. But yeah, I think those are my thoughts.

STEPH: Yeah, those are great points. I’ve certainly worked on projects where that felt very true where it’s a small change, but it would cascade throughout the project. And all the changes were necessary. It wasn’t something that I could split into smaller PRs. So checking if it is the codebase that’s really making it hard to have small PRS is a really great idea.

CHRIS: Who’d have thunk such a little question could get us rambling for so long? Oh, wait, I would have thunk that.

STEPH: And so far, reflecting on the things that we’ve talked about so far, I think I’ve talked a good game of where I’m saying, “Oh, I identify the seams upfront, and then I organize and create different tickets.” And that is very much not the case. That’s the really ideal outcome. But often, I am in the thick of things where like you just said…and it’s this moment of, oh, I’ve done a lot in this PR. And how can I break this up? And that does take time. And it becomes a conversation of trade-off, which is why those Git skills really come in handy because then it will lower the cost of then splitting things out for others.

But for people that are struggling with creating smaller PRs, I do think it’s very fair to ask your team for help. I think it’s also fair that if you issued a large pull request and folks have already reviewed it, and it’s gotten approved, and someone makes a comment like, “Oh, this would be great as two PRs instead of one,” to say, “Awesome, thank you for letting me know. I will take that forward with me, but I’m not going to do it for this PR.”

I wouldn’t recommend making that a habit. But just know that that is something that you can say to someone to say, “I think this one is good to go at this point. But I will keep that in mind for future PRs. And I may even reach out to you for help if I feel like I’m having trouble splitting up a PR.” And bring that person into your progress and use them as an accountability buddy. They can be someone that helps you down that path towards smaller PRs.

CHRIS: Yeah, I definitely agree with that, although it becomes a very subtle line. Saying, “Thank you, but no thank you,” in a pull request or to feedback is delicate. It’s difficult. That’s a whole thing. But I agree there have been times where I have either been the one making that decision or suggesting that or being like, “We probably should have broken this up. But we’re far enough along now. Let’s get this merged. And then we’ll iterate on it after the fact.”

One last thing, actually. I thought I was done, but I have one more thing, which is I feel like there’s a strong parallel between test-driven development and this question in that, often, I hear folks saying, “I don’t know how to write tests upfront. I don’t know how to do that. I know after the fact I can write tests, and I can add them after.” And that can definitely be true. It can become more obvious after you’ve written the code how you could then write a test that would constrain that behavior that would interact with the system.

But I think the useful thing that you can do there is take a moment and pause there and say, “Okay, now that I have written the test, what would it look like if I had written this in the first place?” Or if you really want to go for it, throw away the code, try again. Start with the test first and then rebuild it. That’s maybe a little much.

But that thing of taking these moments of maybe you don’t know upfront how to break the work into smaller pieces, but then you get to the end, and you have that conversation with someone. And they highlight where some parting lines would be, or you figure it out after the fact. Stay there in that moment. Meditate on it a bit and try and internalize that knowledge because that’s how moving forward, you might know how to do this in the future. So take those moments, whether it be with TDD or with pull requests, or breaking up a ticket into smaller tickets, anything like that. And spend a moment there and try and internalize that knowledge so that you have it proactively moving forward.

STEPH: You know how Slack has status? I really like the idea of there being a status that’s meditating on…and you can fill it in. And the example that you just provided, meditating on splitting up a pull request or meditating on how to write a test first, [laughs] I think that would be delightful.

CHRIS: I, too, think that would be delightful. But with that long, adventurous answer to what seemed like a simple question, and they always do, but here we are, shall we wrap up?

STEPH: Let’s wrap up.

CHRIS: The show notes for this episode can be found at bikeshed.fm.

STEPH: This show is produced and edited by Mandy Moore.

CHRIS: 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, as it really helps other folks find the show.

STEPH: If you have any feedback for this or any of our other episodes, you can reach us at @_bikeshed or reach me on Twitter @SViccari.

CHRIS: And I’m @christoomey

STEPH: Or you can reach us at [email protected] via email.

CHRIS: Thanks so much for listening to The Bike Shed, and we’ll see you next week.

All: Byeeeeeeeeeee!

Announcer: This podcast was brought to you by thoughtbot. thoughtbot is your expert design and development partner. Let’s make your product and team a success.

Support The Bike Shed





Source link

Leave a reply

Please enter your comment!
Please enter your name here