Original subtitles

1 1

So in this video, 2

2

we're going to put all our code on to GitHub. 3

3

Or as we usually say, 4

4

we're going to push our code to a remote branch, 5

5

so that we can 6

6

then set up the continuous integration feature 7

7

that I talked about before in the next video. 8

8

And so now here on GitHub, 9

9

let's click on this plus button here, 10

10

and create a new repository. 11

11

Or we could also click right here, 12

12

so there are going to be multiple ways 13

13

of creating a New repository 14

14

because that's basically the most important feature 15

15

on GitHub. 16

16

Am I right? 17

17

Then here, the first thing 18

18

is that we need to give the repository a name, 19

19

and I'm going to call it, 20

20

"fortify-course-video", 21

21

"fortify-course-video", 22

22

"fortify-course-video", 23

23

just so that I know exactly what this repository is about. 24

24

So I like to be really descriptive here. 25

25

Then, I'm going to make it private, 26

26

and so it is no one else can see this repository. 27

27

Then down here, we have the option to add a README 28

28

and a .gitignore, but we don't want to do that, 29

29

okay? 30

30

So if we added a README right now, 31

31

then we would create a conflict later on 32

32

when we import our code. 33

33

So actually, that's what's saying here right now, 34

34

so skip this step, 35

35

if you're importing an existing repository. 36

36

And so that's what we will do next. 37

37

So then click on creating repository, 38

38

(keyboard tapping) 39

39

and so here we are. 40

40

Okay. 41

41

So this year is the URL, basically of or a git repository, 42

42

but what matters here 43

43

is that now there are these two scenarios: 44

44

So there is the scenario 45

45

that we don't have a repository yet. 46

46

So I mean, a local one, 47

47

but that's not the case. 48

48

So we already have the repository 49

49

that we have been working on, 50

50

and so what we want to do now, 51

51

is to push that existing repository 52

52

to this online repository. 53

53

So to this remote repository 54

54

that we just created here. 55

55

And so in order to connect these two, 56

56

we need to copy this line of code 57

57

and execute it in or a local repository. 58

58

So let's go back, clear this here, 59

59

and then paste it and execute it. 60

60

And so what this did here, was to add a remote branch, 61

61

which is called "origin". 62

62

All right, 63

63

and the URL of that remote branch is called, 64

64

this one here. 65

65

So again, with this, we basically let 66

66

our local repository know about 67

67

this remote repository right here. 68

68

And if we check out our branches, now, 69

69

then that origin branch might actually be there. 70

70

Now I'm not sure if it is, 71

71

but let's check that out. 72

72

So git, 73

73

branch, 74

74

and it actually doesn't say here, 75

75

but that doesn't really matter. 76

76

So this was just to check. 77

77

But what matters is that we can now push code 78

78

to this remote branch, which remember is called "origin". 79

79

And, so the way we do that is 80

80

by writing git, 81

81

push, 82

82

and then the name of the remote brand, 83

83

which is called "origin". 84

84

So that's right here. 85

85

And of course, you could give this one another name, 86

86

but "origin" is simply the standard name. 87

87

So that's what everyone uses. 88

88

So git, push, origin, 89

89

and then the name of the branch 90

90

that you want to, to push. 91

91

(keybooard tapping) 92

92

And so let's say, 93

93

that we only want to push the master branch. 94

94

So, hit Enter, 95

95

and then you will see that it's going to do some work here. 96

96

And now it's done. 97

97

Okay. 98

98

And so now, if we go to GitHub 99

99

and reload, or repository here, 100

100

then, 101

101

then our code is there. 102

102

All right. 103

103

Great! 104

104

So we successfully pushed our local repository 105

105

into this remote repository. 106

106

And so now, if we would work on any other computer, 107

107

we could go ahead and take our code out of this repository. 108

108

And you see that indeed, all our code is here, 109

109

at least all the code 110

110

that we did not add to the Git ignore file. 111

111

So that's why you only have to source here now, 112

112

but not the dist and node modules folders. 113

113

But everything else is, of course, here. 114

114

So our index, HTML, and all our source codes. 115

115

And you can see here, 116

116

also, the commit messages that we had, 117

117

and you can see the branches. 118

118

So right now we only have the master branch, 119

119

but if we really wanted to keep that other branch as well, 120

120

in our remote repository, 121

121

then we can simply recall this again. 122

122

And so, .git-push-origin, 123

123

and then the name of that other branch, 124

124

which was called "new feature". 125

125

Now, right. 126

126

So ... 127

127

this looks a bit different, 128

128

but let's see, let's reload. 129

129

And then here it is. 130

130

All right. 131

131

But anyway, let's now add a readme file, 132

132

which is a common thing 133

133

that all GitHub repositories should have. 134

134

So it's basically a file that appears down here 135

135

with a description of the project. 136

136

So let's come here, or actually, let's do it from here. 137

137

So "touch, readme.md", 138

138

and so we can use or command line scales a little bit. 139

139

So, here it is. 140

140

And now to add a title to any MD file. 141

141

So "MD" stands for "markdown". 142

142

And so markdown, is like a special typing format 143

143

that we can use to write simple documents. 144

144

And so let's give this here a name of, "fortify, project", 145

145

and then, an empty line. 146

146

And then here, we can add some description text, 147

147

let's say, 148

148

"a recipe application with custom recipe uploads". 149

149

And so, you can write whatever description you want here. 150

150

I just want to keep it really short here. 151

151

And now, let's go through the same process, as before, 152

152

so that we can also upload this file. 153

153

So basically, upload this modification 154

154

to our remote repository as well. 155

155

So as always, we need to start 156

156

by adding this new file to the staging area, 157

157

then, we need to commit it. 158

158

So git commit message. 159

159

And then here a nice, descriptive, message. 160

160

So edit, the readme, and then git-push-origin, master. 161

161

So let's wait for it. 162

162

And now if we come here, 163

163

you see that we had, 26 minutes ago, we had two commits, 164

164

and this here is the latest commit message. 165

165

And now as we reload this, 166

166

then you'll see, we now have three commits. 167

167

This is the latest commit message. 168

168

And indeed, down here now appears, 169

169

this description that we just added. 170

170

Great! 171

171

Now, if you wanted to now start working on another computer, 172

172

you could simply go to this button here, copy this URL, 173

173

and then do the opposite, which is pull. 174

174

Okay. 175

175

Now, many times when we create a new repository, 176

176

we actually do it the other way around. 177

177

So, we start with a new repository on GitHub, 178

178

then we give it a name, 179

179

and then we actually add a readme here, 180

180

and also a git ignore, then we create that repository, 181

181

and then we pull that repo onto our computer. 182

182

And so this, 183

183

then actually, automatically connects the local repository 184

184

with the remote one. 185

185

And so that makes things a little bit easier. 186

186

So a lot of times I do it like this, but in this case, 187

187

we already had the local repository with all our code. 188

188

And so, therefore, 189

189

we needed to create this repository really empty. 190

190

So just the way that we did it. 191

191

Okay. 192

192

But anyway, 193

193

let's go back here to our remote Git repository now, 194

194

so that in the next video, 195

195

we can finally set up the continuous integration feature 196

196

with netlify.