1
00:00:08,483 --> 00:00:11,477
[Powered by Google Translate] [ROCK MUSIC]

2
00:00:32,435 --> 00:00:35,429
[MUSIC  - “HAPPY TOGETHER”的龜]

3
00:01:27,330 --> 00:01:30,170
DAVID馬蘭：今天，我們開始探索

4
00:01:30,170 --> 00:01:32,710
計算機科學的基本原理，並推出了我們，

5
00:01:32,710 --> 00:01:35,070
現在，本領域的編程，其中，即

6
00:01:35,070 --> 00:01:36,260
只是其中的一個例子。

7
00:01:36,260 --> 00:01:39,600
但在同樣的解決問題的，要知道

8
00:01:39,600 --> 00:01:42,080
CS50的傳統益智明天是星期幾。

9
00:01:42,080 --> 00:01:45,190
如果你還沒有RSVPed此事件，你可以去

10
00:01:45,190 --> 00:01:47,510
cs50.net/rsvp。

11
00:01:47,510 --> 00:01:50,940
你可以把兩個或三個或四個隊。

12
00:01:50,940 --> 00:01:53,080
你的挑戰的問題，像你看到的

13
00:01:53,080 --> 00:01:54,190
那裡開始。

14
00:01:54,190 --> 00:01:57,000
所有新的問題，如果你今年partook去年，

15
00:01:57,000 --> 00:01:59,680
將有機會贏得一些獎品。

16
00:01:59,680 --> 00:02:02,750
其中，Wii和一些禮品證書和類似的，

17
00:02:02,750 --> 00:02:05,650
所有，而與CS50的學生和同學出去玩

18
00:02:05,650 --> 00:02:07,720
和比薩餅和Facebook。

19
00:02:07,720 --> 00:02:10,430
所以，明天，如果你想。

20
00:02:10,430 --> 00:02:13,330
>> 這是CS50，對於那些你加入我們的

21
00:02:13,330 --> 00:02:14,510
第一次。

22
00:02:14,510 --> 00:02:18,030
知道這當然是決心要得到

23
00:02:18,030 --> 00:02:22,605
通過本課程的最終結束，此時你

24
00:02:22,605 --> 00:02:24,270
將不僅理解這些

25
00:02:24,270 --> 00:02:26,450
計算機科學基礎，但你將有

26
00:02:26,450 --> 00:02:29,120
這個非常實用的技能，然後你可以帶回去給

27
00:02:29,120 --> 00:02:31,370
你自己的部門，無論是工程科學，

28
00:02:31,370 --> 00:02:33,570
應用數學，物理科學，自然

29
00:02:33,570 --> 00:02:34,780
科學，或等。

30
00:02:34,780 --> 00:02:37,030
事實上，如此令人興奮的關於計算機科學這些

31
00:02:37,030 --> 00:02:39,900
天，它僅僅是適用於

32
00:02:39,900 --> 00:02:40,990
各種領域。

33
00:02:40,990 --> 00:02:46,210
即使今天，我們只會表面的劃傷

34
00:02:46,210 --> 00:02:49,020
非常傳統的編程語言為C，我們將

35
00:02:49,020 --> 00:02:51,040
名為scratch的東西，而不是看的東西

36
00:02:51,040 --> 00:02:53,420
該cookie實現你的一個愛情故事

37
00:02:53,420 --> 00:02:57,020
前輩在過去的幾年中，講故事，創建遊戲，

38
00:02:57,020 --> 00:03:00,060
創建互動藝術，並真正開始包裝

39
00:03:00,060 --> 00:03:02,240
一些心中周圍的基本結構，

40
00:03:02,240 --> 00:03:05,390
基礎編程，但在上下文中，你會看到，這是

41
00:03:05,390 --> 00:03:09,140
要少得多可怕的，這是神秘的要少得多，你會看到

42
00:03:09,140 --> 00:03:10,140
前長。

43
00:03:10,140 --> 00:03:12,410
和實現，也為那些你剛加入我們這個

44
00:03:12,410 --> 00:03:16,170
學期截至週三的演講，短語，

45
00:03:16,170 --> 00:03:20,260
它是不是那麼重要，你在哪裡結束相對於你的

46
00:03:20,260 --> 00:03:22,950
在這個類中的同學，但你，學期結束

47
00:03:22,950 --> 00:03:27,190
在第11週，結束了自己這一天。

48
00:03:27,190 --> 00:03:32,000
>> 因此，事不宜遲，這也是值得注意的是，

49
00:03:32,000 --> 00:03:34,450
那些不太舒服，那些介於兩者之間，

50
00:03:34,450 --> 00:03:36,825
同時，通過本課程的設計，沒有任何缺點

51
00:03:36,825 --> 00:03:38,760
面對面那些更舒適

52
00:03:38,760 --> 00:03:39,920
未來這一類。

53
00:03:39,920 --> 00:03:41,810
正如你將看到，未來幾週內，我們有不同的

54
00:03:41,810 --> 00:03:44,600
軌道後面的背景不同，這些章節

55
00:03:44,600 --> 00:03:46,500
不太舒服，更舒適，那些某處

56
00:03:46,500 --> 00:03:47,250
在兩者之間。

57
00:03:47,250 --> 00:03:49,520
正如你將看到本週末和下週，有兩個版本

58
00:03:49,520 --> 00:03:52,410
標準和黑客版，所以大多數問題集

59
00:03:52,410 --> 00:03:55,390
，你都可以自我選擇的路徑與您

60
00:03:55,390 --> 00:03:56,615
是最舒服的。

61
00:03:56,615 --> 00:03:58,770
>> 所以，今天，我們深入到這種編程

62
00:03:58,770 --> 00:04:00,060
語言從頭開始。

63
00:04:00,060 --> 00:04:02,250
這是一個圖形化的編程語言，但它有

64
00:04:02,250 --> 00:04:04,500
一些較高層次的語言，我們會相同的功能

65
00:04:04,500 --> 00:04:07,050
後面的學期，其中C

66
00:04:07,050 --> 00:04:08,670
JavaScript和PHP。

67
00:04:08,670 --> 00:04:11,890
但是這將讓我們的雜念，以避免一些

68
00:04:11,890 --> 00:04:14,890
早期的語法，比如分號，括號內的事情，

69
00:04:14,890 --> 00:04:17,720
和其他神秘的細節，乍看之下，只是沒有

70
00:04:17,720 --> 00:04:19,916
在所有智力有趣的，往往會得到

71
00:04:19,916 --> 00:04:22,310
的方式，從一些基本的了解。

72
00:04:22,310 --> 00:04:24,870
現在前面的支撐結構方面，認識到這一點

73
00:04:24,870 --> 00:04:27,570
工具，CS50討論，這將是在球場上的鏈接

74
00:04:27,570 --> 00:04:30,320
網站後的今天，網上論壇

75
00:04:30,320 --> 00:04:32,480
這你就可以問對方的問題和

76
00:04:32,480 --> 00:04:35,020
工作人員，這也是一個工具，我們將在下週看，

77
00:04:35,020 --> 00:04:37,240
我們將使用相當綜合

78
00:04:37,240 --> 00:04:38,780
辦公時間為好。

79
00:04:38,780 --> 00:04:41,670
事實上，辦公時間（星期一）開始，坦率地說，第一

80
00:04:41,670 --> 00:04:43,930
一周的辦公時間是相當低調。

81
00:04:43,930 --> 00:04:46,820
>> 我不認為你會發現全部刮開了不可訪問的。

82
00:04:46,820 --> 00:04:48,930
這是相當不言自明的，正如我們將看到的，所以什麼

83
00:04:48,930 --> 00:04:51,380
今天，我們將使用它是提取一定的

84
00:04:51,380 --> 00:04:53,990
基本的想法，然後，堅持在整個

85
00:04:53,990 --> 00:04:54,900
其餘的學期。

86
00:04:54,900 --> 00:04:57,980
但是，從週一開始，8:00 PM 11:00 PM將

87
00:04:57,980 --> 00:05:01,530
安嫩伯格對大腦休息的辦公時間。

88
00:05:01,530 --> 00:05:04,490
切片將開始在這個晚上，所以在這個

89
00:05:04,490 --> 00:05:07,260
週末，去cs50.net/section，，你會

90
00:05:07,260 --> 00:05:08,530
問了一些問題。

91
00:05:08,530 --> 00:05:10,290
其中，你會如何描述你的

92
00:05:10,290 --> 00:05:12,040
今天的舒適度？

93
00:05:12,040 --> 00:05:14,450
有沒有堅硬，快速的規則，誰在這桶。

94
00:05:14,450 --> 00:05:17,170
這僅僅是諸如此類的事情，你可能知道，如果你

95
00:05:17,170 --> 00:05:20,280
是那些不太舒服或以其他方式之一。

96
00:05:20,280 --> 00:05:21,350
>> 目前，演練。

97
00:05:21,350 --> 00:05:24,020
本週，包括標準問題集規範

98
00:05:24,020 --> 00:05:28,560
黑客版的一致好評，是在cs50.net在線的現在。

99
00:05:28,560 --> 00:05:31,500
你會看到，這些版本，

100
00:05:31,500 --> 00:05:33,940
標準版，是伴隨著每個星期的東西，我們

101
00:05:33,940 --> 00:05:36,550
調用一個代碼演練，一個會議領導下的

102
00:05:36,550 --> 00:05:39,100
課程的教學研究員來指導您完成，

103
00:05:39,100 --> 00:05:42,290
提示，讓你下來時，一個特定的路徑

104
00:05:42,290 --> 00:05:44,150
啟動這些問題集。

105
00:05:44,150 --> 00:05:46,790
因此，這些問題的設置，如果你曾經想要

106
00:05:46,790 --> 00:05:50,250
自己我在哪裡開始，你就開始與這些

107
00:05:50,250 --> 00:05:50,890
演練。

108
00:05:50,890 --> 00:05:53,450
而事實上，讓我給你介紹Zamyla陳

109
00:05:53,450 --> 00:05:55,870
將帶領每一年的教學研究員

110
00:05:55,870 --> 00:05:56,910
這些演練。

111
00:05:56,910 --> 00:05:57,961
Zamyla？

112
00:05:57,961 --> 00:06:03,370
>> [掌聲]

113
00:06:03,370 --> 00:06:03,975
ZAMYLA陳：哦，嗨，大家。

114
00:06:03,975 --> 00:06:05,130
我的名字Zamyla。

115
00:06:05,130 --> 00:06:08,250
我是一個初中就讀工程的Winthrop樓。

116
00:06:08,250 --> 00:06:10,890
但我嘗試和適應盡可能多的計算機科學課程，因為我

117
00:06:10,890 --> 00:06:13,350
可以，這就是為什麼我很高興能領導這個

118
00:06:13,350 --> 00:06:14,590
今年的演練。

119
00:06:14,590 --> 00:06:16,950
演練，對我來說，是一個重要組成部分，我的CS50

120
00:06:16,950 --> 00:06:17,910
經驗。

121
00:06:17,910 --> 00:06:22,710
在演練中，每一個P-SET，我們將通過

122
00:06:22,710 --> 00:06:25,580
一起設置的問題，看問題，種

123
00:06:25,580 --> 00:06:27,360
它們劃分成可管理的叮咬。

124
00:06:27,360 --> 00:06:28,990
我給你的技巧，技術，獲得

125
00:06:28,990 --> 00:06:30,820
通過和開始。

126
00:06:30,820 --> 00:06:33,510
我希望能看到你所有的演練。

127
00:06:33,510 --> 00:06:34,720
如果你不能做它的人，然後

128
00:06:34,720 --> 00:06:36,580
請不要在網上調。

129
00:06:36,580 --> 00:06:36,840
>> DAVID馬蘭：非常好。

130
00:06:36,840 --> 00:06:37,950
謝謝你，Zamyla。

131
00:06:37,950 --> 00:06:40,870
因此，認識到演練，事實上，在一個星期五

132
00:06:40,870 --> 00:06:43,110
下午，但是這是故意設計，使

133
00:06:43,110 --> 00:06:45,750
即使你不想在一個星期五的上課

134
00:06:45,750 --> 00:06:48,490
下午，影片將是更迅速，

135
00:06:48,490 --> 00:06:48,990
本週末。

136
00:06:48,990 --> 00:06:51,880
因此，認識到的cs50.net將所有的Zamyla，

137
00:06:51,880 --> 00:06:53,130
演練。

138
00:06:54,800 --> 00:06:56,890
而這是今天的日期和時間，3:00 PM，

139
00:06:56,890 --> 00:06:58,370
廳，104 Harberd。

140
00:06:58,370 --> 00:07:00,080
一些教學研究員也準備了

141
00:07:00,080 --> 00:07:03,250
一些為你的缺席給你多一點

142
00:07:03,250 --> 00:07:06,760
角度，以他們的經驗和

143
00:07:06,760 --> 00:07:08,990
走出去CS50是怎樣的。

144
00:07:08,990 --> 00:07:11,250
因此，如果我們能夠昏暗的燈光，只是一瞬間，我給你

145
00:07:11,250 --> 00:07:18,100
一些CS50的工作人員。

146
00:07:18,100 --> 00:07:20,440
>> 傑克遜施泰因坎普：我把CS50去年的一個大一新生

147
00:07:20,440 --> 00:07:22,880
下降，和它絕對吹我的腦海裡。

148
00:07:22,880 --> 00:07:25,090
我從來沒有採取任何編程班前，

149
00:07:25,090 --> 00:07:26,380
從來沒有在任何計算機科學

150
00:07:26,380 --> 00:07:27,320
在所有的經驗。

151
00:07:27,320 --> 00:07:29,240
只是，我聽到的嗡嗡聲的類和

152
00:07:29,240 --> 00:07:30,050
決定把它。

153
00:07:30,050 --> 00:07:31,780
>> JULIA參考Mitelman：它真的很有趣，真的很搞。

154
00:07:31,780 --> 00:07:33,480
我的是，這一天 - 

155
00:07:33,480 --> 00:07:36,560
我剛剛看到我有軟盤，大衛給我們

156
00:07:36,560 --> 00:07:38,140
我們第一天的演講。

157
00:07:38,140 --> 00:07:40,020
我已經把它掛在牆上。

158
00:07:40,020 --> 00:07:42,410
這可能是一個小書呆子，但我掛在我的

159
00:07:42,410 --> 00:07:46,930
牆在課堂上作為提醒的是如何的酷。

160
00:07:46,930 --> 00:07:49,240
>> TRAVIS DOWNS：它是如此的尷尬。

161
00:07:49,240 --> 00:07:50,770
>> JACKSON施泰因坎普：計算機科學是你

162
00:07:50,770 --> 00:07:52,370
應盡量即使你不是一個用於

163
00:07:52,370 --> 00:07:54,980
傳統的科學。

164
00:07:54,980 --> 00:07:58,510
這是自身的經驗，和CS50將確保你

165
00:07:58,510 --> 00:08:01,520
支持通過它的轉錄因子，其真正的軍隊。

166
00:08:01,520 --> 00:08:03,700
>> ALI的Nahm：我把它作為一個新生，所以我做了很多

167
00:08:03,700 --> 00:08:04,215
新朋友。

168
00:08:04,215 --> 00:08:07,170
我也引入了這整個的濃度和

169
00:08:07,170 --> 00:08:10,770
整個工程的學校，所以我高度推薦

170
00:08:10,770 --> 00:08:14,360
歡迎您的我們的CS50家庭。

171
00:08:14,360 --> 00:08:17,510
>> 的Yaniv YACOBY：，CS50只是教你如何使用工具

172
00:08:17,510 --> 00:08:19,210
普及。

173
00:08:19,210 --> 00:08:21,840
你只需要一台筆記本電腦，你需要一個網頁瀏覽器，你

174
00:08:21,840 --> 00:08:26,030
需要學習編寫一些代碼，你可以真正建立

175
00:08:26,030 --> 00:08:27,400
整潔的事物。

176
00:08:27,400 --> 00:08:31,660
>> KAREN肖：這是如此的酷，能夠使一些

177
00:08:31,660 --> 00:08:34,580
和人們使用它，讓人們看到它，這就是

178
00:08:34,580 --> 00:08:35,900
我真的很喜歡它。

179
00:08:35,900 --> 00:08:37,429
>> TIM MCLAUGHLIN： - 一種社區的感覺，我覺得，在這

180
00:08:37,429 --> 00:08:39,470
當然到目前為止，我已經採取了比任何其他課程。

181
00:08:39,470 --> 00:08:41,350
你不只是以另一種 - 

182
00:08:41,350 --> 00:08:42,740
你沒有填充其他要求。

183
00:08:42,740 --> 00:08:45,310
你不只是去聽課，要部分。

184
00:08:45,310 --> 00:08:49,630
但是，你在做什麼噸的東西，是所有有關

185
00:08:49,630 --> 00:08:51,560
設計和所有有關的技術，但它不

186
00:08:51,560 --> 00:08:53,090
真的覺得自己像一類的大部分時間。

187
00:08:53,090 --> 00:08:55,012
>> TRAVIS DOWNS的第一天，他們分發了蛋糕，和

188
00:08:55,012 --> 00:08:56,215
我立即就被賣了。

189
00:08:56,215 --> 00:08:57,822
>> JACOB百特免費糖果和比薩餅。

190
00:08:57,822 --> 00:08:59,820
>> ZAMYLA陳： - 無論你的利率水平，我覺得

191
00:08:59,820 --> 00:09:05,170
，CS50，你將有樂趣，你會智力

192
00:09:05,170 --> 00:09:06,070
刺激。

193
00:09:06,070 --> 00:09:07,926
>> MARK GROZEN-SMITH：總是一個黨在課堂上，這是一個

194
00:09:07,926 --> 00:09:09,990
黨的每天晚上都工作在P-SET。

195
00:09:09,990 --> 00:09:11,880
>> JACKSON施泰因坎普：每次完成一個問題集，你

196
00:09:11,880 --> 00:09:13,710
會覺得你已經完成了一個項目。

197
00:09:13,710 --> 00:09:16,580
>> MELISSA牛：這是一年級以後，我完成購物。

198
00:09:16,580 --> 00:09:19,030
我有我的四個班準備好了，我在安尼伯格。

199
00:09:19,030 --> 00:09:21,670
我碰到一個朋友，他​​說，嘿，我在買東西

200
00:09:21,670 --> 00:09:24,330
這個類稱為CS50，你應該跟我來。

201
00:09:24,330 --> 00:09:28,150
結束了那年秋天，這個類後，我

202
00:09:28,150 --> 00:09:30,510
想，也許我要輕微的CS。

203
00:09:30,510 --> 00:09:33,760
但在這裡，我，三年後，仍然學習計算機

204
00:09:33,760 --> 00:09:36,680
科學和實際做它作為一個主要的，我喜歡每

205
00:09:36,680 --> 00:09:37,780
一刻。

206
00:09:37,780 --> 00:09:39,030
>> ROB BOWDEN：我不知道。

207
00:09:46,408 --> 00:09:48,060
>> ALI的Nahm：讓我們來看看。

208
00:09:48,060 --> 00:09:49,200
>> MELISSA牛：瘋狂。

209
00:09:49,200 --> 00:09:50,610
>> 主講人1：我覺得像我是很俗套。

210
00:09:50,610 --> 00:09:52,530
我只是說，喜歡，真棒。

211
00:09:52,530 --> 00:09:53,540
>> 的Yaniv YACOBY：輔助。

212
00:09:53,540 --> 00:09:55,080
>> JACOB百特免費糖果和比薩餅。

213
00:09:55,080 --> 00:09:57,310
>> TRAVIS起伏：一類無法打開，拿出蛋糕。

214
00:09:57,310 --> 00:09:58,510
>> TIM MCLAUGHLIN：精力充沛。

215
00:09:58,510 --> 00:10:00,040
>> VIPUL謝卡瓦特必不可少的。

216
00:10:00,040 --> 00:10:02,636
>> ROB BOWDEN：讓我想起了一個答案。

217
00:10:02,636 --> 00:10:04,480
我覺得我得到的東西。

218
00:10:04,480 --> 00:10:07,092
哦，天啊。

219
00:10:07,092 --> 00:10:13,370
是啊，我叫羅布·波頓，這是CS50。

220
00:10:13,370 --> 00:10:16,340
>> [掌聲]

221
00:10:20,810 --> 00:10:23,390
DAVID馬蘭：好吧，讓我們開始畫一幅畫

222
00:10:23,390 --> 00:10:26,230
的方向，使我們可以走了，讓我們來介紹

223
00:10:26,230 --> 00:10:28,190
這個概念在這裡被稱為偽代碼。

224
00:10:28,190 --> 00:10:29,560
所以偽代碼是不是一種編程

225
00:10:29,560 --> 00:10:30,810
你們自己的語言。

226
00:10:30,810 --> 00:10:33,250
這是什麼技術本身，但它只是一個

227
00:10:33,250 --> 00:10:36,490
一般的方式表達自己相當精確，

228
00:10:36,490 --> 00:10:39,730
相當算法，公平的程序，但不

229
00:10:39,730 --> 00:10:42,570
不必擔心你的語言表達

230
00:10:42,570 --> 00:10:43,150
自己英寸

231
00:10:43,150 --> 00:10:46,280
這是某些型號的英語和編程語言

232
00:10:46,280 --> 00:10:48,790
你碰巧是熟悉的，所以我們可以開始

233
00:10:48,790 --> 00:10:50,600
寫這樣的事情，因為我們去。

234
00:10:50,600 --> 00:10:54,450
而事實上，約瑟夫，我能借用你在舞台上是

235
00:10:54,450 --> 00:10:55,490
文士在這裡？

236
00:10:55,490 --> 00:11:00,130
我已經先行一步在這裡提前忘了把

237
00:11:00,130 --> 00:11:02,920
襪子的今天，這將是我們更

238
00:11:02,920 --> 00:11:03,780
可笑的例子。

239
00:11:03,780 --> 00:11:04,580
>> 現在，我需要你在這裡。

240
00:11:04,580 --> 00:11:05,630
我會做襪子的一部分。

241
00:11:05,630 --> 00:11:08,040
所以，在這裡，我們有一個小的便箋。

242
00:11:08,040 --> 00:11:09,940
這是從字面上只是TEXTEDIT在Mac。

243
00:11:09,940 --> 00:11:12,270
我們要編寫一個可運行的程序，但

244
00:11:12,270 --> 00:11:14,220
我們只是要開始畫出來的偽代碼基於

245
00:11:14,220 --> 00:11:17,830
勸你到我這裡提供的一些。

246
00:11:17,830 --> 00:11:20,760
因此，這裡是我的一堆襪子在家裡。

247
00:11:20,760 --> 00:11:23,320
當我在早上醒來時，我沒有襪子，我們現在

248
00:11:23,320 --> 00:11:26,280
需要寫一個程序，各種各樣的算法，

249
00:11:26,280 --> 00:11:27,900
在我腳上這雙襪子。

250
00:11:27,900 --> 00:11:30,860
前進的道路上，讓我們來看看，如果我們絆倒，或遇到，

251
00:11:30,860 --> 00:11:32,860
一些的想法，你會不得不開始

252
00:11:32,860 --> 00:11:35,470
想更認真地進行編程時，

253
00:11:35,470 --> 00:11:37,950
否則你的程序不表現得相當打算。

254
00:11:37,950 --> 00:11:39,580
>> 所以，我坐在這裡。

255
00:11:39,580 --> 00:11:41,180
我已經得到了我一堆襪子。

256
00:11:41,180 --> 00:11:43,780
的第一件事情，一個合理的人會是什麼

257
00:11:43,780 --> 00:11:46,600
做時，我們的目標是把一雙襪子嗎？

258
00:11:46,600 --> 00:11:49,190
有人給我一個步驟，只有一個步驟。

259
00:11:49,190 --> 00:11:49,796
是嗎？

260
00:11:49,796 --> 00:11:50,690
觀眾：彎下來。

261
00:11:50,690 --> 00:11:54,290
DAVID馬蘭：彎腰，好了。

262
00:11:54,290 --> 00:11:55,540
步驟2。

263
00:11:59,975 --> 00:12:00,645
步驟2。

264
00:12:00,645 --> 00:12:01,840
觀眾：拿起你的襪子。

265
00:12:01,840 --> 00:12:03,220
DAVID馬蘭：拿起你的襪子。

266
00:12:03,220 --> 00:12:07,610
好了，如此輕微的模糊性，這是第一個

267
00:12:07,610 --> 00:12:09,380
我們應該刻意的絆腳石

268
00:12:09,380 --> 00:12:10,290
在這裡遇上。

269
00:12:10,290 --> 00:12:14,110
這是一個有點曖昧，所以拿起你的襪子。

270
00:12:14,110 --> 00:12:17,425
好吧，我會拿這個，但一台電腦，在短短的實現

271
00:12:17,425 --> 00:12:20,420
位，是不會有那樣的人的本能，只是

272
00:12:20,420 --> 00:12:21,490
挑最近的一個。

273
00:12:21,490 --> 00:12:23,590
我們將不得不開始不久，表達

274
00:12:23,590 --> 00:12:24,610
我們更準確。

275
00:12:24,610 --> 00:12:26,600
>> 好，那麼第二步是拿起你的襪子。

276
00:12:26,600 --> 00:12:27,520
我們會接受它。

277
00:12:27,520 --> 00:12:28,620
步驟三。

278
00:12:28,620 --> 00:12:29,532
在後面。

279
00:12:29,532 --> 00:12:30,900
觀眾：找到一個匹配的一對。

280
00:12:30,900 --> 00:12:32,060
DAVID馬蘭：找到匹配的一對。

281
00:12:32,060 --> 00:12:34,740
好了，所以這是很好的。

282
00:12:34,740 --> 00:12:35,650
我不得不選擇這種襪子。

283
00:12:35,650 --> 00:12:39,200
因此，我們的目標是找到一個匹配的襪子，現在，但什麼

284
00:12:39,200 --> 00:12:39,990
什麼意思呢？

285
00:12:39,990 --> 00:12:42,130
一個合理的人，就像上週三時，我只是

286
00:12:42,130 --> 00:12:44,700
知道如何找到麥克·史密斯在電話簿中，只種

287
00:12:44,700 --> 00:12:45,640
去與他們的本能。

288
00:12:45,640 --> 00:12:49,220
但在這裡，它顯然襪子在這裡，但計算機的

289
00:12:49,220 --> 00:12:51,350
不會是這樣的本能。

290
00:12:51,350 --> 00:12:53,830
一台電腦要位的集合，我們

291
00:12:53,830 --> 00:12:55,380
上週三討論，而這些都是

292
00:12:55,380 --> 00:12:56,710
組織以某種方式在內存中。

293
00:12:56,710 --> 00:13:00,400
但問題是，只有一台計算機有能力

294
00:13:00,400 --> 00:13:03,390
看一次的事情，而事實上，即使我們

295
00:13:03,390 --> 00:13:05,980
人類 - 即使它感覺就像我低頭和分裂

296
00:13:05,980 --> 00:13:08,900
第二次以後，我知道的襪子在哪裡，我的大腦，我的眼睛

297
00:13:08,900 --> 00:13:12,000
大概是做了一個快速脫脂的那些襪子，然後鎖存

298
00:13:12,000 --> 00:13:13,400
中的一個問題。

299
00:13:13,400 --> 00:13:15,780
>> 因此，如果我們現在更故意一台電腦，

300
00:13:15,780 --> 00:13:17,780
我怎麼找到這個匹配的對嗎？

301
00:13:17,780 --> 00:13:18,890
好了，我們要循環。

302
00:13:18,890 --> 00:13:21,440
我們也許在這個亂七八糟的襪子上環

303
00:13:21,440 --> 00:13:25,760
它撿起地板FOR EACH襪子，讓我這樣說，

304
00:13:25,760 --> 00:13:30,195
，及其IF相同的形狀和大小作為另外一個，THEN

305
00:13:30,195 --> 00:13:32,150
點，點，點，我們將繼續這個故事。

306
00:13:32,150 --> 00:13:34,430
因此，對於每一個襪子，所以我挑了這一個。

307
00:13:34,430 --> 00:13:36,520
我檢查，這是等於這一個。

308
00:13:36,520 --> 00:13:38,250
這不是，所以我拋開一邊。

309
00:13:38,250 --> 00:13:39,220
然後，我再次重複。

310
00:13:39,220 --> 00:13:40,340
這是一個平等的嗎？

311
00:13:40,340 --> 00:13:42,010
不，它不是，所以我把它放在一邊。

312
00:13:42,010 --> 00:13:42,710
這是人嗎？

313
00:13:42,710 --> 00:13:43,200
號

314
00:13:43,200 --> 00:13:43,670
這本嗎？

315
00:13:43,670 --> 00:13:44,520
否，等等。

316
00:13:44,520 --> 00:13:48,730
然後終於有希望，我會遇到這樣的襪子在這裡。

317
00:13:48,730 --> 00:13:51,350
因此，如果是相同的形狀，大小，把它。

318
00:13:51,350 --> 00:13:53,980
>> 而現在，將是我們下一步的工作嗎？

319
00:13:53,980 --> 00:13:54,402
是嗎？

320
00:13:54,402 --> 00:13:56,090
觀眾：由左，右確定。

321
00:13:56,090 --> 00:13:58,980
DAVID馬蘭：好吧，確定左，右，所以

322
00:13:58,980 --> 00:14:01,870
幸運的是，這樣的作品。

323
00:14:01,870 --> 00:14:04,020
一個小對稱的，或者我只是穿他們的方式。

324
00:14:04,020 --> 00:14:07,020
好了，所以我已經確定了正確的。

325
00:14:07,020 --> 00:14:09,980
而現在，在我們繼續之前，請讓我指出約瑟夫

326
00:14:09,980 --> 00:14:12,890
在這裡做一個精通編程的排序。

327
00:14:12,890 --> 00:14:15,800
所以，再一次，有沒有人這樣做的方式，但除此之外，

328
00:14:15,800 --> 00:14:18,480
編號的線路，約瑟夫已經開始這樣做，

329
00:14:18,480 --> 00:14:19,460
排序縮進。

330
00:14:19,460 --> 00:14:21,950
事實上，這是一個非常常見的編程慣例，

331
00:14:21,950 --> 00:14:26,110
據此，當你做一些反复，循環的風格，

332
00:14:26,110 --> 00:14:28,480
我們的英文短語“對於每一個暗示

333
00:14:28,480 --> 00:14:31,090
襪子“，該公約在偽代碼中，我們會看到，

334
00:14:31,090 --> 00:14:33,410
正常的編程語言，是縮進。

335
00:14:33,410 --> 00:14:36,240
命中了幾次空格鍵，按下Tab鍵等，

336
00:14:36,240 --> 00:14:40,660
使嵌套下方的“FOR EACH襪子”是塊

337
00:14:40,660 --> 00:14:43,430
的東西，你需要做的，循環的結果。

338
00:14:43,430 --> 00:14:45,940
因此，所有的輸送語義。

339
00:14:45,940 --> 00:14:48,620
同時，現在的“，如果它是具有相同形狀和大小的，”

340
00:14:48,620 --> 00:14:51,590
事實上，“要”進一步被縮進只是意味著

341
00:14:51,590 --> 00:14:54,370
這是你唯一應該做的，如果這一條件，

342
00:14:54,370 --> 00:14:59,770
在該分支，即岔路口，在事實上也確實如此。

343
00:14:59,770 --> 00:15:02,130
>> 所以，現在在這裡，我們是在第四步，確定左，右。

344
00:15:02,130 --> 00:15:03,410
我已經確定。

345
00:15:03,410 --> 00:15:05,150
給我5步。

346
00:15:05,150 --> 00:15:07,880
在技​​術上，我們真的可以調用

347
00:15:07,880 --> 00:15:09,510
的FOR EACH事情 - 

348
00:15:09,510 --> 00:15:11,450
您應該列出所有的行，如果

349
00:15:11,450 --> 00:15:12,190
我們將做到這一點。

350
00:15:12,190 --> 00:15:14,006
約瑟夫：[聽不清]

351
00:15:14,006 --> 00:15:14,610
DAVID MALAN：[聽不清]？

352
00:15:14,610 --> 00:15:16,070
好，好，沒事的，我們將做您的方式。

353
00:15:16,070 --> 00:15:19,590
好了，所以第五步，我們怎麼做正確的襪子？

354
00:15:19,590 --> 00:15:22,310
我們該如何進行下一步，在這裡？

355
00:15:22,310 --> 00:15:22,730
是嗎？

356
00:15:22,730 --> 00:15:24,300
觀眾：抬起右腿。

357
00:15:24,300 --> 00:15:27,100
DAVID馬蘭抬起右腿，好吧。

358
00:15:27,100 --> 00:15:29,330
第六步？

359
00:15:29,330 --> 00:15:30,728
快速。

360
00:15:30,728 --> 00:15:31,202
是啊。

361
00:15:31,202 --> 00:15:33,100
觀眾：找到一個開放的襪子。

362
00:15:33,100 --> 00:15:34,440
DAVID馬蘭：好吧，襪子的開口端。

363
00:15:34,440 --> 00:15:34,840
那麼好。

364
00:15:34,840 --> 00:15:37,180
所以在這裡，說實話，一個非常普遍的本能是

365
00:15:37,180 --> 00:15:39,880
穿上合適的襪子，但同樣是相當模糊的。

366
00:15:39,880 --> 00:15:42,750
除非計算機或人知道到底是什麼意思，

367
00:15:42,750 --> 00:15:45,160
它不會被執行，所以在這裡，我已經

368
00:15:45,160 --> 00:15:46,520
開幕的股票。

369
00:15:46,520 --> 00:15:48,222
第七步？

370
00:15:48,222 --> 00:15:49,700
觀眾：觸摸你的腳趾。

371
00:15:49,700 --> 00:15:51,070
DAVID馬蘭：觸摸腳趾。

372
00:15:51,070 --> 00:15:53,546
好了，現在我們去 - 

373
00:15:53,546 --> 00:15:56,480
好吧，我要在這裡需要一些自由。

374
00:15:56,480 --> 00:15:57,110
謝謝。

375
00:15:57,110 --> 00:15:59,210
第八步？

376
00:15:59,210 --> 00:16:00,060
放在襪子。

377
00:16:00,060 --> 00:16:02,060
好了，現在我認為我們非常接近，幾乎排序的需要

378
00:16:02,060 --> 00:16:03,480
此人在家。

379
00:16:03,480 --> 00:16:05,980
所有的權利，所以這上升。

380
00:16:05,980 --> 00:16:07,950
我會採取一些自由，這是什麼意思，真的。

381
00:16:07,950 --> 00:16:08,920
把襪子。

382
00:16:08,920 --> 00:16:10,853
好了，現在第九步？

383
00:16:10,853 --> 00:16:11,740
觀眾：將腳放下。

384
00:16:11,740 --> 00:16:12,510
DAVID馬蘭：謝謝你。

385
00:16:12,510 --> 00:16:15,610
步驟九，將腳放下，而現在，我們可以重複。

386
00:16:15,610 --> 00:16:19,540
因此推測，我們現在可以進入第10步，說確定

387
00:16:19,540 --> 00:16:21,960
離開襪子，但想必已經做了。

388
00:16:21,960 --> 00:16:24,100
>> 這樣的話，我可以排序的重複這些步驟。

389
00:16:24,100 --> 00:16:25,260
但是，這種迴避的問題。

390
00:16:25,260 --> 00:16:28,100
在此之前，最後一次，我們想重複一些東西，我們

391
00:16:28,100 --> 00:16:30,730
這樣做，是反复，一遍又一遍，

392
00:16:30,730 --> 00:16:32,660
Each循環，可以這麼說。

393
00:16:32,660 --> 00:16:36,420
難道是有意義的使用循環，以同時處理

394
00:16:36,420 --> 00:16:38,470
的左側和右側的襪子？

395
00:16:38,470 --> 00:16:40,460
因為感覺這樣的操作是相當多

396
00:16:40,460 --> 00:16:43,090
相同的，除了一個事實，就是在這裡，一個開始

397
00:16:43,090 --> 00:16:44,850
從這裡開始嗎？

398
00:16:44,850 --> 00:16:47,400
我們循環，或者說我們只是一味地寫入步驟

399
00:16:47,400 --> 00:16:48,745
10和11和12？

400
00:16:48,745 --> 00:16:50,540
觀眾：循環。

401
00:16:50,540 --> 00:16:52,240
>> DAVID馬蘭：好吧，如此循環。

402
00:16:52,240 --> 00:16:54,730
其實，我可能會說，只要繼續前進。

403
00:16:54,730 --> 00:16:55,720
那麼，為什麼出現這樣的情況呢？

404
00:16:55,720 --> 00:16:57,940
那麼，這實際上是第一個非明顯

405
00:16:57,940 --> 00:17:01,210
設計決定，而事實上，其中的度量之一

406
00:17:01,210 --> 00:17:03,990
我們將開始評估，為自己和你，

407
00:17:03,990 --> 00:17:06,780
是如何精心設計的，它是一個程序的質量。

408
00:17:06,780 --> 00:17:09,619
你做了最少量的必要工作，

409
00:17:09,619 --> 00:17:12,480
完成這項工作的最迅速，無論是在條款的

410
00:17:12,480 --> 00:17:15,430
你的時間或在計算機的運行時間？

411
00:17:15,430 --> 00:17:17,589
多少操作的時間才可以執行？

412
00:17:17,589 --> 00:17:20,180
因此，可以說，這是一個機會，一個循環，因為

413
00:17:20,180 --> 00:17:22,829
只要我開始複製和粘貼，正如約瑟有效

414
00:17:22,829 --> 00:17:25,010
在某一時刻開始做，你是種浪費你的

415
00:17:25,010 --> 00:17:27,140
時間，你是雙重的表現。

416
00:17:27,140 --> 00:17:30,260
>> 但同時，這些都是真的只是兩個特殊的

417
00:17:30,260 --> 00:17:31,890
的情況下，左，右。

418
00:17:31,890 --> 00:17:34,930
而在此之前，我可能有10個或20個或更多的襪子

419
00:17:34,930 --> 00:17:37,960
一堆，但它肯定是有道理的有50行

420
00:17:37,960 --> 00:17:40,180
代碼說檢查襪子，然後下一個，

421
00:17:40,180 --> 00:17:41,300
然後下一個。

422
00:17:41,300 --> 00:17:43,450
在這裡，這是一個不太明顯的一點，我會提出

423
00:17:43,450 --> 00:17:44,390
我們可以去任何一種方式。

424
00:17:44,390 --> 00:17:46,720
我們既可以有該循環中，儘管它只是循環

425
00:17:46,720 --> 00:17:50,620
兩次，或者我們可以簡單地複製和粘貼只是一點點

426
00:17:50,620 --> 00:17:53,270
在這裡，以獲得完成工作。

427
00:17:53,270 --> 00:17:55,210
但這種方案是不穩定的，可以這麼說。

428
00:17:55,210 --> 00:17:59,120
所以它可能有一些失誤，錯誤或角落的情況下，

429
00:17:59,120 --> 00:18:00,860
講，我們並沒有真正預期。

430
00:18:00,860 --> 00:18:03,400
沒事就去錯了時間，但什麼可能出錯

431
00:18:03,400 --> 00:18:06,100
在執行這個程序？

432
00:18:06,100 --> 00:18:07,040
觀眾：你沒有任何的襪子。

433
00:18:07,040 --> 00:18:08,980
>> DAVID馬蘭：那麼，有可能是沒有襪子有任何責任。

434
00:18:08,980 --> 00:18:10,380
因此，讓我們來看看，角落的情況。

435
00:18:10,380 --> 00:18:14,670
因此，如果我們可以滾動返回到步驟1，步驟1是

436
00:18:14,670 --> 00:18:16,540
向下彎曲，使檢查出來。

437
00:18:16,540 --> 00:18:21,250
第二步，拿起你的襪子，然後找到匹配的襪子，

438
00:18:21,250 --> 00:18:22,420
確定正確的。

439
00:18:22,420 --> 00:18:25,050
樣的，我們做了一大堆的假設，這就是，

440
00:18:25,050 --> 00:18:27,720
坦率地說，為什麼程序有時會崩潰。

441
00:18:27,720 --> 00:18:30,240
如果你作為程序員，取得了一定的假設，如

442
00:18:30,240 --> 00:18:33,000
一定要襪子肯定有去

443
00:18:33,000 --> 00:18:35,310
留在電腦中的內存，當然有是怎麼回事

444
00:18:35,310 --> 00:18:37,420
硬盤驅動器上的磁盤剩餘空間 - 

445
00:18:37,420 --> 00:18:39,040
好吧，如果你讓這些假設，那就是不，

446
00:18:39,040 --> 00:18:41,880
其實，現實，誰知道有時什麼電腦

447
00:18:41,880 --> 00:18:42,520
怎麼辦呢？

448
00:18:42,520 --> 00:18:44,450
有時，當你得到的紡紗沙灘球或

449
00:18:44,450 --> 00:18:47,750
冷凍Windows或等，正是因為一些

450
00:18:47,750 --> 00:18:50,980
程序員沒有預料到那些所謂的角落的情況下。

451
00:18:50,980 --> 00:18:53,050
還有什麼能已經錯了這個項目？

452
00:18:53,050 --> 00:18:53,330
是嗎？

453
00:18:53,330 --> 00:18:55,950
>> 觀眾：你沒有右腿和左腿。

454
00:18:55,950 --> 00:18:58,920
DAVID馬蘭：好吧，可能沒有一個正確的腿和

455
00:18:58,920 --> 00:19:01,940
左腿，因此這個方案可能不會成為普遍

456
00:19:01,940 --> 00:19:02,590
適用。

457
00:19:02,590 --> 00:19:03,658
其他人嗎？

458
00:19:03,658 --> 00:19:05,650
觀眾：你可能已經拿起一個孤兒的襪子。

459
00:19:05,650 --> 00:19:07,970
DAVID馬蘭：我可能會紛紛拿起一個孤兒的襪子，所以

460
00:19:07,970 --> 00:19:11,250
不匹配的襪子，有沒有兄弟姐妹，因為我已​​經

461
00:19:11,250 --> 00:19:13,650
失去了它，它的撕裂，這是在洗，或等。

462
00:19:13,650 --> 00:19:15,550
這樣，也沒有真正被處理。

463
00:19:15,550 --> 00:19:15,790
是嗎？

464
00:19:15,790 --> 00:19:17,510
觀眾：你可能已經有襪子。

465
00:19:17,510 --> 00:19:19,050
DAVID馬蘭：我可能已經有襪子。

466
00:19:19,050 --> 00:19:20,080
我其實沒有檢查。

467
00:19:20,080 --> 00:19:23,350
如果您沒有襪子，然後繼續做

468
00:19:23,350 --> 00:19:24,330
線1和2。

469
00:19:24,330 --> 00:19:24,980
而這可能發生。

470
00:19:24,980 --> 00:19:26,880
你睡著了你的襪子和喜歡，所以

471
00:19:26,880 --> 00:19:28,860
這件事情，是非常合理的角落的情況。

472
00:19:28,860 --> 00:19:29,630
或許有其他嗎？

473
00:19:29,630 --> 00:19:31,310
觀眾：襪子裡面。

474
00:19:31,310 --> 00:19:34,000
DAVID馬蘭：那麼襪子裡面，所以我們也沒有錯誤

475
00:19:34,000 --> 00:19:35,330
檢查，在短。

476
00:19:35,330 --> 00:19:38,550
我們沒有檢查，如果國家的世界是我們期望的。

477
00:19:38,550 --> 00:19:41,310
如果我們真的找到了我們要找的，我們沒有檢查。

478
00:19:41,310 --> 00:19:43,310
>> 儘管這是一個荒謬的例子

479
00:19:43,310 --> 00:19:46,110
涉及的襪子，在一天結束的時候，這正是

480
00:19:46,110 --> 00:19:48,740
樣的心態，你需要有編寫程序時，

481
00:19:48,740 --> 00:19:51,740
即使在Scratch以及在C，在JavaScript中，在PHP中，

482
00:19:51,740 --> 00:19:53,920
因為否則，你的程序將展出

483
00:19:53,920 --> 00:19:56,980
相當於，紡紗沙灘球或產生

484
00:19:56,980 --> 00:19:58,210
結果不準確。

485
00:19:58,210 --> 00:20:00,250
因此，許多的感謝我們的抄寫員約瑟夫。

486
00:20:00,250 --> 00:20:05,060
[掌聲]

487
00:20:05,060 --> 00:20:06,850
>> DAVID馬蘭：好，那麼是什麼，

488
00:20:06,850 --> 00:20:08,230
事實上，計算機程序？

489
00:20:08,230 --> 00:20:09,670
好了，讓我們快速瀏覽一個

490
00:20:09,670 --> 00:20:11,100
代表在這裡。

491
00:20:11,100 --> 00:20:15,260
所以這是一個在語言編寫的程序稱為C，C是

492
00:20:15,260 --> 00:20:17,830
很老的這些天，但許多新的語言建

493
00:20:17,830 --> 00:20:18,460
在它的上面。

494
00:20:18,460 --> 00:20:21,180
事實上，PHP，一個以網絡為中心的語言，我們會

495
00:20:21,180 --> 00:20:24,050
向學期的結束，本身就具有所謂的一個

496
00:20:24,050 --> 00:20:27,550
解釋器，程序，C語言編寫的，但更多的

497
00:20:27,550 --> 00:20:28,690
在從現在開始的幾個星期。

498
00:20:28,690 --> 00:20:30,840
但這種方案，這是什麼意思寫了

499
00:20:30,840 --> 00:20:32,880
程序，雖然是一個很簡單的一個。

500
00:20:32,880 --> 00:20:35,540
我們這裡有一些相當神秘的語法，但你可以

501
00:20:35,540 --> 00:20:38,340
可能已經猜到了，即使你從來沒有編程之前，

502
00:20:38,340 --> 00:20:39,750
這個程序。

503
00:20:39,750 --> 00:20:43,640
事實上，我不知道printf是什麼，但打印肯定

504
00:20:43,640 --> 00:20:45,700
讓人想起了打印的東西的想法。

505
00:20:45,700 --> 00:20:48,590
所以，是的，這個方案最終要打印出來

506
00:20:48,590 --> 00:20:50,250
的話：“你好，世界”。

507
00:20:50,250 --> 00:20:53,390
>> 現在，無論你使用的是Mac或PC或Linux計算機上，賠率

508
00:20:53,390 --> 00:20:55,550
是的，至少如果你下載了一些自由

509
00:20:55,550 --> 00:20:58,000
可用的軟件，你可以編寫程序上

510
00:20:58,000 --> 00:21:00,310
自己的筆記本電腦很長一段時間了。

511
00:21:00,310 --> 00:21:03,040
在Mac OS，例如，有這樣的程序稱為

512
00:21:03,040 --> 00:21:05,340
終端配備了一台Mac，這通常是在您的

513
00:21:05,340 --> 00:21:07,550
實用工具“文件夾中，它通常會打開一個黑色的和

514
00:21:07,550 --> 00:21:09,820
白色或類白色與黑色的窗口，在你有一個

515
00:21:09,820 --> 00:21:11,410
提示，你可以鍵入命令。

516
00:21:11,410 --> 00:21:13,060
因此，這其實是讓人聯想起什麼樣的電腦

517
00:21:13,060 --> 00:21:15,100
之前的圖形用戶

518
00:21:15,100 --> 00:21:16,710
接口，圖形用戶界面，走了過來。

519
00:21:16,710 --> 00:21:19,200
現在，在Windows中，有一個類似的機構的形式

520
00:21:19,200 --> 00:21:20,130
在命令提示符下。

521
00:21:20,130 --> 00:21:23,430
>> 但我要在這裡做的是打開了，讓我們說，

522
00:21:23,430 --> 00:21:26,580
文字編輯再次，相同的程序我們使用的

523
00:21:26,580 --> 00:21:28,870
偽代碼剛才，我要繼續前進，並

524
00:21:28,870 --> 00:21:30,080
我寫的第一個程序。

525
00:21:30,080 --> 00:21:34,030
包括stdio.h中，這意味著什麼，INT主

526
00:21:34,030 --> 00:21:36,880
無效，這意味著什麼，然後在中間這裡，

527
00:21:36,880 --> 00:21:40,560
printf的（“你好，世界”）。然後密切的報價，

528
00:21:40,560 --> 00:21:42,340
關閉括號，分號。

529
00:21:42,340 --> 00:21:44,460
現在，我要繼續前進，剛打命令的-S。我要去

530
00:21:44,460 --> 00:21:47,650
繼續前進，保存為hello.c的，所以該公約

531
00:21:47,650 --> 00:21:50,530
C語言編程的世界是文件命名為點C。

532
00:21:50,530 --> 00:21:52,880
我只是把在約翰·哈佛的主目錄，

533
00:21:52,880 --> 00:21:56,370
在這裡，請單擊“保存”，現在我會去到這

534
00:21:56,370 --> 00:21:59,110
終端窗口，這又是這個黑和白的提示

535
00:21:59,110 --> 00:22:00,860
我在哪裡可以執行命令。

536
00:22:00,860 --> 00:22:04,550
>> 我可以運行程序輸入他們的名字，而不是由

537
00:22:04,550 --> 00:22:06,710
在通常意義上雙擊圖標。

538
00:22:06,710 --> 00:22:10,590
但是，事情是關於C是一門語言，如C第一

539
00:22:10,590 --> 00:22:13,150
這種形式，一些所謂的源代碼。

540
00:22:13,150 --> 00:22:15,400
的東西，看起來有點像英語，但

541
00:22:15,400 --> 00:22:17,980
絕對不喜歡英語約瑟夫的偽一

542
00:22:17,980 --> 00:22:18,930
剛才。

543
00:22:18,930 --> 00:22:20,560
這是多了幾分神秘的。

544
00:22:20,560 --> 00:22:22,830
它似乎遵循一定的模式或規則。

545
00:22:22,830 --> 00:22:25,300
事實上，我花括號，分號，引號，

546
00:22:25,300 --> 00:22:28,240
尖括號，給人的感覺就像一台計算機想出了這個

547
00:22:28,240 --> 00:22:29,250
類的語言。

548
00:22:29,250 --> 00:22:32,010
但是，如果我走了，現在，這個終端窗口，我可以運行

549
00:22:32,010 --> 00:22:35,250
命令要轉換的源代碼

550
00:22:35,250 --> 00:22:36,610
一些所謂的目標代碼。

551
00:22:36,610 --> 00:22:39,690
這是要轉換到零的類似英語的語法

552
00:22:39,690 --> 00:22:41,760
的，同樣類型的零和的，我們

553
00:22:41,760 --> 00:22:42,820
談到週三。

554
00:22:42,820 --> 00:22:44,810
現在，我要運行一個命令叫鐺。

555
00:22:44,810 --> 00:22:47,750
在這個問題上的幾個星期來，但它是一個程序，

556
00:22:47,750 --> 00:22:52,330
我可以把hello.c的成一大堆

557
00:22:52,330 --> 00:22:53,640
0和1。

558
00:22:53,640 --> 00:22:54,950
>> 現在，我已經運行此命令。

559
00:22:54,950 --> 00:22:57,940
我已經運行鐺，然後我說自己對這個文件運行

560
00:22:57,940 --> 00:23:00,630
名為hello.c的，這是我剛才的

561
00:23:00,630 --> 00:23:02,090
似乎什麼都沒有發生。

562
00:23:02,090 --> 00:23:05,550
不過說實在的，如果我周圍戳我的主目錄，我會看到

563
00:23:05,550 --> 00:23:09,620
這愚蠢的命名程序a.out，現在存在的。

564
00:23:09,620 --> 00:23:12,250
在寫作時，這僅僅是一個程序的默認名稱

565
00:23:12,250 --> 00:23:15,140
我們可以覆蓋這個最終的，但a.out是

566
00:23:15,140 --> 00:23:18,340
該程序的名稱，我只是轉換成零和一。

567
00:23:18,340 --> 00:23:21,490
而現在，它的零和一，我的Mac，在這種情況下，或

568
00:23:21,490 --> 00:23:24,670
您的Windows的PC，可以理解的位，這些

569
00:23:24,670 --> 00:23:25,410
0和1。

570
00:23:25,410 --> 00:23:29,130
因此，當我按下回車鍵，我看到“你好，世界！”

571
00:23:29,130 --> 00:23:31,270
>> 但是，這是一個有點馬車。

572
00:23:31,270 --> 00:23:34,110
我沒太說：“你好，世界！：空氣： -  jharvard。”空氣是

573
00:23:34,110 --> 00:23:35,020
我的電腦的名稱。

574
00:23:35,020 --> 00:23:37,730
Jharvard的帳戶名稱，所以什麼我很清楚

575
00:23:37,730 --> 00:23:41,070
省略的程序？

576
00:23:41,070 --> 00:23:42,480
一些種換行。

577
00:23:42,480 --> 00:23:45,150
我沒有打相當於Enter鍵或回車，

578
00:23:45,150 --> 00:23:47,760
這是，再次證明了一個事實，即計算機可以

579
00:23:47,760 --> 00:23:49,800
只有你告訴他們做什麼。

580
00:23:49,800 --> 00:23:52,400
而事實上，我並沒有告訴電腦移動

581
00:23:52,400 --> 00:23:53,860
光標移動到下一行 - 

582
00:23:53,860 --> 00:23:55,200
好了，它肯定不是要做到這一點

583
00:23:55,200 --> 00:23:56,750
擅自對我來說。

584
00:23:56,750 --> 00:24:00,860
所以，如果我回到我的程序，和我說\ n  - 

585
00:24:00,860 --> 00:24:03,180
因此，\ n，我們很快就會看到，就是這樣，

586
00:24:03,180 --> 00:24:06,910
奇怪的事情，比如新行字符，事情

587
00:24:06,910 --> 00:24:08,840
的結果，否則將

588
00:24:08,840 --> 00:24:09,940
打回車鍵。

589
00:24:09,940 --> 00:24:11,730
但現在，只知道打的回車鍵

590
00:24:11,730 --> 00:24:14,170
只是讓我們的代碼看起來很奇怪，所以決定世界，你知道

591
00:24:14,170 --> 00:24:16,580
什麼，讓事情變得更漂亮，保持在同一行，讓我們

592
00:24:16,580 --> 00:24:19,070
只是說，\ n表示一個新行。

593
00:24:19,070 --> 00:24:22,260
讓我重新保存文件，返回到終端窗口，

594
00:24:22,260 --> 00:24:25,290
重新運行a.out，回車。

595
00:24:25,290 --> 00:24:28,374
還是不穩定的，但為什麼呢？

596
00:24:28,374 --> 00:24:29,750
>> 觀眾：[聽不清]

597
00:24:29,750 --> 00:24:31,540
馬蘭DAVID：是啊，所以我需要重新編譯內核。

598
00:24:31,540 --> 00:24:34,610
因此，編譯程序將其從源

599
00:24:34,610 --> 00:24:37,660
代碼到目標代碼，源代碼，零和的。

600
00:24:37,660 --> 00:24:40,830
現在，這一事實，我打這個文字編輯保存在

601
00:24:40,830 --> 00:24:43,450
這些零和的，因為我首先需要

602
00:24:43,450 --> 00:24:48,260
告訴鐺哎，我已經改變了這些代碼行，

603
00:24:48,260 --> 00:24:49,040
源代碼。

604
00:24:49,040 --> 00:24:51,010
您需要重新生成的a.out。

605
00:24:51,010 --> 00:24:52,990
什麼也沒有發生，但在一台電腦，

606
00:24:52,990 --> 00:24:55,820
在命令行，可以這麼說，當什麼也沒發生，

607
00:24:55,820 --> 00:24:57,510
這通常意味著一切都很好。

608
00:24:57,510 --> 00:24:59,040
這意味著，當任何事情發生，

609
00:24:59,040 --> 00:25:00,420
你搞砸了，一般。

610
00:25:00,420 --> 00:25:04,020
>> 現在讓我們去a.out的，而事實上，我現在有“你好，

611
00:25:04,020 --> 00:25:04,440
世界“。

612
00:25:04,440 --> 00:25:05,990
而現在，這些零和的嗎？

613
00:25:05,990 --> 00:25:07,520
在哪裡，其實有那些？

614
00:25:07,520 --> 00:25:10,710
好了，我真的不能只是打個招呼周圍很

615
00:25:10,710 --> 00:25:11,210
有效。

616
00:25:11,210 --> 00:25:12,650
讓我打開文字編輯。

617
00:25:12,650 --> 00:25:14,060
這裡的a.out格式。

618
00:25:14,060 --> 00:25:17,390
讓我先打開，這顯然是我的

619
00:25:17,390 --> 00:25:19,080
程序的外觀。

620
00:25:19,080 --> 00:25:21,570
所以，我打開了，不hello.c的，但a.out的。

621
00:25:21,570 --> 00:25:23,960
但是，這實際上是不是真的是我的計劃。

622
00:25:23,960 --> 00:25:26,450
顯然，這是某種形式的字母字符。

623
00:25:26,450 --> 00:25:28,670
我沒有看到零和的，但這是

624
00:25:28,670 --> 00:25:30,780
因為a.out是一個程序。

625
00:25:30,780 --> 00:25:33,540
零和的 - 但文字編輯，顧名思義，它是

626
00:25:33,540 --> 00:25:37,130
就像在Windows的“記事本”，僅僅是一個文本編輯器，所以它的

627
00:25:37,130 --> 00:25:39,730
混淆所有的這些零和的

628
00:25:39,730 --> 00:25:41,870
雖然他們是什麼？

629
00:25:41,870 --> 00:25:43,380
ASCII字符。

630
00:25:43,380 --> 00:25:45,020
>> 所以，記得上週三，我們只是想出了這個

631
00:25:45,020 --> 00:25:48,740
任意映射的數字，或位，字母

632
00:25:48,740 --> 00:25:51,690
字母和標點符號等。

633
00:25:51,690 --> 00:25:54,920
所以，它是一個文本編輯器的文字編輯，曲解

634
00:25:54,920 --> 00:25:57,270
這些模式應該是零和一

635
00:25:57,270 --> 00:25:59,990
印刷的話，如“你好，世界”。它顯示

636
00:25:59,990 --> 00:26:02,150
ASCII，這就是為什麼它看起來有點亂。

637
00:26:02,150 --> 00:26:04,910
現在，在這裡有一些提示的正確性。

638
00:26:04,910 --> 00:26:08,090
請注意，如果我突出，有一種淡淡的實際“你好，

639
00:26:08,090 --> 00:26:10,810
世界“，所以在該程序中的某個地方

640
00:26:10,810 --> 00:26:12,120
我寫了一句。

641
00:26:12,120 --> 00:26:14,610
但是，讓我們繼續前進，現在看到一個不同的程序。

642
00:26:14,610 --> 00:26:17,420
這是不是我們會經常使用它，但它也與

643
00:26:17,420 --> 00:26:19,970
一台Mac，將裡面的CS50設備。

644
00:26:19,970 --> 00:26:23,940
讓我先打開一個程序，稱為XXD。

645
00:26:23,940 --> 00:26:26,530
>> 早在一天，大多數程序被命名為相當神秘，

646
00:26:26,530 --> 00:26:28,200
這樣的趨勢仍在繼續。

647
00:26:28,200 --> 00:26:31,160
但是，b表示為二進制吐這項計劃。

648
00:26:31,160 --> 00:26:32,330
不要運行它。

649
00:26:32,330 --> 00:26:35,770
顯示我作為零和的，這是C

650
00:26:35,770 --> 00:26:37,190
節目中，我們只寫了。

651
00:26:37,190 --> 00:26:39,920
現在，我一個人在這裡，我真的不知道是什麼

652
00:26:39,920 --> 00:26:42,230
這些不同的模式，零和的代表。

653
00:26:42,230 --> 00:26:45,320
早在一天，我與我的打孔卡或類似的，

654
00:26:45,320 --> 00:26:48,080
其實看一下這些不同的模式

655
00:26:48,080 --> 00:26:51,560
01111000，實際上代表。

656
00:26:51,560 --> 00:26:54,390
更糟糕的是，我需要做的沖​​孔或創造

657
00:26:54,390 --> 00:26:56,130
這些模式的零和一。

658
00:26:56,130 --> 00:27:00,410
但現在，信仰，CPU，英特爾在裡面，所以

659
00:27:00,410 --> 00:27:03,440
說，我們的電腦裡面的這些天，知道

660
00:27:03,440 --> 00:27:05,100
如何解釋這些零和一。

661
00:27:05,100 --> 00:27:07,010
一些零和的意思是打印的。

662
00:27:07,010 --> 00:27:09,040
一些零和一的意思是播放聲音。

663
00:27:09,040 --> 00:27:13,630
一些0和1的意思是接受用戶輸入的鍵盤。

664
00:27:13,630 --> 00:27:15,960
有各種不同的模式，但我們幸運的是，

665
00:27:15,960 --> 00:27:19,680
作為人類，一般只需要擔心編程

666
00:27:19,680 --> 00:27:21,270
這個相當高的水平。

667
00:27:21,270 --> 00:27:24,320
和其他CS類，你可以深入陷，並期待

668
00:27:24,320 --> 00:27:26,820
在這些零和一類的東西，或尚未

669
00:27:26,820 --> 00:27:28,000
還是其他的東西。

670
00:27:28,000 --> 00:27:29,210
>> 現在讓我們將這個。

671
00:27:29,210 --> 00:27:32,550
讓我們非常迅速地從C和移動的東西

672
00:27:32,550 --> 00:27:36,390
更令人欣慰的一點，多了幾分令人興奮的，因為

673
00:27:36,390 --> 00:27:39,340
我們可以回到我們的動畫和聲音，在這樣的

674
00:27:39,340 --> 00:27:40,940
顯然已經逃脫了，我們在這

675
00:27:40,940 --> 00:27:42,480
相當原始的接口。

676
00:27:42,480 --> 00:27:46,430
因此，這可以表示，現在在同樣的程序在C

677
00:27:46,430 --> 00:27:50,060
編程語言刮如下。

678
00:27:50,060 --> 00:27:54,230
這是相當於這個Hello World程序編寫

679
00:27:54,230 --> 00:27:57,370
這一塊拼圖式的語言，稱為划痕。

680
00:27:57,370 --> 00:28:00,600
所以，讓我繼續前進，打開了這個程序。

681
00:28:00,600 --> 00:28:01,850
它再次從頭開始。

682
00:28:01,850 --> 00:28:03,880
它是免費提供的，這是同樣的事情，我們

683
00:28:03,880 --> 00:28:05,120
從今天開始。

684
00:28:05,120 --> 00:28:07,790
>> 所以在這裡從頭開始，和它分成幾個

685
00:28:07,790 --> 00:28:09,700
不同的部分。

686
00:28:09,700 --> 00:28:12,690
在最頂端的權利，我們有所謂的階段，

687
00:28:12,690 --> 00:28:13,670
的確，這就是餅乾

688
00:28:13,670 --> 00:28:15,440
只是有點前執行。

689
00:28:15,440 --> 00:28:19,660
舞台上的東西叫精靈，人物，或

690
00:28:19,660 --> 00:28:21,030
對象，或實體。

691
00:28:21,030 --> 00:28:23,320
這其實並不重要，你是怎麼想的，但他們

692
00:28:23,320 --> 00:28:26,740
是可編程的，可移動的東西，並在這種情況下，這

693
00:28:26,740 --> 00:28:30,730
我們的學生寫的程序，有一對夫婦的薑餅

694
00:28:30,730 --> 00:28:32,990
餅乾，一對夫婦的圓形餅乾，一大堆

695
00:28:32,990 --> 00:28:35,430
心，一​​大堆的眼鏡。

696
00:28:38,170 --> 00:28:42,420
因為這一點，他或她能夠編程每個人

697
00:28:42,420 --> 00:28:44,720
單個字符分開。

698
00:28:44,720 --> 00:28:46,480
>> 現在，這是什麼意思編寫這些人物呢？

699
00:28:46,480 --> 00:28:49,440
那麼，讓我繼續前進，點擊此左手餅乾

700
00:28:49,440 --> 00:28:51,830
滾動到左上角。

701
00:28:51,830 --> 00:28:53,670
現在我的屏幕的左上角是

702
00:28:53,670 --> 00:28:55,280
所謂的腳本區域。

703
00:28:55,280 --> 00:28:58,790
這是一個空白的石板上，最初，我可以

704
00:28:58,790 --> 00:29:01,540
拖放，坦率地說，這樣做的拼圖

705
00:29:01,540 --> 00:29:03,020
正是他們在說什麼。

706
00:29:03,020 --> 00:29:05,820
在拼圖這個堆棧的頂部是字

707
00:29:05,820 --> 00:29:09,340
當綠旗時，如果你沒有注意到的，

708
00:29:09,340 --> 00:29:12,300
該cookie歌曲的方式，我開始點擊，從字面上看，

709
00:29:12,300 --> 00:29:13,320
綠色標誌。

710
00:29:13,320 --> 00:29:16,590
所以，在左上角的一塊拼圖，是指當

711
00:29:16,590 --> 00:29:19,780
人點擊綠色標誌，繼續做

712
00:29:19,780 --> 00:29:21,110
下面的東西。

713
00:29:21,110 --> 00:29:23,330
>> 現在，他們的cookie繼續做嗎？

714
00:29:23,330 --> 00:29:25,810
我真的不知道如何解釋這一點，但

715
00:29:25,810 --> 00:29:29,220
操作部份顯然其凹槽設置到零，然後，它等待

716
00:29:29,220 --> 00:29:31,740
三秒鐘，然後它改變其組為1，那麼它

717
00:29:31,740 --> 00:29:33,590
等待一秒鐘，然後它改變了它

718
00:29:33,590 --> 00:29:35,100
槽減少到一個。

719
00:29:35,100 --> 00:29:37,373
然後，這實際上看起來像一個位的錯誤，不應該

720
00:29:37,373 --> 00:29:39,440
必須改變其槽一遍又一遍，除非它是

721
00:29:39,440 --> 00:29:43,380
其他地方被改變，但這一系列的步驟是什麼

722
00:29:43,380 --> 00:29:46,800
口述這個特定的cookie的行為。

723
00:29:46,800 --> 00:29:49,180
因此，讓我們實際向後滾動，而不是看的東西

724
00:29:49,180 --> 00:29:50,430
這麼複雜。

725
00:29:50,430 --> 00:29:52,260
讓我繼續前進，去到文件，新建，

726
00:29:52,260 --> 00:29:53,560
並得到一個乾淨的石板。

727
00:29:53,560 --> 00:29:56,590
>> 所以現在，我確實有一個空的腳本區域，空蕩盪的舞台，

728
00:29:56,590 --> 00:29:59,380
我們默認的精靈划痕，並在左上角

729
00:29:59,380 --> 00:30:01,670
在我的屏幕上我有他們所有的托盤

730
00:30:01,670 --> 00:30:03,400
可用的拼圖。

731
00:30:03,400 --> 00:30:06,300
我們不會通過，這些東西很多

732
00:30:06,300 --> 00:30:09,470
再次，因為今天，大多數是不言自明的，但我們會

733
00:30:09,470 --> 00:30:12,370
嘗試對其進行分類，並指出的相似

734
00:30:12,370 --> 00:30:15,380
這些未來的語言，我們將潛水。

735
00:30:15,380 --> 00:30:19,180
在左上角是第一次當綠旗點擊，

736
00:30:19,180 --> 00:30:22,170
所以讓我拖在這裡，放大了一下。

737
00:30:22,170 --> 00:30:25,780
如果我點擊綠色旗幟，沒有什麼發生，因為

738
00:30:25,780 --> 00:30:29,360
我，不附加任何邏輯，任何聲明說，以

739
00:30:29,360 --> 00:30:31,040
，綠色的標誌，所以讓我上去的

740
00:30:31,040 --> 00:30:32,500
在這裡類別。

741
00:30:32,500 --> 00:30:34,840
我目前在控制類。

742
00:30:34,840 --> 00:30:37,630
相反，我會去色類，

743
00:30:37,630 --> 00:30:39,970
這裡有一大堆的東西，說的說，

744
00:30:39,970 --> 00:30:43,110
認為，改變顏色，交換機服裝。

745
00:30:43,110 --> 00:30:44,860
>> 所以，你可以做愚蠢的事情的服裝，

746
00:30:44,860 --> 00:30:45,870
聲音和等。

747
00:30:45,870 --> 00:30:49,970
讓我繼續前進，只是說，說了，現在看到我拖

748
00:30:49,970 --> 00:30:52,940
刪除這一塊拼圖，它會要鎖存

749
00:30:52,940 --> 00:30:55,010
成相應的形狀。

750
00:30:55,010 --> 00:30:58,020
所以，當我去，讓我的鼠標，他們鎖定

751
00:30:58,020 --> 00:31:01,770
在一起，而現在，如果我在這裡，點擊綠色旗幟，

752
00:31:01,770 --> 00:31:05,910
貓其實打個招呼，因為這裡面是什麼

753
00:31:05,910 --> 00:31:06,980
這種白盒。

754
00:31:06,980 --> 00:31:08,900
我們很快就會看到，這是所謂的白盒

755
00:31:08,900 --> 00:31:10,250
參數或參數。

756
00:31:10,250 --> 00:31:12,560
這是一種方法下改變的行為，在這種情況下，一個

757
00:31:12,560 --> 00:31:15,070
一塊拼圖，但如果我想說的就是我說的

758
00:31:15,070 --> 00:31:18,610
之前，打個招呼，世界，我現在可以回去在這裡，

759
00:31:18,610 --> 00:31:21,990
點擊播放“，”你好，世界“是什麼的說。

760
00:31:21,990 --> 00:31:24,340
>> 因此，我們從字面上編程。

761
00:31:24,340 --> 00:31:27,540
這還不是全部，引人注目的一個程序，但至少

762
00:31:27,540 --> 00:31:30,140
這是一個更引人注目的一點東西，看起來，

763
00:31:30,140 --> 00:31:31,300
乍看之下，是這樣的。

764
00:31:31,300 --> 00:31:34,190
我們可以很快地得到更多的表現

765
00:31:34,190 --> 00:31:36,600
因為在Scratch，像在其他語言中，有所有

766
00:31:36,600 --> 00:31:40,010
各種報表，而不是只說或打印的東西，但

767
00:31:40,010 --> 00:31:42,650
你可以做這樣的事情在等待，正如我們剛才看到的

768
00:31:42,650 --> 00:31:44,240
的cookie，一些秒數。

769
00:31:44,240 --> 00:31:46,440
您可以播放聲音在從零開始的環境，

770
00:31:46,440 --> 00:31:49,050
就像你可以在一個正常的計算機程序播放聲音。

771
00:31:49,050 --> 00:31:52,440
您可以檢查被稱為布爾表達式。

772
00:31:52,440 --> 00:31:55,630
所以，現在，讓我們開始添加到我們的工具包的一些術語

773
00:31:55,630 --> 00:31:58,840
例如，約瑟夫和我一樣，實際上涉及到

774
00:31:58,840 --> 00:32:00,080
這裡的襪子。

775
00:32:00,080 --> 00:32:03,040
因此，聲明僅是事實的陳述。

776
00:32:03,040 --> 00:32:04,160
做到這一點。

777
00:32:04,160 --> 00:32:07,370
一個指令的精靈，還是我的人，做一些事情。

778
00:32:07,370 --> 00:32:10,420
布爾表達式是具有價值的東西，

779
00:32:10,420 --> 00:32:14,580
所謂的真值，這是零或一，虛假或

780
00:32:14,580 --> 00:32:17,890
真實的，或關閉，或者是沒有。

781
00:32:17,890 --> 00:32:19,730
你是怎麼想的其實並不重要，但它是一個

782
00:32:19,730 --> 00:32:20,700
二進制狀態。

783
00:32:20,700 --> 00:32:22,610
內特討論在星期三的視頻，

784
00:32:22,610 --> 00:32:23,570
不同的事情。

785
00:32:23,570 --> 00:32:25,740
>> 因此，在Scratch中，布爾表達式發生看

786
00:32:25,740 --> 00:32:28,910
類似這裡這些藍色對象，在這種情況下，問題

787
00:32:28,910 --> 00:32:30,960
標誌意味著你問的問題。

788
00:32:30,960 --> 00:32:34,250
是貓，或精靈，觸摸鼠標嗎？

789
00:32:34,250 --> 00:32:36,580
因此，這僅是一個例子的擦除塊會

790
00:32:36,580 --> 00:32:39,950
讓我們檢查“是”或“否”，是觸摸鼠標

791
00:32:39,950 --> 00:32:40,790
精靈在屏幕上？

792
00:32:40,790 --> 00:32:42,840
而這可能是有用的，如果你真的想要做的事情

793
00:32:42,840 --> 00:32:43,820
用你的鼠標。

794
00:32:43,820 --> 00:32:46,470
除了布爾表達式，我們有事情

795
00:32:46,470 --> 00:32:49,110
就像是按下鼠標，這樣你就可以檢測到該種

796
00:32:49,110 --> 00:32:50,200
的問題以及。

797
00:32:50,200 --> 00:32:52,590
如果你真的想要，我們可以做數學，並有

798
00:32:52,590 --> 00:32:55,170
其實更引人注目的不僅僅是純粹的用途

799
00:32:55,170 --> 00:32:56,400
算術，正如我們將看到的。

800
00:32:56,400 --> 00:32:59,690
偽隨機性，使你的程序似乎認為

801
00:32:59,690 --> 00:33:03,490
或不同的表現，根據一些看似隨機的值，

802
00:33:03,490 --> 00:33:06,610
然後我們有布爾表達式，如喜歡的東西。

803
00:33:06,610 --> 00:33:08,830
所以，如果你真的想要檢查兩個值，我們可以看到在

804
00:33:08,830 --> 00:33:11,110
我們可以從頭開始實際測試，如果這是

805
00:33:11,110 --> 00:33:13,190
，這是真的。

806
00:33:13,190 --> 00:33:15,300
例如，在我的襪子的情況下，我已經在

807
00:33:15,300 --> 00:33:19,045
非常年底提出這樣的問題，如果左襪子是正確的襪子

808
00:33:19,045 --> 00:33:20,610
是，退出。

809
00:33:20,610 --> 00:33:22,710
大功告成的一天，所以這將是一個

810
00:33:22,710 --> 00:33:24,300
是的機會。

811
00:33:24,300 --> 00:33:27,740
>> 因此，讓我們繼續前進，試圖拼湊一些這些加在一起

812
00:33:27,740 --> 00:33:31,570
進入一對夫婦的例子

813
00:33:31,570 --> 00:33:32,610
引人注目的不是這一個。

814
00:33:32,610 --> 00:33:35,770
因此，讓我繼續在這裡和開放的一些例子

815
00:33:35,770 --> 00:33:38,350
，將永遠是課程的網站上，並

816
00:33:38,350 --> 00:33:39,870
打開hello2。

817
00:33:39,870 --> 00:33:42,910
因此，在hello2在這裡，我們有一個程序，做了幾

818
00:33:42,910 --> 00:33:46,290
的東西，但它不這樣做，因為我們可能一樣有效。

819
00:33:46,290 --> 00:33:48,900
所以在這裡它說：“你好，世界”一秒鐘，然後等待

820
00:33:48,900 --> 00:33:49,450
一秒鐘。

821
00:33:49,450 --> 00:33:51,720
然後它再次，然後它再次。

822
00:33:51,720 --> 00:33:55,530
所以，如果我點擊綠色旗幟，划痕說：“你好，世界。

823
00:33:55,530 --> 00:33:57,160
你好，世界。

824
00:33:57,160 --> 00:34:00,080
你好，世界“。而這顯然是候選人現在

825
00:34:00,080 --> 00:34:00,860
改善。

826
00:34:00,860 --> 00:34:03,070
>> 什麼是邊際改善，希望我們能

827
00:34:03,070 --> 00:34:07,610
現在，如果SCRATCH支持的概念嗎？

828
00:34:07,610 --> 00:34:08,310
有些類型的循環。

829
00:34:08,310 --> 00:34:10,960
某種重複，現在，將是很好，所以讓我

830
00:34:10,960 --> 00:34:11,920
實際嘗試。

831
00:34:11,920 --> 00:34:13,870
讓我去移動這。

832
00:34:13,870 --> 00:34:16,449
因此，通知，可以分離塊容易，你可以添加到

833
00:34:16,449 --> 00:34:17,420
將它們連接。

834
00:34:17,420 --> 00:34:20,730
讓我去“控制”下，向下滾動這裡，事實上，

835
00:34:20,730 --> 00:34:24,000
這裡有這樣的一塊拼圖，“重複”和“永遠和

836
00:34:24,000 --> 00:34:24,870
永遠的如果。

837
00:34:24,870 --> 00:34:28,500
所以這是一個以多種方式表達循環結構

838
00:34:28,500 --> 00:34:29,340
在從頭開始。

839
00:34:29,340 --> 00:34:31,730
我可能要在這裡不下去，因為我只

840
00:34:31,730 --> 00:34:34,639
希望這種情況發生了三次，但可能重複。

841
00:34:34,639 --> 00:34:38,449
因此，讓我拖在這裡重複，拖放，

842
00:34:38,449 --> 00:34:42,530
現在不是說：“你好，世界”三個不同的時代，

843
00:34:42,530 --> 00:34:44,230
在這裡，讓我拖這一塊拼圖。

844
00:34:44,230 --> 00:34:46,610
即使它似乎並不適合，該程序是智能

845
00:34:46,610 --> 00:34:48,920
足以實現將增長到填滿，所以它的

846
00:34:48,920 --> 00:34:51,270
形狀的問題，而不是絕對的大小。

847
00:34:51,270 --> 00:34:54,030
讓我改變重複3，現在讓我去

848
00:34:54,030 --> 00:34:56,560
並拖動等待一秒鐘，以及在那裡。

849
00:34:56,560 --> 00:34:59,220
這是怎麼回事以及折斷，所以現在我要拖

850
00:34:59,220 --> 00:35:01,370
這些傢伙在這裡，只是因為我扔掉

851
00:35:01,370 --> 00:35:02,710
不需要他們了。

852
00:35:02,710 --> 00:35:05,920
讓我縮小，點擊綠色旗幟現在，我們有

853
00:35:05,920 --> 00:35:09,600
相同的程序，但我之前預測的，更好的

854
00:35:09,600 --> 00:35:12,200
設計多麼糟糕，因為你能想像這個程序

855
00:35:12,200 --> 00:35:14,410
將得到的，肯定是美觀，如果你有

856
00:35:14,410 --> 00:35:16,640
開始複製和粘貼，複製和粘貼，或

857
00:35:16,640 --> 00:35:20,020
一遍又一遍相同的該死的東西拖放。

858
00:35:20,020 --> 00:35:22,260
>> 現在，簡單地說，打印到屏幕上的東西

859
00:35:22,260 --> 00:35:25,350
屏幕，真正是令人興奮的，所以讓我們打開一個

860
00:35:25,350 --> 00:35:26,580
第三方差在這裡。

861
00:35:26,580 --> 00:35:29,810
而現在，你會看到，這很快就會招人煩 - 

862
00:35:29,810 --> 00:35:30,850
[MEOW]

863
00:35:30,850 --> 00:35:31,940
DAVID馬蘭 - 但它也是一種可愛。

864
00:35:31,940 --> 00:35:35,244
[MEOW]

865
00:35:35,244 --> 00:35:37,460
DAVID馬蘭：好吧，那麼要好，而我們當然可以使用，

866
00:35:37,460 --> 00:35:41,060
同樣的過渡，分塊成一個循環

867
00:35:41,060 --> 00:35:43,520
結構，但讓我們使它更有趣的是。

868
00:35:43,520 --> 00:35:47,480
>> 讓我去進取，不斷開拓的第四個方差在這裡，我在那裡

869
00:35:47,480 --> 00:35:50,020
走一步算一步進一步。

870
00:35:50,020 --> 00:35:54,450
因此，根據這一點，傻雖然這是第一

871
00:35:54,450 --> 00:35:58,530
一目了然，這是什麼程序怎麼辦呢？

872
00:35:58,530 --> 00:35:59,790
這將喵一次。

873
00:35:59,790 --> 00:36:00,160
為什麼呢？

874
00:36:00,160 --> 00:36:03,340
那麼，一個是，據我所知，總是小於2。

875
00:36:03,340 --> 00:36:04,890
這裡有沒有概念的隨機性。

876
00:36:04,890 --> 00:36:07,240
我已經字面上硬編碼的一和二，但是這是一個

877
00:36:07,240 --> 00:36:10,370
例如，現在實際使用的布爾表達式。

878
00:36:10,370 --> 00:36:13,650
就像約瑟夫在他的偽代碼，壓痕IF

879
00:36:13,650 --> 00:36:17,170
你找到匹配的襪子，然後執行以下操作，在這裡，我們有

880
00:36:17,170 --> 00:36:19,750
表達式IF一個是小於兩個THEN  - 

881
00:36:19,750 --> 00:36:21,820
而事實上，我們甚至有一點點縮進，

882
00:36:21,820 --> 00:36:24,480
紫色稍微向右縮進 - 

883
00:36:24,480 --> 00:36:26,600
那麼你要播放聲音喵。

884
00:36:26,600 --> 00:36:30,060
現在，在這種情況下，1始終是小於2，所以這

885
00:36:30,060 --> 00:36:31,970
是種浪費了條件。

886
00:36:31,970 --> 00:36:34,890
但我們，正如我們所看到的，就可以將其他的事情

887
00:36:34,890 --> 00:36:37,420
這些佔位符，其中一，二。

888
00:36:37,420 --> 00:36:41,340
現在讓我們提前到5這幾個例子

889
00:36:41,340 --> 00:36:45,850
打著招呼看看這是什麼程序會做。

890
00:36:45,850 --> 00:36:48,710
>> 所以，現在，在一個英語句子，請問這是

891
00:36:48,710 --> 00:36:51,460
程序的行為呢？

892
00:36:51,460 --> 00:36:52,950
聽眾：貓叫聲一半的時間。

893
00:36:52,950 --> 00:36:55,380
DAVID馬蘭：喵半的時間，所以這是一種

894
00:36:55,380 --> 00:36:56,700
傳達一個非常簡單的想法。

895
00:36:56,700 --> 00:36:59,400
儘管我們碰巧使用這裡的幾個不等式

896
00:36:59,400 --> 00:37:01,860
在一些數字，這真的只是一個程序化

897
00:37:01,860 --> 00:37:09,490
方式，精確的方式，說如果硬幣出現正面的，去

898
00:37:09,490 --> 00:37:10,270
和喵。

899
00:37:10,270 --> 00:37:13,540
或者反過來說，如果硬幣來了尾巴，不喵。

900
00:37:13,540 --> 00:37:15,110
而在這種情況下，怎麼表達呢？

901
00:37:15,110 --> 00:37:17,950
我們將選擇一個隨機數從1到10，如果

902
00:37:17,950 --> 00:37:21,110
數小於6，繼續前進，喵。

903
00:37:21,110 --> 00:37:22,260
這究竟是怎麼進來的？

904
00:37:22,260 --> 00:37:24,620
好了，發現只是拖放和

905
00:37:24,620 --> 00:37:26,190
事情鎖定到位。

906
00:37:26,190 --> 00:37:28,020
>> 所以，現在讓我們來看看如果這種隨機性的工作。

907
00:37:28,020 --> 00:37:29,845
讓我繼續前進，點擊綠色旗幟。

908
00:37:29,845 --> 00:37:31,120
[MEOW]

909
00:37:31,120 --> 00:37:32,000
DAVID馬蘭：好吧。

910
00:37:32,000 --> 00:37:33,430
[MEOW]

911
00:37:33,430 --> 00:37:35,260
DAVID馬蘭：好吧。

912
00:37:35,260 --> 00:37:38,510
好了，好了，所以我們得到了頭，頭，尾，有效。

913
00:37:38,510 --> 00:37:39,295
尾巴。

914
00:37:39,295 --> 00:37:39,590
[MEOW]

915
00:37:39,590 --> 00:37:41,829
DAVID馬蘭頭。

916
00:37:41,829 --> 00:37:43,220
[MEOW]

917
00:37:43,220 --> 00:37:44,040
DAVID馬蘭：非常好。

918
00:37:44,040 --> 00:37:46,220
它總是很尷尬時，只統計你得到一個壞

919
00:37:46,220 --> 00:37:48,510
運行，它的頭，程序實際上是不

920
00:37:48,510 --> 00:37:49,230
工作如你所願。

921
00:37:49,230 --> 00:37:51,210
但是，這一次，它的工作，我們似乎有，如果我們這樣做

922
00:37:51,210 --> 00:37:53,830
這是一個無限的數量的時候，50％的勝算。

923
00:37:53,830 --> 00:37:56,950
再次，現在不是所有的，有趣的，只是使貓

924
00:37:56,950 --> 00:37:59,840
喵喵，讓我們看看如果我們不能進一步推動這一點，

925
00:37:59,840 --> 00:38:01,820
在第六版。

926
00:38:01,820 --> 00:38:05,620
所以，現在，我們有真的很惱人版本 - 

927
00:38:05,620 --> 00:38:08,215
[貓叫聲每隔幾秒鐘]

928
00:38:08,215 --> 00:38:10,640
DAVID馬蘭： - 這是所謂的，一般情況下，作為

929
00:38:10,640 --> 00:38:11,670
無限循環。

930
00:38:11,670 --> 00:38:14,190
>> 如此無限循環，在這種情況下，感覺不錯。

931
00:38:14,190 --> 00:38:16,970
它肯定會開始聽起來壞，但無限

932
00:38:16,970 --> 00:38:18,740
循環並非總是壞事。

933
00:38:18,740 --> 00:38:20,910
你能想到的情況下在計算機程序中在那裡你會

934
00:38:20,910 --> 00:38:22,910
其實想要一個無限循環？

935
00:38:22,910 --> 00:38:23,691
是嗎？

936
00:38:23,691 --> 00:38:26,520
觀眾：當你要檢查的條件。

937
00:38:26,520 --> 00:38:28,240
DAVID馬蘭：好吧，當你要檢查的條件嗎？

938
00:38:28,240 --> 00:38:29,190
像什麼？

939
00:38:29,190 --> 00:38:30,440
觀眾：[聽不清]

940
00:38:36,060 --> 00:38:38,170
DAVID馬蘭：好，好，所以如果你有一些計劃，一些

941
00:38:38,170 --> 00:38:40,440
家庭自動化的事情，你要不斷的種

942
00:38:40,440 --> 00:38:41,980
顯示器是什麼的情況下。

943
00:38:41,980 --> 00:38:42,850
上的燈嗎？

944
00:38:42,850 --> 00:38:45,020
的燈光，因為也許你有一個計時器，

945
00:38:45,020 --> 00:38:47,360
你希望他們去，你可能需要做的事情

946
00:38:47,360 --> 00:38:48,290
一遍又一遍。

947
00:38:48,290 --> 00:38:50,540
言而事實上，定時器，任何人已

948
00:38:50,540 --> 00:38:53,100
您的計算機或數字手錶上的時鐘，這是一個

949
00:38:53,100 --> 00:38:54,210
無限循環。

950
00:38:54,210 --> 00:38:56,980
它的不斷更新的時間，因為它是不斷

951
00:38:56,980 --> 00:38:59,750
檢查和檢查，檢查的時間變化，

952
00:38:59,750 --> 00:39:01,000
如果是這樣，哦，我的上帝。

953
00:39:03,670 --> 00:39:04,740
終於在時鐘的改變。

954
00:39:04,740 --> 00:39:07,020
它需要向您顯示該值。

955
00:39:07,020 --> 00:39:10,880
因此而大多數的時間無限循環的一個錯誤，

956
00:39:10,880 --> 00:39:13,950
或者至少是一個糟糕的設計決定，有時他們

957
00:39:13,950 --> 00:39:14,785
有其價值。

958
00:39:14,785 --> 00:39:18,170
>> 好吧，讓我們，進一步推進這裡hello7。

959
00:39:18,170 --> 00:39:20,410
所以，現在的程序將獲得多一點互動。

960
00:39:20,410 --> 00:39:23,120
讓我在這裡，再次放大，這是很好

961
00:39:23,120 --> 00:39:23,640
關於從頭開始。

962
00:39:23,640 --> 00:39:26,760
我們將用它來清晰，划痕，就在今天和成

963
00:39:26,760 --> 00:39:27,780
下週的設置問題。

964
00:39:27,780 --> 00:39:31,920
但在週一，我們潛入C.在這個程序中，確實如此，

965
00:39:31,920 --> 00:39:33,190
永遠，下面的。

966
00:39:33,190 --> 00:39:35,890
如果觸摸鼠標指針 - 現在，誰是

967
00:39:35,890 --> 00:39:36,420
上下文在這裡？

968
00:39:36,420 --> 00:39:39,670
好了，請注意，誰在底部的選擇

969
00:39:39,670 --> 00:39:43,060
右邊是貓，雪碧，所以這些腳本，這

970
00:39:43,060 --> 00:39:45,720
程序，適用於專門給他。

971
00:39:45,720 --> 00:39:48,950
所以，如果貓接觸的鼠標指針，那麼它會

972
00:39:48,950 --> 00:39:51,350
玩這個下來，等待2秒鐘，和

973
00:39:51,350 --> 00:39:53,030
然後重複廣告nauseum。

974
00:39:53,030 --> 00:39:55,360
>> 所以，讓我們繼續打比賽。

975
00:39:55,360 --> 00:39:57,580
什麼也沒有發生，但如果我想寵

976
00:39:57,580 --> 00:39:59,310
貓現在，我可以簡單的。

977
00:39:59,310 --> 00:40:01,130
[MEOW]

978
00:40:01,130 --> 00:40:02,244
DAVID馬蘭：可愛的。

979
00:40:02,244 --> 00:40:05,956
[MEOW]

980
00:40:05,956 --> 00:40:08,750
DAVID馬蘭：好了，不那麼討厭，但也變得平淡，

981
00:40:08,750 --> 00:40:11,480
所以，讓我們繼續前進，看看如果我們不能注入

982
00:40:11,480 --> 00:40:12,460
多一點邏輯。

983
00:40:12,460 --> 00:40:14,300
這是例7。

984
00:40:14,300 --> 00:40:16,090
>> 在這裡，例如八個，我們要

985
00:40:16,090 --> 00:40:18,670
引入ELSE的條件。

986
00:40:18,670 --> 00:40:21,440
所以很像一個文字的岔路口，你可以去

987
00:40:21,440 --> 00:40:24,260
你可以向左或向右走，在一個編程的條件

988
00:40:24,260 --> 00:40:28,120
語言一樣從頭開始，我們將看到C，可以讓你

989
00:40:28,120 --> 00:40:32,230
通過在一個方向或另一個IF ELSE結構。

990
00:40:32,230 --> 00:40:35,160
因此，毫不誇張地說，如果觸摸鼠標指針，

991
00:40:35,160 --> 00:40:38,680
會玩一些聲音，否則它要玩這個

992
00:40:38,680 --> 00:40:39,800
聲，喵喵。

993
00:40:39,800 --> 00:40:42,510
現在，如果你可以推斷出這些聲音的名稱，你可以

994
00:40:42,510 --> 00:40:45,310
大概已經猜到這個計劃的目的是想起了

995
00:40:45,310 --> 00:40:46,250
的想法。

996
00:40:46,250 --> 00:40:48,742
這貓咪咪聲快樂。

997
00:40:48,742 --> 00:40:49,230
[MEOW]

998
00:40:49,230 --> 00:40:51,410
DAVID馬蘭：令人高興的，但並不

999
00:40:51,410 --> 00:40:52,926
很喜歡被感動。

1000
00:40:52,926 --> 00:40:54,550
[河東獅]

1001
00:40:54,550 --> 00:40:57,500
DAVID馬蘭：所以，現在我們有一隻貓，他們會罵你的。

1002
00:40:57,500 --> 00:41:00,570
>> 好吧，最後一個例子。這裡的貓，和

1003
00:41:00,570 --> 00:41:02,920
讓我們打開這裡的這個版本9。

1004
00:41:02,920 --> 00:41:06,190
所以，現在，我們有一個最惱人的聲音，我可以

1005
00:41:06,190 --> 00:41:11,630
找到，所以我們有一個海象海獅在這裡誰去

1006
00:41:11,630 --> 00:41:13,222
按照下面的方法做。

1007
00:41:13,222 --> 00:41:20,870
[SEAL BARK]

1008
00:41:20,870 --> 00:41:23,310
DAVID馬蘭：好吧，那麼，這將繼續下去，直到你找出如何

1009
00:41:23,310 --> 00:41:24,640
這個程序的工作原理。

1010
00:41:24,640 --> 00:41:28,560
所以這個時候，這種動物有兩個腳本，什麼

1011
00:41:28,560 --> 00:41:31,050
有趣的是，這些腳本將要執行

1012
00:41:31,050 --> 00:41:32,260
平行。

1013
00:41:32,260 --> 00:41:35,340
所以，因為他們都開始一個綠色的標誌點擊，

1014
00:41:35,340 --> 00:41:38,080
像這樣的，這兩個程序開始運行後

1015
00:41:38,080 --> 00:41:41,370
一次，即使他們永遠循環。

1016
00:41:41,370 --> 00:41:44,420
因此，在上面的腳本中，我有一些邏輯。

1017
00:41:44,420 --> 00:41:49,275
什麼功能，提供了嗎？

1018
00:41:49,275 --> 00:41:50,740
[SEAL BARK]

1019
00:41:50,740 --> 00:41:51,670
觀眾：[聽不清]

1020
00:41:51,670 --> 00:41:53,295
DAVID馬蘭：如果它是什麼？

1021
00:41:53,295 --> 00:41:53,760
[SEAL BARK]

1022
00:41:53,760 --> 00:41:55,852
觀眾：如果靜音為零，它要繼續玩

1023
00:41:55,852 --> 00:41:58,410
的聲音。 [SEAL BARK]

1024
00:41:58,410 --> 00:41:58,940
DAVID馬蘭：好，好。

1025
00:41:58,940 --> 00:42:01,960
因此，如果處於靜音狀態，無論是什麼，這個橙色的是零，

1026
00:42:01,960 --> 00:42:05,370
然後播放海獅的聲音，想：“噢，

1027
00:42:05,370 --> 00:42:06,770
嗨，“兩秒鐘。

1028
00:42:06,770 --> 00:42:09,380
現在，我不知道什麼是靜音的，但零讓人想起了

1029
00:42:09,380 --> 00:42:11,230
虛假或關閉的想法。

1030
00:42:11,230 --> 00:42:14,490
因此，如果靜音是假的，所以如果不是靜音，

1031
00:42:14,490 --> 00:42:15,660
播放聲音。

1032
00:42:15,660 --> 00:42:17,350
好吧，怎麼做，我們禁用這個事情呢？

1033
00:42:17,350 --> 00:42:19,310
>> 那麼，讓我們來看看在那裡的第二個腳本。

1034
00:42:19,310 --> 00:42:22,130
第二個腳本設置靜音為零。

1035
00:42:22,130 --> 00:42:25,180
請注意，它也是橙色的，所以什麼划痕是什麼顏色

1036
00:42:25,180 --> 00:42:27,400
在相同的色調塊，如果它的排序

1037
00:42:27,400 --> 00:42:28,850
的邏輯關係。

1038
00:42:28,850 --> 00:42:32,850
因此，正如靜音往上頂是橙色，所以在這裡是靜音

1039
00:42:32,850 --> 00:42:34,060
橙塊中提到的。

1040
00:42:34,060 --> 00:42:36,170
但是，這是一個變量賦值，所以就像在

1041
00:42:36,170 --> 00:42:39,170
代數，您有x，y和z，在編程的

1042
00:42:39,170 --> 00:42:41,440
變量，但他們一般 - 

1043
00:42:41,440 --> 00:42:42,580
讓我們暫停了一會兒，數字如何

1044
00:42:42,580 --> 00:42:44,280
停止亂叫。

1045
00:42:44,280 --> 00:42:45,480
我該怎麼做呢？

1046
00:42:45,480 --> 00:42:46,480
[SEAL BARK]

1047
00:42:46,480 --> 00:42:47,920
DAVID馬蘭：好吧。

1048
00:42:47,920 --> 00:42:49,490
它停了下來。好吧。

1049
00:42:49,490 --> 00:42:52,230
>> 因此，正如在代數你有變量x，y，和z，但在

1050
00:42:52,230 --> 00:42:55,260
編程時，如x，y和z變量一般是

1051
00:42:55,260 --> 00:42:57,330
令人難以接受的，因為他們不是在所有的表現。

1052
00:42:57,330 --> 00:43:00,070
他們沒有任何語義含義，因此，在大多數

1053
00:43:00,070 --> 00:43:02,110
編程語言中，變量可以有充分的

1054
00:43:02,110 --> 00:43:05,270
成熟的名稱或單詞或短語，喜歡靜音，說

1055
00:43:05,270 --> 00:43:06,030
他們做了什麼。

1056
00:43:06,030 --> 00:43:09,380
因此，這第二個腳本也聽，永遠和它說

1057
00:43:09,380 --> 00:43:12,100
如果該鍵，鍵盤的鍵空間，

1058
00:43:12,100 --> 00:43:13,370
按下問號。

1059
00:43:13,370 --> 00:43:16,300
因此，有一個條件，這是一個布爾表達式

1060
00:43:16,300 --> 00:43:19,010
要回答一個問題，無論是真實或虛假的，

1061
00:43:19,010 --> 00:43:22,880
然後我裡面有它，如果按下空格鍵

1062
00:43:22,880 --> 00:43:28,020
如果處於靜音狀態是零，一個設置靜音，否則設置靜音零。

1063
00:43:28,020 --> 00:43:30,510
因此，這岔路口，請注意我是如何

1064
00:43:30,510 --> 00:43:33,500
嵌套的兩個IF條件，是檢查的一種方式是

1065
00:43:33,500 --> 00:43:36,610
按下空格鍵，因為如果是這樣，我可以想去

1066
00:43:36,610 --> 00:43:38,000
這樣或那樣的方式方法。

1067
00:43:38,000 --> 00:43:40,210
我怎麼反轉靜音的價值嗎？

1068
00:43:40,210 --> 00:43:41,410
我要檢查是零嗎？

1069
00:43:41,410 --> 00:43:45,890
如果是這樣，做它一，否則為零，因此切換

1070
00:43:45,890 --> 00:43:47,670
它的兩個國家。

1071
00:43:47,670 --> 00:43:50,030
>> 好，那麼我們有那麼一些這些基本

1072
00:43:50,030 --> 00:43:50,540
結構。

1073
00:43:50,540 --> 00:43:52,810
我們有布爾表達式，並且認識到，太，這是

1074
00:43:52,810 --> 00:43:54,050
不是所有的陌生。

1075
00:43:54,050 --> 00:43:56,730
事實上，這裡有一個快速的哈佛核心課程的CS50的屏幕截圖

1076
00:43:56,730 --> 00:43:59,740
購物工具，任何網站有複選框

1077
00:43:59,740 --> 00:44:02,420
下拉菜單真的，這段時間，一直在使用

1078
00:44:02,420 --> 00:44:03,430
布爾表達式。

1079
00:44:03,430 --> 00:44:05,760
在這種情況下，在這裡，如果您按一下旁邊的複選框

1080
00:44:05,760 --> 00:44:08,620
當然大於或等於4.5，或者相同的旁邊

1081
00:44:08,620 --> 00:44:11,200
教員，你要指定一個布爾表達式。

1082
00:44:11,200 --> 00:44:14,780
我該表達式為true的課程。

1083
00:44:14,780 --> 00:44:17,080
或向右，不與我的課程發生衝突

1084
00:44:17,080 --> 00:44:20,440
服用，如果被檢查，那麼，你要檢查

1085
00:44:20,440 --> 00:44:22,890
該條件，否則你要忽略它。

1086
00:44:22,890 --> 00:44:25,170
因此，布爾表達式是一種周圍的一切，但是當

1087
00:44:25,170 --> 00:44:28,080
我們把他們的條件下，無論是IF條件，IF

1088
00:44:28,080 --> 00:44:30,480
偷別人，或者我們甚至可以模擬更深

1089
00:44:30,480 --> 00:44:32,830
水平，IF ELSE IF ELSE  - 

1090
00:44:32,830 --> 00:44:34,430
因此，這是一種三元狀態。

1091
00:44:34,430 --> 00:44:36,920
你可以去這樣或這樣或這樣。

1092
00:44:36,920 --> 00:44:39,680
我們可以保持嵌套的東西去不同的方向。

1093
00:44:39,680 --> 00:44:41,800
>> 因此，從無到有這些循環，永遠。

1094
00:44:41,800 --> 00:44:44,750
它具有這些功能，如重複10，

1095
00:44:44,750 --> 00:44:46,260
有限的次數。

1096
00:44:46,260 --> 00:44:49,040
現在我們有能力來設置變量，所以在這種情況下，

1097
00:44:49,040 --> 00:44:51,810
我已經聲明，例如，一個變量的所謂的襪子。

1098
00:44:51,810 --> 00:44:54,340
我初始化為0，而另一個方向

1099
00:44:54,340 --> 00:44:56,940
我們可以在這裡與約瑟同在，也許我

1100
00:44:56,940 --> 00:45:00,150
只是跟踪我有多少襪子和終止

1101
00:45:00,150 --> 00:45:03,490
該程序時，該變量的值是2。

1102
00:45:03,490 --> 00:45:05,660
這將是另一種方式的排序，概括，

1103
00:45:05,660 --> 00:45:08,820
的問題，一次又一次地做一些事情。

1104
00:45:08,820 --> 00:45:12,080
好吧，讓我們繼續前進，現在介紹一些新的東西。

1105
00:45:12,080 --> 00:45:14,100
所以，你與以前的編程經驗

1106
00:45:14,100 --> 00:45:17,120
我知道很多語言的數組，向量或

1107
00:45:17,120 --> 00:45:19,970
列表，事實上，從無到有這樣的事情，太。

1108
00:45:19,970 --> 00:45:22,510
因此，讓我們來看看，如果我們不能拿東西到一個新的水平。

1109
00:45:22,510 --> 00:45:24,920
如果我有能力，現在，這些拼圖

1110
00:45:24,920 --> 00:45:29,080
添加東西，如一個詞或數字，一個變量，我可以

1111
00:45:29,080 --> 00:45:30,550
開始積累事情。

1112
00:45:30,550 --> 00:45:33,630
這實際上是相當中肯的東西，如遊戲，

1113
00:45:33,630 --> 00:45:35,810
你走動的角色扮演遊戲

1114
00:45:35,810 --> 00:45:38,600
一些幻想世界中收集的東西，撿東西了，

1115
00:45:38,600 --> 00:45:39,900
收入點，或類似物。

1116
00:45:39,900 --> 00:45:42,310
您可能想要跟踪的某種庫存，

1117
00:45:42,310 --> 00:45:45,180
的確，這就是，我們以前的學生在這裡做

1118
00:45:45,180 --> 00:45:47,750
一些所謂的Fruitcraft RPG。

1119
00:45:47,750 --> 00:45:51,820
>> 因此，讓我去進取，不斷開拓的東西在這裡，並在

1120
00:45:51,820 --> 00:45:56,260
Fruitcraft，我們這個世界的頂端。

1121
00:45:56,260 --> 00:45:58,820
因此，讓我繼續前進，點擊綠色旗幟。

1122
00:45:58,820 --> 00:46:01,040
在左上方的通知是某種形式的庫存。

1123
00:46:01,040 --> 00:46:04,110
這是從頭開始實施，我們會打電話給一個數組或

1124
00:46:04,110 --> 00:46:06,890
的名單，現在我們有這樣的小動畫。

1125
00:46:06,890 --> 00:46:10,440
因此，正如我們起步比較早，這個cookie的愛情故事，

1126
00:46:10,440 --> 00:46:13,320
然後我們先進的貓和海獅，現在我們可以有

1127
00:46:13,320 --> 00:46:15,100
更互動的東西。

1128
00:46:15,100 --> 00:46:18,250
而這個藍色的小傢伙，我就可以開始走動，他的

1129
00:46:18,250 --> 00:46:19,500
這裡的小家。

1130
00:46:19,500 --> 00:46:22,570
因此，它看起來像他有一個出口在這裡，所以我使用

1131
00:46:22,570 --> 00:46:25,260
箭頭鍵，向上，向下，左，右。

1132
00:46:25,260 --> 00:46:28,370
現在我在外面，所以讓就是我來到這裡的。

1133
00:46:28,370 --> 00:46:30,920
看起來像一個橙色的，而事實上，只要我觸摸

1134
00:46:30,920 --> 00:46:33,110
橙色，它就會一屁股到我的庫存。

1135
00:46:33,110 --> 00:46:35,640
如果我走了，這裡的櫻桃，現在我有一些

1136
00:46:35,640 --> 00:46:36,760
其他在我的庫存。

1137
00:46:36,760 --> 00:46:39,100
這是所有漂亮的，可愛的，但想想如何，現在，這

1138
00:46:39,100 --> 00:46:39,840
實施。

1139
00:46:39,840 --> 00:46:42,490
好了，我們有這個概念的名單，而這顯然是一個

1140
00:46:42,490 --> 00:46:45,470
一塊拼圖，你剛才說你想要添加到它，

1141
00:46:45,470 --> 00:46:46,950
橙，櫻桃。

1142
00:46:46,950 --> 00:46:48,540
現在，這是什麼藍色的小傢伙在做什麼？

1143
00:46:48,540 --> 00:46:49,810
那麼，他是一個精靈。

1144
00:46:49,810 --> 00:46:52,190
據推測，橙色和櫻桃 - 

1145
00:46:52,190 --> 00:46:54,140
他們自己單獨的精靈。

1146
00:46:54,140 --> 00:46:56,980
和使用條件的布爾表達式，

1147
00:46:56,980 --> 00:47:00,530
學生可能是能夠表達IF藍色的傢伙，是

1148
00:47:00,530 --> 00:47:04,590
接觸櫻桃，然後添加他的字櫻桃

1149
00:47:04,590 --> 00:47:07,890
庫存，然後也隱藏了櫻花精靈。

1150
00:47:07,890 --> 00:47:10,600
因此，引擎蓋下的，有可能仍然是一個櫻桃

1151
00:47:10,600 --> 00:47:11,350
精靈。

1152
00:47:11,350 --> 00:47:14,160
我們只要告訴它有效地成為無形的。

1153
00:47:14,160 --> 00:47:16,340
>> 現在，如果我繼續走在這裡，我們也可以這樣做

1154
00:47:16,340 --> 00:47:19,150
近端的事情，在那裡我可以去閱讀的標誌。

1155
00:47:19,150 --> 00:47:23,170
因此，如果藍色的傢伙觸摸的標誌，我們可以有這樣的言論塊

1156
00:47:23,170 --> 00:47:26,455
就像貓的話，對我們說話打招呼，所說，“有

1157
00:47:26,455 --> 00:47:26,880
一些水果嗎？

1158
00:47:26,880 --> 00:47:29,290
把它帶到水果的地方。“好吧，那麼現在，顯然，

1159
00:47:29,290 --> 00:47:30,550
我有我的方向。

1160
00:47:30,550 --> 00:47:33,050
我可以去這裡的水果產地，行自己

1161
00:47:33,050 --> 00:47:33,740
與門。

1162
00:47:33,740 --> 00:47:35,390
現在，我在這裡。

1163
00:47:35,390 --> 00:47:38,120
我可以上去的人，在櫃檯上。

1164
00:47:38,120 --> 00:47:40,330
他發現，我敢接近他，所以不必是

1165
00:47:40,330 --> 00:47:46,780
很相同的接觸，我已經贏得了比賽。

1166
00:47:46,780 --> 00:47:49,890
因此，我們有Fruitcraft RPG。

1167
00:47:49,890 --> 00:47:52,200
>> 所以，我們可以做的事情比這更先進。

1168
00:47:52,200 --> 00:47:53,200
我們可以添加聲音。

1169
00:47:53,200 --> 00:47:54,610
我們可以添加的偽隨機性。

1170
00:47:54,610 --> 00:47:56,260
我們可以增加複雜性。

1171
00:47:56,260 --> 00:47:58,490
讓我繼續在這裡，而不是做我自己，

1172
00:47:58,490 --> 00:48:01,240
讓我告訴你一個更複雜的意見書

1173
00:48:01,240 --> 00:48:06,640
我們去年從某一個名為布萊克的人。

1174
00:48:06,640 --> 00:48:08,910
我們有一個志願者出現在舒適

1175
00:48:08,910 --> 00:48:12,600
攝像頭和玩遊戲嗎？

1176
00:48:12,600 --> 00:48:13,450
如何在那裡？

1177
00:48:13,450 --> 00:48:15,380
上來吧。

1178
00:48:15,380 --> 00:48:19,680
所有的權利，因此本場比賽，你剛才在不知不覺中

1179
00:48:19,680 --> 00:48:20,780
主動發揮 - 

1180
00:48:20,780 --> 00:48:25,910
[掌聲]

1181
00:48:25,910 --> 00:48:28,610
DAVID馬蘭： - 從昔日被稱為是

1182
00:48:28,610 --> 00:48:30,100
“青蛙過河”。你叫什麼名字？

1183
00:48:30,100 --> 00:48:30,730
任達：仁達。

1184
00:48:30,730 --> 00:48:31,050
DAVID MALAN：Redna？

1185
00:48:31,050 --> 00:48:32,530
任達：這是布倫達與B。

1186
00:48:32,530 --> 00:48:33,190
DAVID馬蘭：好吧，人大。

1187
00:48:33,190 --> 00:48:33,590
大衛。

1188
00:48:33,590 --> 00:48:34,580
認識你很高興。

1189
00:48:34,580 --> 00:48:38,690
>> 因此，在“青蛙過河”，如果我們能夠提高音量

1190
00:48:38,690 --> 00:48:39,780
一點點，你這小

1191
00:48:39,780 --> 00:48:41,010
綠色青蛙在底部。

1192
00:48:41,010 --> 00:48:43,940
您可以使用左，右，上，下​​，和你的目標是

1193
00:48:43,940 --> 00:48:46,510
橫穿馬路，過河，觸摸睡蓮

1194
00:48:46,510 --> 00:48:47,760
在頂部。

1195
00:48:52,090 --> 00:48:53,440
胡。

1196
00:48:53,440 --> 00:48:54,630
一個T  - 

1197
00:48:54,630 --> 00:48:56,400
重做，好嗎？

1198
00:48:56,400 --> 00:48:58,890
讓我們的命中停止。

1199
00:48:58,890 --> 00:49:00,140
沒有人看見。

1200
00:49:10,470 --> 00:49:12,930
[掌聲]

1201
00:49:17,023 --> 00:49:17,850
[掌聲]

1202
00:49:17,850 --> 00:49:19,341
DAVID馬蘭：是的。

1203
00:49:19,341 --> 00:49:20,832
非常好。

1204
00:49:20,832 --> 00:49:22,082
非常好，謝謝你。

1205
00:49:27,300 --> 00:49:29,430
>> 因此，有青蛙過河。現在，你知道你做了什麼

1206
00:49:29,430 --> 00:49:32,170
得到自己，多了一個不同的志願者

1207
00:49:32,170 --> 00:49:34,910
另一名學生提交的遊戲。

1208
00:49:34,910 --> 00:49:35,560
你要來嗎？

1209
00:49:35,560 --> 00:49:36,576
你叫什麼名字？

1210
00:49:36,576 --> 00:49:37,000
理查德：理查德。

1211
00:49:37,000 --> 00:49:37,420
DAVID馬蘭：理查德。

1212
00:49:37,420 --> 00:49:39,732
好吧，理查德，就到了。

1213
00:49:39,732 --> 00:49:42,187
[掌聲]

1214
00:49:45,140 --> 00:49:47,030
DAVID馬蘭：你有什麼話聽起來就會很

1215
00:49:47,030 --> 00:49:54,180
熟悉的很快，所以這裡是你的指示。

1216
00:49:54,180 --> 00:49:56,580
因此，在某一時刻，一些拼圖碎片會向上滾動

1217
00:49:56,580 --> 00:49:58,150
從屏幕上，看起來離開

1218
00:49:58,150 --> 00:49:59,450
或右向上或向下。

1219
00:49:59,450 --> 00:50:01,230
你會打箭頭鍵以這樣的方式

1220
00:50:01,230 --> 00:50:04,540
它對應於那些排隊的拼圖

1221
00:50:04,540 --> 00:50:05,720
在頂部的佔位符。

1222
00:50:05,720 --> 00:50:07,500
所以，當你看到一個左箭頭，它線與左

1223
00:50:07,500 --> 00:50:09,260
箭頭，打左箭頭。

1224
00:50:09,260 --> 00:50:10,866
你可以開始了。

1225
00:50:10,866 --> 00:50:13,674
[MUSIC  - “強”KAYNE西]

1226
00:51:21,222 --> 00:51:23,470
DAVID馬蘭：好了，又大又圓的掌聲理查德。

1227
00:51:23,470 --> 00:51:26,082
[掌聲]

1228
00:51:32,426 --> 00:51:33,720
DAVID馬蘭：非常好。

1229
00:51:33,720 --> 00:51:34,110
謝謝。

1230
00:51:34,110 --> 00:51:37,104
[掌聲]

1231
00:51:41,600 --> 00:51:44,330
>> DAVID馬蘭：那麼有趣，表面上看起來，排序

1232
00:51:44,330 --> 00:51:46,590
恐嚇，因為它可能實現的東西作為

1233
00:51:46,590 --> 00:51:49,550
看似複雜的，實現學生

1234
00:51:49,550 --> 00:51:51,450
沒有，只是寫這一次。

1235
00:51:51,450 --> 00:51:54,200
相反，你可以打破一個看似複雜的問題，

1236
00:51:54,200 --> 00:51:56,840
成更小的碎片，而這，也同樣是

1237
00:51:56,840 --> 00:51:57,560
將是一個主題。

1238
00:51:57,560 --> 00:52:00,490
寫一個程序，在幾乎任何你可以做的最糟糕的事情

1239
00:52:00,490 --> 00:52:03,480
語言是坐下來，興奮得不得了，寫

1240
00:52:03,480 --> 00:52:07,200
整個該死的東西，然後只是希望它的工作原理

1241
00:52:07,200 --> 00:52:08,510
當你完成寫作。

1242
00:52:08,510 --> 00:52:10,920
相反，編程的過程中，一般應該

1243
00:52:10,920 --> 00:52:13,440
是非常謹慎的，迭代，這樣你只

1244
00:52:13,440 --> 00:52:16,955
設置非常小的步驟，為自己，一口大小的塊

1245
00:52:16,955 --> 00:52:20,070
你要咬，所以你有這些理智

1246
00:52:20,070 --> 00:52:21,740
檢查，能滿足你的小里程碑。

1247
00:52:21,740 --> 00:52:24,170
然後你建立這些上創造更多的

1248
00:52:24,170 --> 00:52:25,400
還是複雜的事情。

1249
00:52:25,400 --> 00:52:26,820
>> 因此，舉例來說，我們可以去

1250
00:52:26,820 --> 00:52:28,380
實施這樣的比賽嗎？

1251
00:52:28,380 --> 00:52:30,160
坦白地說，我一定會由剛開始

1252
00:52:30,160 --> 00:52:32,260
支持在一個時間的一個關鍵。

1253
00:52:32,260 --> 00:52:34,840
讓我們只需要實現支持左箭頭。

1254
00:52:34,840 --> 00:52:37,610
因此，學生必須以某種方式在Photoshop中創建的，或在

1255
00:52:37,610 --> 00:52:40,340
刮刮本身使用的小的圖形化編輯器，

1256
00:52:40,340 --> 00:52:42,680
看起來像一個在頂部的箭頭鍵離開了那裡，只是

1257
00:52:42,680 --> 00:52:43,910
灰色的佔位符。

1258
00:52:43,910 --> 00:52:46,610
然後，學生必須弄清楚什麼x，y坐標

1259
00:52:46,610 --> 00:52:48,380
穿上它，把它放在窗口。

1260
00:52:48,380 --> 00:52:50,730
0，0，在這裡，所以你必須要弄清楚的數量

1261
00:52:50,730 --> 00:52:53,690
像素或點，以抵消該箭頭從

1262
00:52:53,690 --> 00:52:54,800
屏幕頂部。

1263
00:52:54,800 --> 00:52:57,040
，然後一旦在地方的，你的程序不實際

1264
00:52:57,040 --> 00:53:00,380
做任何事情，所以你需要第二個精靈，

1265
00:53:00,380 --> 00:53:04,470
例如，一個綠色的箭頭指向左邊，和你

1266
00:53:04,470 --> 00:53:06,710
那麼就需要開始編寫一些腳本。

1267
00:53:06,710 --> 00:53:09,310
>> 你看到的，也許，這些事情開始出現在

1268
00:53:09,310 --> 00:53:11,470
不同的速度，並分別在不同的顏色

1269
00:53:11,470 --> 00:53:13,750
位置，這是因為學生用了一下

1270
00:53:13,750 --> 00:53:14,990
偽隨機性。

1271
00:53:14,990 --> 00:53:17,440
和偽隨機性的，我的意思是選擇一個號碼

1272
00:53:17,440 --> 00:53:20,230
某物與某物的，因為你可以

1273
00:53:20,230 --> 00:53:22,890
地圖的事情，開始的數量是一樣，如果在一個

1274
00:53:22,890 --> 00:53:24,940
5，好了，讓我們做的事情綠。

1275
00:53:24,940 --> 00:53:28,290
如果是6到10之間，讓我們一塊拼圖

1276
00:53:28,290 --> 00:53:29,730
紅色代替。

1277
00:53:29,730 --> 00:53:31,840
只要你有辦法產生某種

1278
00:53:31,840 --> 00:53:34,730
隨機性，你可以作出決定的基礎上，

1279
00:53:34,730 --> 00:53:35,260
隨機性。

1280
00:53:35,260 --> 00:53:37,490
我一直在說因為有一個偽隨機

1281
00:53:37,490 --> 00:53:38,390
小骯髒的秘密。

1282
00:53:38,390 --> 00:53:41,130
計算機不能拿出隨機數。

1283
00:53:41,130 --> 00:53:42,800
他們只能做他們被告知，因為

1284
00:53:42,800 --> 00:53:44,110
他們是人造的設備。

1285
00:53:44,110 --> 00:53:45,880
他們可以像我們人類不只是猜一個數字

1286
00:53:45,880 --> 00:53:46,960
覺得我們可以。

1287
00:53:46,960 --> 00:53:50,970
一台計算機做一些數學變出

1288
00:53:50,970 --> 00:53:53,970
數學數的錯覺，有時使用

1289
00:53:53,970 --> 00:53:57,420
一天的時間作為當前的輸入搞清楚什麼

1290
00:53:57,420 --> 00:53:59,570
數返回，但更多的是另一次。

1291
00:53:59,570 --> 00:54:02,060
現在，只需要知道，我們可以生成偽隨機性。

1292
00:54:02,060 --> 00:54:04,610
>> 所以一旦我有能力為左箭頭開始

1293
00:54:04,610 --> 00:54:07,990
出現在不同的時間，以不同的速度，然後

1294
00:54:07,990 --> 00:54:10,230
我可以回去，並添加一些這些IF條件。

1295
00:54:10,230 --> 00:54:14,950
如果此sprite接觸到其他人，和左箭頭

1296
00:54:14,950 --> 00:54:16,330
鍵被按下 - 

1297
00:54:16,330 --> 00:54:17,900
所以在這種情況下，三個條件。

1298
00:54:17,900 --> 00:54:20,750
我可以使用，並阻止或許，在這種情況下 - 

1299
00:54:20,750 --> 00:54:23,210
然後我想繼續前進，增加的分數。

1300
00:54:23,210 --> 00:54:25,130
在上面，我們有一個分數，我們有真棒，

1301
00:54:25,130 --> 00:54:26,510
清涼，善，和Boo。

1302
00:54:26,510 --> 00:54:29,810
因此，有五個變量，顯然這名學生

1303
00:54:29,810 --> 00:54:32,220
用於跟踪這些各種度量。

1304
00:54:32,220 --> 00:54:34,180
因此，在短，最終的結果是驚人的。

1305
00:54:34,180 --> 00:54:37,320
它的樂趣，它的樂趣發揮，它的參與，但這不是

1306
00:54:37,320 --> 00:54:38,380
當學生開始了。

1307
00:54:38,380 --> 00:54:42,210
他或她開始在一個更小的步驟。

1308
00:54:42,210 --> 00:54:44,470
>> 那麼，什麼是其他一些積木​​，我們可以

1309
00:54:44,470 --> 00:54:45,760
織成這些程序？

1310
00:54:45,760 --> 00:54:48,750
嗯，有這等概念在大多數語言中，

1311
00:54:48,750 --> 00:54:50,730
刮開其中，被稱為線程。

1312
00:54:50,730 --> 00:54:54,660
因此，一台計算機可以沒有真正做多件事情在

1313
00:54:54,660 --> 00:54:56,730
時間，至少不是通常的。

1314
00:54:56,730 --> 00:54:59,930
相反，一台計算機通常具有只有一個CPU，甚至

1315
00:54:59,930 --> 00:55:02,230
雖然電腦是超級快，因此可以

1316
00:55:02,230 --> 00:55:04,740
創建做多件事情的錯覺 - 

1317
00:55:04,740 --> 00:55:06,180
檢查您的郵件，讓瞬間

1318
00:55:06,180 --> 00:55:07,770
信息，打印文件 - 

1319
00:55:07,770 --> 00:55:11,530
真的，一台計算機跳躍從印刷到即時消息

1320
00:55:11,530 --> 00:55:15,160
收發電子郵件，背和提出如此之快，我們

1321
00:55:15,160 --> 00:55:18,170
慢機智的人，只是不知道，它實際上是

1322
00:55:18,170 --> 00:55:21,240
運行這些程序一點點的時間。

1323
00:55:21,240 --> 00:55:23,960
現在，這一點的白色謊言，因為如今這些天，

1324
00:55:23,960 --> 00:55:26,740
許多我們的電腦就是所謂的多核心，所以你

1325
00:55:26,740 --> 00:55:29,760
有一個CPU，但多個內核，這是一種像

1326
00:55:29,760 --> 00:55:31,760
具有多個CPU。

1327
00:55:31,760 --> 00:55:35,020
>> 所以有時候，電腦可以真正做多件事情

1328
00:55:35,020 --> 00:55:38,500
在一段時間，但一般在一個程序中，程序

1329
00:55:38,500 --> 00:55:40,200
依靠這些東西叫做線程。

1330
00:55:40,200 --> 00:55:43,160
因此，一個線程是有點像一個微型的程序，可以

1331
00:55:43,160 --> 00:55:46,540
並存的另一個微型程序，可以運行

1332
00:55:46,540 --> 00:55:51,250
在平行的，或者至少是可以運行的誤解，認為

1333
00:55:51,250 --> 00:55:52,990
他們同時運行。

1334
00:55:52,990 --> 00:55:55,060
因此，划痕支持這些東西叫做線程。

1335
00:55:55,060 --> 00:55:57,580
你可以有多個腳本執行一次，就像我們

1336
00:55:57,580 --> 00:56:00,220
與海獅，這讓我們真正

1337
00:56:00,220 --> 00:56:03,620
有這些精靈之間的相互作用。

1338
00:56:03,620 --> 00:56:09,910
讓我繼續在這裡拉起來，讓我們說，線程，

1339
00:56:09,910 --> 00:56:11,870
發揮如下。

1340
00:56:11,870 --> 00:56:13,950
我們有兩個精靈，每個人，我們會看到

1341
00:56:13,950 --> 00:56:15,720
只有一個腳本。

1342
00:56:15,720 --> 00:56:18,000
注意到，似乎有一些情報，

1343
00:56:18,000 --> 00:56:21,335
貓在這一個，因為他越來越近了 - 

1344
00:56:21,335 --> 00:56:21,730
[河東獅]

1345
00:56:21,730 --> 00:56:24,540
DAVID MALAN： - 接近的小鳥。

1346
00:56:24,540 --> 00:56:26,570
>> 鳥是怎樣的操作？

1347
00:56:26,570 --> 00:56:28,200
好吧，讓我們先來看看在鳥。

1348
00:56:28,200 --> 00:56:31,220
鳥腳本的綠色標誌被點擊時，去X

1349
00:56:31,220 --> 00:56:34,020
等於負115和，y等於150。

1350
00:56:34,020 --> 00:56:37,010
所以，我只是想通了，我想一個隨機位置

1351
00:56:37,010 --> 00:56:39,580
鳥開始，我只是一屁股默認情況下，他在那裡。

1352
00:56:39,580 --> 00:56:42,800
，然後永遠不接觸貓，所以這是一個不同的

1353
00:56:42,800 --> 00:56:45,080
種循環結構，但同樣的想法，這樣做一遍，並

1354
00:56:45,080 --> 00:56:45,780
一遍又一遍。

1355
00:56:45,780 --> 00:56:49,410
所以，只要你不接觸貓，將三個步驟，

1356
00:56:49,410 --> 00:56:51,680
如果你的邊緣，彈跳，這是樣的

1357
00:56:51,680 --> 00:56:53,320
反射中台球感。

1358
00:56:53,320 --> 00:56:56,140
所以這是如何的鳥，周圍種

1359
00:56:56,140 --> 00:56:58,890
看似隨意，但它只是因為它的反彈

1360
00:56:58,890 --> 00:57:00,170
在這種情況下的壁。

1361
00:57:00,170 --> 00:57:03,170
>> 同時，現在的貓是一種欺騙。

1362
00:57:03,170 --> 00:57:05,520
的貓，當單擊綠旗，是的，開始在

1363
00:57:05,520 --> 00:57:07,390
一些位置，一個隨機的位置 - 

1364
00:57:07,390 --> 00:57:09,590
至少在部分每回升

1365
00:57:09,590 --> 00:57:11,430
隨機的綠色塊 - 

1366
00:57:11,430 --> 00:57:14,660
然後永遠IF接觸的鳥，玩獅子的聲音，

1367
00:57:14,660 --> 00:57:15,790
然後停止腳本。

1368
00:57:15,790 --> 00:57:18,560
所以，當我說，終止或退出之前，有一個難題

1369
00:57:18,560 --> 00:57:20,600
在刮片，將只殺程序在該

1370
00:57:20,600 --> 00:57:22,900
點，因為它是一種邏輯上完成。

1371
00:57:22,900 --> 00:57:25,030
但除此之外，在這裡，請注意會發生什麼。

1372
00:57:25,030 --> 00:57:28,470
指向的鳥類和移動一步。

1373
00:57:28,470 --> 00:57:31,390
因此，這指向鳥種的優勢貓

1374
00:57:31,390 --> 00:57:34,640
，它的歸位，我們可以在移動的鳥

1375
00:57:34,640 --> 00:57:37,370
現在使這個方案更有趣。

1376
00:57:37,370 --> 00:57:41,520
前進了一步，而不是在每個CPU週期的時間，每

1377
00:57:41,520 --> 00:57:44,280
罷工收費的鐘聲，可以這麼說，讓我繼續前進，

1378
00:57:44,280 --> 00:57:47,350
移動，比方說，貓的五個步驟的時間。

1379
00:57:47,350 --> 00:57:51,120
單擊“開始”，單擊“運行”，現在他真的發現他迅速。

1380
00:57:51,120 --> 00:57:55,620
如果我們雙擊這10個步驟，種“

1381
00:57:55,620 --> 00:57:56,370
適合他的。

1382
00:57:56,370 --> 00:57:57,750
現在，我們可以給鳥，

1383
00:57:57,750 --> 00:57:59,540
也許，一個位的優勢。

1384
00:57:59,540 --> 00:58:02,370
讓我們到的鳥類和移動三個步驟的，而不是說，

1385
00:58:02,370 --> 00:58:07,140
讓我們繼續前進了30步。

1386
00:58:07,140 --> 00:58:08,700
但他到底還是被抓住了。

1387
00:58:08,700 --> 00:58:10,430
>> 所以在這裡，我們有兩個線程。

1388
00:58:10,430 --> 00:58:13,230
它關押在兩個腳本和兩個從頭開始

1389
00:58:13,230 --> 00:58:16,150
精靈，但在其他語言中的想法是，你可以

1390
00:58:16,150 --> 00:58:19,220
寫，從本質上講，太多這樣的程序，並有

1391
00:58:19,220 --> 00:58:22,950
他們真正的運行，或虛構，在平行。

1392
00:58:22,950 --> 00:58:25,280
>> 現在，這個概念在編程中被稱為

1393
00:58:25,280 --> 00:58:28,010
事件，這是東西，我們會看到在C，

1394
00:58:28,010 --> 00:58:30,500
被稱為C.語言中，我們將看到對學期結束

1395
00:58:30,500 --> 00:58:33,240
在網絡編程，當我們介紹了JavaScript和

1396
00:58:33,240 --> 00:58:36,970
建設的網頁是動態的，交互的概念

1397
00:58:36,970 --> 00:58:37,710
與用戶。

1398
00:58:37,710 --> 00:58:40,430
因此，在這種情況下，我們有一個非常簡單的例子，兩個

1399
00:58:40,430 --> 00:58:43,860
精靈，男孩和女孩，每個人都有各自的

1400
00:58:43,860 --> 00:58:48,040
線程，但不知何故，這兩個是相互溝通的方式

1401
00:58:48,040 --> 00:58:49,490
一種叫做事件。

1402
00:58:49,490 --> 00:58:52,750
因此，讓我繼續在這裡和放大男孩的腳本，

1403
00:58:52,750 --> 00:58:54,050
這看起來是這樣的。

1404
00:58:54,050 --> 00:58:57,510
當綠色環保標誌的點擊，永遠做到以下幾點。

1405
00:58:57,510 --> 00:59:01,510
如果密鑰空間，或按空格鍵被按下，說

1406
00:59:01,510 --> 00:59:03,900
馬可兩秒鐘，這是純粹的審美上的

1407
00:59:03,900 --> 00:59:06,860
屏幕，一點點的講話泡沫，但隨後播出。

1408
00:59:06,860 --> 00:59:09,240
>> 因此，廣播是另一個刮片，這是

1409
00:59:09,240 --> 00:59:12,050
代表一類的功能在編程

1410
00:59:12,050 --> 00:59:15,080
，讓不同的程序，不同的線程，

1411
00:59:15,080 --> 00:59:17,120
間的溝通，以某種方式發送

1412
00:59:17,120 --> 00:59:18,520
消息，一個到另一個。

1413
00:59:18,520 --> 00:59:21,930
通過一張紙，在課堂上是一種技術含量低

1414
00:59:21,930 --> 00:59:22,700
相同的。

1415
00:59:22,700 --> 00:59:24,300
所以廣播事件。

1416
00:59:24,300 --> 00:59:26,210
我可以給這個消息，這個詞事件

1417
00:59:26,210 --> 00:59:27,270
完全是任意的。

1418
00:59:27,270 --> 00:59:30,000
刮有時會出現下拉菜單，所以我就想出了

1419
00:59:30,000 --> 00:59:33,230
一個隨機類似事件的話，因為現在，這個小男孩

1420
00:59:33,230 --> 00:59:36,600
當我按下最關鍵的是，他的廣播事件。

1421
00:59:36,600 --> 00:59:39,270
如果我現在看女孩的腳本，她的劇本

1422
00:59:39,270 --> 00:59:42,690
超級簡單的，因為她需要做的是不採取行動時，

1423
00:59:42,690 --> 00:59:44,100
點擊綠旗。

1424
00:59:44,100 --> 00:59:47,910
她的目的是採取行動的時候，她收到了報價，享有的，

1425
00:59:47,910 --> 00:59:51,210
“事件”，在這一點上，她在聽，因此對

1426
00:59:51,210 --> 00:59:52,960
所謂事件，一遍又一遍。

1427
00:59:52,960 --> 00:59:55,790
當她收到這種情況下，她會喊

1428
00:59:55,790 --> 00:59:57,680
Polo為2秒。

1429
00:59:57,680 --> 01:00:01,090
>> 所以你也許可以推斷出這到底是什麼

1430
01:00:01,090 --> 01:00:03,190
下一個結果將是。

1431
01:00:03,190 --> 01:00:04,910
讓我點擊綠色旗幟。

1432
01:00:04,910 --> 01:00:06,610
什麼也沒有發生，因為我需要做什麼？

1433
01:00:06,610 --> 01:00:07,310
觀眾：空格鍵。

1434
01:00:07,310 --> 01:00:08,630
DAVID馬蘭：空格鍵。

1435
01:00:08,630 --> 01:00:11,990
男孩說女孩說馬可，波羅。

1436
01:00:11,990 --> 01:00:13,670
但是，這不是硬編碼本身。

1437
01:00:13,670 --> 01:00:16,740
這是跨腳本之間的通信，所以現在我們

1438
01:00:16,740 --> 01:00:19,240
有能力做出更複雜的程序，

1439
01:00:19,240 --> 01:00:22,830
這兩個都以某種方式相互溝通。

1440
01:00:22,830 --> 01:00:25,260
>> 因此，在我們可以採取什麼樣的方向嗎？

1441
01:00:25,260 --> 01:00:28,260
好了，問題集，真的，目標是到

1442
01:00:28,260 --> 01:00:29,830
有樂趣的划痕。

1443
01:00:29,830 --> 01:00:32,440
黑客版，你會，而不是有一個更好玩的

1444
01:00:32,440 --> 01:00:35,850
先進的版本Scratch的BYOB建設

1445
01:00:35,850 --> 01:00:38,040
自己的塊，但這個想法是一樣的。

1446
01:00:38,040 --> 01:00:38,780
您就可以 - 

1447
01:00:38,780 --> 01:00:39,710
是的，這是故意的。

1448
01:00:39,710 --> 01:00:42,450
它來自大學伯克利分校。

1449
01:00:42,450 --> 01:00:45,200
BYOB是黑客Edition版本，但兩者

1450
01:00:45,200 --> 01:00:48,180
人口統計資料，標準版和黑客版的一致好評，

1451
01:00:48,180 --> 01:00:50,940
手頭未來一周的目標是實際上只是潛水

1452
01:00:50,940 --> 01:00:53,050
深，自己動手編程，使

1453
01:00:53,050 --> 01:00:55,240
一些有趣的，互動的東西，

1454
01:00:55,240 --> 01:00:58,020
藝術的東西，好玩的東西，其實

1455
01:00:58,020 --> 01:01:01,020
展示，讓週末，你將有一個項目，

1456
01:01:01,020 --> 01:01:03,770
不僅是你的第一個CS50的pset，但你將有一個

1457
01:01:03,770 --> 01:01:05,620
小東西，你可以炫耀在安嫩伯格

1458
01:01:05,620 --> 01:01:08,830
它上傳到麻省理工學院的網站，朋友，甚至家庭。

1459
01:01:08,830 --> 01:01:11,760
所以當我在星期三說，我們預期90％之類的，

1460
01:01:11,760 --> 01:01:13,970
一般，做標準的版本。

1461
01:01:13,970 --> 01:01:16,660
實現對於那些你也有這個插座

1462
01:01:16,660 --> 01:01:18,990
否則可能會發現自己有點無聊的基礎知識

1463
01:01:18,990 --> 01:01:21,650
真的想潛水和你已經制定一個願景

1464
01:01:21,650 --> 01:01:25,380
與以前的背景，這更友好的

1465
01:01:25,380 --> 01:01:26,240
環境。

1466
01:01:26,240 --> 01:01:29,030
>> 因此，讓我拉了另外一個例子，我們的前

1467
01:01:29,030 --> 01:01:33,830
這裡的學生，並通過歌曲告訴了一點東西。

1468
01:01:33,830 --> 01:01:37,430
同樣，由於這個劇本，想想你如何去

1469
01:01:37,430 --> 01:01:40,520
實施這一計劃正是這些相同

1470
01:01:40,520 --> 01:01:44,180
積木，一點點的偽隨機性和

1471
01:01:44,180 --> 01:01:46,010
有點熟悉的歌曲。

1472
01:01:46,010 --> 01:01:47,910
如果我們能提高音量，只需要一點點嗎？

1473
01:01:47,910 --> 01:01:49,160
[MUSIC  - “IT'S RAINING MEN”THE WEATHER GIRLS]

1474
01:03:02,261 --> 01:03:03,930
>> DAVID馬蘭：這是它的CS50。

1475
01:03:03,930 --> 01:03:05,860
我們會看到你的週一。

1476
01:03:05,860 --> 01:03:21,152
[掌聲]