No matter where you are in your career, whether a developer, designer, PM or manager you have aspirations.
We've talked about long-term vision in past episodes, and in today's episode we're talking about habit forming and constant progress and bringing those together into focus.
If you have questions about today's episode, want to start a conversation about today's topic or just want to let us know if you found this episode valuable I encourage you to join the conversation or start your own on our community platform Spectrum.chat/specfm/developer-tea
If you're enjoying the show and want to support the content head over to iTunes and leave a review! It helps other developers discover the show and keep us focused on what matters to you.
This is a daily challenge designed help you become more self-aware and be a better developer so you can have a positive impact on the people around you. Check it out and give it a try at https://www.teabreakchallenge.com/.
Sentry tells you about errors in your code before your customers have a chance to encounter them.
Not only do we tell you about them, we also give you all the details you’ll need to be able to fix them. You’ll see exactly how many users have been impacted by a bug, the stack trace, the commit that the error was released as part of, the engineer who wrote the line of code that is currently busted, and a lot more.
Give it a try for yourself at Sentry.io
No matter where you are in your career, whether you are a developer or a designer or something entirely different, you probably have some kind of aspirations. You want to maybe if you're a new developer, get your first job. Or if you're a mid-career, maybe you want to get the next promotion or the next title. Or maybe your aspirations are something entirely different. You want to become a mentor or a founder of a company. Or maybe you just want to retire early. Now, we've talked about aspirations on the show and how when you develop your kind of career goals, your purpose, your long-term vision, the only way that you can actually begin to achieve that is to break it down into smaller goals, a daily progress kind of thing. And we've also talked about the only way really to develop consistent progress towards those goals as to have habits. In today's episode, though, we want to focus on this habit forming and constant progress concept. We want to bring that together with another concept that we've talked about on the show before. In fact, it was one of the very first concepts that we've talked about on Developer Tea. That is the idea of focus. My name is Jonathan Cutrell. After listening to Developer Tea, my goal in the show is to help driven developers find clarity, perspective, and purpose in their careers. Developers are perhaps naturally good at breaking things down. So the idea that you need to break down your bigger goals and the smaller ones is really pretty easy to accept. Developers often face this kind of breaking down of bigger concepts into smaller ones. And we have to decompose these tasks that we receive in building features, for example, we might decompose that into smaller and smaller pieces until we get to the smallest possible change that we can make. And then we repeat that process. This is how software development happens. And in many ways, it's how life happens. It's how we achieve the things that we set out to achieve. But if you evaluate your progress, if you evaluate where you are on that long map towards whatever your goals are, if you match a picture of what you expect of yourself, of against what you are getting out of yourself, it's easy to see those things break down. While developers can be pretty good at breaking things down into their kind of smaller components, one thing developers are not traditionally good at is understanding context, making trade offs based on that context. This problem shows up in our lives, especially in our personal development and ultimately in our careers. The problem kind of looks like this. Let's say that you have three or four different goals in life and you break those down into two or three habits per goal. Now you have something like 12 habits to maintain. And so in order to service each of those habits, they have to be very small. Now this isn't not accomplishable by any means. But the problem is that it feels like very little progress has been made on any given habit at any given point in time. What's even more detrimental to your progress is that when you have these incredibly small increments, the feedback loop doesn't have a strong signal. In other words, you're not getting a lot of reward for accomplishing those tiny, tiny habits. And we're not saying that you need to jump down to a single habit at a time and forsake all of your good habits. But if you listen to the show on a regular basis, you know that there's a lot of ideas to digest. Being a developer is a complex job. Being a human is complex on its own, managing relationships in a professional workplace is complex. And then if you add on this idea that we have to constantly be learning, there's so much that we have to balance. And so in today's episode, we're talking about perhaps a more effective way to view these kind of habit development processes. Before we talk about this more effective way, I want to talk to you about today's sponsor's century. Speaking of habits, it's a good habit to write tests for your code. This often catches regression errors and usually it helps you establish a happy path, right? And the idea that most of your code is going to work, this can be validated by your tests. But the problem is sometimes tests just don't cover every case. It's very difficult to predict every case that's going to happen. And it's also difficult to predict how people are going to interact with your software. So a more sophisticated and ultimately effective way to manage errors in your code is to approach it from multiple angles. This is one angle, but another angle is to receive reporting from your production applications. It doesn't even have to just be production. You can also receive reporting from your development and staging applications, your QA applications. There may be errors happening that you don't even see on the front end that you can get reports about. If your user's experience errors, they're not likely to tell you before a few of them leave, and losing customers because of a simple problem in your code, like for example, maybe you spelled something wrong. This can be really painful. You have a lot of regret that you didn't catch that error earlier. Century helps you with this. Not only do you get a stack trace of what the error is and where it's occurring in your code, but you can also see who wrote the code that is resulting in the errors that you can trace it down a little bit faster. You also get a link to the commit. You can get alerts in pretty much every format that you can imagine, e-mail, Slack. You can set up almost any kind of alerting that you would want. I encourage you to check it out. Cintry.io. This is a much more sophisticated way to deal with errors in your code than just relying on tests and manual checking. Head over to Cintry.io to get started today. Thank you to Cintry for sponsoring today's episode. These are difficult to develop. It's not just about developing a behavior that you beat into your brain over and over. It's about creating default behaviors. It's difficult to have a default behavior that you haven't really created a groove for. You haven't really gotten good at it. Imagine picking up a new text editor. Only if the text editor has a lot of features that you have to learn. For example, going from a basic note pad to something like VIM. This would be a big jump. Only using VIM for a little bit of your day, it's going to take a long time for those habits to find the groove in your daily actions. Instead of trying to learn VIM on top of doing eight other new things, perhaps it makes sense to only learn VIM. If you focus all of your efforts on developing one habit at a time, it's quite possible that the habit that you're trying to develop, you'll be able to gain expertise a little bit more quickly. This provides you that needed feedback loop for the learning process. We're not saying that you only focus on one thing at a time, but rather that you have a limited focus. There's a balance. You don't want to try to develop too many habits at once, but developing only one habit at a time is probably not a good idea. The reason for this is because the way that we learn requires some distance between learning sessions. In other words, we're probably going to learn how to ride a bike better by riding three days a week, for example, for 10 weeks, rather than riding 30 days in a row. This space in between provides your brain the opportunity to assimilate the information. This is in our unconscious thinking. This assimilation generally happens when we're sleeping, but it can also happen when we're doing things completely unrelated to, in this case, riding a bike. You want the concept of spaced repetition, and you also want to ensure that you're not just focusing on one habit because of a concept called interleaving. Humans are actually better at remembering things if they interleave them with other things. For example, it's probably a better idea to read two or three books at once rather than one book, if the goal is long-term retention. We can lose motivation if we make such little progress that it's nearly invisible. That motivation comes from that feedback loop. If you don't see yourself improving at riding the bike, for example, it becomes a little bit hard to go out and fall down over and over in the next session. Generally speaking, developers have a harder time with limiting the number of things we're trying to do at once. Part of this is cultural. We see all of these new tools, and it's difficult to say no to so many things. We see all of this available media to consume. There's hundreds of links on hacker news, all from brilliant people who want your attention, and sometimes they end up getting it. A problem is if you split your attention too wide, that meaningful progress that we were talking about to have a motivating feedback loop and the thing that you're trying to do, it goes away. You're trying to do too much. Ben Franklin famously practiced this, and he was actually fairly young at the age of 20. He practiced 13 different virtues. We'll go ahead and tell you what those are. Temperance, silence, order, resolution, frugality, industries, sincerity, justice, moderation, loneliness, tranquility, chastity, and humility. We can't claim on this podcast that Ben Franklin was the perfect model of all of these virtues, but one thing that Ben Franklin had right is that he didn't try to focus on all of these at once. The idea of developing 13 different virtues and constantly checking to see if you are practicing those virtues seems nearly impossible. So instead, Franklin would focus on one per week. So in cycles of 13 weeks, he would revisit these virtues. Now it seems like this would take a long time to develop on any one virtue, but simple math tells us that this means Franklin would focus on each of these 13 virtues four times a year. Of course, meaning that 13 weeks is a quarter of a year. So this is the kind of concept that we need to be focusing on. Not trying to improve on all 13 of these virtues, for example, or trying to learn seven different languages all at once, but instead learning them in limited quantities. Making meaningful progress on a limited number of things is much more suited to human psychology than making a tiny amount of progress on a large number of things. So the takeaway for this episode, what I want you to do is to evaluate your goals, the habits that you are forming, evaluate the ways that you are taking your big goals and turning them into immediate action, right? The hope, by the way, and we're going to talk about this in the next episode, but the hope is that your actions have a much faster feedback loop than your goals. So if you want to hear more about that, make sure you subscribe so you don't miss that episode. But limit that number, the number of habits that you're forming, the number of actions that you're trying to develop, the number of virtues, the number of relationships, the number of books you're reading, whatever you are doing, limit the number. Don't try to do your whole career. Don't try to develop your whole career all at once. Instead, develop it column by column. Develop it room by room. Don't be sucked into the trap that thinking that if you build one column and move away from it, that it will somehow disintegrate. Instead, think about your career as a compounding building where one piece of development, one piece of self-development actually feeds the next piece of self-development. They don't sit in silos and require constant feeding. They are going to starve, but instead your development will thrive if you limit your focus. Thank you so much for listening to today's episode. Thank you again to Century for sponsoring today's episode. If you have an application in production that has had an error that you didn't know about, then you know the pain of catching errors in production after the fact. I encourage you to go and check out Century that can help you avoid that situation altogether. Century.io. Thank you so much to spec.fm. The show wouldn't be possible without the spec network. I'd have respect.fm to find other podcasts and content that is specifically designed to help designers and developers level up in their career. Today's episode was produced by our wonderful producers Sarah Jackson. Thank you so much for listening and until next time, enjoy your tea.