Webinars

AI Webinar: Coding with GitHub Copilot

Intrigued by the excitement around GitHub Copilot, often called a programmer's “ultimate ally?” Curious about leveraging generative AI to enhance your programming skills and coding efficiency? Then this webinar is for you! Join us as Eric Greene, a seasoned GitHub Copilot user and educator, discusses the capabilities of GitHub Copilot and guides you on how to use it effectively.

In this engaging 1-hour session, Eric will teach you how to:

Understand the differences between Copilot for Individuals and Copilot for Business.
Identify scenarios where Copilot shines as the ideal solution and recognize when it might not fit best.
Seamlessly integrate Copilot into Visual Studio Code.
Work with Copilot Chat and Code Suggestions to streamline your coding and debugging processes.
Use Copilot as a collaborative partner in programming rather than just a code generator.

At the conclusion, Eric will eagerly take your questions.

Prerequisites: Attendees should have general software programming experience.

About the presenter:

With 27 years of professional experience in computer programming, Eric Greene stands out for his expertise in cloud computing, web development, and IoT programming. He is a seasoned educator, imparting knowledge on various subjects ranging from JavaScript web technologies, C#, and Python to specialized areas like DevOps, Git, and task automation. His repertoire includes programming languages like C and Rust, particularly in real-world applications like web application programming and task automation.

Eric has delivered training sessions to a diverse clientele, including Fortune 500 companies, well-known charities, and global organizations, showcasing his ability to adapt and cater to various learning environments. As a testament to his proficiency and dedication to education, he holds a professional certification in online instruction, is a Microsoft Certified Trainer, and possesses multiple software development certifications. Eric contributes his vast knowledge to Axcel ILT, offering courses on modern tools and technologies, including GitHub Copilot, helping professionals enhance their skills in the evolving landscape of computer programming.

How Eric uses GitHub to improve his daily work as a programmer:

“As a software programmer frequently exploring new libraries and frameworks, I've found GitHub Copilot to be an invaluable resource for learning how to implement applications using new-to-me libraries and frameworks. Its ability to generate contextually specific programming code idiomatically is beneficial.

An example: the first Next.js React TypeScript project with which I used GitHub Copilot. I reached a point where I needed to develop some unit tests, but needed help mocking some third-party libraries I incorporated. This is where GitHub Copilot shined: as I began to draft code for mocking a library, Copilot promptly offered a comprehensive function as a suggestion. Although the suggested code wasn't perfect, it was a solid starting point, enabling me to refine and correct the minor inaccuracies with minimal effort. This guidance from GitHub Copilot was a significant time-saver, sparing me countless hours I would have spent wrestling with the intricacies of library mocking on my own.”

WEBVTT

1
00:00:04.470 --> 00:00:15.939
Axcel ILT: Hi, everybody! Welcome to this Wednesday's webinar. We've got Github co-pilot for you, and I'm here with my colleague, Eric Green. So thank you for being here, Eric, and thank you. Everyone who's joined us today.

2
00:00:18.290 --> 00:00:19.390
Axcel ILT: Sorry about that.

3
00:00:21.840 --> 00:00:23.740
Axcel ILT: All right. Just gonna

4
00:00:24.580 --> 00:00:48.589
Axcel ILT: keep on going here. Okay, just before, just before we start. Just in case you you didn't know. We are now part of excel, ilt instructor led training. So we've got excel, break, exit certified and web age solutions, and we're all under the umbrella of Excel. Ilt. My name is Ann, and before we became part of excel I worked for with excel break for 13 years.

5
00:00:48.690 --> 00:01:00.219
Axcel ILT: And now I get to work with exit certified and web age. And this is great news for you, because we've got a ton of resources now that we all share like instructors like Eric and courseware certifications

6
00:01:00.430 --> 00:01:03.819
Axcel ILT: and everything you can need for a full suite of training

7
00:01:04.451 --> 00:01:28.670
Axcel ILT: and just to tell you a little bit about the nuances among our brands, accelerate focuses on customized courses for teams, exit certified looks at vendor authorized certification courses and web H solutions is more upscaling programs for entire organizations. But it does not matter who you contact, because we're all one company. And we were. Gonna well, we will jump in and get you to the right spot for your training.

8
00:01:29.501 --> 00:01:54.839
Axcel ILT: And speaking of training we do have a Github co-pilot course a full day. So this is really just a snapshot that Eric's gonna give you. So the full day has hands on labs. Plenty of time for QA. With the instructor can be at your site or for teams, and Eric is great at customizing courses, so if you don't want a full day. You can do a half day, and he can incorporate any programming language that you want to use, like Python Java go lang

9
00:01:55.080 --> 00:02:12.519
Axcel ILT: pretty much anything but if you are not part of a team or just one person, and you need an open enrollment course. You are in luck. We are running a full day on April 20 s. Got the URL here. It's a little bit long. So right after I hand it over to Eric, I will put this URL in the chat for you.

10
00:02:13.730 --> 00:02:15.386
Axcel ILT: And speaking of Eric,

11
00:02:15.890 --> 00:02:31.880
Axcel ILT: Just as a personal note, I've had the pleasure of working with Eric. Over on the accelerate side for over 10 years, and if you haven't been in a class with him or experienced a webinar you are in for a treat today. He is such a good presenter, and so great at taking complex

12
00:02:32.170 --> 00:02:37.400
Axcel ILT: topics and breaking them down and making them super understandable. But his knowledge is like

13
00:02:37.660 --> 00:02:39.890
Axcel ILT: almost like no one I've ever.

14
00:02:39.890 --> 00:02:41.179
Eric Greene: All that he's got.

15
00:02:41.180 --> 00:02:54.990
Axcel ILT: Well, okay, sorry. I know I'm gushing. He just has, you know, 27 years of experience. A seasoned instructor definitely over a decade of instructing experience teaches a lot of courses, including

16
00:02:55.290 --> 00:03:18.645
Axcel ILT: our github co-pilot course. And I'm sorry I just have to say this, because it really is. I I think just outstanding that he has a 9 and a half out of 10 average ratings for his emails. And it's you know, over 1,800, with 236 classes under his belt. You know you can't go those those odds on amazon.com right. So

17
00:03:20.112 --> 00:03:23.730
Axcel ILT: alright let me go ahead and

18
00:03:24.568 --> 00:03:27.260
Axcel ILT: stop sharing my screen. And, Eric.

19
00:03:27.870 --> 00:03:32.619
Axcel ILT: you can go oops. Okay, let me see if you can go ahead and share.

20
00:03:32.620 --> 00:03:35.259
Eric Greene: Yep, let me go ahead and click share.

21
00:03:35.640 --> 00:03:37.599
Eric Greene: Can you see my slide deck.

22
00:03:38.192 --> 00:03:40.610
Axcel ILT: Yes, what is go? Github, co-pilot.

23
00:03:40.830 --> 00:03:42.400
Eric Greene: Perfect, perfect.

24
00:03:42.480 --> 00:04:07.119
Eric Greene: Alright! Well, and thank you so much for the very kind introduction. And I've been working together for the last 10 years she is actually the one who got me into training, to begin with. So all the way back in the day when it was just accelerate. But now that we've merged the companies together, we now have the ability to really help customers in so many new kinds of ways.

25
00:04:07.280 --> 00:04:12.609
Eric Greene: and just like there's been a big change with accelerate and the merging of the companies.

26
00:04:12.630 --> 00:04:16.640
Eric Greene: There's also been a big change that's happened in the programming world.

27
00:04:17.010 --> 00:04:23.180
Eric Greene: So, as Ann mentioned. I've been writing software for money, basically for the last 27 years.

28
00:04:23.450 --> 00:04:27.349
Eric Greene: And the last 10 years my focus has really been

29
00:04:27.420 --> 00:04:28.650
Eric Greene: on teaching.

30
00:04:29.180 --> 00:04:34.320
Eric Greene: I've seen a lot of tools, a lot of programming tools, a lot of great programming tools.

31
00:04:36.000 --> 00:04:39.529
Eric Greene: get developed, get released, get used.

32
00:04:40.015 --> 00:04:44.270
Eric Greene: By programmers over over the last almost 30 years now.

33
00:04:44.510 --> 00:04:48.610
Eric Greene: and I have to tell you out of all the tools that I've seen.

34
00:04:49.280 --> 00:04:51.120
Eric Greene: Github co-pilot

35
00:04:51.140 --> 00:04:53.509
Eric Greene: is by far the most amazing.

36
00:04:54.100 --> 00:05:07.260
Eric Greene: It's it's amazing in so many ways. So I got started with co-pilot about 2 years ago. So it was back in July of 2022. So I guess about a year after it was released originally, or at least released in Beta.

37
00:05:07.550 --> 00:05:10.120
Eric Greene: And I remember being on the Github website.

38
00:05:10.370 --> 00:05:16.670
Eric Greene: and there was an offer for like a free trial if I if I signed up for it. And so I did.

39
00:05:16.840 --> 00:05:21.440
Eric Greene: and I installed copilot, and I had used a couple of other tools similar to it

40
00:05:21.540 --> 00:05:31.720
Eric Greene: prior to trying out co-pilot. So I thought it might be helpful. But you know the other tools weren't too great. So I was thinking, you know. Maybe co-pilot wouldn't be too great, either.

41
00:05:32.310 --> 00:05:33.960
Eric Greene: About 2 h

42
00:05:33.980 --> 00:05:37.540
Eric Greene: into working on my first project

43
00:05:37.920 --> 00:05:39.550
Eric Greene: using copilot.

44
00:05:39.910 --> 00:05:43.810
Eric Greene: I had to create a complicated unit test

45
00:05:44.180 --> 00:05:48.120
Eric Greene: for a next Js react application that I was building.

46
00:05:48.470 --> 00:05:56.740
Eric Greene: And I wasn't sure how I was going to mock a certain set of objects in terms of writing this unit test.

47
00:05:57.070 --> 00:06:00.319
Eric Greene: I had installed copilot a couple of hours earlier.

48
00:06:00.650 --> 00:06:05.160
Eric Greene: and as I was starting to code out the unit test.

49
00:06:05.960 --> 00:06:08.090
Eric Greene: 30 lines of code

50
00:06:08.180 --> 00:06:10.880
Eric Greene: instantly appeared on the screen.

51
00:06:11.920 --> 00:06:16.400
Eric Greene: In those 30 lines of code it had all of the code that I needed

52
00:06:16.680 --> 00:06:19.890
Eric Greene: to mock the object that I needed to mock.

53
00:06:20.720 --> 00:06:24.880
Eric Greene: I was amazed. I was sold on copilot at that point

54
00:06:25.170 --> 00:06:31.869
Eric Greene: in all my years of writing software, using code completion and telecense or looking things up on Stack overflow.

55
00:06:31.980 --> 00:06:34.110
Eric Greene: I had never seen a tool

56
00:06:34.490 --> 00:06:37.929
Eric Greene: that could understand the context

57
00:06:38.090 --> 00:06:39.809
Eric Greene: of what I was coding.

58
00:06:40.400 --> 00:06:45.030
Eric Greene: and then give me a suggestion that was nearly perfect

59
00:06:45.290 --> 00:06:47.299
Eric Greene: on how to solve my problem.

60
00:06:47.920 --> 00:06:52.670
Eric Greene: And that's when I realized the programming world was going to be changing.

61
00:06:52.910 --> 00:06:57.850
Eric Greene: Now. At the time I was the only person that I knew who used copilot.

62
00:06:58.070 --> 00:07:03.609
Eric Greene: I tried sharing it with some other developers. They didn't really take too much of a close look at it.

63
00:07:03.950 --> 00:07:06.230
Eric Greene: and then about I don't know. Maybe

64
00:07:06.240 --> 00:07:10.530
Eric Greene: 4, 5 months later, if you all remember, in the fall of 2022,

65
00:07:10.790 --> 00:07:14.219
Eric Greene: that's when Chat Gpt came out. Version 3

66
00:07:14.530 --> 00:07:24.680
Eric Greene: and generative AI Openai Chat Gpt. These became names that everybody in the household knew

67
00:07:24.980 --> 00:07:42.499
Eric Greene: Mom, Dad, the grandparents, the kids. Everybody started to learn about chat. Gpt, generative AI, how you could use it to answer all these questions and solve all these problems that would require previously a a bunch of Google searches and clicking through links. You could go right to chat, Gpt.

68
00:07:42.640 --> 00:07:44.000
Eric Greene: and get your answer.

69
00:07:44.440 --> 00:07:51.200
Eric Greene: It was at about that time that people started to really pay attention to what copilot could do for them.

70
00:07:51.360 --> 00:07:55.750
Eric Greene: because copilot is really just generative. AI

71
00:07:56.070 --> 00:07:57.150
Eric Greene: geared

72
00:07:57.170 --> 00:07:58.320
Eric Greene: for programming.

73
00:07:58.580 --> 00:08:06.739
Eric Greene: So it's kind of like a special use case with a bunch of extra little bells and whistles, a special use case for what the more generalized

74
00:08:07.030 --> 00:08:10.240
Eric Greene: tools like Chat Gpt are able to do.

75
00:08:10.840 --> 00:08:15.479
Eric Greene: And at that point. That's when Copilot started to get the attention

76
00:08:15.830 --> 00:08:18.030
Eric Greene: of the software development industry.

77
00:08:18.250 --> 00:08:24.290
Eric Greene: And, of course, throughout the throughout the year of 2,023, everyone started adopting copilot.

78
00:08:24.340 --> 00:08:30.530
Eric Greene: Microsoft and Github really started promoting copilot, not just to individual users, but

79
00:08:30.550 --> 00:08:34.979
Eric Greene: upgrading it so that it would be appropriate for uses by by businesses.

80
00:08:35.090 --> 00:08:38.899
Eric Greene: Earlier this year they turned on Github copilot enterprise.

81
00:08:39.120 --> 00:08:47.440
Eric Greene: And so now this has become a tool not just utilized by a couple of individual developers who are willing to try a free trial.

82
00:08:47.750 --> 00:08:52.509
Eric Greene: Now, it is something that is basically being deployed throughout the enterprise

83
00:08:53.120 --> 00:09:03.500
Eric Greene: just like text editors 40 years ago started to revolutionize how software development was done. Instead of doing punch cards and stuff like that, you could now code in a text editor

84
00:09:03.580 --> 00:09:09.820
Eric Greene: just like tools like code completion started making the editing experience a lot better back in the nineties.

85
00:09:10.180 --> 00:09:11.430
Eric Greene: Well, now.

86
00:09:12.080 --> 00:09:17.399
Eric Greene: we have Github co-pilot, and it really changes the game in a lot of ways

87
00:09:17.650 --> 00:09:21.919
Eric Greene: as we go through our presentation today, I'll be talking about

88
00:09:22.160 --> 00:09:25.710
Eric Greene: some of the ways in which I think it's going to change the programming world.

89
00:09:25.880 --> 00:09:29.829
Eric Greene: I'll also try to address some of the

90
00:09:30.040 --> 00:09:32.900
Eric Greene: concerns legitimate concerns

91
00:09:32.910 --> 00:09:36.170
Eric Greene: that some programmers, or even businesses, have

92
00:09:36.390 --> 00:09:37.860
Eric Greene: about copilot.

93
00:09:38.000 --> 00:09:39.789
Eric Greene: So as much as I'm going to

94
00:09:39.960 --> 00:09:43.420
Eric Greene: talk about copilot promote the use of copilot.

95
00:09:43.540 --> 00:09:48.259
Eric Greene: I definitely want to talk about the good and the bad of it. So you have a balanced view.

96
00:09:48.290 --> 00:09:51.920
Eric Greene: so you can understand why this is such a great tool, but also

97
00:09:51.940 --> 00:09:56.519
Eric Greene: make sure that you learn how to use it the right way. And that really is the key.

98
00:09:56.630 --> 00:09:59.270
Eric Greene: learning how to use the tool

99
00:09:59.550 --> 00:10:00.709
Eric Greene: the right way.

100
00:10:01.270 --> 00:10:02.970
Eric Greene: So let's start off first.

101
00:10:03.410 --> 00:10:06.519
Eric Greene: Copilot is an AI Pair programmer.

102
00:10:07.540 --> 00:10:11.040
Eric Greene: That statement cannot be overstated.

103
00:10:11.430 --> 00:10:15.719
Eric Greene: One of the biggest mistakes that people make when they start working with copilot

104
00:10:15.900 --> 00:10:19.160
Eric Greene: is they think of copilot as a code generator.

105
00:10:19.530 --> 00:10:21.599
Eric Greene: Please do not think of it that way.

106
00:10:21.850 --> 00:10:24.959
Eric Greene: If you think of copilot as a code generator.

107
00:10:25.030 --> 00:10:30.619
Eric Greene: you're going to end up making a lot of mistakes with it, and miss out on some of the best value

108
00:10:30.810 --> 00:10:32.480
Eric Greene: that it actually offers.

109
00:10:33.010 --> 00:10:35.510
Eric Greene: Yes, copilot does

110
00:10:35.720 --> 00:10:38.369
Eric Greene: generate code as part of using it.

111
00:10:38.830 --> 00:10:43.790
Eric Greene: But the way to look at copilot is similar to the way you would look at pair programming.

112
00:10:44.040 --> 00:10:45.749
Eric Greene: So how does pair programming work?

113
00:10:45.940 --> 00:10:49.400
Eric Greene: You have one computer, one keyboard, one mouse.

114
00:10:50.040 --> 00:10:54.549
Eric Greene: one monitor, but 2 chairs, one for each programmer.

115
00:10:54.900 --> 00:10:58.999
Eric Greene: one programmer's coding, the other one is actively watching

116
00:10:59.170 --> 00:11:00.860
Eric Greene: and contributing along.

117
00:11:01.320 --> 00:11:07.960
Eric Greene: Then, after a while, the 2 programmers switch the other programmer starts coding, and the other one actively contributes.

118
00:11:08.690 --> 00:11:09.960
Eric Greene: The way to think

119
00:11:09.990 --> 00:11:14.379
Eric Greene: of copilot is copilot. Is that AI pair programmer

120
00:11:15.330 --> 00:11:19.559
Eric Greene: that basically comes alongside you and helps you to do your coding.

121
00:11:20.250 --> 00:11:22.579
Eric Greene: just like when you're writing code

122
00:11:22.900 --> 00:11:27.129
Eric Greene: and your pair programming friend would code review what you're coding.

123
00:11:27.250 --> 00:11:31.719
Eric Greene: or when your pair pair programming friend is coding. You would code review what they're coding.

124
00:11:31.990 --> 00:11:34.070
Eric Greene: That's how you work with copilot.

125
00:11:34.380 --> 00:11:40.770
Eric Greene: When copilot generates code. Many times you will be able to accept the suggestion and just use it.

126
00:11:41.070 --> 00:11:45.110
Eric Greene: But many times you'll also have to make some tweaks and modifications to it.

127
00:11:45.490 --> 00:11:50.500
Eric Greene: Also, when you're writing your code, you can use copilot to code, review you

128
00:11:50.600 --> 00:11:57.440
Eric Greene: and offer you suggestions and improvements and ideas on maybe better ways to solve a problem.

129
00:11:57.920 --> 00:12:02.129
Eric Greene: One of the big things that's promoted about copilot is that it makes you faster.

130
00:12:02.540 --> 00:12:11.220
Eric Greene: In some ways it can make you faster. But I don't really think of that as the primary benefit, and, in fact, in some cases it might even slow you down slightly.

131
00:12:11.570 --> 00:12:13.950
Eric Greene: not because it's giving you bad code.

132
00:12:14.040 --> 00:12:17.970
Eric Greene: but because copilot, when used as a pair programmer

133
00:12:18.300 --> 00:12:22.750
Eric Greene: forces you to really look at code, to really think about the code.

134
00:12:22.820 --> 00:12:27.060
Eric Greene: to do code reviews with copilot, to look for better ways, to do things.

135
00:12:27.160 --> 00:12:34.499
Eric Greene: How many of us have gone to stack, overflow before, and copied a bunch of code from Stack overflow, pasted it into a file and ran it.

136
00:12:34.510 --> 00:12:37.340
Eric Greene: But we really couldn't explain what we copied and pasted

137
00:12:37.740 --> 00:12:44.099
Eric Greene: with copilot when it makes a suggestion or offers you a suggestion in response to the code you've already created.

138
00:12:44.230 --> 00:12:49.950
Eric Greene: Copilot can not only make that suggestion, but it can also explain to you what that code does.

139
00:12:50.290 --> 00:12:52.879
Eric Greene: So many times since using copilot.

140
00:12:53.180 --> 00:12:57.650
Eric Greene: The biggest value that I've seen from it was not the actual generation of code.

141
00:12:57.750 --> 00:13:01.010
Eric Greene: but its amazing ability to explain to me

142
00:13:01.340 --> 00:13:04.630
Eric Greene: the code within the context. I'm using it

143
00:13:04.650 --> 00:13:07.590
Eric Greene: something that traditional documentation

144
00:13:07.720 --> 00:13:10.879
Eric Greene: and other tools like Stack overflow just can't do for you.

145
00:13:11.240 --> 00:13:15.000
Eric Greene: And that's one of the reasons why copilot is so transforming.

146
00:13:15.550 --> 00:13:18.479
Eric Greene: Another thing I want to mention, too, about copilot

147
00:13:18.850 --> 00:13:20.390
Eric Greene: is that copilot

148
00:13:20.500 --> 00:13:24.240
Eric Greene: works really well with almost all languages.

149
00:13:24.520 --> 00:13:28.839
Eric Greene: Sure, some of the really old languages that aren't that popular

150
00:13:28.940 --> 00:13:30.819
Eric Greene: copilot's not so great with

151
00:13:31.250 --> 00:13:36.669
Eric Greene: some of the languages or libraries that we're using that literally just released new features

152
00:13:36.690 --> 00:13:40.369
Eric Greene: a lot of times copilot struggles with that until it gets trained on them.

153
00:13:40.710 --> 00:13:45.140
Eric Greene: But for the bulk of the programming that we do, especially in the enterprise space.

154
00:13:45.210 --> 00:13:52.840
Eric Greene: which is definitely somewhere between the really old stuff that nobody uses anymore. And the latest stuff that came out yesterday.

155
00:13:53.230 --> 00:13:56.450
Eric Greene: copilot provides excellent, excellent support.

156
00:13:56.740 --> 00:14:04.340
Eric Greene: And what's really interesting is this, when I teach my co-pilot classes, as Ann mentioned, I will teach it with whatever language you want.

157
00:14:04.350 --> 00:14:09.020
Eric Greene: So if you want to do a Java class, we'll do Java, you want to do. C. Sharp. We'll do C. Sharp.

158
00:14:09.490 --> 00:14:12.130
Eric Greene: but what I'll sometimes do in those classes

159
00:14:12.340 --> 00:14:17.080
Eric Greene: is I'll pick some other language nobody in the class has ever heard of before.

160
00:14:17.300 --> 00:14:21.240
Eric Greene: and I'll repeat the same demonstration in that other language.

161
00:14:21.450 --> 00:14:25.090
Eric Greene: And that's when people really, truly start to realize

162
00:14:25.430 --> 00:14:27.089
Eric Greene: the value of copilot

163
00:14:27.800 --> 00:14:29.120
Eric Greene: in a sense.

164
00:14:29.510 --> 00:14:31.849
Eric Greene: and don't take my example too far.

165
00:14:32.360 --> 00:14:33.860
Eric Greene: But in a sense.

166
00:14:33.950 --> 00:14:39.009
Eric Greene: copilot almost makes the programming language an implementation detail

167
00:14:39.400 --> 00:14:45.910
Eric Greene: that doesn't mean you don't have to know your languages, or know how to properly use them, or be able to adequately code review.

168
00:14:46.010 --> 00:14:53.343
Eric Greene: But what you will find is, instead of identifying yourself as a C sharp developer, or a Java developer, or

169
00:14:53.820 --> 00:14:55.679
Eric Greene: or a python developer.

170
00:14:55.830 --> 00:15:03.970
Eric Greene: What you'll start to realize is when you use copilot properly for both generating code reviewing code and learning code.

171
00:15:04.540 --> 00:15:10.390
Eric Greene: you will be able to jump between different programming languages in ways that you would have never imagined.

172
00:15:10.510 --> 00:15:15.159
Eric Greene: So instead of just being limited to Php, because that's what you happen to know. Now

173
00:15:15.200 --> 00:15:21.339
Eric Greene: you can embrace that project that would be better implemented in Python, or better implemented in C sharp.

174
00:15:21.710 --> 00:15:25.479
Eric Greene: with no, with with with fewer problems and fewer issues.

175
00:15:25.980 --> 00:15:29.540
Eric Greene: So that's really what copilot is

176
00:15:29.770 --> 00:15:35.130
Eric Greene: is it's really starting to elevate natural language, natural human language

177
00:15:35.950 --> 00:15:39.960
Eric Greene: to that almost to the point of being a programming language in and of itself.

178
00:15:40.140 --> 00:15:43.699
Eric Greene: through the various prompts and stuff that we give. Copilot.

179
00:15:44.400 --> 00:15:45.280
Eric Greene: sell

180
00:15:46.400 --> 00:15:47.470
Eric Greene: co-pilot.

181
00:15:48.290 --> 00:15:49.829
Eric Greene: Github provides

182
00:15:50.151 --> 00:15:55.270
Eric Greene: several a couple of extensions that you can install in your editor to make use of it.

183
00:15:55.550 --> 00:16:02.490
Eric Greene: The first thing to know is that copilot is actually a service provided by Github. You must have an active license.

184
00:16:02.590 --> 00:16:09.899
Eric Greene: even if you already have a paid account for accessing code repositories and github actions and stuff like that.

185
00:16:10.150 --> 00:16:12.110
Eric Greene: Copilot itself

186
00:16:12.460 --> 00:16:16.999
Eric Greene: is an additional license fee. On top of that

187
00:16:17.180 --> 00:16:28.260
Eric Greene: you can get an individual license, or if you're part of a larger company, you can get it through Github co-pilot for business. You can get that through the company that you're that you're working for

188
00:16:29.040 --> 00:16:36.990
Eric Greene: in terms of the extensions. There's 2 extensions. There's one that provides the code suggestions, and there's one that provides the copilot chat.

189
00:16:37.070 --> 00:16:40.159
Eric Greene: You might be asking yourself, why are there 2 extensions?

190
00:16:40.350 --> 00:16:43.290
Eric Greene: You have to understand the history of copile it a little bit.

191
00:16:43.420 --> 00:16:54.240
Eric Greene: When Copilot first got started it was just code suggestions. That was the feature set that I first discovered when I first started working with it back in July of 2022.

192
00:16:54.650 --> 00:17:02.459
Eric Greene: But later on, once things like Chat Gpt became super popular and people were using things like Chacht for programming purposes.

193
00:17:02.880 --> 00:17:07.219
Eric Greene: A new feature called copilot chat was added to copilot.

194
00:17:07.530 --> 00:17:11.950
Eric Greene: What's interesting is as awesome as the code suggestions are.

195
00:17:12.020 --> 00:17:13.609
Eric Greene: in my opinion.

196
00:17:13.849 --> 00:17:18.460
Eric Greene: 80% of the value of using copilot is the copilot chat.

197
00:17:18.869 --> 00:17:22.730
Eric Greene: So if you are making use of copilot chat within your company.

198
00:17:22.960 --> 00:17:32.070
Eric Greene: make sure that your Github administrator not only enables copilot, but specifically enables copilot chat because it is technically possible

199
00:17:32.080 --> 00:17:39.380
Eric Greene: to use the code suggestions without the chat feature. But I'm here to tell you all the cool stuff that you hear about copilot.

200
00:17:39.650 --> 00:17:44.229
Eric Greene: 80% of all that cool stuff is all provided by the chat one way or another.

201
00:17:44.250 --> 00:17:46.359
Eric Greene: So you definitely want the chat feature.

202
00:17:46.730 --> 00:17:47.520
Eric Greene: Now.

203
00:17:48.290 --> 00:17:49.470
Eric Greene: copilot

204
00:17:49.850 --> 00:17:59.370
Eric Greene: is an in editor experience. Now there are a couple of couple of things that have been added to it here recently. For example, you can use

205
00:17:59.410 --> 00:18:01.950
Eric Greene: co-pilot with the Github cli.

206
00:18:02.060 --> 00:18:07.309
Eric Greene: If you have an enterprise account with Github, you can use copilot as part of

207
00:18:07.847 --> 00:18:13.280
Eric Greene: doing things like a pull, request, descriptions and other things like that.

208
00:18:13.610 --> 00:18:14.400
Eric Greene: But

209
00:18:15.091 --> 00:18:19.869
Eric Greene: but the the real core feature part of it is the in editor experience.

210
00:18:19.900 --> 00:18:26.490
Eric Greene: People will often ask me, can I incorporate co-pilot into like my my build, pipeline, or something like that?

211
00:18:26.560 --> 00:18:31.360
Eric Greene: The answer is. No, it really is designed to be a pair programmer

212
00:18:31.450 --> 00:18:34.330
Eric Greene: for that in editor programming experience.

213
00:18:34.510 --> 00:18:39.059
Eric Greene: So if you have your copilot subscription, then, which editors are supported

214
00:18:40.250 --> 00:18:55.180
Eric Greene: visual studio code is probably the most commonly used editor in the world. It has supports both the co-pilot suggestions and the copilot chat, and it's the one that I'll be using here the most as we get into the demonstrations here shortly.

215
00:18:55.970 --> 00:19:02.230
Eric Greene: Copilot code suggestions and chat are also supported in regular visual studio.

216
00:19:02.440 --> 00:19:14.420
Eric Greene: They are also supported in the jet brains. Ids. So if you use pie, charm, webstorm, intellig, all of those jet brings, editors, support code suggestions

217
00:19:14.740 --> 00:19:15.870
Eric Greene: and chat

218
00:19:16.540 --> 00:19:20.150
Eric Greene: as well as visual studio code and regular visual studio.

219
00:19:20.780 --> 00:19:24.739
Eric Greene: Now you'll see in my list here. I have neo them listed

220
00:19:25.430 --> 00:19:29.240
Eric Greene: neo vim as well as as your data studio.

221
00:19:29.550 --> 00:19:35.529
Eric Greene: Both support co-pilot code suggestions, but they do not support.

222
00:19:35.650 --> 00:19:38.819
Eric Greene: They do not support the chat feature.

223
00:19:39.290 --> 00:19:51.160
Eric Greene: So if you want the chat, you're limited to regular visual studio Vs. Code and the Jetbrains Ides. If you want code suggestions, you can also use azure data studio as well as Neovamp.

224
00:19:51.530 --> 00:19:54.330
Eric Greene: Now, are there any other editors supporting

225
00:19:55.220 --> 00:19:59.179
Eric Greene: by Github? Officially? No, these are the only ones supported.

226
00:19:59.940 --> 00:20:04.360
Eric Greene: Are there? Third party unofficial extensions that you can use?

227
00:20:04.610 --> 00:20:10.459
Eric Greene: I have found some, for example, one of the groups of people that I do teaching, for

228
00:20:10.620 --> 00:20:12.490
Eric Greene: they like to use emacs.

229
00:20:12.640 --> 00:20:16.749
Eric Greene: So someone asked me, Can I? Can they? Could they use copilot with emacs.

230
00:20:16.890 --> 00:20:21.479
Eric Greene: I did a little searching online, and I found an unofficial plugin

231
00:20:21.650 --> 00:20:26.319
Eric Greene: that allows you to use copilot code suggestions only

232
00:20:26.830 --> 00:20:28.170
Eric Greene: in emacs.

233
00:20:28.380 --> 00:20:37.459
Eric Greene: So if you have another editor that you like to use, it might be worth the time to go look for an unofficial extension to see if you can connect that into copilot.

234
00:20:37.740 --> 00:20:42.720
Eric Greene: To my knowledge there are no unofficial extensions that support chat.

235
00:20:42.980 --> 00:20:48.539
Eric Greene: but there are some unofficial extensions that do support the copal code suggestions.

236
00:20:48.660 --> 00:20:51.557
Eric Greene: And I've seen that myself in terms of

237
00:20:52.140 --> 00:20:56.029
Eric Greene: in terms of setting it up with with emacs. Okay.

238
00:20:56.520 --> 00:20:57.320
Eric Greene: now.

239
00:20:57.600 --> 00:21:01.760
Eric Greene: I'm going to flip over to the Github website here for just a brief moment

240
00:21:03.990 --> 00:21:10.100
Eric Greene: on the Github website. They actually have 2 web pages that talk about the different extensions.

241
00:21:10.500 --> 00:21:13.390
Eric Greene: I'm going to drop these links into the chat.

242
00:21:14.160 --> 00:21:19.770
Eric Greene: This first one covers the code suggestions. You'll see there's the 5 editors that are supported.

243
00:21:21.090 --> 00:21:23.289
Eric Greene: So I'll drop that link into there.

244
00:21:24.390 --> 00:21:26.030
Eric Greene: There is also

245
00:21:26.040 --> 00:21:28.970
Eric Greene: the page that shows you the copilot chat.

246
00:21:28.980 --> 00:21:33.900
Eric Greene: while it's all really just co-pilot. Technically, because of the evolution of the product.

247
00:21:33.960 --> 00:21:38.080
Eric Greene: Copilot chat is treated as a separate kind of thing, a separate feature.

248
00:21:38.550 --> 00:21:41.050
Eric Greene: And I'll drop the link to this in the chat.

249
00:21:45.970 --> 00:21:49.019
Eric Greene: There's the link to that. Okay.

250
00:21:50.560 --> 00:21:52.559
Eric Greene: I think I see a question here about the

251
00:21:52.840 --> 00:21:53.860
Eric Greene: rice.

252
00:21:54.020 --> 00:21:54.715
Eric Greene: So

253
00:21:55.870 --> 00:22:02.279
Eric Greene: I, of course, don't set pricing for Github, but if my memory is correct, I believe it's $10

254
00:22:02.420 --> 00:22:06.430
Eric Greene: a month for the individual license, or maybe a hundred dollars for the year.

255
00:22:06.570 --> 00:22:17.040
Eric Greene: and then for the business license which your employer would pay for. That's $20 a month, and I believe the Enterprise license is $40 a month. So

256
00:22:17.379 --> 00:22:23.800
Eric Greene: if you're just an individual freelance developer, it's I think I paid 100 a year when I first signed up for it.

257
00:22:24.880 --> 00:22:25.740
Eric Greene: Okay.

258
00:22:26.670 --> 00:22:27.990
Eric Greene: all right. So

259
00:22:29.090 --> 00:22:32.310
Eric Greene: one thing I want to mention about these 2 web pages here

260
00:22:32.810 --> 00:22:38.000
Eric Greene: they have the instructions for installing the extension, getting logged in.

261
00:22:38.010 --> 00:22:45.000
Eric Greene: and all the little hot keys and stuff that you can use to interact with the various features of the extensions.

262
00:22:45.250 --> 00:22:52.529
Eric Greene: And the cool thing is with these instructions you can pick your editor, and it gives you the instructions that are specific to that editor

263
00:22:52.880 --> 00:22:57.649
Eric Greene: so definitely take a look at those 2 links. If you want to learn how to install the extension

264
00:22:57.660 --> 00:23:00.950
Eric Greene: into your editor and start making use of it.

265
00:23:01.650 --> 00:23:03.380
Eric Greene: Okay, back over to here.

266
00:23:04.820 --> 00:23:16.680
Eric Greene: So co-pilot, it's powered by generative AI. As you all know, Microsoft owns Github Microsoft made a huge out 10 billion dollar investment in Openai

267
00:23:17.160 --> 00:23:25.710
Eric Greene: so between Microsoft, Openai and Github, they are the 3 companies that work together to provide the copilot service.

268
00:23:25.760 --> 00:23:27.790
Eric Greene: which is, of course, the actual.

269
00:23:27.840 --> 00:23:38.920
Eric Greene: you know, service online. But then all the stuff that it does behind the scenes in terms of the generative AI models and making the code suggestions. And things like that.

270
00:23:39.380 --> 00:23:43.760
Eric Greene: Now, one of the interesting questions people often have about copilot is.

271
00:23:44.100 --> 00:23:46.700
Eric Greene: what about the security

272
00:23:47.350 --> 00:23:48.650
Eric Greene: of our code?

273
00:23:49.360 --> 00:23:57.409
Eric Greene: People are always wondering, you know, if if we have private code repositories in our business, is copilot being trained off of those

274
00:23:57.520 --> 00:23:58.990
Eric Greene: private repos

275
00:23:59.020 --> 00:24:05.420
Eric Greene: when you type into the editor and you send Code up to co-pilot to give you back suggestions.

276
00:24:05.430 --> 00:24:07.729
Eric Greene: What's happening to that code? Right?

277
00:24:07.940 --> 00:24:14.890
Eric Greene: So let's just go ahead and address that question here real quick before we even get into seeing how awesome the tool is.

278
00:24:15.190 --> 00:24:29.969
Eric Greene: So co-pilot, and keep in mind. By the way, I do not work for Github, I am not on the co-pilot programming team. I am not sitting there in the data center watching where all the little bites go back and forth. We're using copilot.

279
00:24:30.090 --> 00:24:37.479
Eric Greene: I am sharing with you what I know from what I've read in Github's documentation, and from what I understand about the product.

280
00:24:37.540 --> 00:24:50.010
Eric Greene: So if there's any area here in which I am incorrect, or an error is simply by accident. Please forgive me. But ultimately all things related to the terms and services and stuff, for from Github

281
00:24:50.030 --> 00:24:53.680
Eric Greene: I'd refer you back to officially, Github, to answer those for you.

282
00:24:53.720 --> 00:24:56.740
Eric Greene: But from my understanding, from what I've read.

283
00:24:57.190 --> 00:24:59.490
Eric Greene: the way this basically works

284
00:24:59.790 --> 00:25:05.029
Eric Greene: is that copilot is only trained on publicly available code

285
00:25:05.350 --> 00:25:08.749
Eric Greene: that would definitely apply to any public

286
00:25:08.910 --> 00:25:10.849
Eric Greene: repositories on Github.

287
00:25:11.080 --> 00:25:17.740
Eric Greene: I'm not sure if they use other public sources they quite possibly could. But it's only trained on public code.

288
00:25:17.820 --> 00:25:24.579
Eric Greene: any private code, any code that's part of your your organization or or business that

289
00:25:24.680 --> 00:25:29.659
Eric Greene: is not included in the training whatsoever. All of that is private.

290
00:25:30.200 --> 00:25:34.760
Eric Greene: Now here's the thing one of the big mistakes that people will make with co-pilot

291
00:25:34.940 --> 00:25:40.529
Eric Greene: is, they think that copilot is like copying and pasting code. That's not the case.

292
00:25:40.860 --> 00:25:42.579
Eric Greene: Copilot goes off.

293
00:25:42.830 --> 00:25:45.740
Eric Greene: learns about programming, so to speak.

294
00:25:45.900 --> 00:25:51.039
Eric Greene: and then makes generative suggestions to you. Right?

295
00:25:51.050 --> 00:25:58.339
Eric Greene: So, for example, I'll often be asked, well, what about plagiarism or license type? Violation stuff like that?

296
00:25:58.750 --> 00:26:00.290
Eric Greene: It's kind of like this.

297
00:26:00.500 --> 00:26:06.380
Eric Greene: If I go off and learn how to do a bunch of programming, and you ask me a question on how to solve a problem.

298
00:26:06.520 --> 00:26:11.650
Eric Greene: and I sit down with your editor. And I'm like, Oh, yeah, just type out some code here to do this.

299
00:26:11.760 --> 00:26:19.070
Eric Greene: How would you know if there was plagiarism or license violations? How would how would you go through my history of programming

300
00:26:19.220 --> 00:26:25.950
Eric Greene: to figure out if I was somehow exactly copying somebody's code or copying their idea? You can't.

301
00:26:26.030 --> 00:26:27.550
Eric Greene: There's no way.

302
00:26:27.780 --> 00:26:32.539
Eric Greene: There's no way to know that I'm just generating the code for you based upon my experience.

303
00:26:32.650 --> 00:26:34.410
Eric Greene: That's how copilot works.

304
00:26:34.590 --> 00:26:42.950
Eric Greene: Copilot learns a lot, but copilots, not copying and pasting code. Copilot is literally generating the code from its training.

305
00:26:43.260 --> 00:26:46.589
Eric Greene: There would be no way to know where that code came from.

306
00:26:46.820 --> 00:26:59.759
Eric Greene: Now it is possible that the code that it generates could match existing public code, just like, if any of us were to write a for loop, our for loop might match some type of public code already in existence.

307
00:26:59.770 --> 00:27:02.280
Eric Greene: Right? There's only so many ways to write a for loop.

308
00:27:02.440 --> 00:27:06.139
Eric Greene: but in terms of copying and paste that doesn't happen

309
00:27:06.620 --> 00:27:09.880
Eric Greene: for people who are using Github for business.

310
00:27:10.200 --> 00:27:14.500
Eric Greene: Github does give you the ability to block code suggestions

311
00:27:14.530 --> 00:27:18.379
Eric Greene: when that suggestion matches existing public code.

312
00:27:18.460 --> 00:27:26.410
Eric Greene: So if the generative AI creates something that just happens to match existing public code, it will block the suggestion.

313
00:27:26.480 --> 00:27:37.629
Eric Greene: But the truth is, if I were to analyze your code base, I'd probably find a fair amount of code that matches public code, not because somebody copied and pasted, but because there's only so many ways to do something.

314
00:27:38.050 --> 00:27:39.789
Eric Greene: so you can turn off

315
00:27:39.850 --> 00:27:43.040
Eric Greene: any suggestions that match public code

316
00:27:43.200 --> 00:27:45.599
Eric Greene: if you want to, with Github for business.

317
00:27:45.950 --> 00:27:54.870
Eric Greene: But you'll also lose a lot of the value of copilot because so much of the code we just type, anyways, is going to match something that exists out in the public space.

318
00:27:55.300 --> 00:27:58.719
Eric Greene: Now, what exactly is actually sent

319
00:27:59.630 --> 00:28:01.040
Eric Greene: up to

320
00:28:01.150 --> 00:28:04.230
Eric Greene: Github servers when you get suggestions back.

321
00:28:04.800 --> 00:28:07.249
Eric Greene: So as you're typing in your editor.

322
00:28:07.660 --> 00:28:08.860
Eric Greene: copilot

323
00:28:09.240 --> 00:28:10.930
Eric Greene: will include

324
00:28:11.760 --> 00:28:13.280
Eric Greene: any code

325
00:28:13.740 --> 00:28:16.809
Eric Greene: that is in the area that you're typing.

326
00:28:17.260 --> 00:28:21.139
Eric Greene: It can include any files that you have opened in your editor.

327
00:28:21.230 --> 00:28:28.730
Eric Greene: It can also include any specific files that you reference, such as when you're chatting, you can say, Oh, reference! This particular file

328
00:28:29.490 --> 00:28:35.259
Eric Greene: copilot will include that in the code that it sends up to the copilot server

329
00:28:35.310 --> 00:28:37.660
Eric Greene: to get your suggestions

330
00:28:38.940 --> 00:28:40.890
Eric Greene: that code that is sent up

331
00:28:41.600 --> 00:28:49.249
Eric Greene: once it is used to formulate a suggestion that code is immediately deleted on Github servers, and it is not retained

332
00:28:50.010 --> 00:28:51.180
Eric Greene: also.

333
00:28:51.190 --> 00:28:54.779
Eric Greene: once the response, the suggestions are sent back to you.

334
00:28:55.030 --> 00:28:59.419
Eric Greene: The suggestions themselves are also immediately

335
00:28:59.700 --> 00:29:00.630
Eric Greene: deleted.

336
00:29:01.460 --> 00:29:07.499
Eric Greene: so Github does not retain any of the code that you send up to generate the suggestions.

337
00:29:07.780 --> 00:29:10.910
Eric Greene: It also does not retain the suggestions either.

338
00:29:11.000 --> 00:29:14.459
Eric Greene: So the question, then, is, What does copilot

339
00:29:14.780 --> 00:29:16.140
Eric Greene: actually keep?

340
00:29:16.740 --> 00:29:20.479
Eric Greene: Well, the copilot service is a service like any other service.

341
00:29:20.950 --> 00:29:24.340
Eric Greene: Github will retain for 24 months

342
00:29:24.520 --> 00:29:26.839
Eric Greene: usage data on the service.

343
00:29:27.010 --> 00:29:29.880
Eric Greene: So what editor are you using.

344
00:29:30.280 --> 00:29:37.139
Eric Greene: what types of, or how many requests are being made? How many suggestions are being sent back as a suggestion being accepted?

345
00:29:37.380 --> 00:29:41.270
Eric Greene: So it's not so much tracking the actual content of the suggestion.

346
00:29:41.480 --> 00:29:43.859
Eric Greene: But was the suggestion accepted

347
00:29:44.680 --> 00:29:54.719
Eric Greene: through this type of interactivity data? Github can measure what editors people are using, so it knows where to invest the time and money on building out extensions

348
00:29:55.390 --> 00:30:01.539
Eric Greene: by knowing whether or not people are accepting the suggestions. It knows whether or not the retraining of the model

349
00:30:01.800 --> 00:30:02.730
Eric Greene: is

350
00:30:03.410 --> 00:30:08.479
Eric Greene: generating more value over the earlier training of the model. So what's so on and so forth.

351
00:30:08.580 --> 00:30:13.009
Eric Greene: So there is some interactivity data, but all of it is pseudo anonymized.

352
00:30:13.180 --> 00:30:17.840
Eric Greene: and none of it has any of the actual code that you either sent up

353
00:30:17.870 --> 00:30:21.719
Eric Greene: or any of the code suggestions that are sent back. Okay?

354
00:30:22.280 --> 00:30:23.260
Eric Greene: All right.

355
00:30:23.530 --> 00:30:24.550
Eric Greene: So

356
00:30:27.060 --> 00:30:38.519
Eric Greene: what is a generative AI model? We kind of use this term all the time. Now, most people probably have a good idea of what it means. But let's just give a quick little definition. Here's this from Nvidia.

357
00:30:38.880 --> 00:30:44.090
Eric Greene: Generative AI enables users to quickly generate new content based on a variety of inputs.

358
00:30:44.290 --> 00:30:49.880
Eric Greene: inputs and outputs of these models can include text images, sounds, animation, 3D models or other types of data.

359
00:30:50.130 --> 00:30:56.960
Eric Greene: Generative AI models use neural networks to identify patterns and structures and then generate new and original content.

360
00:30:57.150 --> 00:31:12.430
Eric Greene: So what I said before about it, not copying and pasting. It's not copying and pasting other people's code. It just learns how to do things, and as we all know, we learn how to do something. If we look at the stuff we start producing, it probably does bear some similarity to the things we were trained on.

361
00:31:15.720 --> 00:31:17.590
Eric Greene: Okay, so

362
00:31:18.070 --> 00:31:20.130
Eric Greene: is github co-pilot.

363
00:31:20.290 --> 00:31:21.180
Eric Greene: Perfect.

364
00:31:21.930 --> 00:31:23.940
Eric Greene: right? What's interesting is

365
00:31:23.980 --> 00:31:32.090
Eric Greene: we accept the fact that human beings are not perfect right? We know that when programmers write code they're going to make mistakes

366
00:31:32.570 --> 00:31:34.979
Eric Greene: when we get a tool like copilot, though

367
00:31:35.430 --> 00:31:46.339
Eric Greene: we ask ourselves the question, is it always going to generate perfect code? Is it always going to generate the best code. Is it always going to do things the most efficient way? Is it always going to follow best practices?

368
00:31:46.630 --> 00:31:57.640
Eric Greene: It's funny we expect co-pilot to do that, but none of us would actually ever be able to code that way. It doesn't matter how experienced you are. You will make mistakes. There will be things you don't know.

369
00:31:57.660 --> 00:32:00.500
Eric Greene: There will be things that change that you're not aware of.

370
00:32:01.120 --> 00:32:06.820
Eric Greene: The thing about copilot is, if you hold it to the standard of perfection. It's never going to achieve that.

371
00:32:07.260 --> 00:32:09.489
Eric Greene: But if you ask yourself.

372
00:32:09.670 --> 00:32:12.200
Eric Greene: does it do a good job overall

373
00:32:12.530 --> 00:32:16.839
Eric Greene: that? Can it do a better job than the actual programmer in many situations.

374
00:32:17.060 --> 00:32:22.510
Eric Greene: when used as a pair of programmer. Can it add value? Could it increase your productivity

375
00:32:22.530 --> 00:32:24.129
Eric Greene: in the code that you're writing.

376
00:32:24.390 --> 00:32:27.180
Eric Greene: and the answers to all of those questions are, yes.

377
00:32:27.840 --> 00:32:34.669
Eric Greene: if you think of copilot as merely a code generator, and you just always accept the code that it suggests.

378
00:32:35.120 --> 00:32:38.480
Eric Greene: and assuming that it's going to be perfect, you're going to be very disappointed.

379
00:32:38.890 --> 00:32:43.380
Eric Greene: But if you use it as a pair of programmer to help you speed up the writing of your code.

380
00:32:43.620 --> 00:32:47.109
Eric Greene: get suggestions on code that might be new to you.

381
00:32:47.220 --> 00:32:50.649
Eric Greene: get some insight on how to solve technical challenges.

382
00:32:50.820 --> 00:32:54.449
Eric Greene: have some explanations on new code. You've never looked at before.

383
00:32:54.650 --> 00:33:00.370
Eric Greene: Fix bugs and improve code, learn new programming languages, even discuss programming concepts.

384
00:33:00.670 --> 00:33:02.150
Eric Greene: Copilot does

385
00:33:02.310 --> 00:33:06.030
Eric Greene: all of these things very, very, very, very well.

386
00:33:06.520 --> 00:33:14.199
Eric Greene: So we don't want to hold copilot to the standard of perfection, because it's just not going to do that generative AI doesn't work that way

387
00:33:14.220 --> 00:33:18.680
Eric Greene: in order for generative AI to be beneficial and understand the context.

388
00:33:18.870 --> 00:33:23.130
Eric Greene: we have to allow for the fact that it's going to make some mistakes. Okay.

389
00:33:23.460 --> 00:33:24.310
Eric Greene: self.

390
00:33:27.750 --> 00:33:35.319
Eric Greene: we're going to actually take a look here at how to use copilot. I'm going to focus most of my time just in Vs code.

391
00:33:35.540 --> 00:33:38.590
Eric Greene: doing some demonstrations and explaining some things.

392
00:33:38.977 --> 00:33:46.170
Eric Greene: I'll also briefly show you visual studio, and jet brings just so you can see that it all looks the same over there, too.

393
00:33:46.552 --> 00:33:53.059
Eric Greene: But I'll fire those up right at the end of the demonstration. But we're going to focus now here on actually using copilot

394
00:33:53.080 --> 00:33:54.649
Eric Greene: in the editor itself.

395
00:33:55.050 --> 00:33:56.869
Eric Greene: So I've got a

396
00:33:57.060 --> 00:33:59.010
Eric Greene: Vs code opened up here.

397
00:33:59.340 --> 00:34:03.039
Eric Greene: and if you come over here you'll see I've got my

398
00:34:04.010 --> 00:34:05.820
Eric Greene: copilot extension

399
00:34:05.850 --> 00:34:07.889
Eric Greene: installed. Okay?

400
00:34:08.870 --> 00:34:12.240
Eric Greene: And over here you can see copilots turned on.

401
00:34:12.360 --> 00:34:14.389
Eric Greene: and I'm also logged into my

402
00:34:14.420 --> 00:34:15.789
Eric Greene: Github account here.

403
00:34:15.880 --> 00:34:22.069
Eric Greene: So you have to have the actual subscription, and you've got to have the extension installed. But once you do, you're good to go

404
00:34:22.510 --> 00:34:29.959
Eric Greene: now out of all the languages that you can use copilot with probably the one that has the absolute best support is python.

405
00:34:30.030 --> 00:34:33.659
Eric Greene: So I thought we would take a look at a couple of examples here of using

406
00:34:34.070 --> 00:34:39.120
Eric Greene: python with copilot, and let's see what it can, what it can do for us. Okay.

407
00:34:39.409 --> 00:34:44.289
Eric Greene: So I figured we'd start over here with the copilot chat. Here's the little chat window.

408
00:34:45.480 --> 00:34:48.940
Eric Greene: and what I'm going to do is I'm going to ask Copilot

409
00:34:49.159 --> 00:34:52.050
Eric Greene: to help me get started with a little python program.

410
00:34:52.440 --> 00:34:54.500
Eric Greene: so I'll come into copilot and say.

411
00:34:54.980 --> 00:34:57.130
Eric Greene: I am working on a new

412
00:34:58.460 --> 00:34:59.820
Eric Greene: python program.

413
00:35:02.080 --> 00:35:04.000
Eric Greene: I need to create

414
00:35:04.050 --> 00:35:05.640
Eric Greene: a console

415
00:35:06.040 --> 00:35:07.000
Eric Greene: based

416
00:35:07.990 --> 00:35:09.630
Eric Greene: python program

417
00:35:10.280 --> 00:35:11.690
Eric Greene: that will

418
00:35:11.800 --> 00:35:13.660
Eric Greene: add 2 numbers

419
00:35:14.370 --> 00:35:15.240
Eric Greene: together.

420
00:35:15.730 --> 00:35:17.279
Eric Greene: I'm just going to talk to it

421
00:35:18.410 --> 00:35:19.810
Eric Greene: and human language.

422
00:35:21.590 --> 00:35:23.150
Eric Greene: we'll see what it comes back with.

423
00:35:28.860 --> 00:35:29.720
Eric Greene: Okay.

424
00:35:30.880 --> 00:35:32.029
Eric Greene: so take a look.

425
00:35:32.880 --> 00:35:37.210
Eric Greene: It's going to suggest to me that I create a function called add 2 numbers.

426
00:35:37.520 --> 00:35:42.040
Eric Greene: And it's going to give me some code here that I can work with. Okay.

427
00:35:42.270 --> 00:35:43.970
Eric Greene: So let's see here

428
00:35:44.000 --> 00:35:50.899
Eric Greene: before I copy and paste and copy and paste that code over. Oh, one other thing I'll mention is notice the explanation

429
00:35:51.020 --> 00:35:56.269
Eric Greene: it actually gives you explanations on the code that it suggests to you which is really really nice.

430
00:35:56.980 --> 00:35:59.599
Eric Greene: But before I copy and paste this over.

431
00:35:59.830 --> 00:36:12.730
Eric Greene: I think I'd like to incorporate python type pins. I teach a lot of python classes, and what's interesting is probably 95% of my students in my python classes have never used python type pins before.

432
00:36:12.880 --> 00:36:18.080
Eric Greene: And then when I start using them in the class, they get confused because they're like, what are these type hip things all about?

433
00:36:18.420 --> 00:36:23.149
Eric Greene: So let's say, I never used type pins before, and I wanted copilot to

434
00:36:23.160 --> 00:36:26.749
Eric Greene: show me how to use them here. No problem. I'm just going to say.

435
00:36:27.320 --> 00:36:30.620
Eric Greene: please update this code to use

436
00:36:30.990 --> 00:36:32.090
Eric Greene: high pens.

437
00:36:38.130 --> 00:36:41.439
Eric Greene: Hey? Take a look at that. Now I've got tight pence that I can work with.

438
00:36:41.790 --> 00:36:44.860
Eric Greene: so we'll go ahead and copy this code. And what's nice is I can

439
00:36:45.060 --> 00:36:48.490
Eric Greene: create a little file over here. We'll say new file. We'll call app

440
00:36:48.570 --> 00:36:49.810
Eric Greene: dot pi.

441
00:36:50.350 --> 00:36:53.704
Eric Greene: Then we'll come over to here, and I'm just gonna simply

442
00:36:54.230 --> 00:36:55.940
Eric Greene: paste that in over here.

443
00:36:56.220 --> 00:36:58.470
Eric Greene: I've got my little python program.

444
00:36:58.950 --> 00:37:02.459
Eric Greene: I'll come into here and say, python app pi.

445
00:37:03.050 --> 00:37:04.809
Eric Greene: and we'll put in our number.

446
00:37:05.160 --> 00:37:06.549
Eric Greene: and there's our sum.

447
00:37:06.840 --> 00:37:15.890
Eric Greene: Now I happen to know just how to fire off the python program. But what if I didn't? Could co-pilot. Help me fire off the python program.

448
00:37:16.340 --> 00:37:17.420
Eric Greene: Sure it could.

449
00:37:17.650 --> 00:37:19.180
Eric Greene: I could come into here.

450
00:37:19.970 --> 00:37:24.150
Eric Greene: and I could use the terminal scope, and I could say.

451
00:37:24.820 --> 00:37:26.260
Eric Greene: Please tell me

452
00:37:26.490 --> 00:37:28.129
Eric Greene: how to run

453
00:37:28.370 --> 00:37:30.690
Eric Greene: my python program.

454
00:37:36.790 --> 00:37:37.530
Eric Greene: Okay?

455
00:37:37.900 --> 00:37:39.210
Eric Greene: So here

456
00:37:39.260 --> 00:37:42.610
Eric Greene: it's going to tell me that. Say, python. And then, whatever my file name.

457
00:37:42.800 --> 00:37:45.839
Eric Greene: here it is. App dot pi. Okay.

458
00:37:46.030 --> 00:37:48.590
Eric Greene: now, what's cool with this is, you can actually

459
00:37:48.900 --> 00:37:51.410
Eric Greene: come into here and insert this into the terminal

460
00:37:51.680 --> 00:37:54.010
Eric Greene: course. I'd have to modify this to say.

461
00:37:54.980 --> 00:37:56.409
Eric Greene: App dot pi.

462
00:37:56.440 --> 00:37:57.909
Eric Greene: and then I have my

463
00:37:58.000 --> 00:37:59.360
Eric Greene: program running there.

464
00:37:59.890 --> 00:38:00.640
Eric Greene: Now.

465
00:38:03.430 --> 00:38:07.719
Eric Greene: that's the coolness of the chat in the actual copilot course.

466
00:38:07.750 --> 00:38:12.000
Eric Greene: we actually build a full blown rest. Api.

467
00:38:12.430 --> 00:38:14.410
Eric Greene: Generally it's a rest. Api.

468
00:38:14.850 --> 00:38:18.580
Eric Greene: in the language of your choice, using copilot chat.

469
00:38:18.880 --> 00:38:23.069
Eric Greene: we assume that you have no knowledge of the language.

470
00:38:23.260 --> 00:38:31.199
Eric Greene: Maybe some basic programming experience, maybe a little bit of rest Api knowledge, but definitely no knowledge of the language or the framework.

471
00:38:31.300 --> 00:38:33.320
Eric Greene: And we actually use copilot

472
00:38:33.410 --> 00:38:37.770
Eric Greene: to build the entire thing from scratch both the copilot chat

473
00:38:37.800 --> 00:38:41.770
Eric Greene: as well as the in editor suggestions. Okay.

474
00:38:41.870 --> 00:38:55.779
Eric Greene: so we're just kind of doing a little small subset of what we do in the actual course. But in the course you'd build out a whole program using copilot every step of the way to explain the language, the frameworks, the concepts, and the ideas, so on and so forth.

475
00:38:56.350 --> 00:38:57.100
Eric Greene: Now.

476
00:38:57.900 --> 00:39:06.270
Eric Greene: let's say, I wanted to enhance this application to support subtraction and and multiplication and division.

477
00:39:06.450 --> 00:39:07.350
Eric Greene: Okay.

478
00:39:07.800 --> 00:39:10.239
Eric Greene: so I already have this file open.

479
00:39:10.670 --> 00:39:12.760
Eric Greene: I could highlight the code.

480
00:39:13.150 --> 00:39:15.540
Eric Greene: I can also come down here

481
00:39:16.220 --> 00:39:19.310
Eric Greene: and put the asterisk or not asterisk a pound sign

482
00:39:19.640 --> 00:39:25.739
Eric Greene: or hashtag and say, file, and I'm going to automatically include file app pi in here

483
00:39:25.950 --> 00:39:27.620
Eric Greene: and I'm going to ask it. This.

484
00:39:28.590 --> 00:39:30.210
Eric Greene: please upgrade

485
00:39:30.620 --> 00:39:31.800
Eric Greene: the code

486
00:39:32.340 --> 00:39:33.953
Eric Greene: to support

487
00:39:35.480 --> 00:39:37.040
Eric Greene: addition.

488
00:39:38.330 --> 00:39:39.780
Eric Greene: subtraction.

489
00:39:41.510 --> 00:39:43.090
Eric Greene: multiplication

490
00:39:43.760 --> 00:39:45.130
Eric Greene: and division.

491
00:39:48.540 --> 00:39:49.859
Eric Greene: The user

492
00:39:50.370 --> 00:39:52.149
Eric Greene: should be prompted

493
00:39:52.920 --> 00:39:54.770
Eric Greene: for the desired

494
00:39:56.550 --> 00:39:58.109
Eric Greene: math operation.

495
00:39:58.710 --> 00:39:59.950
Eric Greene: Also

496
00:40:00.430 --> 00:40:03.740
Eric Greene: allow the user to run multiple

497
00:40:03.760 --> 00:40:05.510
Eric Greene: math operations

498
00:40:07.460 --> 00:40:09.719
Eric Greene: and to exit the program

499
00:40:11.910 --> 00:40:13.160
Eric Greene: they will

500
00:40:13.390 --> 00:40:14.170
Eric Greene: type

501
00:40:15.980 --> 00:40:16.830
Eric Greene: exit.

502
00:40:17.880 --> 00:40:21.550
Eric Greene: Now, before I hit. Enter on this, I want to highlight something to you.

503
00:40:21.950 --> 00:40:23.500
Eric Greene: I've probably taught

504
00:40:23.850 --> 00:40:26.989
Eric Greene: over the last few months, probably around 30

505
00:40:27.230 --> 00:40:33.329
Eric Greene: of these co-pilot classes. It's been a huge, a huge thing that I've been doing a lot of teaching for

506
00:40:33.550 --> 00:40:40.070
Eric Greene: across lots of time, zones at that. So some classes starting at like one o'clock in the morning, and things like that.

507
00:40:40.260 --> 00:40:41.090
Eric Greene: But

508
00:40:42.110 --> 00:40:44.560
Eric Greene: while I've done this many times.

509
00:40:44.600 --> 00:40:49.340
Eric Greene: and while I have the usual set of demos and stuff that I use when I teach

510
00:40:49.870 --> 00:40:58.209
Eric Greene: what I'm doing here for you right now is completely live and unrehearsed other than I have a good knowledge of what copilot can do.

511
00:40:58.970 --> 00:41:04.610
Eric Greene: I'm typing this out and showing you what it can do just by having a normal interaction with it.

512
00:41:04.830 --> 00:41:07.270
Eric Greene: because that's the power of copilot

513
00:41:07.350 --> 00:41:13.080
Eric Greene: copalit isn't something that you have to go off and learn a bunch of complicated things to get up and running with it

514
00:41:13.100 --> 00:41:19.490
Eric Greene: for as powerful and as an amazing as it is, a lot of people over complicate what it is.

515
00:41:19.670 --> 00:41:25.890
Eric Greene: They over, complicate it at the management level, they over complicate it at the developer level. They think it's going to be some

516
00:41:25.950 --> 00:41:30.670
Eric Greene: big thing that has to be like rolled out in stages and stuff like that. And

517
00:41:30.680 --> 00:41:37.280
Eric Greene: and you're going to need, you know, 10 years of training to become an expert at it, or to believe in what it can do for you.

518
00:41:37.430 --> 00:41:38.889
Eric Greene: It doesn't work like that.

519
00:41:39.590 --> 00:41:42.309
Eric Greene: It's intuitive and straightforward

520
00:41:42.610 --> 00:41:50.609
Eric Greene: in the class. What we focus in on is we focus in on a lot of the technical stuff that I explained earlier and some additional things

521
00:41:50.710 --> 00:41:54.190
Eric Greene: we also focus in on, how do you write your prompts?

522
00:41:54.590 --> 00:42:02.889
Eric Greene: How do you interact with copilot? We give you a lot of ideas and suggestions and practical ways of interacting with it through the prompt system.

523
00:42:03.290 --> 00:42:05.640
Eric Greene: But even if you don't know that

524
00:42:05.930 --> 00:42:07.880
Eric Greene: it's so intuitive.

525
00:42:07.900 --> 00:42:13.019
Eric Greene: it's just like talking to another person. So let's hit enter, and let's see what it generates for me.

526
00:42:18.030 --> 00:42:22.000
Eric Greene: Right? You will not get. So I so I'm seeing this in the chat here real quick. Yes.

527
00:42:22.140 --> 00:42:37.960
Eric Greene: you you will get different answers. It's non-deterministic. That's the nature of generative. AI. That's why I tell you it's not copying and pasting. When you interact with co-pilot. It's not like reading an answer from the database. It's kind of like, if you talk to a programmer today for an answer.

528
00:42:37.980 --> 00:42:51.360
Eric Greene: they'd give you or ask a developer today a question. You get one answer. Ask them tomorrow you get something slightly different. Maybe the way you ask the question. Maybe the way you emphasize certain words, maybe conditions in the office have changed.

529
00:42:51.620 --> 00:43:07.629
Eric Greene: And so they give you a slightly different answer. Co. Pilot is very much like that. It gives you very contextually aware answers, which does, which means you don't always get the exact same response back. That's why you still have to have knowledge of programming. You still have to have knowledge of your tooling. You still have to have

530
00:43:07.790 --> 00:43:09.030
Eric Greene: all of that.

531
00:43:09.190 --> 00:43:10.040
Eric Greene: But

532
00:43:10.850 --> 00:43:16.519
Eric Greene: it's able to really help you out with these contextualized responses. Let's take a look at the code that it produced.

533
00:43:18.440 --> 00:43:21.109
Eric Greene: So here I've got my perform operation

534
00:43:22.060 --> 00:43:27.060
Eric Greene: here. I've got my while loop it put all that together for me, so I'm just going to come into here.

535
00:43:27.750 --> 00:43:30.650
Eric Greene: I'll just delete that, and let's kind of throw this in there.

536
00:43:31.410 --> 00:43:32.950
Eric Greene: And now I've got my

537
00:43:33.160 --> 00:43:34.229
Eric Greene: program here.

538
00:43:34.790 --> 00:43:35.580
Eric Greene: Now

539
00:43:35.980 --> 00:43:37.510
Eric Greene: is this code

540
00:43:38.360 --> 00:43:41.119
Eric Greene: the absolute best way to do this?

541
00:43:41.610 --> 00:43:43.210
Eric Greene: Maybe maybe not.

542
00:43:43.440 --> 00:43:45.799
Eric Greene: Is there a more optimized way of doing it?

543
00:43:45.910 --> 00:43:46.920
Eric Greene: Possibly.

544
00:43:47.600 --> 00:43:54.389
Eric Greene: But I want to use this little illustration here to kind of point out something I think is important to consider.

545
00:43:56.210 --> 00:44:01.059
Eric Greene: Imagine you're back in the 1960 S. And you're writing Assembly language code.

546
00:44:01.900 --> 00:44:05.520
Eric Greene: and a programmer comes to you and says, Hey, we have this

547
00:44:05.690 --> 00:44:09.039
Eric Greene: new language called the C. Programming language.

548
00:44:09.360 --> 00:44:11.429
Eric Greene: late 60 s. Early 70 s.

549
00:44:11.600 --> 00:44:12.295
Eric Greene: And

550
00:44:13.460 --> 00:44:16.309
Eric Greene: and we'd like you to use that instead of assembly.

551
00:44:16.830 --> 00:44:20.359
Eric Greene: you know what a lot of those Assembly language programmers probably said.

552
00:44:20.720 --> 00:44:26.829
Eric Greene: well, if I start using CI won't have control over the individual

553
00:44:27.450 --> 00:44:28.720
Eric Greene: processor

554
00:44:28.990 --> 00:44:30.380
Eric Greene: operations.

555
00:44:30.890 --> 00:44:37.549
Eric Greene: And maybe the C. Programming code won't be quite as efficient in the way that it handles functions and other things like that.

556
00:44:37.760 --> 00:44:43.160
Eric Greene: So I don't want to use C, because I lose too much control. I want to keep programming and assembly.

557
00:44:43.720 --> 00:44:56.160
Eric Greene: Now, if I came to any of us and said, please build your next web application in assembly language. Everybody would think that I was crazy for suggesting that, and I would be crazy for suggesting it, because it'd be a lot of assembly code to write.

558
00:44:56.530 --> 00:44:57.980
Eric Greene: But the point is.

559
00:44:58.020 --> 00:45:08.169
Eric Greene: whenever people go from a lower level language to a higher level language, there's always some type of sacrifice you have to make in terms of having control over things.

560
00:45:08.640 --> 00:45:11.009
Eric Greene: Well, just like when you go from C

561
00:45:11.070 --> 00:45:13.890
Eric Greene: up to Java or up to C. Sharp.

562
00:45:14.360 --> 00:45:17.049
Eric Greene: or you go to something like python itself.

563
00:45:17.620 --> 00:45:18.720
Eric Greene: Honestly.

564
00:45:19.000 --> 00:45:22.660
Eric Greene: Python is one of the most inefficient languages out there.

565
00:45:22.880 --> 00:45:26.029
Eric Greene: Really, it's one of the slowest and most inefficient.

566
00:45:26.280 --> 00:45:28.269
Eric Greene: But is that really a problem?

567
00:45:28.430 --> 00:45:34.780
Eric Greene: Not really because people are super productive with it? And paying programmers is the most expensive part of any project.

568
00:45:35.040 --> 00:45:47.610
Eric Greene: Not only that things like I/O operations are always slower, even if python is inefficient, so when a python program is slow, it's very rarely because of the python. It's mostly the I/O operations that are slowing it down.

569
00:45:47.900 --> 00:45:49.330
Eric Greene: But the point is.

570
00:45:49.360 --> 00:45:54.560
Eric Greene: python makes developers be more productive, but they do give up a lot of control

571
00:45:54.690 --> 00:45:58.809
Eric Greene: over the operations being executed on the CPU

572
00:45:59.500 --> 00:46:03.510
Eric Greene: when I come to copilot, and it generates all this code for me in like a minute.

573
00:46:03.890 --> 00:46:08.110
Eric Greene: and people were like, well, you know, it could be a little more efficient. It could be a little bit faster.

574
00:46:08.230 --> 00:46:13.179
Eric Greene: It's kind of like the Assembly language programmer saying, I want to keep programming an assembly instead of C.

575
00:46:13.450 --> 00:46:14.220
Eric Greene: Now.

576
00:46:14.500 --> 00:46:25.389
Eric Greene: if the code is slow, do I have to have the skills and ability to go in there and make it a little faster. Sure I do. Just like many of the early C programmers would do in line, assembly, and stuff like that.

577
00:46:25.830 --> 00:46:30.839
Eric Greene: But in the long term the most expensive part of software is paying people to write it.

578
00:46:31.070 --> 00:46:38.100
Eric Greene: So when we have tools like this that allow us to generate code. That's good, maybe not as perfect as it could be.

579
00:46:38.470 --> 00:46:47.890
Eric Greene: Think about how much more productive we are, how much faster software can get rolled out, and how much better that is for for the companies that we work with and our clients.

580
00:46:48.200 --> 00:46:49.740
Eric Greene: And so, as you can see.

581
00:46:50.070 --> 00:46:55.559
Eric Greene: I generated a fair amount of code here very quickly. Do I still need to code review it absolutely.

582
00:46:55.570 --> 00:47:01.539
Eric Greene: But is it doesn't have to be perfect? No, but you know what the truth be told, even the code that I was going to write probably wasn't perfect.

583
00:47:01.670 --> 00:47:08.739
Eric Greene: So we have to keep all that in mind when measuring our expectations for what copilot can do or not do for us

584
00:47:08.990 --> 00:47:12.920
Eric Greene: real quick. I'm going to come into here and run this. Let's see if it actually works.

585
00:47:13.330 --> 00:47:14.730
Eric Greene: We'll say, add

586
00:47:15.480 --> 00:47:16.810
Eric Greene: 2, 3,

587
00:47:17.020 --> 00:47:18.360
Eric Greene: and then we can do

588
00:47:18.710 --> 00:47:19.560
Eric Greene: exit.

589
00:47:19.880 --> 00:47:20.700
Eric Greene: Now.

590
00:47:22.890 --> 00:47:29.060
Eric Greene: one really neat thing about copilot we can do is I can highlight this code here and watch this

591
00:47:29.980 --> 00:47:31.050
Eric Greene: co-pilot

592
00:47:31.540 --> 00:47:32.920
Eric Greene: generate docs.

593
00:47:35.960 --> 00:47:36.970
Eric Greene: There you go!

594
00:47:37.000 --> 00:47:43.350
Eric Greene: How many of us like to take the time to go through and actually document the code that we're working on. Nobody likes to do that

595
00:47:43.620 --> 00:47:52.829
Eric Greene: with co-pilot, though. You can come in here and start documenting all of your methods. Think about how much more helpful that's going to be to other programmers who have to come in and look at your code.

596
00:47:53.830 --> 00:47:58.549
Eric Greene: What's interesting is in a lot of my python classes. I'll ask my students.

597
00:47:58.690 --> 00:48:03.149
Eric Greene: why do we include this line of code in our python program? Right?

598
00:48:03.870 --> 00:48:07.849
Eric Greene: Most of my students don't know even those who have been using python for years.

599
00:48:08.330 --> 00:48:10.539
Eric Greene: so I'll come in here. I'll right. Click.

600
00:48:10.960 --> 00:48:13.830
Eric Greene: I'll say a copilot. Explain this.

601
00:48:14.790 --> 00:48:17.490
Eric Greene: Let's see what copilot comes back with an answer, for.

602
00:48:18.350 --> 00:48:24.029
Eric Greene: So it's a common python idiom, and checks to see if the script is being run directly, or it's being imported

603
00:48:24.360 --> 00:48:27.079
Eric Greene: as a module. And that's actually the correct answer

604
00:48:27.320 --> 00:48:36.659
Eric Greene: right? So I can go through. And I can get explanations, especially on code that maybe I've used for years, but never really thought about what it does. I've just kind of copied and pasted it right?

605
00:48:36.760 --> 00:48:37.980
Eric Greene: Let's be honest.

606
00:48:38.240 --> 00:48:54.780
Eric Greene: When most of us went off to school, and we got our degrees in computer science and stuff and became software developers. We thought that we'd be implementing all of these really cool algorithms and stuff like that and and discovering all these new things and computer science and writing really awesome software.

607
00:48:55.030 --> 00:48:58.020
Eric Greene: Well, what happens when you get into the average corporate job.

608
00:48:58.310 --> 00:49:17.110
Eric Greene: the average corporate job, you copy and paste code and swap out nouns and verbs. Right? You go to add a new feature to an existing piece of software. You copy a bunch of code that somebody else has already created, and then you make modifications to it to incorporate that new Plugin, or whatever into the software that you're working on.

609
00:49:17.350 --> 00:49:21.680
Eric Greene: How much of that Plugin code. Do you really pay attention to? Do you really know what it's doing?

610
00:49:22.000 --> 00:49:27.970
Eric Greene: A lot of times in my C sharp classes? I'll ask the programmers in the class. Those will be using C sharp for 20 years.

611
00:49:28.110 --> 00:49:31.750
Eric Greene: I'll have them try to explain some of the auto-generated

612
00:49:31.760 --> 00:49:34.670
Eric Greene: project code that visual studio creates for you

613
00:49:34.880 --> 00:49:37.379
Eric Greene: most of the time. They're not really sure what it's doing.

614
00:49:37.630 --> 00:49:41.890
Eric Greene: and that's because when we copy and paste we don't really pay attention.

615
00:49:42.060 --> 00:49:43.060
Eric Greene: Well.

616
00:49:43.580 --> 00:49:47.369
Eric Greene: with copilot, we can go back to that initial code.

617
00:49:47.400 --> 00:49:50.144
Eric Greene: and we can go in there and we can

618
00:49:50.700 --> 00:49:54.080
Eric Greene: and we can have it. Explain to us what that code is doing.

619
00:49:54.110 --> 00:49:58.719
Eric Greene: We can learn what that what that generated code is contributing to the project.

620
00:49:59.030 --> 00:50:01.009
Eric Greene: That's what I mean by copilot.

621
00:50:01.270 --> 00:50:07.220
Eric Greene: It's not just our pair programming AI pair programmer, not just the fact that it generated some code.

622
00:50:07.260 --> 00:50:10.340
Eric Greene: But I have the ability to do discussions and stuff with it.

623
00:50:10.540 --> 00:50:16.549
Eric Greene: Now I'm going to throw in one little one additional little example here of the code suggestions.

624
00:50:17.410 --> 00:50:19.849
Eric Greene: and we'll just call this sample dot pi

625
00:50:22.240 --> 00:50:29.429
Eric Greene: a common demo that you'll see when people want to. Demo demonstrate code suggestions is they'll type in a comment like this.

626
00:50:30.360 --> 00:50:31.010
Eric Greene: Add

627
00:50:31.740 --> 00:50:33.219
Eric Greene: 3 numbers

628
00:50:34.440 --> 00:50:35.340
Eric Greene: together.

629
00:50:35.850 --> 00:50:38.270
Eric Greene: Now, what is copilot going to give back to me?

630
00:50:38.840 --> 00:50:40.789
Eric Greene: I don't. I don't know

631
00:50:40.880 --> 00:50:46.860
Eric Greene: right. It could give me back a bunch of comments. It could give me back some actual code. Usually it gives me back a function like this

632
00:50:47.520 --> 00:50:48.350
Eric Greene: boom.

633
00:50:48.850 --> 00:50:50.380
Eric Greene: But here's the cool thing.

634
00:50:50.830 --> 00:50:55.630
Eric Greene: I'm not limited to just giving it something simple, like adding 3 numbers together.

635
00:50:55.810 --> 00:50:57.639
Eric Greene: I can do something like this.

636
00:50:58.980 --> 00:51:01.420
Eric Greene: Generate a list of

637
00:51:02.410 --> 00:51:03.940
Eric Greene: 100

638
00:51:04.000 --> 00:51:05.990
Eric Greene: random numbers

639
00:51:06.740 --> 00:51:08.030
Eric Greene: between

640
00:51:08.620 --> 00:51:09.859
Eric Greene: one in a thousand.

641
00:51:12.790 --> 00:51:15.019
Eric Greene: Okay, so I have my.

642
00:51:15.060 --> 00:51:18.989
Eric Greene: my my random numbers there, right? But I'm going to change that.

643
00:51:19.200 --> 00:51:20.480
Eric Greene: I'm going to say.

644
00:51:20.670 --> 00:51:22.280
Eric Greene: write a function

645
00:51:22.740 --> 00:51:24.340
Eric Greene: that generates

646
00:51:24.520 --> 00:51:25.560
Eric Greene: a list.

647
00:51:26.330 --> 00:51:29.320
Eric Greene: all right. So now we get into the comment.

648
00:51:29.540 --> 00:51:37.120
Eric Greene: I don't like the fact that it did this during my demo, but I'm kind of glad that it did, because this is an example of sometimes where a copilot can go a little haywire.

649
00:51:37.470 --> 00:51:38.979
Eric Greene: So what I'm going to do

650
00:51:40.090 --> 00:51:41.110
Eric Greene: is

651
00:51:44.100 --> 00:51:52.909
Eric Greene: there we go now I get my function. I think it's when I put write, it interprets the interprets that is generating documentation. So really, I should just say function.

652
00:51:52.980 --> 00:51:57.819
Eric Greene: But anyways, there's my random numbers, you know why it's including the documentation, by the way.

653
00:51:58.020 --> 00:52:05.080
Eric Greene: because I included the documentation over here. So it's picking up on this and including the documentation here because of that.

654
00:52:05.420 --> 00:52:07.219
Eric Greene: But anyways, now, I'm going to do this.

655
00:52:09.490 --> 00:52:10.780
Eric Greene: a function

656
00:52:11.150 --> 00:52:12.780
Eric Greene: that generates

657
00:52:13.720 --> 00:52:15.340
Eric Greene: some descriptive

658
00:52:16.420 --> 00:52:18.710
Eric Greene: statistics for a list of numbers.

659
00:52:21.380 --> 00:52:25.230
Eric Greene: Okay, so there are some basic stats. But it doesn't have everything that I want.

660
00:52:25.720 --> 00:52:27.780
Eric Greene: What if I want to have on here.

661
00:52:28.410 --> 00:52:29.790
Eric Greene: including

662
00:52:30.300 --> 00:52:31.960
Eric Greene: the population

663
00:52:33.120 --> 00:52:34.380
Eric Greene: variance?

664
00:52:36.190 --> 00:52:39.259
Eric Greene: So I'll just delete this and let it recreate it for me.

665
00:52:48.920 --> 00:52:50.100
Eric Greene: Alright! There you go!

666
00:52:50.260 --> 00:52:56.239
Eric Greene: So it generates the population variance some languages that I work with. It actually does all the math calculations.

667
00:52:56.340 --> 00:53:04.640
Eric Greene: and it'll actually give me the population variance versus the sample variance and stuff like that, with the degrees of freedom being handled a little bit differently.

668
00:53:05.040 --> 00:53:10.060
Eric Greene: But you can see it can generate a lot of code here for you, and it actually knows what descriptive stats are

669
00:53:10.380 --> 00:53:11.560
Eric Greene: pretty cool. Right?

670
00:53:11.830 --> 00:53:13.100
Eric Greene: So anyways.

671
00:53:13.210 --> 00:53:19.800
Eric Greene: you can use the code suggestion tool. And when you're typically just coding things out like, if, for example, if I came down to here

672
00:53:20.960 --> 00:53:22.416
Eric Greene: and I just said

673
00:53:24.300 --> 00:53:26.310
Eric Greene: name, look at that.

674
00:53:27.150 --> 00:53:37.829
Eric Greene: It gives me a bunch of code, and then I can go in and tweak it. Now, if you just start hitting Tab and just accepting all the suggestions and not reading it. That's a bad thing to do. That's just like copying and pasting from stack, overflow and running it.

675
00:53:38.070 --> 00:53:43.110
Eric Greene: You do need to code review what's being what's being generated as you're working with it.

676
00:53:43.280 --> 00:53:51.840
Eric Greene: The last little demo I'm going to do here for you, and then we'll quickly open up visual studio and pie charm, so you can see what it looks like being installed. There

677
00:53:51.980 --> 00:53:55.900
Eric Greene: is. I want to come back over to our app pi and our chat window.

678
00:53:56.310 --> 00:53:58.799
Eric Greene: I want to show you something very interesting here.

679
00:53:59.340 --> 00:54:01.090
Eric Greene: So I'm going to

680
00:54:02.270 --> 00:54:05.300
Eric Greene: include my file at Pi.

681
00:54:06.000 --> 00:54:08.180
Eric Greene: Please write this program

682
00:54:09.690 --> 00:54:13.440
Eric Greene: in Javascript with Node. Js.

683
00:54:26.660 --> 00:54:27.820
Eric Greene: pretty cool. Right?

684
00:54:32.840 --> 00:54:33.650
Eric Greene: Okay.

685
00:54:39.020 --> 00:54:40.960
Eric Greene: please write this program

686
00:54:44.510 --> 00:54:46.180
Eric Greene: in the rust language.

687
00:54:47.480 --> 00:54:49.419
Eric Greene: And what you're going to find here

688
00:54:49.640 --> 00:54:52.780
Eric Greene: is that you still need to know the languages you're working with.

689
00:54:53.210 --> 00:54:54.759
Eric Greene: But the language is

690
00:54:55.990 --> 00:55:00.720
Eric Greene: in in a real, in a very real way, start to become an implementation detail.

691
00:55:01.700 --> 00:55:06.920
Eric Greene: Think about when you write a program with.net and you can run it on windows. Mac and Linux.

692
00:55:07.080 --> 00:55:18.290
Eric Greene: right? That's different operating systems. You can even run it on different chip architectures. Do you worry about the details of the operating system or the chip architecture? No, those are implementation details handled by the.net runtime.

693
00:55:18.610 --> 00:55:21.790
Eric Greene: Here I'm allowing the copilot runtime, so to speak.

694
00:55:22.150 --> 00:55:25.510
Eric Greene: to handle the creation of this program in any language that I want.

695
00:55:25.850 --> 00:55:27.660
Eric Greene: and we'll do one last one. Here

696
00:55:28.330 --> 00:55:29.990
Eric Greene: we'll say a file.

697
00:55:34.220 --> 00:55:35.890
Eric Greene: and then let's do.

698
00:55:36.350 --> 00:55:39.539
Eric Greene: Please write this program in

699
00:55:39.840 --> 00:55:42.680
Eric Greene: Haskell Haskell is a

700
00:55:42.880 --> 00:55:47.020
Eric Greene: functional programming language that's notoriously hard to work with.

701
00:55:47.240 --> 00:55:51.030
Eric Greene: Some people really love it and think it's super cool. But it's a pretty tough language to work with.

702
00:55:51.410 --> 00:55:53.530
Eric Greene: It's very different in how it works.

703
00:55:53.790 --> 00:55:55.480
Eric Greene: And we've just produced this

704
00:55:55.630 --> 00:55:56.710
Eric Greene: in Haskell.

705
00:55:57.470 --> 00:56:19.549
Eric Greene: So anyways, the reason I mention all this is to say you're gonna start to look at programming languages, not as unnecessary, because different languages have different features that that that, you know, solve certain problems in terms of actually executing code. Some programs are great for concurrent execution. Some programs have to be written in Javascript, if you want to run it in the browser, so on and so forth.

706
00:56:19.780 --> 00:56:22.110
Eric Greene: So it's not that programming languages go away.

707
00:56:22.180 --> 00:56:26.950
Eric Greene: But you do start to see the beginning here of how they could start to become an implementation detail

708
00:56:26.980 --> 00:56:29.290
Eric Greene: kind of like we don't really worry about

709
00:56:29.380 --> 00:56:32.920
Eric Greene: and and an x 8, 6 processor versus

710
00:56:33.070 --> 00:56:44.700
Eric Greene: an arm processor for standard business programming. Now, if you're a device driver writer stuff like that, that's a different story. But if you're just building business applications, we don't really think about those types of details.

711
00:56:45.170 --> 00:56:46.040
Eric Greene: Okay.

712
00:56:46.360 --> 00:56:52.912
Eric Greene: before I open it up to questions here or go through and look at the questions we've been getting. Let me

713
00:56:53.740 --> 00:56:55.830
Eric Greene: open up visual studio here.

714
00:56:55.860 --> 00:56:59.180
Eric Greene: I'm not actually going to code anything. I just want to show you

715
00:56:59.290 --> 00:57:03.989
Eric Greene: what it looks like to have copilot in here. So you know, it basically looks exactly the same.

716
00:57:04.210 --> 00:57:11.579
Eric Greene: That's one thing that's kind of nice about this is, it doesn't really matter whether it's jet brings Bs code or visual studio.

717
00:57:11.700 --> 00:57:14.899
Eric Greene: There's the copilot interaction right there.

718
00:57:15.030 --> 00:57:17.940
Eric Greene: and copilot itself is actually installed

719
00:57:18.230 --> 00:57:21.870
Eric Greene: as a as an extension. So there's the copilot chat.

720
00:57:22.030 --> 00:57:23.559
Eric Greene: and there's copilot.

721
00:57:23.990 --> 00:57:27.058
Eric Greene: The same thing is also true for working with

722
00:57:27.990 --> 00:57:29.190
Eric Greene: pie charm.

723
00:57:29.390 --> 00:57:39.319
Eric Greene: So if I open up pie. Charm here. Now, one thing with jet brings in jet brings. There's only one plugin you have to install to get both the copilot and the copilot chat.

724
00:57:39.902 --> 00:57:45.379
Eric Greene: The other 2. You have to install 2 extensions, but with pie charm there's only one extension

725
00:57:45.730 --> 00:57:51.220
Eric Greene: and we'll just say, create a new project here, and I'll just say, create.

726
00:57:52.940 --> 00:57:56.120
Eric Greene: And if you go over here, see the little copilot icon.

727
00:57:57.940 --> 00:58:00.800
Eric Greene: If you click on this, it's the same copilot chat

728
00:58:01.560 --> 00:58:02.840
Eric Greene: as we had before.

729
00:58:02.900 --> 00:58:07.909
Eric Greene: So the Ui interface is exactly the same, regardless of which, editor, that you use.

730
00:58:08.170 --> 00:58:25.270
Eric Greene: What are some other features you can use with it that we didn't talk about here. You can generate unit tests. You can have it solve coding problems. It can detect static problems as well as potential problems that would occur at Runtime, not because it runs the code, but it recognizes the patterns that lead to those problems at Runtime.

731
00:58:25.430 --> 00:58:27.930
Eric Greene: And like. I said. It works with just about any

732
00:58:27.980 --> 00:58:37.050
Eric Greene: any language that you're going to want to use. I teach classes with it for python. Go lang Java, C. Sharp

733
00:58:37.200 --> 00:58:39.480
Eric Greene: Javascript type script.

734
00:58:39.630 --> 00:58:48.359
Eric Greene: Am I an expert at all of those languages? No, but I don't have to be, because co-pilot enables me to write the code in those languages.

735
00:58:48.500 --> 00:58:52.499
Eric Greene: I've had some classes where we've just picked a language out of the blue that nobody knows.

736
00:58:52.530 --> 00:58:55.000
Eric Greene: And we've written the same program with it.

737
00:58:55.090 --> 00:59:02.930
Eric Greene: Does it mean? It's ready to go to production? No, you need somebody who probably knows the language to review it. But it's amazing what you can do with co-pilot.

738
00:59:03.100 --> 00:59:07.250
Eric Greene: All right, let me go ahead and take a quick look here, some of the questions that we've received

739
00:59:07.260 --> 00:59:11.429
Eric Greene: and and I'll do my best to answer all of them.

740
00:59:11.750 --> 00:59:21.239
Eric Greene: So co-pilot for business. Yeah, your code remains within your organization, like your code, goes up for a few moments to co-pilot to get the suggestions. But

741
00:59:21.270 --> 00:59:30.939
Eric Greene: but Co. Github is not taking your organization's code. It's not training off of it. It's not giving it to anybody else. It's not making suggestions to other people with it. Okay.

742
00:59:31.750 --> 00:59:35.310
Eric Greene: all right. Let's see here, high level interaction.

743
00:59:36.430 --> 00:59:50.729
Eric Greene: Right? So I'm not. I'm not familiar with all the details of how copilot is actually implemented up in the cloud and how it gets trained and how it integrates with open AI. I just know that it's using their their learning models

744
00:59:50.790 --> 00:59:53.700
Eric Greene: to to provide the suggestions to us.

745
00:59:54.370 --> 00:59:55.870
Eric Greene: Let's see here.

746
00:59:58.900 --> 01:00:00.740
Eric Greene: Okay, so

747
01:00:00.960 --> 01:00:03.470
Eric Greene: let me talk about this question here

748
01:00:03.720 --> 01:00:06.190
Eric Greene: about about junior developers.

749
01:00:07.330 --> 01:00:14.919
Eric Greene: So this is like the number one concern that that people have concerning using things like copilot

750
01:00:14.950 --> 01:00:17.320
Eric Greene: is, what about junior developers?

751
01:00:17.710 --> 01:00:19.629
Eric Greene: So I have a couple of thoughts on that

752
01:00:20.330 --> 01:00:21.479
Eric Greene: number one.

753
01:00:22.070 --> 01:00:24.919
Eric Greene: I've worked with a lot of senior developers

754
01:00:25.060 --> 01:00:26.020
Eric Greene: who

755
01:00:26.320 --> 01:00:33.460
Eric Greene: don't know the language as well as they should a lot of times. They don't even know the latest features of the language.

756
01:00:33.500 --> 01:00:35.410
Eric Greene: So maybe they learn Java

757
01:00:35.490 --> 01:00:37.309
Eric Greene: 1015 years ago.

758
01:00:37.380 --> 01:00:39.539
Eric Greene: And when you read their code today.

759
01:00:41.010 --> 01:00:45.799
Eric Greene: it's the same code. They wrote 15 years ago, and they haven't learned any of the new features.

760
01:00:46.110 --> 01:00:48.220
Eric Greene: So I think the struggle

761
01:00:48.330 --> 01:00:49.270
Eric Greene: of

762
01:00:50.260 --> 01:00:53.549
Eric Greene: Do I understand what copilot is creating?

763
01:00:53.670 --> 01:00:57.879
Eric Greene: I think that's a problem that plagues all developers, not just

764
01:00:57.980 --> 01:01:06.040
Eric Greene: the junior developers or the senior developers. A lot of times the junior developers will be more aware of the newer features, because that's what they started learning

765
01:01:06.190 --> 01:01:11.020
Eric Greene: as opposed to the senior developers who might be coding things kind of kind of the old way.

766
01:01:11.400 --> 01:01:15.710
Eric Greene: as I mentioned to you. I've been writing code professionally for 27 years.

767
01:01:16.550 --> 01:01:24.320
Eric Greene: When I have used copilot to code, review my code like, I'll write some code and ask copilot. Is there a better way to write this?

768
01:01:24.600 --> 01:01:33.150
Eric Greene: I have been surprised at times that some of the suggestions that it made to me, and those suggestions were actually better than the way I wrote it.

769
01:01:33.640 --> 01:01:36.870
Eric Greene: and I could have sworn the way I wrote. It was the best way to do it.

770
01:01:37.010 --> 01:01:41.000
Eric Greene: So all of us have room for improvement. If you use copilot

771
01:01:41.110 --> 01:01:42.540
Eric Greene: as a

772
01:01:42.930 --> 01:01:52.840
Eric Greene: as a pair programmer, and you ask it to review your code and and and and you review the code that it creates for you, and you discuss the code being created.

773
01:01:53.010 --> 01:01:55.750
Eric Greene: you'll have a lot less likely chance

774
01:01:55.930 --> 01:01:57.780
Eric Greene: of of

775
01:01:58.060 --> 01:02:01.589
Eric Greene: incorporating code. That's bad code. Okay?

776
01:02:01.680 --> 01:02:25.089
Eric Greene: But the key is, the programmer has to take the time to interact with co-pilot to go over it and make sure they understand it. You have the same problem with Stack Overflow. It's just with stack overflow. You have to go through a Google search first, copy paste before you run into the problem with co-pilot. It just, you know, puts the code right in the editor. So if you just hit and tab like, as I mentioned before. You can't think of it really as just a code generator.

777
01:02:26.220 --> 01:02:27.330
Eric Greene: All right.

778
01:02:29.043 --> 01:02:30.389
Eric Greene: Let's see.

779
01:02:31.400 --> 01:02:49.169
Eric Greene: So in terms of in terms of co-pilot, it's receiving the code from your editor in terms of how it's processing that code. I'm not familiar with that. I don't. I don't create the large language models. AI in terms of creating AI learning models. That's not my my specialty.

780
01:02:49.526 --> 01:02:56.980
Eric Greene: I just use the tool. And so it sends your code up. It does the processing that it does and gives you back the code suggestions

781
01:02:59.250 --> 01:03:04.010
Eric Greene: overall efficiency by adopting copilot. This is really hard to measure.

782
01:03:04.678 --> 01:03:09.210
Eric Greene: You know, copilot or Github and Microsoft. They have their numbers and stuff.

783
01:03:09.525 --> 01:03:16.404
Eric Greene: And if you go to the Github site it'll say, Oh, it, you know, makes everybody 50 more efficient. But how do you measure that? I had a

784
01:03:16.930 --> 01:03:18.769
Eric Greene: a customer of mine say.

785
01:03:18.930 --> 01:03:25.369
Eric Greene: well, we have access to some secret Apis that will tell us how many suggestions people are really accepting.

786
01:03:25.710 --> 01:03:28.080
Eric Greene: And I said, though, but what does that really tell you?

787
01:03:28.410 --> 01:03:37.969
Eric Greene: I could accept a suggestion because it's 50 correct. And I'm gonna modify it. That doesn't mean the suggestion was correct. It just means that I was gonna have to go in and tweak it.

788
01:03:38.070 --> 01:03:40.960
Eric Greene: I could accept the whole suggestion, and it could be wrong.

789
01:03:41.320 --> 01:03:44.690
Eric Greene: I could see the suggestion, choose not to accept it.

790
01:03:44.990 --> 01:03:48.899
Eric Greene: be inspired by what I saw for a moment, and then write my own solution.

791
01:03:49.130 --> 01:04:00.079
Eric Greene: How do you measure if it's making you more efficient or not in terms of speed? That's a really hard thing to answer, and I'll be honest with you as a developer from just giving you my opinion.

792
01:04:00.350 --> 01:04:04.480
Eric Greene: I don't think of co-pilot in terms of making me faster in terms of speed.

793
01:04:04.540 --> 01:04:06.970
Eric Greene: I think of copilot in terms of

794
01:04:07.110 --> 01:04:15.580
Eric Greene: helping me to learn more and teach me more, and and give me more information about things that I did not realize I did not have.

795
01:04:15.990 --> 01:04:16.730
Eric Greene: Now

796
01:04:17.000 --> 01:04:23.299
Eric Greene: does it make me faster sometimes? Sure if it writes a bunch of code and it looks good, and I accept it. Yeah, I didn't have to type all that out.

797
01:04:23.490 --> 01:04:28.580
Eric Greene: But if I really go back and code review it, and I see something novel that I've never tried before.

798
01:04:28.690 --> 01:04:35.090
Eric Greene: Then if I'm using copilot correctly, I'm going to interact with copilot to understand better the code that it created.

799
01:04:36.670 --> 01:04:37.580
Eric Greene: Okay.

800
01:04:38.322 --> 01:04:41.699
Eric Greene: in terms of clearing the context with copilot.

801
01:04:41.790 --> 01:04:44.230
Eric Greene: If you want to do like a new chat.

802
01:04:44.380 --> 01:04:45.769
Eric Greene: you can click this

803
01:04:45.920 --> 01:04:48.359
Eric Greene: if you close all of your open files.

804
01:04:48.570 --> 01:05:05.650
Eric Greene: It should be a new session. I can't guarantee you that it is, but it should be a new session. You, of course, can always reload visual studio code, whatever, and that will also kind of reinitialize things. But you've got the files closed, and you've got your your new chat there. You should be in a new session.

805
01:05:07.068 --> 01:05:16.630
Eric Greene: In terms of training co-pilot. You can't really do that. There are some newer things at the Enterprise level with Code Pilot, where you can create knowledge bases and even

806
01:05:16.700 --> 01:05:20.369
Eric Greene: have it like, understand your whole code repository.

807
01:05:20.430 --> 01:05:33.380
Eric Greene: But from just a developer perspective working in your editor, you don't really train it to do anything. It just uses the immediate context of the files. You have open the code that you're editing, and any files that you specifically reference.

808
01:05:33.520 --> 01:05:34.440
Eric Greene: and

809
01:05:34.610 --> 01:05:35.950
Eric Greene: it gives you.

810
01:05:36.010 --> 01:05:39.209
Eric Greene: It gives you the results based upon that. Okay.

811
01:05:40.140 --> 01:05:45.559
Eric Greene: all right. What are the total savings productivity? You can't you like? I said. You can't really measure

812
01:05:45.970 --> 01:05:48.650
Eric Greene: total savings and productivity. I will tell you this.

813
01:05:51.380 --> 01:05:58.099
Eric Greene: I have not personally met any programmer who has used copilot, who came back and said it slowed them down.

814
01:05:58.610 --> 01:06:06.980
Eric Greene: or that it wasn't worth the investment. Now, if you go searching online, go to Youtube, you can find a few youtubers out there who will

815
01:06:07.230 --> 01:06:13.230
Eric Greene: talk about how they stopped using copilot. They also stopped using the cloud. They only use them.

816
01:06:13.697 --> 01:06:22.550
Eric Greene: They don't use any other public services, and they've disconnected from everything. And now they're much happier doing that. You will find people from with that perspective.

817
01:06:22.620 --> 01:06:28.140
Eric Greene: But except for those those people who are just really not going to use any type of service.

818
01:06:28.160 --> 01:06:32.130
Eric Greene: Most everybody that you that you come across online

819
01:06:32.160 --> 01:06:38.479
Eric Greene: youtubers talking about copilot, other programmers who are using it. Everybody finds it's beneficial.

820
01:06:38.570 --> 01:06:45.459
Eric Greene: Now, does everybody find it beneficial to the degree that Microsoft or Github might promote the stats?

821
01:06:45.650 --> 01:06:46.930
Eric Greene: Probably not.

822
01:06:47.020 --> 01:06:51.619
Eric Greene: Do people find it beneficial in different ways. Like for me, the big thing is about learning stuff.

823
01:06:51.830 --> 01:06:57.110
Eric Greene: For me. It's not the code generation. It's the ability to learn and go deeper and work in new languages

824
01:06:57.270 --> 01:06:59.879
Eric Greene: for other people. If they just don't want to type.

825
01:07:00.160 --> 01:07:02.829
Eric Greene: the cogeneration might be the big thing for them.

826
01:07:03.090 --> 01:07:06.719
Eric Greene: But I find the co-pilot, as simple as it is.

827
01:07:07.880 --> 01:07:08.940
Eric Greene: is.

828
01:07:08.980 --> 01:07:17.640
Eric Greene: is so amazing. And how the generative AI works. You get to work with your AI pair programmer in the way that's most comfortable for you.

829
01:07:17.770 --> 01:07:18.550
Eric Greene: Okay.

830
01:07:19.440 --> 01:07:20.520
Eric Greene: all right.

831
01:07:23.820 --> 01:07:25.050
Eric Greene: let me

832
01:07:26.050 --> 01:07:31.460
Eric Greene: check the chat here for any questions. We have the the chat and the Q. And a. Give me a second here.

833
01:07:33.470 --> 01:07:34.670
Eric Greene: All right.

834
01:07:38.990 --> 01:07:39.900
Eric Greene: Okay.

835
01:07:40.180 --> 01:07:43.730
Eric Greene: so I'm probably not going to be able to get to

836
01:07:43.850 --> 01:07:45.370
Eric Greene: all of these.

837
01:07:45.660 --> 01:07:48.560
Eric Greene: But let me let me take a quick look here, real quick.

838
01:07:50.650 --> 01:07:56.829
Eric Greene: yes, you can use copilot to learn how to create python packages. I actually had to do that.

839
01:07:57.030 --> 01:08:04.380
Eric Greene: So I teach python classes. But, as you know, you can do pi pi packages, you can do conda packages things like that.

840
01:08:04.730 --> 01:08:09.550
Eric Greene: I had a class that I taught where we did a bunch of python.

841
01:08:09.570 --> 01:08:12.119
Eric Greene: see extensions for python.

842
01:08:12.180 --> 01:08:16.659
Eric Greene: and we needed to package them up with the various package management mechanisms.

843
01:08:16.890 --> 01:08:26.310
Eric Greene: And if you've ever gone online and tried to look up how to do that. You'll find all these different versions and variations of how to do packaging stuff in Python

844
01:08:27.000 --> 01:08:29.739
Eric Greene: as part of that course that I was creating.

845
01:08:30.580 --> 01:08:34.410
Eric Greene: To put all the instructions together in the courseware.

846
01:08:34.540 --> 01:08:42.850
Eric Greene: I found that Copilot was extremely helpful for anything related to Python C. Programming python.

847
01:08:42.970 --> 01:08:49.399
Eric Greene: as well as the various packaging mechanisms, make file configuration stuff like that.

848
01:08:49.649 --> 01:09:03.129
Eric Greene: Co-pilot has excellent excellent support for that, and if you want to ask it questions like, what is an egg? What's a wheel stuff like that for python packaging? It does a really great job in giving explanations on that. Okay.

849
01:09:03.510 --> 01:09:10.730
Eric Greene: copilot knows about any framework. So the person here is asking about fast Api copilot knows about any framework.

850
01:09:10.930 --> 01:09:12.920
Eric Greene: If I came into here and said.

851
01:09:13.710 --> 01:09:15.240
Eric Greene: Please create

852
01:09:15.430 --> 01:09:16.479
Eric Greene: a

853
01:09:16.950 --> 01:09:19.479
Eric Greene: simple python.

854
01:09:19.529 --> 01:09:21.270
Eric Greene: Fast Api

855
01:09:21.630 --> 01:09:23.990
Eric Greene: application for me.

856
01:09:27.590 --> 01:09:29.099
Eric Greene: And you could pick anything

857
01:09:29.590 --> 01:09:30.939
Eric Greene: you could say.

858
01:09:31.240 --> 01:09:32.740
Eric Greene: Please create

859
01:09:33.720 --> 01:09:36.020
Eric Greene: a rust

860
01:09:37.250 --> 01:09:38.750
Eric Greene: tactics, web

861
01:09:38.960 --> 01:09:40.460
Eric Greene: rest. Api.

862
01:09:45.189 --> 01:09:50.780
Eric Greene: It doesn't matter, because, remember, it's trained on all the public codes. So as long as people are using a framework or whatever

863
01:09:50.930 --> 01:09:53.089
Eric Greene: it can generate it. Okay.

864
01:09:53.660 --> 01:10:03.039
Eric Greene: alright. Now, the reason why I use the word, please. And I actually have really cut back. I used to be a lot more conversational with my Para programmer.

865
01:10:03.230 --> 01:10:10.450
Eric Greene: but the reason why I I use, please is I try to think of my pair programmer as a fellow programmer.

866
01:10:10.540 --> 01:10:15.670
Eric Greene: Right? So I try to be nice to it and treat it with respect, and people laugh when I tell them that.

867
01:10:15.740 --> 01:10:27.409
Eric Greene: But the way that I work with it is, I don't want to think of it as just some code generator. I want to think of it as a pair programmer, and so part of that is conditioning my conditioning myself mentally

868
01:10:27.930 --> 01:10:50.579
Eric Greene: to work with co-pilot as a fellow programmer. And so that's why I try to use some some niceties like Please, and stuff like that. Sometimes I'll even give it a whole story, you know. I don't know very much about python, and my manager wants me to build this application, and I'm not really in the mood. What's the fastest way that I can go? Kind of like what you'd say to another person if you were working on a project

869
01:10:50.740 --> 01:10:58.430
Eric Greene: and believe it or not, co-pilot will adjust its answer. If you tell it, you're brand new, it'll give you, step by step, instructions. If you tell it your experience.

870
01:10:58.450 --> 01:11:07.780
Eric Greene: it'll give you a short summary on how to do something. It really does factor in context, not just of the code itself, but you as the person interacting with it.

871
01:11:09.290 --> 01:11:11.630
Eric Greene: Okay, let's see here.

872
01:11:19.190 --> 01:11:25.160
Eric Greene: see here, I'm looking through the chats here real quick, just to pick up any questions that are there.

873
01:11:28.510 --> 01:11:29.590
Eric Greene: K,

874
01:11:32.680 --> 01:11:35.400
Eric Greene: yeah. So, you know, sometimes the code you get

875
01:11:35.720 --> 01:11:37.639
Eric Greene: just won't be very good code.

876
01:11:37.860 --> 01:11:39.720
Eric Greene: It could be because

877
01:11:39.940 --> 01:11:45.129
Eric Greene: there's something wrong with the AI tooling. It could also be because we're not good at asking questions.

878
01:11:45.380 --> 01:11:48.900
Eric Greene: One of the first things I discovered when I started using Chat Gpt

879
01:11:49.210 --> 01:11:54.459
Eric Greene: was, I wasn't good at asking questions. I made too many assumptions about

880
01:11:54.520 --> 01:12:02.170
Eric Greene: what the AI might be thinking, and I kind of learned that I was probably making those assumptions in my human conversations as well.

881
01:12:02.440 --> 01:12:10.050
Eric Greene: And so I found working with chacht and co-pilot chat have actually helped me do a better job in talking to real people.

882
01:12:10.280 --> 01:12:22.180
Eric Greene: because now I think more about how I'm asking my question, what details I'm including or not, including, which I didn't necessarily really pay that much attention to before I just spoke right

883
01:12:22.480 --> 01:12:29.310
Eric Greene: well with copilot. You get to iterate very quickly on asking questions and having technical discussions.

884
01:12:29.320 --> 01:12:39.220
Eric Greene: And it does a good job. It's kind of like when you're using grammarly right? Grammarly points out your your errors as you're typing well over time, you start to write

885
01:12:39.420 --> 01:12:44.069
Eric Greene: better text because you learn the lessons that grammarly is pointing out to you.

886
01:12:44.410 --> 01:12:48.120
Eric Greene: I find the same thing is true when interacting with with copilot.

887
01:12:49.810 --> 01:12:50.920
Eric Greene: All right.

888
01:12:55.620 --> 01:13:02.920
Eric Greene: I don't know anything about support for eclipse. Unfortunately, I know a lot of people use that editor, but but I'm not. I'm not aware.

889
01:13:03.970 --> 01:13:04.880
Eric Greene: Okay.

890
01:13:05.080 --> 01:13:07.239
Eric Greene: so the evolution of programming.

891
01:13:07.570 --> 01:13:12.809
Eric Greene: Here's what I tell my students. So I've been incorporating AI into my classes for the last

892
01:13:13.260 --> 01:13:14.820
Eric Greene: year year and a half.

893
01:13:15.370 --> 01:13:22.369
Eric Greene: so I didn't originally incorporate AI. But as people started to become more aware of it and more curious about it.

894
01:13:22.530 --> 01:13:25.800
Eric Greene: I started incorporating it into parts of my classes.

895
01:13:25.810 --> 01:13:35.150
Eric Greene: You have to be careful, though, because, as an instructor. If you're teaching and everything is being generated by AI, the students start to question how much you actually know about the topic.

896
01:13:35.300 --> 01:13:38.659
Eric Greene: So so I try to limit the use of it.

897
01:13:39.018 --> 01:13:44.120
Eric Greene: But but I do demonstrate how to use it so they can make use of it in their coding.

898
01:13:44.460 --> 01:13:46.990
Eric Greene: And here's what I tell all of my students.

899
01:13:47.680 --> 01:13:51.030
Eric Greene: If you are a person who's been in the industry

900
01:13:51.700 --> 01:13:55.920
Eric Greene: 30 40 years, you're probably looking at retirement.

901
01:13:56.030 --> 01:13:58.389
Eric Greene: and the next 10 or 15 years.

902
01:13:58.860 --> 01:14:01.559
Eric Greene: You're probably going to be okay

903
01:14:01.660 --> 01:14:04.179
Eric Greene: with how we do the coding today

904
01:14:04.220 --> 01:14:12.240
Eric Greene: as great as copilot is as great as the AI is, we still need programmers to write curly braces and parentheses and stuff like that.

905
01:14:12.750 --> 01:14:13.770
Eric Greene: However.

906
01:14:14.080 --> 01:14:16.120
Eric Greene: for those of you who are new.

907
01:14:16.500 --> 01:14:20.909
Eric Greene: your programming career is going to look very different than the one that I've had

908
01:14:21.540 --> 01:14:27.439
Eric Greene: the one I've had for the last 30 years. Curly braces and semicolons was very different

909
01:14:27.510 --> 01:14:32.160
Eric Greene: than the previous generations had where they had to use punch cards right?

910
01:14:32.520 --> 01:14:36.420
Eric Greene: So we've gone through this transition before from vacuum tubes to

911
01:14:36.540 --> 01:14:46.290
Eric Greene: transistors to doing punch cards to actually having computer terminals and editors to having full blown ides and code completion.

912
01:14:46.380 --> 01:14:52.690
Eric Greene: And now we're making the next transition with the with the generative AI stuff, the co-pilots and such

913
01:14:53.100 --> 01:14:59.640
Eric Greene: for those of you who are new to programming, like you're you're early in your career, and I mean, from like a young age. I mean, if you're

914
01:14:59.680 --> 01:15:07.009
Eric Greene: if you're 70 and you're new to programming, you're probably not going to be programming for the next 20 years. But if you're in your twenties.

915
01:15:07.260 --> 01:15:10.390
Eric Greene: You are probably going to have a very, very different

916
01:15:11.030 --> 01:15:13.920
Eric Greene: career ahead of you than what mine has been.

917
01:15:14.010 --> 01:15:19.720
Eric Greene: Yours is not going to be focused in on curly braces and parentheses and semicolons.

918
01:15:19.770 --> 01:15:23.649
Eric Greene: Yours is going to be focused in on higher level abstractions.

919
01:15:23.810 --> 01:15:31.410
Eric Greene: The time that I spent typing in semicolons and curly braces. You're going to be able to spend that time solving bigger and more complex problems.

920
01:15:31.670 --> 01:15:36.339
Eric Greene: You see, computer science originally started off with, how do I manipulate the processor

921
01:15:36.530 --> 01:15:37.290
Eric Greene: right?

922
01:15:38.060 --> 01:15:41.159
Eric Greene: Then, eventually we we move past the processor

923
01:15:41.320 --> 01:15:46.849
Eric Greene: and lower level memory management to how do I work in in relatively

924
01:15:47.320 --> 01:16:01.220
Eric Greene: simple and basic abstractions. That's really what most programming we do today is it's mostly in simple or basic abstractions, right? It might seem complex to us. But they're they're simple and basic abstractions compared to what's coming in the future.

925
01:16:01.570 --> 01:16:07.769
Eric Greene: However, when we write that code, we still have to focus in on some things like semicolons and curly braces and stuff like that.

926
01:16:08.570 --> 01:16:10.709
Eric Greene: However, for the next generation

927
01:16:11.190 --> 01:16:16.099
Eric Greene: you're going to be focusing in on higher level, much more complex

928
01:16:16.560 --> 01:16:17.860
Eric Greene: abstractions.

929
01:16:17.870 --> 01:16:25.679
Eric Greene: You're not going to be dealing with the details of parentheses and curly braces like I am today, just like I don't deal with

930
01:16:25.700 --> 01:16:27.819
Eric Greene: writing the assembly code

931
01:16:28.190 --> 01:16:30.320
Eric Greene: of generations before.

932
01:16:30.780 --> 01:16:37.090
Eric Greene: And so for those of you who are who are young, you definitely want to learn everything you can

933
01:16:37.120 --> 01:16:39.610
Eric Greene: about how to use this tooling

934
01:16:39.730 --> 01:16:44.970
Eric Greene: to make you more efficient to make you more knowledgeable how to make yourself more productive.

935
01:16:45.190 --> 01:16:51.800
Eric Greene: because when you go to get the job interview, it's not just going to be. Can you accomplish some type of exercise on leak code?

936
01:16:51.900 --> 01:16:54.829
Eric Greene: It's going to be. Do you know how to use this tooling

937
01:16:55.320 --> 01:16:57.560
Eric Greene: to actually build real software?

938
01:16:57.770 --> 01:17:04.419
Eric Greene: And you'll be surprised. It's not going to be about the semicolons. It's going to be about those higher level concepts and ideas

939
01:17:04.550 --> 01:17:12.510
Eric Greene: that you're going to have to be able to utilize the AI to help you build. A good example of this is, if you think about the Iron Man Movies

940
01:17:12.830 --> 01:17:17.289
Eric Greene: right? I think it was Jonathan Stark was his name, and he wanted to create the Iron Man suit

941
01:17:17.340 --> 01:17:21.059
Eric Greene: when he went back to his lab to create the Iron Man suit. He wasn't.

942
01:17:21.130 --> 01:17:24.460
Eric Greene: He wasn't, you know, firing up the

943
01:17:24.760 --> 01:17:29.090
Eric Greene: it wasn't firing up the fire pit to like break out the blacksmith hammer and start.

944
01:17:29.280 --> 01:17:36.590
Eric Greene: you know, banging the metal into shape. He wasn't breaking out the screwdriver and screwing the the pieces of the Iron Man suit together.

945
01:17:36.680 --> 01:17:45.429
Eric Greene: He used his computer and his AI to design the suit, and then he used all of the tooling that he had all powered by AI

946
01:17:45.680 --> 01:17:47.480
Eric Greene: to build the iron Man suit.

947
01:17:47.660 --> 01:17:56.420
Eric Greene: so was he still technically involved. Did he have to know a lot of stuff to build it? Yeah. But he didn't have to figure out how to use a lathe or how to cut sheet metal.

948
01:17:56.460 --> 01:17:58.719
Eric Greene: That was all done for him by his tooling.

949
01:17:59.130 --> 01:18:03.409
Eric Greene: That's what's going to happen with programming in the long run. We're still going to have programmers.

950
01:18:03.550 --> 01:18:10.520
Eric Greene: But they're just not going to be focused in on curly braces and semicolons, just like, I don't worry about OP codes to the CPU anymore.

951
01:18:11.060 --> 01:18:12.960
Eric Greene: Hopefully, that analogy

952
01:18:12.980 --> 01:18:14.570
Eric Greene: makes sense to everybody.

953
01:18:16.110 --> 01:18:17.240
Eric Greene: All rights

954
01:18:17.480 --> 01:18:18.320
Eric Greene: cool.

955
01:18:19.480 --> 01:18:20.570
Eric Greene: All right.

956
01:18:22.860 --> 01:18:29.659
Eric Greene: I can't speak too much to cobal. You can have it generate cobal for you if I came into here and opened up app pi

957
01:18:30.030 --> 01:18:32.019
Eric Greene: and I come into here and I did a

958
01:18:33.660 --> 01:18:35.100
Eric Greene: file.

959
01:18:35.380 --> 01:18:37.080
Eric Greene: and we'll say, Please

960
01:18:37.950 --> 01:18:39.130
Eric Greene: generate

961
01:18:39.140 --> 01:18:40.460
Eric Greene: the cobalt

962
01:18:40.710 --> 01:18:43.120
Eric Greene: version of this code.

963
01:18:43.420 --> 01:18:45.190
Eric Greene: It'll generate it for you.

964
01:18:46.730 --> 01:19:02.310
Eric Greene: But in terms of how that works on cobal systems that would be an example of something where I'd have to know more details about something. It's not just enough to know co-pilot. I'd have to know something more about cobalt and the actual systems that it runs on. But yes, it did generate the cobal program.

965
01:19:02.320 --> 01:19:04.499
Eric Greene: and I always like to do this one for fun.

966
01:19:05.120 --> 01:19:09.150
Eric Greene: and I don't know if it'll generate the whole thing here. But please generate the

967
01:19:09.420 --> 01:19:11.100
Eric Greene: arm. 64.

968
01:19:11.290 --> 01:19:13.139
Eric Greene: Assembly for this code.

969
01:19:16.470 --> 01:19:17.340
Eric Greene: Pop.

970
01:19:20.410 --> 01:19:25.650
Eric Greene: so it's going to tell me that I can't do it. But if I had a simpler C program it would give me the arm assembly for it.

971
01:19:25.900 --> 01:19:26.820
Eric Greene: Okay.

972
01:19:27.140 --> 01:19:30.157
Eric Greene: anyways, I wanna thank you all.

973
01:19:31.496 --> 01:19:35.889
Eric Greene: thank you all. So much for attending the webinar today. I hope

974
01:19:36.170 --> 01:19:40.799
Eric Greene: some of the demonstrations, but also a lot of the concepts to you.

975
01:19:40.920 --> 01:19:42.170
Eric Greene: We're helpful.

976
01:19:42.360 --> 01:19:46.279
Eric Greene: I know everyone has a variety of views on AI. And.

977
01:19:46.280 --> 01:19:48.739
Axcel ILT: You need to start talking so can you

978
01:19:49.010 --> 01:19:49.690
Axcel ILT: out.

979
01:19:52.940 --> 01:19:56.609
Eric Greene: Usage of of copilot and stuff like that

980
01:19:56.730 --> 01:20:04.659
Eric Greene: and and so, hopefully, I've given you some things to think about here in terms of what copilot is.

981
01:20:04.700 --> 01:20:09.900
Eric Greene: how to use it, examples of using it, and what the role of copilot and AI will be

982
01:20:10.050 --> 01:20:19.809
Eric Greene: in the future for all of us. Okay. Now I appreciate everyone taking the time to attend, and I apologize for going a little bit over. But I hope it was interesting for all of you, and I wish you all the best.

983
01:20:20.120 --> 01:20:39.973
Axcel ILT: Yeah, thank you. Thank you so much, Eric. Sorry. My audio kind of broke through there for a second. But I wanted to thank you so much, and thanks for everyone who came because you made it so fun and interactive with all of your wonderful questions. And, Eric, thank you for staying for and answering them all as well. This this is great and

984
01:20:40.280 --> 01:20:49.220
Axcel ILT: wonderful job. And I I did have to. I laughed a little bit inside, because I also say, please, when I'm working with gem, and I cause I just feel like I should.

985
01:20:49.220 --> 01:20:50.320
Eric Greene: Right, right.

986
01:20:50.320 --> 01:20:52.620
Axcel ILT: I'm good. I'm just if

987
01:20:53.290 --> 01:20:57.740
Axcel ILT: bear with me 1 s, I'm gonna just see if I can share my screen for a second.

988
01:20:58.040 --> 01:20:59.390
Eric Greene: Of course I'll stop sharing.

989
01:20:59.390 --> 01:21:00.410
Axcel ILT: Okay, thank you.

990
01:21:02.221 --> 01:21:31.740
Axcel ILT: Let's see. Just wanna see if you can see introduction to Github Co. Pilot training. There should be coming up right now. Yes, okay. So this is the link that I put in the chat. We'll also be sending you this out when we send the recorded video. So that'll be coming out for you tomorrow. But you know this is just a snapshot with Eric. But you know, if you liked an hour with Eric. The only thing better is the whole day with Eric. Any amount of time you can get with Eric. So

991
01:21:32.029 --> 01:21:40.130
Axcel ILT: and if you're just one or 2 people. And you need to be trained when we do have an online virtual class scheduled for April 20, s.

992
01:21:40.370 --> 01:21:57.420
Axcel ILT: and yeah, you'll get the you got the URL, and thank you everyone so much. Again. I go. I'll I'll go ahead and release you out into the world. You were so nice to stick with us, and we really appreciate it. Have a wonderful day, everybody. And Eric, thank you again so much for this, and we hope to see you all next time on our next webinar.

993
01:21:57.770 --> 01:22:00.169
Axcel ILT: Hey? Okay, bye, everyone. Thank you.

994
01:22:00.170 --> 01:22:01.039
Eric Greene: Yeah, everybody.

AI Webinar: Coding with GitHub Copilot

AI Webinar: Coding with GitHub Copilot

Alert!

Modal Title

Error!

Default Title

Prompt

Confirm

Login