1
00:00:00,000 --> 00:00:00,270

2
00:00:00,270 --> 00:00:01,790
DAVID MALAN：欢迎回来，大家好。

3
00:00:01,790 --> 00:00:05,030
所以昨天，你会记得，
我们针对这些主题在这里。

4
00:00:05,030 --> 00:00:08,380
因此，我们有四个首要topics--
隐私，安全和社会;

5
00:00:08,380 --> 00:00:11,960
互联网技术;云计算;
最终，Web开发。

6
00:00:11,960 --> 00:00:14,170
>> 没有人有
带宽或时间

7
00:00:14,170 --> 00:00:16,900
观看小约翰
奥利弗昨晚？

8
00:00:16,900 --> 00:00:20,120
这其实很有趣，
如果不是有点恐怖。

9
00:00:20,120 --> 00:00:24,700
对任何事情有任何疑问
我们昨天做？

10
00:00:24,700 --> 00:00:27,600
任何澄清？

11
00:00:27,600 --> 00:00:35,580
要做出任何疑问
相信我们触及到今天以某种形式？

12
00:00:35,580 --> 00:00:37,300
所以洗涮。

13
00:00:37,300 --> 00:00:38,760
>> 那么什么是上了议事日程今天？

14
00:00:38,760 --> 00:00:41,301
因此，我认为我们今天会开始
一起来看一下什么是一般

15
00:00:41,301 --> 00:00:44,460
被称为在计算thinking--
简单化的风险，思考

16
00:00:44,460 --> 00:00:46,636
像一台计算机，也许
想着像一个工程师，

17
00:00:46,636 --> 00:00:48,510
并试图开始
组织你的想法

18
00:00:48,510 --> 00:00:52,039
或者给你一个更好的感
涉及什么实际指挥

19
00:00:52,039 --> 00:00:54,080
一台电脑做一些事情
通过编程方式。

20
00:00:54,080 --> 00:00:56,663
我们会保持它在一个相当
高的水平，相当多的英语，

21
00:00:56,663 --> 00:00:59,850
但尝试使用熟悉的
举例正式如何

22
00:00:59,850 --> 00:01:01,450
你会去解决问题。

23
00:01:01,450 --> 00:01:04,080
>> 我们将重温一些CS
主题，像抽象，

24
00:01:04,080 --> 00:01:06,040
里面传来了一对夫妇
次昨日，

25
00:01:06,040 --> 00:01:07,554
算法，然后表示。

26
00:01:07,554 --> 00:01:09,720
而这也正是我们将开始
今天在短短的时刻。

27
00:01:09,720 --> 00:01:11,481
然后我们将看看节目。

28
00:01:11,481 --> 00:01:13,480
我们就来看看一些
基础构造

29
00:01:13,480 --> 00:01:16,450
与您可能熟悉
甚至可能会发现很直观。

30
00:01:16,450 --> 00:01:18,370
>> 我们来看看，其实，
在样品编程

31
00:01:18,370 --> 00:01:21,244
环境是非常便利，
很爱玩，也确实有针对性

32
00:01:21,244 --> 00:01:22,555
对于年龄在12岁以上。

33
00:01:22,555 --> 00:01:25,930
我们将花几分钟时间有
然后拿东西到较低的水平

34
00:01:25,930 --> 00:01:30,360
实际上谈一些
的算法和数据结构，

35
00:01:30,360 --> 00:01:32,360
可以这么说，那
程序员通常使用

36
00:01:32,360 --> 00:01:35,040
解决更为问题
效率可能比你

37
00:01:35,040 --> 00:01:37,322
能够不通通做。

38
00:01:37,322 --> 00:01:40,280
午餐后，我们就一起来看看
在技​​术堆栈，这仅仅是

39
00:01:40,280 --> 00:01:42,240
说的一种假想方式
技术集合

40
00:01:42,240 --> 00:01:43,690
你可能使用
解决一些问题。

41
00:01:43,690 --> 00:01:46,670
我们将谈论字母表
中存在的语言汤today--

42
00:01:46,670 --> 00:01:50,930
Java和Python和C ++ PHP和
Ruby和各种其他的东西。

43
00:01:50,930 --> 00:01:53,740
>> 我们将看一看简要
在设计模式。

44
00:01:53,740 --> 00:01:57,730
程序员，随着时间的推移，
有采用的方法

45
00:01:57,730 --> 00:02:00,690
倾向于帮助他们
解决问题更容易。

46
00:02:00,690 --> 00:02:04,390
当你开始看到自己写的
同样的代码连连，

47
00:02:04,390 --> 00:02:08,080
人的正式重复
而归于名字给他们

48
00:02:08,080 --> 00:02:10,084
然后用它们和
推进当中，最终。

49
00:02:10,084 --> 00:02:12,250
我们将讨论一点点
关于移动战略，

50
00:02:12,250 --> 00:02:16,099
像什么意思实际上
使移动应用或移动网站。

51
00:02:16,099 --> 00:02:17,140
你为Android做呢？

52
00:02:17,140 --> 00:02:17,730
你于iOS呢？

53
00:02:17,730 --> 00:02:19,160
你为那些呢？

54
00:02:19,160 --> 00:02:20,326
什么是取舍？

55
00:02:20,326 --> 00:02:23,180
然后最后，我们将采取
看看网络编程，这

56
00:02:23,180 --> 00:02:25,380
是的总称
真正描述的任何时间

57
00:02:25,380 --> 00:02:28,410
你写软件的
为了在网络上运行，

58
00:02:28,410 --> 00:02:30,430
无论是在手机还是
桌面或笔记本电脑。

59
00:02:30,430 --> 00:02:33,490
下面我们通过一个简单的介绍一下
数据库和设计

60
00:02:33,490 --> 00:02:39,049
其中，如果仅仅是因为几乎所有的
有趣基于网络的应用

61
00:02:39,049 --> 00:02:40,590
这几天有某种数据库。

62
00:02:40,590 --> 00:02:42,380
否则，它会
只是静态内容。

63
00:02:42,380 --> 00:02:45,254
和数据库使您可以
随时间的变化，无论是你自己

64
00:02:45,254 --> 00:02:45,960
或者从用户。

65
00:02:45,960 --> 00:02:47,820
我们会考虑如何
会去设计

66
00:02:47,820 --> 00:02:50,510
该数据库的那种行话
可能出现的以工程师

67
00:02:50,510 --> 00:02:52,790
在白板讨论
当实际执行

68
00:02:52,790 --> 00:02:53,900
首次的应用程式。

69
00:02:53,900 --> 00:02:57,002
>> 我们将讨论简单说一下
API的，有用的服务

70
00:02:57,002 --> 00:02:59,960
您可以使用站上
别人的肩膀上，无论公司

71
00:02:59,960 --> 00:03:02,619
或个人，以及解决您的
自己的问题更迅速。

72
00:03:02,619 --> 00:03:04,785
然后，我们也许会涉足
有点用JavaScript，

73
00:03:04,785 --> 00:03:08,900
该公司使用的编程语言
无论是在浏览器这些天，但也

74
00:03:08,900 --> 00:03:09,820
在服务器上。

75
00:03:09,820 --> 00:03:11,890
也许，我们将
重温，时间允许的话，

76
00:03:11,890 --> 00:03:15,670
一些动手网络的东西，我们的
昨天做和整合两个

77
00:03:15,670 --> 00:03:17,630
我们一起休会之前。

78
00:03:17,630 --> 00:03:22,380
>> 因此，与that--什么ahead--是
有什么遗漏，你

79
00:03:22,380 --> 00:03:26,289
想确保我们插入
并在某些点触摸。

80
00:03:26,289 --> 00:03:28,330
如果是弹簧介意，
要拿出来不久。

81
00:03:28,330 --> 00:03:32,010
但是，我们为什么不开始与
看看计算思维。

82
00:03:32,010 --> 00:03:35,420
>> 让我提议，
计算思维是，同样，

83
00:03:35,420 --> 00:03:38,830
排序的高层描述的
什么是计算机科学家可能会做。

84
00:03:38,830 --> 00:03:42,470
事实上，让我们开始
有三个成分，

85
00:03:42,470 --> 00:03:44,207
可能会进入计算机思维。

86
00:03:44,207 --> 00:03:45,790
这仅仅是一个描述它的方式。

87
00:03:45,790 --> 00:03:48,490
我们当然可以定义
这在任何数量的方式。

88
00:03:48,490 --> 00:03:50,630
>> 但是，让我提议，
今天的缘故，

89
00:03:50,630 --> 00:03:53,910
这世界上的问题，
所有的世界难题，

90
00:03:53,910 --> 00:03:56,730
当由接近
计算机科学家可以

91
00:03:56,730 --> 00:04:00,990
如被看作是我们将
电话输入，

92
00:04:00,990 --> 00:04:08,142
需要得到送入我们就这么叫
算法，则得到的输出。

93
00:04:08,142 --> 00:04:10,600
换言之，整个
解决问题的我主张世界

94
00:04:10,600 --> 00:04:13,140
可以蒸馏成
这三种成分。

95
00:04:13,140 --> 00:04:14,450
所以，我是什么意思的投入？

96
00:04:14,450 --> 00:04:17,060
输入正是你在做什么
递给为了解决。

97
00:04:17,060 --> 00:04:20,052
>> 举例来说，这里的
一个老同学的问题。

98
00:04:20,052 --> 00:04:22,760
如果我这里有电话本和
我想看看东西进去，

99
00:04:22,760 --> 00:04:23,760
这是我的意见。

100
00:04:23,760 --> 00:04:26,260
我有1000个左右
在电话簿页面。

101
00:04:26,260 --> 00:04:27,780
这是输入到我的问题。

102
00:04:27,780 --> 00:04:31,507
我想找到的东西
像迈克·史密斯，这样的朋友

103
00:04:31,507 --> 00:04:33,840
其名称和编号是
希望能在这个地址簿。

104
00:04:33,840 --> 00:04:36,430
>> 这是细胞的天前
手机，所以我不能只是搜索。

105
00:04:36,430 --> 00:04:38,540
所以，我必须这样做旧
学校实际上搜索

106
00:04:38,540 --> 00:04:41,331
这些投入对于一些答案。

107
00:04:41,331 --> 00:04:43,580
这答案是正要
被称为输出。

108
00:04:43,580 --> 00:04:44,871
所以输入是电话簿。

109
00:04:44,871 --> 00:04:47,787
该算法是任何集
步骤我用找到迈克·史密斯。

110
00:04:47,787 --> 00:04:50,120
和输出，希望
迈克·史密斯的电话号码。

111
00:04:50,120 --> 00:04:52,703
而这则是刚
最具代表性的任何问题

112
00:04:52,703 --> 00:04:55,210
与你手输入
并希望产生的输出。

113
00:04:55,210 --> 00:04:59,459
>> 因此，我们认为这个过程之前，
通过它我们可以解决这个问题，

114
00:04:59,459 --> 00:05:01,250
寻找迈克·史密斯和
类似的东西，

115
00:05:01,250 --> 00:05:04,090
让我们考虑的第一和
的last--输入和输出。

116
00:05:04,090 --> 00:05:08,060
物理上，当然，输入在这里
由纸一大堆粘在一起

117
00:05:08,060 --> 00:05:09,400
在电话簿的形式。

118
00:05:09,400 --> 00:05:13,660
但是电脑，笔记本电脑course--
和台式机甚至是手机

119
00:05:13,660 --> 00:05:16,430
这些days--那些
电子设备。

120
00:05:16,430 --> 00:05:20,920
>> 和在一天结束时，什么
唯一的输入到电脑？

121
00:05:20,920 --> 00:05:23,299
嗯，这是像
在这份电源线。

122
00:05:23,299 --> 00:05:25,590
我将其插入墙上，
我得到的电子流，

123
00:05:25,590 --> 00:05:27,048
这让我运行的机器。

124
00:05:27,048 --> 00:05:30,420
或者，也许这些都是电子
我的电池的方式产生。

125
00:05:30,420 --> 00:05:33,790
但在一天结束时，这是
唯一进入我的笔记本电脑。

126
00:05:33,790 --> 00:05:35,772
和这么多有趣
东西最终是

127
00:05:35,772 --> 00:05:37,480
中走出来，无论是
由打印机的方式

128
00:05:37,480 --> 00:05:40,320
或屏幕或audially或类似物。

129
00:05:40,320 --> 00:05:45,320
>> 所以，如果我们所有的作为我们的
基本输入到计算机

130
00:05:45,320 --> 00:05:49,160
电，所以才
电子进入和或缩小，

131
00:05:49,160 --> 00:05:54,465
所以我们如何使用该输入
实际上代表的信息？

132
00:05:54,465 --> 00:05:57,090
换句话说，我们如何获得
从电力的简单流程

133
00:05:57,090 --> 00:06:00,350
到代表实际
数字或字母实际

134
00:06:00,350 --> 00:06:03,620
在屏幕上或实际图像
或实际的电影或电子邮件

135
00:06:03,620 --> 00:06:05,690
或任何数量的这些
更高层次的概念，

136
00:06:05,690 --> 00:06:07,680
如果你愿意，在
到头来不知何故

137
00:06:07,680 --> 00:06:11,950
已被存储在这
电子机械装置

138
00:06:11,950 --> 00:06:16,260
只使用简单的ingredients--
电子出入？

139
00:06:16,260 --> 00:06:19,530
>> 因此，它似乎是，
在最简单的形式，

140
00:06:19,530 --> 00:06:23,260
唯一的一种状态
我在我的世界，所以

141
00:06:23,260 --> 00:06:25,350
到speak--条件
在我的天下 - 要么是

142
00:06:25,350 --> 00:06:33,020
我有电子流，电
流动的，或者我不是 - 等等，关闭。

143
00:06:33,020 --> 00:06:35,850
让我们正式开启和关闭，
作为一名计算机科学家可能，

144
00:06:35,850 --> 00:06:37,255
只用1和0。

145
00:06:37,255 --> 00:06:39,880
让我们只介绍一些武断
但一致的编号。

146
00:06:39,880 --> 00:06:41,970
1意味着，0表示关闭。

147
00:06:41,970 --> 00:06:45,427
或者你也可以认为这是
对真正的手段和虚假的手段。

148
00:06:45,427 --> 00:06:47,510
你也可以做黑色
和白色或红色和蓝色。

149
00:06:47,510 --> 00:06:48,759
你只需要两个描述符。

150
00:06:48,759 --> 00:06:52,240
和计算机科学家们
一般只要用0和1。

151
00:06:52,240 --> 00:06:58,980
>> 所以，如果是这样的话，我唯一的字母
是由0和1的，如何

152
00:06:58,980 --> 00:07:03,360
我可不可以去连号
2在一台电脑，更别说3号

153
00:07:03,360 --> 00:07:06,140
或一个字母
或图像或电影？

154
00:07:06,140 --> 00:07:08,910
我们怎么样的引导
从自己这一基本原则

155
00:07:08,910 --> 00:07:12,080
的0和1的和实际
代表更有趣的东西？

156
00:07:12,080 --> 00:07:14,430
>> 好了，让我们把这个问题
搁置一会儿就好了

157
00:07:14,430 --> 00:07:17,520
并考虑什么
希望熟悉，

158
00:07:17,520 --> 00:07:21,150
即使你有没有想过
它在任何细节为10，20，30，40，50

159
00:07:21,150 --> 00:07:22,520
更多年。

160
00:07:22,520 --> 00:07:24,780
这是什么？

161
00:07:24,780 --> 00:07:28,050
你将如何发音呢？

162
00:07:28,050 --> 00:07:30,770
不是一个很难回答的问题。

163
00:07:30,770 --> 00:07:32,950
一个数字，但它是什么？

164
00:07:32,950 --> 00:07:34,842
1，2，3，或123。

165
00:07:34,842 --> 00:07:37,800
我喜欢你是怎么说的1，2，3，
因为这是观看它的一种方式。

166
00:07:37,800 --> 00:07:39,870
1，2，3，它的一个序列
三个符号。

167
00:07:39,870 --> 00:07:42,005
这是图片，我们
现在有话。

168
00:07:42,005 --> 00:07:44,880
如果你之类的阅读全部
同时，在英国一个典型的人类

169
00:07:44,880 --> 00:07:46,600
会说123。

170
00:07:46,600 --> 00:07:48,350
这就是形式的
更高层次的概念，

171
00:07:48,350 --> 00:07:50,340
感觉就像一个相当大的数字。

172
00:07:50,340 --> 00:07:51,490
>> 但是，我们是怎么到达那里？

173
00:07:51,490 --> 00:07:54,640
嗯，这可能是因为一段时间
你想过这个问题是这样，

174
00:07:54,640 --> 00:07:56,680
但早在我的一天，我
那种得知这个

175
00:07:56,680 --> 00:08:01,030
作为1的专栏中，10级的
列和100的列。

176
00:08:01,030 --> 00:08:06,400
从而Lakisa说，这是
1，2，3，但它也是123。

177
00:08:06,400 --> 00:08:08,700
但是，我们如何从中获取
前者向后者？

178
00:08:08,700 --> 00:08:12,340
>> 那么，你通常会做
100的专栏中，我有一个1。

179
00:08:12,340 --> 00:08:14,794
所以，这等于是说100次1。

180
00:08:14,794 --> 00:08:16,210
然后在10的专栏中，我有2个。

181
00:08:16,210 --> 00:08:18,464
所以，这等于是说10次2。

182
00:08:18,464 --> 00:08:19,630
在1的专栏中，我有3个。

183
00:08:19,630 --> 00:08:21,720
所以，这等于是说1次3。

184
00:08:21,720 --> 00:08:24,290
>> 如果我添加这些东西
在一起，这当然

185
00:08:24,290 --> 00:08:27,470
是100加10加3。

186
00:08:27,470 --> 00:08:31,750
呵呵，这就是为什么我得到这个
123更高级别的概念。

187
00:08:31,750 --> 00:08:37,220
这只是基本的数学运算，由此这些
符号具有权重给他们，如果

188
00:08:37,220 --> 00:08:39,620
将占位符或列的值。

189
00:08:39,620 --> 00:08:42,090
有一次我乘的一切
出来，我得到这个号码。

190
00:08:42,090 --> 00:08:47,840
>> 所以，你知道怎么很多怎么说话
binary-- 0和1's--像电脑一样？

191
00:08:47,840 --> 00:08:50,410
OK，完美的，没有一个人，或
你们没有觉得你做的。

192
00:08:50,410 --> 00:08:52,550
不过，我会声称你
其实已经知道了。

193
00:08:52,550 --> 00:08:55,330
我们只需要几分调整
我们的心智模式一点点。

194
00:08:55,330 --> 00:08:57,250
但是这个过程是完全相同的。

195
00:08:57,250 --> 00:09:01,460
>> 让我离开这一个那里，
而不是拉下来了一会儿。

196
00:09:01,460 --> 00:09:05,060
在计算机世界，
我们只有0和1的。

197
00:09:05,060 --> 00:09:07,240
这样一来，事情那
要改变的是什么？

198
00:09:07,240 --> 00:09:10,920
那么，在我的人类世界中，
十进位制，DEC意义10，

199
00:09:10,920 --> 00:09:12,740
我已经在我手上了多少位？

200
00:09:12,740 --> 00:09:15,270

201
00:09:15,270 --> 00:09:16,540
10，对不对？

202
00:09:16,540 --> 00:09:17,880
0到9，当然。

203
00:09:17,880 --> 00:09:21,210
>> 这就是为什么我们有
10的地点和100的位置。

204
00:09:21,210 --> 00:09:22,380
那是哪里来的？

205
00:09:22,380 --> 00:09:24,430
那么，这是10到0的力量。

206
00:09:24,430 --> 00:09:28,440
这是10到1的功率，10
到2的幂，等等。

207
00:09:28,440 --> 00:09:32,110
你只是保持你的乘以列
10，出发只需1

208
00:09:32,110 --> 00:09:33,700
在这里最右边的之一。

209
00:09:33,700 --> 00:09:35,490
>> 因此在世界上
电脑，如果你只

210
00:09:35,490 --> 00:09:39,600
有binary--双向含义
2--或0和1的，我们只是

211
00:09:39,600 --> 00:09:42,420
真的需要改变
那数学的基础。

212
00:09:42,420 --> 00:09:46,410
因此，换句话说，现在我们只是
有1的专栏和曲风

213
00:09:46,410 --> 00:09:51,270
这是哪里going-- 2的专栏中，
4个专栏，也许超越。

214
00:09:51,270 --> 00:09:52,250
这是为什么？

215
00:09:52,250 --> 00:09:55,650
那么，这是2 0次方。

216
00:09:55,650 --> 00:09:57,270
这是2 1。

217
00:09:57,270 --> 00:09:59,610
这是2到2，依此类推。

218
00:09:59,610 --> 00:10:04,910
>> 因此而在这里，我们有1，10年代，
100的，1000的，万的，10万级的，1

219
00:10:04,910 --> 00:10:10,560
数以百万计，等等，这里
我们有1个，2个，4个，8个，16个，32，64。

220
00:10:10,560 --> 00:10:13,950
你只要保持乘以2，
而不是继续乘以10。

221
00:10:13,950 --> 00:10:16,780
所以，现在，如果目标在
一方面是代表

222
00:10:16,780 --> 00:10:20,240
仅使用0和1的数字，
让我们考虑我们如何到达那里。

223
00:10:20,240 --> 00:10:26,540
>> 此，当然，是模式0
0 0，但什么号码概念

224
00:10:26,540 --> 00:10:27,490
它代表什么？

225
00:10:27,490 --> 00:10:35,430
那么，4次加0 2次加0
1次0，让我们添加这些在一起。

226
00:10:35,430 --> 00:10:40,030
4次0，当然，0，加2
次0是，当然，0加1次0

227
00:10:40,030 --> 00:10:40,850
是，当然，0。

228
00:10:40,850 --> 00:10:44,910
所以啊，这代表了
一些我们人类所知道的0。

229
00:10:44,910 --> 00:10:47,810
>> 好了，现在，让我们很
迅速快进。

230
00:10:47,810 --> 00:10:53,600
如果我不是没有代表
0 0 0，但让我们做1 0 1，

231
00:10:53,600 --> 00:10:57,010
这可能是如何Lakisa，此前，
只会念它1 0 1。

232
00:10:57,010 --> 00:11:01,020
但是现在，我们怎么把它带到更高
水平，我们人类可能知道多少？

233
00:11:01,020 --> 00:11:04,220
那么，什么是这个数字？

234
00:11:04,220 --> 00:11:06,060
这是5，我们知道5的数量。

235
00:11:06,060 --> 00:11:06,870
>> 那么，这是为什么？

236
00:11:06,870 --> 00:11:09,620
好了，我们才能真正的排序
穿行有条不紊

237
00:11:09,620 --> 00:11:14,880
4次1，2 0次，1次1。

238
00:11:14,880 --> 00:11:19,880
添加这些在一起，所以
这是4加0加1。

239
00:11:19,880 --> 00:11:21,577
而这，的确，5。

240
00:11:21,577 --> 00:11:24,660
所以它现在变得有些乏味
一次又一次地做算术。

241
00:11:24,660 --> 00:11:26,300
但是这个过程是完全相同的。

242
00:11:26,300 --> 00:11:28,380
>> 有唯一
在我们的世界变了

243
00:11:28,380 --> 00:11:32,740
是，我们的列是1，2，4，8，16，
等，代替1，10，100，

244
00:11:32,740 --> 00:11:33,740
1000。

245
00:11:33,740 --> 00:11:40,000
而这仅仅是因为我们的字母表
从0到9减少到只有0到1。

246
00:11:40,000 --> 00:11:50,851
>> 因此，作为一个小测验这里，怎么会
你代表二进制数字7？

247
00:11:50,851 --> 00:11:51,350
0？

248
00:11:51,350 --> 00:11:53,490
好吧，0，你的意思是0 0 0？

249
00:11:53,490 --> 00:11:58,140

250
00:11:58,140 --> 00:11:59,693
再说一遍，卡琳娜。

251
00:11:59,693 --> 00:12:03,010

252
00:12:03,010 --> 00:12:03,550
完善。

253
00:12:03,550 --> 00:12:04,370
这是为什么？

254
00:12:04,370 --> 00:12:08,530
这是有效的4加2加1。

255
00:12:08,530 --> 00:12:09,580
很好。

256
00:12:09,580 --> 00:12:14,364
>> 我们如何代表一点点
another--怎么样2号？

257
00:12:14,364 --> 00:12:18,360

258
00:12:18,360 --> 00:12:20,690
关闭，而是倒退。

259
00:12:20,690 --> 00:12:21,660
所以，这是什么？

260
00:12:21,660 --> 00:12:26,290
为4加1，以便再次是5。

261
00:12:26,290 --> 00:12:28,310
>> 所以what's--对不起，卡琳娜？

262
00:12:28,310 --> 00:12:29,220
0 1 0。

263
00:12:29,220 --> 00:12:34,762
0 1 0将是2，因为再次，甚至
如果是那种不跳出你，

264
00:12:34,762 --> 00:12:35,470
只是做数学题。

265
00:12:35,470 --> 00:12:40,390
4次0，0，2倍
1是2，1次0为0。

266
00:12:40,390 --> 00:12:42,830
因此，这是我们所知道的2的数量。

267
00:12:42,830 --> 00:12:44,030
>> 如何对数8？

268
00:12:44,030 --> 00:12:51,240

269
00:12:51,240 --> 00:12:52,730
嗯？

270
00:12:52,730 --> 00:12:53,330
好。

271
00:12:53,330 --> 00:12:56,130
所以，我们种需要另一个占位符。

272
00:12:56,130 --> 00:12:59,570
我们需要1 0 0 0。

273
00:12:59,570 --> 00:13:02,280
这就是我们的那种真正的
老同学十进制。

274
00:13:02,280 --> 00:13:05,280
你如何代表人数1000？

275
00:13:05,280 --> 00:13:08,480
>> 嗯，你似乎是
那种在一个艰难的位置，

276
00:13:08,480 --> 00:13:10,390
如果问你代表
数字1000，

277
00:13:10,390 --> 00:13:14,960
因为即使你给自己喜欢
这些9，这些9，这些0，

278
00:13:14,960 --> 00:13:18,730
这是最大的数字，你
有，你没有完全得到为1000。

279
00:13:18,730 --> 00:13:26,920
所以，如果你1000，你只需要另
的位置，这样就可以做1 0 0 0，

280
00:13:26,920 --> 00:13:29,460
ERGO人数1000人。

281
00:13:29,460 --> 00:13:34,200
>> 所以，现在，让我们来映射这种
概念性的讨论给硬件，

282
00:13:34,200 --> 00:13:37,470
再次在这里，输入只是
这个小电力电缆，电

283
00:13:37,470 --> 00:13:39,300
进来和流出。

284
00:13:39,300 --> 00:13:44,740
所以对于从这里被映射
在那里，那么，我们真的需要？

285
00:13:44,740 --> 00:13:49,460
那么，你能想到的是一个内部
电脑，一大堆的灯泡，

286
00:13:49,460 --> 00:13:50,450
如果你愿意。

287
00:13:50,450 --> 00:13:52,040
他们真的叫晶体管。

288
00:13:52,040 --> 00:13:55,121
和晶体管只是切换
这可以是打开或关闭。

289
00:13:55,121 --> 00:13:56,870
所以，你能想到的
晶体管那是上

290
00:13:56,870 --> 00:14:00,730
是允许电力流动，
晶体管那是冒充停止

291
00:14:00,730 --> 00:14:02,170
电力流入。

292
00:14:02,170 --> 00:14:04,130
而非采取
在这里的灯光，

293
00:14:04,130 --> 00:14:06,450
为什么不让我做这种
新的派风格。

294
00:14:06,450 --> 00:14:11,360
因此，这可能是一个图1中，手电筒
正对，仅勉强虽然。

295
00:14:11,360 --> 00:14:14,050
而这可能是0，现在是关闭。

296
00:14:14,050 --> 00:14:18,277
>> 因此，使用这种物理设备，我
现在可以表示二进制的系统。

297
00:14:18,277 --> 00:14:19,235
我只需要两个状态。

298
00:14:19,235 --> 00:14:21,660
不要紧什么
颜色是或它是什么。

299
00:14:21,660 --> 00:14:25,920
所有重要的是，我有
在一个国家和另一个国家了。

300
00:14:25,920 --> 00:14:30,605
因此，使用我的手机在这里，我该怎么办
代表我们所知道的0的数量？

301
00:14:30,605 --> 00:14:34,490

302
00:14:34,490 --> 00:14:38,550
或者把等价，是什么
数字我现在能代表？

303
00:14:38,550 --> 00:14:39,810
0，因为该设备处于关闭状态。

304
00:14:39,810 --> 00:14:41,560
>> 如果我这样做呢？

305
00:14:41,560 --> 00:14:43,583
而现在，我该怎么办
表示数字2？

306
00:14:43,583 --> 00:14:46,380

307
00:14:46,380 --> 00:14:50,930
我能借你的手机
在这里，正如我们昨天做？

308
00:14:50,930 --> 00:14:58,490
因此，让我们来看看，所以如果我要代表
数字2，这是2号？

309
00:14:58,490 --> 00:14:59,050
没有。

310
00:14:59,050 --> 00:15:02,250
什么号码是我不小心
代表在这里？

311
00:15:02,250 --> 00:15:03,550
这实际上是数字3。

312
00:15:03,550 --> 00:15:05,008
>> 那么，哪一个做我想要关掉？

313
00:15:05,008 --> 00:15:09,634
黑手机or--好，如果they're--
黑手机或白色手机？

314
00:15:09,634 --> 00:15:10,300
白色手机。

315
00:15:10,300 --> 00:15:17,020
所以，如果我把这个关闭，我们
线它在这里，我们有一个1

316
00:15:17,020 --> 00:15:19,487
在2的地方，并
0在1的位置。

317
00:15:19,487 --> 00:15:21,195
所以我现在
表示数字2。

318
00:15:21,195 --> 00:15:24,680
而这，当然，会是多少
3，因为现在这两个灯

319
00:15:24,680 --> 00:15:25,350
在...上。

320
00:15:25,350 --> 00:15:27,480
>> 我会停在这里，
但按理说

321
00:15:27,480 --> 00:15:31,100
如果我想代表
号4或8或更高，

322
00:15:31,100 --> 00:15:32,529
我将需要更多的手机。

323
00:15:32,529 --> 00:15:33,820
但是，这一切是怎么回事。

324
00:15:33,820 --> 00:15:37,800
所以，如果你曾经听说过
中A--里面感谢你 - 计算机

325
00:15:37,800 --> 00:15:42,269
是数百万个晶体管，这是
只是数百万小小的开关。

326
00:15:42,269 --> 00:15:44,310
他们不是光
灯泡是打开和关闭，

327
00:15:44,310 --> 00:15:48,340
但他们要么允许电
某处流动或停止。

328
00:15:48,340 --> 00:15:52,140
所以，有你的两个
states--开或关，开或关。

329
00:15:52,140 --> 00:15:55,730
>> 所以我们现在似乎
有这种能力

330
00:15:55,730 --> 00:16:00,590
代表这个概念，
我们希望在实际硬件。

331
00:16:00,590 --> 00:16:05,520
但是，所有我们现在拥有的是能力
来表示数字又好像。

332
00:16:05,520 --> 00:16:08,580
那么，我们如何去代表
英文字母，这

333
00:16:08,580 --> 00:16:12,310
感觉像一个排序功能的你
将要添加到现代计算机

334
00:16:12,310 --> 00:16:14,280
一旦你有数字吗？

335
00:16:14,280 --> 00:16:16,930
>> 事实上，如果你仔细想想
它在历史上，计算机

336
00:16:16,930 --> 00:16:19,426
真的被引入到
作为数字计算器。

337
00:16:19,426 --> 00:16:21,300
但当然，这些
天，他们做更多的事情。

338
00:16:21,300 --> 00:16:23,799
即使当他们启动，你
通常会看到一个或多个单词。

339
00:16:23,799 --> 00:16:27,420
那么，你如何表现的话，
如果你已经是再次

340
00:16:27,420 --> 00:16:31,054
在电的结束
天，或等效地0和1的？

341
00:16:31,054 --> 00:16:34,430

342
00:16:34,430 --> 00:16:35,690
>> 是啊。

343
00:16:35,690 --> 00:16:38,320
是的，我的意思是，我们种做
这个昨天以某种形式，

344
00:16:38,320 --> 00:16:40,200
其中，在某些时候，
我想我随意

345
00:16:40,200 --> 00:16:46,741
说，如果我们想要代表
字母A，我们可以只把那个叫1。

346
00:16:46,741 --> 00:16:49,990
它是在加密的情况下，
在这里我们只是需要某种形式的代码，

347
00:16:49,990 --> 00:16:51,160
某种映射。

348
00:16:51,160 --> 00:16:56,680
>> 因此，也许A将被表示为
1，和B将被表示为2，

349
00:16:56,680 --> 00:17:01,560
和Z将被表示
作为26，例如。

350
00:17:01,560 --> 00:17:07,430
然后是唯一需要注意的是，如果我
要在我的电子邮件编码的信

351
00:17:07,430 --> 00:17:10,430
还是在我的短信
数字，大家

352
00:17:10,430 --> 00:17:12,640
必须同意使用
同组约定。

353
00:17:12,640 --> 00:17:14,619
事实上，世界
做了这一点。

354
00:17:14,619 --> 00:17:18,040
>> 有在世界上的系统
所谓的ASCII，美国标准

355
00:17:18,040 --> 00:17:21,640
信息交换码，
这是一个简单的决定，有些年份

356
00:17:21,640 --> 00:17:25,720
以前，人类制造的
决定，是要平等的，不

357
00:17:25,720 --> 00:17:32,260
1，2，和26，以及因此forth--它是一个
小different--但65，66，67。

358
00:17:32,260 --> 00:17:34,010
我拉了
图中只是一瞬间。

359
00:17:34,010 --> 00:17:34,580
但它的随意性。

360
00:17:34,580 --> 00:17:36,329
但没关系
它的随意性。

361
00:17:36,329 --> 00:17:38,620
世界上有只保持一致。

362
00:17:38,620 --> 00:17:40,540
>> 现在，最近，
有一些票友

363
00:17:40,540 --> 00:17:45,430
所谓的Unicode，因为世界上的那种
来实现，发明电脑后，

364
00:17:45,430 --> 00:17:50,977
有比多好
在世界上256个符号

365
00:17:50,977 --> 00:17:53,560
我们可能要代表，
尤其是当你介绍

366
00:17:53,560 --> 00:17:58,420
亚洲语言和其他符号
需要比你更表现

367
00:17:58,420 --> 00:18:02,150
可以容纳的最早版本
这个代码，这被称为ASCII。

368
00:18:02,150 --> 00:18:05,250
所以Unicode的实际上允许
您使用起来更加的0和2。

369
00:18:05,250 --> 00:18:08,830
特别是，你不断听到
字的字节社会中甚至只

370
00:18:08,830 --> 00:18:09,400
昨天。

371
00:18:09,400 --> 00:18:12,040
而一个字节又是什么？

372
00:18:12,040 --> 00:18:14,840
>> 什么是字节？

373
00:18:14,840 --> 00:18:15,700
这只是8位。

374
00:18:15,700 --> 00:18:17,150
那么是什么究竟意味着什么？

375
00:18:17,150 --> 00:18:22,400
嗯，这意味着，更早的时候，我们
谈到二进制和我所用

376
00:18:22,400 --> 00:18:28,010
任意三位当我们
谈到binary-- 1的地方，

377
00:18:28,010 --> 00:18:33,600
2的地方，和4的place--好，
一个字节只是意味着你在说

378
00:18:33,600 --> 00:18:38,730
未在三个单位，但
四，五，六，七八，

379
00:18:38,730 --> 00:18:46,910
这给了我们8的地方，
16年代，32年代，64年代，和128的。

380
00:18:46,910 --> 00:18:50,010
>> 换句话说，比特是不是所有的
该措施的有用单位，

381
00:18:50,010 --> 00:18:53,132
因为它就像一个很小的小
片的信息，开启或关闭。

382
00:18:53,132 --> 00:18:54,840
因此，一些年前，
世界刚刚决定

383
00:18:54,840 --> 00:18:59,060
它稍微更方便地在说话
字节为单位，在时间八件事。

384
00:18:59,060 --> 00:19:01,670
于是从而诞生
一个字节的概念。

385
00:19:01,670 --> 00:19:03,640
所以，我们在这里有八位。

386
00:19:03,640 --> 00:19:06,810
>> 而事实证明，也为类似
原因，世界上决定年

387
00:19:06,810 --> 00:19:12,439
以前，来表示一个ASCII字母，
你要使用8位的单位。

388
00:19:12,439 --> 00:19:14,230
所以，即使你不
需要那么多，你

389
00:19:14,230 --> 00:19:18,130
始终将使用8位
代表一个字母。

390
00:19:18,130 --> 00:19:20,950
这是方便的，
因为那样的话，如果你

391
00:19:20,950 --> 00:19:28,720
收到具有0 0 0 1 1信息
1 1 0后跟另一个1 1 1 0 1 0

392
00:19:28,720 --> 00:19:33,320
0 1，因此，如果您收到16
位，世界正好可以

393
00:19:33,320 --> 00:19:37,460
假定第一8是一个字母
第二是8的另一封信。

394
00:19:37,460 --> 00:19:39,240
>> 不要紧，有多少。

395
00:19:39,240 --> 00:19:41,460
它只是事项
我们都一致

396
00:19:41,460 --> 00:19:42,950
当我们解释这些位。

397
00:19:42,950 --> 00:19:44,377
而这只是随机的。

398
00:19:44,377 --> 00:19:47,210
这意味着什么，但我没有
仔细想想这意味着什么。

399
00:19:47,210 --> 00:19:49,620
>> 所以这是一个白色的小谎言。

400
00:19:49,620 --> 00:19:51,990
原来，ASCII
实际使用的仅7位。

401
00:19:51,990 --> 00:19:54,180
而第八位
所谓扩展ASCII。

402
00:19:54,180 --> 00:19:56,290
但问题是，最终是一样的。

403
00:19:56,290 --> 00:19:58,850
世界一般
标准化的8位。

404
00:19:58,850 --> 00:20:04,290
>> 因此，这似乎是一个小
限制，因为我只能

405
00:20:04,290 --> 00:20:07,970
代表资本A，
通过资本Z.资本2

406
00:20:07,970 --> 00:20:10,940
但是确实不，如果我去中场休息
有一堆资源

407
00:20:10,940 --> 00:20:13,695
线上，例如，
asciitable.com，这

408
00:20:13,695 --> 00:20:16,310
将是一个小
压倒在第一。

409
00:20:16,310 --> 00:20:18,910
但我会指出，
这里是什么是非常重要的。

410
00:20:18,910 --> 00:20:24,090
>> 这恰好be--，我会
walk--让我们来看看，如果我去在这里。

411
00:20:24,090 --> 00:20:27,990
这里，在该小数
列，数65。

412
00:20:27,990 --> 00:20:32,201
而在右手列字母
性格，人权委员会，是字母A.

413
00:20:32,201 --> 00:20:34,450
而且你可以忽略，现在，
一切都在中间。

414
00:20:34,450 --> 00:20:36,769
这是十六进制，
八进制，和一个HTML代码。

415
00:20:36,769 --> 00:20:39,810
这个网站只是试图抛出
你有很多一次的信息。

416
00:20:39,810 --> 00:20:42,970
但是，我们关心的是十进制
列和字符列。

417
00:20:42,970 --> 00:20:46,190
>> 因此，通过这样的逻辑，是什么
数，世界

418
00:20:46,190 --> 00:20:50,510
已经决定代表小写？

419
00:20:50,510 --> 00:20:52,230
是啊，97。

420
00:20:52,230 --> 00:20:55,850
而仅仅是用来迷惑
可能略有下降，

421
00:20:55,850 --> 00:21:03,715
什么号码已经是世界决定
将代表数字1？

422
00:21:03,715 --> 00:21:06,900

423
00:21:06,900 --> 00:21:10,910
没错，因为we-- 49，似乎
在这里，在底部向下走了。

424
00:21:10,910 --> 00:21:12,320
>> 现在，我是什么意思呢？

425
00:21:12,320 --> 00:21:14,830
所以，事实证明，
在计算机系统中，

426
00:21:14,830 --> 00:21:16,840
一般是有
根本的区别

427
00:21:16,840 --> 00:21:19,920
之间的数字和字符。

428
00:21:19,920 --> 00:21:22,330
一个数字是我们的事
学会长大的时候

429
00:21:22,330 --> 00:21:23,830
我们在小学的超级年轻。

430
00:21:23,830 --> 00:21:25,110
这事你算。

431
00:21:25,110 --> 00:21:30,220
但一个字符仅仅是一个形状，
字形，可以这么说，在屏幕上。

432
00:21:30,220 --> 00:21:36,200
>> 现在，我们人类那种见
一些看起来是这样的。

433
00:21:36,200 --> 00:21:39,060
而我们说，哦，那是2号。

434
00:21:39,060 --> 00:21:44,999
但是，没有，这只是看起来的象征
就像我们所知道的数字2。

435
00:21:44,999 --> 00:21:46,790
所以有这
根本的区别

436
00:21:46,790 --> 00:21:50,340
实际数字和字符之间。

437
00:21:50,340 --> 00:21:52,130
这是一个数字。

438
00:21:52,130 --> 00:21:54,420
但是总体来说，在
一台电脑的情况下，

439
00:21:54,420 --> 00:21:56,809
如果你不是看到
像这样quoted--

440
00:21:56,809 --> 00:21:58,600
而你总是不
必须看到它引用，

441
00:21:58,600 --> 00:22:01,474
但对于discussion--的缘故，如果
你看到周围的一些报价，

442
00:22:01,474 --> 00:22:02,730
现在这是一个字符。

443
00:22:02,730 --> 00:22:06,330
因此，这2号下方
一个计算机的内部机罩

444
00:22:06,330 --> 00:22:12,220
将与一个图案来表示
代表的比特数

445
00:22:12,220 --> 00:22:14,850
50，根据图表联机。

446
00:22:14,850 --> 00:22:18,300
>> 然而，如果计算机
刚看到这一点，这

447
00:22:18,300 --> 00:22:24,580
将与表示
位0 0 0 0 0 0 1 0模式。

448
00:22:24,580 --> 00:22:29,595
然而，这种性格会
实际as--现在代表，

449
00:22:29,595 --> 00:22:34,710
我觉得有点harder--所以这
人物将与0来表示

450
00:22:34,710 --> 00:22:39,080
0 1--需要什么吗？

451
00:22:39,080 --> 00:22:44,450
0 0 1 1 0 0 1 0。

452
00:22:44,450 --> 00:22:45,480
我是如何做到这一点？

453
00:22:45,480 --> 00:22:49,580
嗯，这是50号，如果你
使用这些列繁衍出来，

454
00:22:49,580 --> 00:22:53,530
这是2号，等等
这就是为什么有这种二分法。

455
00:22:53,530 --> 00:22:55,850
>> 而这仅仅是一个
现在传情的特点

456
00:22:55,850 --> 00:22:59,710
中存在的编程语言
我们将简要地对今天晚些时候触及。

457
00:22:59,710 --> 00:23:01,950
在编程语言，
你一般有，

458
00:23:01,950 --> 00:23:04,495
但并非总是如此，事
调用不同的数据类型。

459
00:23:04,495 --> 00:23:06,870
换言之，一个programmer--
当他或她正在写，

460
00:23:06,870 --> 00:23:11,150
程序员获取决定什么
格式存储自己的数据。

461
00:23:11,150 --> 00:23:14,120
您可以将数据存储为
原始数据，如数字2。

462
00:23:14,120 --> 00:23:17,940
或者你可以将它们存储为字符串，
或字符序列

463
00:23:17,940 --> 00:23:21,550
你会通常与表达
报价在您的编程语言。

464
00:23:21,550 --> 00:23:25,230
>> 你可以拥有的东西called--
我会简单化，并呼吁他们

465
00:23:25,230 --> 00:23:28,870
实numbers--使数字，
就像数字2不是整数，

466
00:23:28,870 --> 00:23:31,310
但喜欢的数字4.56。

467
00:23:31,310 --> 00:23:33,490
所以实数还可以
有小数点，

468
00:23:33,490 --> 00:23:36,340
所以这是一个根本的不同
在计算机中的数据块。

469
00:23:36,340 --> 00:23:41,920
然后，你甚至可以有
其他数据类型仍。

470
00:23:41,920 --> 00:23:45,810
所以这真的只是一个传情
最简单的设计决策

471
00:23:45,810 --> 00:23:50,960
一个程序员可能
使引擎盖下方。

472
00:23:50,960 --> 00:23:52,925
>> 所以，只是还没有什么问题吗？

473
00:23:52,925 --> 00:23:57,320

474
00:23:57,320 --> 00:23:59,860
因此，让我们试着让
这一点更真实。

475
00:23:59,860 --> 00:24:02,120
此硬件不
这么多的使用了。

476
00:24:02,120 --> 00:24:07,420
但大多数人在这个房间可能
从小一起长大的，并仍然使用硬盘驱动器

477
00:24:07,420 --> 00:24:08,010
某种程度上来说。

478
00:24:08,010 --> 00:24:10,100
>> 尽管大多数的
我们的笔记本电脑不再

479
00:24:10,100 --> 00:24:15,900
有一个这样的操作设备，
今天，而不是一般笔记本电脑

480
00:24:15,900 --> 00:24:18,590
有固态硬盘
没有移动部件。

481
00:24:18,590 --> 00:24:22,840
并且更趋于昂贵，
不幸的是，但有点快

482
00:24:22,840 --> 00:24:27,230
和A--很好，经常，速度快了很多，
这是原因之一。

483
00:24:27,230 --> 00:24:28,980
而且它不
产生很多热量。

484
00:24:28,980 --> 00:24:31,680
它可以更小，因此它的
通常一个净正。

485
00:24:31,680 --> 00:24:35,030
>> 但是，这使我们能够映射
多一点具体什么

486
00:24:35,030 --> 00:24:38,460
我们在0的谈论和
现在1的水平提升到一个物理设备。

487
00:24:38,460 --> 00:24:40,810
这是一件事对我说话
大约0和1中术语

488
00:24:40,810 --> 00:24:43,990
我的手机或抽象的术语
的开关被打开和关闭。

489
00:24:43,990 --> 00:24:45,340
但对于硬盘驱动器？

490
00:24:45,340 --> 00:24:48,495
在你的笔记本电脑，如果你有一个旧
之一，或在您的台式电脑，

491
00:24:48,495 --> 00:24:51,200
或肯定服务器
今天，在这里你有

492
00:24:51,200 --> 00:24:53,070
有硬盘驱动器
的空间兆兆位

493
00:24:53,070 --> 00:24:55,560
4 TB的空间，
还有什么意思呢？

494
00:24:55,560 --> 00:24:59,560
>> 一个硬盘驱动器1
空间的手段太字节

495
00:24:59,560 --> 00:25:03,890
有1万亿字节
它以某种方式里面，

496
00:25:03,890 --> 00:25:10,450
或等价内8万亿比特。

497
00:25:10,450 --> 00:25:16,240
1 TB的将是8兆兆位
或1万亿位，

498
00:25:16,240 --> 00:25:19,330
意味着如果你有一个硬
驱动器，你有不知何故

499
00:25:19,330 --> 00:25:22,400
或其他一万亿0
和1的内部的它。

500
00:25:22,400 --> 00:25:25,360
如果我们只是来看看的
硬盘驱动器的任意图像

501
00:25:25,360 --> 00:25:30,110
的代表，这是一个多么难
驱动器可能通常看起来像里面。

502
00:25:30,110 --> 00:25:32,600
>> 它也有点像
一个老唱机

503
00:25:32,600 --> 00:25:35,350
但一般用
多个记录里面，所以

504
00:25:35,350 --> 00:25:38,270
到speak--多
盘片，因为他们是所谓的，

505
00:25:38,270 --> 00:25:42,259
金属圆盘，和
这时，一个小的读头，

506
00:25:42,259 --> 00:25:43,550
很像一个老唱机。

507
00:25:43,550 --> 00:25:46,589
和读头前后移动
提出并以某种方式读取位。

508
00:25:46,589 --> 00:25:49,380
什么是对这些盘片，甚至
虽然我们人类无法看到它们，

509
00:25:49,380 --> 00:25:52,757
无论是在现实还是在这张照片，
有微小的磁性颗粒。

510
00:25:52,757 --> 00:25:55,090
而且，即使你早就
忘了电的使用原理，

511
00:25:55,090 --> 00:25:57,550
磁性粒子
即通常的充电

512
00:25:57,550 --> 00:26:00,570
有北边和南边
end--所以南北。

513
00:26:00,570 --> 00:26:03,000
这样一来，世界刚
决定前一段时间

514
00:26:03,000 --> 00:26:06,570
即，如果基本上是一个磁性协议
在这样的排列，南北，

515
00:26:06,570 --> 00:26:07,610
让我们把那个叫1。

516
00:26:07,610 --> 00:26:10,470
如果它是代替南北，
我们只需要调用一个0。

517
00:26:10,470 --> 00:26:13,350
所以，如果你有
您的处置一万亿

518
00:26:13,350 --> 00:26:16,300
小小的磁
particles--和希望，

519
00:26:16,300 --> 00:26:18,740
硬件中匠心
为了翻转周围的人

520
00:26:18,740 --> 00:26:24,450
当你看到fit--，如果你想
代表一大堆0，你

521
00:26:24,450 --> 00:26:28,120
只需要8磁性颗粒
所有的排列是这样的。

522
00:26:28,120 --> 00:26:30,330
如果你要代表
8个1的，你只要

523
00:26:30,330 --> 00:26:33,170
需要对齐的8磁性颗粒
回背靠背这样。

524
00:26:33,170 --> 00:26:35,515
>> 这是什么意思了
磁性粒子？

525
00:26:35,515 --> 00:26:38,390
坦率地说，这些年过去了，
仍然在我脑海中的东西

526
00:26:38,390 --> 00:26:42,139
就是这个家伙，如果你
从小一起长大的这件事情。

527
00:26:42,139 --> 00:26:43,930
这为little--
这些unfamiliar--一个

528
00:26:43,930 --> 00:26:47,810
小童年的玩具
这里有这个人无毛

529
00:26:47,810 --> 00:26:51,690
拥有所有这些小小的黑色
磁性粒子随之而来。

530
00:26:51,690 --> 00:26:53,930
而使用红棒，
这仅仅是一个磁铁，

531
00:26:53,930 --> 00:26:58,460
你可以排序的给他胡子或
眉毛或头发他或任何东西。

532
00:26:58,460 --> 00:27:00,710
所以，事实上，如果我们放大
在，例如，这

533
00:27:00,710 --> 00:27:02,950
是一种游戏，你
可以用长毛威利玩。

534
00:27:02,950 --> 00:27:06,570
>> 而这只是说，这些
大得多的磁性粒子

535
00:27:06,570 --> 00:27:09,890
比实际是一个硬盘驱动器上，
和少得多的磁性粒子。

536
00:27:09,890 --> 00:27:11,640
但是让我们真正看到
那么，如果你确实有

537
00:27:11,640 --> 00:27:14,720
微小磁性颗粒在
硬盘驱动器，你怎么能真正

538
00:27:14,720 --> 00:27:19,090
使用这些表示数据。

539
00:27:19,090 --> 00:27:20,070
>> [视频回放]

540
00:27:20,070 --> 00:27:24,190
>> -The硬盘是你的电脑
大多数商店的永久数据。

541
00:27:24,190 --> 00:27:27,170
要做到这一点，数据
沿RAM旅行

542
00:27:27,170 --> 00:27:31,720
软件的信号，告诉
硬盘如何存储这些数据。

543
00:27:31,720 --> 00:27:36,570
硬盘驱动器电路的转换
信号转换成电压波动。

544
00:27:36,570 --> 00:27:40,880
这些，反过来，控制硬盘的
曲子分为移动一些为数不多的搬家

545
00:27:40,880 --> 00:27:43,440
零件留在现代计算机。

546
00:27:43,440 --> 00:27:47,650
>> 一些信号控制电机，
其中旋转的金属涂层的拼盘。

547
00:27:47,650 --> 00:27:50,980
您的数据实际上是
存储在这些盘片。

548
00:27:50,980 --> 00:27:56,250
其他信号移动读/写磁头
读或写在盘片的数据。

549
00:27:56,250 --> 00:28:00,100
该机械是如此精确
一个人的头发甚至无法

550
00:28:00,100 --> 00:28:02,800
首脑之间传递
和旋转盘片。

551
00:28:02,800 --> 00:28:04,887
然而，这一切工作以惊人的速度。

552
00:28:04,887 --> 00:28:05,470
[结束播放]

553
00:28:05,470 --> 00:28:06,780
你可以在看
视频的尾部，

554
00:28:06,780 --> 00:28:08,340
一般有多个盘片。

555
00:28:08,340 --> 00:28:10,250
因此，阅读头
不只是读顶部。

556
00:28:10,250 --> 00:28:12,458
这有点像三
四个或更多的读出头

557
00:28:12,458 --> 00:28:14,920
这一举动像这样，
同时读取数据。

558
00:28:14,920 --> 00:28:17,407
>> 所以有很多的
复杂性和排序时机

559
00:28:17,407 --> 00:28:18,740
该公司参与了硬盘驱动器。

560
00:28:18,740 --> 00:28:21,920
而事情是真的纺织补
速度快，所以有很多的复杂性。

561
00:28:21,920 --> 00:28:25,220
但是，让我们在一个小更深的放大和
看到这些磁性颗粒

562
00:28:25,220 --> 00:28:27,370
以及如何我们在他们得到。

563
00:28:27,370 --> 00:28:28,750
>> [视频回放]

564
00:28:28,750 --> 00:28:31,830
>>  - 让我们看看我们
只是慢动作看到的。

565
00:28:31,830 --> 00:28:35,230
当电力的短暂脉冲
被发送到读/写头，

566
00:28:35,230 --> 00:28:39,000
它翻转上一个微小的电磁
用于第二的一小部分。

567
00:28:39,000 --> 00:28:41,390
磁铁创建
场，它改变

568
00:28:41,390 --> 00:28:44,600
一个很小，很小的极性
金属颗粒的一部分

569
00:28:44,600 --> 00:28:46,960
其中每个大衣盘片表面。

570
00:28:46,960 --> 00:28:50,020
图案系列这些微小的
磁盘上的充电区域

571
00:28:50,020 --> 00:28:54,590
表示在数据的单个位
由计算机使用的二进制数字系统。

572
00:28:54,590 --> 00:28:57,510
>> 现在，如果当前正在发送的一个
通过读/写头的方法，

573
00:28:57,510 --> 00:28:59,899
该区域在一个方向上偏振。

574
00:28:59,899 --> 00:29:01,940
如果当前在发送
相反的方向，

575
00:29:01,940 --> 00:29:04,020
极化反转。

576
00:29:04,020 --> 00:29:06,440
你如何让数据从硬盘？

577
00:29:06,440 --> 00:29:08,190
刚刚反转的过程。

578
00:29:08,190 --> 00:29:10,440
因此，它是在粒子
磁盘获取当前

579
00:29:10,440 --> 00:29:12,260
在读/写头移动。

580
00:29:12,260 --> 00:29:14,580
放在一起的数百万
这些磁化段，

581
00:29:14,580 --> 00:29:16,220
和你有一个文件。

582
00:29:16,220 --> 00:29:21,030
>> 现在，一个单一的文件的块可以是
散布在驱动器的盘片，

583
00:29:21,030 --> 00:29:24,060
有点像乱
在你的办公桌上的文件。

584
00:29:24,060 --> 00:29:27,590
因此，一个特殊的额外的文件保留
跟踪的东西在哪里。

585
00:29:27,590 --> 00:29:30,440
难道你不希望你有
类似的东西？

586
00:29:30,440 --> 00:29:31,290
>> [结束播放]

587
00:29:31,290 --> 00:29:36,260
>> 所以被提到的有，或许是
在删除昨天的话题。

588
00:29:36,260 --> 00:29:38,380
当你删除一个
文件，昨天我们说

589
00:29:38,380 --> 00:29:41,020
一台电脑实际上做
什么，当你拖动的东西

590
00:29:41,020 --> 00:29:44,110
到回收站或垃圾桶？

591
00:29:44,110 --> 00:29:45,150
它只是忘记它。

592
00:29:45,150 --> 00:29:47,540
但是0和1的，
磁性粒子

593
00:29:47,540 --> 00:29:50,640
看起来像红色和蓝色
这里的东西，或在这里我的手臂，

594
00:29:50,640 --> 00:29:52,350
仍然存在硬盘上。

595
00:29:52,350 --> 00:29:56,090
>> 所以存在软件 - 
Norton实用程序和昔日

596
00:29:56,090 --> 00:29:58,159
和其他更现代
软件 - 刚

597
00:29:58,159 --> 00:30:01,200
将扫描整个硬盘驱动器寻找
在所有这些0和1的，因为它

598
00:30:01,200 --> 00:30:06,890
事实证明，大多数文件formats--
Word文档，Excel文件，图像，

599
00:30:06,890 --> 00:30:10,380
视频files--都有一定的
图案，其中常见的。

600
00:30:10,380 --> 00:30:12,550
每个视频文件可能
是一个不同的视频，

601
00:30:12,550 --> 00:30:14,870
但前几
位通常是相同​​的。

602
00:30:14,870 --> 00:30:16,790
或最后几个位
通常是相同​​的。

603
00:30:16,790 --> 00:30:19,910
>> 因此具有较高的概率，
你可以看一下这些模式。

604
00:30:19,910 --> 00:30:23,700
而且，即使该文件已被遗忘，
你可以以很高的概率说，

605
00:30:23,700 --> 00:30:28,460
但是这看起来像一个Word文档，
让恢复它和取消算了吧，

606
00:30:28,460 --> 00:30:28,990
如果你愿意。

607
00:30:28,990 --> 00:30:32,330
所以这就是你如何恢复
数据要么被意外

608
00:30:32,330 --> 00:30:36,560
删除或删除或故意
删除的任何目的。

609
00:30:36,560 --> 00:30:42,530
>> 相比之下，安全删除做什么
在这样的图像的上下文中？

610
00:30:42,530 --> 00:30:44,059
没错，让他们全部随机。

611
00:30:44,059 --> 00:30:46,350
所以它像是移动的一些
他们失望，他们中的一些起来，

612
00:30:46,350 --> 00:30:49,433
留下他们中的一些不变，
通常会使随机噪声出来，

613
00:30:49,433 --> 00:30:52,960
或只是也许使所有的
他们0或全部的1的。

614
00:30:52,960 --> 00:30:56,350
而这也可以一般
擦洗你的数据了。

615
00:30:56,350 --> 00:31:00,160
>> 现在让我们回到问题
的计算思维，即

616
00:31:00,160 --> 00:31:03,270
我们有公式输入。

617
00:31:03,270 --> 00:31:06,390
和算法给出
你最终输出。

618
00:31:06,390 --> 00:31:09,270
我们现在专注于投入和
输出，因为现在，我

619
00:31:09,270 --> 00:31:12,159
要求我们有办法
表示输入和输出。

620
00:31:12,159 --> 00:31:13,450
我们只是要使用二进制。

621
00:31:13,450 --> 00:31:15,910
>> 而且不管我们
今天想代表，

622
00:31:15,910 --> 00:31:20,230
不管它是一个数字或字母
或其数千电话簿

623
00:31:20,230 --> 00:31:23,210
或图像或电影，在结束
这一天，它的所有0和1。

624
00:31:23,210 --> 00:31:26,640
而我坚持认为，尽管这
是一个超级简单的世界，只是0

625
00:31:26,640 --> 00:31:28,240
和1，我们可以建立自己的。

626
00:31:28,240 --> 00:31:32,210
而我们看到的一个例子
与字母迄今。

627
00:31:32,210 --> 00:31:35,615
>> 现在让我们专注于此
中间成分的算法。

628
00:31:35,615 --> 00:31:38,190
让我们回到本
例如迈克·史密斯。

629
00:31:38,190 --> 00:31:41,689
所以在这个电话簿，这不可否认，
我们不使用那么多了，

630
00:31:41,689 --> 00:31:42,980
有待解决的问题。

631
00:31:42,980 --> 00:31:45,040
我们希望找到一个像迈克·史密斯。

632
00:31:45,040 --> 00:31:47,520
>> 而且我可以做什么找迈克？

633
00:31:47,520 --> 00:31:51,197
好吧，我可以打开这个
书，开始在第一页，

634
00:31:51,197 --> 00:31:52,780
实现，哦，我在一节。

635
00:31:52,780 --> 00:31:53,510
迈克不在那里。

636
00:31:53,510 --> 00:31:55,510
我需要史密斯在S部分。

637
00:31:55,510 --> 00:31:58,192
所以，只要保持在同一时间开启一页。

638
00:31:58,192 --> 00:32:00,900
让我假装这是所有
白页，而不是黄页，

639
00:32:00,900 --> 00:32:02,910
因为我们不会找到
迈克黄页反正。

640
00:32:02,910 --> 00:32:04,034
但是，我在白页。

641
00:32:04,034 --> 00:32:05,340
而现在，我在B部分。

642
00:32:05,340 --> 00:32:06,810
我还没有找到他。

643
00:32:06,810 --> 00:32:08,890
所以我一直在同一时间开启一页。

644
00:32:08,890 --> 00:32:10,130
>> 这是一种算法。

645
00:32:10,130 --> 00:32:12,440
它是一组指令
为解决一些问题。

646
00:32:12,440 --> 00:32:16,480
换句话说，看
页面上，如果麦克的不就行了，

647
00:32:16,480 --> 00:32:20,020
翻页，并重复
再，再而三，

648
00:32:20,020 --> 00:32:21,760
理想情况下低头，你正在做的。

649
00:32:21,760 --> 00:32:24,120
所以该算法中，
这个过程中，是否正确？

650
00:32:24,120 --> 00:32:27,400

651
00:32:27,400 --> 00:32:28,830
>> 抱歉。

652
00:32:28,830 --> 00:32:30,056
不，我听到一些号。

653
00:32:30,056 --> 00:32:33,250

654
00:32:33,250 --> 00:32:36,125
OK，但它is--是啊，
它肯定乏味。

655
00:32:36,125 --> 00:32:39,000
就像，我们将在这里一整天，如果我
保持在这个速度寻找迈克。

656
00:32:39,000 --> 00:32:41,430
但让我声称它是正确的。

657
00:32:41,430 --> 00:32:43,850
这是愚蠢的，但它是正确的。

658
00:32:43,850 --> 00:32:47,209
>> 在一天结束时，只要它可能
走，我会找到迈克，如果他在那里

659
00:32:47,209 --> 00:32:48,250
而我关注。

660
00:32:48,250 --> 00:32:50,230
我最终到达他的页面。

661
00:32:50,230 --> 00:32:52,890
如果我太远，如果
我得到的T形截面，

662
00:32:52,890 --> 00:32:55,900
然后，我可以稍微优化
而只是说，HM，全部完成。

663
00:32:55,900 --> 00:32:57,980
我甚至都不需要浪费
时间要到Z的。

664
00:32:57,980 --> 00:33:00,010
但是，这是一个非常
线性方法，如果你

665
00:33:00,010 --> 00:33:03,370
将一个很有几分左到右
方法中，一条直线。

666
00:33:03,370 --> 00:33:05,560
而它的正确的，但速度慢。

667
00:33:05,560 --> 00:33:09,250
>> 所以我从小学记得，排序
从小学一年级学生的优化，

668
00:33:09,250 --> 00:33:13,756
在那里我学会了如何不算数
由那些而是由twos--所以2，4，6。

669
00:33:13,756 --> 00:33:15,630
这是一个，要困难得多
这样做，但在理论上，这是

670
00:33:15,630 --> 00:33:20,149
faster-- 8，10，12，14，等等。

671
00:33:20,149 --> 00:33:21,190
怎么样的算法？

672
00:33:21,190 --> 00:33:23,150
是不是更有效？

673
00:33:23,150 --> 00:33:23,880
是不是更快吗？

674
00:33:23,880 --> 00:33:25,365
>> 听众：这是有效的。

675
00:33:25,365 --> 00:33:28,560
>> DAVID MALAN：是的，所以它的def--它的
从字面上快一倍，假设我

676
00:33:28,560 --> 00:33:30,170
不要让她绊倒了我的手指。

677
00:33:30,170 --> 00:33:32,294
这是快一倍，因为
我转向通过两个

678
00:33:32,294 --> 00:33:36,560
一次，而不是一个网页，但它是
潜在地正确的，因为为什么呢？

679
00:33:36,560 --> 00:33:37,852
>> 听众：你跳过一些。

680
00:33:37,852 --> 00:33:41,185
DAVID MALAN：对，如果迈克会发生什么
被也许sandwiched--当我后来

681
00:33:41,185 --> 00:33:44,370
在电话簿，麦克恰好是
夹在这两个页面之间，

682
00:33:44,370 --> 00:33:46,720
我只是一味地略过。

683
00:33:46,720 --> 00:33:48,490
因此，我们需要一点点修复那里。

684
00:33:48,490 --> 00:33:51,290
有一次，我打了T形截面，我
不能只是自信地说，

685
00:33:51,290 --> 00:33:52,420
我们没有找到迈克·史密斯。

686
00:33:52,420 --> 00:33:53,770
我大概有原路折回。

687
00:33:53,770 --> 00:34:00,210
或事实上，当我到达的人
命名为S-N，而不是S-M代表史密斯，

688
00:34:00,210 --> 00:34:02,790
马上，我可能会增加一倍
回来了，因为也许他

689
00:34:02,790 --> 00:34:03,900
是以前的页面上。

690
00:34:03,900 --> 00:34:05,070
>> 但我没有远加倍奉还。

691
00:34:05,070 --> 00:34:08,030
从理论上讲，如果我这样做，在合适的
那时，我刚回去一页。

692
00:34:08,030 --> 00:34:10,139
因此它仅添加一个额外的步骤。

693
00:34:10,139 --> 00:34:13,070
所以，我已经走了快一倍，
但它花了我一个额外的页面。

694
00:34:13,070 --> 00:34:14,699
但是，这感觉就像一个净赢。

695
00:34:14,699 --> 00:34:17,230
>> 但是，这并不怎么大多数人
这个房间将解决这个问题。

696
00:34:17,230 --> 00:34:20,313
什么将一个典型的人，也许是
几年前做的，找迈克·史密斯？

697
00:34:20,313 --> 00:34:22,900

698
00:34:22,900 --> 00:34:24,800
是啊，没发现迈克。

699
00:34:24,800 --> 00:34:27,190
我该怎么办？

700
00:34:27,190 --> 00:34:31,027
因此，获得更近了一点，但我做的
知道 - 什么是真正的关于电话簿？

701
00:34:31,027 --> 00:34:32,110
听众：这是连续的。

702
00:34:32,110 --> 00:34:32,760
DAVID MALAN：这是连续的。

703
00:34:32,760 --> 00:34:33,750
这是按字母顺序排列。

704
00:34:33,750 --> 00:34:36,540
所以，如果我在M部分，
迈克显然是正确的，

705
00:34:36,540 --> 00:34:39,949
我可以从字面上撕裂
在half--问题

706
00:34:39,949 --> 00:34:44,360
它通常比that--容易撕裂
一半的问题，并把它扔掉，

707
00:34:44,360 --> 00:34:47,627
所以现在，我有一个问题，这就是
不再是1000 pages--这是辛苦，

708
00:34:47,627 --> 00:34:50,210
因为我觉得我居然撕毁
电话簿这个时间 - 不

709
00:34:50,210 --> 00:34:52,219
1000页，而500元。

710
00:34:52,219 --> 00:34:54,750
>> 所以，问题是字面上一半大。

711
00:34:54,750 --> 00:34:58,170
这是相当有吸引力的，因为
与我以前的算法，版本

712
00:34:58,170 --> 00:35:02,870
图1和2，我只是使问题
一个页面较小，两页小

713
00:35:02,870 --> 00:35:03,470
在一个时间。

714
00:35:03,470 --> 00:35:07,230
而现在，我做到了500
页面的小的一次。

715
00:35:07,230 --> 00:35:10,089
>> 好了，现在，卡里姆建议
我去的右半部分。

716
00:35:10,089 --> 00:35:12,380
所以我要去大致
到中间，给予或采取。

717
00:35:12,380 --> 00:35:15,185
如果我这样做数学，
我可以去正确的中间。

718
00:35:15,185 --> 00:35:17,060
而现在，我意识到，哦，
我在T节。

719
00:35:17,060 --> 00:35:18,280
其实我走得太远。

720
00:35:18,280 --> 00:35:21,670
>> 但我可以再次撕裂
一半的问题，把它扔掉。

721
00:35:21,670 --> 00:35:23,330
而我的字节不一样大。

722
00:35:23,330 --> 00:35:28,780
这只是什么的，256页或250
页面，给予或现在服用。

723
00:35:28,780 --> 00:35:31,570
但它仍然方式更
超过一页两页。

724
00:35:31,570 --> 00:35:33,345
>> 所以现在，我去大致中间。

725
00:35:33,345 --> 00:35:35,330
哦，我没去很远够了。

726
00:35:35,330 --> 00:35:37,880
所以我重复，重复，重复，
重复，直到我希望

727
00:35:37,880 --> 00:35:40,360
只剩下一个页面。

728
00:35:40,360 --> 00:35:44,000
>> 这样邀请问题，如果我
开始的约1,000名页面，

729
00:35:44,000 --> 00:35:47,340
做到了多少步带我
我的算法1版本？

730
00:35:47,340 --> 00:35:50,420
好吧，如果迈克是在S
部，在最坏的情况下，

731
00:35:50,420 --> 00:35:52,630
这是相当接近
字母表的末尾。

732
00:35:52,630 --> 00:35:56,559
因此，如果电话本有1000页，
我会在1000页找到迈克，

733
00:35:56,559 --> 00:35:57,100
给予或采取。

734
00:35:57,100 --> 00:35:59,750
也许它就像800左右，但
这是相当接近1000。

735
00:35:59,750 --> 00:36:01,680
>> 然而，在第二
算法，多少

736
00:36:01,680 --> 00:36:06,840
翻页最大可能我
需要找迈克·史密斯？

737
00:36:06,840 --> 00:36:09,970
有1000多页，但我
在时间做他们二。

738
00:36:09,970 --> 00:36:13,045
对，所以最大似500ish，因为
如果我去通过整个电话簿，

739
00:36:13,045 --> 00:36:14,170
在这一点，我可以停止。

740
00:36:14,170 --> 00:36:16,669
但我可以刮掉一小部分被
只是停在T形截面。

741
00:36:16,669 --> 00:36:19,880
但它在最坏的情况下，500页。

742
00:36:19,880 --> 00:36:24,710
>> 所以，我有多少次可以分割
1,00o页电话簿中再次半

743
00:36:24,710 --> 00:36:30,450
并一次again--从
1000至500至250至125？

744
00:36:30,450 --> 00:36:32,250
多久之前，我打一个页面？

745
00:36:32,250 --> 00:36:35,510

746
00:36:35,510 --> 00:36:36,370
是啊，这是10个左右。

747
00:36:36,370 --> 00:36:40,780
根据舍入和这样，它的
约10页共需要开启

748
00:36:40,780 --> 00:36:43,290
或电话簿需要被撕裂。

749
00:36:43,290 --> 00:36:44,710
>> 所以这是非常强大的。

750
00:36:44,710 --> 00:36:48,170
我们开始了1000页的问题
在所有这三个故事。

751
00:36:48,170 --> 00:36:51,850
但是在第一种算法，它
拉着我，最坏的情况下，1000页

752
00:36:51,850 --> 00:36:52,740
周折找到迈克。

753
00:36:52,740 --> 00:36:55,590
第二种算法，500
网页找到迈克。

754
00:36:55,590 --> 00:36:58,480
第三个算法，10页找到迈克。

755
00:36:58,480 --> 00:37:00,230
而且它更
强大的，当你认为

756
00:37:00,230 --> 00:37:01,860
有关排序相反的情景。

757
00:37:01,860 --> 00:37:05,680
假设电话公司下一个
今年也许合并两个乡镇一起，

758
00:37:05,680 --> 00:37:08,550
和电话簿突然
这厚厚的，而不是说这个，

759
00:37:08,550 --> 00:37:12,470
所以2000页，而不是1000。

760
00:37:12,470 --> 00:37:15,640
好吧，我的第一个算法寻找
迈克·史密斯在2000页的电话本，

761
00:37:15,640 --> 00:37:21,460
更糟糕的情况下，要采取
明年有多少页打开？

762
00:37:21,460 --> 00:37:24,800
>> 电话簿为2,000页，
so--好，不是一个。

763
00:37:24,800 --> 00:37:29,540
如果电话簿两倍厚
第一算法，第一算法，

764
00:37:29,540 --> 00:37:30,380
2000，对不对？

765
00:37:30,380 --> 00:37:33,005
在最坏的情况下，迈克真的
关闭到书的结尾，

766
00:37:33,005 --> 00:37:34,110
所以它的2000翻页。

767
00:37:34,110 --> 00:37:38,070
第二种算法通过去
三三两两，像1000页。

768
00:37:38,070 --> 00:37:41,490
>> 但是怎么样在我的第三个
和最近算法？

769
00:37:41,490 --> 00:37:44,950
如果电话公司的一倍
从1000至2000的页数，

770
00:37:44,950 --> 00:37:47,770
多少次需要我撕
那本书一半找到迈克？

771
00:37:47,770 --> 00:37:48,710
>> 听众：刚才之一。

772
00:37:48,710 --> 00:37:51,001
>> DAVID MALAN：只要多一个，
因为一个页面撕裂，

773
00:37:51,001 --> 00:37:53,270
我可以从字面上分
和征服，如果你愿意，

774
00:37:53,270 --> 00:37:57,410
在半则服用了这个问题
一个巨大的咬出来。

775
00:37:57,410 --> 00:38:01,420
所以这是一个例子
效率，可以说是一种算法

776
00:38:01,420 --> 00:38:04,100
与我们所有人都
排序直观地熟悉。

777
00:38:04,100 --> 00:38:07,780
但它只是为正确
我的其他算法

778
00:38:07,780 --> 00:38:09,630
与对TWEAK
第二算法，

779
00:38:09,630 --> 00:38:11,290
但它是如此有效得多。

780
00:38:11,290 --> 00:38:14,030
>> 而事实上，什么是计算机
科学家，或者反过来程序员，

781
00:38:14,030 --> 00:38:17,580
书写时通常会做
代码是揣摩，

782
00:38:17,580 --> 00:38:19,960
没事，我不希望我的
节目刚是正确的，

783
00:38:19,960 --> 00:38:23,220
我也希望它是有效的
问题和解决问题很好。

784
00:38:23,220 --> 00:38:26,450
今天在现实世界中想像，
像谷歌索引，搜索

785
00:38:26,450 --> 00:38:31,580
像数十亿个网页，试想如果他们
使用第一算法来查找的猫

786
00:38:31,580 --> 00:38:34,620
一个十亿pages--看着之中
第一页在他们的数据库，

787
00:38:34,620 --> 00:38:37,700
第二个，第三个，只是寻找
一只猫，寻找一只猫。

788
00:38:37,700 --> 00:38:40,350
这是相当不错的减缓它似乎。

789
00:38:40,350 --> 00:38:43,170
他们可以改用东西
称为二进制搜索，这

790
00:38:43,170 --> 00:38:47,420
没有coincidence--双向含义二，我们
不断分裂东西2，在half--

791
00:38:47,420 --> 00:38:50,205
他们可以使用二进制搜索
也许找猫甚至更快，

792
00:38:50,205 --> 00:38:51,830
或不管它是你正在寻找。

793
00:38:51,830 --> 00:38:54,125
>> 坦率地说，有
更炫的算法

794
00:38:54,125 --> 00:38:56,250
该做的不仅仅是更多
分东西两半

795
00:38:56,250 --> 00:38:58,180
为了快速查找信息。

796
00:38:58,180 --> 00:39:00,880
我们将讨论一点点
今天的午饭后。

797
00:39:00,880 --> 00:39:02,640
因此，让我只能尽力代表这一点。

798
00:39:02,640 --> 00:39:05,380
我们并不需要进入
任何数学或实际数字。

799
00:39:05,380 --> 00:39:07,070
我们可以抽象地谈论这个。

800
00:39:07,070 --> 00:39:11,580
>> 但让我求婚，如果你
现在是具有讨论

801
00:39:11,580 --> 00:39:13,491
与工程师
提出这种算法

802
00:39:13,491 --> 00:39:15,490
而你试图让
计算的决定，

803
00:39:15,490 --> 00:39:17,285
因为也许
工程师对你说，你

804
00:39:17,285 --> 00:39:19,910
知道吗，我可以实现
像2分钟线性搜索。

805
00:39:19,910 --> 00:39:21,150
就是这么简单。

806
00:39:21,150 --> 00:39:24,790
二进制搜索是不是花哨，但
它会带我像10分钟，

807
00:39:24,790 --> 00:39:26,650
所以5倍长。

808
00:39:26,650 --> 00:39:30,900
>> 有一个行业在这里，即使是在条件
在决定写什么软件。

809
00:39:30,900 --> 00:39:34,760
你写的简单算法，
这将只是把你们俩分钟呢？

810
00:39:34,760 --> 00:39:39,880
或者你花更多的时间，10分钟，
写爱好者算法？

811
00:39:39,880 --> 00:39:43,540
你如何决定样的问题？

812
00:39:43,540 --> 00:39:46,710
或者你可以让它多了几分真实。

813
00:39:46,710 --> 00:39:50,610
我告诉我的老板是要采取
我任何一个星期10周

814
00:39:50,610 --> 00:39:52,490
实施
在这种方式的软件，如何

815
00:39:52,490 --> 00:39:56,103
你决定哪些
算法绿灯？

816
00:39:56,103 --> 00:39:56,603
卡里姆？

817
00:39:56,603 --> 00:39:57,550
>> 听众：观众，我猜。

818
00:39:57,550 --> 00:39:57,960
>> DAVID MALAN：观众。

819
00:39:57,960 --> 00:39:59,460
你说的观众呢？

820
00:39:59,460 --> 00:40:03,460
>> 听众：如果它是怎么回事
由用户使用

821
00:40:03,460 --> 00:40:09,050
谁[听不清]使用者[听不清]。

822
00:40:09,050 --> 00:40:11,232
但是，如果它的东西你
只是在做自己

823
00:40:11,232 --> 00:40:13,946
便利的问题，
[听不清]更快。

824
00:40:13,946 --> 00:40:16,820
DAVID MALAN：是的，它的快速和
脏来形容它的好方法。

825
00:40:16,820 --> 00:40:18,695
事实上，如果你是
描述了很多我的时间

826
00:40:18,695 --> 00:40:23,630
在研究生院，其中很多时候，
我写了糟糕的代码自觉so--

827
00:40:23,630 --> 00:40:26,490
至少，这就是我如何
合理化它 - 那么自觉，

828
00:40:26,490 --> 00:40:30,670
因为即使我在写代码
这是执行相对缓慢，

829
00:40:30,670 --> 00:40:33,750
我能写代码本身
相当快，支出仅几分钟

830
00:40:33,750 --> 00:40:35,107
或小时而不是几天。

831
00:40:35,107 --> 00:40:37,190
而事实证明，我
偶尔需要睡觉。

832
00:40:37,190 --> 00:40:41,270
所以，即使我的代码需要8
小时运行，很好，很好，

833
00:40:41,270 --> 00:40:42,850
我只是走在它运行时睡觉。

834
00:40:42,850 --> 00:40:46,350
>> 所以在当时，我认为这是
很巧，即使我显然

835
00:40:46,350 --> 00:40:48,990
通过我的博士工作非常慢。

836
00:40:48,990 --> 00:40:52,270
但是，反过来是
即，如果我写的软件

837
00:40:52,270 --> 00:40:55,930
其他人谁
更要紧比我好，

838
00:40:55,930 --> 00:40:59,580
让他们等候8小时
拿回自己的搜索结果

839
00:40:59,580 --> 00:41:01,350
是不是所有的引人注目。

840
00:41:01,350 --> 00:41:04,090
所以，花更多的时间
前面编写软件

841
00:41:04,090 --> 00:41:07,300
即更高效，更
像我们的第三个算法，

842
00:41:07,300 --> 00:41:09,780
可能有利于用户在一段时间。

843
00:41:09,780 --> 00:41:12,710
因此，它实际上取决于在
时间如何将这些费用加起来。

844
00:41:12,710 --> 00:41:14,960
如果你将要写作
软件使用一次，

845
00:41:14,960 --> 00:41:17,240
可能还不如做
快速和肮脏的，因为他们说。

846
00:41:17,240 --> 00:41:18,198
只是把它在一起。

847
00:41:18,198 --> 00:41:20,560
它的代码尴尬
你，这是如此糟糕，

848
00:41:20,560 --> 00:41:23,860
但它得到正确地完成任务，
即使它是没有效率。

849
00:41:23,860 --> 00:41:27,200
相反，你花更多的时间
的东西，得到它恰到好处。

850
00:41:27,200 --> 00:41:30,730
然后摊销随着时间的推移，
时间的前期费用

851
00:41:30,730 --> 00:41:34,330
也许是值得的，如果你继续
优化为常见的情况。

852
00:41:34,330 --> 00:41:37,620
>> 事实上，这是在一个主题
编程，或计算机科学更多

853
00:41:37,620 --> 00:41:41,390
通常，试图优化
不是为罕见的情况下

854
00:41:41,390 --> 00:41:44,390
但共同的case--什么操作
是要一次又一次地发生？

855
00:41:44,390 --> 00:41:47,730
如果你想拥有数十亿美元
用户搜索您的网站上，

856
00:41:47,730 --> 00:41:52,030
你应该花额外的
周前面编写更好的软件，

857
00:41:52,030 --> 00:41:53,670
让所有的用户受益。

858
00:41:53,670 --> 00:41:57,840
现在，让我们尝试捕捉这个
形象地少，但没有这么多

859
00:41:57,840 --> 00:41:58,610
数字。

860
00:41:58,610 --> 00:42:01,680
>> 因此，这里只是一个老同学的图表。

861
00:42:01,680 --> 00:42:04,260
让我说，这就是时间。

862
00:42:04,260 --> 00:42:06,660
并不要紧what--
其实，不，不是的时间。

863
00:42:06,660 --> 00:42:08,320
让我们把那另一个轴。

864
00:42:08,320 --> 00:42:15,700
让我们说，这是时间，
这就是问题的大小。

865
00:42:15,700 --> 00:42:17,830
>> 和一个计算机科学家
通常可能调用

866
00:42:17,830 --> 00:42:20,820
这仅仅局限于N。 n是像
我们去到变量中，其中

867
00:42:20,820 --> 00:42:26,351
n是一个数，n个，以及它的
你有任何的投入数量。

868
00:42:26,351 --> 00:42:28,100
因此，在这种情况下，n是
的页数。

869
00:42:28,100 --> 00:42:30,150
所以它可能是1000中
的情况下，我们只是告诉。

870
00:42:30,150 --> 00:42:31,969
>> 所以，时间可以是任何计量单位。

871
00:42:31,969 --> 00:42:32,760
也许，这是第二次。

872
00:42:32,760 --> 00:42:33,410
也许，这是天。

873
00:42:33,410 --> 00:42:34,590
也许，这就像翻页。

874
00:42:34,590 --> 00:42:35,215
没关系。

875
00:42:35,215 --> 00:42:38,840
无论你希望计算，即
将时间或等效的成本。

876
00:42:38,840 --> 00:42:42,400
>> 因此，与第一个
算法，如果我，例如，

877
00:42:42,400 --> 00:42:45,920
有一个1000页的电话本，
我要画一个点那里，

878
00:42:45,920 --> 00:42:51,450
因为如果它是1000页，花了
大约1000翻页，给予或采取。

879
00:42:51,450 --> 00:42:54,100
然后，如果我有一个
2000页的电话本，

880
00:42:54,100 --> 00:42:57,200
我要去画第二
在此点，因为2000页，

881
00:42:57,200 --> 00:42:59,810
它就像2000秒
或翻页或什么的。

882
00:42:59,810 --> 00:43:02,480
因此，当我前面说的，这是
样的线性关系，

883
00:43:02,480 --> 00:43:06,020
这是故意的，因为我想
后来on--权now--划清界限。

884
00:43:06,020 --> 00:43:07,770
这是怎样的一个直
行的关系。

885
00:43:07,770 --> 00:43:10,180
斜率是1/1，如果你愿意。

886
00:43:10,180 --> 00:43:14,630
>> 同时，第二算法
说，如果你有1000页

887
00:43:14,630 --> 00:43:17,680
而你使用第二算法，
在那里我数2的，把

888
00:43:17,680 --> 00:43:22,564
同时两页，我要画一个
点低于或者高于我的原始点？

889
00:43:22,564 --> 00:43:23,450
>> 听众：下面。

890
00:43:23,450 --> 00:43:27,992
>> DAVID MALAN：下面，因为正如我们所看到的，
它需要较少的时间，一半多的时间。

891
00:43:27,992 --> 00:43:29,950
所以点应该是一半
高达另一个。

892
00:43:29,950 --> 00:43:33,330
而同样的协议在这里，此点
也许应该是大致那里。

893
00:43:33,330 --> 00:43:39,666
所以我的第二个算法，同样地，
具有随时间的线性关系。

894
00:43:39,666 --> 00:43:41,990
而且我们可以得出它是这样。

895
00:43:41,990 --> 00:43:45,950
>> 所以，现在，第三个和最后
算法是有点难以得出。

896
00:43:45,950 --> 00:43:49,530
但是直觉，如果我有1000
我的第三个算法的网页，

897
00:43:49,530 --> 00:43:52,340
它应该只把我像10步。

898
00:43:52,340 --> 00:43:57,500
如果我有2000页
我的第三个算法，

899
00:43:57,500 --> 00:44:01,570
应采取我不要10
步骤，但11，只是多一个。

900
00:44:01,570 --> 00:44:03,610
因此，我们只能勉强维持会看到这一点。

901
00:44:03,610 --> 00:44:06,010
>> 而事实证明，如果
我放大此，我

902
00:44:06,010 --> 00:44:09,320
要夸大的效果，
该线的形状，最终

903
00:44:09,320 --> 00:44:11,990
不是直line--
因为，事实上，如果它是，

904
00:44:11,990 --> 00:44:15,390
它看起来更像
others--它实际上是一个曲线

905
00:44:15,390 --> 00:44:19,265
，如果我们放大，是怎么回事
看起来更像这一点。

906
00:44:19,265 --> 00:44:21,670
它 - 嗯，好吧，忽略这一部分。

907
00:44:21,670 --> 00:44:25,330
这是我的钢笔一样的角度。

908
00:44:25,330 --> 00:44:29,000
这是一个曲线，就是始终
越来越多，永远，永远，永远

909
00:44:29,000 --> 00:44:32,100
增加，但只是勉强。

910
00:44:32,100 --> 00:44:36,260
>> 所以，随着时间的推移，你有一个
关系，即更喜欢这个。

911
00:44:36,260 --> 00:44:37,540
它看起来几乎笔直。

912
00:44:37,540 --> 00:44:40,330
但它是非常缓慢地上升。

913
00:44:40,330 --> 00:44:44,780
但沿着几乎所有的点
您的x轴，水平轴，

914
00:44:44,780 --> 00:44:46,550
它比其他行低。

915
00:44:46,550 --> 00:44:49,930
>> 所以这可能是一个关系
N，因此，如果您有n页，

916
00:44:49,930 --> 00:44:51,100
你需要n秒。

917
00:44:51,100 --> 00:44:53,320
这可能是有关系的n / 2。

918
00:44:53,320 --> 00:44:56,710
您有n个网页，它需要
你N / 2秒，一半多。

919
00:44:56,710 --> 00:45:00,590
而这是一个对数
关系，这

920
00:45:00,590 --> 00:45:08,920
如果你还记得，日志N捕获基地2
这种增长，可以这么说。

921
00:45:08,920 --> 00:45:12,000
因此，这是何许神圣
在这三个中的圣杯

922
00:45:12,000 --> 00:45:15,940
在这里，因为它只是这么多
高效，但可以说更复杂

923
00:45:15,940 --> 00:45:18,610
实现。

924
00:45:18,610 --> 00:45:20,510
任何问题？

925
00:45:20,510 --> 00:45:26,220
>> 那么，让我做到这一点，让
我打开一个文本窗口

926
00:45:26,220 --> 00:45:29,100
只是让我们可以尝试
在这里正式的东西。

927
00:45:29,100 --> 00:45:32,410
所以，现在让我继续前进，
实现这个算法

928
00:45:32,410 --> 00:45:35,170
在代码中发现迈克·史密斯，
如果你愿意，伪码。

929
00:45:35,170 --> 00:45:36,620
我不打算使用Java或C ++。

930
00:45:36,620 --> 00:45:38,610
我只是要使用排序
英语的语法，这是我们

931
00:45:38,610 --> 00:45:40,151
一般会叫伪代码。

932
00:45:40,151 --> 00:45:41,660
在这里，我有一个空白窗口。

933
00:45:41,660 --> 00:45:48,180
而且我说的很第一步
第一种算法是拿起电话簿。

934
00:45:48,180 --> 00:45:51,740
第二步是开卷第一页。

935
00:45:51,740 --> 00:45:58,080
步骤3将看
麦克·史密斯页面。

936
00:45:58,080 --> 00:46:02,740
如果页面上，叫麦克。

937
00:46:02,740 --> 00:46:11,640
其他依次页，转到第3步。

938
00:46:11,640 --> 00:46:13,590
完成后，让我们说。

939
00:46:13,590 --> 00:46:18,110
>> 所以它不是相当完美，
我们将看到一个时刻。

940
00:46:18,110 --> 00:46:21,050
但是，让我们考虑一下
概念我在这里介绍。

941
00:46:21,050 --> 00:46:24,450
所以步骤1和2和3
有相当多的动词。

942
00:46:24,450 --> 00:46:26,544
他们声明，actions--做到这一点。

943
00:46:26,544 --> 00:46:28,710
因此在编程
语言，我们一般会

944
00:46:28,710 --> 00:46:32,349
叫他们陈述或
函数或过程，

945
00:46:32,349 --> 00:46:33,640
打电话给他们许多东西。

946
00:46:33,640 --> 00:46:35,460
但他们只是actions--做到这一点。

947
00:46:35,460 --> 00:46:40,370
>> 第4步是根本不同的，
因为它是一种问一个问题。

948
00:46:40,370 --> 00:46:42,400
它说我们是一种
的在一个岔路口。

949
00:46:42,400 --> 00:46:48,000
如果麦克在页面上，请致电
他，所以左转，如果你愿意。

950
00:46:48,000 --> 00:46:52,170
如果没有，回去一定
其他page--或者说，对不起，

951
00:46:52,170 --> 00:46:56,650
回去一些其他步骤，其中
导致某种循环结构。

952
00:46:56,650 --> 00:46:59,530
而我们一次又一次地做一遍。

953
00:46:59,530 --> 00:47:01,300
>> 而实际上，你知道吗？

954
00:47:01,300 --> 00:47:01,800
是啊。

955
00:47:01,800 --> 00:47:04,704

956
00:47:04,704 --> 00:47:09,010
否则，如果在书站结束。

957
00:47:09,010 --> 00:47:11,624
因此，我们需要怎样的一个第三
状态，因为你

958
00:47:11,624 --> 00:47:14,290
不能让翻页广告
nauseum，因为最终，我会

959
00:47:14,290 --> 00:47:15,320
撞书的结尾。

960
00:47:15,320 --> 00:47:18,546
并且在一个程序中的错误可能是
没有预见到的情况。

961
00:47:18,546 --> 00:47:21,420
然后我才意识到，哦，等等
一分钟，我需要第三个场景。

962
00:47:21,420 --> 00:47:23,900
如果我出的网页，我
真的应该只停留。

963
00:47:23,900 --> 00:47:25,330
否则，它是不确定的。

964
00:47:25,330 --> 00:47:29,260
这是怎么回事，如果我继续发生
说翻过这一页，回去，

965
00:47:29,260 --> 00:47:31,810
这是当电脑
死机或崩溃，当你打

966
00:47:31,810 --> 00:47:34,160
一些未预料到的情况那样。

967
00:47:34,160 --> 00:47:37,280
>> 现在，迈克
史密斯的第三算法 - 

968
00:47:37,280 --> 00:47:43,150
拿起电话本，
翻书序曲一到

969
00:47:43,150 --> 00:47:48,640
不，不是第一页这个时候，
到middle--哦，嗯，那倒是

970
00:47:48,640 --> 00:47:49,640
是第二算法。

971
00:47:49,640 --> 00:47:50,590
让我们只是跳到第三。

972
00:47:50,590 --> 00:47:50,930
>> 听众：哦，对不起。

973
00:47:50,930 --> 00:47:51,971
>> DAVID MALAN：那很好。

974
00:47:51,971 --> 00:47:58,590
让我们只是跳到third--开放
以中，现在找迈克·史密斯。

975
00:47:58,590 --> 00:48:02,300
如果页面上，叫麦克。

976
00:48:02,300 --> 00:48:04,910
然后，我们究竟要在这里说什么？

977
00:48:04,910 --> 00:48:06,134
还有什么？

978
00:48:06,134 --> 00:48:10,620

979
00:48:10,620 --> 00:48:12,370
我们可以表达这种
在任何数量的方式。

980
00:48:12,370 --> 00:48:13,369
有没有正确的答案。

981
00:48:13,369 --> 00:48:20,819

982
00:48:20,819 --> 00:48:23,735
好吧，如果不再，但我们需要
be-- OK，我们确实需要两分，

983
00:48:23,735 --> 00:48:25,630
但做我们想要去向左或向右走？

984
00:48:25,630 --> 00:48:29,560
我们如何表达这一概念？

985
00:48:29,560 --> 00:48:31,790
那么，在小李的情况下，是的，这是公平的。

986
00:48:31,790 --> 00:48:35,050
但是好了，这实际上是一个很好的点。

987
00:48:35,050 --> 00:48:35,550
没关系。

988
00:48:35,550 --> 00:48:36,924
我们将继续与这个逻辑下去。

989
00:48:36,924 --> 00:48:38,182
所以 - 

990
00:48:38,182 --> 00:48:39,810
>> 听众：不到一半。

991
00:48:39,810 --> 00:48:40,560
DAVID MALAN：是的。

992
00:48:40,560 --> 00:48:49,820
所以，如果别的页面，我们会说，少
比·史密斯，史密斯的左侧，

993
00:48:49,820 --> 00:48:52,220
then--让我们来看看，是
这要复杂？

994
00:48:52,220 --> 00:49:01,885
否则，如果屏幕出现之前，史密斯，
撕了一半，扔掉哪一半？

995
00:49:01,885 --> 00:49:05,643

996
00:49:05,643 --> 00:49:09,140
>> 听众：我想
这是[听不清]。

997
00:49:09,140 --> 00:49:11,650
>> DAVID MALAN：我听说两个答案。

998
00:49:11,650 --> 00:49:12,431
>> 听众：左。

999
00:49:12,431 --> 00:49:14,430
DAVID MALAN：OK，扔
远的左半边，如Lakisa

1000
00:49:14,430 --> 00:49:19,700
前面说了，左
一半的话，我有种

1001
00:49:19,700 --> 00:49:23,940
想只是去中场休息，我去的权利。

1002
00:49:23,940 --> 00:49:27,380
或等价的，我做了一个小
一开始的有点乱在这里，

1003
00:49:27,380 --> 00:49:30,760
我切实想
再去步骤2，

1004
00:49:30,760 --> 00:49:38,270
其中，开到middle--或open--
是的，我们只能说，页面中间。

1005
00:49:38,270 --> 00:49:39,020
而这种修复它。

1006
00:49:39,020 --> 00:49:39,936
它不再是一本书。

1007
00:49:39,936 --> 00:49:42,210
这只是一本书的一半，
如此开放页面中间。

1008
00:49:42,210 --> 00:49:44,010
>> else--是几乎没有。

1009
00:49:44,010 --> 00:49:54,000
第6步，否则，如果屏幕出现后，史密斯，
撕成两半，扔掉右前卫，

1010
00:49:54,000 --> 00:49:55,680
然后转到步骤2。

1011
00:49:55,680 --> 00:49:58,920

1012
00:49:58,920 --> 00:50:05,230
别的不干了，第四个情况下，如果
我们没有离开页面打开。

1013
00:50:05,230 --> 00:50:06,394
这样我们就可以打扫一下。

1014
00:50:06,394 --> 00:50:07,560
我们应该打扫一下。

1015
00:50:07,560 --> 00:50:10,656
这是很伪代码，如果你
会的，非常高的水平的描述。

1016
00:50:10,656 --> 00:50:12,280
但它确实一般拍摄的想法。

1017
00:50:12,280 --> 00:50:16,040
>> 并再次，在这种情况下，我们
有一个条件的概念，

1018
00:50:16,040 --> 00:50:20,450
一个分支，在一个岔路口，使得
一个decision--如果，走这条路，

1019
00:50:20,450 --> 00:50:23,082
否则如果走这条路，
否则如果走那条路。

1020
00:50:23,082 --> 00:50:25,040
而这是一个非常普遍的
编程技术

1021
00:50:25,040 --> 00:50:27,721
决定哪个方向
去，可以这么说。

1022
00:50:27,721 --> 00:50:29,970
我们也有一些
的循环结构，其中

1023
00:50:29,970 --> 00:50:32,440
我们一次又一次地做一些事情。

1024
00:50:32,440 --> 00:50:34,820
>> 现在，事实证明，很多
如在本实施例中，

1025
00:50:34,820 --> 00:50:37,660
作为超级精确是非常重要的。

1026
00:50:37,660 --> 00:50:42,180
但是，我们也看到了一些
我们保持通话抽象。

1027
00:50:42,180 --> 00:50:45,490
这是什么意思拿起电话簿？

1028
00:50:45,490 --> 00:50:47,740
我们只是那种服用
理所当然的在这个房间

1029
00:50:47,740 --> 00:50:49,340
这是有一定的语义。

1030
00:50:49,340 --> 00:50:51,740
我们都只是一种知道，哦，
好了，拿起电话本。

1031
00:50:51,740 --> 00:50:52,864
这是什么究竟意味着什么？

1032
00:50:52,864 --> 00:50:59,060
嗯，这实际上意味着延长
手，俯身，延长手指，

1033
00:50:59,060 --> 00:51:03,890
手指之间捏书，
站起来，用手拉向你。

1034
00:51:03,890 --> 00:51:05,940
我们可以真正做到
迂腐这一点，

1035
00:51:05,940 --> 00:51:08,640
真的是超级精确
至于我在做什么。

1036
00:51:08,640 --> 00:51:13,300
但是，所有这些步骤都统称
这意味着什么，拿起了电话本。

1037
00:51:13,300 --> 00:51:16,940
>> 因此更早的时候，我说，每
前两个语句

1038
00:51:16,940 --> 00:51:20,830
可以被认为是一个
继续或函数，

1039
00:51:20,830 --> 00:51:24,090
实际上它代表了我们
保持通话的抽象。

1040
00:51:24,090 --> 00:51:28,770
这就像一个高层次的概念
的问题的说明那

1041
00:51:28,770 --> 00:51:31,110
实际上涉及相当多的步骤。

1042
00:51:31,110 --> 00:51:34,190
所以这一点，也是一个
在编程中经常性的话题，

1043
00:51:34,190 --> 00:51:41,125
因此我可能会写一个程序
使用语法像this--

1044
00:51:41,125 --> 00:51:42,000
pick_up_phone_book（）。

1045
00:51:42,000 --> 00:51:44,344

1046
00:51:44,344 --> 00:51:46,510
然后，语法，我
要偷东西

1047
00:51:46,510 --> 00:51:48,090
从大多数编程语言。

1048
00:51:48,090 --> 00:51:51,270
>> 现在，第1步看起来更加
更像是一个函数，

1049
00:51:51,270 --> 00:51:53,160
作为一个程序员调用它。

1050
00:51:53,160 --> 00:51:58,650
它看起来像代码有人
给一个名称，并给予

1051
00:51:58,650 --> 00:52:03,300
我在其他使用somehow--
也就是说，什么线我突出

1052
00:52:03,300 --> 00:52:07,050
代表的功能，也许
我甚至没有实现自己。

1053
00:52:07,050 --> 00:52:10,410
有人年长，比聪明
我已经想通了

1054
00:52:10,410 --> 00:52:12,700
如何表达你的观点
的拿起电话簿。

1055
00:52:12,700 --> 00:52:15,860
它就像五个步骤我只是
列举了，把我的头顶部。

1056
00:52:15,860 --> 00:52:19,350
>> 但他或她已经实现
这一点，给了那些几个步骤

1057
00:52:19,350 --> 00:52:22,339
一个名字，pick_up_phone_book。

1058
00:52:22,339 --> 00:52:24,380
而括号是
正是大多数程序员

1059
00:52:24,380 --> 00:52:27,100
在做这样的语句的结束。

1060
00:52:27,100 --> 00:52:30,190
我现在能站在他或她的
肩膀再也没有，

1061
00:52:30,190 --> 00:52:32,465
想想这意味着什么
拿起电话簿。

1062
00:52:32,465 --> 00:52:34,090
我只能说，拿起电话簿。

1063
00:52:34,090 --> 00:52:36,690
而这正是
我们所有的人在这里做。

1064
00:52:36,690 --> 00:52:38,940
>> 当我们大概1
岁，2岁时，

1065
00:52:38,940 --> 00:52:41,690
有人曾教给我们什么
为了拿起电话簿。

1066
00:52:41,690 --> 00:52:43,810
从那之后，
我们已经抽象化了

1067
00:52:43,810 --> 00:52:46,739
从这些很无趣
机械步骤。

1068
00:52:46,739 --> 00:52:48,530
我们只是有一个
直观的了解

1069
00:52:48,530 --> 00:52:50,480
中意味着什么
拿起电话簿。

1070
00:52:50,480 --> 00:52:55,730
>> 你现在可以推断
更复杂的things--

1071
00:52:55,730 --> 00:52:57,640
建筑大楼。

1072
00:52:57,640 --> 00:52:59,940
像对某些人来说，
实际上具有意义。

1073
00:52:59,940 --> 00:53:03,080
承包商，建筑师，
有一定的意义。

1074
00:53:03,080 --> 00:53:06,400
他们会知道该怎么做，如果
我说，去构建一个建筑。

1075
00:53:06,400 --> 00:53:10,520
>> 但在房间里我们大多数人不能
处理抽象的那个级别。

1076
00:53:10,520 --> 00:53:14,850
你需要告诉我们喜欢去拿
铲去得到具体

1077
00:53:14,850 --> 00:53:17,250
并钉上木块
一起和其他任何

1078
00:53:17,250 --> 00:53:18,830
参与建设的建筑。

1079
00:53:18,830 --> 00:53:21,690
那是因为我们还没有
尚未被编程理解

1080
00:53:21,690 --> 00:53:23,629
这意味着什么建筑大楼。

1081
00:53:23,629 --> 00:53:24,920
我们没有这样的抽象。

1082
00:53:24,920 --> 00:53:26,570
我们没有这个功能。

1083
00:53:26,570 --> 00:53:29,930
>> 所以你会看到
编程语言，在一般情况下，

1084
00:53:29,930 --> 00:53:34,570
尤其是更现代的语言，
像Java，PHP和Ruby和Python，

1085
00:53:34,570 --> 00:53:37,610
他们更成熟
比旧的语言，

1086
00:53:37,610 --> 00:53:40,140
像C和C ++，但其他人。

1087
00:53:40,140 --> 00:53:42,580
因此他们提出更多
功能内置的。

1088
00:53:42,580 --> 00:53:45,640
更多的代码已被写入
人们过去

1089
00:53:45,640 --> 00:53:50,520
我们现在可以通过电话或
召唤或使用，因为我暗示

1090
00:53:50,520 --> 00:53:52,231
在这个位置突出显示的行。

1091
00:53:52,231 --> 00:53:55,230
所以，即使我们不说话
大约本身的编程语言，

1092
00:53:55,230 --> 00:54:00,230
只是伪代码，所有的
想法仍然在讨论中。

1093
00:54:00,230 --> 00:54:04,600
而事实证明精度
超级重要的，是抽象。

1094
00:54:04,600 --> 00:54:06,570
让我们试着
传达如下。

1095
00:54:06,570 --> 00:54:11,000
>> 我不小心可能会被宠坏
这个在屏幕上闪烁的幻灯片

1096
00:54:11,000 --> 00:54:12,260
过早。

1097
00:54:12,260 --> 00:54:16,550
但让我问一个勇敢的志愿者，
如果你不介意的话来了。

1098
00:54:16,550 --> 00:54:19,040
你会在前面
相机，如果你与确定。

1099
00:54:19,040 --> 00:54:24,950
有没有人愿意来，并给
说明在这里你的同事？

1100
00:54:24,950 --> 00:54:29,540
只要有到这里来和
站在这里了，说一些话。

1101
00:54:29,540 --> 00:54:32,890
>> 维多利亚是微笑最
并避免我的眼睛最。

1102
00:54:32,890 --> 00:54:34,740
你愿意来上了？

1103
00:54:34,740 --> 00:54:35,240
好。

1104
00:54:35,240 --> 00:54:38,480
如果每个人都在你的座位
可以拿出一张废纸，

1105
00:54:38,480 --> 00:54:39,750
如果你愿意。

1106
00:54:39,750 --> 00:54:40,760
横格纸是罚款。

1107
00:54:40,760 --> 00:54:41,990
过来这样。

1108
00:54:41,990 --> 00:54:44,580
或某些纸张的那
你昨天给予，

1109
00:54:44,580 --> 00:54:46,493
随便一个空白页
纸，如果你能。

1110
00:54:46,493 --> 00:54:52,240

1111
00:54:52,240 --> 00:54:54,870
如果你没有任何，只
如果你可以问你的邻居。

1112
00:54:54,870 --> 00:55:04,220

1113
00:55:04,220 --> 00:55:07,580
>> 所以，就目前而言，对于
本例中，维

1114
00:55:07,580 --> 00:55:11,520
将要发挥的作用
一个程序员，工程师，谁

1115
00:55:11,520 --> 00:55:16,130
需要你的程序是，作为
电脑，做一些事情。

1116
00:55:16,130 --> 00:55:19,570
我们会看到什么假设
你决定做。

1117
00:55:19,570 --> 00:55:22,700
我们将看到她选择的精确度是。

1118
00:55:22,700 --> 00:55:26,220
如果这个演示云
教学上很好，很多错误

1119
00:55:26,220 --> 00:55:29,220
将作出，我们会再使用
随着讨论的机会。

1120
00:55:29,220 --> 00:55:32,010
但你应该挑战
要避免这些错误，

1121
00:55:32,010 --> 00:55:32,896
成为一个优秀的程序员。

1122
00:55:32,896 --> 00:55:35,520
因此在手的挑战，如果
你喜欢在这里走了过来，

1123
00:55:35,520 --> 00:55:38,799
在屏幕上的维多利亚前
这里 - 并希望，没有你

1124
00:55:38,799 --> 00:55:40,590
当我记得这个
闪现在屏幕上。

1125
00:55:40,590 --> 00:55:44,097
不要转身可言，因为
还有另外一个屏幕在这个房间

1126
00:55:44,097 --> 00:55:44,930
我可以关掉。

1127
00:55:44,930 --> 00:55:46,620
所以，不要回头。

1128
00:55:46,620 --> 00:55:49,090
>> 在维多利亚面前
是一样的尖叫。

1129
00:55:49,090 --> 00:55:54,170
而她现在的工作是告诉你
你一张纸上画什么。

1130
00:55:54,170 --> 00:55:57,020
我们将看到，基于
单单口头指示，

1131
00:55:57,020 --> 00:56:00,020
计算机代码，如果你愿意，
如何准确的图纸

1132
00:56:00,020 --> 00:56:02,330
are--你的实现是。

1133
00:56:02,330 --> 00:56:02,980
合理？

1134
00:56:02,980 --> 00:56:03,604
>> 听众：是的。

1135
00:56:03,604 --> 00:56:04,980
DAVID MALAN：OK，执行。

1136
00:56:04,980 --> 00:56:06,030
>> 听众：画一个正方形。

1137
00:56:06,030 --> 00:56:09,050
>> [笑声]

1138
00:56:09,050 --> 00:56:12,310
>> DAVID MALAN：而且没有
问题可能会问。

1139
00:56:12,310 --> 00:56:13,720
只能做有人告诉你什么。

1140
00:56:13,720 --> 00:56:17,570

1141
00:56:17,570 --> 00:56:22,550
哦，如果你有今天的幻灯片
在标签页中打开，不看你的标签。

1142
00:56:22,550 --> 00:56:23,670
好？

1143
00:56:23,670 --> 00:56:26,135
>> 听众：OK，画一个圆。

1144
00:56:26,135 --> 00:56:32,544

1145
00:56:32,544 --> 00:56:34,872
一个slope--我能说的斜率？

1146
00:56:34,872 --> 00:56:35,830
DAVID MALAN：给你。

1147
00:56:35,830 --> 00:56:38,230

1148
00:56:38,230 --> 00:56:38,980
听众：一个斜坡。

1149
00:56:38,980 --> 00:56:46,330

1150
00:56:46,330 --> 00:56:49,795
和一个三角形。

1151
00:56:49,795 --> 00:56:50,850
>> DAVID MALAN：好的。

1152
00:56:50,850 --> 00:56:52,286
而在这里呆一会儿就好了。

1153
00:56:52,286 --> 00:56:56,046

1154
00:56:56,046 --> 00:56:58,910
而且我要来
在短短的时刻左右。

1155
00:56:58,910 --> 00:57:02,420
没必要把你们的名字。

1156
00:57:02,420 --> 00:57:05,030
让我来到我身边
收集您的图纸，

1157
00:57:05,030 --> 00:57:08,330
如果你不介意撕裂出来。

1158
00:57:08,330 --> 00:57:12,110
>> 下面是我们回来。

1159
00:57:12,110 --> 00:57:14,770
我会投影在屏幕上。

1160
00:57:14,770 --> 00:57:18,310
我看到一个正方形，圆形，
一个斜率和一个三角形。

1161
00:57:18,310 --> 00:57:20,130
所以这是一个答案在那里。

1162
00:57:20,130 --> 00:57:23,640
和let's--哎呦。

1163
00:57:23,640 --> 00:57:25,370
谢谢。

1164
00:57:25,370 --> 00:57:30,710
这里的另一个品种，
和一个它的后面。

1165
00:57:30,710 --> 00:57:34,130

1166
00:57:34,130 --> 00:57:37,120
>> 因此，他们似乎都捕捉到的精神。

1167
00:57:37,120 --> 00:57:38,600
谢谢。

1168
00:57:38,600 --> 00:57:44,970
还有一个，这里是另外一个。

1169
00:57:44,970 --> 00:57:51,590
斜坡的解释是
有点不同，有点弯曲。

1170
00:57:51,590 --> 00:57:57,140
与最接近的，或者是因为
与你已经特异性精彩

1171
00:57:57,140 --> 00:58:03,520
描述的，或者你有种
看到它之前，这确实是

1172
00:58:03,520 --> 00:58:06,340
维多利亚什么实际描述。

1173
00:58:06,340 --> 00:58:09,190
>> 但现在，那些你们谁
没有得到它完全正确，

1174
00:58:09,190 --> 00:58:11,140
让我们在这里提供了一些异议。

1175
00:58:11,140 --> 00:58:13,770
所以维多利亚先说画一个正方形。

1176
00:58:13,770 --> 00:58:15,830
而现在，我们可以假设
今天的缘故

1177
00:58:15,830 --> 00:58:17,538
大家都知道
如何绘制一个正方形。

1178
00:58:17,538 --> 00:58:20,590
但是，这并不完全清楚，对不对？

1179
00:58:20,590 --> 00:58:23,220
你怎么还能有
画出的方形，或在

1180
00:58:23,220 --> 00:58:27,114
可能是一些模棱两可的
这里的电脑吗？

1181
00:58:27,114 --> 00:58:28,280
听众：位置和大小。

1182
00:58:28,280 --> 00:58:28,980
DAVID MALAN：位置，对不对？

1183
00:58:28,980 --> 00:58:32,070
在座的各位有一些形状的纸，
一般矩形，但稍微

1184
00:58:32,070 --> 00:58:32,830
不同的尺寸。

1185
00:58:32,830 --> 00:58:36,250
但你肯定会已制定，
如果你想，一个巨大的广场，也许

1186
00:58:36,250 --> 00:58:37,220
一个小广场。

1187
00:58:37,220 --> 00:58:38,417
也许，有人旋转。

1188
00:58:38,417 --> 00:58:39,500
我不认为我们看到了。

1189
00:58:39,500 --> 00:58:41,790
但是，它可能是更多的钻石
喜欢但还是尽管如此，

1190
00:58:41,790 --> 00:58:42,900
数学上的正方形。

1191
00:58:42,900 --> 00:58:44,850
所以这是可以说是模棱两可。

1192
00:58:44,850 --> 00:58:46,709
>> 然后她说，画一个圆。

1193
00:58:46,709 --> 00:58:49,250
你们有些人根本旁边绘制
它，这是没有道理的，

1194
00:58:49,250 --> 00:58:52,450
因为人类倾向于认为或阅读
从右到左的大多数语言，所以不是

1195
00:58:52,450 --> 00:58:53,017
一个坏的猜测。

1196
00:58:53,017 --> 00:58:55,100
但那个圈子可能
一直在正方形内，

1197
00:58:55,100 --> 00:58:57,600
本来是围绕着
广场上，本来是在别处

1198
00:58:57,600 --> 00:58:59,480
在纸张上的，所以可以说是模棱两可。

1199
00:58:59,480 --> 00:59:03,290
>> 斜率可能已经也许
采取最自由口头

1200
00:59:03,290 --> 00:59:04,200
有什么意思。

1201
00:59:04,200 --> 00:59:06,980
和你们中的一些解释
它作为一个波浪线

1202
00:59:06,980 --> 00:59:08,560
或直线等。

1203
00:59:08,560 --> 00:59:11,719
然后三角形，也可以有
被定向在任何数量的方式。

1204
00:59:11,719 --> 00:59:14,760
因此，在短期，即使有一些
你一眼，你就像，哇，好

1205
00:59:14,760 --> 00:59:17,020
简单，小孩子可以
得出这样的，好了没有

1206
00:59:17,020 --> 00:59:19,640
真的，除非你
超级，超级说服力

1207
00:59:19,640 --> 00:59:22,045
并告诉计算机
究竟该怎么做。

1208
00:59:22,045 --> 00:59:24,420
因此，如果我们可以，如果你有
另一张纸上，让我们

1209
00:59:24,420 --> 00:59:26,710
试试这一次。

1210
00:59:26,710 --> 00:59:29,880
我想给维多利亚1
这里，屏幕上的其他的例子。

1211
00:59:29,880 --> 00:59:34,060
再次，不掉头
不看你的幻灯片。

1212
00:59:34,060 --> 00:59:37,304
我给她一点时间
想想如何描述这一点。

1213
00:59:37,304 --> 00:59:39,012
不要让他们看到
恐惧在你的眼前。

1214
00:59:39,012 --> 00:59:40,820
>> [笑声]

1215
00:59:40,820 --> 00:59:43,710
>> 再次，这一次杠杆
其中一些外卖

1216
00:59:43,710 --> 00:59:48,130
并试图让几乎所有人
至少正确的答案。

1217
00:59:48,130 --> 00:59:52,260
>> 听众：OK，取
一张纸，看看

1218
00:59:52,260 --> 00:59:54,500
在一张纸的中间。

1219
00:59:54,500 --> 00:59:59,591
在那片中间
纸，画一个立方体。

1220
00:59:59,591 --> 01:00:01,244
>> [笑声]

1221
01:00:01,244 --> 01:00:02,660
DAVID MALAN：有我们学到了什么？

1222
01:00:02,660 --> 01:00:03,540
我们是如此接近。

1223
01:00:03,540 --> 01:00:06,320

1224
01:00:06,320 --> 01:00:09,045
OK，重复，如果你能为大家。

1225
01:00:09,045 --> 01:00:13,210
>> 听众：在的中间
一张纸，画一个对象，

1226
01:00:13,210 --> 01:00:14,842
它看起来像一个立方体。

1227
01:00:14,842 --> 01:00:17,332
>> DAVID MALAN：OK，这是
你所得到的工作。

1228
01:00:17,332 --> 01:00:20,010

1229
01:00:20,010 --> 01:00:23,080
请允许我以分析
并没有那么多的关键，

1230
01:00:23,080 --> 01:00:25,720
但要索赔
维多利亚肯定

1231
01:00:25,720 --> 01:00:28,967
似乎非常想在
高层次的抽象，它

1232
01:00:28,967 --> 01:00:29,800
不是没有道理的。

1233
01:00:29,800 --> 01:00:32,160
因为否则的话，我们都会
是非常不正常的，

1234
01:00:32,160 --> 01:00:35,740
如果我们是有史以来如此精确
与我们所做的一切的世界。

1235
01:00:35,740 --> 01:00:38,890
>> 但话说到了我middle--
以为我们是在这样一个良好的跟踪

1236
01:00:38,890 --> 01:00:42,340
那里，就像去正中央
页面，然后绘制一个立方体。

1237
01:00:42,340 --> 01:00:45,730
于是，她的思维抽象，
因为她还是观看

1238
01:00:45,730 --> 01:00:48,490
什么是确实是屏幕上的立方体。

1239
01:00:48,490 --> 01:00:51,185
但是，有这么多的机会
口译那里。

1240
01:00:51,185 --> 01:00:53,560
而事实上，有这么多
你可以表达其它方式

1241
01:00:53,560 --> 01:00:55,101
是，我将在稍后提出。

1242
01:00:55,101 --> 01:00:59,770
所以在这里我们有一个化身
在picture-- whoops--之一

1243
01:00:59,770 --> 01:01:02,830
图片的化身，所以
小三维它，

1244
01:01:02,830 --> 01:01:04,160
这是很好的。

1245
01:01:04,160 --> 01:01:08,470
>> 这里是另外一个，在这里你有
同样的，虽然它是一种开放的立方体。

1246
01:01:08,470 --> 01:01:12,020
有些人把它一点点
更加扁平化，二维的。

1247
01:01:12,020 --> 01:01:13,910
这很好。

1248
01:01:13,910 --> 01:01:17,380
所以，确实是在
纸张的中心。

1249
01:01:17,380 --> 01:01:22,720
这一次我想你会
喜欢，因为如果我们何去何从，

1250
01:01:22,720 --> 01:01:25,130
这就是她被描述的。

1251
01:01:25,130 --> 01:01:29,570
所以，现在，让我提出怎么回事
我们可以描述这种情况。

1252
01:01:29,570 --> 01:01:34,070
>> 早在一天，一个最
比较常见的方式来学习编程

1253
01:01:34,070 --> 01:01:38,900
是写代码，写
指令线，

1254
01:01:38,900 --> 01:01:42,640
该控制的小
龟在屏幕上。

1255
01:01:42,640 --> 01:01:45,660
标志和本其他的变种
是语言的名称。

1256
01:01:45,660 --> 01:01:47,550
而龟生活的世界。

1257
01:01:47,550 --> 01:01:49,970
>> 因此，假设该矩形
空间是他的世界。

1258
01:01:49,970 --> 01:01:53,340
你会被assuming--我做起
真的不知道怎么画乌龟，

1259
01:01:53,340 --> 01:01:54,740
让我们像这样做。

1260
01:01:54,740 --> 01:01:57,340
然后，他有一个壳
然后也许有些脚。

1261
01:01:57,340 --> 01:01:59,840
所以，你可能有这个小
字符在屏幕上。

1262
01:01:59,840 --> 01:02:02,270
>> 并在此对象
程序设计语言

1263
01:02:02,270 --> 01:02:06,070
是迫使龟
往上走，下，左，右

1264
01:02:06,070 --> 01:02:08,420
并把他下笔
或拿起他的笔了，

1265
01:02:08,420 --> 01:02:12,720
因此他居然可以在屏幕上绘制
在这个平面呈长方形的世界。

1266
01:02:12,720 --> 01:02:16,850
那么，我想你可能会去，
并且，你应该考虑跳水

1267
01:02:16,850 --> 01:02:19,520
到精神上描述时，
说明更一般地，

1268
01:02:19,520 --> 01:02:21,720
我会声称，就是把你
笔在middle--下降

1269
01:02:21,720 --> 01:02:23,100
我们会摆脱
乌龟，因为我真的不能

1270
01:02:23,100 --> 01:02:24,680
不断吸引他很好。

1271
01:02:24,680 --> 01:02:27,170
>> 而现在，还能怎样
我说画一个立方体？

1272
01:02:27,170 --> 01:02:32,830
好了，我们可以这样说平局
一个对角线东北，例如

1273
01:02:32,830 --> 01:02:35,182
或以45度角向上。

1274
01:02:35,182 --> 01:02:36,640
而这可能会在这里得到了我。

1275
01:02:36,640 --> 01:02:38,380
而我从一个立方体很远。

1276
01:02:38,380 --> 01:02:42,430
但现在，我可以说的东西
像旋转90度到左侧

1277
01:02:42,430 --> 01:02:47,370
画线的
等长西北部。

1278
01:02:47,370 --> 01:02:49,470
而且我可以继续
具有类似的方向。

1279
01:02:49,470 --> 01:02:50,720
而且这不是一件容易的事。

1280
01:02:50,720 --> 01:02:53,345
坦率地说，我们可能会
在这里已经五分钟。

1281
01:02:53,345 --> 01:02:59,600
但也许我们会得到以
东西，在一天结束时，

1282
01:02:59,600 --> 01:03:04,280
最终被一个立方体，但我们
跳水是抽象的内

1283
01:03:04,280 --> 01:03:06,370
做到这一点在如此低的
级别你不能真正

1284
01:03:06,370 --> 01:03:09,795
看到你在做什么，直到整个
事情是居然还有在页面上。

1285
01:03:09,795 --> 01:03:12,670
所以这是一个总的原则，
再次，programming--这个想法

1286
01:03:12,670 --> 01:03:13,320
抽象。

1287
01:03:13,320 --> 01:03:15,920
它是如此奇妙
强大，因为再次，

1288
01:03:15,920 --> 01:03:19,281
她只是说，画一个立方体，所有的
我们几乎将神交非常快。

1289
01:03:19,281 --> 01:03:21,030
我们只是知道，
OK，绘制一个立方体。

1290
01:03:21,030 --> 01:03:24,030
我们可能不知道的方向，
所以我们可以是一个小更精确，

1291
01:03:24,030 --> 01:03:26,297
但我们可以大致想象
或者知道一个立方体是什么。

1292
01:03:26,297 --> 01:03:28,130
这是非常有用的，
因为如果你每次

1293
01:03:28,130 --> 01:03:31,540
坐了下来，作为一个程序员在
键盘来写代码，

1294
01:03:31,540 --> 01:03:33,912
如果你不得不想在这样
较低的水平，我们谁也没

1295
01:03:33,912 --> 01:03:35,120
会永远做成任何事情。

1296
01:03:35,120 --> 01:03:38,259
当然，没有人会
享受编写代码的过程。

1297
01:03:38,259 --> 01:03:41,550
它会像在0和1的写作，
坦率地说是不是所有的很久以前

1298
01:03:41,550 --> 01:03:43,680
人类是在0和1的编写代码。

1299
01:03:43,680 --> 01:03:46,960
我们很快就想出了
这些较高级别languages​​--

1300
01:03:46,960 --> 01:03:49,410
C ++和Java等。

1301
01:03:49,410 --> 01:03:52,500
>> 因此，让我们试试这个一次刚
翻转表，让我们所有的人

1302
01:03:52,500 --> 01:03:55,450
不得不思考的机会
在相当的方式相同。

1303
01:03:55,450 --> 01:03:59,230
我们可以得到一个更多志愿者这
来时间最长的板和借鉴，

1304
01:03:59,230 --> 01:04:01,480
不背诵？

1305
01:04:01,480 --> 01:04:02,070
是啊，OK。

1306
01:04:02,070 --> 01:04:04,820
本，上来吧。

1307
01:04:04,820 --> 01:04:08,510
而且，本，在这种情况下，一旦你
面对董事会，不看左边，

1308
01:04:08,510 --> 01:04:09,370
不看的权利。

1309
01:04:09,370 --> 01:04:12,367
只能做你的
同事在这里告诉你。

1310
01:04:12,367 --> 01:04:14,950
而对于其他人的
房间里，你现在的程序员。

1311
01:04:14,950 --> 01:04:16,020
他的计算机。

1312
01:04:16,020 --> 01:04:21,395
和画面我在这里选择
提前这是一个在这里。

1313
01:04:21,395 --> 01:04:24,490

1314
01:04:24,490 --> 01:04:27,660
他们just--他们在想
一个有趣的笑话就是一切。

1315
01:04:27,660 --> 01:04:31,510
>> 所以会有人不喜欢
志愿的第一条指令

1316
01:04:31,510 --> 01:04:35,470
或声明应
命令Ben的笔吗？

1317
01:04:35,470 --> 01:04:40,850
我们会集体这样做，也许
从每人一个指令。

1318
01:04:40,850 --> 01:04:41,440
对不起？

1319
01:04:41,440 --> 01:04:42,440
>> 听众：画一个圆。

1320
01:04:42,440 --> 01:04:45,866
DAVID MALAN：画一个圆
是我听到的第一件事。

1321
01:04:45,866 --> 01:04:47,100
>> 听众：向上顶。

1322
01:04:47,100 --> 01:04:48,140
>> DAVID MALAN：往上顶。

1323
01:04:48,140 --> 01:04:52,504
OK，我们可以让你删除，撤消。

1324
01:04:52,504 --> 01:04:53,420
而现在，别人。

1325
01:04:53,420 --> 01:04:55,994
丹，你会舒服
提供的下一个指令？

1326
01:04:55,994 --> 01:05:02,070
>> 听众：当然，绘制中心
圆的底部的，

1327
01:05:02,070 --> 01:05:07,121
与small--一点
从狭小的空间，

1328
01:05:07,121 --> 01:05:15,420
画一条直线下降到三
的方式季度在案板上

1329
01:05:15,420 --> 01:05:17,845
一个微小的角度，以你的左边。

1330
01:05:17,845 --> 01:05:21,250

1331
01:05:21,250 --> 01:05:22,620
>> DAVID MALAN：好。

1332
01:05:22,620 --> 01:05:24,086
>> 听众：很小的角度。

1333
01:05:24,086 --> 01:05:32,807
>> DAVID MALAN：撤销，Ctrl-Z键。好。

1334
01:05:32,807 --> 01:05:34,890
安德鲁，你想提供
向上的下一个指令？

1335
01:05:34,890 --> 01:05:35,515
>> 听众：当然。

1336
01:05:35,515 --> 01:05:43,250
从该行的底部，
进一步轻微angle--

1337
01:05:43,250 --> 01:05:49,024
whoops--也许大约三分之一
长度[听不清]

1338
01:05:49,024 --> 01:05:52,928
很小的角度向下像
第三[听不清]的长度。

1339
01:05:52,928 --> 01:05:57,550

1340
01:05:57,550 --> 01:06:00,578
所以是的，从这一点来说，
画一条线第三

1341
01:06:00,578 --> 01:06:04,150
先前的长度的
线进一步向左侧。

1342
01:06:04,150 --> 01:06:08,416

1343
01:06:08,416 --> 01:06:10,040
>> DAVID MALAN：那行吗？

1344
01:06:10,040 --> 01:06:12,330
直线，这是确定？

1345
01:06:12,330 --> 01:06:14,900
OK，奥利弗，你要
提供了下？

1346
01:06:14,900 --> 01:06:28,564
>> 听众：[听不清]从
圆的底部，[听不清]。

1347
01:06:28,564 --> 01:06:32,000

1348
01:06:32,000 --> 01:06:45,126
借鉴右侧
的[听不清]厘米。

1349
01:06:45,126 --> 01:06:46,560
>> [笑声]

1350
01:06:46,560 --> 01:06:49,872
>> DAVID MALAN：我想你会
要转换这里是英寸。

1351
01:06:49,872 --> 01:06:50,764
>> 听众：停止。

1352
01:06:50,764 --> 01:06:52,186
>> [笑声]

1353
01:06:52,186 --> 01:06:54,570
>> DAVID MALAN：OK。

1354
01:06:54,570 --> 01:06:56,660
[？ ARA，？]你想
提供了下？

1355
01:06:56,660 --> 01:07:00,653

1356
01:07:00,653 --> 01:07:15,443
>> 听众：绘制[听不清]
上部[听不清]相同。

1357
01:07:15,443 --> 01:07:28,829
[听不清]画圆，画到
[听不清]，并绘制[听不清]。

1358
01:07:28,829 --> 01:07:33,799

1359
01:07:33,799 --> 01:07:36,730
>> DAVID MALAN：OK，没有更多的撤消。

1360
01:07:36,730 --> 01:07:38,390
让我们做一个或两个指令。

1361
01:07:38,390 --> 01:07:40,825
克里斯，你想提供一个？

1362
01:07:40,825 --> 01:07:46,182
>> 听众：在底部
圆的，[听不清]

1363
01:07:46,182 --> 01:07:51,528
绘制平等线喷溅
向下向左[听不清]。

1364
01:07:51,528 --> 01:07:59,304

1365
01:07:59,304 --> 01:08:00,590
>> DAVID MALAN：OK。

1366
01:08:00,590 --> 01:08:01,170
安德鲁？

1367
01:08:01,170 --> 01:08:02,472
我们did--卡里姆？

1368
01:08:02,472 --> 01:08:06,891

1369
01:08:06,891 --> 01:08:13,765
>> 听众：从右边线开始，
左行的末尾，底部

1370
01:08:13,765 --> 01:08:21,012
你要去说得对
的长度相同线

1371
01:08:21,012 --> 01:08:27,680
你在，绘图
正确的[听不清]。

1372
01:08:27,680 --> 01:08:33,572

1373
01:08:33,572 --> 01:08:37,991
[听不清]度，所以[听不清]
度在右侧。

1374
01:08:37,991 --> 01:08:41,919

1375
01:08:41,919 --> 01:08:43,500
>> DAVID MALAN：好的。

1376
01:08:43,500 --> 01:08:44,029
让我们暂停一下。

1377
01:08:44,029 --> 01:08:44,950
不要转身呢。

1378
01:08:44,950 --> 01:08:46,783
让我们暂停，让我们
尝试另一个尝试

1379
01:08:46,783 --> 01:08:48,850
我们之前透露给本
他一直画。

1380
01:08:48,850 --> 01:08:51,189
您可以随机播放奔
在right--或实际，

1381
01:08:51,189 --> 01:08:54,080
没有，我们只是给你
另一块板，甚至更好。

1382
01:08:54,080 --> 01:08:57,640
所以会有人现在想
采取更多的办法

1383
01:08:57,640 --> 01:09:02,149
维多利亚在早期花了，在那里
我们在一个更高层次的抽象说话

1384
01:09:02,149 --> 01:09:05,149
在短短一个句子
两个描述奔

1385
01:09:05,149 --> 01:09:07,229
没有什么画
渐入杂草，

1386
01:09:07,229 --> 01:09:10,670
可以这么说，在这一个较低的水平？

1387
01:09:10,670 --> 01:09:11,206
维多利亚。

1388
01:09:11,206 --> 01:09:11,706
[笑声]

1389
01:09:11,706 --> 01:09:14,249
听众：画一个图
的行走的人。

1390
01:09:14,249 --> 01:09:18,866
而他的腿和胳膊
必须是右侧。

1391
01:09:18,866 --> 01:09:20,505
>> DAVID MALAN：OK，这就是你得到的。

1392
01:09:20,505 --> 01:09:27,210

1393
01:09:27,210 --> 01:09:27,710
好吧。

1394
01:09:27,710 --> 01:09:31,609
我们为什么不透露给奔他做了什么。

1395
01:09:31,609 --> 01:09:32,890
所以，掌声雷动。

1396
01:09:32,890 --> 01:09:35,700
这是最难的也许。

1397
01:09:35,700 --> 01:09:37,931
>> 因此，即使我们谈论
在相当愚蠢的条款

1398
01:09:37,931 --> 01:09:39,680
关于刚刚绘制
图片，希望你

1399
01:09:39,680 --> 01:09:44,226
才能真正体会的程度
表现，可能是必要

1400
01:09:44,226 --> 01:09:45,850
为了告诉计算机做什么。

1401
01:09:45,850 --> 01:09:50,370
而事实上，这一事实本
之所以能够如此迅速地得出这样的

1402
01:09:50,370 --> 01:09:54,227
是有点遗嘱于使用
语言，也许是更高层次

1403
01:09:54,227 --> 01:09:57,060
英文版本，允许他
只是使用的话，或者听到的话

1404
01:09:57,060 --> 01:09:59,990
从维多利亚，这让他
这些abstractions--只画

1405
01:09:59,990 --> 01:10:03,020
一个人影步行到
right--那种有

1406
01:10:03,020 --> 01:10:07,100
一些语义它不是
几乎一样明显，当你只是

1407
01:10:07,100 --> 01:10:10,310
他说，把你的下笔，画
到右侧，绘制到左边。

1408
01:10:10,310 --> 01:10:12,420
>> 所以这也很
常见的编程。

1409
01:10:12,420 --> 01:10:15,253
这可以说是像
非常低级语言，编程

1410
01:10:15,253 --> 01:10:16,730
在0和1的，如果你愿意。

1411
01:10:16,730 --> 01:10:19,320
并且这将是一个更高的水平
编程语言在Java中，

1412
01:10:19,320 --> 01:10:20,278
或类似的东西。

1413
01:10:20,278 --> 01:10:22,050
的A位
过于简单化，但是这

1414
01:10:22,050 --> 01:10:24,310
该有点像情绪
感觉，你觉得当

1415
01:10:24,310 --> 01:10:26,630
用一种东西或其他。

1416
01:10:26,630 --> 01:10:32,650
无奈有点这里所需要
对于这样的精度，但机会

1417
01:10:32,650 --> 01:10:34,930
是有点宽松与
这里的解释。

1418
01:10:34,930 --> 01:10:38,060
不过，当然，错误
可以作为结果产生。

1419
01:10:38,060 --> 01:10:40,500
>> 如果您想在home--我们
不会做这一块的分类 - 

1420
01:10:40,500 --> 01:10:41,900
但如果你想
这带来一个归属，

1421
01:10:41,900 --> 01:10:43,387
我以为我们会潜入这一点。

1422
01:10:43,387 --> 01:10:45,970
所以，如果你想打这个
游戏与其他显著

1423
01:10:45,970 --> 01:10:49,180
或孩子或类似物，则
可能会喜欢这一点。

1424
01:10:49,180 --> 01:10:54,460
>> 因此，让我们继续前进，并期待在最后
这里计算思维的东西。

1425
01:10:54,460 --> 01:10:57,010
这给我们带来了约翰
奥利弗，不为剪辑

1426
01:10:57,010 --> 01:11:00,070
你可能已经看到昨晚，
但是有点最近的问题。

1427
01:11:00,070 --> 01:11:03,310
几个月前，大众汽车
花了很有点高射炮

1428
01:11:03,310 --> 01:11:05,651
是什么原因，如果你知道吗？

1429
01:11:05,651 --> 01:11:07,025
他们怎么惹上麻烦呢？

1430
01:11:07,025 --> 01:11:10,270

1431
01:11:10,270 --> 01:11:14,030
>> 是啊，所以他们emissions--
试图击败排放

1432
01:11:14,030 --> 01:11:19,100
通过实质上有测试他们的
汽车污染环境少

1433
01:11:19,100 --> 01:11:23,620
当他们的汽车被正在测试
，污染环境的更

1434
01:11:23,620 --> 01:11:25,547
当汽车没有被测试。

1435
01:11:25,547 --> 01:11:28,630
什么是越来越有趣
在世界上，你可能已经推断出

1436
01:11:28,630 --> 01:11:34,072
从like--讨论是什么
它 -  CarPlay，苹果软件汽车

1437
01:11:34,072 --> 01:11:35,780
而事实上，许多
我们越来越多地

1438
01:11:35,780 --> 01:11:38,390
有触摸屏在我们的汽车，
有一个可怕的量

1439
01:11:38,390 --> 01:11:41,250
在人们的软件
今天的汽车，这

1440
01:11:41,250 --> 01:11:45,650
坦率地打开蠕虫的时候一个整体
它涉及到安全和人身风险。

1441
01:11:45,650 --> 01:11:48,070
但在今天，让我们
只关注什么

1442
01:11:48,070 --> 01:11:52,170
参与编写软件
可能已耍花招系统。

1443
01:11:52,170 --> 01:11:54,510
>> 对于的定义
问题，对于那些不熟悉，

1444
01:11:54,510 --> 01:11:55,740
让我们来看看约翰·奥利弗。

1445
01:11:55,740 --> 01:11:58,115
而对于那些熟悉
这个问题，让我们来看看它

1446
01:11:58,115 --> 01:12:00,480
在通过约翰·奥利弗一个有趣的镜头，以及。

1447
01:12:00,480 --> 01:12:05,810
因此，让我打这个游戏，我
认为，三分钟的介绍。

1448
01:12:05,810 --> 01:12:07,074
该死的。

1449
01:12:07,074 --> 01:12:07,740
[视频回放]

1450
01:12:07,740 --> 01:12:08,170
-汽车 - 

1451
01:12:08,170 --> 01:12:09,919
DAVID MALAN：很明显，
在YouTube上，it's--

1452
01:12:09,919 --> 01:12:12,500
 -  --the最聪明的字符
在速度与激情的电影。

1453
01:12:12,500 --> 01:12:16,080
本周，德国汽车制造商
大众发现自己

1454
01:12:16,080 --> 01:12:19,430
在丑闻的中间
潜在的犯罪比例。

1455
01:12:19,430 --> 01:12:23,020
>> -Volkswagen是支撑数十亿
罚款，可能的刑事指控

1456
01:12:23,020 --> 01:12:25,530
其高管，如
公司道歉

1457
01:12:25,530 --> 01:12:28,790
索具1100多万辆汽车，以
帮助其击败的排放测试。

1458
01:12:28,790 --> 01:12:32,110
>>  - 某些柴油车型设计
与先进的软件，

1459
01:12:32,110 --> 01:12:35,410
使用的信息，包括位置
方向盘和车辆的

1460
01:12:35,410 --> 01:12:38,820
速度，以确定汽车是
进行排放检测。

1461
01:12:38,820 --> 01:12:42,620
该种情况下，发动机
将减少有毒物质的排放。

1462
01:12:42,620 --> 01:12:46,040
但是汽车操纵旁路
当它被驱动。

1463
01:12:46,040 --> 01:12:51,370
排放量增加10至40
次超过可接受水平的EPA。

1464
01:12:51,370 --> 01:12:55,920
>> -Wow，10〜40倍
大于EPA允许。

1465
01:12:55,920 --> 01:12:59,570
这是最糟糕的事情
大众已经做过，

1466
01:12:59,570 --> 01:13:04,200
是你可能会说，如果
你从来没有听说过二战。

1467
01:13:04,200 --> 01:13:09,710
但也许是如何最确实的标志
比较麻烦大众是，

1468
01:13:09,710 --> 01:13:12,730
是人们在很
上面已经下台。

1469
01:13:12,730 --> 01:13:16,320
该公司首席执行官辞职后，周三
争着做损害控制，

1470
01:13:16,320 --> 01:13:20,380
说他对不起不休，这
响起了巨大直到它横空出世

1471
01:13:20,380 --> 01:13:22,920
他只有10％的遗憾
但操纵了他的嘴

1472
01:13:22,920 --> 01:13:25,600
人为夸大他的sorriness。

1473
01:13:25,600 --> 01:13:29,700
而与此同时，大众汽车在美国
首席有他自己的道歉。

1474
01:13:29,700 --> 01:13:33,580
>>  - 让我们清楚这一点，
我们公司是不诚实的。

1475
01:13:33,580 --> 01:13:37,140
而在我的德语单词，我们
已经完全搞砸了。

1476
01:13:37,140 --> 01:13:41,360
>> 是啊，但完全拧
最多是不是德国人的作品。

1477
01:13:41,360 --> 01:13:43,750
和德语
有许多美丽的短语

1478
01:13:43,750 --> 01:13:50,070
来形容，就像这样的情况下，
如[德国]，这意味着大致，

1479
01:13:50,070 --> 01:13:52,870
自带的悲伤
从业务相关的谎言，

1480
01:13:52,870 --> 01:13:59,060
或[德国]，换算
作为羞辱那些涉及父亲

1481
01:13:59,060 --> 01:14:00,352
汽油云。

1482
01:14:00,352 --> 01:14:02,060
这是一个美丽的语言。

1483
01:14:02,060 --> 01:14:04,660
它只是帆了舌头。

1484
01:14:04,660 --> 01:14:07,920
顺便说一句，而男人的
道歉也许听起来诚恳，

1485
01:14:07,920 --> 01:14:12,260
值得注意的是，他在讲话
2016年官方发布派对

1486
01:14:12,260 --> 01:14:17,310
大众帕萨特，这意味着短期内
说对不起后，他这样表示。

1487
01:14:17,310 --> 01:14:18,850
>>  - 谢谢的光临。

1488
01:14:18,850 --> 01:14:19,630
享受夜晚。

1489
01:14:19,630 --> 01:14:21,300
旁边是蓝尼·克罗维兹。

1490
01:14:21,300 --> 01:14:24,640
>> [音乐]

1491
01:14:24,640 --> 01:14:28,230
>> -OK，OK，你的结局
道歉与旁边

1492
01:14:28,230 --> 01:14:31,940
蓝尼·克罗维兹不
尖叫清醒悔悟。

1493
01:14:31,940 --> 01:14:35,830
它的尖叫声，我们问苯教
乔维，他说没有。

1494
01:14:35,830 --> 01:14:38,600
大众汽车的品牌有
遭到严重破坏。

1495
01:14:38,600 --> 01:14:42,466
坦率地说，他们的新广告
运动是不完全帮助。

1496
01:14:42,466 --> 01:14:47,289
>>  -  [德国]，我们在大众汽车希望
为欺骗你道歉

1497
01:14:47,289 --> 01:14:47,930
我们的车辆。

1498
01:14:47,930 --> 01:14:48,513
>> [结束播放]

1499
01:14:48,513 --> 01:14:54,090
DAVID MALAN：所以这是一个
环岛路of-- sorry--

1500
01:14:54,090 --> 01:14:58,730
这是一种迂回的方式
引入一个基本问题

1501
01:14:58,730 --> 01:15:02,810
在软件，这是你
需要检测一定的条件。

1502
01:15:02,810 --> 01:15:07,680
这样一来，在眼前的问题在这里
是，请问有车有可能，

1503
01:15:07,680 --> 01:15:09,870
作为在软件中实现
这些程序员，

1504
01:15:09,870 --> 01:15:11,850
检测到它实际上被测试？

1505
01:15:11,850 --> 01:15:14,150
所以要超清晰，
他们在做什么

1506
01:15:14,150 --> 01:15:17,940
是，在环境中
程序员想通

1507
01:15:17,940 --> 01:15:20,460
该车当时正在
经过测试，他们不知何故

1508
01:15:20,460 --> 01:15:24,840
汽车排放少排放，少
排放量，所以毒性较低的烟雾

1509
01:15:24,840 --> 01:15:25,470
和这样的。

1510
01:15:25,470 --> 01:15:27,261
但是，当它通常
驾驶的道路上，

1511
01:15:27,261 --> 01:15:30,350
它只是发出尽可能多
污染，因为它想要的。

1512
01:15:30,350 --> 01:15:33,870
>> 所以，我们怎么可能写
伪这个算法？

1513
01:15:33,870 --> 01:15:37,820
我们怎么能写的伪代码
在汽车运行的软件？

1514
01:15:37,820 --> 01:15:43,390
我的意思是，简而言之，沸腾
到这样的事情。

1515
01:15:43,390 --> 01:15:48,000
在被测试，减少排放。

1516
01:15:48,000 --> 01:15:50,750
其他排放更多。

1517
01:15:50,750 --> 01:15:52,630
但是，这是一个小
过高的水平，对不对？

1518
01:15:52,630 --> 01:15:58,580
>> 让我们尝试潜水至于这是什么
被测试手段抽象。

1519
01:15:58,580 --> 01:16:06,340
换句话说，即使你什么都不知道
问题关于汽车，什么样的

1520
01:16:06,340 --> 01:16:13,440
也许你为了确定是否问
你正在测试中，如果你的车？

1521
01:16:13,440 --> 01:16:19,638
什么样的特点可能是
目前如果汽车正在测试？

1522
01:16:19,638 --> 01:16:21,026
>> 听众：检测设备。

1523
01:16:21,026 --> 01:16:22,420
>> DAVID MALAN：检测设备。

1524
01:16:22,420 --> 01:16:26,060
因此，如果检测设备
在附近，然后减少排放。

1525
01:16:26,060 --> 01:16:28,669
所以，我可以想像实施
与某种相机

1526
01:16:28,669 --> 01:16:29,960
或者检测什么是你的周围。

1527
01:16:29,960 --> 01:16:32,870
让我，让我们
只是感觉太复杂

1528
01:16:32,870 --> 01:16:37,914
实际上还有其他
硬件只是用于这一目的。

1529
01:16:37,914 --> 01:16:44,830
>> 听众：如果你在
公园，如果你的引擎盖打开。

1530
01:16:44,830 --> 01:16:47,320
>> DAVID MALAN：在公园或
引擎盖打开，所以这是很好的。

1531
01:16:47,320 --> 01:16:47,420
>> 听众：与汽车的运行。

1532
01:16:47,420 --> 01:16:50,480
>> DAVID MALAN：所以这是一个有点
更concrete--和汽车的运行。

1533
01:16:50,480 --> 01:16:55,690
因此，这将是一个会合
几个不同的情况下，如果你愿意。

1534
01:16:55,690 --> 01:16:59,227
因此，如果汽车在公园里，甚至
虽然这是一个非常机械的东西

1535
01:16:59,227 --> 01:17:01,060
通常情况下，我可以
想象编写软件，

1536
01:17:01,060 --> 01:17:03,476
特别是因为有
常光有这些天，

1537
01:17:03,476 --> 01:17:07,400
我可以想像那里是
软件可以查询器

1538
01:17:07,400 --> 01:17:10,634
或什么不是，你在公园里，有
你的驱动器，你在相反。

1539
01:17:10,634 --> 01:17:12,550
我可以回去了
回答是肯定的任

1540
01:17:12,550 --> 01:17:14,400
或无来者的题型。

1541
01:17:14,400 --> 01:17:17,630
>> 所以，我也大概可以回答
一个问题一样，是引擎盖打开。

1542
01:17:17,630 --> 01:17:21,860
也许，有一些类型的传感器
要么给我回1或0，

1543
01:17:21,860 --> 01:17:23,720
真的还是假的，发动机罩打开。

1544
01:17:23,720 --> 01:17:28,180
然后车跑，我可以检测
通过什么样的机制，不知何故？

1545
01:17:28,180 --> 01:17:30,430
一样，汽车运行过程中，我
可以检测到它的上，

1546
01:17:30,430 --> 01:17:32,127
我能以某种方式检测
该汽车在行驶？

1547
01:17:32,127 --> 01:17:32,881
>> 听众：RPM包。

1548
01:17:32,881 --> 01:17:35,190
>> DAVID MALAN：是啊，所以有
总是那针

1549
01:17:35,190 --> 01:17:38,034
告诉你每多少转
分钟的车轮正在经历。

1550
01:17:38,034 --> 01:17:39,200
因此，我可以看看那个。

1551
01:17:39,200 --> 01:17:43,090
如果它不是0，这可能
是指汽车在行驶。

1552
01:17:43,090 --> 01:17:45,400
但是，我们必须是一个
稍微细心那里，

1553
01:17:45,400 --> 01:17:49,780
因为 - 让我们简化this--
如果我们只是说，如果车跑，

1554
01:17:49,780 --> 01:17:53,070
我们不希望只是减少排放，
我们想，如果汽车运行

1555
01:17:53,070 --> 01:17:54,310
和它的被测试。

1556
01:17:54,310 --> 01:17:56,320
>> 所以有一些其他
成分，乡亲

1557
01:17:56,320 --> 01:18:00,550
已经假设该软件是干什么的，
由于缺少实际的源代码，

1558
01:18:00,550 --> 01:18:05,130
您可以从只有几分推断
汽车的物理效应，以什么

1559
01:18:05,130 --> 01:18:08,280
可能是下面怎么回事
罩中的软件。

1560
01:18:08,280 --> 01:18:17,090
所以，如果车跑，也许，
比如说，后轮不动，

1561
01:18:17,090 --> 01:18:19,420
这可能预示
的一种考验？

1562
01:18:19,420 --> 01:18:22,830
我究竟在暗示这里？

1563
01:18:22,830 --> 01:18:24,830
是的，也许，这是在一个
这些辊的事情，

1564
01:18:24,830 --> 01:18:28,340
其中类似的车轮转向
在前面或在后面，

1565
01:18:28,340 --> 01:18:32,570
取决于它是否是前轮或
后轮驱动，所以一半的轮子

1566
01:18:32,570 --> 01:18:34,420
是移动的，但该
另外两个都没有，这

1567
01:18:34,420 --> 01:18:36,320
是在现实世界中一个奇怪的局面。

1568
01:18:36,320 --> 01:18:38,110
如果你开车在
道路，这是不应该的。

1569
01:18:38,110 --> 01:18:40,568
但如果你是在一个仓库
对某种辊系统，

1570
01:18:40,568 --> 01:18:41,630
确实可能发生。

1571
01:18:41,630 --> 01:18:46,980
>> 我认为，人们还提出，也许，
如果汽车是运行和转向

1572
01:18:46,980 --> 01:18:51,300
没有秒针轮动，即
太可能是一个信号，

1573
01:18:51,300 --> 01:18:54,090
因为这是合理的
就像道路上的通俗易懂。

1574
01:18:54,090 --> 01:18:57,960
但即便如此，人类可能是
移动一点点或肯定

1575
01:18:57,960 --> 01:18:59,100
超过几秒钟。

1576
01:18:59,100 --> 01:19:01,030
或一过程
分钟，赔率是它不

1577
01:19:01,030 --> 01:19:03,510
要在对被固定
完全相同的位置。

1578
01:19:03,510 --> 01:19:05,440
>> 因此，换句话说，我们
可以采取减法，

1579
01:19:05,440 --> 01:19:08,200
你正在测试，
打破这个功能

1580
01:19:08,200 --> 01:19:10,420
到这些部件的成分。

1581
01:19:10,420 --> 01:19:13,440
这就是真正的大众汽车什么的
工程师在某种程度上做到了。

1582
01:19:13,440 --> 01:19:17,070
他们编写软件自觉地
检测汽车是否正在测试中，

1583
01:19:17,070 --> 01:19:20,440
因此，减少排放，否则
发射在通常的方式。

1584
01:19:20,440 --> 01:19:22,690
>> 这里的问题也是如此，
是，软件不是

1585
01:19:22,690 --> 01:19:26,080
是你真的可以看到，除非
有所谓的源代码。

1586
01:19:26,080 --> 01:19:29,060
因此，有两种不同类型的
代码 - 至少两种不同类型的

1587
01:19:29,060 --> 01:19:30,130
在世界上的代码。

1588
01:19:30,130 --> 01:19:33,150
有一种叫做源
码，这是不不像

1589
01:19:33,150 --> 01:19:37,240
我们一直在写，源代码。

1590
01:19:37,240 --> 01:19:40,099
>> 这是源代码写在
一个叫伪语言，

1591
01:19:40,099 --> 01:19:41,640
这只是一些英语等。

1592
01:19:41,640 --> 01:19:43,140
还有就是它没有正式的定义。

1593
01:19:43,140 --> 01:19:46,770
但是，C，以及Java，C ++，这些
都是正规的语言说，

1594
01:19:46,770 --> 01:19:50,610
当你在写他们，你有什么
是包含源代码的文本文件。

1595
01:19:50,610 --> 01:19:54,850
>> 但也有一些在
世界称为机器代码。

1596
01:19:54,850 --> 01:20:00,579
和机器代码，不幸的是，
仅有0和1的。

1597
01:20:00,579 --> 01:20:02,870
所以机代码是什么
机器理解，当然。

1598
01:20:02,870 --> 01:20:04,470
源代码是什么人懂。

1599
01:20:04,470 --> 01:20:08,390
>> 一般，但不
总是有一个节目

1600
01:20:08,390 --> 01:20:14,090
一个程序员使用了采用源
代码并把它变成机器代码。

1601
01:20:14,090 --> 01:20:17,400
而这程序
一般被称为编译器。

1602
01:20:17,400 --> 01:20:19,820
所以，你的输入源代码，
你的输出是机器代码，

1603
01:20:19,820 --> 01:20:22,890
而编译器是一块
软件，做这一进程。

1604
01:20:22,890 --> 01:20:26,260
所以实际上很好地映射到
我们的投入，算法的输出。

1605
01:20:26,260 --> 01:20:30,400
>> 但是，这是一个非常具体的化身
的这一点，这是说，

1606
01:20:30,400 --> 01:20:34,200
即使你拥有大众汽车的一个
汽车就是犯了这一点，

1607
01:20:34,200 --> 01:20:38,390
它不喜欢你可以打开
罩或打开的用户手册或者查看

1608
01:20:38,390 --> 01:20:42,690
在源代码，因为由时间
到达您的车停在你的车道，

1609
01:20:42,690 --> 01:20:45,580
它已经被
转换成0和1的。

1610
01:20:45,580 --> 01:20:51,310
而且它是很辛苦的，不是不可能的，
但很难收集很多的事情

1611
01:20:51,310 --> 01:20:53,710
从刚刚在看
底层0和1的。

1612
01:20:53,710 --> 01:20:57,150
所以，你自己看着办吧，最终，如果
您了解机器operates--

1613
01:20:57,150 --> 01:20:59,870
英特尔inside--如果你了解
英特尔架构，

1614
01:20:59,870 --> 01:21:01,440
但它是非常耗时。

1615
01:21:01,440 --> 01:21:05,010
而即使在那里，你可能
无法看到的一切

1616
01:21:05,010 --> 01:21:08,220
该代码可以做。

1617
01:21:08,220 --> 01:21:12,521
>> 这个或任何疑问
样的过程更普遍？

1618
01:21:12,521 --> 01:21:15,134

1619
01:21:15,134 --> 01:21:18,300
而实际上，我们可以配合这个讨论
苹果昨天的讨论。

1620
01:21:18,300 --> 01:21:22,500
这也就是为什么联邦调查局不能只
去看看在犯罪嫌疑人的手机

1621
01:21:22,500 --> 01:21:26,820
找到的代码行，为
例如，使密码

1622
01:21:26,820 --> 01:21:28,940
或启用，80毫秒的延迟。

1623
01:21:28,940 --> 01:21:31,630
因为到那时它的
在老乡的iPhone，

1624
01:21:31,630 --> 01:21:34,975
它已经被
转换为0和1的。

1625
01:21:34,975 --> 01:21:38,015

1626
01:21:38,015 --> 01:21:40,820
>> 好吧，让我们暂停这里为我们
看看计算思维。

1627
01:21:40,820 --> 01:21:42,320
我们为什么不采取有15分钟的休息时间。

1628
01:21:42,320 --> 01:21:44,130
而当我们回来，我们将
看看编程

1629
01:21:44,130 --> 01:21:46,550
本身并开始绘制一些
这些高层次的概念

1630
01:21:46,550 --> 01:21:49,780
一个实际的，如果俏皮，
编程语言。

1631
01:21:49,780 --> 01:21:51,089