1
00:00:00,000 --> 00:00:01,291
>> DAVID J. MALAN：所以我们又回来了。

2
00:00:01,291 --> 00:00:03,050
这样的高级别
此刻的话题，现在

3
00:00:03,050 --> 00:00:06,440
是技术堆栈，这是不
一个特别的技术术语，

4
00:00:06,440 --> 00:00:09,960
它更多的是捕获所有的任何
技术的组合数

5
00:00:09,960 --> 00:00:11,840
你可以使用来解决问题。

6
00:00:11,840 --> 00:00:14,850
也许是最
合适的方式来启动

7
00:00:14,850 --> 00:00:18,110
会看，因为语言
我一直剑拔弩张了一大堆

8
00:00:18,110 --> 00:00:21,000
和大多数人在房间里有
可能听说过的至少一种。

9
00:00:21,000 --> 00:00:25,730
>> 所以我们为什么不尝试区分
what--区分这些语言

10
00:00:25,730 --> 00:00:28,932
并简要谈谈你们什么时候
选择一个比其他，他们是怎么样

11
00:00:28,932 --> 00:00:30,890
诸如此类的根本
不同，特别是

12
00:00:30,890 --> 00:00:34,830
当你与工程师聊天，
或试图决定谁聘用，

13
00:00:34,830 --> 00:00:37,652
或者执行什么
建议绿灯，

14
00:00:37,652 --> 00:00:39,860
你将如何实际上使
这些类型的决定。

15
00:00:39,860 --> 00:00:41,890
>> 所以我们就滔滔不绝一些事情了。

16
00:00:41,890 --> 00:00:45,300
语言的人有
听说过，想到什么？

17
00:00:45,300 --> 00:00:48,030
C.确定。

18
00:00:48,030 --> 00:00:48,757
OK，C ++。

19
00:00:48,757 --> 00:00:51,400

20
00:00:51,400 --> 00:00:51,990
那是什么？

21
00:00:51,990 --> 00:00:52,390
>> 听众：Python的。

22
00:00:52,390 --> 00:00:53,348
>> DAVID J. MALAN：Python的。

23
00:00:53,348 --> 00:00:55,330
优秀。

24
00:00:55,330 --> 00:00:57,000
还有什么？

25
00:00:57,000 --> 00:00:58,810
Visual Basic中。

26
00:00:58,810 --> 00:01:01,100
我听说的Java。

27
00:01:01,100 --> 00:01:02,610
视觉Basic--又名

28
00:01:02,610 --> 00:01:03,150
VB。

29
00:01:03,150 --> 00:01:03,650
Java的。

30
00:01:03,650 --> 00:01:07,294

31
00:01:07,294 --> 00:01:12,810
.NET，这更是一个捕获所有
对于平时有什么C＃作为语言

32
00:01:12,810 --> 00:01:13,770
有问题。

33
00:01:13,770 --> 00:01:14,770
让我提及。

34
00:01:14,770 --> 00:01:15,900
因此，我们会回来这一点。

35
00:01:15,900 --> 00:01:17,560
对不起？

36
00:01:17,560 --> 00:01:18,170
抱歉？

37
00:01:18,170 --> 00:01:19,877
>> 听众：SQL。

38
00:01:19,877 --> 00:01:20,876
DAVID J. MALAN：划痕？

39
00:01:20,876 --> 00:01:21,610
听众：SQL。

40
00:01:21,610 --> 00:01:22,610
DAVID J. MALAN：哦，SQL。

41
00:01:22,610 --> 00:01:23,110
好。

42
00:01:23,110 --> 00:01:23,750
SQL。

43
00:01:23,750 --> 00:01:29,510
因此，我们会回来的居然that--，
这是突破后good--为好。

44
00:01:29,510 --> 00:01:30,572
还有什么？

45
00:01:30,572 --> 00:01:32,530
>> 听众：甲骨文。

46
00:01:32,530 --> 00:01:34,670
>> DAVID J. MALAN：所以
甲骨文，不是一种语言。

47
00:01:34,670 --> 00:01:36,560
其实，他们将使用SQL为好。

48
00:01:36,560 --> 00:01:38,360
因此，让我们把那个后
休息为好。

49
00:01:38,360 --> 00:01:39,744
很遗憾，这里有什么事？

50
00:01:39,744 --> 00:01:40,660
听众：数学。

51
00:01:40,660 --> 00:01:41,390
DAVID J. MALAN：数学？

52
00:01:41,390 --> 00:01:42,303
可以，当然。

53
00:01:42,303 --> 00:01:46,150

54
00:01:46,150 --> 00:01:49,180
和MATLAB是一种
在那里的时候。

55
00:01:49,180 --> 00:01:50,060
>> 听众：R.

56
00:01:50,060 --> 00:01:51,755
>> DAVID J. MALAN：R.让我们在这里。

57
00:01:51,755 --> 00:01:54,710

58
00:01:54,710 --> 00:01:55,210
Fortran语言。

59
00:01:55,210 --> 00:01:55,880
当然。

60
00:01:55,880 --> 00:01:57,910
较早的学校。

61
00:01:57,910 --> 00:01:59,390
Fortran语言。

62
00:01:59,390 --> 00:02:01,550
COBOL。

63
00:02:01,550 --> 00:02:02,410
我就折腾了BASIC。

64
00:02:02,410 --> 00:02:05,990

65
00:02:05,990 --> 00:02:08,539
BASIC。

66
00:02:08,539 --> 00:02:09,390
任何 - 

67
00:02:09,390 --> 00:02:10,352
>> 听众：MATLAB？

68
00:02:10,352 --> 00:02:11,310
DAVID J. MALAN：MATLAB。

69
00:02:11,310 --> 00:02:12,248
呵呵，打你给它。

70
00:02:12,248 --> 00:02:15,370

71
00:02:15,370 --> 00:02:15,870
什么？

72
00:02:15,870 --> 00:02:18,700
我能想到的一对夫妇别人的。

73
00:02:18,700 --> 00:02:21,876
我能想到的其他几个人的。

74
00:02:21,876 --> 00:02:22,792
什么是最后？

75
00:02:22,792 --> 00:02:23,970
>> 听众：ASP。

76
00:02:23,970 --> 00:02:25,030
>> DAVID J. MALAN：ASP？

77
00:02:25,030 --> 00:02:26,100
是啊。

78
00:02:26,100 --> 00:02:27,100
活动服务器网页。

79
00:02:27,100 --> 00:02:30,270
这通常会落在下
其他语言，有时是C＃，

80
00:02:30,270 --> 00:02:32,040
让我们留给了。

81
00:02:32,040 --> 00:02:35,510
但是，我们会回来给
对于框架和这样的。

82
00:02:35,510 --> 00:02:36,290
还要别的吗？

83
00:02:36,290 --> 00:02:39,020
PHP是受欢迎的。

84
00:02:39,020 --> 00:02:41,710
Ruby是另一回事。

85
00:02:41,710 --> 00:02:48,230
JavaScript，以便不混淆
与Java，是另一回事。

86
00:02:48,230 --> 00:02:49,570
这是怎样的一个地段。

87
00:02:49,570 --> 00:02:53,590
>> 所以可以肯定铺天盖地，
如如果列表尚未，

88
00:02:53,590 --> 00:02:55,650
刚开始知道你在哪里开始。

89
00:02:55,650 --> 00:02:58,130
所以幸运的是，我们
从几个角度接近这一点。

90
00:02:58,130 --> 00:03:03,520
首先，让我们尝试分类
至少有一些语言

91
00:03:03,520 --> 00:03:06,790
分为两大桶，让人联想到的
我们打​​破之前的谈话中，

92
00:03:06,790 --> 00:03:09,630
在这里我们谈到了编译，
和源代码和机器代码，

93
00:03:09,630 --> 00:03:11,440
因为这不是如何
所有的语言。

94
00:03:11,440 --> 00:03:15,640
因此，我们将挖出的几个例子of--
或反examples--该模型。

95
00:03:15,640 --> 00:03:18,490
>> 然后，我们为什么不
谈谈应用程序

96
00:03:18,490 --> 00:03:20,390
这些语言
一般用于。

97
00:03:20,390 --> 00:03:22,840
坦率地说，即使
这是一个相当长的名单，

98
00:03:22,840 --> 00:03:26,320
这只是该列表的一个子集
您通常会从这些天画

99
00:03:26,320 --> 00:03:27,220
解决问题。

100
00:03:27,220 --> 00:03:29,150
某些语言比其他更新。

101
00:03:29,150 --> 00:03:31,170
某些语言
比其他人更受欢迎。

102
00:03:31,170 --> 00:03:34,370
所以它不喜欢你有这样的
在你面前一项艰巨的任务

103
00:03:34,370 --> 00:03:36,970
中决定何时
这些不同的语言。

104
00:03:36,970 --> 00:03:40,110
>> 因此，让我们做到这一点。

105
00:03:40,110 --> 00:03:45,870
我们之前，源代码，
然后我们有机器代码。

106
00:03:45,870 --> 00:03:48,590

107
00:03:48,590 --> 00:03:49,400
哎呦。

108
00:03:49,400 --> 00:03:50,910
写打错字。

109
00:03:50,910 --> 00:03:52,740
机器代码。

110
00:03:52,740 --> 00:03:57,549
我们曾在一些工艺
中间called--是啊，编译器。

111
00:03:57,549 --> 00:03:58,215
所以编译器。

112
00:03:58,215 --> 00:04:00,760

113
00:04:00,760 --> 00:04:03,910
>> 什么机器代码
实际上到底运行在

114
00:04:03,910 --> 00:04:05,680
将是你实际的CPU。

115
00:04:05,680 --> 00:04:09,660
换句话说，由机器码，我
平均最低级别的指令

116
00:04:09,660 --> 00:04:11,330
一个CPU实际上理解。

117
00:04:11,330 --> 00:04:15,100
加法，减法，移动，
保存和类似的操作。

118
00:04:15,100 --> 00:04:19,700
所以，这是什么模型
一般被称为编译语言。

119
00:04:19,700 --> 00:04:21,000
这也许并不奇怪。

120
00:04:21,000 --> 00:04:23,550
>> 因此，这是模型
对于编译语言。

121
00:04:23,550 --> 00:04:25,970
但事实证明，那里的
另一个类的语言

122
00:04:25,970 --> 00:04:32,650
所谓的解释languages​​--
解释languages​​--

123
00:04:32,650 --> 00:04:34,030
是稍微不同的。

124
00:04:34,030 --> 00:04:41,660
你写的源代码，运行
他们通过翻译，

125
00:04:41,660 --> 00:04:45,440
而解释器
什么在CPU上运行。

126
00:04:45,440 --> 00:04:50,120
换句话说，你做了什么不
EMIT是什么，很明显？

127
00:04:50,120 --> 00:04:50,980
机器代码。

128
00:04:50,980 --> 00:04:54,290
在CPU的零和一
最终自己明白。

129
00:04:54,290 --> 00:04:59,780
>> 因此，在这个第一版本和
如C语言，就像我们看到的，

130
00:04:59,780 --> 00:05:02,040
你在源代码中写
这是一个有点神秘，

131
00:05:02,040 --> 00:05:05,300
但至少它是一种类似英语的
和它的至少可读

132
00:05:05,300 --> 00:05:06,780
一旦你习惯了它。

133
00:05:06,780 --> 00:05:10,100
您可以通过一个编译器和跑得过它
你得到的，最终，零和的。

134
00:05:10,100 --> 00:05:11,340
>> 这种过于简单化。

135
00:05:11,340 --> 00:05:12,839
还有在有其他步骤。

136
00:05:12,839 --> 00:05:15,530
事实上，如果你曾经听说过
术语“汇编语言”

137
00:05:15,530 --> 00:05:17,990
这是前一步
在零和一。

138
00:05:17,990 --> 00:05:20,949
这一点更可读，
但仍然相当神秘。

139
00:05:20,949 --> 00:05:23,740
所以有中间步骤
这是，事实上，这里发生了。

140
00:05:23,740 --> 00:05:26,360
但输出，最终
是这些零和一。

141
00:05:26,360 --> 00:05:28,990
>> 但在解释
世界，在这里你有

142
00:05:28,990 --> 00:05:32,680
这是解释型语言
语言，你居然跳过这一步。

143
00:05:32,680 --> 00:05:36,010
换句话说，当你写一个
程序，您只需立即运行。

144
00:05:36,010 --> 00:05:38,960
你不编译它
然后运行它，就像我以前那样。

145
00:05:38,960 --> 00:05:41,132
你只写并运行它。

146
00:05:41,132 --> 00:05:44,340
如果你想快速的变化，
你做一个快速变化和重新运行它。

147
00:05:44,340 --> 00:05:46,640
所以这里没有中间的一步。

148
00:05:46,640 --> 00:05:50,840
>> 现在，该计划我之前写的，
这是这个“Hello World”程序，

149
00:05:50,840 --> 00:05:53,660
你很可能会
wonder--或可合理

150
00:05:53,660 --> 00:05:58,570
state--这不是那个时候
耗时编译我的程序。

151
00:05:58,570 --> 00:06:00,337
它似乎已经做到了就这样。

152
00:06:00,337 --> 00:06:02,170
还有的图形
编译器版本。

153
00:06:02,170 --> 00:06:05,270
我使用的是一个非常神秘的版本，
但你可以打一个播放按钮

154
00:06:05,270 --> 00:06:07,887
这将真正做到
编辑为您服务。

155
00:06:07,887 --> 00:06:10,720
我编译的程序，然后
再次，运行它，我只是做到这一点。

156
00:06:10,720 --> 00:06:13,820
它在左边输出那里，“你好！”

157
00:06:13,820 --> 00:06:15,530
这似乎并没有那么繁重。

158
00:06:15,530 --> 00:06:19,920
但是，当你的程序
不仅仅是一个，两个，三个，

159
00:06:19,920 --> 00:06:25,470
四，五线较长，可以
采取更为秒编译。

160
00:06:25,470 --> 00:06:28,310
有时甚至分钟
相当多的时间进行编译。

161
00:06:28,310 --> 00:06:30,480
毕竟，一些
世界上最大的产品

162
00:06:30,480 --> 00:06:35,040
事情像操作系统，
微软的Word，Microsoft Excel中，

163
00:06:35,040 --> 00:06:39,070
这可能是数以十万计
甚至上百万的长行的代码，

164
00:06:39,070 --> 00:06:41,300
而那些不只是
立即执行。

165
00:06:41,300 --> 00:06:44,560
>> 此外，在网络上，它的
成为时尚使用

166
00:06:44,560 --> 00:06:47,600
简单理解的语言，
部分原因是因为你

167
00:06:47,600 --> 00:06:50,570
可以做出改变作为显影剂
然后就马上重装

168
00:06:50,570 --> 00:06:52,570
浏览器页面和
马上看到结果。

169
00:06:52,570 --> 00:06:56,160
等的HTML，而不是
一种编程语言，

170
00:06:56,160 --> 00:06:58,860
是的解释的语言。

171
00:06:58,860 --> 00:07:00,770
而我们昨天看到了同样的效果。

172
00:07:00,770 --> 00:07:04,070
你只需做后重新加载页面
在Cloud9的变化还有 -  voila--

173
00:07:04,070 --> 00:07:05,560
你看到一个新的结果。

174
00:07:05,560 --> 00:07:07,090
>> 那么，有什么区别吗？

175
00:07:07,090 --> 00:07:13,190
在HTML中，回想一下，我们不得不打开HTML，
开目，开题，紧密称号，

176
00:07:13,190 --> 00:07:15,250
接近头部，开身，等等。

177
00:07:15,250 --> 00:07:19,149
我们有所有这些标签，我们很
不多说了，告诉浏览器该怎么做。

178
00:07:19,149 --> 00:07:20,690
嘿浏览器，来了一个HTML页面。

179
00:07:20,690 --> 00:07:22,170
嘿浏览器，来这里的冠军。

180
00:07:22,170 --> 00:07:24,429
嘿浏览器，来了一些
文本应该大胆。

181
00:07:24,429 --> 00:07:25,720
然后你告诉相反。

182
00:07:25,720 --> 00:07:27,330
嘿浏览器，这是它
为粗体文字。

183
00:07:27,330 --> 00:07:28,830
嘿浏览器，这是它的身体。

184
00:07:28,830 --> 00:07:29,740
等等。

185
00:07:29,740 --> 00:07:31,130
>> 还等什么是浏览器？

186
00:07:31,130 --> 00:07:33,170
浏览器只是一个解释。

187
00:07:33,170 --> 00:07:36,090
这是一个程序，有人喜欢
微软或谷歌已经写的，

188
00:07:36,090 --> 00:07:39,160
他们的生活目的就是
读语言，被称为HTML，

189
00:07:39,160 --> 00:07:39,890
和解释。

190
00:07:39,890 --> 00:07:41,290
从上到下，从左到右。

191
00:07:41,290 --> 00:07:46,880
并随时浏览器看到开放
支架，标题，紧密支架，

192
00:07:46,880 --> 00:07:48,960
它应该是解释
为意，呵呵，那

193
00:07:48,960 --> 00:07:52,490
意味着我应该把这些词的方式
这里在浏览器的顶部。

194
00:07:52,490 --> 00:07:55,700
>> 因此，它只是做HTML代码的话。

195
00:07:55,700 --> 00:07:57,240
但没有零和一。

196
00:07:57,240 --> 00:07:58,250
有没有编译。

197
00:07:58,250 --> 00:07:58,890
你没有做到这一点。

198
00:07:58,890 --> 00:07:59,931
浏览器并没有这样做。

199
00:07:59,931 --> 00:08:01,710
它只是没有涉及。

200
00:08:01,710 --> 00:08:05,890
>> 因此，在这些持续的精神
话题，今天和昨天，

201
00:08:05,890 --> 00:08:08,400
这似乎是一个奇妙的功能。

202
00:08:08,400 --> 00:08:11,410
您保存代码，然后
只要运行它或解释。

203
00:08:11,410 --> 00:08:13,790
有没有中间步骤。

204
00:08:13,790 --> 00:08:15,690
当然，也存在着成本？

205
00:08:15,690 --> 00:08:16,810
不能全部上升空间。

206
00:08:16,810 --> 00:08:19,964
所以，可能是成本是什么？

207
00:08:19,964 --> 00:08:20,940
>> 听众：太空。

208
00:08:20,940 --> 00:08:22,370
>> DAVID J. MALAN：太空。

209
00:08:22,370 --> 00:08:23,370
所以，肯定。

210
00:08:23,370 --> 00:08:26,920
在编译的世界里，你有
不仅原始源代码，

211
00:08:26,920 --> 00:08:29,657
您还要创建和
然后大概节约

212
00:08:29,657 --> 00:08:31,740
本机代码 - 中
零和ones--，这就是

213
00:08:31,740 --> 00:08:33,870
得占用空间量。

214
00:08:33,870 --> 00:08:34,429
绝对。

215
00:08:34,429 --> 00:08:35,765
因此它花费你更多的空间。

216
00:08:35,765 --> 00:08:39,289

217
00:08:39,289 --> 00:08:39,789
是吗？

218
00:08:39,789 --> 00:08:43,280
>> 听众：浏览器可能
不同的解释。

219
00:08:43,280 --> 00:08:46,770
>> DAVID J. MALAN：浏览器可能
不同的解释。

220
00:08:46,770 --> 00:08:48,622
那是真实的。

221
00:08:48,622 --> 00:08:50,330
但我不相信我
自称舒适

222
00:08:50,330 --> 00:08:51,840
这是因为它的解释。

223
00:08:51,840 --> 00:08:56,340
这更多的只是因为它是
一语言的实现

224
00:08:56,340 --> 00:08:58,050
这本身就具有模糊性。

225
00:08:58,050 --> 00:09:01,570
因此，让我们不是很确定
那一个，但好的预感。

226
00:09:01,570 --> 00:09:03,103
还有什么可能付出的代价？

227
00:09:03,103 --> 00:09:03,602
安德鲁？

228
00:09:03,602 --> 00:09:05,912
>> 听众：你结合
两个步骤，让你因此

229
00:09:05,912 --> 00:09:08,300
有越来越多的复杂性，以及。

230
00:09:08,300 --> 00:09:11,040
>> DAVID J. MALAN：本complex--
增加的复杂性在哪里？

231
00:09:11,040 --> 00:09:12,270
为了谁？

232
00:09:12,270 --> 00:09:16,748
>> 听众：所以，在解释
一步，你相结合的解释

233
00:09:16,748 --> 00:09:19,120
和编译器只是领先了中场休息

234
00:09:19,120 --> 00:09:21,100
>> DAVID J. MALAN：啊，OK。

235
00:09:21,100 --> 00:09:25,240
讽刺的是，它可能是一个小
容易实现的解释，

236
00:09:25,240 --> 00:09:29,530
即使它似乎
这种便利的收益率上升空间。

237
00:09:29,530 --> 00:09:30,550
所以可能如此。

238
00:09:30,550 --> 00:09:32,716
但是，那种依赖，我
会说的语言

239
00:09:32,716 --> 00:09:35,720
以及他们如何去
其实现。

240
00:09:35,720 --> 00:09:38,535
可以有很多的复杂性，
实际上，在编译，

241
00:09:38,535 --> 00:09:41,410
只是因为你有从去
东西这么高层次的东西

242
00:09:41,410 --> 00:09:42,560
如此低的水平。

243
00:09:42,560 --> 00:09:45,340
但是，一个好的想法。

244
00:09:45,340 --> 00:09:50,770
>> 所以换句话说，已编译的程序，
当变成这些0和1

245
00:09:50,770 --> 00:09:54,470
在语言结束
在CPU讲，

246
00:09:54,470 --> 00:09:57,850
而在的这一边
世界上，程序，你已经写了，

247
00:09:57,850 --> 00:10:02,527
你的代码已经写了，从来没有真正
被转换成实际的语言

248
00:10:02,527 --> 00:10:03,360
计算机说话。

249
00:10:03,360 --> 00:10:04,190
在零和一。

250
00:10:04,190 --> 00:10:08,480
它停留在原来的，更加人性化
友好，更可读的语言。

251
00:10:08,480 --> 00:10:11,720
所以，可能是什么含义
还有，如果你不实际

252
00:10:11,720 --> 00:10:15,020
打扰您的转换
计划到非常语言

253
00:10:15,020 --> 00:10:18,013
底层计算机说话？

254
00:10:18,013 --> 00:10:19,780
>> 听众：可能并非
明白了点什么？

255
00:10:19,780 --> 00:10:21,170
>> DAVID J. MALAN：可能
不明白的地方。

256
00:10:21,170 --> 00:10:23,297
而这可能claim--
如果不明白

257
00:10:23,297 --> 00:10:25,880
什么东西，这是一个错误或不足
的功能在解释器。

258
00:10:25,880 --> 00:10:28,544
因此，这将是多的
一个错误比成本。

259
00:10:28,544 --> 00:10:30,419
>> 听众：您可以访问
源代码？

260
00:10:30,419 --> 00:10:31,877
DAVID J. MALAN：有一个很好的一个。

261
00:10:31,877 --> 00:10:34,140
所以这里一个缺点就是你
似乎有访问。

262
00:10:34,140 --> 00:10:37,006
你的最终用户，可能看起来
存取源代码。

263
00:10:37,006 --> 00:10:38,130
而这并非总是如此。

264
00:10:38,130 --> 00:10:39,660
但它是在真
JavaScript的情况下，

265
00:10:39,660 --> 00:10:41,660
我们将着眼于后
破发的今天，这

266
00:10:41,660 --> 00:10:45,720
是一种解释型的编程语言
您在源代码中编写。

267
00:10:45,720 --> 00:10:48,890
>> 但是，源代码被转移
从服务器到浏览器

268
00:10:48,890 --> 00:10:51,392
并运行在人的浏览器。

269
00:10:51,392 --> 00:10:54,350
所以在这里，她可以只打开
窗口，就像我在Chrome一直在做，

270
00:10:54,350 --> 00:10:57,740
看看它，因为我们自己
瞥了一眼昨天与谷歌。

271
00:10:57,740 --> 00:11:00,420
它看起来有点
不可理解的，但它的存在。

272
00:11:00,420 --> 00:11:03,482
所以，这绝对是一个价格支付。

273
00:11:03,482 --> 00:11:04,565
听众：性能损失？

274
00:11:04,565 --> 00:11:05,020
戴维·马兰：是的。

275
00:11:05,020 --> 00:11:06,260
而这正是其他大不了的。

276
00:11:06,260 --> 00:11:07,380
有一个性能命中。

277
00:11:07,380 --> 00:11:10,100
因为你有这
中间人，这本身

278
00:11:10,100 --> 00:11:13,740
是一个程序，你们之间
和CPU，而不是

279
00:11:13,740 --> 00:11:17,880
只喂这些原始
零和一到CPU，

280
00:11:17,880 --> 00:11:21,060
有一个性能命中，你
采取与解释型语言。

281
00:11:21,060 --> 00:11:24,240
这样，任意地，程序
这可能耗时1秒

282
00:11:24,240 --> 00:11:27,840
到一台计算机或一个在运行
分钟到这里的计算机上运行，

283
00:11:27,840 --> 00:11:32,059
可能需要10秒或10
分钟到这里的计算机上运行。

284
00:11:32,059 --> 00:11:35,100
它一般不会是
太大的difference--因素10--

285
00:11:35,100 --> 00:11:36,808
因为有
优化你可以做。

286
00:11:36,808 --> 00:11:38,680
但它几乎总是慢。

287
00:11:38,680 --> 00:11:43,070
现在，另一面这一关切
是这样的，还有电脑，每12

288
00:11:43,070 --> 00:11:45,970
18 months--根据
摩尔定律，所以speak--

289
00:11:45,970 --> 00:11:47,600
只是越来越快。

290
00:11:47,600 --> 00:11:48,750
我有越来越多的磁盘空间。

291
00:11:48,750 --> 00:11:49,791
我有越来越多的RAM。

292
00:11:49,791 --> 00:11:50,620
谁真正在乎呢？

293
00:11:50,620 --> 00:11:52,328
>> 而这类型的
合理的说法。

294
00:11:52,328 --> 00:11:55,740
实际上，的原因之一
为什么我们能容忍慢

295
00:11:55,740 --> 00:11:58,480
解释型语言，是因为
我们人类真的不注意到。

296
00:11:58,480 --> 00:12:00,690
该计算机有
刚刚得到织补这么快。

297
00:12:00,690 --> 00:12:04,520
而早在一天，尤其是
当硬件被更多的限制，

298
00:12:04,520 --> 00:12:06,860
你有较少的一切，
这是更昂贵的

299
00:12:06,860 --> 00:12:10,570
所以一切成本较高，以及再
你真的想要挤走

300
00:12:10,570 --> 00:12:12,590
尽可能多的性能，你可以。

301
00:12:12,590 --> 00:12:16,400
但是，这需要在编写
较低的水平，如果你愿意，

302
00:12:16,400 --> 00:12:18,090
用编译语言。

303
00:12:18,090 --> 00:12:20,830
>> 这样你就采取这种性能损失。

304
00:12:20,830 --> 00:12:24,780
但是总体来说，有利的一面
似乎是值得的，这些天。

305
00:12:24,780 --> 00:12:26,850
那么，除了
知识产权问题。

306
00:12:26,850 --> 00:12:28,641
那种可读性
代码中，我们将

307
00:12:28,641 --> 00:12:30,640
回来的时候，我们看的JavaScript。

308
00:12:30,640 --> 00:12:33,140
>> 所以，让我们尝试分类
至少其中的一些。

309
00:12:33,140 --> 00:12:41,650
因此，编译语言之中，我们
将有C，C ++，有点儿，八九不离十，爪哇，

310
00:12:41,650 --> 00:12:48,120
虽然这是一个有点异常，对于
原因我会告诉你在短短的时刻。

311
00:12:48,120 --> 00:12:51,540
C＃是这个名单上。

312
00:12:51,540 --> 00:12:54,930
我们将看到更多的只是在
更现代的语言。

313
00:12:54,930 --> 00:12:55,430
好吧。

314
00:12:55,430 --> 00:12:56,804
这似乎是很多在那里。

315
00:12:56,804 --> 00:13:03,500
而在栅栏的这一边，
可能我们的JavaScript和Python，

316
00:13:03,500 --> 00:13:08,040
和PHP和Ruby。

317
00:13:08,040 --> 00:13:13,640
并且是足够
更近的吗？

318
00:13:13,640 --> 00:13:15,410
那感觉就像很多现在。

319
00:13:15,410 --> 00:13:16,330
好。

320
00:13:16,330 --> 00:13:18,760
然后点点点，
因为名单是无止境的。

321
00:13:18,760 --> 00:13:22,300
>> 而事实上，如果我们只想
获得this--维基百科的感觉，

322
00:13:22,300 --> 00:13:24,130
编译语言。

323
00:13:24,130 --> 00:13:27,150
我猜我们可以得到一个
更为详尽的列表。

324
00:13:27,150 --> 00:13:27,910
所以在这里我们去。

325
00:13:27,910 --> 00:13:30,620
因此，这里是一个更详尽的清单。

326
00:13:30,620 --> 00:13:34,150
我希望有人猜ð
作为一种语言，因为，太多的存在，

327
00:13:34,150 --> 00:13:37,747
但他们停止为D这似乎。

328
00:13:37,747 --> 00:13:39,330
虽然有可能实际上是一个E.

329
00:13:39,330 --> 00:13:41,496
>> 呵呵，其实，这应该
在列表中的这些日子。

330
00:13:41,496 --> 00:13:47,460
斯威夫特居然是
语言，苹果发明

331
00:13:47,460 --> 00:13:50,302
即现在使用，越来越
因此，在iPhone开发。

332
00:13:50,302 --> 00:13:52,260
但是，我们会回来的
随着我们的讨论

333
00:13:52,260 --> 00:13:54,090
在短短的一点点移动为好。

334
00:13:54,090 --> 00:13:55,260
如此迅速也是如此。

335
00:13:55,260 --> 00:13:57,540
>> 然后，如果我们去
解释language--

336
00:13:57,540 --> 00:14:05,010
解释language--那么这里
甚至更长的名单也是如此。

337
00:14:05,010 --> 00:14:07,260
所以，如果你只是谷歌和
看看维基百科上对于这些，

338
00:14:07,260 --> 00:14:09,231
你会看到各种各样的语言。

339
00:14:09,231 --> 00:14:10,980
但是其目的是，
今天真的，只是

340
00:14:10,980 --> 00:14:13,680
归结起来，也许这
知识产权问题

341
00:14:13,680 --> 00:14:18,200
性和可读性由最终用户和
性能，是另一个大问题为好。

342
00:14:18,200 --> 00:14:21,080
>> 因此，这些语言中，
让我看看，如果我们可以给你

343
00:14:21,080 --> 00:14:24,487
只是语言的一些示例。

344
00:14:24,487 --> 00:14:26,820
我们不想去通过
所有语言不休。

345
00:14:26,820 --> 00:14:29,720
你有没有想过什么
某些语言样子？

346
00:14:29,720 --> 00:14:31,562
我们确实看到了刚才。

347
00:14:31,562 --> 00:14:33,520
我们为什么不拿一对夫妇
的功能要求。

348
00:14:33,520 --> 00:14:35,380
谁愿意看什么
其他语言的样子？

349
00:14:35,380 --> 00:14:35,620
是啊。

350
00:14:35,620 --> 00:14:36,150
>> 听众：Java的。

351
00:14:36,150 --> 00:14:36,540
>> DAVID J. MALAN：Java的。

352
00:14:36,540 --> 00:14:37,040
好吧。

353
00:14:37,040 --> 00:14:38,504
所以，让我们去渣。

354
00:14:38,504 --> 00:14:42,300

355
00:14:42,300 --> 00:14:44,900
而只是给你一个sample--
我们可以写这些了，

356
00:14:44,900 --> 00:14:47,670
但它会更快只是
看着别人的示例代码。

357
00:14:47,670 --> 00:14:48,170
好吧。

358
00:14:48,170 --> 00:14:50,330
所以这是一个很好的例子吗？

359
00:14:50,330 --> 00:14:52,040
哎呦。

360
00:14:52,040 --> 00:14:52,540
好。

361
00:14:52,540 --> 00:14:58,810
因此，这里是的Java版本
节目我之前写的，的“Hello World”。

362
00:14:58,810 --> 00:15:01,900
>> 所以Java中，你经常会
看到关键字“类”。

363
00:15:01,900 --> 00:15:03,779
然后你就会看到后，一些名字。

364
00:15:03,779 --> 00:15:05,570
你会看到大括号
像我们以前看到的，

365
00:15:05,570 --> 00:15:08,153
有时他们去了
同一行，有时其他线路，

366
00:15:08,153 --> 00:15:09,734
它是一种个人的决定。

367
00:15:09,734 --> 00:15:11,900
你会看到类似于关键字
“公”，“静”，“无效”。

368
00:15:11,900 --> 00:15:13,790
但是，我们也看到“主”。
“主”一般

369
00:15:13,790 --> 00:15:17,220
缺省功能的名称
或代码的默认存储块，它

370
00:15:17,220 --> 00:15:18,760
获取程序运行。

371
00:15:18,760 --> 00:15:19,330
>> “串。”

372
00:15:19,330 --> 00:15:20,850
什么我们通过串前面是什么意思？

373
00:15:20,850 --> 00:15:23,480
我用它那种随随便便。

374
00:15:23,480 --> 00:15:25,100
字符串是什么？

375
00:15:25,100 --> 00:15:25,601
一个字。

376
00:15:25,601 --> 00:15:27,058
这就像一个字符序列。

377
00:15:27,058 --> 00:15:29,810
单个字符，回
背靠背，通常在一个数组，

378
00:15:29,810 --> 00:15:30,690
正如我们已经讨论过。

379
00:15:30,690 --> 00:15:34,700
而事实上，看到这个语法
这里，这两个方括号？

380
00:15:34,700 --> 00:15:39,210
这意味着，哎电脑，在这里
附带的字符串的数组。

381
00:15:39,210 --> 00:15:42,636
在方括号是
常用来表示。

382
00:15:42,636 --> 00:15:44,510
然后，你可能
采取什么guess--

383
00:15:44,510 --> 00:15:46,580
这也凸显
代码块可能吗？

384
00:15:46,580 --> 00:15:49,737

385
00:15:49,737 --> 00:15:50,639
>> 听众：输出？

386
00:15:50,639 --> 00:15:51,090
>> 戴维·马兰：是的。

387
00:15:51,090 --> 00:15:52,506
它打印一些东西到屏幕上。

388
00:15:52,506 --> 00:15:57,070
因此，“系统”是一种的
参考到您的计算机。

389
00:15:57,070 --> 00:15:59,620
“出”是指您的计算机
输出或屏幕。

390
00:15:59,620 --> 00:16:04,450
因此，“system.out.print LN”大概意思？

391
00:16:04,450 --> 00:16:05,570
“LN”。

392
00:16:05,570 --> 00:16:09,570
打印线，程序员喜欢
显然到一些拼写出单词

393
00:16:09,570 --> 00:16:11,820
以其整体并采取
快捷键与其他词。

394
00:16:11,820 --> 00:16:13,260
但是，“LN”为线，所以打印线。

395
00:16:13,260 --> 00:16:17,370
所以它打印出“你好
世界！“后跟一个新行。

396
00:16:17,370 --> 00:16:18,300
>> 所以这是它。

397
00:16:18,300 --> 00:16:21,150
但是，Java是什么，他们会
通话面向对象的。

398
00:16:21,150 --> 00:16:23,440
事实上，只给一
其他几个定义

399
00:16:23,440 --> 00:16:26,420
那里，你可能
看到，在一般情况下，有

400
00:16:26,420 --> 00:16:30,600
有许多不同类型的
语言文字，但最常见的

401
00:16:30,600 --> 00:16:37,830
是程序或命令式语言。

402
00:16:37,830 --> 00:16:41,600
有功能
语言，这不

403
00:16:41,600 --> 00:16:43,790
意味着别人都不起作用。

404
00:16:43,790 --> 00:16:47,740
然后还有
面向对象的语言。

405
00:16:47,740 --> 00:16:51,170
这也许是最好的
大多数语言的分类

406
00:16:51,170 --> 00:16:56,445
那你会不会选择排序
典型的商业项目。

407
00:16:56,445 --> 00:16:58,910
>> 这将是太多的，
我认为，老鼠的洞，

408
00:16:58,910 --> 00:17:01,620
往下走，尝试解释
不同的差异。

409
00:17:01,620 --> 00:17:04,599
但语言
我们已经看到了这样far--Ç

410
00:17:04,599 --> 00:17:07,680
是程序或
命令式语言。

411
00:17:07,680 --> 00:17:11,200
最近发明了
语言往往是，对不起，

412
00:17:11,200 --> 00:17:14,430
面向对象的，这意味着
他们有其他的功能给他们。

413
00:17:14,430 --> 00:17:18,130

414
00:17:18,130 --> 00:17:19,430
我可以解释它以这种方式？

415
00:17:19,430 --> 00:17:20,950
我们甚至没有去那里。

416
00:17:20,950 --> 00:17:25,200
>> 面向对象的方法
你可以implement--

417
00:17:25,200 --> 00:17:27,930
你可以模拟真实的世界
稍微更有效。

418
00:17:27,930 --> 00:17:29,722
人性化，随着时间的推移，
已经想通了，哇，

419
00:17:29,722 --> 00:17:32,430
这将是，如果我的语言不错
有这个功能或特性。

420
00:17:32,430 --> 00:17:34,830
这就是为什么我们有这么
许多语言在世界上。

421
00:17:34,830 --> 00:17:37,670
理智的人，聪明
人，同意或不同意

422
00:17:37,670 --> 00:17:41,000
和总是那种走到一起
开发新的语言都在一起。

423
00:17:41,000 --> 00:17:41,660
>> 典型的例子。

424
00:17:41,660 --> 00:17:45,260
苹果发明Swift在
想必希望降低

425
00:17:45,260 --> 00:17:47,950
酒吧到iPhone的发展，
因为以前language--

426
00:17:47,950 --> 00:17:51,080
所谓的Objective-C，这可能
也是我们榜单上这里 - 

427
00:17:51,080 --> 00:17:54,190
是更加神秘和多
更难回绕胸臆。

428
00:17:54,190 --> 00:17:57,690
而作为编程无疑成为
更方便和更广泛

429
00:17:57,690 --> 00:18:00,580
人们甚至通过
少技术，该goal--

430
00:18:00,580 --> 00:18:04,160
这是一个非常勇敢的目标尝试
通过降低准入门槛

431
00:18:04,160 --> 00:18:07,400
语言本身
容易上手，

432
00:18:07,400 --> 00:18:09,430
但同样强大的必然。

433
00:18:09,430 --> 00:18:10,560
>> 而另外一门语言。

434
00:18:10,560 --> 00:18:14,110
我们为什么不来看看
在类似的Python，

435
00:18:14,110 --> 00:18:18,090
这是非常流行的这些日子。

436
00:18:18,090 --> 00:18:19,570
蟒蛇。

437
00:18:19,570 --> 00:18:20,464
样本程序。

438
00:18:20,464 --> 00:18:24,600

439
00:18:24,600 --> 00:18:26,700
让我们来看看。

440
00:18:26,700 --> 00:18:28,790
“Hello World”的语言。

441
00:18:28,790 --> 00:18:30,180
我们开工吧。

442
00:18:30,180 --> 00:18:33,625
“你好，世界。”

443
00:18:33,625 --> 00:18:35,375
让我们看看这给
我们一个很好的例子。

444
00:18:35,375 --> 00:18:39,450

445
00:18:39,450 --> 00:18:39,950
好。

446
00:18:39,950 --> 00:18:41,283
所以，这其实是一种乐趣。

447
00:18:41,283 --> 00:18:43,330
所以，如果你曾经谷歌
的“Hello World”，这

448
00:18:43,330 --> 00:18:47,000
恰好是在第一方案中的一个
写过在现代语言，

449
00:18:47,000 --> 00:18:51,830
正如概念证明，你可以看到
种种此实现。

450
00:18:51,830 --> 00:18:54,240
>> 一些语言
我甚至没有听说过。

451
00:18:54,240 --> 00:18:59,770
但是你可以see--让我们去基础，
一个我多年前了解到，在部分。

452
00:18:59,770 --> 00:19:02,720
这是一个有趣的语言，因为你
不得不，作为编程，数

453
00:19:02,720 --> 00:19:03,710
所有的线。

454
00:19:03,710 --> 00:19:05,626
不是不像我是什么
当我在写做

455
00:19:05,626 --> 00:19:08,380
伪上的黄色文件
之前为二进制搜索，

456
00:19:08,380 --> 00:19:09,580
用于搜索电话簿。

457
00:19:09,580 --> 00:19:11,810
>> 所以，如果你想
去到另一行，

458
00:19:11,810 --> 00:19:15,780
你会从字面上键入，
到10，或者去20。

459
00:19:15,780 --> 00:19:19,110
如果你正在写的线条，
公约是做的，这是10号线，

460
00:19:19,110 --> 00:19:22,545
这是第20行，这是行
30，40，与没有在两者之间，

461
00:19:22,545 --> 00:19:25,170
从而给自己一些空间
如果你决定了，等一会儿，

462
00:19:25,170 --> 00:19:27,230
我应该补充一些
更多的代码的某个地方。

463
00:19:27,230 --> 00:19:30,960
你仍然有那种九个机会
挤在你的程序之间

464
00:19:30,960 --> 00:19:33,020
你不得不手动前
重新编排的一切。

465
00:19:33,020 --> 00:19:35,470
>> 因此，这是什么样的我的意思
当我说这个世界上来

466
00:19:35,470 --> 00:19:36,303
用一个新的功能。

467
00:19:36,303 --> 00:19:39,364
某处有人方式
实现的，这小子是愚蠢的。

468
00:19:39,364 --> 00:19:41,280
这仅仅是创建
为程序员工作。

469
00:19:41,280 --> 00:19:44,200
于是，他或她只是一种建
最重要的是一个新的图层

470
00:19:44,200 --> 00:19:46,910
这样你就不必担心
什么行号代码

471
00:19:46,910 --> 00:19:48,570
其实上。

472
00:19:48,570 --> 00:19:54,940
>> 你什么时候可以选择
一种语言或其他？

473
00:19:54,940 --> 00:19:56,690
那么，其中哪些
语言你倾向于

474
00:19:56,690 --> 00:20:00,960
听到的最
你自己的世界，这些天？

475
00:20:00,960 --> 00:20:02,680
让我们下拉的Objective-C了。

476
00:20:02,680 --> 00:20:06,416

477
00:20:06,416 --> 00:20:07,739
>> 听众：C＃。

478
00:20:07,739 --> 00:20:08,530
DAVID J. MALAN：C＃。

479
00:20:08,530 --> 00:20:10,310
因此，让我的颜色。

480
00:20:10,310 --> 00:20:13,190
难道我们有其他颜色的地方？

481
00:20:13,190 --> 00:20:14,550
因此，C＃。

482
00:20:14,550 --> 00:20:16,390
那么，你知道C＃？

483
00:20:16,390 --> 00:20:18,940
什么春天介意吗？

484
00:20:18,940 --> 00:20:20,707
>> 听众：这是一种编程语言。

485
00:20:20,707 --> 00:20:22,540
DAVID J. MALAN：这是一个
编程语言。

486
00:20:22,540 --> 00:20:23,200
好。

487
00:20:23,200 --> 00:20:24,690
那是真实的。

488
00:20:24,690 --> 00:20:26,440
因此，我们在谈论C＃。

489
00:20:26,440 --> 00:20:29,230
C＃趋于中所用
Windows环境中，

490
00:20:29,230 --> 00:20:33,550
所以，如果你正在写的微软软件
适用于Windows，C＃是很常用的，

491
00:20:33,550 --> 00:20:38,560
无论是桌面软件，或
在Windows手机甚至手机软件，

492
00:20:38,560 --> 00:20:41,820
如果你已经拥有了这些，
或在网络上甚至过于。

493
00:20:41,820 --> 00:20:44,642
而事实上，也许卡里姆
上述ASP早些时候？

494
00:20:44,642 --> 00:20:46,600
因此，有这些还
东西叫做框架，

495
00:20:46,600 --> 00:20:51,040
我们可以通过扩展引入。

496
00:20:51,040 --> 00:20:53,280
框架，如ASP。

497
00:20:53,280 --> 00:20:55,740
代表活动服务器网页。

498
00:20:55,740 --> 00:20:59,880
这是代码，
编程的一种方法

499
00:20:59,880 --> 00:21:03,490
其通常可以更容易
编写基于Web应用程序。

500
00:21:03,490 --> 00:21:07,530
换句话说，这将是超级，
超级讨厌写网站

501
00:21:07,530 --> 00:21:09,469
在C语言的
我们以前见过，

502
00:21:09,469 --> 00:21:12,510
因为你将不得不使用打印+ F，
你将不得不使用关键字

503
00:21:12,510 --> 00:21:13,940
“主”和大括号内。

504
00:21:13,940 --> 00:21:16,720
很多神秘的语法
和方法来实现

505
00:21:16,720 --> 00:21:19,195
东西是相当复杂的。

506
00:21:19,195 --> 00:21:20,240
一个网页。

507
00:21:20,240 --> 00:21:23,800
>> 等其他语言的演变
做出那种事情更容易。

508
00:21:23,800 --> 00:21:26,890
反过来，人们纷纷拿出
与框架，排序工具

509
00:21:26,890 --> 00:21:30,520
您可以使用，使它
更容易编写网页。

510
00:21:30,520 --> 00:21:33,070
因此，例如，为了使
这更具体，

511
00:21:33,070 --> 00:21:36,390
让我打开一个刚
一会儿文本文件。

512
00:21:36,390 --> 00:21:39,380
>> 你可能还记得昨天
我们说了些什么

513
00:21:39,380 --> 00:21:41,210
像，这是一个网页。

514
00:21:41,210 --> 00:21:42,300
HTML。

515
00:21:42,300 --> 00:21:45,340
关闭HTML。

516
00:21:45,340 --> 00:21:48,500
让我跳过头
只是做身体在这里。

517
00:21:48,500 --> 00:21:52,810
假设我想
不写的“Hello World”

518
00:21:52,810 --> 00:21:57,020
但“你好大卫，”大卫是
当前登录的用户的名称。

519
00:21:57,020 --> 00:22:00,270
什么样的东西
ASP会做，或JSP--

520
00:22:00,270 --> 00:22:04,060
这是Java服务器pages--或
任何数量的其他框架

521
00:22:04,060 --> 00:22:05,435
是他们没有语言本身。

522
00:22:05,435 --> 00:22:07,351
他们就像
额外的软件，您

523
00:22:07,351 --> 00:22:10,490
将其安装到您的环境
只是使其更易于编程。

524
00:22:10,490 --> 00:22:15,670
>> 因此，例如，而不是必须做
像“你好，的printf（”大卫“）”

525
00:22:15,670 --> 00:22:17,510
或东西是
一种共同mingling--

526
00:22:17,510 --> 00:22:20,840
什么样的代码中，我们已经看到before--
你会做一些简单得多，

527
00:22:20,840 --> 00:22:26,190
如“名字％。”

528
00:22:26,190 --> 00:22:28,660
所以这些框架，
像ASP--和我

529
00:22:28,660 --> 00:22:31,212
不记得，如果我得到
语法正好适合ASP。

530
00:22:31,212 --> 00:22:33,100
JSP是little--这是正确的？

531
00:22:33,100 --> 00:22:36,500
>> 因此，与ASP，这是
那种特殊的语法

532
00:22:36,500 --> 00:22:39,830
一些开发商已经决定
这可能帮助人们走出。

533
00:22:39,830 --> 00:22:43,000
我可以表达更简洁
占位符，例如。

534
00:22:43,000 --> 00:22:47,187
喜欢这里，这里放一个值
这个值的名字不是N-A-M-E，

535
00:22:47,187 --> 00:22:48,520
它存储在那里一定的价值。

536
00:22:48,520 --> 00:22:50,728
因此，“名称”，在这种情况下，
我们所说的变量。

537
00:22:50,728 --> 00:22:52,760
代数有变数
像x和y和z。

538
00:22:52,760 --> 00:22:56,021
程序员使用的是变量
比的x，y和z更具描述，

539
00:22:56,021 --> 00:22:56,520
典型。

540
00:22:56,520 --> 00:23:01,020
因此，“名”会从字面上是某种
对于像存储容器

541
00:23:01,020 --> 00:23:05,440
D-A-V-I-D，为我的名，或谁
其他人登录到该网站。

542
00:23:05,440 --> 00:23:09,300
>> 所以这是一种方便
你会得到一定的环境。

543
00:23:09,300 --> 00:23:14,220
因此，C＃和ASP一样的东西会很
在Windows世界通常被使用，

544
00:23:14,220 --> 00:23:16,460
无论是其台式机
软件或Web服务器，

545
00:23:16,460 --> 00:23:21,490
特别是如果你的服务器是反过来
运行Microsoft Windows和Microsoft

546
00:23:21,490 --> 00:23:25,810
IIS--或Internet Information
服务器，如果我得到的缩写right--

547
00:23:25,810 --> 00:23:27,800
这是微软的Web服务器。

548
00:23:27,800 --> 00:23:30,820
>> 那么，什么其他语言
熟悉的人，

549
00:23:30,820 --> 00:23:35,228
或者你听说过的
往往不是？

550
00:23:35,228 --> 00:23:38,262
>> 听众：我知道，Python的
一种流行的[听不清]的。

551
00:23:38,262 --> 00:23:39,470
戴维·马兰：非常受欢迎。

552
00:23:39,470 --> 00:23:45,490
因此，这里的Python很经常使用
科学应用程序或数据

553
00:23:45,490 --> 00:23:48,330
科学，在那里你有很多
数据要分析

554
00:23:48,330 --> 00:23:50,413
并且要使用
编程语言了。

555
00:23:50,413 --> 00:23:53,640
ř可能通常被用于
同时，在统计范围内。

556
00:23:53,640 --> 00:23:56,400
但是Python有这么多
内置的功能。

557
00:23:56,400 --> 00:23:58,850
因此，许多附加
库，人说。

558
00:23:58,850 --> 00:24:01,260
>> 图书馆是收藏品刚
代码的其他人

559
00:24:01,260 --> 00:24:04,218
写道，您可以使用，这样你
不必重新发明轮子的那些。

560
00:24:04,218 --> 00:24:07,430
所以Python是非常普遍
数据的科学应用。

561
00:24:07,430 --> 00:24:09,930
但它也很普遍
在Web应用程序中使用。

562
00:24:09,930 --> 00:24:12,780
您可以实现动态
网站使用Python。

563
00:24:12,780 --> 00:24:15,210
>> 并通过动态的网站，我
意味着不只是静态内容

564
00:24:15,210 --> 00:24:19,530
就像我们昨天创建，由
只是在拉丁文本硬编码

565
00:24:19,530 --> 00:24:21,820
等这样的事情，
而是能力

566
00:24:21,820 --> 00:24:25,367
登录，能够买
东西，能否退房

567
00:24:25,367 --> 00:24:26,950
与您购物车，或类似物。

568
00:24:26,950 --> 00:24:30,590
所有这些都需要活力和你
需要像其中的一个部分语言。

569
00:24:30,590 --> 00:24:35,060
>> 听众：这是否Python中有自己的
延伸，类似像[听不清]

570
00:24:35,060 --> 00:24:36,060
DAVID J. MALAN：它。

571
00:24:36,060 --> 00:24:42,250
所以在Python的世界里，Django是
一个非常流行的Python框架。

572
00:24:42,250 --> 00:24:46,520
WSGI是另一种机制，这是
排序从这个不同

573
00:24:46,520 --> 00:24:47,640
但在精神上相似。

574
00:24:47,640 --> 00:24:52,200
这是一个插件，可以让你
向在服务器上运行Python代码。

575
00:24:52,200 --> 00:24:53,950
有other--呀。

576
00:24:53,950 --> 00:24:57,250
因此，这些我们称之为框架。

577
00:24:57,250 --> 00:24:58,870
而且这是一个滥用的一点点。

578
00:24:58,870 --> 00:25:00,920
这更多的是一种Web服务器技术。

579
00:25:00,920 --> 00:25:04,610
但我们会保持它的简单，并把
它在此列仍然。

580
00:25:04,610 --> 00:25:05,780
>> 好。

581
00:25:05,780 --> 00:25:07,850
WSGI。

582
00:25:07,850 --> 00:25:09,020
WSGI。

583
00:25:09,020 --> 00:25:12,100
另一件事 - 实际上，让
我谨以自己的列，

584
00:25:12,100 --> 00:25:17,000
因为我将在自己喊
将它们放在同一个桶。

585
00:25:17,000 --> 00:25:24,910
让我们把这个变成服务器
的功能，让我们说。

586
00:25:24,910 --> 00:25:26,710
这不是一个技术术语。

587
00:25:26,710 --> 00:25:29,180
>> 所以在这里，我们可能会WSGI。

588
00:25:29,180 --> 00:25:32,580
有CGI，这是一个较旧的
技术服务了语言

589
00:25:32,580 --> 00:25:35,890
像Perl或PHP，或者其他人。

590
00:25:35,890 --> 00:25:39,000
再次，我已经提到这些条款
与其说是那种根深蒂固他们，

591
00:25:39,000 --> 00:25:40,749
但是，这样如果你看到
他们这件事情

592
00:25:40,749 --> 00:25:42,130
您只需谷歌阅读更多。

593
00:25:42,130 --> 00:25:46,110
有没有真正的果汁
对其中的一些东西。

594
00:25:46,110 --> 00:25:47,850
>> 但是，让我们回到语言。

595
00:25:47,850 --> 00:25:50,499
我们谈到了C＃，Python的。

596
00:25:50,499 --> 00:25:52,790
还有什么可能用于
Web编程可好？

597
00:25:52,790 --> 00:25:54,302
让我们关注仍然。

598
00:25:54,302 --> 00:25:55,247
>> 听众：PHP。

599
00:25:55,247 --> 00:25:56,080
DAVID J. MALAN：PHP。

600
00:25:56,080 --> 00:25:57,413
让我们回到那一个。

601
00:25:57,413 --> 00:25:59,310
所以很常用的PHP。

602
00:25:59,310 --> 00:26:01,560
PHP往往得到一个坏名声。

603
00:26:01,560 --> 00:26:05,790
它开始作为一个语言实现
乡亲谁也许不一定

604
00:26:05,790 --> 00:26:06,960
最好的语言设计者。

605
00:26:06,960 --> 00:26:11,290
所以你可以阅读各种
网上的文章关于PHP是多么糟糕。

606
00:26:11,290 --> 00:26:13,660
不幸的是，这是
体现，部分地

607
00:26:13,660 --> 00:26:18,727
只是宗教辩论
程序员中的爆发。

608
00:26:18,727 --> 00:26:20,560
这是值得
值得铭记，

609
00:26:20,560 --> 00:26:24,410
从商业的角度来看，
这对技术人员很容易

610
00:26:24,410 --> 00:26:26,900
让所有使用过他们的
对某些事物的看法。

611
00:26:26,900 --> 00:26:29,566
它并不意味着
这一个叫喊最响

612
00:26:29,566 --> 00:26:31,870
或具有最强，
angriest的意见是正确的。

613
00:26:31,870 --> 00:26:34,100
很多时候，它真的
只是无所谓。

614
00:26:34,100 --> 00:26:37,970
>> 所以人们只是吵什么
自己的偏见或舒适区是。

615
00:26:37,970 --> 00:26:40,760
所以，你应该保持
考虑到这一点的时候做

616
00:26:40,760 --> 00:26:42,622
一个决定，这只是
因为有人说

617
00:26:42,622 --> 00:26:45,080
这是正确的语言
这项工作，这可能是真实的，

618
00:26:45,080 --> 00:26:48,350
但它也只可能是它是
自己的技术范围内的正确的语言

619
00:26:48,350 --> 00:26:49,267
设置或安乐窝。

620
00:26:49,267 --> 00:26:52,600
这是不坏，但你应该明白
可能有一些背景存在。

621
00:26:52,600 --> 00:26:54,440
有一些客观
错误的语句，

622
00:26:54,440 --> 00:26:59,080
像C是用错误的语言
这些天来实现网站

623
00:26:59,080 --> 00:27:00,520
几乎总是。

624
00:27:00,520 --> 00:27:03,370
但是，这不是没有道理
地说，任何这些

625
00:27:03,370 --> 00:27:05,700
错了，我们已经迄今为止盘旋。

626
00:27:05,700 --> 00:27:08,180
>> PHP经历了许多版本了。

627
00:27:08,180 --> 00:27:11,310
所以语言往往有版本
与它们相关联的数字。

628
00:27:11,310 --> 00:27:15,390
PHP是提出来，我觉得，第7版现在，
所以它的存在了相当一段时间。

629
00:27:15,390 --> 00:27:18,270
而作为语言得到更新，
他们经常获得新功能。

630
00:27:18,270 --> 00:27:22,510
但你必须要留意这一点
因为如果你的网站已经

631
00:27:22,510 --> 00:27:27,539
在PHP中的7版本中实现，但
你想运行自己的网站，

632
00:27:27,539 --> 00:27:29,830
或者也许你已经外包
你的代码的开发

633
00:27:29,830 --> 00:27:31,960
给别人，他们邮寄
它给你或将其发送给你

634
00:27:31,960 --> 00:27:33,960
他们说，在这里，把
这是你的Web服务器上，

635
00:27:33,960 --> 00:27:36,610
如果你的Web服务器是几
年outdated--它是否

636
00:27:36,610 --> 00:27:39,465
在自己的服务器或Web host--
它可能不会实际运行。

637
00:27:39,465 --> 00:27:41,340
所以这些都是该种
的东西，别人

638
00:27:41,340 --> 00:27:44,067
需要谨记
升级站点时

639
00:27:44,067 --> 00:27:45,650
或执行它的第一次。

640
00:27:45,650 --> 00:27:46,900
>> 我听说JavaScript的早。

641
00:27:46,900 --> 00:27:50,570
因此，JavaScript是一种有趣
之一，它通常是

642
00:27:50,570 --> 00:27:53,030
客户端，因为我们将看到
中场休息时，后

643
00:27:53,030 --> 00:27:55,000
意味着它在用户的浏览器中运行。

644
00:27:55,000 --> 00:27:58,400
但是你也可以运行
JavaScript的这些天

645
00:27:58,400 --> 00:28:03,450
使用一种叫
Node.js的，其中的Node.js

646
00:28:03,450 --> 00:28:08,000
适用于运行机制
JavaScript代码的服务器端，

647
00:28:08,000 --> 00:28:12,430
而不是使用Python或
PHP或其他语言。

648
00:28:12,430 --> 00:28:17,820
>> JavaScript是特别适合
聊天应用和实时

649
00:28:17,820 --> 00:28:22,050
应用程序，而PHP是不是一个伟大的
语言实现的东西

650
00:28:22,050 --> 00:28:25,050
就像一个聊天服务器，用户
保持联系，它不断。

651
00:28:25,050 --> 00:28:28,760
PHP是更访问我的
一次，回来的结果，

652
00:28:28,760 --> 00:28:31,790
然后点击另一个链接一些
从现在几秒钟​​或几分钟。

653
00:28:31,790 --> 00:28:36,020
而Node.js的和JavaScript可以
更多用于永久连接。

654
00:28:36,020 --> 00:28:40,840
您怀疑其他语言
通常用于Web的东西？

655
00:28:40,840 --> 00:28:42,800
>> 听众：请问jQuery的是一个框架？

656
00:28:42,800 --> 00:28:44,050
>> DAVID J. MALAN：好问题。

657
00:28:44,050 --> 00:28:44,700
都不是。

658
00:28:44,700 --> 00:28:51,210
我会打电话jQuery的图书馆，在那里
再一个图书馆仅仅是一串代码

659
00:28:51,210 --> 00:28:53,250
别人有
撰文指出，一般

660
00:28:53,250 --> 00:28:56,390
解决了一些问题，
使得它，希望更方便

661
00:28:56,390 --> 00:28:57,760
为你做你的工作。

662
00:28:57,760 --> 00:29:00,820
让我做的一个例子
这在纸幅的情况下。

663
00:29:00,820 --> 00:29:03,910
>> 在幅材的上下文有
这种语言，JavaScript中，

664
00:29:03,910 --> 00:29:06,690
我们将在后面看到，这样你
可以这样说this--

665
00:29:06,690 --> 00:29:10,060
“的document.getElementById”。

666
00:29:10,060 --> 00:29:11,490
而我怎么叫它昨天？

667
00:29:11,490 --> 00:29:16,800
首先，我认为，是唯一的ID我给
到这个样子的元素。

668
00:29:16,800 --> 00:29:23,110
“P ID =”第一个“>”，然后我们有
像“Lorem存有”，等等。

669
00:29:23,110 --> 00:29:28,210
所以，如果我在写一个程序
JavaScript来操纵不知何故，

670
00:29:28,210 --> 00:29:30,830
改变的网页，我们
昨天被打，

671
00:29:30,830 --> 00:29:33,010
我会用这
代码高亮显示的行

672
00:29:33,010 --> 00:29:38,700
获得HTML的特定片段
从我的网页，特定节点，

673
00:29:38,700 --> 00:29:39,680
正如我们将调用它。

674
00:29:39,680 --> 00:29:44,540
>> 然而，在jQuery的，而不是写作
这一点，这是原始的JavaScript代码 - 

675
00:29:44,540 --> 00:29:48,870
刚刚开箱，这就是你如何
写它 - 你不是刚才说，

676
00:29:48,870 --> 00:29:50,260
“＃第一。”

677
00:29:50,260 --> 00:29:52,330
这是等价的。

678
00:29:52,330 --> 00:29:56,040
只有如此，在此基础上很
神秘的例子，也许什么

679
00:29:56,040 --> 00:29:57,870
是使用jQuery的说法？

680
00:29:57,870 --> 00:30:01,390

681
00:30:01,390 --> 00:30:05,111
为什么要开发利用就像一个图书馆
jQuery的，在此基础上孤立的例子，

682
00:30:05,111 --> 00:30:05,610
也许？

683
00:30:05,610 --> 00:30:06,335
>> 听众：更少的代码。

684
00:30:06,335 --> 00:30:06,780
>> 戴维·马兰：是的。

685
00:30:06,780 --> 00:30:07,530
这是更少的代码。

686
00:30:07,530 --> 00:30:09,070
这只是更快的输入。

687
00:30:09,070 --> 00:30:11,690
对位是
它看起来可怕。

688
00:30:11,690 --> 00:30:13,540
你不能真正读懂它从左到右。

689
00:30:13,540 --> 00:30:16,730
事实上，因为它主要是
现在标点符号，而不是实际的话，

690
00:30:16,730 --> 00:30:20,950
我可以种推断
“的document.getElementById”变

691
00:30:20,950 --> 00:30:23,640
从由它的ID的文档的元素。

692
00:30:23,640 --> 00:30:26,750
我真的可以用没有这样的
从这里这个东西助记符。

693
00:30:26,750 --> 00:30:27,680
>> 所以这是一个权衡。

694
00:30:27,680 --> 00:30:30,763
有自带一个复杂
经常使用图书馆，特别是

695
00:30:30,763 --> 00:30:31,440
像jQuery。

696
00:30:31,440 --> 00:30:34,700
但现实是jQuery有样
中成为一个事实上的标准，

697
00:30:34,700 --> 00:30:38,110
使几乎任何人这些
天谁写的JavaScript代码

698
00:30:38,110 --> 00:30:41,520
使用jQuery或某事
喜欢它，而不再写入

699
00:30:41,520 --> 00:30:45,200
这样一个冗长的表达式为
这一点，因为再次，人性化

700
00:30:45,200 --> 00:30:47,850
了解到，哇，这是
那种一个错失的机会

701
00:30:47,850 --> 00:30:49,030
让我们的生活更轻松。

702
00:30:49,030 --> 00:30:51,140
所以，人类使他们的生活更轻松。

703
00:30:51,140 --> 00:30:53,310
好问题。

704
00:30:53,310 --> 00:30:55,870
>> 其他语言来考虑。

705
00:30:55,870 --> 00:30:58,660
我想这中间说
名单Ruby是相当流行。

706
00:30:58,660 --> 00:31:01,310
因此在世界
红宝石，有一个框架

707
00:31:01,310 --> 00:31:03,590
所谓Rails的，这是非常受欢迎的。

708
00:31:03,590 --> 00:31:06,880
因此，Ruby on Rails是一个
常用的表达。

709
00:31:06,880 --> 00:31:10,330
此外，在这个世界上，让我
圆形的Java的Web的东西，

710
00:31:10,330 --> 00:31:14,160
凡在Java世界
你可能有JSP或Java

711
00:31:14,160 --> 00:31:18,450
小服务程序，这是一种常见的技术。

712
00:31:18,450 --> 00:31:22,560
而这仅仅是再次使用方式
在服务器环境中该语言。

713
00:31:22,560 --> 00:31:23,520
>> 所以，这是什么意思？

714
00:31:23,520 --> 00:31:25,770
如果你有一个物理
服务器，你会从字面上

715
00:31:25,770 --> 00:31:30,510
下载的Web服务器软件
并以这样的方式安装

716
00:31:30,510 --> 00:31:33,510
你有一个支持
这些框架，与您

717
00:31:33,510 --> 00:31:37,260
可以反过来，使用一个或
更多的这些语言。

718
00:31:37,260 --> 00:31:40,260
而在现实中，如果您注册
就像一个虚拟主机或某些云

719
00:31:40,260 --> 00:31:41,968
服务我们谈
昨天，常

720
00:31:41,968 --> 00:31:44,885
的东西只是自带的
机器对你的配置。

721
00:31:44,885 --> 00:31:46,510
你并不需要手动设置起来。

722
00:31:46,510 --> 00:31:51,040
但是，如果你做到了，这是哪里的作用
系统管理员，可以这么说，

723
00:31:51,040 --> 00:31:51,860
进场。

724
00:31:51,860 --> 00:31:54,151
他或她居然会做
这种东西对你来说，

725
00:31:54,151 --> 00:31:58,510
或所谓的管理员
往往会为你做这个。

726
00:31:58,510 --> 00:31:59,010
好吧。

727
00:31:59,010 --> 00:32:03,300
对其中一些在这里有问题吗？

728
00:32:03,300 --> 00:32:06,690
或者在任何机会
所有询问的语言吗？

729
00:32:06,690 --> 00:32:09,500
构架？

730
00:32:09,500 --> 00:32:11,530
然后让我介绍
只是另一个库

731
00:32:11,530 --> 00:32:13,150
这也是很常见的这些天。

732
00:32:13,150 --> 00:32:15,340
这个名单可以无限地继续下去。

733
00:32:15,340 --> 00:32:19,140
>> 而这个库是怎么样的
开始失宠。

734
00:32:19,140 --> 00:32:19,850
它的存在了。

735
00:32:19,850 --> 00:32:22,040
它是由推广
Twitter的一段时间。

736
00:32:22,040 --> 00:32:24,470
而现在很多的网站，
许多开发人员使用它。

737
00:32:24,470 --> 00:32:26,629
但新的东西来了
一起出来，来了。

738
00:32:26,629 --> 00:32:29,420
但是，让我给你一个感觉
意味着什么使用图书馆。

739
00:32:29,420 --> 00:32:32,250
如此反复，JavaScript是
一个非常流行的语言。

740
00:32:32,250 --> 00:32:35,340
CSS或级联样式表，
我们谈到了昨天。

741
00:32:35,340 --> 00:32:36,600
这同样是无所不在的。

742
00:32:36,600 --> 00:32:40,130
没有人让今天的网页
不使用HTML和CSS最低限度。

743
00:32:40,130 --> 00:32:42,510
但它并不总是那么容易
做某些事情。

744
00:32:42,510 --> 00:32:46,281
>> 因此，让我去getbootstrap.com。

745
00:32:46,281 --> 00:32:46,780
哎呦。

746
00:32:46,780 --> 00:32:48,280
这不是我们如何拼写。

747
00:32:48,280 --> 00:32:52,410
Getbootstrap.com，这
是要带领我

748
00:32:52,410 --> 00:32:56,140
对于这个库的登录页面。

749
00:32:56,140 --> 00:32:59,720
因此，他们呼吁慷慨
本身的框架，其

750
00:32:59,720 --> 00:33:02,032
是一种形式的公平，
但我还是会称它为

751
00:33:02,032 --> 00:33:03,490
不止一个框架库。

752
00:33:03,490 --> 00:33:05,760
但这些都只是值得商榷的语义。

753
00:33:05,760 --> 00:33:12,360
让我去他们的CSS标签，
让我去这样的事情。

754
00:33:12,360 --> 00:33:15,450
>> 因此，回顾一下我们的表格看起来
像昨天Cloud9？

755
00:33:15,450 --> 00:33:16,370
这是相当难看。

756
00:33:16,370 --> 00:33:17,320
老同学的按钮。

757
00:33:17,320 --> 00:33:20,420
我认为，按钮是灰色的通过
默认。所有的一切都真的

758
00:33:20,420 --> 00:33:22,420
格式化相当乱七八糟。

759
00:33:22,420 --> 00:33:26,940
所以，如果你希望你的Web形式看
有点nicer--让我放大这里。

760
00:33:26,940 --> 00:33:30,050
>> 并通过更好的我真的只是
意思是很挑剔的美学。

761
00:33:30,050 --> 00:33:35,390
所以注意邮箱有怎么了
圆角的矩形角到它。

762
00:33:35,390 --> 00:33:37,010
所以这是一个少许清洁剂存在。

763
00:33:37,010 --> 00:33:40,770
注意，词的电子邮件
在那里，直到我开始输入

764
00:33:40,770 --> 00:33:41,797
然后消失。

765
00:33:41,797 --> 00:33:43,130
所以这是一个不错的小功能。

766
00:33:43,130 --> 00:33:46,046
注意怎么回事是怎么样的
泛着很好，其中一些这个你

767
00:33:46,046 --> 00:33:49,069
获得从浏览器免费的，
但一些这也是库

768
00:33:49,069 --> 00:33:51,360
码，其他人都
写了给你这个。

769
00:33:51,360 --> 00:33:53,480
>> 像这样的事情
给我我的密码。

770
00:33:53,480 --> 00:33:58,480
这个按钮是不是更性感一点
默认。非常流行现在。

771
00:33:58,480 --> 00:34:03,570
自从iOS的7左右，
世界已经变得非常平坦，

772
00:34:03,570 --> 00:34:09,000
而世界面前
许多阴影，大量的

773
00:34:09,000 --> 00:34:11,040
对图标的思考。

774
00:34:11,040 --> 00:34:14,170
很像在服装世界
有来来去去的流行趋势。

775
00:34:14,170 --> 00:34:16,190
现在一切都平坦您的手机上。

776
00:34:16,190 --> 00:34:19,159
>> 实际上，按钮上的
iPhone现在只是蓝色的链接。

777
00:34:19,159 --> 00:34:21,000
这里没有甚至经常圆形按钮。

778
00:34:21,000 --> 00:34:22,791
所以这些都只是事
这进出

779
00:34:22,791 --> 00:34:26,659
时尚的，所以你这是怎么可能
做一个更现代的外观的Web表单。

780
00:34:26,659 --> 00:34:27,159
纽扣。

781
00:34:27,159 --> 00:34:29,190
因此，引导有很多漂亮的按钮。

782
00:34:29,190 --> 00:34:33,639
所以，如果你想蓝色的按钮，
绿色按钮，蓝，橙，红。

783
00:34:33,639 --> 00:34:35,840
引导使得它更容易
做这些事情。

784
00:34:35,840 --> 00:34:38,131
这些是各种事情
你绝对可以

785
00:34:38,131 --> 00:34:41,840
昨天已经用CSS和做
HTML，但它只是在颈部疼痛。

786
00:34:41,840 --> 00:34:44,840
所以相反，什么引导会
有你要做的就是这样的事情。

787
00:34:44,840 --> 00:34:48,960
>> 如果你想要一个button--原来这
是我们没有使用yesterday-- HTML标记

788
00:34:48,960 --> 00:34:53,070
你希望它看起来
像这样的绿色按钮，

789
00:34:53,070 --> 00:34:57,380
你从字面上只是给它一个类，
我们确实谈论昨天，

790
00:34:57,380 --> 00:34:59,710
的“BTN BTN-的成功。”

791
00:34:59,710 --> 00:35:00,971
>> 为什么这些话？

792
00:35:00,971 --> 00:35:03,470
Twitter的，引导的作者，
想出了这些话。

793
00:35:03,470 --> 00:35:05,428
他们可以被称为
他们希望他们任何东西。

794
00:35:05,428 --> 00:35:08,480
但是，你现在越来越是
他人在微博在这种情况下，

795
00:35:08,480 --> 00:35:12,360
已经想通了，你怎么做
按钮看上去非常干净和绿色。

796
00:35:12,360 --> 00:35:15,580
他们打包该功能
在CSS类，叫做“BTN”。

797
00:35:15,580 --> 00:35:19,790
和“BTN-成功”，让我们任何人都可以
现在使用它，甚至没有考虑

798
00:35:19,790 --> 00:35:20,290
它。

799
00:35:20,290 --> 00:35:22,880
因此，他们都抽象化了
一个绿色按钮的概念

800
00:35:22,880 --> 00:35:25,320
因此，我们不必在意
实现它自己。

801
00:35:25,320 --> 00:35:28,520
事实上，我们可以专注于实现
我们感兴趣的东西。

802
00:35:28,520 --> 00:35:30,902
>> 如果我们在这里向下滚动。

803
00:35:30,902 --> 00:35:32,110
在屏幕上的错误信息。

804
00:35:32,110 --> 00:35:35,440
有时候你需要一点消息
出现在浏览器的顶部。

805
00:35:35,440 --> 00:35:39,729
我们任何人可以做一些该做的
努力，昨天的教训后，

806
00:35:39,729 --> 00:35:40,770
但你为什么要这么做呢？

807
00:35:40,770 --> 00:35:42,540
这是这样的无趣
审美细节。

808
00:35:42,540 --> 00:35:44,248
让我们站在
自举的肩膀上

809
00:35:44,248 --> 00:35:49,440
并让他们给我们这样的事情，
我们从字面上看，得到一个红色的框，

810
00:35:49,440 --> 00:35:53,220
只需要做一个段落
标签与类of--遗憾。

811
00:35:53,220 --> 00:35:57,307
“BG-危险”将会给我们
这微红方块。

812
00:35:57,307 --> 00:35:59,140
现在，让我们去
更有趣的事情。

813
00:35:59,140 --> 00:36:02,950
如果我回到顶部
这个页面并转到组件，

814
00:36:02,950 --> 00:36:05,380
现在世界变得更有趣。

815
00:36:05,380 --> 00:36:08,826
例如，很常见的是
下拉这样的菜单。

816
00:36:08,826 --> 00:36:11,560
这将是一个绝对的
疼痛实现。

817
00:36:11,560 --> 00:36:13,610
它不是很久
以前，我们的程序员

818
00:36:13,610 --> 00:36:16,490
必须实施这些
种从头开始菜单。

819
00:36:16,490 --> 00:36:20,800
>> 但它是这样一个共同的模式
，图书馆像引导

820
00:36:20,800 --> 00:36:25,230
只是给大家做一个能力
远的下拉菜单，更轻松。

821
00:36:25,230 --> 00:36:27,850
有没有人做到这一点的方式，
但如果我阅读文档

822
00:36:27,850 --> 00:36:32,100
我也看到，OK，我应该使用
这个HTML，如果我想要一个下拉菜单

823
00:36:32,100 --> 00:36:34,030
其行为这样。

824
00:36:34,030 --> 00:36:36,690
>> 同样，让我们​​去按钮下拉。

825
00:36:36,690 --> 00:36:38,470
因此，这是更炫。

826
00:36:38,470 --> 00:36:41,800
如果我想这看起来像一个按钮
但小三角指

827
00:36:41,800 --> 00:36:44,080
我一下就可以了
而得到这个菜单，这

828
00:36:44,080 --> 00:36:45,760
是使用一种称为JavaScript语言。

829
00:36:45,760 --> 00:36:47,470
而我们都可以实现
这在JavaScript中。

830
00:36:47,470 --> 00:36:49,720
但是再次，这是一个轮
你不想重塑。

831
00:36:49,720 --> 00:36:52,700
你只想把它关闭
货架库这一点。

832
00:36:52,700 --> 00:36:58,145
>> 让我们去的东西
像进度条。

833
00:36:58,145 --> 00:36:59,770
所以，这样的事情是挺酷的。

834
00:36:59,770 --> 00:37:02,910
如果你见过一个进度
酒吧在屏幕上移动，

835
00:37:02,910 --> 00:37:06,380
实施经常
仅仅是一个旋转图标。

836
00:37:06,380 --> 00:37:10,200
事实上，正如顺便说一句，让
我去Ajax--是什么呢？

837
00:37:10,200 --> 00:37:10,710
Ajax的信息？

838
00:37:10,710 --> 00:37:11,720
哎呦。

839
00:37:11,720 --> 00:37:13,035
Ajaxinfo。

840
00:37:13,035 --> 00:37:14,800
让我记住地址。

841
00:37:14,800 --> 00:37:15,820
在那里，我们走了。

842
00:37:15,820 --> 00:37:19,850
>> 所以，如果你见过一些动画
而加载页面时，或思考，

843
00:37:19,850 --> 00:37:25,410
或保存，或创造的东西，你
可能会看到这样的动画，因为这些。

844
00:37:25,410 --> 00:37:28,800
因此，让我们看的东西
像这样一个在这里，

845
00:37:28,800 --> 00:37:33,550
而我们选择的前景色
绿色，感觉一种友好。

846
00:37:33,550 --> 00:37:34,545
我可以点击这个？

847
00:37:34,545 --> 00:37:35,500
再来一个。

848
00:37:35,500 --> 00:37:36,000
好。

849
00:37:36,000 --> 00:37:38,930
我们就一起去红色的，因为
这就是我们在说什么。

850
00:37:38,930 --> 00:37:40,250
所以在这里我们有它。

851
00:37:40,250 --> 00:37:43,940
>> 所以，如果你见过这样的屏幕上，
由此突然出现，然后

852
00:37:43,940 --> 00:37:47,550
突然消失，是什么
它是实现的呢？

853
00:37:47,550 --> 00:37:48,970
好吧，这只是一个GIF。

854
00:37:48,970 --> 00:37:52,850
G-I-F。这是一个动画
文件，它只是意味着

855
00:37:52,850 --> 00:37:54,327
它就像一个老同学的漫画书。

856
00:37:54,327 --> 00:37:57,160
这里还有一堆不同
那些即将帧[STUTTERING]

857
00:37:57,160 --> 00:37:58,085
而只是在重复。

858
00:37:58,085 --> 00:38:00,090
和它的创建
运动的错觉。

859
00:38:00,090 --> 00:38:03,070
>> 因此，一旦一个页面完成
加载或做一些事情，

860
00:38:03,070 --> 00:38:04,610
什么程序员吗？

861
00:38:04,610 --> 00:38:07,500
那么，他或她只是隐藏这个形象。

862
00:38:07,500 --> 00:38:11,536
因此，所有的进度条是一种被
像一个电影你看。

863
00:38:11,536 --> 00:38:14,660
你是那种无视这一事实，
它实际上没有做任何事情，

864
00:38:14,660 --> 00:38:15,940
它只是感动。

865
00:38:15,940 --> 00:38:19,150
>> 然后，当它完成进步，
他们只是隐藏或关闭它。

866
00:38:19,150 --> 00:38:21,115
而这所有的魔法
这是有事情。

867
00:38:21,115 --> 00:38:22,770
引导给你
票友的东西一点点，

868
00:38:22,770 --> 00:38:25,030
让你可以真正
看到一个百分比，因为它去，

869
00:38:25,030 --> 00:38:27,840
但它也只是排序
一个简单的动画。

870
00:38:27,840 --> 00:38:32,250
>> 让我们来看看一些最后的
这里更复杂的例子。

871
00:38:32,250 --> 00:38:35,526
就像一个模态。

872
00:38:35,526 --> 00:38:36,900
有谁知道一个模式是什么？

873
00:38:36,900 --> 00:38:39,880

874
00:38:39,880 --> 00:38:42,550
模态窗口通常是
一个被认为

875
00:38:42,550 --> 00:38:46,880
采取前景控制
阻止你做其他事情。

876
00:38:46,880 --> 00:38:50,290
它那种迫使用户
注意在屏幕的中间，

877
00:38:50,290 --> 00:38:52,290
锁定他们，通常情况下，
的一切。

878
00:38:52,290 --> 00:38:55,830
>> 所以，如果我推出这个演示中，
屏幕通常会变成灰色。

879
00:38:55,830 --> 00:38:57,060
那么，我们如何让它灰色的？

880
00:38:57,060 --> 00:38:59,080
那么，我们可能只是
改变的背景颜色

881
00:38:59,080 --> 00:39:01,060
像我们昨天做
或类似的东西。

882
00:39:01,060 --> 00:39:03,490
也许这是一个覆盖
该半透明。

883
00:39:03,490 --> 00:39:06,320
现在发现，你可以做
花哨的东西是这样的。

884
00:39:06,320 --> 00:39:09,930
所以，如果你点击一个按钮
并希望一点点蹦出出现，

885
00:39:09,930 --> 00:39:10,710
你可以做到这一点。

886
00:39:10,710 --> 00:39:12,340
所以谁在乎all--是吗？

887
00:39:12,340 --> 00:39:15,791
>> 听众：因此，与引导，
得到它的成立，

888
00:39:15,791 --> 00:39:21,002
是不是像昨天一样简单
我们做的CSS样式的网页？

889
00:39:21,002 --> 00:39:21,960
DAVID J. MALAN：确实是这样。

890
00:39:21,960 --> 00:39:22,835
非常好的问题。

891
00:39:22,835 --> 00:39:24,480
让我去入门。

892
00:39:24,480 --> 00:39:26,090
是的。

893
00:39:26,090 --> 00:39:30,920
所有你必须​​为了做
使用引导程序基本上是复制

894
00:39:30,920 --> 00:39:35,910
并粘贴这三个排长​​队
码到你自己的网站page--顶部

895
00:39:35,910 --> 00:39:38,892
您page--头
而你启动和运行。

896
00:39:38,892 --> 00:39:41,850
还有的做不同的方式
它，但是这将是最简单的。

897
00:39:41,850 --> 00:39:45,190
>> 那么，什么是对所有的有帮助吗？

898
00:39:45,190 --> 00:39:47,524
好吧，如果你没有那么多
一个网站的实施者

899
00:39:47,524 --> 00:39:50,106
但你要设计它，
或者你想别人提供

900
00:39:50,106 --> 00:39:53,220
用线框图，可以这么说，
或者只是艺术家的引渡什么

901
00:39:53,220 --> 00:39:56,080
你想做的事，我，这个
一天，会经常去的网站

902
00:39:56,080 --> 00:39:58,660
像引导，在那里，如果我
要实现something--

903
00:39:58,660 --> 00:40:02,290
像最近在校园
我们希望实施

904
00:40:02,290 --> 00:40:06,170
用于导航基于Web的工具
哈佛大学的课程目录，

905
00:40:06,170 --> 00:40:08,770
使学生更容易
通过课程浏览

906
00:40:08,770 --> 00:40:10,930
并添加课程
购物清单，可以这么说，

907
00:40:10,930 --> 00:40:13,070
来样决定什么
他们希望采取。

908
00:40:13,070 --> 00:40:16,252
>> 我试图想象
我自己，什么成分会

909
00:40:16,252 --> 00:40:17,460
我们要用来建立这个？

910
00:40:17,460 --> 00:40:19,050
将用户界面是什么样的？

911
00:40:19,050 --> 00:40:22,800
而就翻翻喜欢的网站
这或其他类似网站的库，

912
00:40:22,800 --> 00:40:26,560
你可以得到的灵感，因为哇，
我可以用这个小工具，这个小工具，

913
00:40:26,560 --> 00:40:27,330
而这个小部件。

914
00:40:27,330 --> 00:40:29,080
然后真的什么
程序员开始

915
00:40:29,080 --> 00:40:32,800
做的，尤其是这几天在这
Web编程的更现代的世界里，

916
00:40:32,800 --> 00:40:35,827
是编程越来越
有关布线的东西放在一起。

917
00:40:35,827 --> 00:40:38,910
排序采取这一现成的，
这个现成的，这个现成的，

918
00:40:38,910 --> 00:40:41,954
而你作为聪明的
连接所有这些点，

919
00:40:41,954 --> 00:40:45,120
但最终再次建立的东西
站在别人的肩膀上，

920
00:40:45,120 --> 00:40:49,370
让你不花一个月
实施一个愚蠢的下拉菜单中，

921
00:40:49,370 --> 00:40:52,080
这实际上是很难做到的，如果
你想让它在Chrome工作，

922
00:40:52,080 --> 00:40:55,220
而IE和Firefox，以及任何
其他浏览器数量。

923
00:40:55,220 --> 00:40:59,060
这就是为什么有这种丰富
商业和开源软件

924
00:40:59,060 --> 00:41:01,220
行业也是如此。

925
00:41:01,220 --> 00:41:06,810
>> 听众：这是否引导得到更新
你必须然后更新您的联系？

926
00:41:06,810 --> 00:41:07,820
>> DAVID J. MALAN：它。

927
00:41:07,820 --> 00:41:09,090
嗯，是的，它的作用。

928
00:41:09,090 --> 00:41:12,540
引导目前是3.3.6版本。

929
00:41:12,540 --> 00:41:16,720
你会do--一般什么
其实这是值得一提。

930
00:41:16,720 --> 00:41:19,200
还有就是一般的
被称为语义版本

931
00:41:19,200 --> 00:41:20,160
系统在世界上。

932
00:41:20,160 --> 00:41:21,320
不是每个人都这样做了。

933
00:41:21,320 --> 00:41:26,410
>> 但是，如果你看过版本号
属于形式的x.y.z--

934
00:41:26,410 --> 00:41:30,240
因此，例如，第一个版本
方案可能是1.0.0。

935
00:41:30,240 --> 00:41:34,970
或者如果它是非常，非常公测，或
即使阿尔法状态，这意味着使用

936
00:41:34,970 --> 00:41:37,620
在您自己的风险，它不
真的准备好黄金时间，

937
00:41:37,620 --> 00:41:42,080
你甚至可能开始0.0.1
或一些这样的称号。

938
00:41:42,080 --> 00:41:47,260
但是，如果软件开始于版本
1.0，或等价1.0.0，

939
00:41:47,260 --> 00:41:50,530
通常情况下，什么是共同的，这些
days--虽不omnipresent--是

940
00:41:50,530 --> 00:41:53,520
如果一个公司或
个人程序员修复

941
00:41:53,520 --> 00:41:56,140
在一些片的一些bug
软件真的

942
00:41:56,140 --> 00:42:01,620
是一个错误，其更正不应该
在all--它不会改变你的影响

943
00:42:01,620 --> 00:42:03,940
该程序的行为，
它只是修复了的东西

944
00:42:03,940 --> 00:42:06,580
这是行不通的
properly--您通常会

945
00:42:06,580 --> 00:42:08,890
更新z值存在。

946
00:42:08,890 --> 00:42:12,900
这意味着有人喜欢贾巴尔
可以简单地进入他的网站，

947
00:42:12,900 --> 00:42:19,470
盲目地更改版本号
从1.0.0到1.0.1，保存，出货，

948
00:42:19,470 --> 00:42:21,880
并且在理论上，不必
担心他刚刚打破

949
00:42:21,880 --> 00:42:24,430
他的网站是因为
有些欠缺的功能，

950
00:42:24,430 --> 00:42:25,870
因为别的东西打破。

951
00:42:25,870 --> 00:42:28,740
>> 同时，如果我的
程序员或公司的一些

952
00:42:28,740 --> 00:42:35,500
为使一些显著
变化，增加了功能，

953
00:42:35,500 --> 00:42:40,320
我可能会更新我们
1.1.0，因为我其实是

954
00:42:40,320 --> 00:42:42,200
改变库的行为。

955
00:42:42,200 --> 00:42:44,470
我给你，也许更多的功能。

956
00:42:44,470 --> 00:42:48,490
最后，如​​果我是实际
从根本上改变软件，

957
00:42:48,490 --> 00:42:54,380
多，这将打破许多
用户网站或应用程序，

958
00:42:54,380 --> 00:42:59,550
那么我不得不在这个模型中，以
升级主版本号也一样，

959
00:42:59,550 --> 00:43:01,059
这是一个重大更改。

960
00:43:01,059 --> 00:43:03,725
换句话说，我可能有
对于那些跌落不再支持

961
00:43:03,725 --> 00:43:04,350
下拉菜单。

962
00:43:04,350 --> 00:43:07,790
所以，如果您升级到2.0，一半
您的网站可能会停止工作。

963
00:43:07,790 --> 00:43:10,950
这是一类信号
给社会以什么

964
00:43:10,950 --> 00:43:13,223
参与制作的升级。

965
00:43:13,223 --> 00:43:16,710

966
00:43:16,710 --> 00:43:18,020
一个很好的机会来提高。

967
00:43:18,020 --> 00:43:18,718
其他问题？

968
00:43:18,718 --> 00:43:21,761

969
00:43:21,761 --> 00:43:22,260
好吧。

970
00:43:22,260 --> 00:43:26,945
那么让我们来看看最后一个
在这一领域的编程话题

971
00:43:26,945 --> 00:43:30,640
的技术堆栈，
即与移动。

972
00:43:30,640 --> 00:43:36,232
>> 因此，在手机的当今世界
你have--和iPad，和面，

973
00:43:36,232 --> 00:43:37,940
和所有这些类型
的devices--你有

974
00:43:37,940 --> 00:43:40,950
有很多选择，当
谈到实施

975
00:43:40,950 --> 00:43:47,270
一个应用程序或网站
客户的移动设备。

976
00:43:47,270 --> 00:43:51,570
所以刚才陈述
很明显，也许这些天，

977
00:43:51,570 --> 00:43:54,960
什么是平台
开发用于在移动领域？

978
00:43:54,960 --> 00:43:59,650
你可能想什么设备
您的应用或网站支持？

979
00:43:59,650 --> 00:44:00,317
>> 听众：苹果。

980
00:44:00,317 --> 00:44:01,108
DAVID J. MALAN：OK。

981
00:44:01,108 --> 00:44:01,820
因此，苹果的设备。

982
00:44:01,820 --> 00:44:06,740
因此，这意味着iPhone和那
意味着iPad和甚至iPod的。

983
00:44:06,740 --> 00:44:07,627
还有什么？

984
00:44:07,627 --> 00:44:11,006

985
00:44:11,006 --> 00:44:11,505
奥利维尔？

986
00:44:11,505 --> 00:44:11,970
>> 听众：Android系统。

987
00:44:11,970 --> 00:44:13,111
>> DAVID J. MALAN：Android系统。

988
00:44:13,111 --> 00:44:13,610
好。

989
00:44:13,610 --> 00:44:17,335
所以Android手机，Android的
平板电脑，Android市场

990
00:44:17,335 --> 00:44:21,240
甚至混乱因为 - 和
即使苹果正变得凌乱。

991
00:44:21,240 --> 00:44:23,960
而曾几何时
iPhone是具有一定规模，

992
00:44:23,960 --> 00:44:26,560
和iPad是具有一定规模，
和iPod是具有一定规模，现在

993
00:44:26,560 --> 00:44:33,420
我们有iPad的扭蛋，和薄
的人，和iPhone 6 Plus和6。

994
00:44:33,420 --> 00:44:34,407
这已经成为一个烂摊子。

995
00:44:34,407 --> 00:44:35,740
这已经成为了Android的世界。

996
00:44:35,740 --> 00:44:39,030
>> 我说这跟那种轧
我的眼睛，因为从开发者

997
00:44:39,030 --> 00:44:41,680
的角度看，它是一
颈项强痛时

998
00:44:41,680 --> 00:44:45,686
你没有史蒂夫·乔布斯“
绝对控股的愿景

999
00:44:45,686 --> 00:44:47,060
在所有这些规范。

1000
00:44:47,060 --> 00:44:49,726
苹果仍然没有因为他们是
的那些构建硬件。

1001
00:44:49,726 --> 00:44:52,690
但它是一个很好的事情，如果
我是一个软件开发人员，

1002
00:44:52,690 --> 00:44:54,520
只知道我的
iPhone总是会

1003
00:44:54,520 --> 00:44:56,850
是这样的，因为大
这意味着我总是知道

1004
00:44:56,850 --> 00:44:58,847
我是多么的屏幕房地产有。

1005
00:44:58,847 --> 00:45:01,180
所以，如果我想提出一个图标
在顶部左上角，

1006
00:45:01,180 --> 00:45:04,530
这将是完全一样的
把每一个客户的设备上。

1007
00:45:04,530 --> 00:45:07,140
>> 但在iPhone的世界
6S和iPhone 6加号

1008
00:45:07,140 --> 00:45:10,570
在Android的世界
手机，这一切都在地图上。

1009
00:45:10,570 --> 00:45:13,580
因此，这使得它更难程序
东西，尤其是用户界面，

1010
00:45:13,580 --> 00:45:18,270
因为现在你必须开始安排
你的用户界面比较，不

1011
00:45:18,270 --> 00:45:19,730
绝对。

1012
00:45:19,730 --> 00:45:23,524
而同样一直在浏览器真实的，
和台式机和笔记本电脑的年

1013
00:45:23,524 --> 00:45:25,690
因为你，当然，
有不同的屏幕尺寸。

1014
00:45:25,690 --> 00:45:26,189
>> 还有什么？

1015
00:45:26,189 --> 00:45:30,170
你可能有面，
像微软。

1016
00:45:30,170 --> 00:45:31,270
你可能有 - 

1017
00:45:31,270 --> 00:45:32,270
听众：Windows phone的。

1018
00:45:32,270 --> 00:45:32,816
DAVID J. MALAN：那是什么？

1019
00:45:32,816 --> 00:45:33,570
听众：Windows phone的。

1020
00:45:33,570 --> 00:45:34,403
戴维·马兰：是的。

1021
00:45:34,403 --> 00:45:37,570
所以Windows手机仍然可以发现。

1022
00:45:37,570 --> 00:45:41,840
排序黑莓手机的种类，
但他们继续努力。

1023
00:45:41,840 --> 00:45:43,900
然后蕉等设备。

1024
00:45:43,900 --> 00:45:48,020
所以在大多数情况下，让我们
说这些是那些

1025
00:45:48,020 --> 00:45:49,520
此刻关心。

1026
00:45:49,520 --> 00:45:51,890
当然，苹果的东西，
当然Android的东西，

1027
00:45:51,890 --> 00:45:55,640
和Windows之间，像面片
似乎流行起来相当不错。

1028
00:45:55,640 --> 00:45:58,030
>> 所以这些设备中，
如果要推出，

1029
00:45:58,030 --> 00:46:02,677
比方说，对于移动你的存在
公司，什么样的设计决策

1030
00:46:02,677 --> 00:46:03,510
你有没有做什么呢？

1031
00:46:03,510 --> 00:46:06,350
好了，我们已经说了
在苹果世界

1032
00:46:06,350 --> 00:46:08,790
有至少两种语言
这通常使用。

1033
00:46:08,790 --> 00:46:10,260
一个是叫什么？

1034
00:46:10,260 --> 00:46:11,260
>> 听众：Objective-C的。

1035
00:46:11,260 --> 00:46:11,560
>> 戴维·马兰：是的。

1036
00:46:11,560 --> 00:46:13,600
所以目标C，这是上了年纪的。

1037
00:46:13,600 --> 00:46:17,720
这也是语言，许多Mac
应用程序仍然写入了数据。

1038
00:46:17,720 --> 00:46:18,964
那么其他较新的一个是？

1039
00:46:18,964 --> 00:46:19,630
听众：斯威夫特。

1040
00:46:19,630 --> 00:46:20,590
DAVID J. MALAN：斯威夫特。

1041
00:46:20,590 --> 00:46:23,900
而那些是什么样的
两到知道打动人。

1042
00:46:23,900 --> 00:46:28,238
然后在Android的世界，
Android版确实使用什么语言？

1043
00:46:28,238 --> 00:46:30,618
>> 听众：C＃？

1044
00:46:30,618 --> 00:46:31,570
>> 听众：Java的。

1045
00:46:31,570 --> 00:46:34,230
>> DAVID J. MALAN：Java是
语言“大谈特谈”。

1046
00:46:34,230 --> 00:46:37,950
在Windows世界，当然，
我们会说在这种情况下C＃。

1047
00:46:37,950 --> 00:46:40,590
所以，这已经是一种
恼人的，因为什么

1048
00:46:40,590 --> 00:46:43,070
外卖的生意
业主或某人谁只是

1049
00:46:43,070 --> 00:46:44,570
要推出一个移动的存在？

1050
00:46:44,570 --> 00:46:45,220
像，该死？

1051
00:46:45,220 --> 00:46:48,590
就像，如果我想支持
一个相当广泛的用户基础，

1052
00:46:48,590 --> 00:46:52,180
我必须写，这似乎
三个独立的应用程序。

1053
00:46:52,180 --> 00:46:55,630
其中在这些语言中的一种，
之一的Java，一个在C＃。

1054
00:46:55,630 --> 00:46:59,620
即使我想要的功能
是相同的，也没关系。

1055
00:46:59,620 --> 00:47:02,940
我还需要使用不同
语言，因为苹果和微软，

1056
00:47:02,940 --> 00:47:06,084
和谷歌都支持
不同的环境。

1057
00:47:06,084 --> 00:47:07,750
和这个多年来一直是一种挑战。

1058
00:47:07,750 --> 00:47:10,100
早在一天，
人们习惯购买软件

1059
00:47:10,100 --> 00:47:12,230
在电脑店
收缩包装盒，

1060
00:47:12,230 --> 00:47:14,470
你要么必须
端起架子的Mac，

1061
00:47:14,470 --> 00:47:19,040
或for--这也许非常小的Mac
shelf--涨幅较大的Windows货架

1062
00:47:19,040 --> 00:47:19,980
买一些软件。

1063
00:47:19,980 --> 00:47:22,813
而很多时候，甚至没有
什么东西可以在Mac货架上。

1064
00:47:22,813 --> 00:47:23,430
为什么？

1065
00:47:23,430 --> 00:47:26,900
那么，公司决定，如果90％
世界，世界的95％

1066
00:47:26,900 --> 00:47:31,180
有电脑，何苦连
实现在Mac OS上的东西呢？

1067
00:47:31,180 --> 00:47:34,370
>> 作为aside--共
digression--为什么会

1068
00:47:34,370 --> 00:47:40,960
该MAC似乎很不受病毒，
和蠕虫和安全威胁？

1069
00:47:40,960 --> 00:47:44,040
是苹果在这更好的？

1070
00:47:44,040 --> 00:47:45,934
在保持电脑安全的更好吗？

1071
00:47:45,934 --> 00:47:47,750
>> 听众：小观众？

1072
00:47:47,750 --> 00:47:50,720
>> DAVID J. MALAN：这是
可能更大一点吧。

1073
00:47:50,720 --> 00:47:54,740
所以苹果电脑的许多用户
早就声称，哦，使用的是Mac，

1074
00:47:54,740 --> 00:47:57,630
你会幸免于病毒和
蠕虫和所有的这些事

1075
00:47:57,630 --> 00:47:59,180
长期困扰电脑。

1076
00:47:59,180 --> 00:48:02,050
这可能是因为苹果
具有更好的程序员

1077
00:48:02,050 --> 00:48:05,250
他们编写更好的软件，或
操作系统是较好的设计。

1078
00:48:05,250 --> 00:48:06,870
也许吧，但可能不会。

1079
00:48:06,870 --> 00:48:10,840
>> 这也可能是，当你
一个12岁或30什么

1080
00:48:10,840 --> 00:48:13,510
那种坐在家里写作
恶意软件接管

1081
00:48:13,510 --> 00:48:17,480
这个世界，你会去后
在更大的目标受众。

1082
00:48:17,480 --> 00:48:20,590
世界上95％谁可能
运行Windows或某些

1083
00:48:20,590 --> 00:48:21,740
变体。

1084
00:48:21,740 --> 00:48:23,800
所以这是双方一点点。

1085
00:48:23,800 --> 00:48:25,710
但是，他们的信用，
苹果，据我所知，

1086
00:48:25,710 --> 00:48:28,270
还没有真正吹捧自​​己
作为是更安全的，

1087
00:48:28,270 --> 00:48:32,110
因为你只是邀请戏剧，如果
你提出这样的观点，我想。

1088
00:48:32,110 --> 00:48:32,610
>> 好吧。

1089
00:48:32,610 --> 00:48:36,490
没有得到太多的远了
即，我们如何解决这个问题？

1090
00:48:36,490 --> 00:48:39,670
你有买或做你有
支付三个不同的人来开发

1091
00:48:39,670 --> 00:48:41,540
您的应用程序？

1092
00:48:41,540 --> 00:48:42,870
你挑一个比其他？

1093
00:48:42,870 --> 00:48:45,460
应该怎么引导你
想在这里你觉得呢？

1094
00:48:45,460 --> 00:48:47,960

1095
00:48:47,960 --> 00:48:48,460
卡里姆？

1096
00:48:48,460 --> 00:48:51,001

1097
00:48:51,001 --> 00:48:51,500
不。

1098
00:48:51,500 --> 00:48:54,190
其他人。

1099
00:48:54,190 --> 00:48:56,885
>> 听众：刚才来与硬件。

1100
00:48:56,885 --> 00:48:58,510
DAVID J. MALAN：来与硬件？

1101
00:48:58,510 --> 00:48:59,533
你什么意思？

1102
00:48:59,533 --> 00:49:01,282
>> 听众：对于
环境。 [听不清]

1103
00:49:01,282 --> 00:49:04,867

1104
00:49:04,867 --> 00:49:06,200
DAVID J. MALAN：所以这是真的。

1105
00:49:06,200 --> 00:49:09,280
但是你的客户，
同时，可能有iPhone手机，

1106
00:49:09,280 --> 00:49:13,530
他们可能有Android手机，他们
可能必须通过微软提出平板电脑。

1107
00:49:13,530 --> 00:49:19,040
那么，你如何拥有移动战略
所有这些不同的用户？

1108
00:49:19,040 --> 00:49:23,320
这似乎是，如果它的成本，
假设$ 1,000作出iPhone

1109
00:49:23,320 --> 00:49:25,940
应用程序，这是怎么回事
花费您$ 2,000，使

1110
00:49:25,940 --> 00:49:29,250
iPhone应用程序和
Android应用程序，或者$ 3000名

1111
00:49:29,250 --> 00:49:31,407
也支持Windows设备为好。

1112
00:49:31,407 --> 00:49:33,990
这可能是一个相当
轻描淡写，它甚至可能没有

1113
00:49:33,990 --> 00:49:36,050
是这样的线性关系。

1114
00:49:36,050 --> 00:49:41,065
>> 听众：如果你想有一个应用程序或
不是，你可以回应的网站。

1115
00:49:41,065 --> 00:49:41,940
DAVID J. MALAN：好。

1116
00:49:41,940 --> 00:49:46,255
听众：或者你可以有一个本机应用程序。

1117
00:49:46,255 --> 00:49:47,130
戴维·马兰：是的。

1118
00:49:47,130 --> 00:49:50,260
因此，在这里所有这样的背景下，
我们一直在谈论什么

1119
00:49:50,260 --> 00:49:53,190
人会说本地应用程序。

1120
00:49:53,190 --> 00:49:58,040
即正在编写的应用程序
在该装置的本机语言。

1121
00:49:58,040 --> 00:50:02,190
因此，原生的Objective-C或斯威夫特
代码，或者在Java或C＃。

1122
00:50:02,190 --> 00:50:06,900
这意味着当你下载，让我们
说Snapchat，一个流行的应用，

1123
00:50:06,900 --> 00:50:10,060
或者当你下载
Facebook的一个电话，

1124
00:50:10,060 --> 00:50:13,270
您正在下载要么
版本为iPhone写的，

1125
00:50:13,270 --> 00:50:16,830
或者您的Andr​​oid手机编写的，
或者你写的表面。

1126
00:50:16,830 --> 00:50:18,500
>> 但有一个替代方案。

1127
00:50:18,500 --> 00:50:26,020
由于奥利弗被影射，
可以实际使用的HTML 5

1128
00:50:26,020 --> 00:50:33,440
相反，使用什么叫做网络
应用程序，因此你只需

1129
00:50:33,440 --> 00:50:35,940
实现你的手机存在
和任何功能。

1130
00:50:35,940 --> 00:50:37,030
我是什么手机的存在呢？

1131
00:50:37,030 --> 00:50:39,800
喜欢你的网站中有您
联系信息，所有的列表

1132
00:50:39,800 --> 00:50:43,049
你的产品，也许它有一个购物
购物车，也许你通过它卖的东西。

1133
00:50:43,049 --> 00:50:46,850
无论您的应用程序，你
实现它，而不是在Objective-C，

1134
00:50:46,850 --> 00:50:51,200
或夫特或Java或C＃，但在HTML中
5，这是我们看到的语言

1135
00:50:51,200 --> 00:50:55,470
昨天，用JavaScript和CSS。

1136
00:50:55,470 --> 00:50:58,700
>> 什么是关于那些漂亮
三是，要运行它们，

1137
00:50:58,700 --> 00:51:01,981
正是您所需要的软件？

1138
00:51:01,981 --> 00:51:02,980
听众：Web浏览器。

1139
00:51:02,980 --> 00:51:04,229
DAVID J. MALAN：Web浏览器。

1140
00:51:04,229 --> 00:51:07,610
而最好的，我知道，所有这些
设备配有网络浏览器，

1141
00:51:07,610 --> 00:51:10,480
所以用户不必
安装一些特别的东西。

1142
00:51:10,480 --> 00:51:12,920
所以，你可以告诉你的
观众，你的客户，

1143
00:51:12,920 --> 00:51:16,590
进去acme.com的你
浏览器，你只

1144
00:51:16,590 --> 00:51:19,730
有一个基于Web体验
仍然充满屏幕，

1145
00:51:19,730 --> 00:51:25,100
但你不必担心所有的
这些费用和所有这种复杂性。

1146
00:51:25,100 --> 00:51:28,600
但肯定有是怎么回事
是一个catch这里，对不对？

1147
00:51:28,600 --> 00:51:31,740
特别是，如果我想指出
一对夫妇几年前，

1148
00:51:31,740 --> 00:51:35,700
的第一个版本
Facebook的移动应用程序

1149
00:51:35,700 --> 00:51:38,810
主要是一个HTML 5应用程序。

1150
00:51:38,810 --> 00:51:42,490
他们有更
最近，它重新实现

1151
00:51:42,490 --> 00:51:44,700
在他们的其他应用程序。

1152
00:51:44,700 --> 00:51:46,990
>> 那么，为什么你会不
马上要说，

1153
00:51:46,990 --> 00:51:49,190
嗯，很明显，我们要做到这一点？

1154
00:51:49,190 --> 00:51:51,560
什么可能的隐性成本是什么？

1155
00:51:51,560 --> 00:51:52,477
>> 听众：性能。

1156
00:51:52,477 --> 00:51:53,643
DAVID J. MALAN：性能？

1157
00:51:53,643 --> 00:51:54,567
你是什​​么意思？

1158
00:51:54,567 --> 00:52:01,040
>> 听众：本机应用程序
有更多的表现。

1159
00:52:01,040 --> 00:52:03,850
>> DAVID J. MALAN：所以这是
真的，因为有两个原因。

1160
00:52:03,850 --> 00:52:05,270
我们可以简单化的答案。

1161
00:52:05,270 --> 00:52:08,061
和召回我们的讨论
解释与编译语言。

1162
00:52:08,061 --> 00:52:12,030
这是HTML 5与它，只是为了
清晰，JavaScript--常用写

1163
00:52:12,030 --> 00:52:15,880
JS--和CSS都
解释型语言，

1164
00:52:15,880 --> 00:52:21,020
即使只有JavaScript
是一种编程语言。

1165
00:52:21,020 --> 00:52:25,820
>> 等与这些，其中一些这些
被编译，至少这些three--

1166
00:52:25,820 --> 00:52:29,990
Objective-C中，Java和C＃ - 这些，
从理论上讲，应该只是速度更快。

1167
00:52:29,990 --> 00:52:31,670
但还有另一种现实for--

1168
00:52:31,670 --> 00:52:32,440
>> 听众：功能？

1169
00:52:32,440 --> 00:52:32,830
>> DAVID J. MALAN：那是什么？

1170
00:52:32,830 --> 00:52:34,060
>> 听众：功能。

1171
00:52:34,060 --> 00:52:34,570
>> DAVID J. MALAN：功能？

1172
00:52:34,570 --> 00:52:35,070
怎么会这样？

1173
00:52:35,070 --> 00:52:37,305
听众：使用相机
关闭手机或东西。

1174
00:52:37,305 --> 00:52:41,471
您可以使用那些浏览器。

1175
00:52:41,471 --> 00:52:42,470
DAVID J. MALAN：没错。

1176
00:52:42,470 --> 00:52:43,011
他们sec--

1177
00:52:43,011 --> 00:52:45,034
听众：[听不清]

1178
00:52:45,034 --> 00:52:46,700
DAVID J. MALAN：这是个不错的选择。

1179
00:52:46,700 --> 00:52:49,230
有附带功能
与移动电话今天

1180
00:52:49,230 --> 00:52:53,840
都没有，在设计上，为安全
原因，Web浏览器访问。

1181
00:52:53,840 --> 00:52:56,410
因为这将是一种
一个令人毛骨悚然的事情，如果只是当

1182
00:52:56,410 --> 00:53:00,710
您访问google.com，或
cnn.com，或者任何website.com，

1183
00:53:00,710 --> 00:53:04,490
即该网站已关闭电源
你的相机，拿你的照片，

1184
00:53:04,490 --> 00:53:06,010
然后使用它。

1185
00:53:06,010 --> 00:53:09,280
但是，你不会想随机网站
您访问的第一次

1186
00:53:09,280 --> 00:53:10,690
有这种能力。

1187
00:53:10,690 --> 00:53:13,460
>> 还等什么手机
制造商通常做

1188
00:53:13,460 --> 00:53:17,230
是他们刚刚拒绝访问
该类型的信息

1189
00:53:17,230 --> 00:53:20,650
给浏览器，这意味着你
无法实现的摄像头。

1190
00:53:20,650 --> 00:53:24,180
你无法实现推送通知，
你得到你的屏幕上发出哔哔声

1191
00:53:24,180 --> 00:53:26,120
与短消息。

1192
00:53:26,120 --> 00:53:31,350
而事实上，即使GPS是唯一的一种
排序提供给Web浏览器。

1193
00:53:31,350 --> 00:53:34,140
如果你曾经，在笔记本电脑上
或在移动设备上，

1194
00:53:34,140 --> 00:53:38,770
拉升像或许真的
cnn.com，也是当地新闻台

1195
00:53:38,770 --> 00:53:43,890
往往要做到这一点，系统会提示您
经常用message-- foxnews.com

1196
00:53:43,890 --> 00:53:45,170
想知道你的位置。

1197
00:53:45,170 --> 00:53:46,610
批准或拒绝。

1198
00:53:46,610 --> 00:53:52,070
>> 那么，浏览器正试图访问
从您的手机GPS信息。

1199
00:53:52,070 --> 00:53:54,740
但幸运的是微软，
与苹果和谷歌

1200
00:53:54,740 --> 00:53:57,330
已经决定，感觉就像
这是一个很有用的情况下，

1201
00:53:57,330 --> 00:53:59,461
我们希望谷歌地图和
其他工具工作，

1202
00:53:59,461 --> 00:54:02,710
但我们不希望人们爬出来
只需使任何网站做到这一点。

1203
00:54:02,710 --> 00:54:05,934
因此，让我们有点相遇
中途并提示用户。

1204
00:54:05,934 --> 00:54:08,850
但是，这并不一定如此
与所有的硬件​​，象照相机

1205
00:54:08,850 --> 00:54:10,680
和推
通知等，

1206
00:54:10,680 --> 00:54:13,650
所以你可能需要
牺牲某些功能。

1207
00:54:13,650 --> 00:54:15,100
但性能也。

1208
00:54:15,100 --> 00:54:18,020
它是越来越少
时下明显，或许

1209
00:54:18,020 --> 00:54:22,400
作为LTE抓住并更快
在手机上网的速度，

1210
00:54:22,400 --> 00:54:24,110
不过您可以感觉的差异。

1211
00:54:24,110 --> 00:54:28,190
就像一个基于Web的应用程序
只是感觉速度较慢，通常情况下，

1212
00:54:28,190 --> 00:54:31,100
比本机应用程序，部分
因为一个基于网络的应用程序

1213
00:54:31,100 --> 00:54:32,680
顾名思义就是在互联网上。

1214
00:54:32,680 --> 00:54:35,610
它的谈话在网络上的服务器。

1215
00:54:35,610 --> 00:54:39,590
如果你的网络连接
慢，甚至滚动速度可能很缓慢。

1216
00:54:39,590 --> 00:54:43,710
>> 但是本机应用程序，你必须
已经预先downloaded--可能

1217
00:54:43,710 --> 00:54:45,680
当你在家里
从App Store，

1218
00:54:45,680 --> 00:54:47,900
或者你至少预先下载
它在其全部

1219
00:54:47,900 --> 00:54:49,640
此前，无论你
连接speed--

1220
00:54:49,640 --> 00:54:52,530
所以现在你把所有的
比特一般需要。

1221
00:54:52,530 --> 00:54:55,090
也许除了一些数据
来自一个服务器。

1222
00:54:55,090 --> 00:54:57,130
>> 因此，这些都是权衡这里。

1223
00:54:57,130 --> 00:54:59,980
有一种中间的
折衷，事实上。

1224
00:54:59,980 --> 00:55:00,907
而且我觉得你 - 

1225
00:55:00,907 --> 00:55:02,895
>> 听众：使用离线数据。

1226
00:55:02,895 --> 00:55:06,355
在本机应用程序，你可以[听不清]

1227
00:55:06,355 --> 00:55:07,480
DAVID J. MALAN：当然。

1228
00:55:07,480 --> 00:55:09,730
因此，有离线的问题，
这实在是烦人

1229
00:55:09,730 --> 00:55:13,120
如果你不能玩一些游戏或使用
一些软件仅仅是因为你

1230
00:55:13,120 --> 00:55:15,110
在一个地下室的地方
或在电梯。

1231
00:55:15,110 --> 00:55:18,700
原生应用程序是有弹性
与针对概率较高，

1232
00:55:18,700 --> 00:55:20,990
假设你拥有所有的
数据在本地需要。

1233
00:55:20,990 --> 00:55:22,900
>> 所以这里有一个第三个选项。

1234
00:55:22,900 --> 00:55:30,270
让我们绘制频谱
这里这里本机应用程序和Web应用程序。

1235
00:55:30,270 --> 00:55:32,460
什么是中间
东西called--

1236
00:55:32,460 --> 00:55:35,410
我想你可能有
用这个词之前，也许？

1237
00:55:35,410 --> 00:55:37,170
混合应用程序。

1238
00:55:37,170 --> 00:55:40,980
和作为字所暗示的，
这件事情在中间。

1239
00:55:40,980 --> 00:55:46,230
这是一种Web应用程序和
它是一种原生应用。

1240
00:55:46,230 --> 00:55:47,690
>> 而这是什么意思？

1241
00:55:47,690 --> 00:55:51,750
原来有frameworks--
使用从先前已经软件术语

1242
00:55:51,750 --> 00:55:55,860
其他人都写
对这些平台的每一个。

1243
00:55:55,860 --> 00:55:57,500
这些和另外的其它设备。

1244
00:55:57,500 --> 00:56:02,390
事实上，让我去的PhoneGap，
这是一种这样的框架，我

1245
00:56:02,390 --> 00:56:04,520
相信现在的Adobe拥有。

1246
00:56:04,520 --> 00:56:07,830
让我去入门。

1247
00:56:07,830 --> 00:56:09,430
让我们来看看。

1248
00:56:09,430 --> 00:56:12,450
看看我能看到的工具列表。

1249
00:56:12,450 --> 00:56:13,150
硬件。

1250
00:56:13,150 --> 00:56:15,845
入门。

1251
00:56:15,845 --> 00:56:17,570
PhoneGap的硬件。

1252
00:56:17,570 --> 00:56:18,672
>> 让我们来看看。

1253
00:56:18,672 --> 00:56:23,459
PhoneGap的硬件访问。

1254
00:56:23,459 --> 00:56:26,125
让我看看，如果我们可以找到一点
图表，他们曾经有过。

1255
00:56:26,125 --> 00:56:29,170

1256
00:56:29,170 --> 00:56:31,640
这是在其他网站上。

1257
00:56:31,640 --> 00:56:32,525
这是有用的？

1258
00:56:32,525 --> 00:56:33,030
没有。

1259
00:56:33,030 --> 00:56:36,330
这是要去那里浪费时间了。

1260
00:56:36,330 --> 00:56:40,185
PhoneGap的硬件。

1261
00:56:40,185 --> 00:56:40,685
设备。

1262
00:56:40,685 --> 00:56:45,190

1263
00:56:45,190 --> 00:56:48,030
设备API。

1264
00:56:48,030 --> 00:56:49,270
不，他们已经感动了。

1265
00:56:49,270 --> 00:56:50,070
>> PhoneGap的。

1266
00:56:50,070 --> 00:56:54,964
让我们在这最后一眼
看看我可以告诉你。

1267
00:56:54,964 --> 00:56:55,630
入门。

1268
00:56:55,630 --> 00:56:58,160

1269
00:56:58,160 --> 00:56:59,020
安装的PhoneGap。

1270
00:56:59,020 --> 00:57:02,310

1271
00:57:02,310 --> 00:57:03,270
安装移动应用程序。

1272
00:57:03,270 --> 00:57:04,320
来吧。

1273
00:57:04,320 --> 00:57:07,220

1274
00:57:07,220 --> 00:57:08,580
他们已经重组了一切。

1275
00:57:08,580 --> 00:57:09,750
好吧。

1276
00:57:09,750 --> 00:57:11,370
哦，没事。

1277
00:57:11,370 --> 00:57:12,550
好了，我们开始吧。

1278
00:57:12,550 --> 00:57:16,130
这是不是所有的启发，但
这就是我是那种寻找。

1279
00:57:16,130 --> 00:57:20,940
>> 所以PhoneGap的是一个框架，你
可以免费下载，让你

1280
00:57:20,940 --> 00:57:22,750
一些启动代码，从根本上。

1281
00:57:22,750 --> 00:57:26,600
所以一些代码，他们写
这并没有做太多的事情。

1282
00:57:26,600 --> 00:57:29,610
但它给你
本质上是等效

1283
00:57:29,610 --> 00:57:34,910
那样只会把一个应用程序
在用户的屏幕上大的矩形。

1284
00:57:34,910 --> 00:57:38,040
它没有把地址栏，像
浏览器中，并没有把一个地址。

1285
00:57:38,040 --> 00:57:39,650
它只是把一个大的矩形。

1286
00:57:39,650 --> 00:57:43,230
而在配置这个大
矩形，罩下方，

1287
00:57:43,230 --> 00:57:50,780
实际上去acme.com，或者
m.acme.com，对于mobile.acme.com，

1288
00:57:50,780 --> 00:57:52,910
但用户不知道
他们在该地址。

1289
00:57:52,910 --> 00:57:55,520
他们所看到的是
网页的内容。

1290
00:57:55,520 --> 00:57:59,822
>> 但是，什么是这个美好幸福
混合应用程序是什么的PhoneGap

1291
00:57:59,822 --> 00:58:03,030
和其他公司给你的
他们给你的代码一点点

1292
00:58:03,030 --> 00:58:05,760
在Objective-C或斯威夫特，或
代码Java中的一点点，

1293
00:58:05,760 --> 00:58:08,320
或代码一点点
在C＃中，而且基本上，

1294
00:58:08,320 --> 00:58:12,990
你必须提供最低限度是的
您的基于Web的应用程序的地址。

1295
00:58:12,990 --> 00:58:15,750
然后你这个捆绑
一起和你

1296
00:58:15,750 --> 00:58:20,670
有它要么访问
通过互联网的网站，

1297
00:58:20,670 --> 00:58:24,060
或者你甚至缓存在本地
复制应用程序中，

1298
00:58:24,060 --> 00:58:28,690
然后保存您的应用程序
在iPhone格式，Android手机

1299
00:58:28,690 --> 00:58:32,030
格式，表面格式，或
任何数量的其它设备。

1300
00:58:32,030 --> 00:58:34,960
>> 您上传的每个版本
对谷歌Play商店，

1301
00:58:34,960 --> 00:58:37,690
到App Store，以
Windows应用商店，等等。

1302
00:58:37,690 --> 00:58:41,570
而现在，你可以有你的所有
观众下载一个真正的本机应用程序，

1303
00:58:41,570 --> 00:58:44,250
尽管大部分的代码是
别人写的，

1304
00:58:44,250 --> 00:58:49,090
但本机应用程序的所有内容
从何而来，通常情况下，您自己的网站。

1305
00:58:49,090 --> 00:58:53,950
所以，你继续编写网站
在HTML，JavaScript和CSS。

1306
00:58:53,950 --> 00:58:56,400
>> 那么，为什么这些模糊行？

1307
00:58:56,400 --> 00:59:00,240
为什么混合应用程序
这就是那种人，而且还

1308
00:59:00,240 --> 00:59:02,569
一种网络为基础？

1309
00:59:02,569 --> 00:59:04,610
什么是整点
添加这种复杂性？

1310
00:59:04,610 --> 00:59:07,180
我的意思是，即使还在，刚刚从
通过这个页面一瞧，

1311
00:59:07,180 --> 00:59:11,790
入门指南感觉
它有一大堆的步骤我

1312
00:59:11,790 --> 00:59:13,514
做我can--前

1313
00:59:13,514 --> 00:59:14,430
听众：可重用性？

1314
00:59:14,430 --> 00:59:14,960
DAVID J. MALAN：可重用性？

1315
00:59:14,960 --> 00:59:15,618
你什么意思？

1316
00:59:15,618 --> 00:59:16,826
>> 听众：源代码。

1317
00:59:16,826 --> 00:59:19,438
所以相同的代码将运行在
所有不同的平台。

1318
00:59:19,438 --> 00:59:20,313
戴维·马兰：是的。

1319
00:59:20,313 --> 00:59:21,188
听众：[听不清]

1320
00:59:21,188 --> 00:59:23,200

1321
00:59:23,200 --> 00:59:24,200
DAVID J. MALAN：完美。

1322
00:59:24,200 --> 00:59:26,930
如果时间很紧，如果你
没有很多developers--

1323
00:59:26,930 --> 00:59:28,900
也许你有一个开发人员
他或她肯定

1324
00:59:28,900 --> 00:59:31,050
不知道所有这些
environments--肯定不会好，

1325
00:59:31,050 --> 00:59:33,341
当然更不能计划
同时在所有三个

1326
00:59:33,341 --> 00:59:35,970
和船舶三款产品
时间允许的，

1327
00:59:35,970 --> 00:59:40,360
能不能让他（她）的一切建设
在HTML和JavaScript和CSS，

1328
00:59:40,360 --> 00:59:43,260
然后学习一个小小的
有关本机应用程序位，

1329
00:59:43,260 --> 00:59:45,930
刚够下载
这样的框架下，

1330
00:59:45,930 --> 00:59:48,750
然后到你的产品上传到
所有的各种应用商店

1331
00:59:48,750 --> 00:59:51,700
所以，你现在有
本机应用程序。

1332
00:59:51,700 --> 00:59:54,090
>> 所以这似乎是一个双赢的，
但同样，要清楚，

1333
00:59:54,090 --> 00:59:56,540
是什么的电位
成本还是陷阱？

1334
00:59:56,540 --> 01:00:00,292

1335
01:00:00,292 --> 01:00:01,209
>> 听众：性能？

1336
01:00:01,209 --> 01:00:02,083
戴维·马兰：是的。

1337
01:00:02,083 --> 01:00:02,959
性能。

1338
01:00:02,959 --> 01:00:04,250
很难口头描述。

1339
01:00:04,250 --> 01:00:07,590
所以，如果你只是把上
信仰一个移动应用程序，

1340
01:00:07,590 --> 01:00:11,430
一个Web应用程序将
通常执行更慢。

1341
01:00:11,430 --> 01:00:16,500
它可能看起来不完全正确的，因为
在iPhone和Android手机，

1342
01:00:16,500 --> 01:00:19,210
和Windows设备，有
总是一种默认的样子

1343
01:00:19,210 --> 01:00:21,780
感觉所有的
按钮和菜单。

1344
01:00:21,780 --> 01:00:25,160
>> 而公司在网络，可以试试
近似​​的美学

1345
01:00:25,160 --> 01:00:28,329
像引导库，
但user--精明user--

1346
01:00:28,329 --> 01:00:30,620
是要知道
有什么地方不太对劲在这里。

1347
01:00:30,620 --> 01:00:32,510
这很好，也许
这不是什么大不了的事。

1348
01:00:32,510 --> 01:00:35,500
但是性能问题
绝对是一个大问题。

1349
01:00:35,500 --> 01:00:39,400
本机应用程序将趋向于刚
更加敏感，因此

1350
01:00:39,400 --> 01:00:39,946
更好。

1351
01:00:39,946 --> 01:00:42,070
所以，什么话可能是
两全其美的？

1352
01:00:42,070 --> 01:00:44,584
如果你是一个特别小
公司还是一个小团体，

1353
01:00:44,584 --> 01:00:47,000
你没有的资源
并行开发的应用程序

1354
01:00:47,000 --> 01:00:50,480
在所有三个平台，并坦率地说，
感觉这是一个不好的想法

1355
01:00:50,480 --> 01:00:53,526
因为如果你滚出去，上
所有这三个同时实现，

1356
01:00:53,526 --> 01:00:56,400
我们应该增加了一些功能
或者做一些不同的东西，现在

1357
01:00:56,400 --> 01:00:59,530
你要修复它在
三个地方，没有之一。

1358
01:00:59,530 --> 01:01:02,390
什么是可能的最佳
这里的战略整体，

1359
01:01:02,390 --> 01:01:04,130
如果资源和时间是紧？

1360
01:01:04,130 --> 01:01:06,420
>> 听众：只要做到这一点在iOS。

1361
01:01:06,420 --> 01:01:08,390
>> DAVID J. MALAN：这是没有道理的。

1362
01:01:08,390 --> 01:01:10,670
的iPhone，至少在
美国，是超人气。

1363
01:01:10,670 --> 01:01:13,820
Android的似乎仍有优势
的市场份额，全球的整体。

1364
01:01:13,820 --> 01:01:16,740
所以，你是不是
一定代表

1365
01:01:16,740 --> 01:01:19,210
本周全球的整体。

1366
01:01:19,210 --> 01:01:21,180
但是，这绝对是一项决定。

1367
01:01:21,180 --> 01:01:23,620
我的意思是，在校园里我在这里
觉得有些残酷的数

1368
01:01:23,620 --> 01:01:26,600
或者本科生的比例
拥有iPhone手机，而不是Android手机。

1369
01:01:26,600 --> 01:01:28,490
但在国外，它是一种相反的。

1370
01:01:28,490 --> 01:01:30,040
所以你决定根据你的听众。

1371
01:01:30,040 --> 01:01:31,990
你怎么知道你的观众了？

1372
01:01:31,990 --> 01:01:34,080
>> 好了，我们昨天学了一招。

1373
01:01:34,080 --> 01:01:35,060
你可以问问他们。

1374
01:01:35,060 --> 01:01:37,910
如果你有一个俘虏观众
你可以向他们发送调查表。

1375
01:01:37,910 --> 01:01:39,172
或者你可以做什么呢？

1376
01:01:39,172 --> 01:01:40,076
>> 听众：谷歌Analytics（分析）？

1377
01:01:40,076 --> 01:01:40,680
>> DAVID J. MALAN：那是什么？

1378
01:01:40,680 --> 01:01:41,876
>> 听众：谷歌分析。

1379
01:01:41,876 --> 01:01:43,250
DAVID J. MALAN：谷歌分析。

1380
01:01:43,250 --> 01:01:43,750
是啊。

1381
01:01:43,750 --> 01:01:46,970
甚至更多样的技术，只是
看看你自己的Web服务器日志。

1382
01:01:46,970 --> 01:01:49,100
由于发生了什么
每次浏览器，

1383
01:01:49,100 --> 01:01:51,880
无论是笔记本电脑，台式机或
手机访问您的网站？

1384
01:01:51,880 --> 01:01:56,847
他们发送的HTTP标头节目
你他们使用的是什么浏览器和操作系统。

1385
01:01:56,847 --> 01:02:00,180
因此可以推断，以高概率，
你的人口正在使用的方式

1386
01:02:00,180 --> 01:02:01,410
再调整。

1387
01:02:01,410 --> 01:02:03,030
>> 因此，假设这是不可接受的。

1388
01:02:03,030 --> 01:02:07,760
这就是那种不好的业务，如果
Android用户可以不买我们的小部件。

1389
01:02:07,760 --> 01:02:10,942
>> 听众：无论你是
要充电或不？

1390
01:02:10,942 --> 01:02:12,900
DAVID J. MALAN：是否
你要收费吗？

1391
01:02:12,900 --> 01:02:14,900
那么OK，你得到你所支付的。

1392
01:02:14,900 --> 01:02:18,400
>> 听众：无论你的应用是要去
是免费的还是它的gonna--

1393
01:02:18,400 --> 01:02:19,530
>> DAVID J. MALAN：OK。

1394
01:02:19,530 --> 01:02:21,920
因此，也许你可以收回
成本的方式，or--？

1395
01:02:21,920 --> 01:02:26,195
>> 听众：我读了研究一旦说
更多苹果用户付费应用versus--

1396
01:02:26,195 --> 01:02:28,320
DAVID J. MALAN：这是真的
因为他们已经

1397
01:02:28,320 --> 01:02:29,640
付出更多的他们的设备。

1398
01:02:29,640 --> 01:02:31,295
所以，不是没有道理的假设。

1399
01:02:31,295 --> 01:02:32,170
>> 听众：[听不清]

1400
01:02:32,170 --> 01:02:34,439

1401
01:02:34,439 --> 01:02:35,230
DAVID J. MALAN：OK。

1402
01:02:35,230 --> 01:02:38,667
所以，如果他们更愿意付出，
然后与Android用户地狱。

1403
01:02:38,667 --> 01:02:40,500
他们不打算
反正付钱给我们任何东西。

1404
01:02:40,500 --> 01:02:43,499
我们不妨关注我们的优先事项，
至少在最初的几个月

1405
01:02:43,499 --> 01:02:44,810
或一年，在iOS。

1406
01:02:44,810 --> 01:02:46,240
完全合理的。

1407
01:02:46,240 --> 01:02:48,558
什么是更具包容性
战略比？

1408
01:02:48,558 --> 01:02:53,740

1409
01:02:53,740 --> 01:02:54,960
Maybe--那是什么？

1410
01:02:54,960 --> 01:02:57,040
>> 听众：[听不清]

1411
01:02:57,040 --> 01:03:00,142
>> DAVID J. MALAN：更expensive--
所以也许投入更多in--下去。

1412
01:03:00,142 --> 01:03:00,767
听众：是的。

1413
01:03:00,767 --> 01:03:02,050
只是一个移动网站。

1414
01:03:02,050 --> 01:03:03,966
>> DAVID J. MALAN：所以，做一个
移动网站，而不是

1415
01:03:03,966 --> 01:03:05,440
甚至担心这种复杂性。

1416
01:03:05,440 --> 01:03:07,970
或者，也许一个合理的策略，
甚至Facebook的了，

1417
01:03:07,970 --> 01:03:10,890
开始是与混合动力
应用程序，因为它不是

1418
01:03:10,890 --> 01:03:13,582
更难以做到这一点比此。

1419
01:03:13,582 --> 01:03:16,040
你只需要读一些
文件，并找出如何

1420
01:03:16,040 --> 01:03:17,480
的东西上传到App Store。

1421
01:03:17,480 --> 01:03:19,670
因此，也许你开始
此，这样，在第一天，

1422
01:03:19,670 --> 01:03:21,112
可以支持所有的用户。

1423
01:03:21,112 --> 01:03:23,570
然后，就像Facebook的
和其他公司都做了，

1424
01:03:23,570 --> 01:03:25,330
当你有足够的资源，
你能找到人，

1425
01:03:25,330 --> 01:03:27,660
你为什么不重新实现
就在iPhone应用程序。

1426
01:03:27,660 --> 01:03:31,460
你还有每个人的东西，
即使它是一个劣质的经验

1427
01:03:31,460 --> 01:03:33,330
或许，与混合应用。

1428
01:03:33,330 --> 01:03:36,770
但是你可以逐渐铺开
更换你的短期

1429
01:03:36,770 --> 01:03:40,280
与混合应用的措施
您更多的本地应用程序。

1430
01:03:40,280 --> 01:03:44,090
>> 听众：但随着混合应用程序，你
将有机会获得移动功能？

1431
01:03:44,090 --> 01:03:45,440
>> DAVID J. MALAN：不一定。

1432
01:03:45,440 --> 01:03:47,810
因此，也许你做一个
有意识的早期决定，

1433
01:03:47,810 --> 01:03:51,930
你只能在上传照片
对于Facebook原生iPhone应用程序，

1434
01:03:51,930 --> 01:03:56,060
但不能在Android应用程序，
最初，例如。

1435
01:03:56,060 --> 01:04:00,600
这是一个有点善意的谎言，因为
Web应用程序有更多的限制

1436
01:04:00,600 --> 01:04:03,620
比混合应用事实
出，如果我们阅读文档

1437
01:04:03,620 --> 01:04:07,260
为PhoneGap的事情就是这样吧，
人们已经想出了各种办法

1438
01:04:07,260 --> 01:04:11,110
给基于Web的应用
访问摄像头，

1439
01:04:11,110 --> 01:04:13,310
只要你使用
混合应用程序。

1440
01:04:13,310 --> 01:04:14,214
>> 这是如何工作的？

1441
01:04:14,214 --> 01:04:16,130
因为混合
应用，根据定义，

1442
01:04:16,130 --> 01:04:19,600
有一点在Objective-C代码，
和斯威夫特，以及Java或C＃，

1443
01:04:19,600 --> 01:04:20,920
它可以访问硬件。

1444
01:04:20,920 --> 01:04:24,590
不一定一切，
但它很可能会

1445
01:04:24,590 --> 01:04:27,310
是你有情况
足够的访问让相机，

1446
01:04:27,310 --> 01:04:32,960
即使是针对Android平台上，
例如，在人为的例子。

1447
01:04:32,960 --> 01:04:35,515
>> 其他问题吗？

1448
01:04:35,515 --> 01:04:36,279
好吧。

1449
01:04:36,279 --> 01:04:38,070
我们为什么不把我们的
休息15分钟在这里。

1450
01:04:38,070 --> 01:04:44,060
我们将在三个恢复与最后的
看看网络编程，数据库，

1451
01:04:44,060 --> 01:04:45,910
和Javascript。

1452
01:04:45,910 --> 01:04:48,877