Skip to content
449: Evergreen skills for new-ish developers episode artwork

Dec 3, 2024 37 min

449: Evergreen skills for new-ish developers

from The Bike Shed Hosted by thoughtbot

One of the most challenging things about starting out as a developer is how much you need to master all at once. And with so much to learn, it can be difficult for experts to guide fresh developers and advise them on where to focus first. Luckily, some skills will always be useful, no matter what language you’re coding in. In today’s episode, Stephanie and Joël tackle this topic by unpacking several key evergreen skills that will always be valuable, from reading error messages to deciphering a stack trace. They break down how new-ish developers can start acquiring these skills, key obstacles they’re likely to encounter, and how to ask for help when you hit a block. Their conversation covers the ins and outs of debugging, how to feel comfortable in your editor as a new developer, the art of asking for help, and much more. They also share plenty of valuable tips to help you on your journey – including one that will help you commit more frequently. Tune in now to hear it all! Key Points From This Episode: Stephanie’s time at the Ruby Conference in Chicago. The challenges of advising new-ish developers as an expert. Broad evergreen skills that are always valuable to learn. Tips on mastering debugging as a core skill. How to improve your ability to read error messages. Our approach to resolving errors and isolating what is wrong. Advice for learning to read a stack trace (even though it’s intimidating). Strategies for fixing different types of bugs. The value of editor mastery and version history. Tips on how to commit more frequently as a new developer. Learning to ask for help when you hit a block. The art of structuring your questions when asking for help. Breaking down large tasks into smaller sections. Learning to find focus as a new developer. Links Mentioned in Today’s Episode: What technologies should I learn? Debugging blog post series Asking about solutions rather than problems The Bike Shed Joël Quenneville on LinkedIn Joël Quenneville on X Support The Bike Shed Mailtrap [WorkOS](workos.com/)

Episode details come from the podcast's RSS feed.

Embed this episode

Ready to play

449: Evergreen skills for new-ish developers

0:00 37:41
of matches

Transcript Auto-generated, may contain errors

This episode is brought to you by WorkOS. If you're building a B2B SaaS app, at some point, your customers will start asking for enterprise features like single sign-on, SCIM, provisioning, role-based access control, and audit trails. That's where WorkOS comes in, with ease-to-use and flexible APIs that help you ship enterprise features on day one without slowing down your core product development. Today, some of the hottest startups in the world are already powered by WorkOS, including ones you probably know, like Perplexity, Vercel, Jasper, and Webflow. WorkOS also provides a generous free tier of up to 1 million monthly active users for its user management solution.

making it the perfect authentication and authorization solution for growing companies. It comes standard with rich features like social logins, bot protection, MFA, roles, and permissions, and more. If you're currently looking to build SSO for your first enterprise customer, you should consider using WorkOS. Integrate in minutes and start shipping enterprise plans today. Check it all out at WorkOS.com. That's WorkOS.com. Hello, and welcome to another episode of The Bike Shed, a weekly podcast from your friends at ThoughtBot about developing great software. I'm Joelle Kenville. And I'm Stephanie Min, and together we're here to share a bit of what we've learned along the way. So Stephanie, what's new in your world?

So I recently came back from RubyConf in Chicago, where I lived for many, many years and had actually just moved away from two months before the conference. Bad timing. Yeah, it was kind of awkward timing because I had bought my ticket when I still lived there and didn't know that I was going to be moving yet. But I still went because it was nice to go back and see. I obviously love seeing my Ruby friends, but I also got to see my Chicago Ruby friends and just knowing that they were all going to be there. Made me want to not miss out. Were you pretty involved in the Chicago Ruby scene, like meetups or things like that?

I have been to a couple of meetups. I used to work for a Chicago-based software consulting company as well. So there were actually people there who I happened to have some just like branded stuff from that company and who actually came up to me and was like, oh, did you work for this company? I was like, yeah. And we kind of had some shared connections there, which was fun. But yeah, I actually ended up staying at my old place in Chicago that I'm still holding onto for a little bit and was commuting to the conference instead of staying at the conference hotel, which is usually where we...

action is happening. So that was a different experience for me. And I will say, I think that kind of affected my conference experience a little bit. Have you always stayed at the official conference hotel? Or have you ever done the thing where you get like an Airbnb a couple blocks down or stay at a different hotel?

I like to be at the conference hotel because I just don't like to miss out, I think. And there's something really nice about just being able to go upstairs and get anything or take a little rest or something. In fact, I actually ended up staying with one of my friends who had an extra bed and weirdly an extra bathroom in her hotel room on one of the nights that I knew there were just going to be activities late into the evening and there was an early morning the next day. So it was really nice to crash just for one night there. Fun. What were some of the highlights of that conference for you? So I approached this conference a little bit differently. Normally I am a bit of a...

I enjoy watching the talks and kind of staying on the schedule, but I definitely hung out in the hallway track more this time around. So the highlight really just was like spending time with my friends. And this is kind of new to at least this year where the conference has one day of workshops and like a hack day kind of thing. So instead of talks, it's, you know, kind of people are hacking away, taking workshops, but it is a little more free form. I think it is a bit less structured. And I felt like that was a lot nicer in terms of.

everyone wasn't like totally split off going off in their separate tracks. That really facilitated the hallway track for me, where it was kind of maybe sitting at this table where people were hacking and like going over to another table. And I liked it. I think just people, it facilitated people just hanging out more, which is a bit my speed. And so it was good for me that there was a day for that.

Yeah, I think the value of a conference is there's like educational, there's sort of technical things, if you're like hacking and like contributing to open source and things like that. But there's definitely a social component there as well. And sometimes just the getting sort of all these bright minds together and getting a chance to connect and share is where some of the real magic happens. So 12, what's new in your world? I did the opposite of you. Did not go and hang out with a lot of people and do a lot of things. I took a weekend and did pretty much nothing except a little bit of a walk around my neighborhood. I live in Boston, which is...

has a lot of historic sites because a lot of the early events of the American Revolution took place here. And so there's all these historic markers and things. And I got a chance to go to one of these. There's a hill with a viewpoint on the city. And you learn about, oh, why was this place important? In addition to being a really liking software, I'm a bit of a history nerd, a little bit of a geography nerd. I like to learn about new places by understanding the watershed of the area. And one of the things I learned by reading plaques and then later on reading up on some things on my own was that this hill kind of in the middle of the city I was on used to be almost by the edge of the water.

Boston's kind of famously almost entirely landfill. And you look at some of these old maps and it's just really kind of mind-blowing how far and like where all the water was. If you don't know the city, you just look at the two, you're like, wow, they filled in a lot. If you know the city and you look at it and you're like, wait, that place was underwater? Oh, that place was underwater? It brings a whole new perspective. Well, yeah, that's fun that you got to learn a lot more about your city just by taking some time to read the plex around you. I feel like this is the case in Massachusetts. It's probably true in a lot of other parts of the U.S.

City governments love putting up little plaques about things that are kind of important or sometimes not so important about their city just so that you know that there was something special here. And occasionally slowing down and taking the time to read those and understand how it fits in the story of the place you live leads to a lot of interesting learning. Yeah, I recently, just to talk a little bit more about where I moved to, moved to kind of a pretty historic place with a lot of old buildings from when the Dutch had colonized this area. And so there's a lot of plaques around here as well that I've been enjoying walking around. In fact, actually yesterday, I walked past a car that had stopped in the middle of the street and someone had rolled down the window and was trying to read a plaque on a building. From their car? From their car. And they were reading it out loud and I had to awkwardly walk past them. But maybe don't do that. But otherwise, yes, it is fun kind of almost being like a little tourist where you live.

Yeah. So Joel, while I was at RubyConf, I actually met a lot of new Rubyists and developers who were new to programming and software development. One of the things I actually, just as a side note, really appreciate about the conference is that they have this scholars and guides program where people who have been to the conference before can be a guide for people who are going to the conference for the first time. And these are the scholars, and I got to meet a lot of them this time around because I just happened to sit at their table. And I was...

I'm really excited to just remember that there are just new developers coming into the community all the time. For some reason, I always, I just kind of think that I found that it was being a little insular. But yeah, there is Fresh Faces. I appreciate that the conference makes sure they have a good time. But I did end up having a lot of conversations with them about, they were asking for advice a lot of the time about like, how do I get good at programming? Or like, what do I need to focus on? So I thought it could be fun to talk a little bit about what are the skills that newish developers really need. And I think you and I are in agreement that a lot of these are pretty language and framework or tech stack agnostic.

So I think it's interesting when you try to answer that question, especially from the point of view of being someone who's been in the industry for years, because sort of the biases and the experiences that you've had that have led you to where you are sort of always end up kind of coloring the advice that you give. And I feel like too often I hear people give that kind of advice or give advice from their perspective of like, oh, now I'm a senior developer and I've got a decade of experience. And oftentimes it's not that good because it is just so colored by this person's personal experience and biases that it's not helpful for someone who's right at the beginning of their career. Yeah, I think my other qualm with some of the advice, especially one advice that's like learn.

technology or why framework people give that advice sometimes to help you know new developers find their first job and kind of have quote-unquote marketable skills but sometimes i think that ends up doing a little bit of a disservice because that kind of glosses over a lot of just foundational skills that are probably more critical and more applicable like across across the board you know you instead of kind of narrowing down your options to be like i'm this kind of developer like you said especially if that is biased towards you know one person's career experience so yeah i've really tried hard to give advice about just kind of how to develop skills that will help you with any job or technology. I feel like the most, or one of the most helpful pieces of advice that's sort of the most basic, it's just write a lot of code. You have to sort of put in...

2,000 hours or whatever you want to put that number at. You have to put in time to become good at it. Try to actually build things. I think a danger that I see for especially like very early career people is just, again, you talk to one expert and they're like, well, the way you become good is you have to learn functional programming. And then you do a little bit of that. And you hear another expert who's like, no, the way you get good is you write PHP or you learn Rails. You kind of jump from one thing to another following these experts advice. And you kind of dabble in a lot of things and then don't really understand what you're doing. Don't end up writing much code. Don't really build anything. So you don't really grow all that much.

And in the end, you don't have a whole lot to show for your time. So I think that's a classic pitfall that you have to try to avoid. And oftentimes, experts like us can make worse by giving bad recommendations. Yeah, I think, honestly, this is not necessarily the path that I went through. But I can see how having what we call a breakable toy or whatever, just a side project to be actively writing code on, it just gives you that.

experience of having to debug something when it goes wrong and being able to make a change and see what it does. There are some sort of broad developer skills that I think are going to be evergreen and that are really valuable to learn. Maybe you don't need to learn them all up front because if you spend a lot of time learning through the meta skills and never actually take time to code or build something, then those skills aren't going to matter and you're not really going to understand the value of them anyway. So you'd mentioned getting good at debugging. that is the thing that is going to pay off over the course of an entire career. And that's the thing that will help level you up as a developer. Day one junior developer, do you go spend all of your time learning to get good at debugging? Probably not, right? It's a thing that you can like learn in sort of bursts and spurts. And as you encounter bugs, trying to be more thoughtful about it or trying to level up a little bit. And then maybe you pause and you do some other things. And then maybe you come back after a little bit of hindsight and like, all right, I'm ready to do sort of next level debugging and work on getting better at that. So I think having that balance is important. But yeah, debugging is a core skill that getting good at is, you're never going to regret being too good at debugging.

So why don't we get a little bit more granular about debugging and talk about how you even get good at it? I think one of the things I see the most is people not reading error messages. And I get that because when you're pretty unfamiliar with everything, then all of the output is totally incomprehensible to you, right? And so it's really hard to pick out the things that are relevant to whatever issue you're trying to debug. I'm curious, do you have any thoughts about how people can learn to read error messages better? There are a few different things, and those are going to vary by language.

One thing that's worth searching if you're using a language like Ruby is the name of the exception. What is the exception class that got raised? And that will give you a general sense of what kind of error you're falling into. So you might see an error just immediately in your head and go, oh, I think it's this thing. But if you pause and look, you might see, oh, actually, it's a no method error on nil. Why is there nil? Now you can actually start looking at that. But you thought it was some other thing. So just finding that exception class is really helpful. If you ever run into something you just don't understand, that exception class is probably going to be what you want to Google.

Now, there might be a text message that comes along with it, and that might give you some more refinement on sort of why exactly this is going wrong. But I love to start with the sort of, you have a wall of text, find the exception class. This episode is sponsored by MailTrap, an email delivery platform that developers love. An email sending solution with industry-best analytics, SMTP, and email API, along with SDKs for major programming languages, and 24-7 human support. Try for free at mailtrap.io. I have another kind of suggestion, which is find where in the stack trace, kind of like the last place that you see.

file or any code that you are familiar with, because that'll be within the bounds of your application. And then the rest is usually stuff that is related to libraries. And most likely, you don't have to worry too much about that yet. I think that was something that I struggled with and I see people struggle with is that wall of text is really overwhelming. And you're just like, what's up? You know, like, what are all these names of things I've never heard of? And so being able to identify what part is your application ends up being really useful. So for someone who's a sort of brand new...

Just encountering a stack trace is kind of scary, right? It's a lot of text telling you you've done a lot of things wrong. And learning to read a stack trace is a little bit of a skill in and of itself. And not just being like, ah, something went wrong. All right, let me go and try to change my code and see if I can undo what happened here. How do you tend to read a stack trace?

Oh, yeah. That's a good question. I feel like I just have developed muscle memory. So it's a good thing to have me kind of really figure out how to explain to someone. Debugging is interesting because it's a skill that I feel like many of us learn on the job. And we build sort of muscle memory or intuition rather than like sitting down and having someone train us on it or watching a video on it or something like that. And so oftentimes, yeah, you're sort of, you're pairing with someone who's new and you're just like, oh, this is the thing that's wrong. They're like, how did you know that? Like, oh, I read the stack trace. And they're like, that's a lot of text. How did you get this out of the stack trace?

And then you've got to be like, oh, yeah, how do I read a stack trace? Yeah, let's be really, I don't even read the whole stack trace. I scroll up to the top or where there is some kind of line break. I think that is usually a good clue for me that that is the thing that it's trying to highlight. And that's actually an interesting thing because stack traces are not universal in direction from one language to another. Some languages output their stack traces kind of top to bottom and others put them bottom to top. And so just knowing what direction to read is already a great start. Yeah. And I think that's where my previous advice could be really helpful, right? Is looking out for where you see output from your code or code in your application to figure out what direction it's printing out. Treating it almost like a map, right? Trying to find like what's the latest known point and working away from that.

What other debugging things outside of reading the error message? So let's say you know what the error is, but you don't know what to do to change the system to even begin resolving that error. It's like you know what the error is, but you're not quite sure what caused it. Yeah. A technique that I like to use is basically splitting the search space of where the bug could be kind of roughly in half and then half again and then half again. So maybe you know it's in a file, but you don't know where exactly it is. Can you comment out half the file? See if that you, let's say you comment out the top half and you run the code again and the bug doesn't happen.

Comment out the bottom half, the bug does happen. All right, now you know that that bug exists in the top half of the code. Comment out now half of that and sort of keep going smaller and smaller until you find out like exactly what method or what part of the code is doing it. Yeah, I was about to say something very similar in terms of isolating what might be wrong. And I do something similar. I think instead of commenting out sections, I actually go back and just remove everything and then slowly reintroduce what I had had that led to the error.

I guess you also want to work with different scenarios, right? Because sometimes a bug is something you introduce, you break something as part of adding more code. Sometimes it's just as broken code on production, there's a bug report that came in and you're asked to fix it. And the strategies you use for each different kind of bug is going to be different. That's a really good point. There are a lot of other different tricks you can use to get better at debugging. We did a whole series on the ThoughtBot blog with a bunch of different tips on how to debug, how to get better. We'll link them in the show notes. I'm curious, beyond debugging, what are some other skills that you would recommend to a junior developer? Yeah, I have on my list feeling comfortable in their editor, and it does not matter what editor it is. I would never be, I think, the kind of person that says you need to use them in order to be a whatever kind of developer. Just however they feel comfortable. I think having to learn how to...

use your tooling at the same time as trying to learn how to program is so much overload so even if it's you know whatever it is whatever they're already using just learning the basic things of like how to open you know how to use fuzzy search right how to fuzzy search for files how to just like you know search in the whole directory for certain texts like that kind of thing and maybe basic one thing that i actually really like to teach people when they're starting out and kind of going pretty slowly is like a shortcut to like copy the file path that they're currently active in. Things like that end up making kind of everything else downstream, like committing or running a test a lot easier. Yeah, I feel like editor mastery is a thing that, again, will pay off in the long term. But again, it's these sort of evergreen skills are not things you need to get all done right at the beginning, because then you spent all this time on meta skills and haven't actually learned to build or code anything. But they're things that are worth investing in at various points in your career. I feel like my probably most used things in an editor from the start are going to be something like you said, fuzzy search, fuzzy find for a file or something like that.

and then a find and replace. Another piece of tooling, and you kind of hinted at this a little bit, that I think is worth learning at least the basics of early on and then maybe returning to over the course of your career. version control, which in today's world probably means Git. Learn how to stage your work, commit your work, get it pushed up, how to roll back to a previous version of history, that kind of thing. Now, Git is a really powerful tool you can get really advanced with it. Early on, that's one of those things that's going to really pay off. Yeah, I think some really basics like that and even just understanding. Sometimes people understand the commands, but not necessarily the concept. And I do think having both understanding what kind of operation is happening is helpful for

I don't know, not just being totally overwhelmed when you end up accidentally getting rid of your local changes. A thing that I encourage people to do, especially early on, is to just be doing a bunch of little commits all the time. And this is not in the, oh, they have to be sort of expertly crafted atomic commits where everything's deployable. And I have a lot of thoughts on that. This is not what I recommend for beginners. It's just you change a few lines of code, make a commit. It's arbitrary. It's fine. But what you've effectively done is create a bunch of little save points for yourself. And so what you can do then is you introduce a bug.

And you can just sort of jump back. And like you said, find that latest known good point and then reintroduce new code from it. Because sometimes if you accidentally introduce a bug, it's not worth finding it. It's easier to just go back to the last known good point and build from scratch again and not accidentally introduce a bug this time. And so having a bunch of those really tightly together means that you're never losing much work. You always have a good thing you can roll back to. As opposed to, oh, I wish I could undo some things, but now I've got 500 lines of code from two days worth of work just sitting on my machine and I don't know where things went wrong.

I actually think that one of the things that prevents new-ish developers from committing frequently is not knowing what to put in their commit message. And I get that, right? Because it's like, well, what did I even do? And I think that's a good place to start is just even starting to be a little bit aware of what have you done since the last time you committed and having a little more awareness about that. Because that actually cuts across a few of the skills that we talked about with debugging as well, just knowing what changes you made. That's not easy when you have no idea what you're doing. But I think, yeah, that definitely would be advice that I would give someone is just at least trying to be a bit more aware of.

of that instead of leaning into the frenzy of just starting to do things and making changes without a ton of forethought. I think that's like a really good sort of next step once you've gotten the basics of Git going. For someone who's just starting, you know, I would almost encourage people like don't even care about the messages. That's a good point. Maybe even just put a timer on your desk and every 10 minutes commit with the message, you know, save point one, save point two or something like that. Just so you have, you learn the mechanics of how Git works and then you have something to go back to and you know that if you have to undo 10 minutes worth of work, that's all you're going to lose.

And then once you start getting comfortable with that, instead of just arbitrary points in time, then you can start thinking about how do these sort of fit together as one logical set of changes? Because now you're adding sort of an extra mental load there. But then that, I think, then leads to you becoming much better at decomposing your work. And like you said, better debugging because you know what the different pieces are. And it helps you craft better PRs and scope your work and all these things that are really positive habits to build. But you have to start from somewhere. You've convinced me. That's actually really good advice is just getting in the muscle memory of committing at all. And I like the idea of safe points.

like a video game. I feel like that's a really good metaphor to describe it. Because yeah, and once you've learned how to save, then you can add some context to like what those save points are. Like the hard thing when you're a beginner is it's just you have to learn all the things and it's drinking from a fire hose and you're crushed with all these like expectations and feelings of not being good enough. And it's really tough. And then someone comes who's an expert and gives you some best practices to follow or some things you can do.

And that can just be a lot. And oftentimes what I do is try to think of, okay, yes, this is a really good thing for someone to learn to get better at. And maybe that's the thing that they could learn like one year down in their career, two years down. What is the like, if we had to say, you know, this practice is a good like two years in thing. If I had to like retro project it back to the like simplest version that they could do one year in or six months in, what does that look like? Try to put a little bit myself in those shoes. And yeah, that might not look like at all work like Joelle works like today because I can work in the way that I do because I've got over a decade of experience building things.

And there's some things that I do that you can't do if you've not learned a bunch of other prerequisite skills. So I think another good skill to develop is asking questions and asking for help. Let's talk about that a little bit. I think it's almost harder for someone to help you when you're at the point where you're just totally unsure about anything and have tried a bunch of things and gone in a lot of directions because in some ways I think you kind of lose what you were really trying to do in the first place. So I think a good skill is just identifying when you hit a blocker for the thing that you're trying to accomplish.

Now that's getting deep because now we're sort of moving beyond the technical skills and into the social skills. And yeah, knowing when to ask for help, that's a big one. I think for me, it was often sooner than I actually did. Yeah. So learning to recognize when I'm sort of in a loop and just sort of stuck and going in circles and that I should break out of that and ask for help. The how you ask for help or how you word questions such that you can get good responses is also a skill. The my thing's broken, it won't work. I mean, you can ask someone to like pair with you and sit down with you and look at stuff, but just those words are not going to give you a lot of helpful feedback. Yeah, actually it might. I don't know if this is a take or not, but I would almost say like default to asking for someone to guide you because.

that will almost always be more valuable than someone saying run this command and then being like it worked but then you have no idea why it's like you don't need to necessarily understand like everything about why that helped but i think the having someone just explain something and if you just you know click with a little part of what that solution means like maybe you learn a new term i think that is really useful in terms of, I don't know, just like collecting information. And it's particularly relevant information because, you know, you said it can be like drinking from a fire hose. And sometimes those are things that are, you really only get to know from experience. And so having someone with that experience to at least like point it out to you, I think can like help beginners stay focused rather than just going off and being overwhelmed by all of the information there is out there about just everything. There's also, I think, an art to structuring a question.

A classic thing is stating your actual goal. So saying, I'm trying to do this. My goal is to get this feature done or this activity. I try to accomplish that goal by doing x and then y bug happened or it doesn't work. Sometimes what you get is sort of a, how do I do this thing? Which ends up being like a really weird thing to ask. And then people have to ask you like the, why are you trying to do that? And then you realize that part of why you're running into problems is because you're trying to use the wrong tool or the wrong method or something like that. And just like really forcing a square peg into a round hole. And so I usually like to start with a broader, like, here's the general problem I'm trying to solve. Here's the approach I'm using. And then here's the bug or the issue that I'm running into. That way people sort of know if they need to zoom out, oh, before we even go to fixing the bug, your general approach is not even the right approach to use.

Take this other approach and that will, you can bypass the bug entirely. I like that a lot. And I think developers who are able to communicate that in general find, it's like that scales up. It just is a very good strategy for the work that we do. But yeah, it's almost like having new developers be able to identify what a good next step is for kind of what they're trying to accomplish and scoping, having that, even if it's very like scoped really small, like I am trying to get something to appear, you know, this text to appear on the page. That is so useful for people who want to help you. So I really like that writing a lot.

I like what you said about having a small next step, like kind of a micro goal. You might have a larger feature you're trying to build in, but instead of being like, oh, I need to have user login and all this stuff, it's like, forget about user login as a whole thing. Can you have a page with a form that asks you for an email? That form doesn't even need to go anywhere. Can you get a form to display? Maybe you don't even get the form yet. Maybe you microstep even smaller. Can I get a page to show up that just says, welcome to the login page or something like that? And then once you've got that, you're like, OK, I've got that page. Now can I put a form on it with one or maybe two fields on it? OK, great. Now can this form submit anywhere?

And you sort of work your way from one micro step to another. And then the problem that as a bigger feature felt really challenging, when it's broken down into small steps, feels much more approachable. That actually just sparked a thought for me, which was, I think that aligns really well with another thing that I have tried with working with more early career developers is asking them, like, what are you doing today? Or even this hour? And trying to get them to say something that's actually doable or actionable for the immediate amount of time that they have in front of them, rather than being like, well, my project is to do this. And if they're not...

and if and you know it's like obviously there's a lot of sometimes guidance and being like hey well what if you did focus on getting your test to pass or whatever. But I do think that a couple things, both, like that is a skill to develop as a newish developers, like you said, the finding that next step, but also we probably do a better job helping support people and making sure that they know what that is because I think a lot of things are, a lot of issues arise when like they don't have that clarity. I think a thing that we're big proponents of here is testing in general, test-driven development. Test-driven development kind of forces you into that next little micro step. TDD is not an easy technique to pick up. It's definitely not an easy technique to pick up if you're a brand new developer. So I don't recommend...

newcomers immediately jump into test-driven development. That's just one more thing they have to learn. But maybe find some time to pair with an experienced developer who's using that technique and pay attention to how they're now working in really small microsteps and how that helps them with their focus, how that helps them work more concretely towards their goal. And that can be a thing that you bring back to your work, even if it's not actually driving it with tests, just sort of setting these micro goals for yourself of like, oh yeah, I could have a goal of just adding one more screen or adding one more text box or whatever it ends up being. And then eventually, further down your career, you can actually pick up TDD as a whole practice.

But the micro steps, I think, are a valuable part that you can sort of bring back to kind of the earliest bits of your career. Yeah, I think to wrap things up, the idea of finding focus. is a good way to describe a lot of the things we talked about where it's like, can you learn how to do one thing and identify the one line of code or kind of identify one change that happened? And I really like that next time I am working with or kind of giving advice to someone, just figuring out like, what do they need to do to find focus from where they are at? Yeah, focus, one of the, probably one of the most core skills that we have. That's kind of a thing that we take for granted. On that note, shall we wrap up? Let's wrap up.

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!

Frequently asked questions

How long is this episode of The Bike Shed?

This episode is 37 minutes long.

When was this The Bike Shed episode published?

This episode was published on December 3, 2024.

Is there a transcript available for this episode?

Yes, a full transcript is available for this episode. You can read the complete transcript on the episode page.

Can I download this The Bike Shed episode?

Yes. Use the download control on the episode player to save the publisher-provided media file.