Latest / DevQuestions with Tim Corey / 195 What Is the Progression of a Developer?

Transcript

195 What Is the Progression of a Developer? · 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:25
  SPEAKER_02: What is the progression of a developer?
• 0:28
  SPEAKER_02: What are the steps a developer goes through as they increase in their knowledge and skill?
• 0:34
  SPEAKER_02: This is the question we're going to tackle in today's episode of DevQuestions.
• 0:39
  SPEAKER_02: Now, I want to point out before we talk about the steps, and I'm not going to say junior, mid-level, senior, we're not going there.
• 0:45
  SPEAKER_02: We're going to talk a little bit more granular, a little bit more about the how it works rather than just giving random names to things.
• 0:53
  SPEAKER_02: Because everyone has a different definition for those names.
• 0:56
  SPEAKER_02: But at every stage, experience in that stage is what's important, not knowledge.
• 1:04
  SPEAKER_02: So when we talk about these different stages, I want to make sure you know that it's not just, oh, hey, I learned that, therefore I'm through that stage.
• 1:12
  SPEAKER_02: It's not about learning it, it's about having experience in that.
• 1:16
  SPEAKER_02: Because that experience will help you build a foundation that you build upon for the next stage.
• 1:21
  SPEAKER_02: So let's talk about the different stages.
• 1:24
  SPEAKER_02: And these are loose, and sometimes you'll find yourself doing more in earlier stage, even though you've progressed in other areas.
• 1:32
  SPEAKER_02: So just note that it's not a necessarily a linear graph.
• 1:37
  SPEAKER_02: But at the same time, there is going to be a just starting out through much more advanced developer as we go through this list.
• 1:47
  SPEAKER_02: Okay, so number one is you're just learning syntax.
• 1:51
  SPEAKER_02: Okay, so this is where you're learning about the language.
• 1:54
  SPEAKER_02: You're learning about how to even build something in the language.
• 1:58
  SPEAKER_02: You're learning about if statements and variables and how to do loops and methods and all the rest.
• 2:03
  SPEAKER_02: That's just basic syntax.
• 2:06
  SPEAKER_02: And sometimes people think that when they've learned the syntax, that's when they understand the language.
• 2:13
  SPEAKER_02: And in some ways that's true, in a lot of ways it's not.
• 2:17
  SPEAKER_02: Okay, so really this is point one.
• 2:19
  SPEAKER_02: This is the very top level, this is the very earliest in your journey is just knowing syntax.
• 2:26
  SPEAKER_02: And it's really just barely the beginning.
• 2:29
  SPEAKER_02: So if you find yourself in a place where you're you're just learning syntax, don't stop there.
• 2:35
  SPEAKER_02: Okay, that's a great thing to do.
• 2:37
  SPEAKER_02: And everyone starts at this stage, but you don't stop there.
• 2:41
  SPEAKER_02: Okay, so learning the syntax and then learning how to use that.
• 2:45
  SPEAKER_02: Again, experience is what's important at this stage.
• 2:49
  SPEAKER_02: Not just knowing what an if statement is, but having used it 10, 20, 30, 50 times is what's gonna get a value to you.
• 2:58
  SPEAKER_02: Number two, I call advanced syntax.
• 3:01
  SPEAKER_02: So, okay, you've learned about how to do an if statement and a for loop and a for each.
• 3:07
  SPEAKER_02: Maybe even know a difference between a do loop and a while loop and when to use each.
• 3:11
  SPEAKER_02: That's good.
• 3:12
  SPEAKER_02: And that's probably still back in the first syntax category.
• 3:15
  SPEAKER_02: But then there's some more advanced stuff that you're gonna start picking up, the more like the 20%.
• 3:21
  SPEAKER_02: You know, the syntax kind of covers the 80%, but the advanced syntax is like the stuff you don't use every day.
• 3:28
  SPEAKER_02: Things that you might not uh do right away, maybe things like uh asynchronous is probably in that category, or uh delegates, or even some object-oriented programming things like inheritance versus um interfaces and multi-inheritance and all the other things that you could get into.
• 3:47
  SPEAKER_02: Some of those things are more advanced in their syntax, and you won't use it all the time, but that's the next place to go is to dive deeper into the language, dive deeper into how to use the language in more scenarios.
• 4:01
  SPEAKER_02: That's kind of level, the second area.
• 4:04
  SPEAKER_02: After that is when you progress into problem solving and debugging.
• 4:09
  SPEAKER_02: Now, again, you may have done some of this before because you probably had to solve some problems back in syntax.
• 4:15
  SPEAKER_02: But this is where you really start focusing in on solving problems.
• 4:20
  SPEAKER_02: As junior developers, often what you get assigned is all the tickets that come in for, hey, this system's broken.
• 4:26
  SPEAKER_02: This we've got a bug over here.
• 4:28
  SPEAKER_02: Can you fix this logic issue?
• 4:30
  SPEAKER_02: Where you're not writing a new system, you're just solving a problem in the code that's existing.
• 4:37
  SPEAKER_02: And this is where you learn how to track down problems and learn how to debug systems and figure out where the issue is and what's going on.
• 4:45
  SPEAKER_02: Again, experience is really important here.
• 4:48
  SPEAKER_02: This is why when I tell my students to go through the C sharp master course, we learn debugging early on because you're gonna have bugs when you start learning syntax.
• 4:58
  SPEAKER_02: And I want you to practice that debugging right away.
• 5:02
  SPEAKER_02: Because what is most important about problem solving and debugging is the experience of it.
• 5:08
  SPEAKER_02: You can't just read a book on problem solving and then be a great problem solver.
• 5:13
  SPEAKER_02: It may help, but the reality is having seen the problems and having gone through a debugging steps, the more you do that, the more skilled you will be in that area.
• 5:26
  SPEAKER_02: Number four is okay, after syntax and advanced syntax and problem solving and debugging, you get to number four, which is knowledge of how applications are built.
• 5:37
  SPEAKER_02: Not necessarily having built full applications yourself, but knowledge of how they are built.
• 5:44
  SPEAKER_02: For example, as a junior developer, you might be in the room when the team talks about the decisions they make in building an application or in building a system or a part of a system.
• 5:55
  SPEAKER_02: And knowing how that works and starting to figure out how that all fits together.
• 6:02
  SPEAKER_02: How the it's more than just you know this little code bit here, but it's about the bigger picture.
• 6:08
  SPEAKER_02: And sometimes, you know, decisions you make at the big picture will affect which code bits you use or how you use things.
• 6:16
  SPEAKER_02: So knowing how applications are built from experience, from seeing it, is really valuable at this stage.
• 6:24
  SPEAKER_02: And this is where you start getting into that, starting kind of creep into the mid-level developer where you you started to see this stuff and started to work on yourself.
• 6:34
  SPEAKER_02: And then number five is firsthand experience on how to solve problems using long-term thinking.
• 6:43
  SPEAKER_02: So when you get a help ticket and you may you know get an issue where they say, hey, when we enter zero, the system crashes.
• 6:52
  SPEAKER_02: And you go and look and say, okay, well, we can just handle that and say, hey, if it's zero, don't crash.
• 6:57
  SPEAKER_02: I mean, that might be a solution from a junior developer.
• 7:00
  SPEAKER_02: But there are certain problems, and that may be one of them, but there are certain problems where there's a short-term solution, but there's a bigger implication.
• 7:10
  SPEAKER_02: And you have to think through, okay, I could solve this specific problem, but I know that we're gonna have problems X, Y, and Z in the future.
• 7:20
  SPEAKER_02: But if I solve it a different way, then we could solve all those problems or most of those problems, or mitigate potential problems by how we solve this problem.
• 7:31
  SPEAKER_02: So starting to think long term, thinking about more than just the specific little issue you're in right now, but kind of picking your head up and looking at the whole system a little a little bit bigger.
• 7:44
  SPEAKER_02: And you're looking a little bit deeper and a little bit farther down the road where you say, hey, if we do this, then this may become a problem later.
• 7:52
  SPEAKER_02: And starting to think through those longer-term implications of what you're doing.
• 7:59
  SPEAKER_02: Number six, knowledge of the patterns to solve common problems.
• 8:06
  SPEAKER_02: Now, I intentionally said the patterns to solve common problems, not design patterns.
• 8:11
  SPEAKER_02: Because yes, that's technically what we're talking about here in some ways, but not fully, because there are just normal patterns as developers that we have that we learn over time as we have solved problems.
• 8:24
  SPEAKER_02: And this is where I put it at number six because I think it's important.
• 8:27
  SPEAKER_02: And I got a future episode on dev questions that talks specifically on design patterns, but I think it's important to not put design patterns at the beginning.
• 8:38
  SPEAKER_02: Because you haven't seen the problems, you haven't learned how to think long term, you haven't looked at the overall architecture of an application, even if you haven't built one, but having seen it, having worked in an application for a while where you know how applications work and how things interact with each other, at that point, then you've already seen how to do certain things, and you've seen what problems come up when you do certain things certain ways.
• 9:09
  SPEAKER_02: Once you have that knowledge, then knowing about certain patterns that could help make those problems easier is helpful.
• 9:18
  SPEAKER_02: Knowing how to do things better and make things better with a pattern can be very, very valuable.
• 9:26
  SPEAKER_02: But if you don't have the history of knowledge of the big picture and of long-term consequences, well then you apply patterns in a way that is really irresponsible.
• 9:39
  SPEAKER_02: And you don't know any better necessarily because you've never seen the consequences of those long-term decisions that you're making by creating a pattern or using a pattern.
• 9:48
  SPEAKER_02: So being careful to know what the problems are and know the problems you're solving with a given pattern is really important at this stage.
• 9:57
  SPEAKER_02: And then again, practicing it.
• 10:00
  SPEAKER_02: Number seven is that you have an expanding viewpoint on your capabilities.
• 10:09
  SPEAKER_02: So, okay, when you think about what you can do, at first, maybe you're working in just methods and say, okay, I can run a method.
• 10:18
  SPEAKER_02: You know, at first you're in a help desk or you're you know solving help tickets where you saw a bug in somebody else's code.
• 10:25
  SPEAKER_02: But now you started to build methods.
• 10:28
  SPEAKER_02: And then maybe you build whole classes to solve problems.
• 10:33
  SPEAKER_02: And then from there, you start adding features to your application.
• 10:37
  SPEAKER_02: And then maybe you start building small applications or even whole systems that, you know, this part of the job takes a long time, but you start to grow out of, I can do this a little bit at a time, to I've got the long-term picture.
• 10:54
  SPEAKER_02: Um, I've got in my head, I've got the idea of how problems can manifest and the history of how to make sure that I avoid certain problems and pitfalls.
• 11:07
  SPEAKER_02: And I know how to kind of architect, really, is what you're starting to do.
• 11:12
  SPEAKER_02: And it's not, you're not a software architect yet.
• 11:15
  SPEAKER_02: You may be even just a mid-level developer.
• 11:17
  SPEAKER_02: But what you're starting to do is learn how to architect small little bits.
• 11:24
  SPEAKER_02: Start small.
• 11:25
  SPEAKER_02: Don't start with, I'm gonna build an entire application that everyone depends on.
• 11:30
  SPEAKER_02: Not the place to start.
• 11:32
  SPEAKER_02: You need some practice, you need to build up to it.
• 11:34
  SPEAKER_02: But you start with a method and say, okay, how can I design this method in a way that is thinking long-term, is hopefully bug-free, or you know, applying the principles I've seen to make it as bug-free as possible, and in a way that is going to help us out for the future.
• 11:53
  SPEAKER_02: And you start doing that with a class, and then a system or a part of your application, and then a whole system, and so on as you grow in your skills.
• 12:02
  SPEAKER_02: Again, this is where a lot of practice comes into place.
• 12:06
  SPEAKER_02: Where you're doing spending a lot of time just building things.
• 12:10
  SPEAKER_02: Now, number eight is when you start to mentor or lead others.
• 12:16
  SPEAKER_02: This is where you deepen your abilities.
• 12:18
  SPEAKER_02: So you spend some time one-on-one helping people grow, helping people below you, the juniors, the mid-level developers, you're starting to say, hey, let me give you some guidance, some help.
• 12:28
  SPEAKER_02: Maybe you start stepping into a team leadership role where you have a small team of developers that works with you, that you kind of lead and guide, and you start to create that long-term thinking for the team, not just for yourself.
• 12:43
  SPEAKER_02: You see, you keep growing and building upon what you've done before.
• 12:48
  SPEAKER_02: And once you've kind of conquered that, this is when you step into the next role of training others, blogging, speaking, teaching.
• 12:57
  SPEAKER_02: This is part of your growth process.
• 13:00
  SPEAKER_02: Now, not everyone gets here, but I think it's important that the developers that want to go the farthest do this.
• 13:08
  SPEAKER_02: And it's not because, you know, it's not if there are a certain personality or a certain no, it's about you learning.
• 13:16
  SPEAKER_02: It's about you learning how to communicate to a wider audience, to an audience that's not just one person or four people, to an audience that could be hundreds or thousands in a way that is clear, that's concise, that has, you know, steeped in gray advice, that is leading them in the right direction.
• 13:34
  SPEAKER_02: By doing so, if you do it right, you should be pushing yourself further.
• 13:41
  SPEAKER_02: So that's kind of the structure I see, the growth pattern of developers.
• 13:45
  SPEAKER_02: That's what I look for in developers and kind of figure out, okay, where are you in that one-to-nine scale?
• 13:52
  SPEAKER_02: Where are you?
• 13:53
  SPEAKER_02: Because if I hire you to be a senior developer, I want you to be in that number eight range at least.
• 14:00
  SPEAKER_02: I want you to be to the place where you're starting to mentor people.
• 14:03
  SPEAKER_02: You're starting to deepen your abilities by helping lead others to deepen theirs.
• 14:10
  SPEAKER_02: So figuring out where you are on that scale is important.
• 14:13
  SPEAKER_02: Figuring out what the next step for you is is important.
• 14:16
  SPEAKER_02: But the most important thing is to practice what you are learning.
• 14:21
  SPEAKER_02: Practice your particular number and start practicing the next one as well.
• 14:26
  SPEAKER_02: All right.
• 14:26
  SPEAKER_02: So that's my thoughts.
• 14:27
  SPEAKER_02: That's uh my thoughts on what is the progression of software developer?
• 14:33
  SPEAKER_02: How should you progress in your career?
• 14:35
  SPEAKER_02: All right.
• 14:36
  SPEAKER_02: Thanks for listening.
• 14:37
  SPEAKER_02: And as always, I am Tim Corey.
• 14:39
  SPEAKER_01: Thank you for joining us for this episode of Def Questions.
• 14:42
  SPEAKER_01: Tim is committed to making it easier for you to become a developer.
• 14:46
  SPEAKER_01: If you would like to help make more content like this possible, please like, subscribe, rate, and share Deaf Questions.
• 14:53
  SPEAKER_01: You can also send your questions to questions at IamTimcorey.com.
• 14:58
  SPEAKER_01: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 15:05
  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.