Latest / DevQuestions with Tim Corey / 200 What Are Some Major Mistakes Developers Make in Their Career?

Transcript

200 What Are Some Major Mistakes Developers Make in Their Career? · DevQuestions with Tim Corey

• 0:00
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:03
  SPEAKER_00: Join us each episode as we tackle the questions you are asking about a career in software development, understanding the industry, and new technology.
• 0:12
  SPEAKER_00: If you're just starting out or you want to grow stronger as a developer, this is the place to get your questions answered.
• 0:19
  SPEAKER_00: Now, here's your host, expert developer and online educator, Tim Corey.
• 0:26
  SPEAKER_02: What are some major mistakes developers make in their career?
• 0:31
  SPEAKER_02: This is a great topic to cover in today's episode of Dev Questions.
• 0:36
  SPEAKER_02: So I'm going to cover the seven major mistakes that I see developers make that waste their time and slow down their career.
• 0:46
  SPEAKER_02: If you're a developer, you're probably guilty of at least three of these things.
• 0:50
  SPEAKER_02: So let's talk about how to avoid these seven mistakes and speed up your career and not waste your time as you try to progress.
• 1:01
  SPEAKER_02: So, number one thing, one number one major mistake I see is when you just learn new things.
• 1:09
  SPEAKER_02: Now, this is especially true when you first start your career because you think that you're only going to build in the new things.
• 1:17
  SPEAKER_02: But let's use an illustration here that I think will kind of give you a good idea of why that's just not the case and why just learn the new things will really stunt your growth as a developer.
• 1:30
  SPEAKER_02: In the housing industry, building standards change over time.
• 1:35
  SPEAKER_02: When I lived in Pennsylvania, I lived in a house that was built in the 1850s.
• 1:41
  SPEAKER_02: And the building standards then were a whole lot different than they are today.
• 1:45
  SPEAKER_02: And in my basement, I actually had log beams that still had bark on them.
• 1:50
  SPEAKER_02: Like that doesn't happen today.
• 1:53
  SPEAKER_02: We don't just fell a tree and then shove it right into our house.
• 1:57
  SPEAKER_02: So things change over time.
• 1:59
  SPEAKER_02: We have new electrical standards, new ways of doing different building materials and new regulations over how we can do things based upon what we've learned over the years.
• 2:10
  SPEAKER_02: But when those new standards come about, we don't tear down all the old houses and rebuild them with the new standards, right?
• 2:19
  SPEAKER_02: Like that'd be silly.
• 2:20
  SPEAKER_02: So my house from 1850, great house, loved it, and we just fixed it and changed it over time, but it was still structurally that house from 1850.
• 2:29
  SPEAKER_02: It just had new modern things kind of bolted on or you know put into place after the fact.
• 2:36
  SPEAKER_02: We didn't tear it down and start over because there's new ways of doing things.
• 2:41
  SPEAKER_02: Well, application development is no different.
• 2:45
  SPEAKER_02: Focusing only on new things will leave a major gap in your education.
• 2:49
  SPEAKER_02: You won't be able to work on the systems that were built 10, 15, 20 years ago because you're not familiar with how those systems work.
• 2:58
  SPEAKER_02: Now you may say, well, I don't want to work on an old system, but that's like an electrician saying, you know what, I only want to work on houses that were built this year.
• 3:09
  SPEAKER_02: That's great, but you really limited what work you can do.
• 3:14
  SPEAKER_02: And now a lot of the work that you've you know could do, you're not able to do.
• 3:19
  SPEAKER_02: And then you say there's no jobs out there.
• 3:21
  SPEAKER_02: Well, that's because you put a major limitation on your career.
• 3:27
  SPEAKER_02: So businesses are built upon legacy code.
• 3:31
  SPEAKER_02: It's the nature of business.
• 3:33
  SPEAKER_02: It does not matter how cutting-edge the business is, at some point, they will have legacy code.
• 3:40
  SPEAKER_02: Because even if the business starts today and they start with the most modern frameworks, the most modern systems, do you think it's gonna look like five years from now?
• 3:50
  SPEAKER_02: It's not gonna be the most modern framework, the most modern system, because five years have gone by and they can't just throw things out and start over.
• 3:59
  SPEAKER_02: So knowing how to work on a legacy code base and knowing how to integrate new techniques is an important skill to have.
• 4:08
  SPEAKER_02: It's not just about saying, oh, I'm resigned to working on old code.
• 4:12
  SPEAKER_02: It's how do you work on that old code and bring new things into it?
• 4:17
  SPEAKER_02: Just like with my house in the 1850s, it wasn't just, oh, I have to not have electricity because it wasn't really a relevant thing at that time.
• 4:27
  SPEAKER_02: No, we we had all the, we had, you know, high-speed internet.
• 4:31
  SPEAKER_02: Well, how?
• 4:32
  SPEAKER_02: Because we worked with the system we had.
• 4:35
  SPEAKER_02: I had nice new plumbing, I had nice new electrical, I had a lot of things because we worked within the system we had and figured out how to work with the house to improve it over time with those new skills and techniques while still acknowledging that it's a house built in the 1850s.
• 4:53
  SPEAKER_02: That type of skill as a developer is really important because you may not have the equivalent of a house built in the 1850s.
• 5:02
  SPEAKER_02: You may not have a software that was built in the 70s, but you may have software that was built 20 years ago or 15 years ago or 10 years ago, and it will not be cutting edge necessarily.
• 5:15
  SPEAKER_02: Now, it's great to bring it to that spot.
• 5:18
  SPEAKER_02: It's great to bring it to the newer technologies and upgrade it, and that's a huge skill for developers to have because you can become the catalyst for helping an organization move forward and improve, but you have to acknowledge that you will work on legacy code.
• 5:36
  SPEAKER_02: So limiting your learning to only new technologies is going to limit who you can work for and it's gonna slow your growth as a developer.
• 5:45
  SPEAKER_02: Broaden your training to include older versions.
• 5:48
  SPEAKER_02: If you're a.NET developer, include the.NET framework and earlier.NET Core things in your learning.
• 5:55
  SPEAKER_02: Don't just focus on.NET 8 or the coming.NET 9.
• 6:00
  SPEAKER_02: Focus on learning C sharp, learning the.NET system as a whole, and knowing how to move throughout the different versions of it so that you can work with systems that use potentially some older code in a way that will allow you to be useful to the organization as it is and also helpful in moving that organization forward.
• 6:24
  SPEAKER_02: So that's number one.
• 6:26
  SPEAKER_02: Number two is learning only what you need for your current job.
• 6:32
  SPEAKER_02: So this is kind of the opposite end where you know you get into a job and maybe it is working on.NET Framework 4.8.
• 6:41
  SPEAKER_02: Well, then you only learn that and you only work on that.
• 6:44
  SPEAKER_02: That's another major mistake as a developer.
• 6:47
  SPEAKER_02: So too many people cripple their career by only learning what they need to know for their current job.
• 6:55
  SPEAKER_02: This is a mistake because it locks you into a very specific type of job.
• 7:00
  SPEAKER_02: When you try to leave, you'll find there's not as many, you're not as qualified as other candidates.
• 7:06
  SPEAKER_02: And you'll have to spend a lot of time getting up to speed when you should already be applying for jobs.
• 7:13
  SPEAKER_02: This slows your ability to switch jobs and endangers your career if you get laid off suddenly.
• 7:20
  SPEAKER_02: This is a big deal.
• 7:21
  SPEAKER_02: So I've seen a lot of people that get kind of locked in on, well, I'm busy at work and I'm just gonna focus on this, I'm gonna make my current job better, and that's great.
• 7:32
  SPEAKER_02: But just focusing on that, you know, professionally is not wise.
• 7:38
  SPEAKER_02: Expand your knowledge outside of a specific technologies and techniques that your current organization utilizes.
• 7:45
  SPEAKER_02: That may mean taking some of your free time to learn on your own.
• 7:51
  SPEAKER_02: Your employer is not responsible for your education.
• 7:54
  SPEAKER_02: You are.
• 7:55
  SPEAKER_02: Think of this time as investing in your future.
• 7:59
  SPEAKER_02: If you don't invest early and let it grow over time, you'll have very little later on when you need it.
• 8:07
  SPEAKER_02: And in today's job market, the idea of changing jobs is getting more and more relevant to more and more developers because you get laid off, you get, you know, downsized or cut out, and you have to find a new job.
• 8:21
  SPEAKER_02: And it's kind of too late at that point.
• 8:23
  SPEAKER_02: It's not too late, but it's it's pretty late to try and figure out then how to add all these skills that you now need to know.
• 8:31
  SPEAKER_02: Continue to build your skills, invest in you.
• 8:35
  SPEAKER_02: Make sure that you think about you and how you can be a better developer for the next job, whether it's because you want a pay raise and so you switch jobs, or that's because you don't have the opportunity to stay at your current job and you need to find a new one that can support you and your family.
• 8:55
  SPEAKER_02: So that's number two.
• 8:57
  SPEAKER_02: Number three, you're you probably expected this, not practicing.
• 9:02
  SPEAKER_02: So the first attempt at anything is usually your worst attempt.
• 9:06
  SPEAKER_02: So if you're doing your first attempt at something in production or in a real application, that's your worst time.
• 9:14
  SPEAKER_02: That's your worst um iteration of that thing that you've learned.
• 9:19
  SPEAKER_02: Don't do that.
• 9:21
  SPEAKER_02: Make sure your first attempt is in a practice environment.
• 9:24
  SPEAKER_02: Now, you haven't actually proven that you learned a subject until you build something with it.
• 9:30
  SPEAKER_02: This is something that people make a mistake on as they say, well, I watched this, I know what I'm doing, but I've seen it done.
• 9:37
  SPEAKER_02: The problem is that usually watching something or reading a book or whatever it may be, usually you see kind of the happy path where things just work.
• 9:47
  SPEAKER_02: But when things break, what happens?
• 9:49
  SPEAKER_02: Well, you need to figure that out because you need to go through that to know, well, how do I do this in the real world, not just in a nice comfy demo?
• 9:59
  SPEAKER_02: And then practice helps you build clean examples for you to validate what you've learned and how to use it.
• 10:07
  SPEAKER_02: And then that clean example can be useful when you later have to kind of refer back to it and say, wait, how did I do this?
• 10:15
  SPEAKER_02: Well, you have a clean example because you built something, just a sample.
• 10:20
  SPEAKER_02: Doesn't have to really do anything except validate what you learned.
• 10:24
  SPEAKER_02: And then building in production or with a real app without practicing first, it's one of the best ways to introduce major bugs in your code.
• 10:32
  SPEAKER_02: So this again is another danger with not practicing, because you are making your job harder.
• 10:41
  SPEAKER_02: You're slowing down what you want to do in production, even though you're trying to go faster.
• 10:48
  SPEAKER_02: You know, it's it's the idea of racing ahead, but actually instead of being like the rabbit in the race, you're more like a turtle, where you just kind of plod along and and have that steady progress instead of the sprint and get distracted and sprint and get distracted.
• 11:05
  SPEAKER_02: And so when you're talking about learning, practice feels like sometimes you're not getting something done.
• 11:12
  SPEAKER_02: But in reality, it's helping you make steady progress towards your goal and it's allowing you to do things faster because you are taking it a little slower, because you are practicing in a safe environment first and figuring out those bugs and making sure you know how things work before you put it into a real application, so that then those bugs don't slow down your real application and cause major problems.
• 11:42
  SPEAKER_02: So spend time practicing everything you learn.
• 11:46
  SPEAKER_02: You'll improve your understanding of the subject, you'll validate what you were taught, and you'll give yourself something to look back on when you struggle with that subject later on.
• 11:55
  SPEAKER_02: So this is gonna speed up your development and reduce the time you spend debugging non-working code in your real application.
• 12:03
  SPEAKER_02: So that's the reason why practice is so important.
• 12:07
  SPEAKER_02: That's the reasons why practice is so important.
• 12:09
  SPEAKER_02: So that's number three.
• 12:11
  SPEAKER_02: Number four on the major mistakes developers make is learning design patterns before learning how to build applications.
• 12:20
  SPEAKER_02: And this is one specifically focused on those who are earlier on in their learning journey.
• 12:25
  SPEAKER_02: A major focus of education is on design patterns.
• 12:29
  SPEAKER_02: But there's a few problems with this.
• 12:32
  SPEAKER_02: One, you don't know how to build an application yet.
• 12:35
  SPEAKER_02: Two, you don't know what problems the design patterns solve.
• 12:39
  SPEAKER_02: And three, you don't know when the cost of the added complexity of a pattern is worth it.
• 12:45
  SPEAKER_02: So those three things add up to problems.
• 12:49
  SPEAKER_02: They slow down your development.
• 12:51
  SPEAKER_02: Knowing how to build an application is really important because then it gives you that foundation.
• 12:58
  SPEAKER_02: So learn to build applications first.
• 13:01
  SPEAKER_02: And yes, you're gonna build applications, quote unquote, wrong.
• 13:05
  SPEAKER_02: They're gonna be not the best way of doing it.
• 13:08
  SPEAKER_02: That's okay because each application you build should be a little better than the last one.
• 13:14
  SPEAKER_02: You learn to identify the mistakes you make and fix them for the next time.
• 13:18
  SPEAKER_02: This will give you a solid foundation to build upon.
• 13:21
  SPEAKER_02: Then, when you start to see common needs in your application, you can look for design patterns that fill that need.
• 13:28
  SPEAKER_02: You see, now what you have is a need, a problem, and you go find a solution for that problem instead of having solutions and trying to find needs to fill with that solution.
• 13:43
  SPEAKER_02: Okay, there's a difference.
• 13:45
  SPEAKER_02: It's the, you know, getting the cart before the horse.
• 13:48
  SPEAKER_02: It's not the right order.
• 13:50
  SPEAKER_02: Knowing how to build applications is really important first.
• 13:54
  SPEAKER_02: I see a lot of graduates coming out of college where they know all the names for the major patterns, they have all these different patterns in mind, and they can name them better than I can.
• 14:04
  SPEAKER_02: And yet they've never built an application.
• 14:06
  SPEAKER_02: They don't know how to build an application.
• 14:09
  SPEAKER_02: They know all the quote unquote right things to do in an application, but they've only ever built small little practice ones where they've been led by the hand with their in by their instructor.
• 14:20
  SPEAKER_02: Instead of saying, hey, how would you start from scratch?
• 14:23
  SPEAKER_02: How would you build an application?
• 14:24
  SPEAKER_02: A small one even.
• 14:25
  SPEAKER_02: How would you do that?
• 14:27
  SPEAKER_02: Knowing how to do that is super important.
• 14:30
  SPEAKER_02: It's, I think, more important to do that first before you then get into the patterns and other things that will help you, but not yet.
• 14:42
  SPEAKER_02: And if you do it too early, they'll actually make things worse.
• 14:45
  SPEAKER_02: Because one of the things people don't realize when they first start off is that every design pattern has a cost.
• 14:53
  SPEAKER_02: And if you don't know what that cost is, and if you cannot justify that cost, then you don't know if you're making things better or worse.
• 15:05
  SPEAKER_02: And so if you don't know and you just say, well, I'm gonna put design patterns in because design patterns are good, right?
• 15:10
  SPEAKER_02: What you actually do is make things worse and worse and worse.
• 15:15
  SPEAKER_02: And your applications aren't really functional, they don't really work that well because they are quote unquote right, but they're a mess.
• 15:24
  SPEAKER_02: So instead of doing that, learn about the cost, the problems with applications as you build them.
• 15:31
  SPEAKER_02: Learn about the things that you need and learn about the uh areas where things could be better.
• 15:37
  SPEAKER_02: And then when you start to implement a pattern, you will see the costs that it adds to your application as well as the benefits it gives your application.
• 15:47
  SPEAKER_02: And then you can successfully weigh those two to make sure that you're making a wise choice.
• 15:53
  SPEAKER_02: So that's number four.
• 15:55
  SPEAKER_02: Number five is believing more than you actually, believing you know more than you actually do.
• 16:03
  SPEAKER_02: So this can take many forms.
• 16:06
  SPEAKER_02: So let's talk about a few different forms.
• 16:07
  SPEAKER_02: One, you've probably heard about the Dunning-Kruger effect.
• 16:11
  SPEAKER_02: So when the Dunning-Kruger effect essentially says that when you first start out learning something, you think it's easier than it is, or you think you know more than you actually do, because you actually have so little knowledge of a topic that you don't know what you don't know, therefore you think it's easier than it actually is.
• 16:33
  SPEAKER_02: Here's a great example of this.
• 16:35
  SPEAKER_02: And this is something that you know, you may say, Well, I've never done that.
• 16:41
  SPEAKER_02: Choosing how big an application is, saying, you know, doing an estimate of how long it will take to build this simple little application.
• 16:51
  SPEAKER_02: How many times have you done it correctly?
• 16:54
  SPEAKER_02: And how many times have you grossly underestimated how long something will take?
• 17:00
  SPEAKER_02: Application difficulty is one of those things where, you know, the less experience you have building that particular application, the easier it may seem.
• 17:10
  SPEAKER_02: You may say, well, you know what?
• 17:11
  SPEAKER_02: I'm gonna build a CRM, a customer relationship management uh system, because that'd be a great thing to build.
• 17:20
  SPEAKER_02: How long do you think it's gonna take?
• 17:21
  SPEAKER_02: That's gonna take you months, if not years, to build, probably years, uh, especially if you do it on your own, because that's a very complicated system.
• 17:30
  SPEAKER_02: You may say, well, no, it's not.
• 17:31
  SPEAKER_02: It's just real simple.
• 17:32
  SPEAKER_02: It's just tracking people and you know, a couple different uh main categories and trying to track information about it's a lot more complicated than that.
• 17:41
  SPEAKER_02: The same with a student information system, the same with a lot of these other quote unquote starter projects that people try and say are starter projects, they're not.
• 17:50
  SPEAKER_02: Because the farther you go down into something, the more you realize just how much depth and complexity there is.
• 17:58
  SPEAKER_02: And so this is one of those things that when you're a developer, you've got to make sure that you are doing enough research to know what you don't know, to know all the areas that are pitfalls, and to know that you have to learn a lot more than you thought you did.
• 18:17
  SPEAKER_02: And so trying to overcome the Dying Kruger effect is one of these many forms.
• 18:23
  SPEAKER_02: So there's others though, like the tutorial scholar.
• 18:29
  SPEAKER_02: So you watch tutorials that introduce a topic, so you think you understand the topic.
• 18:36
  SPEAKER_02: This goes back to the practice thing, is that you know you've watched these things, you say, hey, I've you know, I've been I've been watching C sharp you know videos for you know months, and now I'm a C sharp developer, right?
• 18:47
  SPEAKER_02: No, no, you're not.
• 18:49
  SPEAKER_02: Because just because you watch something doesn't mean you can do something.
• 18:53
  SPEAKER_02: And if you're not careful, it becomes entertainment rather than education.
• 18:58
  SPEAKER_02: Because just watching something doesn't really matter.
• 19:03
  SPEAKER_02: It's about what you comprehend until you actually use it and can prove to yourself and to others that you can do it, you haven't really learned it.
• 19:14
  SPEAKER_02: So this is another area where developers can overestimate how much they know.
• 19:19
  SPEAKER_02: I see this a lot in resumes, where a person will list something on their resume and say, well, I am you know an intermediate level knowledge of JavaScript.
• 19:30
  SPEAKER_02: And what that actually means is they've watched some JavaScript videos.
• 19:34
  SPEAKER_02: And when we talk about JavaScript, it becomes very evident that they don't really know a whole lot.
• 19:41
  SPEAKER_02: In fact, they may not have actually ever built a web application that uses heavy JavaScript or even moderate levels of JavaScript.
• 19:51
  SPEAKER_02: So that's when you go, hey, maybe you just were more watching tutorials and feeling comfortable rather than actually building something.
• 20:00
  SPEAKER_02: This is why it's so important to build something.
• 20:02
  SPEAKER_02: Another way this can show up is the sheltered developer.
• 20:06
  SPEAKER_02: This is one that can be frustrating at times for me, just to be honest here.
• 20:11
  SPEAKER_02: Um, but it's one where you make assumptions about how the world works because that's what you have seen, even though you've only seen a few situations.
• 20:23
  SPEAKER_02: I get this quite a bit.
• 20:25
  SPEAKER_02: And part of this that's frustrating for me is I've seen a lot in my time.
• 20:30
  SPEAKER_02: I've I've worked as a developer for over 25 years.
• 20:33
  SPEAKER_02: I've been a consultant for hundreds of different companies.
• 20:36
  SPEAKER_02: And so I've seen a lot of different situations, and even I have not seen it all.
• 20:41
  SPEAKER_02: By far have not.
• 20:43
  SPEAKER_02: And again, it's that kind of Dunning-Kruger effect where I know what I don't know to an extent, and I know there's a lot more I don't know.
• 20:52
  SPEAKER_02: But I see people come confidently in and saying, well, this is how this is.
• 20:57
  SPEAKER_02: And I can list situation after situation after situation where that's not true.
• 21:01
  SPEAKER_02: But what it is is you get so focused on your narrow worldview and your narrow uh part of the globe, your narrow part of the industry, your narrow part of development where you think that you have a good handle on how things work because you're a senior developer.
• 21:21
  SPEAKER_02: Well, yes, in your specific situation, but that doesn't necessarily apply to a broader perspective.
• 21:30
  SPEAKER_02: And so if you can identify that, hey, maybe I am a little sheltered, or maybe I am not as broadly skilled as I could be in even knowing what's out there, that can be really beneficial to your career.
• 21:45
  SPEAKER_02: Because when you start talking to people, when you start comparing notes with other developers, how often do you hang out with the developers?
• 21:51
  SPEAKER_02: How often do you have those conversations where you say, What do you do and how does it work?
• 21:56
  SPEAKER_02: And in being open to the idea that they have differing ideas.
• 22:00
  SPEAKER_02: That might be as valid as yours or even better.
• 22:03
  SPEAKER_02: Having those conversations and getting outside of your little bubble will really help your career, allow you to kind of pick your head up a bit, see where things are, and have a better perspective on finding your next job or knowing what's coming or knowing how to take advantage of a new technology.
• 22:24
  SPEAKER_02: Because looking beyond just your situation will be really valuable.
• 22:30
  SPEAKER_02: Okay, the next one in this kind of category of thinking you know more than you do is the perfect, and I'll put this in big old quotes, the perfect resume.
• 22:42
  SPEAKER_02: Um, I get people that tell me I've applied for a thousand jobs, and you know, it's just people aren't you know hiring right, or the recruiters aren't reading the resumes properly, or when it's a thousand times, it's something that you have to fix.
• 23:00
  SPEAKER_02: I know it sounds harsh, and I know you there is a whole messy situation when it comes to hiring, and I know that it's frustrating, and I know that good people don't get hired for jobs they're qualified for.
• 23:12
  SPEAKER_02: But at some point, you have to realize there's a common denominator.
• 23:18
  SPEAKER_02: Okay, and that common denominator is you.
• 23:22
  SPEAKER_02: So you may feel like you don't need to expand your expertise into other areas because those jobs are just asking for too much, or things like that, where you say, hey, you know, I this is who I am, and you just need to accept that I'm a good developer, or you need to know that that's not how that works.
• 23:43
  SPEAKER_02: It's on you to be able to learn what people are looking for and learn how to present what you can do in the way that makes sense for them.
• 23:55
  SPEAKER_02: Because they're not coming to you, you're going to them.
• 23:59
  SPEAKER_02: And therefore, you need to be able to present yourself in a way that's acceptable to them, that's going to be eye-catching to them, that's going to be that's going to show off what you can really do.
• 24:12
  SPEAKER_02: And you need to be able to think through am I a well-rounded developer?
• 24:17
  SPEAKER_02: Being honest with yourself about where am I really?
• 24:22
  SPEAKER_02: And that leads us to the next major thing that developers do wrong or make a mistake in, and that is not honestly evaluating your own work.
• 24:35
  SPEAKER_02: And this is going to be really hard.
• 24:37
  SPEAKER_02: This is something that you don't naturally want to do.
• 24:41
  SPEAKER_02: You naturally want to look at yourself and see yourself as the hero, see yourself as the one that's doing the hard work, that's that's that's right, that's you know, better than other people.
• 24:52
  SPEAKER_02: And you want to see yourself as successful.
• 24:55
  SPEAKER_02: But it's important to be able to have humility enough to look at what you do and honestly evaluate your own work.
• 25:06
  SPEAKER_02: This is connected to number the previous one, number uh five.
• 25:11
  SPEAKER_02: Um when you build something, you need to be able to evaluate it honestly.
• 25:16
  SPEAKER_02: Find the areas that need to be improved.
• 25:18
  SPEAKER_02: If you look at your application, you think it's perfect or nearly perfect, then you're not looking hard enough.
• 25:24
  SPEAKER_02: Always identify areas you could do better next time.
• 25:28
  SPEAKER_02: Because when you do that, then what happens is you do make things better next time.
• 25:33
  SPEAKER_02: And if you're constantly improving slowly, step by step over time, well, you become a more and more valuable developer.
• 25:42
  SPEAKER_02: And this applies to your resume and portfolio as well, as we were just talking about.
• 25:47
  SPEAKER_02: Evaluate how you can make improvements on them regularly.
• 25:53
  SPEAKER_02: Don't blame the hundreds of jobs you applied for as if they're the problem.
• 25:59
  SPEAKER_02: Figure out how to make your resume stand out more in that crowd.
• 26:03
  SPEAKER_02: Again, it's either a hundred people's problem or it's one person's problem.
• 26:08
  SPEAKER_02: Which do you think it might be?
• 26:10
  SPEAKER_02: I'm not saying that you're doing wrong.
• 26:12
  SPEAKER_02: What I'm saying is you can do things differently to have better success.
• 26:18
  SPEAKER_02: So learn to be your own constructive critic.
• 26:22
  SPEAKER_02: Your skills will improve quickly once you do.
• 26:26
  SPEAKER_02: And your resume will too.
• 26:28
  SPEAKER_02: Reach out to others as well, for sure.
• 26:30
  SPEAKER_02: But the first step is going to need to be you being able to look at your own work critically without being with a positive criticality, where you say, hey, this is complete and that's awesome.
• 26:42
  SPEAKER_02: But how can I do it even better next time?
• 26:45
  SPEAKER_02: What can I improve?
• 26:46
  SPEAKER_02: What can I change?
• 26:47
  SPEAKER_02: A developer's mindset, whether it be any of your own work or anything else, a developer's mindset needs to be, how do I make things better?
• 26:57
  SPEAKER_02: That's what you need to focus on.
• 26:59
  SPEAKER_02: Not how do I make things cooler, not how do I make things, you know, I don't know, anything other than better.
• 27:07
  SPEAKER_02: That's your focus.
• 27:09
  SPEAKER_02: How do I make things better for the user, for how the code process was built, how the code process was deployed, how your resume is created, how you present yourself to employers, whatever it is, how do I make things better?
• 27:23
  SPEAKER_02: Now, the seventh and last major mistake I see developers making.
• 27:29
  SPEAKER_02: And this is one that um comes up a lot, and I'm kind of smiling here because I see this a lot on my channel, but focusing on scalability instead of simplicity.
• 27:43
  SPEAKER_02: And I know I just stepped on some toes, and that's okay because I'm gonna step right back.
• 27:49
  SPEAKER_02: Um it is much more important to focus on the simplicity of your app rather than the scalability of your app.
• 28:00
  SPEAKER_02: Now, I'm gonna give you an example here that you may not realize.
• 28:04
  SPEAKER_02: Um, I've said it on a couple different comments.
• 28:06
  SPEAKER_02: I've kind of talked about this a few times, but I may have to do a full video just on this.
• 28:13
  SPEAKER_02: I hear a lot about well, you know, in order to scale, you have to use microservices.
• 28:18
  SPEAKER_02: Or uh monoliths are you know only good for small to medium sized applications, and really they they don't scale, uh, which is just ridiculous.
• 28:28
  SPEAKER_02: Um, and this is one of those things where, again, kind of going back to Dunning Krueger, you don't know what you don't know, therefore you think it's easier or you think something's better.
• 28:36
  SPEAKER_02: Um, Stack Overflow.
• 28:38
  SPEAKER_02: Okay, this is my favorite example because they publish everything, which is awesome.
• 28:42
  SPEAKER_02: I can give you a diagram that shows you exactly what Stack Overflow in the Stack Exchange family, how it's designed and how it runs.
• 28:50
  SPEAKER_02: Stack Overflow in the Stack Exchange system is a monolith.
• 28:55
  SPEAKER_02: It runs on nine web servers.
• 28:58
  SPEAKER_02: Yes, you can have a monolith run on more than one web server.
• 29:01
  SPEAKER_02: We've been doing it for decades.
• 29:03
  SPEAKER_02: Okay, so nine web servers and four SQL servers.
• 29:08
  SPEAKER_02: And actually, Stack Overflow itself has a cluster of two SQL servers, two to the four.
• 29:13
  SPEAKER_02: And of that cluster, one of them is a hot standby.
• 29:17
  SPEAKER_02: So really, the Stack Overflow at site itself is running off of one SQL server.
• 29:25
  SPEAKER_02: So that's pretty scalable.
• 29:28
  SPEAKER_02: The application is a monolith and yet serves 1.3 billion page views per month.
• 29:36
  SPEAKER_02: 1.3 billion.
• 29:38
  SPEAKER_02: And yet their response time is really low.
• 29:41
  SPEAKER_02: I believe it's like 12 milliseconds for the home page and 18 millisecond response time for a question page, like super fast, incredibly fast.
• 29:51
  SPEAKER_02: And I do all this with a monolith.
• 29:55
  SPEAKER_02: Scalability is primarily a feature of understanding how to optimize your application rather than the architecture of your application.
• 30:06
  SPEAKER_02: Now it may seem a little odd, but think this through.
• 30:10
  SPEAKER_02: Scalability is primarily a feature of understanding how to optimize your application rather than the architecture of your application.
• 30:20
  SPEAKER_02: If you cannot write a performant monolith, you will not write a performant microservice system.
• 30:30
  SPEAKER_02: Why would it be different?
• 30:32
  SPEAKER_02: Why is it that your microservices would be better and more performant than your monolith if you can't optimize the code in your monolith?
• 30:40
  SPEAKER_02: A monolith is the going to be the fastest way from top to bottom, start to finish for your application, because everything is connected.
• 30:49
  SPEAKER_02: Everything has a direct connection to everything else.
• 30:52
  SPEAKER_02: So when it comes to communication, it's all internal.
• 30:56
  SPEAKER_02: With a microservice system, you're now spreading things apart.
• 30:59
  SPEAKER_02: You have all the same logic in theory, but yet now you also add in the need to communicate over a longer period of time than you would in a monolith.
• 31:12
  SPEAKER_02: So you've added more complexity.
• 31:14
  SPEAKER_02: And now you've added all these different working parts that have to work in concert and yet independently.
• 31:20
  SPEAKER_02: So you've taken all this, in theory, all the same logic of your monolith, which wasn't performant.
• 31:28
  SPEAKER_02: And you've said, okay, take all that logic, put it into lots of smaller microservices.
• 31:34
  SPEAKER_02: So the logic is still there, it's just broken in different pieces, and it communicates more slowly.
• 31:40
  SPEAKER_02: And you've added a whole layer of communication, things like service bus and you know APIs and GRPC and everything else trying to communicate back and forth with all these different microservices.
• 31:55
  SPEAKER_02: How is that gonna be more performant?
• 31:58
  SPEAKER_02: The only reason you might get more performance is because you're throwing against more servers.
• 32:04
  SPEAKER_02: But the reality is you can take your monolith and put it on multiple servers.
• 32:09
  SPEAKER_02: So that scalability, it's not really what you think it is.
• 32:15
  SPEAKER_02: So your scalability is primarily a focus of the ability to optimize your application.
• 32:24
  SPEAKER_02: If you just try to make your application more scalable through architecture, then you're going to make a major mistake.
• 32:31
  SPEAKER_02: Okay?
• 32:32
  SPEAKER_02: So your application will almost certainly not have the scalability needs of Stack Overflow.
• 32:38
  SPEAKER_02: I love the optimism.
• 32:40
  SPEAKER_02: I love the optimism of you know what?
• 32:42
  SPEAKER_02: We need to be Google scalable.
• 32:44
  SPEAKER_02: Like we need to have the ability to just scale up to millions of people at the same time.
• 32:51
  SPEAKER_02: That's really optimistic, but for 99.9% of the people, you don't need it.
• 32:57
  SPEAKER_02: Okay.
• 32:58
  SPEAKER_02: But what you will have is the need for people to maintain and update your application over time.
• 33:06
  SPEAKER_02: Everyone needs that.
• 33:08
  SPEAKER_02: When you build an application, it will need to be maintained and updated over time.
• 33:13
  SPEAKER_02: Guaranteed.
• 33:14
  SPEAKER_02: Okay, we don't create applications and then never touch them again.
• 33:17
  SPEAKER_02: If you do, you've got a problem.
• 33:19
  SPEAKER_02: But so if we build applications that need to be maintained and updated over time, then a focus on simplicity will have major benefits for every time the application is updated or maintained.
• 33:35
  SPEAKER_02: Because that simplicity will help people understand how your application works, understand how to make it better, understand how to make your application more scalable.
• 33:47
  SPEAKER_02: And yet, if your application is scalable first and doesn't really worry about the complexity that adds, well, then what happens is it's hard to maintain.
• 33:57
  SPEAKER_02: People are nervous to touch it, and it doesn't really scale nearly as well as you think it will.
• 34:03
  SPEAKER_02: So people are going to read your code thousands of times.
• 34:06
  SPEAKER_02: The odds your application needs to scale to billions of views per month is very, very low.
• 34:12
  SPEAKER_02: So thousands of times versus maybe once in a lifetime.
• 34:18
  SPEAKER_02: I would go the thousands of times first.
• 34:20
  SPEAKER_02: Optimize for that first.
• 34:21
  SPEAKER_02: Focus on the thing that will happen the most.
• 34:24
  SPEAKER_02: Now, that does not mean, and please hear me this, it does not mean you ignore scalability.
• 34:31
  SPEAKER_02: But what it does mean is you should value simplicity over a solution that will potentially scale larger.
• 34:38
  SPEAKER_02: So this is where you need to think through how do I write good code, code that is performant, but that is simple.
• 34:48
  SPEAKER_02: Rather than saying, how do I make sure that if we ever get to the point where you have a thousand developers working on this application and we're scaling out to global scale with millions of people per month or even per week, how do we make that work?
• 35:03
  SPEAKER_02: Okay.
• 35:04
  SPEAKER_02: So solutions like clean architecture, CQRS, and mediator are solutions for very specific problems.
• 35:13
  SPEAKER_02: Problems that you probably don't have and probably won't have.
• 35:18
  SPEAKER_02: Now, yes, there are applications where clean architecture, CQRS, and mediator are the right solution.
• 35:25
  SPEAKER_02: But those projects probably aren't yours, especially if you're building an application yourself or with a team of two people or three people.
• 35:37
  SPEAKER_02: You're probably gonna get to that spot.
• 35:39
  SPEAKER_02: What you probably need instead is the simplicity to allow your whole team to work on it well.
• 35:45
  SPEAKER_02: So making a simple app will be hard work.
• 35:52
  SPEAKER_02: Making things simple is hard, but that's where you're gonna see the most return on your investment.
• 35:59
  SPEAKER_02: So it's like saying, hey, if you you could either put your money into a savings account where it'll make 0.1% interest, or you can invest in this investment over here and make 10% interest.
• 36:12
  SPEAKER_02: Which would be the better place to put most of your money?
• 36:16
  SPEAKER_02: Probably the investment.
• 36:17
  SPEAKER_02: Now, you know, let's not go into the weeds of well, that's a bad investment, whatever.
• 36:22
  SPEAKER_02: But just an illustration.
• 36:23
  SPEAKER_02: So when you're talking about your time, which do you want to do?
• 36:27
  SPEAKER_02: Do you want to invest in the very, very small return on your investments of maybe someday being a benefit?
• 36:35
  SPEAKER_02: Or do you want to invest in something where it's going to be a benefit day one and every day after?
• 36:41
  SPEAKER_02: So that's my list of the seven major mistakes that developers make in their career.
• 36:47
  SPEAKER_02: And I'm curious to know how many of those mistakes have you made in your career?
• 36:51
  SPEAKER_02: Start counting them up because we can make these mistakes over time, over and over, even.
• 36:57
  SPEAKER_02: So I know that I've made my fair share of these mistakes.
• 37:01
  SPEAKER_02: So let me know what your comment, what your number is down in the comments.
• 37:04
  SPEAKER_02: I love to hear what your thoughts are on these major mistakes and how you've learned to avoid them over your career.
• 37:11
  SPEAKER_02: Thanks for listening.
• 37:12
  SPEAKER_02: As always, I am Tim Corey.
• 37:15
  SPEAKER_01: Thank you for joining us for this episode of Deaf Questions.
• 37:18
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 37:21
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 37:28
  SPEAKER_01: You can also send your questions to questions at IamtimCorey.com.
• 37:34
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 37:41
  SPEAKER_01: When you're ready to learn to think and code like a professional developer, head over to imtimcore.com and enroll in a course.