1
00:00:11,120 --> 00:00:12,590
我是。。。（听不清）

2
00:00:12,590 --> 00:00:14,820
我是一名大四学生，住在Leverett舍。

3
00:00:14,820 --> 00:00:18,700
我专修计算机科学，同时我是计算机科学50的一名助教

4
00:00:18,700 --> 00:00:21,640
我大一的时候连手提电脑和智能手机都没有。

5
00:00:21,640 --> 00:00:23,550
我那时也没有任何编程的经验。

6
00:00:23,550 --> 00:00:29,690
计算机科学50是我在哈佛上过的令我印象最深刻的课，

7
00:00:29,690 --> 00:00:32,960
因为它很难，但是难的同时让我觉得非常有意思。

8
00:00:32,960 --> 00:00:37,670
同时我交了很多非常好的，长久的朋友，我还学到了很多

9
00:00:37,670 --> 00:00:38,830
非常实用的技能。

10
00:00:38,830 --> 00:00:43,480
我想说我很高兴我当时没有让我自己（编程）背景的缺乏成为

11
00:00:43,480 --> 00:00:44,840
我不上计算机科学50的借口。

12
00:00:44,840 --> 00:00:46,220
我是。。。(听不清)

13
00:00:46,220 --> 00:00:48,910
我现在大四，住在Leverett舍。2014届。

14
00:00:48,910 --> 00:00:51,670
我之前上了计算机科学50。

15
00:00:51,670 --> 00:00:52,380
好的，这就是对计算机科学50的基本介绍。

16
00:00:52,380 --> 00:00:54,400
我们这个选课星期的课就到这里。

17
00:00:54,400 --> 00:00:58,500
记得上次我们是从台灯那里开始的，

18
00:00:58,500 --> 00:01:01,420
这些灯变得很受欢迎，所以我们去又带了一些来。

19
00:01:01,420 --> 00:01:03,790
我想这个能成为我们今年的一个传统

20
00:01:03,790 --> 00:01:07,230
你上台来的话奖励一盏台灯，知道我们送完为止。

21
00:01:07,230 --> 00:01:11,570
但是请记得我们上次是用这些灯来介绍数据表示法的基本知识。

22
00:01:11,570 --> 00:01:15,640
我们当时需要一个在计算机内部表示信息的方法。

23
00:01:15,640 --> 00:01:18,650
那么去达到这个目的的最简单的办法就是用一种元素，电流。

24
00:01:18,650 --> 00:01:21,760
那么你对于电可以做的最简单的事情就是把它打开和关上。

25
00:01:21,760 --> 00:01:23,520
让电子流动或者不流动。

26
00:01:23,520 --> 00:01:27,930
那么用这两种基本的状态，关与开，或者false与true，或者0和

27
00:01:27,930 --> 00:01:31,290
1, 我们开始发现我们在这种情况下可以用灯泡

28
00:01:31,290 --> 00:01:33,720
来表示比0和1更多的数字。

29
00:01:33,720 --> 00:01:36,160
比如我们上次就数到了7。

30
00:01:36,160 --> 00:01:38,840
但是我们所要做的只是不断往那个问题里面加更多的灯泡

31
00:01:38,840 --> 00:01:41,820
这样的话，我们可以表示任何我们

32
00:01:41,820 --> 00:01:42,970
可能想要表示的数字。

33
00:01:42,970 --> 00:01:47,230
好的，我们在周三快速转换到了那个关于字节的支援活动。

34
00:01:47,230 --> 00:01:52,040
大体上说，8个比特就可以成为一个字节，所以我们上次请了8个人自愿上台来。

35
00:01:52,040 --> 00:01:54,900
他们在周三的时候一起代表了8个比特。

36
00:01:54,900 --> 00:01:56,750
当他们手都举起来的时候，他们整体代表了数字1。

37
00:01:56,750 --> 00:01:58,530
当他们手都放下来的时候，他们整体代表了数字0。

38
00:01:58,530 --> 00:02:01,970
那么我们为什么让他们到台上来呢？

39
00:02:01,970 --> 00:02:06,530
我们用这些比特干了什么事？

40
00:02:06,530 --> 00:02:07,510
我们建立了一个字母表。

41
00:02:07,510 --> 00:02:11,550
我们可以在之前学到的东西之上更近一步并且真正的

42
00:02:11,550 --> 00:02:14,200
开始传达更加有趣的信息，

43
00:02:14,200 --> 00:02:15,330
至少是对人类来说更加熟悉的信息。

44
00:02:15,330 --> 00:02:18,360
这将使我们这门课当中不断出现的主题，同时对于

45
00:02:18,360 --> 00:02:21,470
计算机科学总体来说也是，在这个领域当中分层的概念说到最后，

46
00:02:21,470 --> 00:02:24,820
如果你真的是从一个电脑开始最基本的程序的话，就是，

47
00:02:24,820 --> 00:02:25,760
用0和1表示的。

48
00:02:25,760 --> 00:02:27,480
在那下面再基本的层次就是电流了。

49
00:02:27,480 --> 00:02:30,840
但是我们很快就开始觉得底层的那些细节是非常自然的了

50
00:02:30,840 --> 00:02:35,600
开始基于之前人工作的基础之上建立层次，最终

51
00:02:35,600 --> 00:02:38,610
在本学期结束的时候，或者真正大体上作为计算机科学家

52
00:02:38,610 --> 00:02:42,790
和程序员，可以做一些比较大的工程，

53
00:02:42,790 --> 00:02:46,620
通过相互之间工作成果的铺垫，同时也站在别人的肩上。

54
00:02:46,620 --> 00:02:49,300
现在我们快速得从周三的仅仅表示信息的情况转换到

55
00:02:49,300 --> 00:02:52,080
想用信息做些东西的时候了。

56
00:02:52,080 --> 00:02:54,170
那么我们是怎么定义算法的呢？

57
00:02:57,340 --> 00:02:58,900
一系列的指示

58
00:02:58,900 --> 00:03:03,380
所以算法是一系列的指示，一系列步骤，你，一个人，或者

59
00:03:03,380 --> 00:03:07,160
更典型的情况下一台电脑，需要一条条按照顺序执行的

60
00:03:07,160 --> 00:03:08,100
为了达到某些目的。

61
00:03:08,100 --> 00:03:11,360
我们上次有几个目的，其中之一是数数

62
00:03:11,360 --> 00:03:12,250
这教室里面的人数。

63
00:03:12,250 --> 00:03:15,560
类似的另外一个例子就是从黄页里面找到麦克史密斯这个人。

64
00:03:15,560 --> 00:03:19,750
所以你们可能记得我把一本黄页撕两半

65
00:03:19,750 --> 00:03:21,280
直到找到麦克史密斯。

66
00:03:21,280 --> 00:03:24,000
那个演示的目的是想说明

67
00:03:24,000 --> 00:03:27,770
我们是把这个问题不断二分，然后很快地

68
00:03:27,770 --> 00:03:31,750
从1000页纸到只剩下一页纸了。

69
00:03:31,750 --> 00:03:34,860
对于你们之中那些错过了周三的这个片段的人，我想我们可以给你们重播一下

70
00:03:34,860 --> 00:03:36,820
你们之前错过的片段。

71
00:03:36,820 --> 00:03:38,914
让我们来看看。

72
00:03:38,914 --> 00:03:40,906
（视频重播）

73
00:03:55,360 --> 00:03:55,990
好啦。

74
00:03:55,990 --> 00:04:01,432
1500页纸，整齐的撕痕，牛X的撕法。

75
00:04:01,432 --> 00:04:02,850
视频重播结束

76
00:04:02,850 --> 00:04:05,230
那么这些就是周三的内容。

77
00:04:05,230 --> 00:04:09,150
我们从周三内容转换到现在想代表算法

78
00:04:09,150 --> 00:04:12,410
通过一些标准化的方法，不只是口述这个过程，而是

79
00:04:12,410 --> 00:04:16,290
试着在书面或者在电脑屏幕上面标示它们，使得我们

80
00:04:16,290 --> 00:04:19,170
可以在那之上改进，并且最终

81
00:04:19,170 --> 00:04:21,160
去分析它们的正确性或者是运算速度如何。

82
00:04:21,160 --> 00:04:23,360
所以我们介绍了假代码这个概念，

83
00:04:23,360 --> 00:04:26,410
用外行的说法，是什么？

84
00:04:26,410 --> 00:04:26,930
呵呵，是单词。

85
00:04:26,930 --> 00:04:28,730
让我们在这个上面更深一步来看看。

86
00:04:28,730 --> 00:04:32,540
肯定是英文单词，但是是为了干什么？

87
00:04:32,540 --> 00:04:35,180
用这些单词来创建或者表示算法。

88
00:04:35,180 --> 00:04:38,380
所以这世界上没有叫做假代码的这门语言。

89
00:04:38,380 --> 00:04:41,110
而只是有你，用英语，或者你说的任何语言，

90
00:04:41,110 --> 00:04:44,930
用一种粗略的标注来很简洁的表达一种意思。

91
00:04:44,930 --> 00:04:47,930
但是我们会发现，对于一种英语的假代码而言，

92
00:04:47,930 --> 00:04:51,700
并且对于那些由英语衍生出的程序语言来说，

93
00:04:51,700 --> 00:04:55,750
我们会发现有一些固定的表示假代码的

94
00:04:55,750 --> 00:04:57,150
或者程序代码的方法。

95
00:04:57,150 --> 00:05:00,200
所以当你今天开始看到即使是最简单的例子，请意识到

96
00:05:00,200 --> 00:05:02,160
有些规律会在下个星期再次出现。

97
00:05:02,160 --> 00:05:04,710
所以伪代码是一种代表了

98
00:05:04,710 --> 00:05:06,170
程序语言的语言。

99
00:05:06,170 --> 00:05:09,260
我们看到的第一个写下来的例子是这个。

100
00:05:09,260 --> 00:05:12,870
它只是一个三步的程序，目的是数

101
00:05:12,870 --> 00:05:15,650
周三那个视频当中的一个寝室中的人数。

102
00:05:15,650 --> 00:05:19,040
但是这个最简单的程序有很多有意思的方面。

103
00:05:19,040 --> 00:05:20,320
而这将成为不断重复的主题。

104
00:05:20,320 --> 00:05:22,930
那么为了辅助对于这个不熟悉的人，我们插入一个变量。

105
00:05:22,930 --> 00:05:25,650
这个屋子里面的人对变量应该都有所了解

106
00:05:25,650 --> 00:05:27,250
通过代数的学习。

107
00:05:27,250 --> 00:05:31,190
但是在程序当中，变量可以

108
00:05:31,190 --> 00:05:32,220
被叫做任何东西。

109
00:05:32,220 --> 00:05:33,620
我们之前用n来数数

110
00:05:33,620 --> 00:05:37,490
但是我们也可以用”数数“这个单词，或者任何

111
00:05:37,490 --> 00:05:40,240
你喜欢的词语，只要是描述性的

112
00:05:40,240 --> 00:05:41,250
但是它本质上只是一个存储信息的单元

113
00:05:41,250 --> 00:05:44,170
它是一个记忆单元，一些比特，并且每个电脑不同，

114
00:05:44,170 --> 00:05:47,020
那个变量由多少个比特组成。

115
00:05:47,020 --> 00:05:48,450
但是我们可以给它设置内容。

116
00:05:48,450 --> 00:05:50,740
目前为止，我们仅仅设置数字。

117
00:05:50,740 --> 00:05:52,290
但我们也可以设真正的单词。

118
00:05:52,290 --> 00:05:53,420
我们可以放段落。

119
00:05:53,420 --> 00:05:54,560
我们可以放图片

120
00:05:54,560 --> 00:05:57,860
其实可以放任何我们通过0和1表示的东西，

121
00:05:57,860 --> 00:05:59,820
我们可以通过这种更高的变量的形式表达。

122
00:05:59,820 --> 00:06:01,350
所以这个还是比较清楚的。

123
00:06:01,350 --> 00:06:02,210
这个是第一行。

124
00:06:02,210 --> 00:06:05,340
但是我们很快从第一行变成真正用那个变量

125
00:06:05,340 --> 00:06:06,600
做些事情。

126
00:06:06,600 --> 00:06:10,330
在第三行，我们更新N，我们增加N的值。我们可以

127
00:06:10,330 --> 00:06:11,330
用很多种方法写这个程序。

128
00:06:11,330 --> 00:06:14,460
但是最明显的可能是说把N设置成等于

129
00:06:14,460 --> 00:06:16,440
N的值加1

130
00:06:16,440 --> 00:06:17,740
这里我们看到了怎样实现增量。

131
00:06:17,740 --> 00:06:18,740
同时，我们看到这里有个循环。

132
00:06:18,740 --> 00:06:20,720
而这个也可能同样是非常直观的。

133
00:06:20,720 --> 00:06:24,250
一个循环是一个程序中不断重复的东西，

134
00:06:24,250 --> 00:06:25,190
一种圈的结构。

135
00:06:25,190 --> 00:06:29,300
而这里的这个关键语句，对于每个来说，其实是在

136
00:06:29,300 --> 00:06:32,300
很多程序语言中非常常见的，包括我们可能在这个课当中看到的那些。

137
00:06:32,300 --> 00:06:35,850
只要你们见到for这个词，它一般代表了

138
00:06:35,850 --> 00:06:38,410
一个循环，一个回环往复的过程要发生了。

139
00:06:38,410 --> 00:06:40,980
这里值得注意另外一个句法细节。

140
00:06:40,980 --> 00:06:44,660
第三行缩进了一些

141
00:06:44,660 --> 00:06:46,920
通过敲击空格键几下，这是有意为之的。

142
00:06:46,920 --> 00:06:49,870
因为人们的习惯是如果你一遍遍做一件事情的时候

143
00:06:49,870 --> 00:06:54,860
在一个循环当中时，从第二行开始，你把一切属于哪个循环的内容给缩进，

144
00:06:54,860 --> 00:06:58,880
只是为了表示清楚是第三行，而不是例如

145
00:06:58,880 --> 00:07:01,910
第四或第五行，如果这里有第四或第五行的话

146
00:07:01,910 --> 00:07:03,010
属于那个循环。

147
00:07:03,010 --> 00:07:07,340
所以这个简单的缩进传递那个简单的道理。

148
00:07:07,340 --> 00:07:09,390
那么我们现在把这个简单的算法用在几个例子上面。

149
00:07:09,390 --> 00:07:12,620
还有这个，现实世界中的简单例子。

150
00:07:12,620 --> 00:07:15,440
但是这个将代表你会如何

151
00:07:15,440 --> 00:07:17,500
去测试你自己的不断变复杂的程序。

152
00:07:17,500 --> 00:07:21,050
你尝试一些情景，一些代表性的输入，然后看你有没有

153
00:07:21,050 --> 00:07:22,180
取得理想的输出。

154
00:07:22,180 --> 00:07:25,090
所以这个例子有两个人坐在寝室里。

155
00:07:25,090 --> 00:07:27,170
在左边是那个同样的伪代码

156
00:07:27,170 --> 00:07:30,800
然后这是一个这个应用的最后几步的截图

157
00:07:30,800 --> 00:07:35,270
把算法用在这些输入上面，当时屋子里面有两个人

158
00:07:35,270 --> 00:07:39,190
当我们一步步执行第一行，第二行和第三行，然后再重复第二行

159
00:07:39,190 --> 00:07:41,000
和第三行，然后结束--

160
00:07:41,000 --> 00:07:44,870
在算法最后，我们确实是数了屋子里面的

161
00:07:44,870 --> 00:07:45,360
两个人。

162
00:07:45,360 --> 00:07:47,190
然后我们又试了另外一个例子。

163
00:07:47,190 --> 00:07:48,990
然后我们说如果屋子里面一个人也没有呢？

164
00:07:48,990 --> 00:07:50,490
这时候这个代码还正确吗？

165
00:07:50,490 --> 00:07:51,305
它确实还是正确的。

166
00:07:51,305 --> 00:07:55,240
因为正好第二行的条件没有通过，所以，第三行

167
00:07:55,240 --> 00:07:56,620
不会被执行。

168
00:07:56,620 --> 00:07:59,790
这句代码内容根本不会被执行因为他们在这种情况下不适用，如果

169
00:07:59,790 --> 00:08:01,210
屋子里面一个人都没有的话。

170
00:08:01,210 --> 00:08:02,300
但是这没关系

171
00:08:02,300 --> 00:08:06,620
第一句代码将N的初始值设为0，所以即使是这段代码中的

172
00:08:06,620 --> 00:08:10,930
一句最终起了作用，它最后还是给出了正确的答案，正如

173
00:08:10,930 --> 00:08:13,780
最底部的那个橙色的0显示的一样

174
00:08:13,780 --> 00:08:16,300
但是我们后来觉得这个算法有点缺点，

175
00:08:16,300 --> 00:08:17,060
它运行起来挺慢的。

176
00:08:17,060 --> 00:08:19,720
我们肯定可以两个两个数，2，4，6，8，10，

177
00:08:19,720 --> 00:08:20,990
当我们在数屋子里面人数的时候

178
00:08:20,990 --> 00:08:25,030
所以我们改了改这个算法，这个伪代码，然后让第二句当中

179
00:08:25,030 --> 00:08:29,710
每两个人，进一步到第三句当中执行，每次

180
00:08:29,710 --> 00:08:32,200
执行过程中增加两个

181
00:08:32,200 --> 00:08:35,530
那个在数这屋子里面两个人的时候是可行的。

182
00:08:35,530 --> 00:08:38,530
但是，当你仔细想想这个的时候，不需要多久你就

183
00:08:38,530 --> 00:08:40,710
发现这个会出现错误，它在怎样的

184
00:08:40,710 --> 00:08:42,679
简单情况下就发生错误了？

185
00:08:42,679 --> 00:08:45,500
如果在这个屋子里面有三个人，或者大体上来说，屋子里有

186
00:08:45,500 --> 00:08:47,660
奇数个人，包括一个人的时候

187
00:08:47,660 --> 00:08:50,390
我们会数不到这个人，因为没有形成两两一对

188
00:08:50,390 --> 00:08:58,510
所以我们很快地针对这个问题引入了额外的

189
00:08:58,510 --> 00:09:02,560
程序结构到这个伪代码之中

190
00:09:02,560 --> 00:09:04,955
这就是我们称之为的一个条件语句，或者一个树状结构

191
00:09:04,955 --> 00:09:08,420
这个想要表示的意思，形象上来说是一个分叉的意思，一条路上面的分叉口

192
00:09:08,420 --> 00:09:11,080
着这里你可以选择做这个或者，可能做另外一件事

193
00:09:11,080 --> 00:09:15,750
确实，我们针对这个目标加入了第四行，使得代码判断

194
00:09:15,750 --> 00:09:20,820
如果在最后有一个人剩下来的话，它把这个人算作一个特例算进去

195
00:09:20,820 --> 00:09:24,460
那么你就差不多把他们作为一个特殊情况考虑进去，那么现在我们就可以

196
00:09:24,460 --> 00:09:27,810
数偶数个人，也可以数奇数个人了

197
00:09:27,810 --> 00:09:30,260
那么我们有很多种方法来表示这个

198
00:09:30,260 --> 00:09:33,590
老实说，我可以在我选择的时候更加精益求精

199
00:09:33,590 --> 00:09:35,040
在选择伪代码的语言表述的时候

200
00:09:35,040 --> 00:09:36,970
但是至少这个概念的精髓已经被表达出来了

201
00:09:36,970 --> 00:09:40,725
如果你把这段代码给一个不是从事计算机科学的，

202
00:09:40,725 --> 00:09:44,560
或者没有上过计算机科学课的朋友看，他们有可能可以看懂，如果知道屋子里面有三个人的话

203
00:09:44,560 --> 00:09:46,870
应该怎样遵照这些知识来数人数

204
00:09:46,870 --> 00:09:49,920
那么这些基本上就是我们想通过伪代码想取得的完整目标

205
00:09:49,920 --> 00:09:54,300
通过某种方法来标准化我们表达想法的方式

206
00:09:54,300 --> 00:09:56,670
从而通过这些做更加复杂的事情

207
00:09:56,670 --> 00:09:58,845
那么这些就把我引入了今天的对于真正代码的学习

208
00:09:58,845 --> 00:10:01,950
我们今天就要开始编程，尽管实在一个便捷的环境当中

209
00:10:01,950 --> 00:10:05,940
然后我们快速进入稍微复杂一些的语句，但是是一种

210
00:10:05,940 --> 00:10:10,340
你会发现是基本上相同的句法，

211
00:10:10,340 --> 00:10:11,990
和我们之前看到的其他语言一样

212
00:10:11,990 --> 00:10:13,920
它将会只是看上去有点不同

213
00:10:13,920 --> 00:10:16,590
所以我不会只是把这个叫做代码，我会更加准确一些

214
00:10:16,590 --> 00:10:20,170
从今往后，在你写程序的时候，我会说你在写一个源代码

215
00:10:20,170 --> 00:10:21,990
它有点像伪代码

216
00:10:21,990 --> 00:10:26,540
但是我们会发现它在你对于词语的选择之上不像以前那样比较随便了

217
00:10:26,540 --> 00:10:27,310
当你选择你想用的词语的时候

218
00:10:27,310 --> 00:10:31,300
当你在使用某一种语言编程的时候，你必须使用一些命令，语句

219
00:10:31,300 --> 00:10:36,020
和句法，使之符合别人决定的代表那种

220
00:10:36,020 --> 00:10:37,240
特定语言的方法

221
00:10:37,240 --> 00:10:38,510
所以伪代码的语言是由你决定的

222
00:10:38,510 --> 00:10:42,330
但是一个真正的程序语言比如C，我们最后会发现，

223
00:10:42,330 --> 00:10:43,590
是由别人来确定规则的

224
00:10:43,590 --> 00:10:45,590
那么我们怎么来写源代码呢？

225
00:10:45,590 --> 00:10:46,810
好的，我现在就来开始

226
00:10:46,810 --> 00:10:49,100
我来先在这儿打开个窗口

227
00:10:49,100 --> 00:10:50,210
我们会在下周更仔细介绍这个

228
00:10:50,210 --> 00:10:52,300
这个是一个叫做计算机科学50应用的程序

229
00:10:52,300 --> 00:10:55,480
我在用我的Mac运行一个程序，当然你可以做同样的事情

230
00:10:55,480 --> 00:11:00,580
在一台运行windows的电脑上，这个程序会帮助我模拟在

231
00:11:00,580 --> 00:11:03,700
我电脑的一个窗口上运行一个操作系统的感觉

232
00:11:03,700 --> 00:11:06,790
我现在全屏了所以你看不到Mac的操作系统

233
00:11:06,790 --> 00:11:08,340
这是一个叫做Linux的操作系统

234
00:11:08,340 --> 00:11:09,300
它很流行

235
00:11:09,300 --> 00:11:10,120
运行很快

236
00:11:10,120 --> 00:11:12,950
有很大自由度，这使之很吸引人，

237
00:11:12,950 --> 00:11:13,970
尤其是在广告界

238
00:11:13,970 --> 00:11:17,200
我们会在这个学期后面阶段更多介绍这个，我们那时候会用Linux

239
00:11:17,200 --> 00:11:21,230
来进行网页编程和运载真的网页和项目

240
00:11:21,230 --> 00:11:24,910
那么现在，请记住这是一个设计成看上去有些

241
00:11:24,910 --> 00:11:26,750
像Window和Mac操作系统的桌面

242
00:11:26,750 --> 00:11:29,110
只是它又一些不同的名称和图标

243
00:11:29,110 --> 00:11:32,510
但这就是我们说的计算机科学50应用，一个虚拟机器

244
00:11:32,510 --> 00:11:35,310
从下个星期开始，你们将开始在一个窗口当中运行程序

245
00:11:35,310 --> 00:11:36,960
用你自己的Mac或者PC

246
00:11:36,960 --> 00:11:39,760
今天的课上，我将打开最简单的一个程序

247
00:11:39,760 --> 00:11:41,110
它叫做gedit

248
00:11:41,110 --> 00:11:42,565
然后这只是一个文本编辑器

249
00:11:42,565 --> 00:11:44,695
它有点像微软Word， 但是更加简单

250
00:11:44,695 --> 00:11:47,110
它其实有点像txt文本编辑器或者记事本

251
00:11:47,110 --> 00:11:50,280
它只是一个很简单的可以用来在屏幕上面录入文字的程序

252
00:11:50,280 --> 00:11:54,510
只是如果我用某些特殊的后缀储存文件

253
00:11:54,510 --> 00:11:59,860
比如.c，而不是.doc或者是.xls之类

254
00:11:59,860 --> 00:12:04,190
你熟悉的后缀，我实际上可以创建程序，即使是用这个简单的

255
00:12:04,190 --> 00:12:05,130
文本编辑器

256
00:12:05,130 --> 00:12:05,770
那么就让我来演示一下吧

257
00:12:05,770 --> 00:12:09,330
让我先把这个文件先储存为hello.c

258
00:12:09,330 --> 00:12:12,350
再说一句，这个用户界面将会很快地对你变得熟悉

259
00:12:12,350 --> 00:12:14,160
但是现在，我只是在输入一个文件名

260
00:12:14,160 --> 00:12:17,410
我将会把它储存在我的约翰哈佛主页目录里面

261
00:12:17,410 --> 00:12:20,810
现在我有这个标签标示我真的是在编辑

262
00:12:20,810 --> 00:12:23,070
一个叫做hello.c的文件

263
00:12:23,070 --> 00:12:24,510
到目前为止还没有什么特别有趣的事情发生

264
00:12:24,510 --> 00:12:26,000
现在开始这个将变得很密码化了

265
00:12:26,000 --> 00:12:28,370
我来放大一些，这样你们看得更清楚一些

266
00:12:28,370 --> 00:12:35,780
现在我会开始在上面打stdio.h, int main, void, open curly

267
00:12:35,780 --> 00:12:40,140
括弧，1，2，3，4空格缩进，print f, 为了输出某些特定格式的东西

268
00:12:40,140 --> 00:12:44,450
双引号，“hello, world”反斜杠，n，

269
00:12:44,450 --> 00:12:49,640
引号，括弧，冒号，回车空格空格空格

270
00:12:49,640 --> 00:12:52,310
空格，大括弧

271
00:12:52,310 --> 00:12:53,350
我完成了编程

272
00:12:53,350 --> 00:12:57,380
好的，这是一个很简单的程序，每个人

273
00:12:57,380 --> 00:12:59,070
刚刚开始编程的时候都会做的

274
00:12:59,070 --> 00:13:02,300
尽管这个有点复杂，但是它干的事只是

275
00:13:02,300 --> 00:13:04,160
在屏幕上显示，什么？

276
00:13:04,160 --> 00:13:04,910
你好世界

277
00:13:04,910 --> 00:13:07,500
但是仅仅写一个程序是不足够的

278
00:13:07,500 --> 00:13:08,155
所以这个是代码

279
00:13:08,155 --> 00:13:11,300
这是在一个叫做c的语言当中的源代码

280
00:13:11,300 --> 00:13:14,380
它现在被储存在一个叫做hello.c的文件当中

281
00:13:14,380 --> 00:13:16,180
现在看看屏幕底部

282
00:13:16,180 --> 00:13:17,890
再次说明今后的几周我们会更详细介绍这个

283
00:13:17,890 --> 00:13:19,570
但是这是一个我们称之为的视窗终端

284
00:13:19,570 --> 00:13:21,290
这是一个一闪一闪的黑白光标

285
00:13:21,290 --> 00:13:24,390
这是一个传统的电脑界面，大体用于

286
00:13:24,390 --> 00:13:27,050
一些没有鼠标或者其他图像元素的电脑之上

287
00:13:27,050 --> 00:13:28,320
它只需要用你的键盘

288
00:13:28,320 --> 00:13:30,970
然后我可以在这个闪烁的光标上面输入命令

289
00:13:30,970 --> 00:13:33,820
然后为了今天的目标，我仅会输入以下

290
00:13:33,820 --> 00:13:35,610
显示你好

291
00:13:35,610 --> 00:13:39,370
然后这个程序就运行了，就像在如今现实世界当中

292
00:13:39,370 --> 00:13:40,690
我们在上面双击一样

293
00:13:40,690 --> 00:13:44,580
但是在今天这个界面上面，我们将会在这个窗口里面打上它的名字

294
00:13:44,580 --> 00:13:47,980
make hello真的会帮我建立一个叫做hello的程序

295
00:13:47,980 --> 00:13:51,360
它会查找一个文件，在默认状态之下，

296
00:13:51,360 --> 00:13:53,460
叫做hello.c

297
00:13:53,460 --> 00:13:57,260
它会假设我天生需要一个C程序

298
00:13:57,260 --> 00:13:58,230
这个电脑的默认程式就是这样

299
00:13:58,230 --> 00:13:59,550
然后我敲回车键

300
00:13:59,550 --> 00:14:02,050
我看到一些密码表示的输出，但是这些将会变得

301
00:14:02,050 --> 00:14:03,330
在短时间内过于熟悉

302
00:14:03,330 --> 00:14:06,870
这个正好在那个时候运行一个或者更多个编译器，叫做Clang

303
00:14:06,870 --> 00:14:09,080
但是现在，我只有一个另外的闪标

304
00:14:09,080 --> 00:14:13,060
然后我现在打./，我会在

305
00:14:13,060 --> 00:14:14,730
下周说明我为什么要干这些

306
00:14:14,730 --> 00:14:15,910
你好

307
00:14:15,910 --> 00:14:19,650
所以到现在干的事情只是为了编写一个最简单的程序

308
00:14:19,650 --> 00:14:22,640
在我敲回车的时候，干这个事情

309
00:14:22,640 --> 00:14:24,510
这样我就写了我第一个程序

310
00:14:24,510 --> 00:14:27,500
我故意在这个程序上面找乐子是因为

311
00:14:27,500 --> 00:14:28,540
几个原因

312
00:14:28,540 --> 00:14:31,990
第一，你们可能很快就对这个课没有兴趣了

313
00:14:31,990 --> 00:14:33,430
如果这就结束了的话

314
00:14:33,430 --> 00:14:37,100
但是除此之外，这上面有很多干扰项

315
00:14:37,100 --> 00:14:40,640
当你第一次学编程的时候，对于你们当中那些比较不习惯的人

316
00:14:40,640 --> 00:14:43,410
甚至当年的我，当我第一次看到类似的东西的时候

317
00:14:43,410 --> 00:14:46,500
你可能会觉得，好的，这是最后显示了你好世界

318
00:14:46,500 --> 00:14:47,860
但是这里面费了很多劲

319
00:14:47,860 --> 00:14:52,110
这屏幕上有太多语句

320
00:14:52,110 --> 00:14:54,170
以至于它妨碍了一些其实很简单的信息的表达

321
00:14:54,170 --> 00:14:56,700
所以我们今天要做的事就是把C放在一边

322
00:14:56,700 --> 00:14:57,630
我们下周一再回头来说它

323
00:14:57,630 --> 00:15:00,860
我们会用一个文字编程语言叫做Scratch

324
00:15:00,860 --> 00:15:04,470
这是一个我在周三没有讲的程序语言

325
00:15:04,470 --> 00:15:08,870
它会让我们可以做同样的事情但是不用那么复杂

326
00:15:08,870 --> 00:15:12,270
不用理今天那些大括号，括弧，冒号还有那些愚蠢的

327
00:15:12,270 --> 00:15:15,680
干扰人的元素，第一天看一些基本的比较

328
00:15:15,680 --> 00:15:17,230
有趣的想法

329
00:15:17,230 --> 00:15:21,350
所以为了那个目的，我会回到我的桌面

330
00:15:21,350 --> 00:15:25,890
然后向你介绍那个程序的另一种写法

331
00:15:25,890 --> 00:15:30,790
这将会看起来像这样

332
00:15:30,790 --> 00:15:33,930
这就是我将怎样运行那个相同的程序，两个拼图块

333
00:15:33,930 --> 00:15:37,710
当合在一起并被点击的时候，会向世界说

334
00:15:37,710 --> 00:15:39,000
你好世界

335
00:15:39,000 --> 00:15:41,200
让我们开始吧

336
00:15:41,200 --> 00:15:44,965
我将打开一个网站叫做scratch.mit.edu

337
00:15:47,980 --> 00:15:52,040
然后这将会把我带到这个网站

338
00:15:52,040 --> 00:15:54,660
在此之前我已经登录过这个网站，第一个问题

339
00:15:54,660 --> 00:15:55,910
当中我将会带你进行以下几个步骤

340
00:15:55,910 --> 00:15:58,930
我来点击我的scratch文件夹

341
00:15:58,930 --> 00:16:00,720
然后这个会显示一些我

342
00:16:00,720 --> 00:16:02,570
之前创建的项目

343
00:16:02,570 --> 00:16:05,860
其实这个程序语言不仅仅可以

344
00:16:05,860 --> 00:16:08,480
让我们通过拖拉和放置这些拼图块来编程

345
00:16:08,480 --> 00:16:09,730
你甚至都不需要特殊的软件

346
00:16:09,730 --> 00:16:13,190
这些全部融合在一个浏览器当中，所以你理论上可以

347
00:16:13,190 --> 00:16:16,810
在你自己的电脑上编程，可能你们中的有些人已经开始了

348
00:16:16,810 --> 00:16:19,870
甚至不需要CS50应用程序，那个下周才到

349
00:16:19,870 --> 00:16:24,200
我道这边的角上点击创建

350
00:16:24,200 --> 00:16:27,840
等下我会看到一个空白的屏幕

351
00:16:27,840 --> 00:16:30,380
我可以在这个屏幕上开始在一个图形编程空间当中开始编程

352
00:16:30,380 --> 00:16:36,140
这次，干这个事会实际上简单得多

353
00:16:36,140 --> 00:16:41,560
等一会，等网络完成传输的时候，我们在屏幕上看到这个

354
00:16:41,560 --> 00:16:44,870
快速得给你介绍一下，但是我敢说，当你深入这

355
00:16:44,870 --> 00:16:46,840
第一组问题的时候，你会发现这很

356
00:16:46,840 --> 00:16:48,315
建议并且直观

357
00:16:48,315 --> 00:16:50,900
让我们先在脑中大概想象一下

358
00:16:50,900 --> 00:16:54,620
在这个下面的应用框显示的是保存更改，你会看见scratch

359
00:16:54,620 --> 00:16:55,570
这是一个小精灵，

360
00:16:55,570 --> 00:16:56,630
这是一个人物

361
00:16:56,630 --> 00:17:00,740
它住在我们称之为一个舞台的地方，这个大的白色矩形

362
00:17:00,740 --> 00:17:03,120
在上面它可以向上下左右移动，然后

363
00:17:03,120 --> 00:17:04,670
做各种其他类型的动作

364
00:17:04,670 --> 00:17:08,780
同时，在这个用户界面的中间，

365
00:17:08,780 --> 00:17:09,750
我们有一堆拼图块

366
00:17:09,750 --> 00:17:14,060
你会发现这上面显示类似移动10步，转动15度

367
00:17:14,060 --> 00:17:15,550
指向一个特定的方向

368
00:17:15,550 --> 00:17:17,910
但是这上面有分各种类型的方块

369
00:17:17,910 --> 00:17:21,410
所以说如果我进入外观，你会看到有其它种类的拼图块

370
00:17:21,410 --> 00:17:25,530
很显然会让这个人物说你好，去想，出现

371
00:17:25,530 --> 00:17:26,780
或者隐藏

372
00:17:26,780 --> 00:17:30,830
如果去我声音设置里面，那里有让你播放类似喵的声音的方法

373
00:17:30,830 --> 00:17:32,670
停止所有声音，打鼓

374
00:17:32,670 --> 00:17:36,530
所以长话短说，这里有一大堆可以帮助你

375
00:17:36,530 --> 00:17:40,920
指导这个猫，或者任何数量的其他人物去做什么

376
00:17:40,920 --> 00:17:43,850
但是为了使这些发生你需要开始编程

377
00:17:43,850 --> 00:17:48,090
然后这边这个大白框或者右手边的黑框

378
00:17:48,090 --> 00:17:50,170
是我实际上会拉放这些拼图块的地方

379
00:17:50,170 --> 00:17:54,320
那相当于是我的等同于空白窗口的地方

380
00:17:54,320 --> 00:17:57,070
那么我就去点击中间的控制键

381
00:17:57,070 --> 00:17:58,540
或者，让我在事件选项下面开始

382
00:17:58,540 --> 00:18:01,530
在事件选项下，你会注意到一些刻意

383
00:18:01,530 --> 00:18:05,240
不同的形状设置使得它们无法合在一起

384
00:18:05,240 --> 00:18:06,710
在拼图块的顶端

385
00:18:06,710 --> 00:18:10,160
那是因为它们区分一个程序的开始

386
00:18:10,160 --> 00:18:11,910
或者说一段文本的开始

387
00:18:11,910 --> 00:18:16,290
如果我点击绿色旗子然后拖拽

388
00:18:16,290 --> 00:18:18,060
我想让猫先说些什么东西

389
00:18:18,060 --> 00:18:20,510
那么我先到外观控制面板

390
00:18:20,510 --> 00:18:24,060
然后我拖拽说你好这个方块然后把它放置

391
00:18:24,060 --> 00:18:27,220
让它自动拼接

392
00:18:27,220 --> 00:18:28,640
然后我发现我可以在文字上面点击

393
00:18:28,640 --> 00:18:31,960
然后我可以编辑然后让它更加具体，比如说，你好世界

394
00:18:31,960 --> 00:18:36,340
现在我们就有了那个我说等同于那个

395
00:18:36,340 --> 00:18:39,670
复杂得多的在C语言环境下的程序

396
00:18:39,670 --> 00:18:43,130
如果我现在到左手边，请注意那里有个大大的停止标志

397
00:18:43,130 --> 00:18:44,520
和一面大的绿色旗子

398
00:18:44,520 --> 00:18:46,390
请让我放大以显示清楚一些

399
00:18:46,390 --> 00:18:49,390
当我点击绿色旗子的时候，你应该能够猜到这第一

400
00:18:49,390 --> 00:18:51,920
个程序会做些什么

401
00:18:51,920 --> 00:18:55,420
那么这样我们在编程，但我们不会被一些东西干扰

402
00:18:55,420 --> 00:18:58,980
在一些细致的句法和细节当中

403
00:18:58,980 --> 00:19:01,120
让我们再试试一个更有趣的事情

404
00:19:01,120 --> 00:19:04,840
让我进入我的Scratch文件夹

405
00:19:04,840 --> 00:19:10,210
让我在这里打开一个单独的文件夹

406
00:19:10,210 --> 00:19:17,830
放大这个窗口，打开文件，然后我来做今天

407
00:19:17,830 --> 00:19:18,620
的源目录

408
00:19:18,620 --> 00:19:21,660
和往常一样，你会发现，从今天起，今天的所有例子

409
00:19:21,660 --> 00:19:25,225
都可以在课程网站上找到

410
00:19:25,225 --> 00:19:31,170
我会在这里选一点不同的东西

411
00:19:31,170 --> 00:19:33,970
这个我需要一个志愿者

412
00:19:33,970 --> 00:19:36,850
谁今天想要盏台灯？

413
00:19:36,850 --> 00:19:40,600
好，不如找个更---你在最后吗？

414
00:19:40,600 --> 00:19:42,124
下来吧

415
00:19:42,124 --> 00:19:47,230
好的，你想不想参加我们的活动？还是就想要台灯？

416
00:19:47,230 --> 00:19:48,190
瓦妮莎：听不清

417
00:19:48,190 --> 00:19:48,465
大卫马兰：好的

418
00:19:48,465 --> 00:19:49,610
棒极了，你叫什么名字？

419
00:19:49,610 --> 00:19:49,990
瓦妮莎？

420
00:19:49,990 --> 00:19:50,570
我叫大卫

421
00:19:50,570 --> 00:19:51,390
高兴认识你

422
00:19:51,390 --> 00:19:53,840
上来吧，瓦妮莎会控制我的

423
00:19:53,840 --> 00:19:55,490
键盘一段时间

424
00:19:55,490 --> 00:19:57,850
为了节省时间，我意识到

425
00:19:57,850 --> 00:20:01,070
无限网络有点慢，Scratch，我们这个编程环境

426
00:20:01,070 --> 00:20:04,110
可以被下载下来在你自己的电脑上面使用

427
00:20:04,110 --> 00:20:06,360
所以我在上课之前为了以防万一下载了

428
00:20:06,360 --> 00:20:09,120
所有我们有可能用到的文件，这样它们就可以比

429
00:20:09,120 --> 00:20:10,840
在我电脑上面运行得更快一些了

430
00:20:10,840 --> 00:20:13,460
那就是为什么现在我看到了一个Mac专属的界面

431
00:20:13,460 --> 00:20:15,510
我来打开这个

432
00:20:15,510 --> 00:20:18,400
窗口全屏

433
00:20:18,400 --> 00:20:21,740
你会发现我们可以很快地，像这个学生一样

434
00:20:21,740 --> 00:20:26,360
你们的学长，从你好世界到一个更加有意思的

435
00:20:26,360 --> 00:20:27,020
应用

436
00:20:27,020 --> 00:20:28,180
这里是说明

437
00:20:28,180 --> 00:20:29,500
哦，还有件事

438
00:20:29,500 --> 00:20:31,640
我觉得这样可能有意思，因为我们平时

439
00:20:31,640 --> 00:20:32,440
摄像都是朝着这个方向的

440
00:20:32,440 --> 00:20:34,100
我觉得如果我们可以通过瓦妮莎的

441
00:20:34,100 --> 00:20:35,120
眼睛看世界

442
00:20:35,120 --> 00:20:36,670
所以这里我们有些谷歌眼镜

443
00:20:36,670 --> 00:20:39,290
（惊讶的喘气）

444
00:20:39,290 --> 00:20:41,610
我们今天只会送台灯

445
00:20:41,610 --> 00:20:43,530
（笑声）

446
00:20:43,530 --> 00:20:45,260
让我把这个设置起来

447
00:20:45,260 --> 00:20:49,340
好的，先点这个

448
00:20:49,340 --> 00:20:51,910
Ok, Glass，录一段视频

449
00:20:55,700 --> 00:20:56,950
好的，瓦妮莎？

450
00:21:00,940 --> 00:21:05,560
好的，现在题外话说一下，如果你

451
00:21:05,560 --> 00:21:08,540
稍微向右上方看一下的话，你会看到真的镜片

452
00:21:08,540 --> 00:21:09,650
你会看到一个矩形的窗口

453
00:21:09,650 --> 00:21:11,500
你应该能看到你的同学们在被拍摄？

454
00:21:11,500 --> 00:21:11,840
是的

455
00:21:11,840 --> 00:21:12,340
瓦妮莎：是的

456
00:21:12,340 --> 00:21:12,920
大卫马兰：好的

457
00:21:12,920 --> 00:21:15,170
那好啦

458
00:21:15,170 --> 00:21:16,660
我们迟些会放出这些影像

459
00:21:16,660 --> 00:21:18,460
现在先把你的注意力转向屏幕

460
00:21:18,460 --> 00:21:20,990
这门课的之前学生所做的是在屏幕上放一些指示

461
00:21:20,990 --> 00:21:22,670
通过只是用一个画图程序

462
00:21:22,670 --> 00:21:25,040
所以你马上就可以按方向键开始

463
00:21:25,040 --> 00:21:27,790
然后一些拼图块就会开始在屏幕上出现

464
00:21:27,790 --> 00:21:30,900
然后你只要敲方向键，就像在真的DDR当中一样，根据指示

465
00:21:30,900 --> 00:21:32,740
让它们跟那些箭头方向一样

466
00:21:32,740 --> 00:21:33,020
瓦妮莎：好的

467
00:21:33,020 --> 00:21:33,800
大卫马兰：你之前玩过这个吧

468
00:21:33,800 --> 00:21:34,140
瓦妮莎：是的

469
00:21:34,140 --> 00:21:37,330
好的瓦妮莎，开始吧

470
00:21:37,330 --> 00:22:53,082
（音乐 - 侃爷，“更强”）

471
00:22:53,082 --> 00:22:57,080
（鼓掌）

472
00:22:57,080 --> 00:22:59,750
大卫马兰：那我们现在从那个更进一步

473
00:22:59,750 --> 00:23:01,230
显然，那才是最后的成果

474
00:23:01,230 --> 00:23:02,880
你好世界不是最后的成果

475
00:23:02,880 --> 00:23:05,520
但是你不一定要弄这么互动的东西

476
00:23:05,520 --> 00:23:06,810
你也可以做动画

477
00:23:06,810 --> 00:23:10,790
例如，你们之前的一个学生做了这个程序

478
00:23:10,790 --> 00:23:14,100
比起创建一个游戏来说这个更是说了个故事

479
00:23:14,100 --> 00:23:19,180
我们来打开同样的资料目录中的一个程序

480
00:23:19,180 --> 00:23:20,300
从今天的目录中

481
00:23:20,300 --> 00:23:26,990
让我来开始看看一个饼干的爱情故事

482
00:23:26,990 --> 00:23:30,750
我不想把这个搞得太学术，但是当你看的时候，想想

483
00:23:30,750 --> 00:23:34,030
我们今天讲的简单的编程概念中的哪些

484
00:23:34,030 --> 00:23:34,630
到目前为止

485
00:23:34,630 --> 00:23:39,250
变量，循环，条件之类，这个同学可能在

486
00:23:39,250 --> 00:23:41,090
这些形象的表达当中用到了

487
00:23:41,090 --> 00:23:41,760
请看

488
00:23:41,760 --> 00:23:44,118
请看一个饼干的爱情故事

489
00:23:44,118 --> 00:24:06,030
（音乐 - 绿日，“假日”）

490
00:24:06,030 --> 00:24:08,022
(咔)

491
00:24:08,022 --> 00:24:09,272
（音乐 - 乌龟乐队，“开心在一起”）

492
00:24:58,328 --> 00:25:00,560
大卫马兰：好的，我们看到了一个饼干的爱情故事

493
00:25:00,560 --> 00:25:01,360
但即使在那里 -

494
00:25:01,360 --> 00:25:01,755
（鼓掌）

495
00:25:01,755 --> 00:25:08,110
大卫马兰：好的，即使在这里，请想想，在这些心从

496
00:25:08,110 --> 00:25:10,410
屏幕底部到顶部的时候，实际上是有一点点

497
00:25:10,410 --> 00:25:11,440
随机性的

498
00:25:11,440 --> 00:25:14,150
而事实上，我们可以看到，即使在
最简单的环境中，如

499
00:25:14,150 --> 00:25:18,180
Scratch，就像在C语言中一样，你可以生成随机数，或者制造随机的

500
00:25:18,180 --> 00:25:21,110
幻象，从而使这个游戏的趣味性更提升一步

501
00:25:21,110 --> 00:25:23,390
比起你每一步都用代码设计好来说

502
00:25:23,390 --> 00:25:26,360
在你们看到的这些动作中，有一些反应性

503
00:25:26,360 --> 00:25:28,840
当男姜饼人碰到女姜饼人，她

504
00:25:28,840 --> 00:25:30,000
看上去向远处移动了一点

505
00:25:30,000 --> 00:25:33,580
因此，事实上，你可以在大多是编程语言当中实现

506
00:25:33,580 --> 00:25:38,680
事件的概念，就是如果一只手碰到另外一只手，那可能触发使得

507
00:25:38,680 --> 00:25:41,270
你的一些源代码得到实际执行

508
00:25:41,270 --> 00:25:43,740
你可以在听到刚刚屏幕上的这样的东西

509
00:25:43,740 --> 00:25:47,310
那么让我们来快速回顾一下一些我们能用到的基本元素

510
00:25:47,310 --> 00:25:48,790
来实现这些目标

511
00:25:48,790 --> 00:25:51,630
那么这里就是我们今后会用的语句

512
00:25:51,630 --> 00:25:55,030
在Scratch当中的语句是紫色的，像这样

513
00:25:55,030 --> 00:25:56,120
但是那是有任意性的

514
00:25:56,120 --> 00:26:00,140
一个语句只是一块拼图，或者更笼统地说，一个指令，即

515
00:26:00,140 --> 00:26:03,370
告诉电脑执行任务，一个声明。

516
00:26:03,370 --> 00:26:04,680
这里有个简单的范例

517
00:26:04,680 --> 00:26:05,930
说你好世界

518
00:26:05,930 --> 00:26:08,180
另一种可能是等待一秒

519
00:26:08,180 --> 00:26:10,840
所以在Scratch当中提供的这块拼图，会让你

520
00:26:10,840 --> 00:26:13,050
的人物停止几秒钟

521
00:26:13,050 --> 00:26:15,330
这也是一个语句

522
00:26:15,330 --> 00:26:18,640
接下来我们有另外一个更有意思的，播放喵的声音，还有

523
00:26:18,640 --> 00:26:21,480
这个小箭头表示在Scratch当中这是一个下拉菜单

524
00:26:21,480 --> 00:26:22,590
所以你可以导入声音

525
00:26:22,590 --> 00:26:25,095
你可以在Scratch当中录入声音并做其他一些有意思的事情

526
00:26:25,095 --> 00:26:28,450
而那个，同样地，说到最后，也只是一个语句

527
00:26:28,450 --> 00:26:31,250
但是现在让我们介绍一个更有趣的东西，我们称之为

528
00:26:31,250 --> 00:26:32,630
布尔表达式

529
00:26:32,630 --> 00:26:35,180
大写的B，根据一个叫布尔的命名的

530
00:26:35,180 --> 00:26:39,500
而一个布尔表达式只是一个问题或者大体上说，

531
00:26:39,500 --> 00:26:42,980
一条真或假的信息

532
00:26:42,980 --> 00:26:45,830
1或0，是或否

533
00:26:45,830 --> 00:26:48,420
所以它只是一个是非命题

534
00:26:48,420 --> 00:26:52,840
所以这样的一个布尔表达式在Scratch当中看来是一块蓝色的

535
00:26:52,840 --> 00:26:53,560
拼图

536
00:26:53,560 --> 00:26:56,735
它在问一个问题，老鼠下来这个指令，可以是

537
00:26:56,735 --> 00:26:58,430
当然，真或假

538
00:26:58,430 --> 00:27:01,710
那么用Scratch中的这块拼图，你就能检测

539
00:27:01,710 --> 00:27:05,490
一个老鼠是否被人拿下来了

540
00:27:05,490 --> 00:27:06,550
一个和你的程序互动的人

541
00:27:06,550 --> 00:27:08,860
这个有点抽象，但是那边的两个白盒子只是用来

542
00:27:08,860 --> 00:27:09,740
放数字的

543
00:27:09,740 --> 00:27:12,950
所以你可以比较这个数字是否比另外一个小

544
00:27:12,950 --> 00:27:16,180
如果是的话，Scratch会执行这样或者那样的指令

545
00:27:16,180 --> 00:27:17,505
这个更加图像化

546
00:27:17,505 --> 00:27:21,840
如果这个小精灵，这个猫，比方说，实际上碰到了

547
00:27:21,840 --> 00:27:22,510
鼠标指针

548
00:27:22,510 --> 00:27:25,780
因此，如果小箭头在猫上面徘徊，那么这

549
00:27:25,780 --> 00:27:28,030
块拼图将评估为真

550
00:27:28,030 --> 00:27:31,870
这将是真实的，在这种情况下，如果你使用这个布尔表达式，像我们会

551
00:27:31,870 --> 00:27:36,340
过一会儿看到的那样，在一个分叉，你可以要不做这个，要不做那个

552
00:27:36,340 --> 00:27:39,940
就像我们有一个条件语句检查有没有最后一个人

553
00:27:39,940 --> 00:27:40,460
在房间里？

554
00:27:40,460 --> 00:27:42,070
如果是这样，添加一个

555
00:27:42,070 --> 00:27:44,430
否则，别管它了

556
00:27:44,430 --> 00:27:48,650
那么一个布尔表达式可以同时加上“与”语句或者“或”语句

557
00:27:48,650 --> 00:27:53,120
所以你可以把布尔表达式结合在一起然后说这个和这个必须为真

558
00:27:53,120 --> 00:27:54,710
使得整件事为真

559
00:27:54,710 --> 00:27:56,520
这里是一个更现实世界的例子

560
00:27:56,520 --> 00:28:00,060
如果你用了计算机科学50做课程选择，这些复选框

561
00:28:00,060 --> 00:28:03,520
如果你选了课程边上的框当中的是选项

562
00:28:03,520 --> 00:28:07,860
只向我现实Q值是4.5或者更高的

563
00:28:07,860 --> 00:28:10,610
如果你取消它，选不，那就不用管它了

564
00:28:10,610 --> 00:28:13,910
或者类似的，在右边选不和我所选的课程冲突

565
00:28:13,910 --> 00:28:15,650
这可能是真或者假

566
00:28:15,650 --> 00:28:16,715
这只是一个布尔表达式

567
00:28:16,715 --> 00:28:20,080
所以当你使用网站复选框的时候，你只是

568
00:28:20,080 --> 00:28:23,570
在切换相当于一个布尔表达的开和关。

569
00:28:23,570 --> 00:28:25,270
那么你是用什么样的形式使用这些呢？

570
00:28:25,270 --> 00:28:28,820
嗯，在Scratch当中我们会看到在莫一时刻的时候会有条件

571
00:28:28,820 --> 00:28:29,560
跟这个类似

572
00:28:29,560 --> 00:28:33,130
那是明智的因为跟伪代码很像，我们缩进了

573
00:28:33,130 --> 00:28:38,550
这些类似U形的拼图块，意味着任何在那U形中的

574
00:28:38,550 --> 00:28:41,390
内容被执行与否取决于它在哪里

575
00:28:41,390 --> 00:28:45,310
因此，如果用布尔表达式，则里面无论是什么都会被执行

576
00:28:45,310 --> 00:28:46,800
同时，这里有一个如果/或块

577
00:28:46,800 --> 00:28:50,320
所以如果你想让一个分叉处产生选择，Scratch给我们这种方法

578
00:28:50,320 --> 00:28:54,500
通过这样的逻辑，尽管拼图显然是太小了

579
00:28:54,500 --> 00:28:57,400
如果要把其他东西放在里面的话，Scratch里面的拼图，他们

580
00:28:57,400 --> 00:28:58,150
是可以变大的

581
00:28:58,150 --> 00:29:01,370
当你拖拽过来东西并放在它上面时，它就会变化来符合

582
00:29:01,370 --> 00:29:02,510
你想执行的操作

583
00:29:02,510 --> 00:29:07,230
所以我们可以拿两样这种东西制造一个三项选择分叉

584
00:29:07,230 --> 00:29:11,300
使得你可以做这个，那个，或者另外一个操作，通过嵌套他们

585
00:29:11,300 --> 00:29:12,070
通过那种方式

586
00:29:12,070 --> 00:29:14,370
当然，如果你做得太多，它就会开始变得不好看了

587
00:29:14,370 --> 00:29:17,660
但是那时候你实际上有可能还不是编程编得很好

588
00:29:17,660 --> 00:29:20,490
所以那将会成为一个不断重复的主题，风格方面的

589
00:29:20,490 --> 00:29:22,790
问题在于你将你代码的格式弄得有多好

590
00:29:22,790 --> 00:29:24,580
或者你有多好得设计你的代码

591
00:29:24,580 --> 00:29:26,430
我们以后会谈更多这方面的问题

592
00:29:26,430 --> 00:29:27,470
现在我们有循环

593
00:29:27,470 --> 00:29:30,310
Scratch里面有一个很好的无限循环，它的字面意思就是做

594
00:29:30,310 --> 00:29:32,710
只要在循环中的事一遍一遍再一遍

595
00:29:32,710 --> 00:29:35,880
你也可以更具体得说，做以下的事情10遍

596
00:29:35,880 --> 00:29:37,620
你也可以使用变量

597
00:29:37,620 --> 00:29:40,260
你可以在那个下拉菜单里面写任何名字，然后说给我一个

598
00:29:40,260 --> 00:29:43,190
叫做n的变量使它等于某个特定值

599
00:29:43,190 --> 00:29:44,910
然后你就有功能了

600
00:29:44,910 --> 00:29:46,850
我们等下再讲这个

601
00:29:46,850 --> 00:29:49,140
让我再回到Scratch的界面

602
00:29:49,140 --> 00:29:50,970
并让我继续

603
00:29:50,970 --> 00:29:56,660
让我们打开一个，我看看，一个例子

604
00:29:56,660 --> 00:29:58,740
一个更有趣点的例子

605
00:29:58,740 --> 00:30:00,750
其实，让我自己来做一个

606
00:30:00,750 --> 00:30:01,960
我不需要打开这个

607
00:30:01,960 --> 00:30:03,390
让我去新建文件

608
00:30:03,390 --> 00:30:04,740
我进入事件

609
00:30:04,740 --> 00:30:08,460
我要去绿旗，点击，我进入声音

610
00:30:08,460 --> 00:30:11,590
我要拖放一块拼图，播放声音喵。

611
00:30:11,590 --> 00:30:12,580
它合在一起了

612
00:30:12,580 --> 00:30:14,327
而现在，如果我点击绿旗

613
00:30:14,327 --> 00:30:16,260
（喵的声音）

614
00:30:16,260 --> 00:30:17,500
大卫马兰：挺可爱的

615
00:30:17,500 --> 00:30:21,560
好啦，现在我们来做一点更有逻辑性的东西，只是为了演示

616
00:30:21,560 --> 00:30:22,760
我们现在可以做这些

617
00:30:22,760 --> 00:30:25,550
我要把这个从这东西上面解锁

618
00:30:25,550 --> 00:30:27,000
我进入控制

619
00:30:27,000 --> 00:30:28,770
我要拖一个条件

620
00:30:28,770 --> 00:30:30,600
如果符合这个条件，那就怎样

621
00:30:30,600 --> 00:30:32,020
所以那就是这个看起来是怎样的

622
00:30:32,020 --> 00:30:33,890
所以我需要一个布尔表达式

623
00:30:33,890 --> 00:30:38,130
让我进入操作

624
00:30:38,130 --> 00:30:40,270
我马上准备做一些带点数学性的东西，只是为了好玩

625
00:30:40,270 --> 00:30:43,600
我马上进入然后命令如果一个东西比另一个东西少，

626
00:30:43,600 --> 00:30:45,030
那我们就执行一个命令

627
00:30:45,030 --> 00:30:46,890
所以，现在，你看一个随机块

628
00:30:46,890 --> 00:30:51,620
所以请注意，如果我悬停在这东西上面，那将卡在那里

629
00:30:51,620 --> 00:30:54,090
所以现在请注意，我已经开始做一件逻辑上来说更加

630
00:30:54,090 --> 00:30:54,650
有趣的事情了

631
00:30:54,650 --> 00:30:59,720
如果一个1到10之间的随机数比，比方说6小的话

632
00:30:59,720 --> 00:31:03,670
如果我选择6，那实际上就是说，做以下的事情有50%的

633
00:31:03,670 --> 00:31:03,980
概率

634
00:31:03,980 --> 00:31:05,460
这就像抛硬币

635
00:31:05,460 --> 00:31:07,330
现在，我可以有条件地做一些事情

636
00:31:07,330 --> 00:31:10,800
而我要做的就是播放声音

637
00:31:10,800 --> 00:31:14,280
所以，现在，当我点击屏幕上的旗子时就好像抛硬币

638
00:31:14,280 --> 00:31:14,610
（喵叫声）

639
00:31:14,610 --> 00:31:17,160
大卫马兰：可能是抛到正面了（或者反面）

640
00:31:17,160 --> 00:31:17,920
让我们再做一次

641
00:31:17,920 --> 00:31:18,860
（喵叫声）

642
00:31:18,860 --> 00:31:19,790
大卫米兰：又是正面

643
00:31:19,790 --> 00:31:20,280
（喵叫声）

644
00:31:20,280 --> 00:31:21,500
大卫米兰：又是正面

645
00:31:21,500 --> 00:31:22,631
呼，好的

646
00:31:22,631 --> 00:31:24,720
终于抛到反面了

647
00:31:24,720 --> 00:31:29,545
因此，如果我们做这个无线长的时间，我们有50%的几率获得50%的猫叫声

648
00:31:29,545 --> 00:31:32,180
和50％的不出声

649
00:31:32,180 --> 00:31:34,850
那个只是一个基本的让我们做到这一点的元素

650
00:31:34,850 --> 00:31:37,710
但是我需要不停地点那个按钮是有点繁琐的

651
00:31:37,710 --> 00:31:39,810
因此，让我们把那些都拖走

652
00:31:39,810 --> 00:31:42,270
如果你把它们拖到中间，它们自己就会删除掉了

653
00:31:42,270 --> 00:31:43,760
让我再进入控制

654
00:31:43,760 --> 00:31:46,060
选择永远

655
00:31:46,060 --> 00:31:49,952
而这个时候，我要办一件有点烦人的事

656
00:31:49,952 --> 00:31:51,560
（笑声）

657
00:31:51,560 --> 00:31:53,370
大卫马兰：让我再次进入控制

658
00:31:53,370 --> 00:31:57,260
等待一秒钟，为了让它不要太烦人

659
00:31:57,260 --> 00:31:59,870
（猫叫声）

660
00:31:59,870 --> 00:32:00,970
大卫马兰：那有点不自然

661
00:32:00,970 --> 00:32:01,861
好的

662
00:32:01,861 --> 00:32:04,510
（猫叫声）

663
00:32:04,510 --> 00:32:06,406
大卫马兰：请注意，Scratch的好处是，对于你们中间那些

664
00:32:06,406 --> 00:32:09,210
有编程经验的人，你不需要开始和停止操作

665
00:32:09,210 --> 00:32:10,060
你不需要进行编译

666
00:32:10,060 --> 00:32:13,210
你只需要改变它，程序会动态地适应它

667
00:32:13,210 --> 00:32:14,620
因此这开始变得有点意思了

668
00:32:14,620 --> 00:32:16,930
但是让我们更进一步。

669
00:32:16,930 --> 00:32:19,760
让我们取消这个程序。

670
00:32:19,760 --> 00:32:23,300
（猫叫声）

671
00:32:23,300 --> 00:32:25,520
大卫马兰：那就是我们称之为一个Scratch当中程序错误的东西

672
00:32:25,520 --> 00:32:26,770
他不应该还发出那声音。

673
00:32:26,770 --> 00:32:28,340
所以我们会告诉他停下来。

674
00:32:28,340 --> 00:32:30,435
好，那么现在我要进入

675
00:32:30,435 --> 00:32:32,180
我会让麻省理工知道。

676
00:32:32,180 --> 00:32:35,160
我们选择永远。

677
00:32:35,160 --> 00:32:37,240
而现在，我想要一遍一遍地做一件事情。

678
00:32:37,240 --> 00:32:38,760
我要进入​​控制。

679
00:32:38,760 --> 00:32:41,570
我看看，我拖拽我的如果条件语句过来。

680
00:32:41,570 --> 00:32:42,850
那么现在注意这个逻辑。

681
00:32:42,850 --> 00:32:46,430
当点击绿旗，无限执行某操作，但是仅仅在

682
00:32:46,430 --> 00:32:48,890
另外一个条件达到的情况下才做这件事

683
00:32:48,890 --> 00:32:51,480
我会选，我看看，传感。

684
00:32:51,480 --> 00:32:54,430
然后我会选触碰然后把它放在这。

685
00:32:54,430 --> 00:32:55,930
这是一个布尔表达式。

686
00:32:55,930 --> 00:32:57,740
而现在请注意这个下拉菜单里面有

687
00:32:57,740 --> 00:32:59,050
一些预定义的值。

688
00:32:59,050 --> 00:33:00,910
所以我可以说，你碰到屏幕的边缘了吗？

689
00:33:00,910 --> 00:33:03,900
或者，你碰到了鼠标指针，屏幕上的这个箭头了吗？

690
00:33:03,900 --> 00:33:04,620
我准备做这个。

691
00:33:04,620 --> 00:33:08,770
如果是这样的话，放猫叫声

692
00:33:08,770 --> 00:33:11,250
那么现在我差不多有了一个游戏的开始阶段

693
00:33:11,250 --> 00:33:13,110
一个比较可爱的游戏。

694
00:33:13,110 --> 00:33:14,060
（猫叫声）

695
00:33:14,060 --> 00:33:17,250
大卫马兰：好吧，一个可爱的，有程序错误的游戏。

696
00:33:17,250 --> 00:33:20,770
让我们稍等一下。

697
00:33:20,770 --> 00:33:24,910
好的现在再次播放，点击绿色旗子。

698
00:33:24,910 --> 00:33:27,860
（猫叫声）

699
00:33:27,860 --> 00:33:30,460
大卫马兰：那么现在就像是拍一只猫一样。

700
00:33:30,460 --> 00:33:31,850
（猫叫声）

701
00:33:31,850 --> 00:33:34,460
大卫马兰：好的，在这个里面我确实更进了一步。

702
00:33:34,460 --> 00:33:39,250
最近好像很容易做错事。

703
00:33:39,250 --> 00:33:40,240
让我再进入这里。

704
00:33:40,240 --> 00:33:43,720
让我们把这个命名为拍猫。

705
00:33:43,720 --> 00:33:46,600
现在让我们打开不要拍猫。

706
00:33:46,600 --> 00:33:48,330
现在如果我们播放这个的话，你能猜到，如果你

707
00:33:48,330 --> 00:33:49,650
看这这个屏幕的话

708
00:33:49,650 --> 00:33:51,090
（猫叫声）

709
00:33:51,090 --> 00:33:52,170
大卫米兰：好的，如果现在我拍到猫

710
00:33:52,170 --> 00:33:55,420
（狮吼声）

711
00:33:55,420 --> 00:33:57,260
大卫马兰：所以在这种情况下不要去拍猫了。

712
00:33:57,260 --> 00:34:01,350
那么现在我们有一个一个分叉到两个方向的例子。

713
00:34:01,350 --> 00:34:03,130
现在我打开又一个。

714
00:34:03,130 --> 00:34:07,120
这一个也是在我们今天的源代码文件里面的。

715
00:34:07,120 --> 00:34:13,199
让我回到我的源目录，然后选择

716
00:34:13,199 --> 00:34:15,610
这个看看有什么不同。

717
00:34:15,610 --> 00:34:17,449
哇，好的，现在这个开始有点更复杂了。

718
00:34:17,449 --> 00:34:21,300
在我们看到这个可以干什么之前，让我们试着通过程序来猜测，

719
00:34:21,300 --> 00:34:22,219
右手边的程序。

720
00:34:22,219 --> 00:34:25,590
现在我们可以看到Scratch允许我们有多重文字，好几个

721
00:34:25,590 --> 00:34:29,730
程序和一个人物相关，同时明显地，

722
00:34:29,730 --> 00:34:31,760
它们在运行的时候会步调一致。

723
00:34:31,760 --> 00:34:35,570
因为这两个程序都是由点击绿色旗子这个动作触发的，这是

724
00:34:35,570 --> 00:34:38,650
在考虑一个更加高级的课题，你们中间的有些人可能会比较熟悉，

725
00:34:38,650 --> 00:34:40,580
称之为线程，或者多线程。

726
00:34:40,580 --> 00:34:44,400
你会发现，总而言之，今天的计算机可以做多

727
00:34:44,400 --> 00:34:45,270
件事情，在同一时间。

728
00:34:45,270 --> 00:34:48,659
或者可以很快地一件件做事情以至于你根本觉察不到

729
00:34:48,659 --> 00:34:50,150
那其实是在一次做一件事。

730
00:34:50,150 --> 00:34:53,320
但现在，让我们假设这两个程序会被执行

731
00:34:53,320 --> 00:34:54,310
在同一时间。

732
00:34:54,310 --> 00:34:57,350
请注意，它们两个都有永远这个条件。

733
00:34:57,350 --> 00:35:01,270
因此它们都会在我点红色的停止标志之前一直运行。

734
00:35:01,270 --> 00:35:02,100
那么这些指令能达到什么目的呢？

735
00:35:02,100 --> 00:35:06,030
我很明显地在左手边显示了一个变量称为静音。

736
00:35:06,030 --> 00:35:09,030
所以我没有管它叫N那么无聊的名字，我管它叫静音

737
00:35:09,030 --> 00:35:10,240
这样可以在名字中有意思。

738
00:35:10,240 --> 00:35:11,780
我将它设置等于零。

739
00:35:11,780 --> 00:35:16,200
让我们把这个想象成假，或者把那个想象成假。

740
00:35:16,200 --> 00:35:17,490
现在，无限重复执行以下。

741
00:35:17,490 --> 00:35:23,280
如果按下键盘的空格键，如果这是和静音等于零的话，

742
00:35:23,280 --> 00:35:25,930
将静音改变成等于1。

743
00:35:25,930 --> 00:35:27,580
否则，静音设置为零。

744
00:35:27,580 --> 00:35:30,530
所以从逻辑上讲，即使这是一堆拼图块

745
00:35:30,530 --> 00:35:33,160
只是说，当我打空格键，我应该对变量执行怎样的命令

746
00:35:33,160 --> 00:35:34,750
那个叫做静音的变量？

747
00:35:34,750 --> 00:35:37,170
将它从1变到0，或者从0变到1。

748
00:35:37,170 --> 00:35:37,840
就这么简单。

749
00:35:37,840 --> 00:35:40,740
因此它就像是把一个灯的开关打开或者关闭并且记住这个动作，利用

750
00:35:40,740 --> 00:35:42,330
一个变量，我已经做到了。

751
00:35:42,330 --> 00:35:45,990
同时，在右手边，用门外汉的说法，这个的用途

752
00:35:45,990 --> 00:35:47,547
右边脚本的用途是什么？

753
00:35:47,547 --> 00:35:48,860
学生：播放海狮的声音。

754
00:35:48,860 --> 00:35:52,500
大卫马兰：播放海狮的声音，如果它没有被静音的话，

755
00:35:52,500 --> 00:35:53,480
根据那个变量的性质来说。

756
00:35:53,480 --> 00:35:57,360
因此我们可以说我们是在共用一个状态，或者说，在共享信息，在这两个

757
00:35:57,360 --> 00:36:00,540
脚本之间，引文，你们请注意我们在无限循环地做以下的事情。

758
00:36:00,540 --> 00:36:04,620
如果静音是0，那么它就不是静音的，如果静音为假，那么就播放

759
00:36:04,620 --> 00:36:05,980
海狮的声音。

760
00:36:05,980 --> 00:36:09,930
然后给自己提个醒，稍等两秒钟，然后

761
00:36:09,930 --> 00:36:11,140
再次检查。

762
00:36:11,140 --> 00:36:15,150
因此如果我们现在到左边看，到这个东西的位置，然后点击

763
00:36:15,150 --> 00:36:16,662
绿色旗子，

764
00:36:16,662 --> 00:36:30,260
（海狮叫声）

765
00:36:30,260 --> 00:36:31,910
大卫马兰：这个在什么时候会开始变得讨人嫌了呢？

766
00:36:31,910 --> 00:36:33,440
因为这将只是永远持续下去。

767
00:36:33,440 --> 00:36:36,490
所以有时候，所谓的无限循环，是故意的。

768
00:36:36,490 --> 00:36:41,140
但是，在这种情况下，只要我敲击空格键，它就会停止。

769
00:36:41,140 --> 00:36:42,800
现在这个程序还没有退出。

770
00:36:42,800 --> 00:36:44,760
它仍然运行在这些循环中运行。

771
00:36:44,760 --> 00:36:46,540
但是，如果我再次敲击空格键

772
00:36:46,540 --> 00:36:47,851
（海狮叫声）

773
00:36:47,851 --> 00:36:49,650
大卫马兰：它会继续开始发出声音。

774
00:36:49,650 --> 00:36:53,240
因此，我们又有了一种重复做一件事情的方式，但是这次

775
00:36:53,240 --> 00:36:54,920
是有条件限制的。

776
00:36:54,920 --> 00:36:58,940
好的，当我在一遍遍做事的时候，让我

777
00:36:58,940 --> 00:37:01,370
再举一个这样的例子。

778
00:37:01,370 --> 00:37:04,370
这个我叫做数绵羊。

779
00:37:04,370 --> 00:37:05,710
请注意这个东西能起什么作用。

780
00:37:05,710 --> 00:37:08,540
它实际上更像是我们接触过的伪代码

781
00:37:08,540 --> 00:37:12,230
在周三时候，我们介绍了这个东西作为一个数数的工具，再次把它想象成N

782
00:37:12,230 --> 00:37:14,030
为0的时候，它永远执行以下动作。

783
00:37:14,030 --> 00:37:17,960
它显示以下计数器的值，然后等待一秒，然后

784
00:37:17,960 --> 00:37:19,430
改变这个计数器的值一个单位。

785
00:37:19,430 --> 00:37:21,570
在这个情景夏，这个意味着它使得N的值增加了。

786
00:37:21,570 --> 00:37:23,250
所以他往上面加1。

787
00:37:23,250 --> 00:37:25,830
因此，这实际上

788
00:37:25,830 --> 00:37:27,890
并不是我们所想象的数绵羊的活动。

789
00:37:27,890 --> 00:37:33,120
这是羊在数数，从零开始一直数。

790
00:37:33,120 --> 00:37:35,560
所以从逻辑上来说我们可以在这儿做类似的事情。

791
00:37:35,560 --> 00:37:37,750
但是现在让我试着把这里面的一些事情弄得清楚一些。

792
00:37:37,750 --> 00:37:43,440
让我现在打开一个简单的例子，在这里面我们的猫会

793
00:37:43,440 --> 00:37:44,750
开始咳嗽。

794
00:37:44,750 --> 00:37:48,830
好的，现在这里我们有咳嗽0  -

795
00:37:48,830 --> 00:37:50,685
计算机科学家一般从0开始计数。

796
00:37:50,685 --> 00:37:53,480
因此，猫只是要咳嗽三次。

797
00:37:53,480 --> 00:37:54,890
而这儿是我如何执行这个的。

798
00:37:54,890 --> 00:38:00,130
当点击绿旗子的时候，咳嗽，等待，咳嗽，等待，咳嗽，等待。

799
00:38:00,130 --> 00:38:02,470
而为了做到这个我只是拖拽和释放了一些拼图片而已。

800
00:38:02,470 --> 00:38:04,740
当你开始在Scratch上面做些东西的时候，你会发现其实

801
00:38:04,740 --> 00:38:08,620
你实际上可以复制拼图片从而使得你可以更快地做事情而不用拖拽

802
00:38:08,620 --> 00:38:10,310
和放置到让你觉得烦躁的地步。

803
00:38:10,310 --> 00:38:12,680
但是我们现在是在很好的方向上。

804
00:38:12,680 --> 00:38:15,210
因为我怎样能让他咳嗽第四声？

805
00:38:15,210 --> 00:38:16,790
嗯，我可以往下面选。

806
00:38:16,790 --> 00:38:19,420
我可以复制然后在这里黏贴。

807
00:38:19,420 --> 00:38:21,740
我如何让他咳第五次？

808
00:38:21,740 --> 00:38:23,230
那么，再次复制和粘贴。

809
00:38:23,230 --> 00:38:24,210
或再次拖拽放置。

810
00:38:24,210 --> 00:38:26,920
很快这个程序就会变得非常冗长，

811
00:38:26,920 --> 00:38:28,880
很长，但是很无趣。

812
00:38:28,880 --> 00:38:30,120
但是有一种方法可以解决这个问题。

813
00:38:30,120 --> 00:38:33,680
有什么明显的办法可以把这个程序清理一下？

814
00:38:33,680 --> 00:38:36,280
好的，其实我们可以跳出这个程序，然后点击空格

815
00:38:36,280 --> 00:38:37,070
键，然后让他咳嗽。

816
00:38:37,070 --> 00:38:40,150
但是如果我只是想重复做一样事情的话，请记得我们确实有

817
00:38:40,150 --> 00:38:41,310
一些控制结构。

818
00:38:41,310 --> 00:38:43,800
让我把这个移开，进入控制。

819
00:38:43,800 --> 00:38:47,340
让我来弄一个，比如，三次重复。

820
00:38:47,340 --> 00:38:49,410
现在让我拿一些这里面的拼图块。

821
00:38:49,410 --> 00:38:50,980
让我把这个放在这里。

822
00:38:50,980 --> 00:38:52,400
让我把这些都挪开。

823
00:38:52,400 --> 00:38:55,400
现在我就有了一个设计得更好的程序。

824
00:38:55,400 --> 00:38:55,920
为什么呢？

825
00:38:55,920 --> 00:39:00,540
如果我想改变猫咳嗽的次数，我所需要做的只是

826
00:39:00,540 --> 00:39:05,640
改变一个变量，或者一个值，把三改成四

827
00:39:05,640 --> 00:39:06,700
或者五或六。

828
00:39:06,700 --> 00:39:09,060
或者我身子可以做一些有有条件的，用空格键

829
00:39:09,060 --> 00:39:10,320
如果我想的话。

830
00:39:10,320 --> 00:39:11,780
那么这是一个总的规则。

831
00:39:11,780 --> 00:39:14,950
一旦你开始复制和粘贴代码，无论是在Scratch当中，还是在

832
00:39:14,950 --> 00:39:18,340
C当中，你很有可能有事情做得不对。

833
00:39:18,340 --> 00:39:21,950
或者至少，一旦你超过了一些合理的复制次数之后

834
00:39:21,950 --> 00:39:24,610
和粘贴，你有可能有什么事情干错了。

835
00:39:24,610 --> 00:39:26,740
但你知道吗？

836
00:39:26,740 --> 00:39:27,590
我当真不喜欢这个。

837
00:39:27,590 --> 00:39:28,980
这还不是最简洁的设计。

838
00:39:28,980 --> 00:39:32,860
我希望可以有一块拼图叫做咳嗽，这样的话我就

839
00:39:32,860 --> 00:39:36,100
不用自己通过老办法来实现这个了

840
00:39:36,100 --> 00:39:38,220
一定要，比如说，等等--

841
00:39:38,220 --> 00:39:40,320
假如它们只是一块咳嗽拼图呢？

842
00:39:40,320 --> 00:39:41,330
嗯，我可以实现那个。

843
00:39:41,330 --> 00:39:45,010
让我进入更多模块，点击创建模块，现在我得到这里这个

844
00:39:45,010 --> 00:39:45,610
窗口。

845
00:39:45,610 --> 00:39:47,540
我来把这个东西命名为咳嗽。

846
00:39:47,540 --> 00:39:49,400
我点击确定。

847
00:39:49,400 --> 00:39:53,150
现在请注意，我有一个心得起始拼图块，上面有弯曲的。

848
00:39:53,150 --> 00:39:56,590
现在我要用这个做的事情就是，我会偷走这些块。

849
00:39:56,590 --> 00:39:57,800
我把它们放在这里。

850
00:39:57,800 --> 00:40:00,490
现在，用这三块，我已经实现了我称之为

851
00:40:00,490 --> 00:40:03,530
方法，或一个过程，或者你们中有些人可能会称之为一个手法。

852
00:40:03,530 --> 00:40:05,050
用词上的细微差别。

853
00:40:05,050 --> 00:40:06,950
但是现在，让我们先称之为一个方法。

854
00:40:06,950 --> 00:40:08,750
这只是一个新的拼图块。

855
00:40:08,750 --> 00:40:11,000
现在它是这样被实现的。

856
00:40:11,000 --> 00:40:15,170
但是请注意Scratch给了我们一个对于那一整块的

857
00:40:15,170 --> 00:40:16,570
具象表示。

858
00:40:16,570 --> 00:40:21,930
现在，我把这个拖到这边，比如，重复三次，那么

859
00:40:21,930 --> 00:40:26,420
这时将要发生的事情，当我运行这个脚本的时候，是只有一次

860
00:40:26,420 --> 00:40:27,500
只有一个程序在运行。

861
00:40:27,500 --> 00:40:29,880
当点击绿旗的时候只有一个。

862
00:40:29,880 --> 00:40:34,010
但是那个紫色的叫做咳嗽的方块有效地告诉Scratch，每一

863
00:40:34,010 --> 00:40:38,160
次你看到这块拼图的时候，真正执行这些步骤

864
00:40:38,160 --> 00:40:40,420
我之前手动执行的这些。

865
00:40:40,420 --> 00:40:41,410
那么这样就整洁得多了。

866
00:40:41,410 --> 00:40:44,650
但是现在，假设我决定我不要这个猫只是咳嗽。

867
00:40:44,650 --> 00:40:46,660
我希望它也能打喷嚏。

868
00:40:46,660 --> 00:40:48,905
那么，我们怎么能实现打喷嚏呢？

869
00:40:48,905 --> 00:40:51,310
好吧，我差不多可以重复同样的事情。

870
00:40:51,310 --> 00:40:52,690
我可创建另外一个模块。

871
00:40:52,690 --> 00:40:55,940
我可以把这个叫做喷嚏，单击“确定”。

872
00:40:55,940 --> 00:40:59,250
接下来，在这边我可以实际上有，让我来复制这个--

873
00:40:59,250 --> 00:41:02,850
而这就是你应该感觉到你有可能不是在用

874
00:41:02,850 --> 00:41:03,780
最好的办法做有些事情。

875
00:41:03,780 --> 00:41:06,670
我可以花一秒钟说啊嚏，

876
00:41:06,670 --> 00:41:07,440
等待一秒钟。

877
00:41:07,440 --> 00:41:08,715
现在我有了一个新的块叫做喷嚏。

878
00:41:08,715 --> 00:41:10,210
实际上，它就在那里。

879
00:41:10,210 --> 00:41:14,010
但是这个同样，会开始显得，可能不是这一周，但是

880
00:41:14,010 --> 00:41:15,730
下周时你会感觉到有点多余。

881
00:41:15,730 --> 00:41:17,800
显然，这儿的有些步骤有些多余。

882
00:41:17,800 --> 00:41:22,090
因此我提议我们转而将这个定义细化如下。

883
00:41:22,090 --> 00:41:24,820
让我回到我的文件菜单。

884
00:41:24,820 --> 00:41:26,090
我不保存这个版本了。

885
00:41:26,090 --> 00:41:29,080
我进入我之前做好的文件之一。

886
00:41:29,080 --> 00:41:31,190
我打开咳嗽2

887
00:41:31,190 --> 00:41:32,220
哎呀，那是咳嗽2。

888
00:41:32,220 --> 00:41:36,900
让我打开咳嗽3，是个源目录。

889
00:41:36,900 --> 00:41:42,450
咳嗽3及通告。哦，我刚刚讲的故事顺序错误了。

890
00:41:42,450 --> 00:41:45,030
让我重新回到这个故事中来。

891
00:41:45,030 --> 00:41:48,990
我想讲的故事以咳嗽4结尾

892
00:41:48,990 --> 00:41:50,270
找到了。

893
00:41:50,270 --> 00:41:54,380
那么如果我另而将一个更大块的拼图定义为

894
00:41:54,380 --> 00:41:57,250
说一个词n次。

895
00:41:57,250 --> 00:41:59,930
很显然在Scratch当中打喷嚏的声音是阿嚏

896
00:41:59,930 --> 00:42:01,680
我们把它当做一个词来表达，只是因为那是

897
00:42:01,680 --> 00:42:02,750
程序的约束。

898
00:42:02,750 --> 00:42:07,860
咳嗽的声音是（咳嗽），但是咳嗽的英文单词，cough的拼法是C-O-U-G-H。这么看来这两个

899
00:42:07,860 --> 00:42:10,820
不同的词其实是在做同样的事情。

900
00:42:10,820 --> 00:42:12,820
所以我其实可以建立一个像这个一样的新块。

901
00:42:12,820 --> 00:42:14,220
我之前没有使用过这个菜单选项。

902
00:42:14,220 --> 00:42:16,960
但是当你点击创建方块时，你可以选择一些选项。

903
00:42:16,960 --> 00:42:20,900
你可以让这个块实际上需要一定的输入，或者叫做

904
00:42:20,900 --> 00:42:24,710
参数，这样你可以修改你方块的

905
00:42:24,710 --> 00:42:25,520
动作。

906
00:42:25,520 --> 00:42:28,780
那么我刚刚做的事情是把这个方块叫做说

907
00:42:28,780 --> 00:42:30,880
让后我说，它需要一个字符串输入。

908
00:42:30,880 --> 00:42:32,810
现在注意，在默认情况下它说串1。

909
00:42:32,810 --> 00:42:35,440
一个字符串就是一个词，或者一个短语，为了达到一个目的。

910
00:42:35,440 --> 00:42:37,810
但是我现在就仅仅准备放一些占位符在这儿，就像在一个

911
00:42:37,810 --> 00:42:40,620
网站上，当你看到用户名，或者密码，然后它就消失了

912
00:42:40,620 --> 00:42:41,550
当你开始打字的时候。

913
00:42:41,550 --> 00:42:42,720
这就是这些占位符。

914
00:42:42,720 --> 00:42:44,590
现在我要加上一个数字输入。

915
00:42:44,590 --> 00:42:47,180
我会把这个叫做n--但是这是相当随意的。

916
00:42:47,180 --> 00:42:49,510
只是加上一个标签，只是为了使这个方块更加有自我

917
00:42:49,510 --> 00:42:50,570
说明性--

918
00:42:50,570 --> 00:42:53,010
次数，这是我刚刚做的

919
00:42:53,010 --> 00:42:56,540
而最终的结果是，我得到像这样的一个块。

920
00:42:56,540 --> 00:42:58,880
现在请注意，我用一个重复的方块。

921
00:42:58,880 --> 00:43:03,480
但是我并没有完整地编程出三个，我只是在里面拖拽和放置n使得我

922
00:43:03,480 --> 00:43:05,530
可以让这个功能参数化。

923
00:43:05,530 --> 00:43:08,590
我可以让这个功能做一件事情不同的次数，基于

924
00:43:08,590 --> 00:43:09,410
那个值。

925
00:43:09,410 --> 00:43:14,270
请注意，如果这是我做的事情，如果我拖一个词，我可以说不是一个

926
00:43:14,270 --> 00:43:17,860
编好固定的词，而是任意一个传输进来的词，持续一秒钟。

927
00:43:17,860 --> 00:43:20,200
同时，我怎样重新实现咳嗽呢？

928
00:43:20,200 --> 00:43:26,980
我重新定义咳嗽为说咳咳n次。

929
00:43:26,980 --> 00:43:30,480
简单来说，我很快地做这些步骤，但是最简单的想法是当你一旦

930
00:43:30,480 --> 00:43:32,750
开始在你的程序中间看到，等等，我之前

931
00:43:32,750 --> 00:43:36,610
已经做过类似的事情了，我能否找出一些共同的

932
00:43:36,610 --> 00:43:37,090
功能？

933
00:43:37,090 --> 00:43:41,090
我能否把我在做的事情分解成一些基本的概念？

934
00:43:41,090 --> 00:43:42,070
那就是我们在做的事情。

935
00:43:42,070 --> 00:43:44,830
而且我已经把这些东西在视觉上重叠堆砌在一起了

936
00:43:44,830 --> 00:43:47,710
因为它证明了那种从二进制开始的想法，进入ASCII，

937
00:43:47,710 --> 00:43:51,530
编写图形程序，把日益复杂的思路放在之前的思路

938
00:43:51,530 --> 00:43:52,570
之上。

939
00:43:52,570 --> 00:43:53,730
这也是同样的道理。

940
00:43:53,730 --> 00:43:56,870
我从操作Scratch开始，设置咳嗽，然后我发现咳嗽

941
00:43:56,870 --> 00:43:58,540
其实只是说什么东西。

942
00:43:58,540 --> 00:44:01,630
那么请允许我另外施行说什么的概念。

943
00:44:01,630 --> 00:44:05,200
与此之外，我是否可以实现打喷嚏或咳嗽？

944
00:44:05,200 --> 00:44:07,990
我们还可以做更多的类似变化。

945
00:44:07,990 --> 00:44:10,400
从这个基本原则开始，我们可以开始做

946
00:44:10,400 --> 00:44:12,180
日益复杂的程序。

947
00:44:12,180 --> 00:44:14,100
让我开这一个。

948
00:44:14,100 --> 00:44:18,020
我们其实可以有多个精灵同时在屏幕上交互。

949
00:44:18,020 --> 00:44:23,470
我进入我的源目录打开一个叫做线程的，请回忆一下

950
00:44:23,470 --> 00:44:26,920
所谓线程只是两个脚本一起运行的能力

951
00:44:26,920 --> 00:44:28,350
在同一时间。

952
00:44:28,350 --> 00:44:34,490
现在请注意，我们同时有一只鸟和一只猫，它们都有

953
00:44:34,490 --> 00:44:35,270
各自的脚本。

954
00:44:35,270 --> 00:44:37,690
因此请注意，当我点击猫的时候，我得到这些脚本。

955
00:44:37,690 --> 00:44:39,830
当我点击鸟的时候，我得到这些脚本。

956
00:44:39,830 --> 00:44:42,070
所以这些家伙都有它们各自的程序。

957
00:44:42,070 --> 00:44:46,680
当我现在点击绿色旗子的时候，请注意这个程序执行的

958
00:44:46,680 --> 00:44:54,090
是让这个猫很慢很慢地追这个鸟。

959
00:44:54,090 --> 00:44:57,120
但是因为编程的原因猫有一定的优势

960
00:44:57,120 --> 00:45:00,540
使得无论鸟在哪里，猫都向它移动过去。

961
00:45:00,540 --> 00:45:02,150
我们可以以更快的速度玩这个游戏。

962
00:45:02,150 --> 00:45:07,750
如果我在操作猫，请注意我用的是，移动一步

963
00:45:07,750 --> 00:45:11,680
我们让它一次移动五步，所以一次移动五个点。

964
00:45:11,680 --> 00:45:13,580
让我单击播放。

965
00:45:13,580 --> 00:45:14,490
（狮吼声）

966
00:45:14,490 --> 00:45:17,170
大卫马兰：好的，现在我们可以真的给猫一个优势。

967
00:45:17,170 --> 00:45:18,600
一次走10步。

968
00:45:18,600 --> 00:45:20,120
（狮吼声）

969
00:45:20,120 --> 00:45:22,770
大卫马兰：好的，所以很快地，我们来给一些优势

970
00:45:22,770 --> 00:45:23,280
给这个猫。

971
00:45:23,280 --> 00:45:25,310
但我会对这其中的一些细节说不。

972
00:45:25,310 --> 00:45:28,240
路径每次开始有些不同的原因是

973
00:45:28,240 --> 00:45:29,700
我加了一些随机性。

974
00:45:29,700 --> 00:45:33,700
我实际上是把这猫往不同的方向指引

975
00:45:33,700 --> 00:45:38,710
根据我每次想让它开始的不同的方向，那么这个游戏，或者这个动画的每一次，是有

976
00:45:38,710 --> 00:45:39,760
一点点不同的。

977
00:45:39,760 --> 00:45:41,950
现在，让我介绍一个另外的结构。

978
00:45:41,950 --> 00:45:43,860
在这个情形下，我们有功能。

979
00:45:43,860 --> 00:45:46,950
同时也会有一块拼图被称为一个数组，或一个列表

980
00:45:46,950 --> 00:45:50,980
它允许你在一个变量里面储存多个值。

981
00:45:50,980 --> 00:45:53,410
我们看到线程，而现在有事件。

982
00:45:53,410 --> 00:45:56,330
那么现在有一个用到这两个人物的事件。

983
00:45:56,330 --> 00:46:02,490
如果我打开一个叫做事件的文件，从今天的例子里面

984
00:46:02,490 --> 00:46:06,940
我们会看到一个看起来有点像这样的程序。

985
00:46:06,940 --> 00:46:09,630
现在注意这个家伙

986
00:46:09,630 --> 00:46:11,620
注意到我先点击蓝色布偶

987
00:46:11,620 --> 00:46:12,990
他只执行以下操作。

988
00:46:12,990 --> 00:46:15,540
他没有那种跟绿旗关联的拼图。

989
00:46:15,540 --> 00:46:18,620
他有一个当我接受到事件--

990
00:46:18,620 --> 00:46:19,970
然后随便说些单词。

991
00:46:19,970 --> 00:46:21,590
我只是在这个地方打了事件-

992
00:46:21,590 --> 00:46:23,740
他会说波罗两秒钟。

993
00:46:23,740 --> 00:46:25,800
你们当中那些熟悉这个游戏的可能知道

994
00:46:25,800 --> 00:46:26,460
这个下面发展的方向了。

995
00:46:26,460 --> 00:46:29,800
如果我现在点击橙色的布偶，他的程序会做这件事。

996
00:46:29,800 --> 00:46:35,020
任何情况下他会说马克，如果空格键被按下的话。

997
00:46:35,020 --> 00:46:36,580
在屏幕上两秒钟的时间。

998
00:46:36,580 --> 00:46:39,590
但他会使用这个更华丽的叫做广播的模块。

999
00:46:39,590 --> 00:46:42,270
他会播出所谓的事件。

1000
00:46:42,270 --> 00:46:47,540
同时，在这个蓝色的人物，请记住，会听所谓的事件。

1001
00:46:47,540 --> 00:46:50,760
那么这样的话我们会有两个人物交互。

1002
00:46:50,760 --> 00:46:53,790
当我们在这学期后面阶段接触到网络编程的时候，也会同样地

1003
00:46:53,790 --> 00:46:58,320
有好处，如果你让你的网站对一些做出反应，比如

1004
00:46:58,320 --> 00:47:00,130
敲击键盘。

1005
00:47:00,130 --> 00:47:02,120
让我敲一下空格键。

1006
00:47:02,120 --> 00:47:04,020
橙色的家伙说马科。

1007
00:47:04,020 --> 00:47:05,840
蓝家伙说波罗。

1008
00:47:05,840 --> 00:47:10,780
如果我这样做，再次橙色的家伙说马可，蓝色的家伙说，波罗。

1009
00:47:10,780 --> 00:47:14,130
所以，让我们再进一步。

1010
00:47:14,130 --> 00:47:18,790
这次，我们花个几分钟的时间。

1011
00:47:18,790 --> 00:47:19,904
我们有没有

1012
00:47:19,904 --> 00:47:22,380
台灯，下来吧。

1013
00:47:22,380 --> 00:47:24,500
你就在边上的。

1014
00:47:24,500 --> 00:47:25,740
好的，你们都可以上来。

1015
00:47:25,740 --> 00:47:26,990
我们有为大家准备台灯。

1016
00:47:26,990 --> 00:47:28,360
来吧。

1017
00:47:28,360 --> 00:47:30,090
尽管我不知道我们能不能把这噱头

1018
00:47:30,090 --> 00:47:32,035
坚持一个学期。

1019
00:47:32,035 --> 00:47:33,530
好吧，下来吧。

1020
00:47:33,530 --> 00:47:40,260
同时，我们有这个例子来展示，

1021
00:47:40,260 --> 00:47:45,370
只是为了加快节奏，我们有一个从另外一个

1022
00:47:45,370 --> 00:47:48,360
之前学生那里来的，用了同样的基本元素的作品。

1023
00:47:48,360 --> 00:47:48,975
你叫什么名字？

1024
00:47:48,975 --> 00:47:49,240
约翰：约翰。

1025
00:47:49,240 --> 00:47:49,770
大卫马兰：约翰你好。

1026
00:47:49,770 --> 00:47:50,400
高兴认识你。

1027
00:47:50,400 --> 00:47:50,650
你呢？

1028
00:47:50,650 --> 00:47:51,250
塞兹：塞兹。

1029
00:47:51,250 --> 00:47:53,130
大卫马兰：塞兹，幸会。

1030
00:47:53,130 --> 00:47:54,820
约翰，入股你想先来的话。这是一个老

1031
00:47:54,820 --> 00:47:55,910
游戏名叫跳青蛙。

1032
00:47:55,910 --> 00:47:57,530
你可以用键盘控制这个。

1033
00:47:57,530 --> 00:48:02,425
目标是到街和水的那一边去。

1034
00:48:02,425 --> 00:48:12,700
（青蛙人音乐和声音播放）

1035
00:48:12,700 --> 00:48:14,970
大卫马兰：对不起，今天台灯没你的份啦。

1036
00:48:14,970 --> 00:48:19,110
好的，塞兹你来吧。

1037
00:48:19,110 --> 00:48:20,890
好的，我们再来一次。

1038
00:48:20,890 --> 00:48:21,430
塞兹：我用方向键吗？

1039
00:48:21,430 --> 00:48:22,360
大卫马兰：是的，只用方向键。

1040
00:48:22,360 --> 00:48:23,624
上，下，左，右。

1041
00:48:23,624 --> 00:48:35,700
（跳青蛙音乐响起）

1042
00:48:35,700 --> 00:48:37,880
大卫马兰：我们今天把这些称为翻译奖。

1043
00:48:37,880 --> 00:48:38,950
好的，做得非常好。

1044
00:48:38,950 --> 00:48:40,690
好的，这是给你们的，约翰和塞兹。

1045
00:48:40,690 --> 00:48:41,940
恭喜你们，好的。

1046
00:48:46,720 --> 00:48:50,620
再一次，当这个游戏进行的时候，想想具体是怎么回事？

1047
00:48:50,620 --> 00:48:52,060
第一，这儿很明显有很多动作。

1048
00:48:52,060 --> 00:48:55,220
但是我们已经看到了通过猫和鸟的例子，你可以制造动作的感觉，通过

1049
00:48:55,220 --> 00:48:58,350
只是一次又一次地移动一些像素的距离。

1050
00:48:58,350 --> 00:49:00,280
如果你有一个无限执行的方块，

1051
00:49:00,280 --> 00:49:02,120
你可以让这些车一直这么执行下去。

1052
00:49:02,120 --> 00:49:03,720
我们可以有一定随机性。

1053
00:49:03,720 --> 00:49:06,310
那么这个游戏不一定每次都一模一样。

1054
00:49:06,310 --> 00:49:09,940
那些圆木，车子，可以在稍微不同的时间启动，使得

1055
00:49:09,940 --> 00:49:12,690
这个游戏的效果更加有趣。

1056
00:49:12,690 --> 00:49:15,320
同时，我们看到了接受空格键控制的能力。

1057
00:49:15,320 --> 00:49:18,830
但显然，在Scratch当中，你也可以用上，下，左，右发挥指令。

1058
00:49:18,830 --> 00:49:20,760
键盘上的任何键都可以。

1059
00:49:20,760 --> 00:49:22,200
而且你还可以做一些其他的事情。

1060
00:49:22,200 --> 00:49:24,660
让我回到网络版。

1061
00:49:24,660 --> 00:49:30,280
让我进入我们的例子库。

1062
00:49:30,280 --> 00:49:36,120
在我的工作室之下，有这些视频，本质上是一个文件夹

1063
00:49:36,120 --> 00:49:37,780
在scratch.mit.edu这个网站上。

1064
00:49:37,780 --> 00:49:39,710
我们有所有这些项目的网页版。

1065
00:49:39,710 --> 00:49:42,530
让我看看我能不能让我的电脑合作。

1066
00:49:42,530 --> 00:49:47,180
只是我们在麻省理工的一个朋友写的程序。叫做移动的蝴蝶。

1067
00:49:47,180 --> 00:49:50,250
一旦这个打开，这会需要用到更多

1068
00:49:50,250 --> 00:49:51,430
我电脑的硬件。

1069
00:49:51,430 --> 00:49:53,325
Scratch是用Flash播放的。

1070
00:49:53,325 --> 00:49:56,250
Flash可以开启你的网络摄像头，如果你有的话。

1071
00:49:56,250 --> 00:50:00,210
那么如果我把这个全屏，点击绿色旗子，请注意

1072
00:50:00,210 --> 00:50:02,530
这个Flash的安全通知问

1073
00:50:02,530 --> 00:50:04,210
你是否允许我是用网络摄像头？

1074
00:50:04,210 --> 00:50:05,510
通常你应该说拒绝。

1075
00:50:05,510 --> 00:50:07,180
但是这种情况下我们允许。

1076
00:50:07,180 --> 00:50:10,430
让后我让Chrome也允许这个。

1077
00:50:10,430 --> 00:50:15,010
现在，很快你能看见，是的，我。

1078
00:50:15,010 --> 00:50:18,154
如果我的手往上移动的话。

1079
00:50:18,154 --> 00:50:20,390
我不能同时也动我的头。

1080
00:50:20,390 --> 00:50:21,740
还有一个倒影在屏幕上。

1081
00:50:21,740 --> 00:50:23,480
好的，这下好一点。

1082
00:50:23,480 --> 00:50:27,616
你可以把它在屏幕上面移动因为这儿有拼图的程序，哦，

1083
00:50:27,616 --> 00:50:31,640
我知道是什么原因了，因为你们还呢过看到我身后的投影屏幕。

1084
00:50:31,640 --> 00:50:33,870
这下子成了一个套一个了。

1085
00:50:33,870 --> 00:50:36,470
好的，我把这个角度调一下。

1086
00:50:36,470 --> 00:50:37,220
这下好了。

1087
00:50:37,220 --> 00:50:41,310
那么有一块拼图说当你看到有动作在

1088
00:50:41,310 --> 00:50:45,470
物体下面的时候，你可以让它上下左右地移动。

1089
00:50:45,470 --> 00:50:48,950
因此我们有了一点虚拟现实的感觉在这里，全部都在

1090
00:50:48,950 --> 00:50:52,570
我的浏览器里面就能做到，只是使用我的网络摄像头而已。

1091
00:50:52,570 --> 00:50:53,980
还有什么事情呢。

1092
00:50:53,980 --> 00:50:58,350
第一个联系，你们会在等会网站公布的内容上看到

1093
00:50:58,350 --> 00:51:01,100
今晚在cs50.net，是相当开放式的。

1094
00:51:01,100 --> 00:51:04,410
实施一个你自己感兴趣的Scratch的课题，一个游戏，

1095
00:51:04,410 --> 00:51:08,350
一个互动，一些艺术性的东西，然后挑战你自己去用任何数量的

1096
00:51:08,350 --> 00:51:09,660
这些拼图。

1097
00:51:09,660 --> 00:51:11,580
它可以式像这样互动式的。

1098
00:51:11,580 --> 00:51:15,470
或者可以是这样设计成讲一个故事的。

1099
00:51:15,470 --> 00:51:19,200
最后，我们今天差不多说到这儿啦，最后一个例子。

1100
00:51:19,200 --> 00:51:21,290
让我们进入本地版Scratch。

1101
00:51:21,290 --> 00:51:25,300
让我打开这个，然后最会运行一个你们

1102
00:51:25,300 --> 00:51:29,795
之前的学生写的程序。

1103
00:51:32,960 --> 00:51:35,938
好的，这个音量提高一点。

1104
00:51:35,938 --> 00:52:53,770
（音乐播放）

1105
00:52:53,770 --> 00:52:57,255
旁白：下一节计算机科学50，大卫请了一名自愿者上台。

1106
00:52:57,255 --> 00:52:58,636
大卫马兰：这个演示，我们需要一名志愿者。

1107
00:52:58,636 --> 00:53:01,050
你想下来吗？

1108
00:53:01,050 --> 00:53:02,300
你叫什么名字？

1109
00:53:05,320 --> 00:53:06,570
接下来。