Latest / DevQuestions with Tim Corey / 058 First Look at GitHub Copilot and What It Means For Developers

Transcript

058 First Look at GitHub Copilot and What It Means For Developers · 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: Let's take a first look at GitHub Copilot and what it means for us as developers.
• 0:32
  SPEAKER_02: Now, in the past week, I have heard from a lot of people asking the question: what is this new technology?
• 0:39
  SPEAKER_02: Is it going to take over the world?
• 0:40
  SPEAKER_02: Is it going to replace my job?
• 0:43
  SPEAKER_02: What's the good, the bad, the ugly?
• 0:45
  SPEAKER_02: So I thought it'd be a great opportunity to talk about this specifically GitHub Copilot, this new project that just came out, but also in general, what AI means for developers and is it coming for our job?
• 1:01
  SPEAKER_02: Now, this episode of Dev Questions be a little bit different.
• 1:04
  SPEAKER_02: Normally it's just me talking on a screen if you're watching on YouTube.
• 1:07
  SPEAKER_02: If you're listening on a podcast, it's just me talking in your ear.
• 1:11
  SPEAKER_02: But I am going to show off the GitHub Copilot site.
• 1:15
  SPEAKER_02: So I'll swap to a video in video type format.
• 1:19
  SPEAKER_02: If you're listening to the podcast, don't worry, you're not going to be missing any context here.
• 1:23
  SPEAKER_02: I will talk through what I'm what I'm pointing out on the site.
• 1:27
  SPEAKER_02: But if you want more information, you can go to copilot.github.com to get that information.
• 1:34
  SPEAKER_02: Or if you want to go watch this episode on YouTube, that's fine as well.
• 1:38
  SPEAKER_02: But you're not missing anything if you're just listening on the podcast.
• 1:42
  SPEAKER_02: So let's let's talk through what this is all about.
• 1:47
  SPEAKER_02: GitHub just recently launched a new uh limited preview release of a product called GitHub Copilot.
• 1:57
  SPEAKER_02: And the idea behind Copilot is they're saying it's an AI pair programmer to work with you.
• 2:04
  SPEAKER_02: So it's artificial intelligence that's gonna sit next to you and say, hey, how about you do this?
• 2:09
  SPEAKER_02: Hey, hey, how about you add this code?
• 2:12
  SPEAKER_02: And the the promise of this is really cool, but it's not exactly what people think it is.
• 2:20
  SPEAKER_02: So let's talk through these claims, what's true and what's marketing speak, what is gonna be beneficial, what's gonna be detrimental possibly, and what is just not something to worry about.
• 2:33
  SPEAKER_02: So let's start off right away with those two little letters at the very top AI.
• 2:39
  SPEAKER_02: AI stands for artificial intelligence.
• 2:42
  SPEAKER_02: And I can tell you that there's a broad range of what people think artificial intelligence is.
• 2:50
  SPEAKER_02: Some people, when they think of artificial intelligence, they think to the Star Trek The Next Generation, where they had an Android called Data.
• 2:59
  SPEAKER_02: And he was a you know close to human as possible.
• 3:02
  SPEAKER_02: He made his own decisions, he was inscrutable at times, he sacrificed himself other times, he was basically human.
• 3:13
  SPEAKER_02: This is not what this intends to be or is going to be.
• 3:18
  SPEAKER_02: This will not be that type of artificial intelligence.
• 3:22
  SPEAKER_02: GitHub co-pilot will not pass the Turing test, meaning it will not impersonate a human.
• 3:29
  SPEAKER_02: Really, in my mind, this isn't even artificial intelligence.
• 3:34
  SPEAKER_02: Artificial intelligence is it makes decisions, it makes choices, and really this at its heart is not making decisions.
• 3:45
  SPEAKER_02: Now you can argue with me, well, it's kind of making an if-then kind of comparison.
• 3:52
  SPEAKER_02: To me, this fits more in the machine learning category.
• 3:56
  SPEAKER_02: So what this is at its very heart is they have looked at the public repositories for open source code.
• 4:06
  SPEAKER_02: They scanned them and they said, hey, you know what?
• 4:09
  SPEAKER_02: There's some patterns here.
• 4:11
  SPEAKER_02: And with a big enough computer brain, you can look at billions of lines of code and say, I see similarities.
• 4:20
  SPEAKER_02: And they look at those similarities and say, okay, I have learned from this that you know, there's an easy way to, or there's you know, three different ways that people check for, let's just say, use a very simple example, null.
• 4:33
  SPEAKER_02: We check for null in this way, this way, or this way.
• 4:36
  SPEAKER_02: You know, we say is null, we say is not null, we say, you know, um equals not null or equals you know empty object or something like that.
• 4:45
  SPEAKER_02: So there's different different ways of doing it.
• 4:47
  SPEAKER_02: And so it looked at those things in the public repositories.
• 4:50
  SPEAKER_02: And then when you say in your code, hey, I need an is null check, it goes, I know how to do those.
• 4:58
  SPEAKER_02: Let me give you someone else's code, essentially.
• 5:01
  SPEAKER_02: And that's what this really is.
• 5:04
  SPEAKER_02: At its heart, it's just giving you someone else's code, and not even necessarily their full code.
• 5:12
  SPEAKER_02: In fact, we'll see in a minute that they don't even say that's going to work.
• 5:17
  SPEAKER_02: All right.
• 5:17
  SPEAKER_02: But the idea is that this is going to make suggestions for you.
• 5:21
  SPEAKER_02: Let's take a quick example here.
• 5:23
  SPEAKER_02: We're at the very um the first part of their page, they're showing off sentiments.ts, where they we do a replay here.
• 5:33
  SPEAKER_02: What the program writes in comments is, hey, I want to determine if the sentiment of this text is positive using a web service.
• 5:42
  SPEAKER_02: They write that in comments, and then the they write the the opening signature for their method, and then the AI or the ML or whatever call it, GitHub Copa says, I know how to check for sentiment analysis using a web API.
• 5:59
  SPEAKER_02: So it writes out all the code for doing that sentiment analysis, getting all the way down to the end where they've asked for a Boolean, which would be true or false, positive or negative, because they're asking for is positive, and it returns back, hey, if it's positive, then return true.
• 6:15
  SPEAKER_02: Otherwise, return false.
• 6:17
  SPEAKER_02: So it wrote uh you know nine lines of code based upon a common pattern developers do.
• 6:27
  SPEAKER_02: Well, you may not have known that pattern, you may not be familiar with the web service, you may not be familiar with all the things you have to do to check for uh asynchronous code and all the rest.
• 6:39
  SPEAKER_02: It did it for you, and that's pretty cool.
• 6:41
  SPEAKER_02: So there is a really big positive here.
• 6:44
  SPEAKER_02: Um, what I want you to take from this this overall talk is there's positives and negatives here.
• 6:50
  SPEAKER_02: Don't only listen to one of them.
• 6:52
  SPEAKER_02: Listen to both sides here.
• 6:53
  SPEAKER_02: So the positive here is that it is a paraprogrammer.
• 6:57
  SPEAKER_02: It is sitting next to you and saying, Hey, others have done it this way.
• 7:02
  SPEAKER_02: Now, again, this is not artificial intelligence as much as it as it is machine learning, where they have gone out and learned what other developers have done and are suggesting, hey, do you want to do this as well?
• 7:15
  SPEAKER_02: A simplified version of this would be we're taught to use class libraries where we say, let's write the code once and then reuse it.
• 7:25
  SPEAKER_02: Uh, the principle of dry, don't repeat yourself.
• 7:27
  SPEAKER_02: Write the code in a method and then call that method multiple times.
• 7:31
  SPEAKER_02: Well, this is just an expansion of that where we use other people's code as well and don't repeat the work of basically reinventing the wheel.
• 7:42
  SPEAKER_02: When someone has done it well once, or in this case, probably hundreds of times, then why are we doing that same exact code instead of just finding it somewhere?
• 7:54
  SPEAKER_02: The um the example of how we do this right now is you go to Stack Overflow and you search for your question, and you find people who have answered that question, and the the suggested answer, you go, Yeah, that looks good.
• 8:07
  SPEAKER_02: You copy and paste it.
• 8:08
  SPEAKER_02: I mean, the April Fool's joke for this year for Stack Overflow was a new keyboard for Stack Overflow that was just go to Stack Overflow, control C, Control V.
• 8:19
  SPEAKER_02: That was it.
• 8:19
  SPEAKER_02: You know, like just copy and paste, and that's all you need.
• 8:23
  SPEAKER_02: Well, you know, that is humorous, but in a way that's kind of true.
• 8:28
  SPEAKER_02: Why would I rewrite code that already works?
• 8:34
  SPEAKER_02: So this is just pulling that code in from other places.
• 8:37
  SPEAKER_02: Now, some of this looks great, and it could be feature complete 100%, but it's not always going to be that way.
• 8:47
  SPEAKER_02: So the the idea behind this is really positive.
• 8:50
  SPEAKER_02: You're bringing in the things you're already doing.
• 8:53
  SPEAKER_02: You are rein, you're not reinventing the wheel, which as developers we shouldn't be.
• 8:58
  SPEAKER_02: So that's the positive of it.
• 9:00
  SPEAKER_02: The negative of it is this is not going to write code.
• 9:05
  SPEAKER_02: This is not a code generation.
• 9:08
  SPEAKER_02: This is not something where it's going to say, okay, I've never seen this before, but I'm guessing we're going to do this and write methods for you.
• 9:18
  SPEAKER_02: It's going to look at what's already been done.
• 9:20
  SPEAKER_02: When you're thinking about programming, a lot of the stuff you've already done, we're going to do again, whether it's in a new language or whether it's just for a new application.
• 9:31
  SPEAKER_02: Data access is data access.
• 9:33
  SPEAKER_02: Talking to a SQL server is going to look kind of the same through every different project if you use the same, like if you use Dapper, or if you use Entity Framework, or if you use, you know, whatever data access system you use, it's going to look kind of the same from project to project to project.
• 9:51
  SPEAKER_02: The things are going to change.
• 9:53
  SPEAKER_02: There's a few environmental things that'll change, and this will help with that.
• 9:56
  SPEAKER_02: You know, try to infer some things, but um the actual kind of the bare bones of it is gonna be the same.
• 10:04
  SPEAKER_02: So that's the positive of it.
• 10:06
  SPEAKER_02: It's bringing in and helping us not reinvent the wheel.
• 10:10
  SPEAKER_02: It's not quite copy from Stack Overflow, but it's kind of that idea, all right?
• 10:16
  SPEAKER_02: So let's you know talk about what the other things of us are right now.
• 10:21
  SPEAKER_02: This is in public, I'm sorry, private preview.
• 10:24
  SPEAKER_02: Um, it's not something you can get right now.
• 10:26
  SPEAKER_02: You have to sign up, you know, wait list.
• 10:28
  SPEAKER_02: So I don't have it installed, but eventually it's gonna be in Visual Studio Code VS Code, not Visual Studio, VS Code.
• 10:36
  SPEAKER_02: And it's going to use um, they say whatever language you love because it's gonna search you know the web.
• 10:43
  SPEAKER_02: Right now they have not listed C sharp, but I am pretty certain they're gonna have C sharp pretty early on because Microsoft owns GitHub and Microsoft's language is C sharp, um, or one of the languages is C sharp.
• 10:59
  SPEAKER_02: So I would assume that it will be in there pretty soon.
• 11:03
  SPEAKER_02: Okay, but primarily the first things coming out of it are JavaScript, uh, Python, Ruby, TypeScript, those type of things.
• 11:10
  SPEAKER_02: Okay.
• 11:11
  SPEAKER_02: So yes, it's more than autocomplete.
• 11:14
  SPEAKER_02: They they kind of talk about that, but it really kind of is this idea of you give it the the broad strokes of what you want, and then it goes and fills out what it thinks you need.
• 11:27
  SPEAKER_02: But here's the kicker.
• 11:29
  SPEAKER_02: Here's one of the things that people are gonna miss in this.
• 11:34
  SPEAKER_02: You need to understand the code that it writes.
• 11:38
  SPEAKER_02: So if it writes this code that you see right here on the screen or any code, and you go, I don't know what that's doing, you really can't put that in your code, in your program.
• 11:51
  SPEAKER_02: Just like if you go to Stack Overflow and you find code that works, but you're not sure what it does, you really shouldn't put that in your program.
• 12:00
  SPEAKER_02: Because when you put things in your program you don't understand and they break, it's like magic.
• 12:06
  SPEAKER_02: When the magic stops working, you're up a creek.
• 12:09
  SPEAKER_02: What do you do?
• 12:10
  SPEAKER_02: There's nothing you can do.
• 12:12
  SPEAKER_02: So you really need to understand what it's doing.
• 12:17
  SPEAKER_02: All right, again, it's talking about skipping the documentation and searching for examples.
• 12:22
  SPEAKER_02: This has examples, it's really just bringing examples in that's already searched and found, which is very convenient, very positive from that perspective, but it still is just search the web, find examples.
• 12:36
  SPEAKER_02: All right.
• 12:36
  SPEAKER_02: Um, now one of the things that I, you know, writing testing that's pretty awesome.
• 12:41
  SPEAKER_02: It helps you write your tests.
• 12:43
  SPEAKER_02: That's pretty cool.
• 12:44
  SPEAKER_02: One of the things I heard um one on I saw a tweet somewhere where one person said, Hey, you know what?
• 12:50
  SPEAKER_02: This is gonna kind of replace the coding interview.
• 12:53
  SPEAKER_02: And that was actually one of the first demonstrations they used internally for GitHub Copilot.
• 13:00
  SPEAKER_02: Is they took the GitHub two-hour uh coding assessment that they do for developers and they ran GitHub Copilot through it, and it completed the entire assessment in about five minutes using tab tab.
• 13:15
  SPEAKER_02: Um, that's pretty awesome.
• 13:18
  SPEAKER_02: That's really cool stuff, and it does kind of highlight how silly some of those um coding interviews are.
• 13:27
  SPEAKER_02: Uh, because yeah, if you have access to the web where you can look these things up, or if you just have a library you can just bring in, why are you reinventing the wheel here?
• 13:40
  SPEAKER_02: But on the other hand, it does show off that you can write code.
• 13:43
  SPEAKER_02: But as these tools get better, it's gonna be harder and harder to accurately assess a programmer.
• 13:49
  SPEAKER_02: Because while 10 people could tab through in five minutes, answer correctly that two-hour interview question, probably nine people in that 10 people won't understand what the code does, and that's a problem.
• 14:10
  SPEAKER_02: So it is gonna get harder to understand who's a good programmer and who's not, not because there's an elitist thing here, but because again, you don't want to operate on magic.
• 14:22
  SPEAKER_02: So I wouldn't say because I had GitHub Copilot, I don't need to do that two-hour programming test.
• 14:32
  SPEAKER_02: I would still say that's probably a pretty good test, hopefully, um, because it is going to evaluate how you write code, not how the AI writes code.
• 14:44
  SPEAKER_02: So even if that would allow access to the web, but then I'd have I'd make sure they prove, you know, why'd you do that?
• 14:53
  SPEAKER_02: What's this line all about?
• 14:54
  SPEAKER_02: What does this do?
• 14:55
  SPEAKER_02: So that if you go, I'm not sure that line does, then you don't understand your own code.
• 15:01
  SPEAKER_02: That's a problem.
• 15:02
  SPEAKER_02: So I see that's where coding interviews can still have a place, but these tools will make it easier as a real or as a developer that's doing the actual job.
• 15:16
  SPEAKER_02: Again, if you understand the code.
• 15:19
  SPEAKER_02: So there's some cool things here.
• 15:21
  SPEAKER_02: I do want to point out they have some um some quotes here, and I want to point out some good and some bad around these quotes, but I think it highlights some of the assumptions about AI programming or ML programming, or how you want to talk about this idea.
• 15:39
  SPEAKER_02: So this first one in that I'm gonna show from Harry Edwards says trying to code in an unfamiliar language by Googling everything is like navigating a foreign country with just a phrase book.
• 15:51
  SPEAKER_01: Using GitHub Copilot is like hiring an interpreter.
• 15:57
  SPEAKER_01: I don't feel real good with that comment.
• 16:00
  SPEAKER_02: And the reason why is what I've already talked about, the idea that if you don't know why it's doing that, that's concerning to me.
• 16:09
  SPEAKER_02: On the other hand, if you know, as a developer, you understand logic.
• 16:16
  SPEAKER_02: And so switching between languages is a lot easier, it's just about syntax.
• 16:21
  SPEAKER_02: So if it's just helping you with, oh, okay, the syntax for an if statement uses curly braces or uses double parents or whatever it does, that's different.
• 16:32
  SPEAKER_02: So if it's about the syntax and knowing you know what spacing to use, to use commas or semicolons or however you do things in that language, what what keywords to use, that's definitely okay because helping you with the the awkward stuff that's just not that important.
• 16:55
  SPEAKER_02: The important part is the logic.
• 16:57
  SPEAKER_02: But if you don't understand the logic of it, if you don't understand what the code is doing even after writing it, yes, it may work and you maybe get the job done, but that doesn't mean you understand how it works if it breaks.
• 17:17
  SPEAKER_02: And so the danger here is going to be that let's just say you're a uh an intro programmer, you're a junior-level developer, you just get hired, and they say, Hey, I want you to use GitHub Copilot to work with you in building your code.
• 17:34
  SPEAKER_02: Cool.
• 17:35
  SPEAKER_02: You got a great tool to help you write better code.
• 17:39
  SPEAKER_02: And you say, Okay, I need to check for an email address and validate that it is an email address.
• 17:46
  SPEAKER_02: And that's actually one of the examples they have here.
• 17:47
  SPEAKER_02: It writes this really complicated uh regular expression, which has got all the you know crazy stuff in there.
• 17:56
  SPEAKER_02: That's great because that regular expression is messy and it's hard.
• 18:02
  SPEAKER_02: But how do you know it's actually gonna work correctly?
• 18:05
  SPEAKER_02: How do you know what it does?
• 18:07
  SPEAKER_02: How do you know if a email, a valid email address gets rejected by it, how do you know to fix it?
• 18:16
  SPEAKER_02: If you don't, but the problem is as a junior developer, if you get code to work, then because of the fast-paced environment of of you know employment, you may be pushed on to the next project.
• 18:31
  SPEAKER_02: Hey, it's working great, let's move on.
• 18:33
  SPEAKER_02: And it passes all the tasks you can think of going into production.
• 18:38
  SPEAKER_02: So cool, it's working, but you have no clue what your own code does.
• 18:44
  SPEAKER_02: That's scary.
• 18:46
  SPEAKER_02: Okay, so that's my fear is it's going to either enable people who shouldn't be doing this to do it, or it will enable abuse where you're pushed, you're forced into not understanding your own code, just move on, move on, move on.
• 19:03
  SPEAKER_02: It works, and that can put you in a really bad spot.
• 19:07
  SPEAKER_02: Okay, so that's one quote I want to point out.
• 19:09
  SPEAKER_02: Um, the upper right hand here, uh, Gunika, it surprised me how precisely I understood my comment and generated accurate suggestions.
• 19:18
  SPEAKER_02: The ability to choose from 10 different suggestions was the cherry on top.
• 19:23
  SPEAKER_02: And yes, that is amazing.
• 19:26
  SPEAKER_02: Again, you have 10 suggestions to pull from, though.
• 19:30
  SPEAKER_02: How do you know which one is right?
• 19:32
  SPEAKER_02: How do you know which one does the thing you're looking for?
• 19:35
  SPEAKER_02: If you don't understand the code, that's a problem.
• 19:38
  SPEAKER_02: If you do understand the code, that's awesome.
• 19:41
  SPEAKER_02: So definitely some positives and some negatives here.
• 19:44
  SPEAKER_02: So this big quote here in the first day, GitHub Copilot already taught me about the nuance in JavaScript object comparison and is comfortable and is as comfortable with our database schema as I am.
• 19:57
  SPEAKER_02: This is the single most mind-blowing application of ML I've ever seen.
• 20:02
  SPEAKER_02: I love that um Mike pointed out that it's ML that is doing this, it's machine learning.
• 20:07
  SPEAKER_02: It's it's the idea of it's scanned other code bases.
• 20:10
  SPEAKER_02: The teaching the nuance of JavaScript, that can be really helpful because it's gonna suggest things that you're not familiar with.
• 20:18
  SPEAKER_02: And if you look at that and go, why it do that, you can easily Google that and go, what is this, you know, in string and in str thing, or what is this, you know, whatever it does, and go, I didn't know that existed, but now I do, and I know how to put it in code.
• 20:37
  SPEAKER_02: That's really cool.
• 20:39
  SPEAKER_02: As long as it's teaching you, as in your learning what it's doing.
• 20:45
  SPEAKER_02: Okay so there's other things down here.
• 20:50
  SPEAKER_02: Um, the thing I really like, Kate points out.
• 20:52
  SPEAKER_02: Um, Kate says GitHub Copilot discovered the test I was working on, or discovered that a test file I was working on was missing a specific test and suggested and wrote the test for me.
• 21:05
  SPEAKER_02: That's awesome.
• 21:06
  SPEAKER_02: The idea that we can use this in unit testing, and it says, hey, you know what?
• 21:10
  SPEAKER_02: You're missing this edge case, you're missing this um potential bug.
• 21:14
  SPEAKER_02: And let's write a test for it and make sure that the test will fail and then pass.
• 21:19
  SPEAKER_02: That's really cool stuff.
• 21:21
  SPEAKER_02: I think for me, that's where I am the most excited.
• 21:25
  SPEAKER_02: The idea we can we can create a test file and say, hey, I want you to test this method, and it's that's where for me, the pair programmer really becomes true.
• 21:34
  SPEAKER_02: Because a pair programmer will point out things that are blind spots to you, the assumptions that you have that maybe aren't true.
• 21:42
  SPEAKER_02: You know, that email address example.
• 21:44
  SPEAKER_02: I would love to see it write the tests for that email method as well, where it would say, Okay, let's try the standard email address where it's you know Tim at IamtimCore.com, where you have the you know, the normal parts of an email.
• 22:00
  SPEAKER_02: Email address.
• 22:00
  SPEAKER_02: Then let's do things like um dot co.
• 22:03
  SPEAKER_02: So Tim I am Timcorey.co.
• 22:06
  SPEAKER_02: That's still a valid domain, or you know, a longer extension, or different extensions, or you know, single letters.
• 22:13
  SPEAKER_02: There's a lot of different possibilities you can do.
• 22:16
  SPEAKER_02: Um, first name dot last name add, and and so on.
• 22:21
  SPEAKER_02: So having that care programmer say you missed an edge case is really cool.
• 22:30
  SPEAKER_02: I hope that's one of the things that really comes out of this.
• 22:33
  SPEAKER_02: So um this is a pretty cool project.
• 22:38
  SPEAKER_02: It's kind of the the next generation or even a sister generation, probably next generation, of what Intellicode does now in Visual Studio.
• 22:49
  SPEAKER_02: We already have this.
• 22:50
  SPEAKER_02: Intellicode has already scanned other repositories and has found these are the things that you probably are looking for, and it helps you know complete whole um sections of your code, little sections, not as big as this.
• 23:05
  SPEAKER_02: So we already have this, this kind of the next step or in that um the idea of the ML scanning of the web and learning how coders write code and moving on from there.
• 23:19
  SPEAKER_02: There is down here, um, I believe, yes, how good is GitHub Copilot?
• 23:24
  SPEAKER_02: I want to point this out.
• 23:25
  SPEAKER_02: They benchmarked it against a set of Python functions that have good test coverage and open source repositories.
• 23:32
  SPEAKER_02: They blanked out all the function bodies and asked GitHub Copilot to fill them in.
• 23:37
  SPEAKER_02: The model got this right 43% of the time on the first try, and 50% 57% of the time when allowed 10 attempts.
• 23:48
  SPEAKER_02: That kind of gives you a good idea of where it's at.
• 23:54
  SPEAKER_02: So it already has a good set of tests, and it has now the method names to make those tests work.
• 24:01
  SPEAKER_02: So it's got a lot of information to pull from, and then they say go, and it gets it right 43% of the time.
• 24:09
  SPEAKER_02: And after 10 attempts, getting it 57% of the time, well, it it seems like that's better.
• 24:15
  SPEAKER_02: It's tried 10 times.
• 24:17
  SPEAKER_02: And yes, it's a learning algorithm that's gonna get better over time, but that's still getting it right half the time.
• 24:23
  SPEAKER_02: And this is why I'm stressing the fact that you need to understand what it's doing or trying to do.
• 24:30
  SPEAKER_02: Because if it's getting getting the code right even 57% of the time, that means the code it puts in is wrong at least 43% of the time.
• 24:43
  SPEAKER_02: Think about that.
• 24:45
  SPEAKER_02: The code that it suggested can be wrong, and so it may feel like it's right, it may look like it's right, it may even run somewhat, but it may be wrong.
• 24:58
  SPEAKER_02: So this is why I stress so much that you are the developer, you're in charge, you're the one that needs to understand the code, you're the one that needs to sign off on the code, you're the one that needs to fix the code when it breaks.
• 25:12
  SPEAKER_02: So this is an amazing looking tool.
• 25:16
  SPEAKER_02: Now, this is early preview, this is just coming out, but it's going to be, I think, a really good tool to use.
• 25:28
  SPEAKER_02: It'll be one that I will install in my VS Code, I will try now, I will probably use it pretty much all the time.
• 25:38
  SPEAKER_02: It doesn't mean it's replacing me.
• 25:41
  SPEAKER_02: Okay, and so that's one of the questions I'm getting a lot is hey, is it going to be in five years?
• 25:48
  SPEAKER_02: We don't need developers.
• 25:50
  SPEAKER_02: No, no, it's not.
• 25:52
  SPEAKER_02: Um even if this were to get to 100%, this does not mean and it's not going to get to 100%.
• 26:01
  SPEAKER_02: No tool ever does.
• 26:02
  SPEAKER_02: Um, no programmer ever does either.
• 26:04
  SPEAKER_02: Um, even if it got to 100% effective at doing these predictive methods, this does not mean that it will ever replace developers.
• 26:17
  SPEAKER_01: First of all, this is a learning system.
• 26:22
  SPEAKER_01: What does it learn from?
• 26:24
  SPEAKER_01: Developers.
• 26:26
  SPEAKER_01: Well, it learns the code that developers wrote.
• 26:29
  SPEAKER_01: So in fact, if you were to turn this loose right now, it would actually make itself dumber over time.
• 26:39
  SPEAKER_02: Because if it writes code that you just check in and say, Yep, cool, Gab Copilot wrote it, awesome, and check it in your repository.
• 26:47
  SPEAKER_02: It's not going to use that code to help train itself how to do it better in the future, but it's learning from its own mistakes.
• 26:55
  SPEAKER_02: And so it's going to reinforce those mistakes, which means it's going to get dumber and dumber and dumber over time.
• 27:00
  SPEAKER_02: It needs developers to go, no, this is bad code.
• 27:04
  SPEAKER_02: Let's fix it.
• 27:05
  SPEAKER_02: And then it learns oh, this is better code for that.
• 27:08
  SPEAKER_02: This is more used code for that.
• 27:10
  SPEAKER_02: I'm going to get better over time.
• 27:12
  SPEAKER_02: That takes developers.
• 27:14
  SPEAKER_02: Okay.
• 27:14
  SPEAKER_02: So that's one thing.
• 27:15
  SPEAKER_02: It's got to have developers to learn from.
• 27:17
  SPEAKER_02: It cannot learn on its own.
• 27:20
  SPEAKER_02: This is not artificial intelligence in the fact that it's a self-generating machine.
• 27:25
  SPEAKER_02: It's not going to self-learn these things.
• 27:28
  SPEAKER_02: It's going to take developers teaching it everything.
• 27:32
  SPEAKER_02: Right.
• 27:33
  SPEAKER_02: So that's one thing about it's not taking a very job.
• 27:38
  SPEAKER_01: Another is that this tool is just the next step in the evolution of development.
• 27:49
  SPEAKER_01: Back when we first had computers, where they were just raw ones and zero machines.
• 27:57
  SPEAKER_02: And this is before my time, but originally we programmed computers, we being developers in general, not me, um, with ones and zeros, with teaching it in binary.
• 28:08
  SPEAKER_02: And we learn assembly language.
• 28:10
  SPEAKER_02: We we talk assembly language.
• 28:12
  SPEAKER_02: That's really confusing and really dense and hard to understand.
• 28:16
  SPEAKER_02: And so over time, we have built up languages that did some of the work for us.
• 28:24
  SPEAKER_02: As a, if you're a C sharp developer, you have.NET.
• 28:28
  SPEAKER_02: And.NET does a lot of stuff for you.
• 28:30
  SPEAKER_02: You want a console window, you just say console application.
• 28:34
  SPEAKER_02: That's just a console application, gives you a console window.
• 28:37
  SPEAKER_02: You want to write to it, you say console.write line.
• 28:39
  SPEAKER_02: There is code behind that that a different developer you've never met probably wrote.
• 28:46
  SPEAKER_02: That is built upon a whole framework of code that developers wrote that you've probably never met.
• 28:53
  SPEAKER_02: And yet you put it in your production writing code, and it's fine because they wrote the code, they understood it, they tested it, they made sure it worked right, and then you build on top of that.
• 29:04
  SPEAKER_02: And some people say, well, that's not real development.
• 29:06
  SPEAKER_02: Real development is, I had one this past uh week or two where a person said, you know,.NET developers aren't real developers because they're using all these tools when a real developer uses C or C.
• 29:20
  SPEAKER_01: C or C is still an abstraction over ones and zeros, over assembly.
• 29:25
  SPEAKER_02: So there's always going to be this next level up of making our lives easier.
• 29:32
  SPEAKER_02: And we want to embrace that.
• 29:34
  SPEAKER_02: Because yes, it may feel like, oh, they're taking my job, oh, they're making, you know, change in how I do things, and I don't like that.
• 29:43
  SPEAKER_02: Um, I get that change is hard.
• 29:46
  SPEAKER_02: But at some point, we have to stop saying, let's build wheels, and start saying, let's use wheels that have been built for us.
• 29:56
  SPEAKER_02: And that's what this is.
• 29:58
  SPEAKER_02: We're building on top of the shoulders of giants.
• 30:01
  SPEAKER_02: We're building on top of what other people have gone before and done.
• 30:06
  SPEAKER_02: So this is going to be a continual improvement of development.
• 30:12
  SPEAKER_02: So this is kind of like we're seeing an evolutionary step.
• 30:16
  SPEAKER_02: It's a small one, it's not nearly as big as you think it is, but it is a small evolutionary step closer to the idea of us not having to do much work.
• 30:28
  SPEAKER_02: But I tell you what, they're never going to replace programmers.
• 30:32
  SPEAKER_02: Even here, you see that you have to tell it what you want.
• 30:36
  SPEAKER_02: Okay, I want a sentiment analysis that uses a web service.
• 30:42
  SPEAKER_02: That's not a lot, but it gives the necessary information for the AI to find potential suggestions.
• 30:51
  SPEAKER_02: Because at the end of the day, the job of a developer is writing logic.
• 30:59
  SPEAKER_02: It's not about the code, it's not about the syntax, it's not about the language, it's about writing the logic or identifying the steps necessary to get from point A to point B, whatever that is for your specific situation.
• 31:18
  SPEAKER_02: So this is going to help you with the syntax.
• 31:22
  SPEAKER_02: This is going to help you with developing the micro bits of logic where your job is going to be to have the overall, the bigger piece of the logic, putting the building blocks together.
• 31:37
  SPEAKER_02: This just makes the building blocks easier.
• 31:40
  SPEAKER_02: So don't be afraid for your job.
• 31:43
  SPEAKER_02: Don't be afraid that this is going to take over development jobs.
• 31:47
  SPEAKER_02: This is not.
• 31:48
  SPEAKER_02: This is not Skynet.
• 31:49
  SPEAKER_02: This is not AI that's going to revolutionize the industry.
• 31:54
  SPEAKER_02: We've already had this for years.
• 31:56
  SPEAKER_02: It's just making it a little easier.
• 31:59
  SPEAKER_02: There was a tool back in, I believe it was Visual Studio 2013, maybe even earlier, that it's been a while.
• 32:11
  SPEAKER_02: So it's it's been a while since I've used it.
• 32:14
  SPEAKER_02: But it's a tool where you would um type, there's a plugin, something like that, where you would type in a question and it would bring in the code directly from Stack Overflow answers to that question.
• 32:28
  SPEAKER_02: You know, um, how do I check for an email address in C sharp?
• 32:32
  SPEAKER_02: And it would pop in your code the accepted answer, the code of it.
• 32:37
  SPEAKER_02: And you go, Yep, that looks good, and away you go.
• 32:40
  SPEAKER_02: That's kind of what this is doing, only at a much grander scale, a much uh more in-depth and that kind of thing.
• 32:47
  SPEAKER_02: We've had this kind of stuff for years.
• 32:50
  SPEAKER_02: We still have jobs, there's still a need for developers, um, a great increasing need for developers.
• 32:57
  SPEAKER_02: So this is not gonna take your job.
• 32:59
  SPEAKER_02: Okay, this is not true AI, this is not gonna learn on its own.
• 33:03
  SPEAKER_02: So this is gonna be an interesting tool, something to keep our eye on.
• 33:09
  SPEAKER_02: Just don't get caught up in the hype and believe it's more than it is.
• 33:14
  SPEAKER_02: This will be a nice supporting tool.
• 33:20
  SPEAKER_01: This is not a massive thing.
• 33:24
  SPEAKER_02: This is a nice supporting tool with great marketing.
• 33:28
  SPEAKER_02: That's what it is.
• 33:28
  SPEAKER_02: Okay, so definitely I'm positive towards it.
• 33:31
  SPEAKER_02: I'm positive towards the fact that it's gonna be able to help people and help developers and make our lives a little easier.
• 33:40
  SPEAKER_02: But I am not gonna get caught up in the hype train of thinking it's more than it is or in thinking it's going to uh replace what I do or make my job um somehow redundant.
• 33:51
  SPEAKER_02: Okay, so that's my thoughts on GitHub Copilot.
• 33:54
  SPEAKER_02: Thanks for listening to this week's episode.
• 33:57
  SPEAKER_02: This little bit different episode, but this week's episode of DevQuesti.
• 34:02
  SPEAKER_02: If you have a question about uh development, the first place I recommend you check out is the archive because the archive has a lot of questions.
• 34:11
  SPEAKER_02: I think this is question number 58 or so that I have answered about developers' questions.
• 34:17
  SPEAKER_02: So check out either on YouTube, there's a whole playlist for dev questions, or go to I am Tim Corey and check out the podcast, which are also on iTunes and Spotify, and pretty much wherever you listen to your podcasts.
• 34:31
  SPEAKER_02: If you don't find the question that you're looking for, go ahead and either leave a comment on the YouTube channel or um on I am Tim Corey on the podcast page as a form to fill out to ask your question.
• 34:43
  SPEAKER_02: I'll try to get to it if um it's a question I think will and will be helpful to as many developers as possible.
• 34:49
  SPEAKER_02: But either way, I will at least evaluate it and think through how we can possibly work this in somewhere.
• 34:56
  SPEAKER_02: All right.
• 34:57
  SPEAKER_02: Thanks for listening.
• 34:58
  SPEAKER_02: Have a great day.
• 34:59
  SPEAKER_02: As always, I am Tim Corey.
• 35:01
  SPEAKER_00: Thank you for joining us for this episode of Dev Questions.
• 35:04
  SPEAKER_00: Tim is committed to making it easier for you to become a developer.
• 35:07
  SPEAKER_00: If you would like to help make more content like this possible, please like, subscribe, rate, and share Dev Questions.
• 35:15
  SPEAKER_00: You can also send your questions to questions at Iamtimcorey.com.
• 35:20
  SPEAKER_00: Until next time, remember, you are too smart and your time too valuable to waste it making all the mistakes Tim did.
• 35:27
  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.