Latest / DevQuestions with Tim Corey / 246. What is the fastest way to become a developer?

Transcript

246. What is the fastest way to become a developer? · DevQuestions with Tim Corey

• 0:00
  SPEAKER_01: What is the fastest way to become a developer?
• 0:02
  SPEAKER_01: What shortcuts can I take to become a developer quickly?
• 0:06
  SPEAKER_01: Whether you're just starting out as a developer or you're looking to improve, I'm going to share with you the secrets to becoming a developer quickly.
• 0:15
  SPEAKER_01: Let's talk about it in today's episode of Dev Questions.
• 0:26
  SPEAKER_00: Welcome to the Dev Questions Podcast with Tim Corey.
• 0:30
  SPEAKER_01: Software development is more than just writing code.
• 0:33
  SPEAKER_01: So let's talk about the rest of it.
• 0:34
  SPEAKER_01: Specifically, let's talk about the fastest way to become a developer.
• 0:39
  SPEAKER_01: Now, there's lots of systems out there that offer quick results.
• 0:43
  SPEAKER_01: Whether it's a boot camp promising that you'll be a developer in eight weeks, or an online course promising that you'll be a developer in just a few short hours, these offers sound great.
• 0:54
  SPEAKER_01: They also often sound too good to be true.
• 0:57
  SPEAKER_01: That's because they often are.
• 0:59
  SPEAKER_01: See, these offers are essentially a get rich quick scheme.
• 1:04
  SPEAKER_01: They just hide it behind the idea of becoming a developer and then getting money because you're a developer.
• 1:11
  SPEAKER_01: Unfortunately, that's not how becoming a developer works.
• 1:14
  SPEAKER_01: It takes time and it takes effort.
• 1:17
  SPEAKER_01: But even so, there are ways to speed up the process.
• 1:21
  SPEAKER_01: So let's talk about the ways to speed up the process of becoming a software developer.
• 1:27
  SPEAKER_01: Number one, put together a training plan.
• 1:30
  SPEAKER_01: If you're just blindly going from thing to thing and just picking and choosing randomly what to learn next based upon what you feel in the moment you think you might need, well, that's gonna lead for a really wandering, weaving path towards your eventual destination if you even get there.
• 1:48
  SPEAKER_01: So having a training plan in place where you say, this is where I'm going, these are the steps I'm gonna take to get there, having that in place will help you move forward in a straight line faster.
• 2:02
  SPEAKER_01: Next, build things right away.
• 2:04
  SPEAKER_01: This is like the key principle here.
• 2:07
  SPEAKER_01: This is the number one way to move forward fast.
• 2:12
  SPEAKER_01: And it sounds counterintuitive, right?
• 2:14
  SPEAKER_01: It sounds like, well, I can skip building things.
• 2:17
  SPEAKER_01: I'm just going to just learn it and then go on to the next thing.
• 2:21
  SPEAKER_01: But that's not really learning.
• 2:23
  SPEAKER_01: You see, the the way you actually learn it is to do it.
• 2:28
  SPEAKER_01: Having head knowledge, having book knowledge, having memorized terms, these things aren't that important.
• 2:35
  SPEAKER_01: In fact, learning all the syntax for C sharp really doesn't give you a whole lot.
• 2:41
  SPEAKER_01: Instead, it's knowing how to take that syntax and apply it, knowing how to put it together into something larger.
• 2:49
  SPEAKER_01: It's like knowing that you have all the ingredients in the kitchen, but never actually having built a meal.
• 2:56
  SPEAKER_01: You see, it's not about having the ingredients in the kitchen.
• 3:00
  SPEAKER_01: It's about being able to build great meals.
• 3:03
  SPEAKER_01: And even with the right ingredients, it takes some practice to get things right to build something that tastes good.
• 3:09
  SPEAKER_01: Well, in the same way that apps, it takes some practice to build something that works well, even though you think you know all the individual ingredients or the syntax pieces.
• 3:19
  SPEAKER_01: So build things right away.
• 3:22
  SPEAKER_01: That will give you experience necessary to quickly move forward.
• 3:26
  SPEAKER_01: Now, it's still gonna take time, it's still gonna take effort, but this is the fast way to go is to start building things.
• 3:35
  SPEAKER_01: So, number one, put together a training plan.
• 3:38
  SPEAKER_01: Number two, build things right away.
• 3:40
  SPEAKER_01: Number three, be consistent.
• 3:43
  SPEAKER_01: Oftentimes I see people who are energetic, who were saying, yeah, I want to be a developer.
• 3:48
  SPEAKER_01: I'm gonna start today, I'm gonna spend eight hours a day studying.
• 3:52
  SPEAKER_01: Well, that's great.
• 3:53
  SPEAKER_01: I'm growing I'm super happy that you're enthusiastic.
• 3:57
  SPEAKER_01: But temper that a bit.
• 4:00
  SPEAKER_01: Spend a little less time up front and be more consistent at it.
• 4:04
  SPEAKER_01: It is better to spend a couple of hours a day or an hour a day or an hour every two days every time consistently, as opposed to trying to do eight, 10 hours once a week.
• 4:20
  SPEAKER_01: It just doesn't work as well.
• 4:22
  SPEAKER_01: So being consistent, have that consistent progress, that that plodding along.
• 4:27
  SPEAKER_01: When you run a marathon, you don't sprint for the first mile.
• 4:31
  SPEAKER_01: You pace yourself.
• 4:33
  SPEAKER_01: Even though you could go faster, in the long run, it'll be faster to go slow and consistent.
• 4:40
  SPEAKER_01: Okay, so be consistent in your training.
• 4:43
  SPEAKER_01: Take your time, do it right.
• 4:45
  SPEAKER_01: Number four, do the hard thing.
• 4:48
  SPEAKER_01: And this could be debugging, it could be solving tricky problems, it could be just a certain point in your training journey where you go, man, I'm struggling to learn this, whether it's asynchronous programming or it's some kind of technique or something like that inside of the language where you're like, man, I'm I'm having a hard time grasping this.
• 5:11
  SPEAKER_01: Stick with it.
• 5:12
  SPEAKER_01: Do the hard thing.
• 5:14
  SPEAKER_01: Because here's the deal we don't get paid to do the easy thing.
• 5:19
  SPEAKER_01: If it was easy, everyone would do it, right?
• 5:22
  SPEAKER_01: You've probably heard that.
• 5:23
  SPEAKER_01: Well, as a software developer, we get paid to do the hard thing, the thing that other people fail to do, the thing that stops other people from going further.
• 5:33
  SPEAKER_01: And that's where you see a lot of new developers, where you might have a thousand new developers that are all trying to start learning a technology right away.
• 5:44
  SPEAKER_01: You might think, man, how can I ever stand out from the crowd?
• 5:47
  SPEAKER_01: Do the hard thing.
• 5:48
  SPEAKER_01: Because what happens is for most people, they hit the hard thing where their app doesn't compile.
• 5:54
  SPEAKER_01: They get an error and they get frustrated.
• 5:57
  SPEAKER_01: They spend time asking for help.
• 6:00
  SPEAKER_01: They don't actually solve the problem their own, they try to make somebody else do it for them.
• 6:06
  SPEAKER_01: Well, guess what happens?
• 6:07
  SPEAKER_01: Even if they get through that problem, there's another problem coming, another, and another.
• 6:13
  SPEAKER_01: And eventually they will just stop getting through.
• 6:15
  SPEAKER_01: It's like they're walking through a swamp up to their waist in muck, where it gets slower and slower and slower.
• 6:22
  SPEAKER_01: Whereas if you can say, you know what, I'm gonna figure this out, well, you're gonna learn debugging because you're gonna learn how do I track down a bug?
• 6:31
  SPEAKER_01: How do I understand what an error message is and how do I, how do I identify where it's talking about?
• 6:36
  SPEAKER_01: How do I read a stack trace?
• 6:38
  SPEAKER_01: How do I, you know, instrument my application so I can see what's happening step by step?
• 6:44
  SPEAKER_01: How do I read code so that I understand what the compiler is doing, what the computer is doing when it's running my code, so I can understand and how to take the assumptions out of my application and actually learn what's going on.
• 7:00
  SPEAKER_01: If you do the hard thing, if you push through, it's gonna be difficult, it's gonna slow you down.
• 7:05
  SPEAKER_01: And you might think, Tim, this is a slow way of doing things.
• 7:08
  SPEAKER_01: It's not, it's the fast way.
• 7:10
  SPEAKER_01: Because what will happen is you will learn more in that struggle than the person next to you who's trying to get out of it.
• 7:18
  SPEAKER_01: And by you learning more, yes, it slows you down at first.
• 7:21
  SPEAKER_01: They may even get through their problem because someone helped them.
• 7:24
  SPEAKER_01: But eventually what happens is the next problem comes and the next problem and the next problem, and it gets easier for you because you've practiced debugging or you've practiced pushing through these hard problems and looking at things in different ways and really trying to wrap your brain around what's happening so that you get better and better and better at it.
• 7:44
  SPEAKER_01: Well, software development is all about doing hard things.
• 7:48
  SPEAKER_01: And so the more you do those hard things, the better you'll be at that, which means the better developer you will be as well.
• 7:56
  SPEAKER_01: So, number four, do the hard thing.
• 7:58
  SPEAKER_01: Number five, don't bounce around.
• 8:02
  SPEAKER_01: Now, this is kind of tied in number four.
• 8:04
  SPEAKER_01: Because what happens often is a person who's learning software development, they learn a technology up to a certain point.
• 8:11
  SPEAKER_01: They do the to-do list, they do the hello world project, you know, they do these simple little projects, and then they hit something a little bit more tricky and they go, oh, that's kind of hard.
• 8:23
  SPEAKER_01: And they say, Well, I've learned enough.
• 8:25
  SPEAKER_01: I'm gonna go learn this other thing because that other thing is really shiny.
• 8:28
  SPEAKER_01: And so they bounce from one thing to the next to the next.
• 8:31
  SPEAKER_01: You'll see this a lot with front-end frameworks where a person will say, Well, I'm learning web developments.
• 8:38
  SPEAKER_01: I'm learning HTML and CSS.
• 8:39
  SPEAKER_01: Well, actually, actually, I'm gonna learn JavaScript.
• 8:42
  SPEAKER_01: Well, no, actually, I'm gonna learn Angular.
• 8:44
  SPEAKER_01: Well, I started Angular, but you know, React is better.
• 8:47
  SPEAKER_01: So now I heard Vue was pretty awesome.
• 8:48
  SPEAKER_01: It's not gonna go to Vue.
• 8:49
  SPEAKER_01: Oh, you know what?
• 8:50
  SPEAKER_01: There's Blazor.
• 8:52
  SPEAKER_01: And it's like, well, you've got all these technologies where you've done a few little demos of them, but you never actually learn them well.
• 9:00
  SPEAKER_01: And so what happens is you've got lots of experiences that you maybe even put in your resume, you probably shouldn't, but you put in your resume and say, I know all these things, but whenever you get asked about them or asked to build something in them, you can't do it because you never actually went to that depth.
• 9:17
  SPEAKER_01: So instead, what happens is you spent all this time and didn't get anywhere.
• 9:24
  SPEAKER_01: And that's another reason why sticking with it, doing the hard thing, not bouncing around, these things make you go forward faster.
• 9:33
  SPEAKER_01: Not because it feels fast, but because instead of bouncing around and essentially wasting your time, you are spending the time necessary to actually learn something and go deeper and figure out how this actually works.
• 9:49
  SPEAKER_01: And by doing so, you become a valuable developer in that area.
• 9:54
  SPEAKER_01: You're not in every area, you can't be in every area, but you know what?
• 9:58
  SPEAKER_01: In that area, you become more valuable.
• 10:01
  SPEAKER_01: Now, number six, don't cheat.
• 10:04
  SPEAKER_01: And what do I mean by don't cheat?
• 10:06
  SPEAKER_01: Because there's no mod or looking over your shoulder.
• 10:10
  SPEAKER_01: But when you're learning software development, it gets easy to cheat.
• 10:15
  SPEAKER_01: What I mean by that is let's say you're stuck on a problem and you can't figure out why your app is crashing, and it's throwing an error, and you don't know what is going on.
• 10:25
  SPEAKER_01: Well, the temptation is to ask somebody else to help you.
• 10:31
  SPEAKER_01: Don't cheat.
• 10:32
  SPEAKER_01: Try to do it yourself first.
• 10:35
  SPEAKER_01: I see so many people that say, I have an error, and I say, What's the error code?
• 10:40
  SPEAKER_01: What's the error message?
• 10:41
  SPEAKER_01: And I say, I don't know.
• 10:43
  SPEAKER_01: Well, you didn't even do the very first step of trying to figure out yourself.
• 10:48
  SPEAKER_01: So you're cheating.
• 10:49
  SPEAKER_01: What you're trying to do is make me fix your problem.
• 10:53
  SPEAKER_01: You're trying to get out of the hard situation.
• 10:56
  SPEAKER_01: That's cheating.
• 10:57
  SPEAKER_01: Don't cheat.
• 10:59
  SPEAKER_01: Spend the time necessary to read the error code, find out where it is in the code, track down what's happening in the code, put breakpoints in, look at the stack trace, spend the time necessary to understand what's going on, when this happens, what the data around that situation is, and so on to figure out why you're getting this error.
• 11:20
  SPEAKER_01: Okay, don't cheat.
• 11:22
  SPEAKER_01: Another way of becoming more and more common is to just ask AI to do it for you.
• 11:28
  SPEAKER_01: So you want to implement dependency injection.
• 11:31
  SPEAKER_01: Okay, hey, Chat GPT, implement that.
• 11:34
  SPEAKER_01: Or hey, co-pilot, implement that.
• 11:36
  SPEAKER_01: Well, eventually, I will highly encourage you to do that.
• 11:41
  SPEAKER_01: Eventually.
• 11:42
  SPEAKER_01: But here's the deal.
• 11:43
  SPEAKER_01: When you don't know how to do it yourself, the AI is gonna potentially get it wrong.
• 11:51
  SPEAKER_01: And you won't know.
• 11:53
  SPEAKER_01: That's the problem.
• 11:54
  SPEAKER_01: So learn how to do it yourself first, so that when you have the AI help you, it will be a helper, not your leader.
• 12:03
  SPEAKER_01: Make sure Microsoft named Copilot well.
• 12:07
  SPEAKER_01: It should be your copilot, your helper, your assistant, not your pilot, not your leader, not the thing that tells you what to do.
• 12:17
  SPEAKER_01: Instead, you should tell it what to do and you should check its work.
• 12:22
  SPEAKER_01: So don't cheat and just say, oh, well, I'm gonna have copilot do it.
• 12:26
  SPEAKER_01: The same is true for we talked about setting up a path and knowing what your path is.
• 12:32
  SPEAKER_01: Well, don't just ask AI for your path because it's gonna give you information, it's not all going to be right.
• 12:40
  SPEAKER_01: But the problem is it will sound right.
• 12:42
  SPEAKER_01: And so what happens is you go in the wrong direction.
• 12:46
  SPEAKER_01: Close, but not right.
• 12:49
  SPEAKER_01: And so you waste time because you decide to let an AI lead you instead of letting an AI assist you.
• 13:00
  SPEAKER_01: That's cheating.
• 13:01
  SPEAKER_01: Don't cheat.
• 13:03
  SPEAKER_01: Sometimes it's going to take hard work.
• 13:06
  SPEAKER_01: In fact, if you find that you're only ever doing easy things, you're probably not employable.
• 13:12
  SPEAKER_01: Because if it's only ever easy things, then you're replaceable.
• 13:17
  SPEAKER_01: Because if if you can do it easily, then so can somebody else.
• 13:21
  SPEAKER_01: And so it's not a valuable skill to have.
• 13:24
  SPEAKER_01: It takes work to do things right.
• 13:27
  SPEAKER_01: We talk about the idea that junior developers are going away.
• 13:31
  SPEAKER_01: I don't think they are.
• 13:32
  SPEAKER_01: But the reason why people think that is because of the fact that they say, well, actually, it's going to be mid-level and senior developers doing all the work.
• 13:42
  SPEAKER_01: Well, you have to get there somehow.
• 13:45
  SPEAKER_01: But you can do that if you follow this plan.
• 13:49
  SPEAKER_01: If you don't cheat, if you work through the hard thing, and then you can get to the point where you can use AI as your assistant and it can turn you into a mid-level developer.
• 14:00
  SPEAKER_01: It can help you move forward faster as long as you're not cheating and letting it lead.
• 14:07
  SPEAKER_01: Okay.
• 14:07
  SPEAKER_01: So very fine line there.
• 14:09
  SPEAKER_01: You need to be sure of what you're doing.
• 14:12
  SPEAKER_01: Okay.
• 14:13
  SPEAKER_01: So that's the six things that I think should are helpful.
• 14:17
  SPEAKER_01: Um, take time, taking the time to do it right will save you so much time compared to cutting corners.
• 14:25
  SPEAKER_01: And that's the real overarching answer here is take the time, do it right.
• 14:32
  SPEAKER_01: Slow and steady wins the race, right?
• 14:35
  SPEAKER_01: You're running a marathon, you're not running a sprint.
• 14:37
  SPEAKER_01: And so make sure you don't try and take illegal shortcuts.
• 14:40
  SPEAKER_01: They're going to send you off the path the wrong direction.
• 14:43
  SPEAKER_01: Make sure that you do the hard thing, put in the effort, don't bounce around, be consistent.
• 14:49
  SPEAKER_01: These things are really important to getting a good outcome.
• 14:54
  SPEAKER_01: But doing so will save you a lot of time compared to those who don't.
• 15:00
  SPEAKER_01: All right.
• 15:01
  SPEAKER_01: So thanks for listening.
• 15:02
  SPEAKER_01: And as always, I am Tim Corey.
• 15:04
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 15:07
  SPEAKER_00: When you're ready to learn to think and code like a professional developer, head over to imtimcore.com and enroll in a course.