1
00:00:00,000 --> 00:00:02,500
[Powered by Google Translate] [讲座] [Web开发：从理念到实践]

2
00:00:02,500 --> 00:00:04,200
[本库恩] [比利Janitsch] [哈佛大学]

3
00:00:04,200 --> 00:00:07,250
[这是CS50] [CS50.TV]

4
00:00:07,250 --> 00:00:10,840
[比利]你好，我叫比利，这是本。 >> [奔]你好。

5
00:00:10,840 --> 00:00:12,840
我们今天要谈论的Web开发。

6
00:00:12,840 --> 00:00:14,840
[WEBDEV] [比利Janitsch和本·库恩]

7
00:00:14,840 --> 00:00:16,840
关于我们位在前。

8
00:00:16,840 --> 00:00:19,590
本是排序的后端的家伙。他做事情的工作。

9
00:00:19,590 --> 00:00:21,870
然后我进去，让他们漂亮。

10
00:00:21,870 --> 00:00:26,610
我主要是参与更前端的布局设计类的东西，

11
00:00:26,610 --> 00:00:31,260
和Ben，而另一方面，知道自己在做什么，所以他的作品在后端的东西。

12
00:00:31,260 --> 00:00:34,050
我们一起做了几件事情。

13
00:00:34,050 --> 00:00:38,710
举例来说，去年我们曾在Gimblium这是一个网络游戏开发工作室。

14
00:00:38,710 --> 00:00:40,400
这是我们的最终类项目，

15
00:00:40,400 --> 00:00:42,780
从那时起，我们已经取得了哈佛大学类

16
00:00:42,780 --> 00:00:47,860
这是用于浏览和购物的课程在哈佛大学一个在线的框架。

17
00:00:47,860 --> 00:00:53,180
>> 我们要开始这个想法为我们的网站。

18
00:00:53,180 --> 00:00:57,480
我们将让Facebook，但对于猫。

19
00:00:57,480 --> 00:00:59,520
在你真正做这个网站，

20
00:00:59,520 --> 00:01:02,520
不要让这个网站，因为它不是很好，但是我们将使用它作为一个框架

21
00:01:02,520 --> 00:01:05,349
并通过我们怎样把这种想法的过程

22
00:01:05,349 --> 00:01:07,450
并把它变成一个真正的网站，我们可以使用。

23
00:01:07,450 --> 00:01:11,940
我们将通过打破网站下载下来的开始。

24
00:01:11,940 --> 00:01:13,190
就像你一直在做的CS50，

25
00:01:13,190 --> 00:01:17,360
你要想想什么是进入这个网站上的实际组件。

26
00:01:17,360 --> 00:01:21,290
基本上是从一个想法，就是那种一个抽象的概念，把它

27
00:01:21,290 --> 00:01:23,590
成为一个真正的，实实在在的东西，你可以做。

28
00:01:23,590 --> 00:01:25,910
我们通过问一些问题开始。

29
00:01:25,910 --> 00:01:28,070
这是什么网站？我们为什么做呢？

30
00:01:28,070 --> 00:01:30,670
什么是它会被用来做什么？诸如此类的事情。

31
00:01:30,670 --> 00:01:33,660
在Facebook的猫的情况下，

32
00:01:33,660 --> 00:01:37,730
我们基本上希望有一个网站，让猫的社交网络与对方。

33
00:01:37,730 --> 00:01:41,260
的想法是，他们可以张贴对方的墙壁上，

34
00:01:41,260 --> 00:01:43,510
他们可以提出意见，诸如此类的事情。

35
00:01:43,510 --> 00:01:46,720
而这也正是我们进入的功能组件。

36
00:01:46,720 --> 00:01:51,270
我们现在有这样的框架 - 我们的用户配置文件，

37
00:01:51,270 --> 00:01:53,990
我们有意见，我们可以发布。

38
00:01:53,990 --> 00:01:57,390
也许有一天我们会进水的喜好和诸如此类的事情。

39
00:01:57,390 --> 00:02:00,410
样的，我们要优先考虑这些特性去英寸

40
00:02:00,410 --> 00:02:03,340
我们想说的一样，好吧，这真的很重要，每个人都有一个配置文件

41
00:02:03,340 --> 00:02:06,440
而且每个人都可以发表各自的墙壁上。

42
00:02:06,440 --> 00:02:08,509
次要的是，意见将是很好。

43
00:02:08,509 --> 00:02:10,180
也许以后我们会进水喜欢。

44
00:02:10,180 --> 00:02:13,700
所以，你想拥有一个什么样的基础到项目的想法

45
00:02:13,700 --> 00:02:17,260
这有什么样的，可以在以后应用于更广泛的功能。

46
00:02:17,260 --> 00:02:20,870
你要排序的有一个特定的列表记，

47
00:02:20,870 --> 00:02:24,090
但你开始这个项目不会是你完成的项目。

48
00:02:24,090 --> 00:02:27,100
换句话说，事情会你正在开发的网站，而改变，

49
00:02:27,100 --> 00:02:30,090
并且要留有余地的。

50
00:02:30,090 --> 00:02:34,470
我把它交给奔谁去谈谈结构。

51
00:02:34,470 --> 00:02:39,610
>> [奔]我要谈论Web开发的更多技术方面。

52
00:02:39,610 --> 00:02:42,370
让我们只是去了一些基础知识第一。

53
00:02:42,370 --> 00:02:45,730
当你在做一个web应用程序，

54
00:02:45,730 --> 00:02:50,470
，你将不得不具备的主要分工是

55
00:02:50,470 --> 00:02:52,700
你将有一些东西在客户端怎么回事 - 

56
00:02:52,700 --> 00:02:56,700
那就是，你的浏览器代码需要从网站

57
00:02:56,700 --> 00:03:01,910
和JavaScript，HTML，CSS的东西。

58
00:03:01,910 --> 00:03:04,490
这是所有客户端上。

59
00:03:04,490 --> 00:03:08,680
你将有一个在服务器端运行其他代码

60
00:03:08,680 --> 00:03:10,770
它记录所有的人在发送给您的数据，

61
00:03:10,770 --> 00:03:15,060
决定谁给什么，这样的东西。

62
00:03:15,060 --> 00:03:20,380
这只是一些术语，让你们都熟悉我们正在谈论的。

63
00:03:20,380 --> 00:03:28,600
除此之外部门它的好，想着你的Web应用程序中的条款

64
00:03:28,600 --> 00:03:32,500
一对夫妇不同的分量。

65
00:03:32,500 --> 00:03:35,270
当你在做web开发

66
00:03:35,270 --> 00:03:41,710
那你应该总是尝试做的事情之一是降低复杂性。

67
00:03:41,710 --> 00:03:45,710
更复杂的代码是更多的机会存在，使臭虫，

68
00:03:45,710 --> 00:03:47,710
就越难以后更改。

69
00:03:47,710 --> 00:03:50,140
因此，如果你能打破你的应用程序进入一些不同的功能区

70
00:03:50,140 --> 00:03:57,640
即会 - 你可以减少跨区域的通信量的排序 - 

71
00:03:57,640 --> 00:04:03,530
这将帮助你很多，从长远来看减少错误方面。

72
00:04:03,530 --> 00:04:07,950
>> 要具体，通常人们瓜分了一个Web应用程序到 - 

73
00:04:07,950 --> 00:04:13,190
这是种时髦词了，但他们仍然有用。

74
00:04:13,190 --> 00:04:17,940
你可能听说过人们谈论的模型，视图和控制器。

75
00:04:17,940 --> 00:04:23,210
模型是您的应用程序将要处理的实际数据。

76
00:04:23,210 --> 00:04:28,260
例如，在你的猫的Facebook，你的模型将是 - 

77
00:04:28,260 --> 00:04:35,340
你有一个模型一样的帖子，和一个模型为用户配置文件，这样的东西。

78
00:04:35,340 --> 00:04:41,090
您的意见是你如何展示数据给用户。

79
00:04:41,090 --> 00:04:46,660
你可能有1视图寻找一个岗位，所有的评论

80
00:04:46,660 --> 00:04:51,720
和不同的观点对你的墙具有所有文章列表

81
00:04:51,720 --> 00:04:57,170
定向到你，并有不同的看法为您订阅 - 类似的东西。

82
00:04:57,170 --> 00:05:00,610
最后，你有这是基本的控制器，当人们发送给您的帖子

83
00:05:00,610 --> 00:05:03,310
和您更新您的后端系统，

84
00:05:03,310 --> 00:05:06,400
你增加了一堆柜台，和什么的。

85
00:05:06,400 --> 00:05:07,860
这些都是你的控制器。

86
00:05:07,860 --> 00:05:11,030
>> 我将要讨论大部分是关于模型。

87
00:05:11,030 --> 00:05:14,030
意见在技术上并不困难，问题是多与他们的设计

88
00:05:14,030 --> 00:05:22,040
控制器将要具体到任何你正在设计。

89
00:05:22,040 --> 00:05:25,220
但也有一些可以使用相当普遍的技术

90
00:05:25,220 --> 00:05:30,220
让你的模型更好，更容易与我认为是非常有益的工作。

91
00:05:30,220 --> 00:05:35,860
这主要是将是如何处理你的web应用程序的数据在一个不错的方式。

92
00:05:35,860 --> 00:05:40,420
配车型的主要问题

93
00:05:40,420 --> 00:05:44,540
是他们生活的客户端和服务器上，你必须弄清楚

94
00:05:44,540 --> 00:05:51,170
一）如何让他们 - 所有相关的人 - 从服务器到客户端，

95
00:05:51,170 --> 00:05:53,440
和b）如何使它们保持同步。

96
00:05:53,440 --> 00:05:58,700
你的用户会想要做一些更新。

97
00:05:58,700 --> 00:06:00,470
他们将要进行新的帖子。

98
00:06:00,470 --> 00:06:04,800
他们将要喜欢的事情和东西，如果你有喜​​欢。

99
00:06:04,800 --> 00:06:11,490
这些都是处理模型的主要技术难题。

100
00:06:11,490 --> 00:06:15,680
那你会想要问自己的第一件事就是

101
00:06:15,680 --> 00:06:18,420
什么样的数据去在这个模型中，并且我们要什么样的查询到想要做的 - 

102
00:06:18,420 --> 00:06:24,290
也就是说，我们如何来看待这些模型？

103
00:06:24,290 --> 00:06:26,940
为了您的猫的Facebook为例，

104
00:06:26,940 --> 00:06:31,520
您的文章将不得不与它相关联的作者，

105
00:06:31,520 --> 00:06:35,660
有些墙后的文本，以及壁后的收件人。

106
00:06:35,660 --> 00:06:38,470
然后你可能要质疑，在一堆不同的方式。

107
00:06:38,470 --> 00:06:42,220
你想看看它通过谁写的帖子，

108
00:06:42,220 --> 00:06:46,620
通过谁收到的发布，也许通过他们发布的日期。

109
00:06:46,620 --> 00:06:50,340
但如果你打算按日期做，那么你必须到另一个字段添加到您的文章

110
00:06:50,340 --> 00:06:52,490
当它实际上是发布。

111
00:06:52,490 --> 00:07:00,220
这2个因素 - 你想要什么样的数据使用，你怎么想观看 - 

112
00:07:00,220 --> 00:07:04,200
你应该想想他们首先是因为他们互相依赖，

113
00:07:04,200 --> 00:07:08,030
而这将更加难以将它们以后。

114
00:07:08,030 --> 00:07:12,750
>> 还有一些其他方面的考虑。

115
00:07:12,750 --> 00:07:17,540
当你思考你如何处理在服务器上的模型

116
00:07:17,540 --> 00:07:20,540
你想看看什么是 - 

117
00:07:20,540 --> 00:07:27,440
基本上你想使服务器尽可能的简单。

118
00:07:29,440 --> 00:07:35,500
在客户端做的东西一般是，如果你能完全做到这一点的客户端上要快得多

119
00:07:35,500 --> 00:07:38,230
没有做任何形式的网络请求。

120
00:07:38,230 --> 00:07:47,860
我们的想法是做尽可能多的疑问，你可以在客户端上。

121
00:07:47,860 --> 00:07:51,560
与唯一的问题

122
00:07:51,560 --> 00:07:54,160
是，如果您要求您的所有数据在开始

123
00:07:54,160 --> 00:07:57,160
那么那将需要很长的时间来加载。

124
00:07:57,160 --> 00:08:02,290
所以，这个想法是要在有足够数据在客户端之间的折中

125
00:08:02,290 --> 00:08:07,640
你可以做大部分工作，但还有不只是获取面面俱到

126
00:08:07,640 --> 00:08:09,710
使您获得真正慢加载时间在开始。

127
00:08:09,710 --> 00:08:12,610
例如，你的猫的数据

128
00:08:12,610 --> 00:08:20,340
你可能会想取一串最近墙岗位。

129
00:08:20,340 --> 00:08:23,790
你不会想获取所有的人，因为这可以回去了几年。

130
00:08:23,790 --> 00:08:25,470
但你不想要获取它们一次一个

131
00:08:25,470 --> 00:08:28,740
因为这会引入大量的网络开销。

132
00:08:28,740 --> 00:08:33,620
>> 它往往相当困难 - 一旦你有一个数据库运行 - 

133
00:08:33,620 --> 00:08:37,210
它往往非常难以改变的你在它什么样的数据 - 

134
00:08:37,210 --> 00:08:40,510
也就是说，添加一个新的数据库列或某事 - 

135
00:08:40,510 --> 00:08:43,510
所以一个好的策略实际上​​只是保持你的很多数据在文本BLOB  - 

136
00:08:43,510 --> 00:08:53,880
一个JSON的blob  -  JSON是JavaScript的对象符号 - 

137
00:08:53,880 --> 00:08:58,330
究其原因，是非常有用的，因为你可以添加新的属性

138
00:08:58,330 --> 00:09:01,920
所有这些斑点的JSON不改变你的数据库。

139
00:09:01,920 --> 00:09:06,860
唯一的缺点是，如果你有一堆领域

140
00:09:06,860 --> 00:09:09,890
那你后来加入 - 就像隐藏在JSON一滴 - 

141
00:09:09,890 --> 00:09:12,850
那么它很难在数据库中查询它们。

142
00:09:12,850 --> 00:09:17,690
举例来说，如果你以后 - 如果你有你的模型后，我们前面讨论过的

143
00:09:17,690 --> 00:09:25,380
只有作者，收件人和文本 - 

144
00:09:25,380 --> 00:09:29,000
你也可以有一个JSON的blob，然后，如果你以后想添加一个日期字段

145
00:09:29,000 --> 00:09:31,000
你不会有改变你的数据库。

146
00:09:31,000 --> 00:09:36,140
你可以只添加日期以所有文本字段。

147
00:09:36,140 --> 00:09:39,640
然后你就可以看看那些在客户端，

148
00:09:39,640 --> 00:09:42,430
但你不能够查询它们在服务器端

149
00:09:42,430 --> 00:09:44,430
因为它是隐藏的文字里。

150
00:09:44,430 --> 00:09:49,920
>> 要思考的另一个问题

151
00:09:49,920 --> 00:09:52,400
是如何你的客户和你的服务器要沟通。

152
00:09:52,400 --> 00:09:56,040
你通常希望保持这种尽可能简单。

153
00:09:56,040 --> 00:10:02,230
你可以有这样一个get  - 我 - 这个数据请求，

154
00:10:02,230 --> 00:10:09,140
一个建立 - 一个全新的对象的东西，以及更新，一个历史的对象的要求。

155
00:10:09,140 --> 00:10:12,930
而这些都将是一个服务器上的不同的URL，你 - 

156
00:10:12,930 --> 00:10:20,030
浏览器会 - 你可以使用AJAX请求所有这些

157
00:10:20,030 --> 00:10:24,000
而无论是接收或交的数据。

158
00:10:24,000 --> 00:10:26,600
再次，我们的猫的Facebook为例，

159
00:10:26,600 --> 00:10:32,350
你可以有这个URL来获得一个单独的职位，

160
00:10:32,350 --> 00:10:39,750
而且你已经有了一个URL来创建一个新的墙后

161
00:10:39,750 --> 00:10:45,670
也许您上传个人照片，这样的东西的URL。

162
00:10:45,670 --> 00:10:51,730
但同样，这是预先取得大部分数据，这样你就不必继续

163
00:10:51,730 --> 00:10:53,360
使得网络请求。

164
00:10:53,360 --> 00:10:59,030
出于这个原因，你可能不希望有一个帖子说个人get请求，

165
00:10:59,030 --> 00:11:03,210
而是你只是想在整面墙1 get请求。

166
00:11:03,210 --> 00:11:06,110
然后，如果你想取得一个平衡，因为 - 

167
00:11:06,110 --> 00:11:10,970
这也将取决于您的应用程序。

168
00:11:10,970 --> 00:11:13,430
因为如果你期待的人只有10或20墙职位

169
00:11:13,430 --> 00:11:15,430
这将是罚款。

170
00:11:15,430 --> 00:11:17,390
但是，如果你希望他们将有成千上万的那么请求将花费太长时间，

171
00:11:17,390 --> 00:11:23,580
所以你可能要添加一个获取 - 所有职位 - 因为参数。

172
00:11:23,580 --> 00:11:26,580
>> 对于所有这些你可能会想同步您的数据以JSON  - 

173
00:11:26,580 --> 00:11:29,260
JavaScript对象表示法。

174
00:11:29,260 --> 00:11:34,600
几乎每一个语言处理JSON的非常好。

175
00:11:34,600 --> 00:11:40,880
jQuery有这个漂亮的getJSON函数，会做所有的辛勤工作的你。

176
00:11:40,880 --> 00:11:47,390
并在PHP中也是非常不错的JSON通信功能。

177
00:11:47,390 --> 00:11:52,660
所以，这可能是用于发送您的模型来回的最佳格式。

178
00:11:52,660 --> 00:11:56,570
>> 由于我们已经谈到，到目前为止的例子，

179
00:11:56,570 --> 00:12:00,520
这里是你的猫的Facebook应用程序的示例流程。

180
00:12:00,520 --> 00:12:07,760
它与您的浏览器请求的基础网站的网址开始起飞。

181
00:12:07,760 --> 00:12:15,470
该服务器可能会发送过来的静态HTML和一些JavaScript和CSS。

182
00:12:15,470 --> 00:12:19,170
它通常最好不要在服务器上做任何渲染。

183
00:12:19,170 --> 00:12:23,370
您可能不希望 - 

184
00:12:23,370 --> 00:12:28,360
什么样的服务器是不是做有下降的墙职位列表

185
00:12:28,360 --> 00:12:31,120
并产生一些HTML为每一个和发送该结束了。

186
00:12:31,120 --> 00:12:34,960
它通常是最好做在客户端上，否则

187
00:12:34,960 --> 00:12:38,580
你要重新绘制的东西每一次，你必须做出一个服务器请求。

188
00:12:38,580 --> 00:12:42,450
而这很快为您提供了大量的开销。

189
00:12:42,450 --> 00:12:47,430
它通常是最好的只是船降下静态HTML

190
00:12:47,430 --> 00:12:50,660
然后JavaScript和CSS，会做在客户端的呈现。

191
00:12:50,660 --> 00:12:56,750
只要这些东西进来，

192
00:12:56,750 --> 00:13:03,500
那么你可以有 - 在JavaScript  - 你能为墙面做数据的请求

193
00:13:03,500 --> 00:13:08,740
之类的东西，之后，服务器基本上只是在做数据库查询

194
00:13:08,740 --> 00:13:10,740
并检查权限。

195
00:13:10,740 --> 00:13:16,690
唯一重要的事情是，它不能发送超过其他一些用户墙职位

196
00:13:16,690 --> 00:13:19,220
那你不许看。

197
00:13:19,220 --> 00:13:28,050
它可以基本上是一个非常薄的接入层到数据库，

198
00:13:28,050 --> 00:13:32,820
然后将所有的显示数据 - 所有的意见和东西 - 

199
00:13:32,820 --> 00:13:37,280
那些可以在浏览器中发生，然后当你想使一个职位或东西

200
00:13:37,280 --> 00:13:40,000
你只是发送另一个请求。

201
00:13:40,000 --> 00:13:45,350
>> 还有一些花哨的东西，你可以在此之上做。

202
00:13:45,350 --> 00:13:49,550
在更具体的技术信息方面，

203
00:13:49,550 --> 00:13:53,360
在普通的JavaScript开发可以是一个有点痛苦的，

204
00:13:53,360 --> 00:13:56,220
所以有一些库和工具，这将有助于你一个不少。

205
00:13:56,220 --> 00:14:03,690
我想你们都可能听说过jQuery的，这使得做的HTML渲染

206
00:14:03,690 --> 00:14:08,890
和操纵方便很多 - 有很多花哨的功能淡入淡出，

207
00:14:08,890 --> 00:14:12,020
和做比比动画。

208
00:14:12,020 --> 00:14:13,720
还有这个库称为Underscore.js。

209
00:14:13,720 --> 00:14:20,760
它有很多有用的实用功能，的东西，你会期望JavaScript才能有

210
00:14:20,760 --> 00:14:24,740
它真的doesn't  - 比如洗牌数组，

211
00:14:24,740 --> 00:14:28,900
从列表中删除重复项，或压扁列表的列表。

212
00:14:28,900 --> 00:14:30,900
这只是一个小的代码示例。

213
00:14:30,900 --> 00:14:36,520
底线有一吨，你希望你把所有的时间这些漂亮的功能。

214
00:14:36,520 --> 00:14:38,840
>> 再有就是1，我想花一点点时间对多个库

215
00:14:38,840 --> 00:14:44,800
所谓Backbone.js因为骨干确实能帮助你处理在客户端模式

216
00:14:44,800 --> 00:14:47,210
和很多的混乱，它可引起。

217
00:14:47,210 --> 00:14:53,550
骨干网为您提供的模型和集合这个概念

218
00:14:53,550 --> 00:14:58,300
在JavaScript中它们基本上完全一样的JavaScript对象

219
00:14:58,300 --> 00:15:04,900
在JavaScript数组，但他们有，当你改变它们的属性事件。

220
00:15:04,900 --> 00:15:09,090
就像在JavaScript中，你可以有一个事件，当按钮被点击或某事

221
00:15:09,090 --> 00:15:14,800
这些骨干模型和骨干的集合将广播之类的东西

222
00:15:14,800 --> 00:15:17,510
当他们改变。

223
00:15:17,510 --> 00:15:22,270
这意味着，你可以只写这样的事情代码片段在这里 - 

224
00:15:22,270 --> 00:15:27,530
这表示，当你添加任何职位阵列您重绘整个墙面。

225
00:15:27,530 --> 00:15:34,270
这可以说只要喜欢的文章的数量变化，

226
00:15:34,270 --> 00:15:38,970
你通知有人喜欢他们贴的用户。

227
00:15:38,970 --> 00:15:45,210
或当某一职位的任何属性更改您重绘后。

228
00:15:45,210 --> 00:15:51,050
这样的东西，将节省您万吨的复杂性，因为否则

229
00:15:51,050 --> 00:15:55,440
如果你不那么每一个在你的代码时，你改变有这样一些框架

230
00:15:55,440 --> 00:16:04,280
关于后事情，你必须要记得自己叫所有的渲染功能

231
00:16:04,280 --> 00:16:07,680
之类的东西，如果你想添加新的东西发生

232
00:16:07,680 --> 00:16:10,680
每次你修改后的时间，你就必须要经过你的每一个地方

233
00:16:10,680 --> 00:16:14,610
您修改了帖子，并添加新的东西的代码。

234
00:16:14,610 --> 00:16:21,450
像这样的框架将免去很多的层之间的通信

235
00:16:21,450 --> 00:16:28,280
使你的代码复杂和难以维护。

236
00:16:28,280 --> 00:16:31,170
>> 有大约看法也一点点。

237
00:16:31,170 --> 00:16:35,960
我要离开这个最给比利，因为他们在技术上并不十分困难。

238
00:16:35,960 --> 00:16:43,540
使用jQuery你的看法。这几乎就像一个必要在这一点上。

239
00:16:43,540 --> 00:16:46,290
它只是让一切变得更轻松。

240
00:16:46,290 --> 00:16:48,290
有很多的库。

241
00:16:48,290 --> 00:16:49,970
如果你有复杂的用户界面元素，

242
00:16:49,970 --> 00:16:57,250
如果你想要一个自动完成的事情还是喜欢那些花哨的多选择之一 - 

243
00:16:57,250 --> 00:17:04,790
如果你想这样的事情，你应该只是围绕搜索

244
00:17:04,790 --> 00:17:08,130
你可以找到一个好的图书馆，会做你想要的。

245
00:17:08,130 --> 00:17:11,579
比利将更多地解释的意见，实际上是困难的部分。

246
00:17:11,579 --> 00:17:17,530
此外，作为一个侧面说明，骨干具有使意见交流一些功能

247
00:17:17,530 --> 00:17:22,800
很好地与模型 - 看看所有这些库的文档，其实。

248
00:17:22,800 --> 00:17:28,270
试想一下，在文档。他们是写得很好，易于遵循。

249
00:17:28,270 --> 00:17:33,890
一般情况下，你可以非常简单，只是谷歌，如果你有问题。

250
00:17:33,890 --> 00:17:36,370
有很多人使用它们。

251
00:17:36,370 --> 00:17:42,020
我觉得这是作为一个最后要注意的。

252
00:17:42,020 --> 00:17:48,770
>> 也有一些更高级的东西，你可以做

253
00:17:48,770 --> 00:17:53,400
如果你正在寻找让你的web应用程序的额外真棒。

254
00:17:53,400 --> 00:17:59,760
你可以这样做 - 新的HTML5规范有很多花哨的东西，你可以做。

255
00:17:59,760 --> 00:18:05,780
本地存储 - 这是你可以在浏览器中存储的数据 - 

256
00:18:05,780 --> 00:18:09,470
而不必回去细读服务器的一切，

257
00:18:09,470 --> 00:18:12,470
你可以保留一些它的客户端，甚至让人们 - 

258
00:18:12,470 --> 00:18:20,850
在某些情况下，它甚至可以让你使用网页离线。

259
00:18:20,850 --> 00:18:26,980
有这个东西叫的WebSockets这是一个不同类型的网络通信

260
00:18:26,980 --> 00:18:30,930
在那里，而不是只是你做一个请求，你会得到响应就大功告成了，

261
00:18:30,930 --> 00:18:35,240
你一直打开到服务器的连接，所以你可以做这样的事情

262
00:18:35,240 --> 00:18:37,240
实时更新。

263
00:18:37,240 --> 00:18:42,020
所以，如果你试图做一个聊天应用程序，你可以使用的WebSockets

264
00:18:42,020 --> 00:18:43,790
沟通来回，这样你就不必继续申请，

265
00:18:43,790 --> 00:18:48,410
“哦，服务器，没有人给我聊一会儿吗？”每10秒什么的。

266
00:18:48,410 --> 00:18:55,620
还有一个有趣的HTML5功能，您可以使它看起来像

267
00:18:55,620 --> 00:18:58,340
页面的URL被改变，而无须真正重新加载它。

268
00:18:58,340 --> 00:19:03,230
您可以使用前进和后退按钮没有做一堆的网络请求。

269
00:19:03,230 --> 00:19:14,660
这样的东西是使其迅速方面确实有用，而且工作就像一个web应用程序应该。

270
00:19:14,660 --> 00:19:17,680
>> 还有这个东西叫做CoffeeScript的。

271
00:19:17,680 --> 00:19:24,450
CoffeeScript的是不同的语言，其实，那编译为JavaScript。

272
00:19:24,450 --> 00:19:30,080
你会写所有的代码在CoffeeScript中，然后运行这个编译器，

273
00:19:30,080 --> 00:19:33,300
和它吐出一个JavaScript文件，您可以在您的网页。

274
00:19:33,300 --> 00:19:38,860
究其原因，CoffeeScript的是好的，因为它摆脱了很多的

275
00:19:38,860 --> 00:19:44,760
奇怪的案件JavaScript有哪里等于平等，

276
00:19:44,760 --> 00:19:51,130
和等于等于做不同的事情，还是喜欢 - 

277
00:19:51,130 --> 00:19:55,740
它用于处理数组和功能更好的语法。

278
00:19:55,740 --> 00:20:00,460
这是CoffeeScript中的一个小片段，产生所有的方块的列表

279
00:20:00,460 --> 00:20:04,900
从10 ^ 2〜1 ^ 2以相反的顺序。

280
00:20:04,900 --> 00:20:08,410
正如你所看到的，CoffeeScript的往往可以让你在1线表现

281
00:20:08,410 --> 00:20:10,890
什么将采取5行JavaScript。

282
00:20:10,890 --> 00:20:13,230
它可以使事情变得更加简单。

283
00:20:13,230 --> 00:20:15,390
它是新的语法一点点学习在第一，

284
00:20:15,390 --> 00:20:18,010
但它肯定会让你从长远来看更富有成效。

285
00:20:18,010 --> 00:20:22,050
>> 您也可以使用其他语言在服务器上比PHP  - 

286
00:20:22,050 --> 00:20:27,570
语言如Ruby，Python或甚至还有所谓的node.js项目

287
00:20:27,570 --> 00:20:31,450
，可以让你使用JavaScript在服务器上。

288
00:20:31,450 --> 00:20:34,700
就个人而言，我真的，真的很讨厌的PHP。

289
00:20:34,700 --> 00:20:38,310
我只是不喜欢和它一起工作。

290
00:20:38,310 --> 00:20:43,450
如果你也认为这是一种语言的一个可怕的cluge，

291
00:20:43,450 --> 00:20:46,160
那么你可以使用其中的一个来代替。

292
00:20:46,160 --> 00:20:54,780
一般来说，如果你想要做的东西，你真的不知道你会怎么办呢，

293
00:20:54,780 --> 00:20:56,780
刚刚在网上搜索。

294
00:20:56,780 --> 00:20:59,990
还有成吨的资源，特别是对 - 

295
00:20:59,990 --> 00:21:03,260
StackOverflow的是一个伟大的。

296
00:21:03,260 --> 00:21:06,400
它的这个网站，程序员互相提问。

297
00:21:06,400 --> 00:21:09,690
您可能遇到了它，如果你正在对CS50习题麻烦。

298
00:21:09,690 --> 00:21:16,820
并有做几乎任何你想万吨库。

299
00:21:16,820 --> 00:21:21,710
如果你想要做的东西，你不知道如何做到这一点，

300
00:21:21,710 --> 00:21:23,710
不要以为这是不可能的。

301
00:21:23,710 --> 00:21:26,160
只要看看周围，你可能会发现一些好的资源。

302
00:21:26,160 --> 00:21:29,280
>> 作为一般的包，

303
00:21:29,280 --> 00:21:33,650
主要的外卖是让事情变得简单。

304
00:21:33,650 --> 00:21:36,010
更复杂的代码是在一开始

305
00:21:36,010 --> 00:21:40,370
你尝试做花哨的东西越多，

306
00:21:40,370 --> 00:21:43,300
的时间越长得到的东西实际上是功能性

307
00:21:43,300 --> 00:21:46,480
并就越难将在以后更改。

308
00:21:46,480 --> 00:21:49,580
因此，首先要做的事情是喑哑的，简单的方法。

309
00:21:49,580 --> 00:21:51,720
一起去的，

310
00:21:51,720 --> 00:21:59,070
不要害怕扔掉旧代码或清洁了很多。

311
00:21:59,070 --> 00:22:05,320
一般来说，一旦你真正拥有的东西的工作，

312
00:22:05,320 --> 00:22:09,640
它更容易去思考比当你还处于起步阶段

313
00:22:09,640 --> 00:22:12,610
的我怎么把这一切放在一起。

314
00:22:12,610 --> 00:22:17,500
这是最好使的作品最愚蠢的可能的设计

315
00:22:17,500 --> 00:22:22,270
然后反复比试图让一切都在第一时间进行改进。

316
00:22:22,270 --> 00:22:28,330
在客户端 - 服务器事业部方面，尽量保持你的服务器非常简单 - 

317
00:22:28,330 --> 00:22:33,030
只是一个数据库和一些认证和不做有什么艰苦的工作。

318
00:22:33,030 --> 00:22:37,540
在浏览器中做所有的复杂的东西在客户端

319
00:22:37,540 --> 00:22:40,650
在JavaScript中一样，你可以。

320
00:22:40,650 --> 00:22:43,420
环顾四周，使您的生活更美好库。

321
00:22:43,420 --> 00:22:46,850
总是最好使用代码，别人写

322
00:22:46,850 --> 00:22:49,850
如果你 - 而不是你自己写吧。

323
00:22:49,850 --> 00:22:57,560
有很多东西在互联网上。谷歌是你最好的朋友。

324
00:22:57,560 --> 00:22:59,560
谷歌是程序员最好的朋友。

325
00:22:59,560 --> 00:23:07,620
是啊，绝对不要害怕到处寻找的东西。

326
00:23:07,620 --> 00:23:11,860
好的。及以上比利。

327
00:23:11,860 --> 00:23:14,600
>> [比利]其实，在我开始与一些设计的东西，

328
00:23:14,600 --> 00:23:17,250
没有任何人有任何任何事情，他谈到了问题的本？

329
00:23:17,250 --> 00:23:20,290
好了，好。

330
00:23:20,290 --> 00:23:22,220
再次，让我们知道，如果有什么不清楚

331
00:23:22,220 --> 00:23:25,420
或者如果您希望我们走过去的东西多一点。

332
00:23:25,420 --> 00:23:30,330
我要退一步了一下，说说设计的更为根本的部分。

333
00:23:30,330 --> 00:23:34,840
奔提到所谓的模型 - 对不起，模型视图控制器系统

334
00:23:34,840 --> 00:23:38,520
这是有点技术方面，所以我要看看具体的意见，

335
00:23:38,520 --> 00:23:42,930
和我要开始你如何设计一个视图，看起来不错。

336
00:23:42,930 --> 00:23:50,540
下面是一种对我们的猫Facebook上的真正的基本模板。

337
00:23:50,540 --> 00:23:54,190
我认为有现代的UI设计中的一些基础知识

338
00:23:54,190 --> 00:23:56,190
这是值得回升。

339
00:23:56,190 --> 00:23:58,210
你可以看到有大量的白色空间在整个页面，

340
00:23:58,210 --> 00:24:00,790
足够的空间的东西。

341
00:24:00,790 --> 00:24:02,580
不要觉得你必须压扁东西放到一个页面。

342
00:24:02,580 --> 00:24:06,700
你要离开大量的空间打开，如果你去到几乎任何现代的网站

343
00:24:06,700 --> 00:24:08,380
你会看到有白色无处不在。

344
00:24:08,380 --> 00:24:10,380
有白色的，你不会想到的地方。

345
00:24:10,380 --> 00:24:14,570
你有这样的调色板，它是明智的开头

346
00:24:14,570 --> 00:24:17,880
选择一个调色板，你打算使用和发展。

347
00:24:17,880 --> 00:24:22,250
您也 - 它有助于选择字体，和排序的方式，您正在使用

348
00:24:22,250 --> 00:24:24,450
设计这些具体的基本面。

349
00:24:24,450 --> 00:24:26,910
你有你的类型，你有你的颜色，然后你可以种

350
00:24:26,910 --> 00:24:29,380
根据需要在适应一切。

351
00:24:29,380 --> 00:24:37,710
所以，正如我所说，你的配色方案你想用你的配色方案的大胆色彩

352
00:24:37,710 --> 00:24:40,320
节制。头是不错的。按钮是好的，有非常大的，浮华的色彩。

353
00:24:40,320 --> 00:24:43,710
但在一般情况下，如果你有一个网站，有色彩无处不在，

354
00:24:43,710 --> 00:24:47,250
在脸上都盯着你，它只是看起来杂乱，而且它没有好。

355
00:24:47,250 --> 00:24:50,430
你想一般采用浅色。

356
00:24:50,430 --> 00:24:52,890
尝试，再挑一个漂亮连贯的配色方案。

357
00:24:52,890 --> 00:24:56,640
你可以有很多颜色的这些小飞溅 - 

358
00:24:56,640 --> 00:25:00,240
可以看起来很不错，但你想使用它们相当谨慎。

359
00:25:00,240 --> 00:25:04,270
>> 正如我所说的，你想成为最小。少即是几乎总是更。

360
00:25:04,270 --> 00:25:07,430
如果你能显示东西或不显示的东西，

361
00:25:07,430 --> 00:25:10,230
和你有点不确定是否应该存在默认情况下 - 

362
00:25:10,230 --> 00:25:13,400
可能是你最好离开它了。你总是可以在以后添加它。

363
00:25:13,400 --> 00:25:16,620
是啊，让事情变得简单。

364
00:25:16,620 --> 00:25:19,510
但最重要的，你要考虑多个设计。

365
00:25:19,510 --> 00:25:23,520
不要以为，当你犯了一个网站，你必须在你的头，你要

366
00:25:23,520 --> 00:25:26,310
使网站以某种方式，并且它要看起来完全是这样的。

367
00:25:26,310 --> 00:25:29,830
这将有顶部的蓝色边栏上的蓝色标题和

368
00:25:29,830 --> 00:25:32,670
然后将黄色的子报头的事情。

369
00:25:32,670 --> 00:25:34,670
你想多个模板。

370
00:25:34,670 --> 00:25:37,350
您可以 - 如果你有好的照相馆，您可以打开排序，高达和

371
00:25:37,350 --> 00:25:39,600
设计一个网站，只要你喜欢它的样子。

372
00:25:39,600 --> 00:25:41,680
如果没有，你可以只使用笔和纸，

373
00:25:41,680 --> 00:25:44,000
但划伤了多种设计。

374
00:25:44,000 --> 00:25:47,000
你想基本上有一个设置，你有很多不同的设计，

375
00:25:47,000 --> 00:25:50,810
而如果一个人结束了工作，那么这是伟大的。

376
00:25:50,810 --> 00:25:53,370
如果最终失败，那么你总是有一个又一个转向。

377
00:25:53,370 --> 00:25:57,960
一般情况下，不要觉得你应受限制

378
00:25:57,960 --> 00:26:00,830
到任何设计您最初决定。

379
00:26:00,830 --> 00:26:04,420
设计是非常可变的，并且该模型的重要性部

380
00:26:04,420 --> 00:26:09,480
控制器查看系统是可以进出交换你想要不同的看法。

381
00:26:09,480 --> 00:26:13,510
你可以挥洒的数据的一种方法，然后再决定，呵呵，其实，不工作的很好。

382
00:26:13,510 --> 00:26:19,190
我认为这是一种过于复杂或有这里的一部分，这不是真正的工作，

383
00:26:19,190 --> 00:26:22,150
所以我只是要完全放弃这一观点，并交换在一个完全新的。

384
00:26:22,150 --> 00:26:24,790
我们仍然可以使用老款车型和老的控制器。

385
00:26:24,790 --> 00:26:27,490
我们可以在服务器和客户端因为我们之前做的一切。

386
00:26:27,490 --> 00:26:32,850
而是将数据作为显示的实际波将是稍微不同的。

387
00:26:32,850 --> 00:26:35,840
>> 至于实际执行你想要的设计，

388
00:26:35,840 --> 00:26:39,330
一旦你有几个设计勾勒出在纸上或照相馆或什么的，

389
00:26:39,330 --> 00:26:42,120
还有一些被提供给您的工具。

390
00:26:42,120 --> 00:26:45,700
第一个你非常熟悉的是你的HTML，PHP或任何

391
00:26:45,700 --> 00:26:48,990
你只用代码来在您的网站的静态页面的语言。

392
00:26:48,990 --> 00:26:51,990
你用HTML那种，让你这些标签的工作很多

393
00:26:51,990 --> 00:26:57,820
你可以把东西放进了，基本上它是组织内容的方式。

394
00:26:57,820 --> 00:27:00,990
例如，你有头那里，所以你将有一个标题标签，

395
00:27:00,990 --> 00:27:05,770
而这将有它内部的一些文字这可能是要在另一个标记。

396
00:27:05,770 --> 00:27:08,380
那么你有一个侧边栏，也许有一些不同的环节，

397
00:27:08,380 --> 00:27:10,160
和那些将要放在不同的标签。

398
00:27:10,160 --> 00:27:13,870
所以，基本上HTML在它的心脏是瓜分页面的方式如何

399
00:27:13,870 --> 00:27:16,980
你最终想要格式化。

400
00:27:16,980 --> 00:27:18,980
如此反复，你以前见过的。

401
00:27:18,980 --> 00:27:20,540
你很舒服的现在与它一起工作

402
00:27:20,540 --> 00:27:23,120
因为你希望做最后的PSET，

403
00:27:23,120 --> 00:27:26,150
所以应该是没有问题的。

404
00:27:26,150 --> 00:27:31,280
>> 那么你有CSS基本上可以处理所有的设计静态方面。

405
00:27:31,280 --> 00:27:35,320
它会处理所有的颜色，所有不同元素的定位，

406
00:27:35,320 --> 00:27:36,840
在那里它们相对于彼此去，

407
00:27:36,840 --> 00:27:41,530
他们有多大，不同类型，你就必须定位运动的 - 

408
00:27:41,530 --> 00:27:46,030
换句话说，你就可以有固定的东西，这样当你向下滚动，他们留下来，

409
00:27:46,030 --> 00:27:48,700
或者你可以有相对于其他元素的东西。

410
00:27:48,700 --> 00:27:50,730
所有那类东西是在CSS中。

411
00:27:50,730 --> 00:27:54,630
此外，你可以做不同的装饰，你可以有文字的颜色，

412
00:27:54,630 --> 00:27:56,630
文字特效，所有的那种东西的。

413
00:27:56,630 --> 00:28:00,360
奔上了这最后一个周末一个很好的研讨会上，

414
00:28:00,360 --> 00:28:04,450
所以我一定会检查出来，如果​​你打算做一些花哨的东西用CSS。

415
00:28:04,450 --> 00:28:09,850
CSS3实际上是对CSS的最新版本，它可以做各种各样的非常好的事情。

416
00:28:09,850 --> 00:28:14,750
它可以做渐变，你可以有不错的，圆润的边角，你可以做各种各样的东西

417
00:28:14,750 --> 00:28:17,940
为使您的网站看起来更加现代和花哨。

418
00:28:17,940 --> 00:28:22,150
>> 下一个工具是JavaScript和jQuery的这本谈了一点关于，

419
00:28:22,150 --> 00:28:24,150
但我会得到一点点远成。

420
00:28:24,150 --> 00:28:28,100
JavaScript的，因为你已经用它在课堂上的工作一点点，或者至少看到它，

421
00:28:28,100 --> 00:28:31,870
是一种动态的东西做以HT​​ML的方式。

422
00:28:31,870 --> 00:28:35,950
HTML，如你所知，是静态的，所以一旦你有你的HTML不能修改它。

423
00:28:35,950 --> 00:28:40,050
但JavaScript，在某些方面，是一种能够修改HTML。

424
00:28:40,050 --> 00:28:44,520
所以，你可以这样做，这是伟大的，而JavaScript真的是一个痛苦的工作。

425
00:28:44,520 --> 00:28:49,050
它是如此漫长而钝，并做哪怕是最简单的事情

426
00:28:49,050 --> 00:28:51,630
需要大量的JavaScript的线条。

427
00:28:51,630 --> 00:28:55,410
因此，jQuery是一个基本上JavaScript库，它简化了这一切。

428
00:28:55,410 --> 00:28:59,880
它说，好吧，如果你想有一个方盒子来自左

429
00:28:59,880 --> 00:29:03,980
而淡出人们的页面，以便它在中间，在JavaScript中，将采取 - 

430
00:29:03,980 --> 00:29:06,340
我不知道，百行做的，这将是一个痛苦，

431
00:29:06,340 --> 00:29:10,540
和你出来了憎恨一切关于网络编程的。

432
00:29:10,540 --> 00:29:15,380
JQuery的你基本上有元素点淡入，或者类似的东西。

433
00:29:15,380 --> 00:29:18,580
所以，非常，非常简单的功能，可以让你做各种很酷的动画

434
00:29:18,580 --> 00:29:20,580
和那种事。

435
00:29:20,580 --> 00:29:23,300
另一件事，这两个都是非常好的，只是在做动态的东西

436
00:29:23,300 --> 00:29:25,300
与该网站。

437
00:29:25,300 --> 00:29:28,370
因此，而不是仅仅有你的HTML页面 - 它显示了一些数据，但实际上并不

438
00:29:28,370 --> 00:29:32,130
做任何事情 -  JavaScript和jQuery将让你有按钮，您可以点击，

439
00:29:32,130 --> 00:29:37,960
你可以拖动的元素和重新排序它们，对它们进行排序，并且有新的元素

440
00:29:37,960 --> 00:29:40,500
添加或删除。您可以添加，删除，诸如此类的事情。

441
00:29:40,500 --> 00:29:44,570
因此，jQuery也吨很酷的事情。

442
00:29:44,570 --> 00:29:48,840
和Vipul保持今天实际上是给它一个研讨会上，我相信，在5点钟，

443
00:29:48,840 --> 00:29:51,220
所以如果你能坚持围绕这么久，那会 -  5或4？

444
00:29:51,220 --> 00:29:54,930
四。抱歉。它实际上是右后这一点，所以我会建议

445
00:29:54,930 --> 00:29:56,680
坚持围绕它，如果你能。

446
00:29:56,680 --> 00:30:00,180
jQuery是超级，超级有用，你就可以做很多非常好的事情吧

447
00:30:00,180 --> 00:30:03,460
对于几乎任何Web开发项目。

448
00:30:03,460 --> 00:30:06,200
>> 现在，我要进入怎样的一个区别。

449
00:30:06,200 --> 00:30:08,210
我一直在谈论基本上是关于用户界面。

450
00:30:08,210 --> 00:30:11,510
用户界面是网站的仅仅是设计。

451
00:30:11,510 --> 00:30:13,780
但有几分另一个概念，它是用户体验。

452
00:30:13,780 --> 00:30:15,900
两者有很大的不同。

453
00:30:15,900 --> 00:30:19,440
接口是绝对的经验的一部分。

454
00:30:19,440 --> 00:30:21,340
换句话说，当你去一个网站，你看看接口。

455
00:30:21,340 --> 00:30:22,960
这就是你如何体验的网站的一部分。

456
00:30:22,960 --> 00:30:24,960
但用户体验不止于此。

457
00:30:24,960 --> 00:30:29,910
用户体验是什么，用户会从你的网站的印象。

458
00:30:29,910 --> 00:30:31,910
所以，很显然，接口是其中的一部分。

459
00:30:31,910 --> 00:30:35,340
它绝对是一个必要组成部分，但它不是足够。

460
00:30:35,340 --> 00:30:38,790
换句话说，如果你有一个漂亮的界面，它的漂亮，丰富多彩，所有这一切，

461
00:30:38,790 --> 00:30:43,650
这是伟大的，但如果用户进入你的网站，看到一个漂亮的布局，它的困惑

462
00:30:43,650 --> 00:30:47,060
一切，不知道如何做任何事情，那么显然你已经有了一个真正

463
00:30:47,060 --> 00:30:48,930
可怜的网站。

464
00:30:48,930 --> 00:30:50,930
这就是那种地方的用户体验的用武之地。

465
00:30:50,930 --> 00:30:54,570
我要谈谈UX设计 -  UX是短的用户体验 - 

466
00:30:54,570 --> 00:30:58,050
善良的你如何能确保你有一个良好的用户体验。

467
00:30:58,050 --> 00:31:04,330
第一点是，你可以设计一个网站，用户可以做任何事情，

468
00:31:04,330 --> 00:31:06,820
该用户可能想要的。

469
00:31:06,820 --> 00:31:08,940
但是，如果用户无法弄清楚如何做的那些事 - 

470
00:31:08,940 --> 00:31:12,850
换句话说，如果用户没有一个好主意，当他们去到你的网站，

471
00:31:12,850 --> 00:31:17,660
“哦，如果我想更新我的个人资料，然后我点击这个按钮，或者如果我想张贴上

472
00:31:17,660 --> 00:31:20,850
人的涂鸦墙上，然后我去他们的墙，点击一个小盒子。“

473
00:31:20,850 --> 00:31:24,410
如果用户不知道，那么你有效地并没有真正

474
00:31:24,410 --> 00:31:27,080
正确实现该功能。

475
00:31:27,080 --> 00:31:30,900
实现的功能之一是，用户实际上能够使用它。

476
00:31:30,900 --> 00:31:34,810
它可能是令人沮丧的 - 你可能会做一个网站，它可以做各种

477
00:31:34,810 --> 00:31:37,810
奇妙的事情，但随后你就会有人们对其进行测试，并说，“这不可能做到这一点。

478
00:31:37,810 --> 00:31:39,770
为什么不能这样做呢？“，你会说还给他们，

479
00:31:39,770 --> 00:31:44,420
“嗯，这可以。你只需要进入第七下拉菜单上的这种模糊的

480
00:31:44,420 --> 00:31:48,470
只有通过在底部右下角“或类似的链接找到页面。

481
00:31:48,470 --> 00:31:50,430
很明显，你不希望出现这种情况。

482
00:31:50,430 --> 00:31:53,420
你希望它是明确的，以你的用户什么他们应该做的，

483
00:31:53,420 --> 00:31:56,240
它应该是简单而直观的他们。

484
00:31:56,240 --> 00:32:01,180
>> 要尝试做另一件事是，如果有人的会去你的网站

485
00:32:01,180 --> 00:32:05,520
和9个10倍做动作A和1出10倍做动作B，

486
00:32:05,520 --> 00:32:08,950
你可能想集中行动A.经验

487
00:32:08,950 --> 00:32:12,240
换句话说，你想它非常，非常清楚该怎么做A。

488
00:32:12,240 --> 00:32:15,980
A应前端和中心 - 去到现场，看到了吧，哦，它就在那里。

489
00:32:15,980 --> 00:32:20,850
而乙显然，你想清楚，但你可以让它多一点

490
00:32:20,850 --> 00:32:22,850
在背景中。

491
00:32:22,850 --> 00:32:24,640
大卫给出了一个很好的例子在讲座中，

492
00:32:24,640 --> 00:32:26,640
这是波士顿T系统的。

493
00:32:26,640 --> 00:32:29,440
当你去到波士顿T和你想要买一张票，

494
00:32:29,440 --> 00:32:32,700
你必须进入5个菜单，然后才能真正购买车票

495
00:32:32,700 --> 00:32:37,130
为2美元，二元五角的价值，这是多大的才能乘坐地铁

496
00:32:37,130 --> 00:32:39,130
在一个方向上。

497
00:32:39,130 --> 00:32:41,600
这是一个问题，因为大多数人谁是乘坐地铁

498
00:32:41,600 --> 00:32:44,880
可能只是想去一个地方，购买他们的票，得到的时候了。

499
00:32:44,880 --> 00:32:47,550
它没有任何意义，他们必须经历许多不同的菜单

500
00:32:47,550 --> 00:32:49,550
到那里。

501
00:32:49,550 --> 00:32:51,760
更好的用户体验将是第一个页面上的快捷按钮

502
00:32:51,760 --> 00:32:54,760
这只是说，'买了单程票，“那将使所有的标准

503
00:32:54,760 --> 00:32:58,550
默认值，然后如果有人想购买不同的车票比，

504
00:32:58,550 --> 00:33:01,690
他们还在，当然，可以选择，但你已经优化

505
00:33:01,690 --> 00:33:04,080
共同使用的情况下，这是非常重要的。

506
00:33:04,080 --> 00:33:06,830
你可以看到这样的例子在Facebook上，对不对？

507
00:33:06,830 --> 00:33:09,410
如果你去Facebook和要发布一个状态，

508
00:33:09,410 --> 00:33:11,710
它的右侧上方，而这正是你经常想做的事情。

509
00:33:11,710 --> 00:33:14,730
只要您进入的页面，你可以做的最常见的事情，

510
00:33:14,730 --> 00:33:16,730
你想做的事情。

511
00:33:16,730 --> 00:33:17,550
如果你想要做这样稍微复杂的事情，

512
00:33:17,550 --> 00:33:21,070
说我想要去我朋友的墙上，张贴图片就可以了 - 

513
00:33:21,070 --> 00:33:24,810
我想要做的时候，但不是经常张贴状态更新 - 

514
00:33:24,810 --> 00:33:28,200
所以在这种情况下，我输入他们的名字在箱体顶部，点击他们的个人资料，

515
00:33:28,200 --> 00:33:31,680
然后，尽管如此，它的右侧上方有一次，我已经得到了他们的个人资料。

516
00:33:31,680 --> 00:33:38,240
再次，我已经优化的优先级为最常见的使用案例。

517
00:33:38,240 --> 00:33:41,800
>> 另一个重要的事情是有点，往往人们会尝试解决这个问题

518
00:33:41,800 --> 00:33:44,890
说，好吧，所以我做了该网站，人们发现它令人困惑，

519
00:33:44,890 --> 00:33:46,110
，这是一个问题，对不对？

520
00:33:46,110 --> 00:33:49,210
很显然，我不希望人们通过我的网站的内容所迷惑。

521
00:33:49,210 --> 00:33:53,210
但要解决的方式是不是有东西弹出说，

522
00:33:53,210 --> 00:33:55,290
哎，我要教你如何使用这个网站。

523
00:33:55,290 --> 00:33:58,130
步骤1  - 单击此按钮。第2步 - 去这里。

524
00:33:58,130 --> 00:34:03,080
当然，这是变通的办法 - 这是一种方式，你可以告诉人们应该做些什么，但它的

525
00:34:03,080 --> 00:34:05,080
真的不是最佳的方式。

526
00:34:05,080 --> 00:34:07,420
如果我去一个网站，突然间我催要本教程是在告诉我，

527
00:34:07,420 --> 00:34:11,739
做什么和去哪里，这一切，那不是好玩的了。

528
00:34:11,739 --> 00:34:13,739
这不是我的一个很好的经验。

529
00:34:13,739 --> 00:34:17,130
这是一种痛苦。我想刚开始做的东西。

530
00:34:17,130 --> 00:34:19,449
人们会收了他们的对话方块中，

531
00:34:19,449 --> 00:34:23,580
或走出教程，不知道该怎么做，然后抱怨，因为

532
00:34:23,580 --> 00:34:25,580
你还没有告诉他们该怎么做。

533
00:34:25,580 --> 00:34:29,530
解决这个问题的方法是不给予任何形式的教程或方向 - 

534
00:34:29,530 --> 00:34:31,530
类似的事情。

535
00:34:31,530 --> 00:34:33,719
就像你能避免它，你真的想向用户显示该怎么办

536
00:34:33,719 --> 00:34:36,429
刚刚通过了如何在网站的布局的性质。

537
00:34:36,429 --> 00:34:39,090
换句话说，如果我去给Facebook没有登录，

538
00:34:39,090 --> 00:34:40,920
我的主网页上看到的第一件事情 - 

539
00:34:40,920 --> 00:34:44,480
这是一个有点登录框。所以，真不错。我需要登陆。它就在那里。

540
00:34:44,480 --> 00:34:48,030
然而，如果我去到Facebook，我不得不单击底部一点点链接

541
00:34:48,030 --> 00:34:51,920
那个说'登录'和页面的其余部分只是一些图片什么的，

542
00:34:51,920 --> 00:34:54,820
我真的不知道该怎么做了吧？我会被混淆。

543
00:34:54,820 --> 00:34:58,590
因此，它可以告诉我去那里，然后单击按钮进行登录，

544
00:34:58,590 --> 00:35:01,080
或者在日志中键可以在那里我会看到它的顶部是正确的。

545
00:35:01,080 --> 00:35:04,780
你要始终显示用户做什么，

546
00:35:04,780 --> 00:35:06,750
这应该是固有的页本身。

547
00:35:06,750 --> 00:35:09,880
>> 当你正在考虑设计和嘲讽了不同的方式

548
00:35:09,880 --> 00:35:13,810
表达你的网站，你真的要想想什么样的用户会

549
00:35:13,810 --> 00:35:19,380
做以及如何告诉他们该怎么做。

550
00:35:19,380 --> 00:35:23,530
最后一件事就是测试是真的，真的很重要。

551
00:35:23,530 --> 00:35:27,400
这是伟大的找人 - 找个朋友，找人你不知道，即使 - 

552
00:35:27,400 --> 00:35:30,420
谁是从未见过的站点之前使用该网站。

553
00:35:30,420 --> 00:35:33,650
因为你已经在现场工作了几个小时，你一直盯着它，

554
00:35:33,650 --> 00:35:36,670
你确切地知道这样做很明显你将要测试

555
00:35:36,670 --> 00:35:39,520
事情，你一直都在，你知道的工作。

556
00:35:39,520 --> 00:35:42,680
但如果别人走来，并使用该以前从未使用过该网站，

557
00:35:42,680 --> 00:35:46,880
这是一种独特的体验，因为你有别人谁没有先验知识

558
00:35:46,880 --> 00:35:51,530
该网站进入，所以他们将有有效地不知道该怎么做的

559
00:35:51,530 --> 00:35:54,890
或者什么样的用例都存在他们。

560
00:35:54,890 --> 00:36:00,930
这是伟大的。这是独一无二的，因为它们基本上是一个人与一个空白的头脑。

561
00:36:00,930 --> 00:36:03,750
他们可以告诉你，如果事情是混乱或不清晰。

562
00:36:03,750 --> 00:36:07,580
他们可以给你的正是你的网站的用户体验是一个想法。

563
00:36:07,580 --> 00:36:10,630
它可以是非常困难告诉自己，所以我肯定会鼓励你

564
00:36:10,630 --> 00:36:13,640
为您开发的项目 - 如果你正在做的基于Web的项目 - 

565
00:36:13,640 --> 00:36:18,290
早在你有某种功能的演示使用该网站得到的人。

566
00:36:18,290 --> 00:36:25,330
>> 现在，我要谈谈如何管理一个Web开发项目一点点。

567
00:36:25,330 --> 00:36:28,900
我们已经讨论了如何才能做到的技术后端侧，

568
00:36:28,900 --> 00:36:31,050
如何设计一个非常好的网站，

569
00:36:31,050 --> 00:36:34,150
这就是伟大的，如果你自己的工作，但 - 

570
00:36:34,150 --> 00:36:37,300
即使你通过自己的工作，特别是如果你在一个团队工作，

571
00:36:37,300 --> 00:36:39,580
项目管理成为一个大问题。

572
00:36:39,580 --> 00:36:42,340
那种你既然听说过项目管理的不同形式

573
00:36:42,340 --> 00:36:45,410
小学的时候你被告知小组的工作。

574
00:36:45,410 --> 00:36:46,820
你必须合作，沟通，所有这一切。

575
00:36:46,820 --> 00:36:49,620
这一切都仍然适用在这里，但也有一些特殊情况

576
00:36:49,620 --> 00:36:54,910
要知道，你要确保你处理好计算机科学。

577
00:36:54,910 --> 00:36:58,050
我先谈一点关于球队，你会是英寸

578
00:36:58,050 --> 00:37:03,280
这是非常重要的，选择一个团队进行工作的大小合适，

579
00:37:03,280 --> 00:37:05,890
并在最终的项目，我认为你必须选择的选项

580
00:37:05,890 --> 00:37:08,610
如果我是正确的1至4人。

581
00:37:08,610 --> 00:37:12,050
你要确保你不只是选择的人数

582
00:37:12,050 --> 00:37:14,950
您要使用，因为他们是你的朋友合作。

583
00:37:14,950 --> 00:37:18,170
你要选择一个团队，是一个很好的大小，这将完成这项工作。

584
00:37:18,170 --> 00:37:22,700
有一个权衡中有更多的人与较少的人。

585
00:37:22,700 --> 00:37:25,320
如果您有更多的人，显然更多的工作可以做

586
00:37:25,320 --> 00:37:28,450
因为你有很多的人，大量的代码，很多想法，

587
00:37:28,450 --> 00:37:29,870
这就是所有伟大。

588
00:37:29,870 --> 00:37:32,590
但它也需要更多的管理和更大量的沟通。

589
00:37:32,590 --> 00:37:34,720
换句话说，如果你有4人工作在同一个项目

590
00:37:34,720 --> 00:37:39,200
而且他们都编辑了相同的代码，或多或少都种需要知道的

591
00:37:39,200 --> 00:37:40,920
这是怎么回事，因此需要你 - 

592
00:37:40,920 --> 00:37:44,580
排序的，如果你添加了一些新的功能，你必须告诉人们 -  I'm加入此，

593
00:37:44,580 --> 00:37:48,510
我改变了这种以这种方式 - 特别是如果你进入非常深的东西

594
00:37:48,510 --> 00:37:52,730
像模型和控制器，实际上将影响该网站如何工作的。

595
00:37:52,730 --> 00:37:54,500
整个团队需要意识到这一点，

596
00:37:54,500 --> 00:37:58,140
所以你需要确保你不选择太大的球队，那将是很难

597
00:37:58,140 --> 00:37:59,970
让沟通。

598
00:37:59,970 --> 00:38:02,930
你也不想选择一个足够小的团队，你不会

599
00:38:02,930 --> 00:38:06,250
能够沟通，​​因为它只是你。

600
00:38:06,250 --> 00:38:11,270
>> 另一个要考虑的是，人们的技能的平衡。

601
00:38:11,270 --> 00:38:14,350
这是伟大的，如果你真的所有优秀的程序员。

602
00:38:14,350 --> 00:38:17,050
但如果你是所有后端的人，那么你的网站是不会很好看

603
00:38:17,050 --> 00:38:20,860
因为你有这个伟大的数据库，而且它超快的搜索查询 - 

604
00:38:20,860 --> 00:38:26,130
这是伟大的 - 但是当你去到它，它就像1990年的网站用红色和蓝色

605
00:38:26,130 --> 00:38:30,370
无处不在，而这也不行。

606
00:38:30,370 --> 00:38:34,210
请注意，Ben和我的工作作为一个团队是非常好的，因为我是那种更

607
00:38:34,210 --> 00:38:38,030
在前端，我们无论是在中端交互，和本真的很好用后端的东西，

608
00:38:38,030 --> 00:38:43,550
使作品真的很好，因为我们可以设计任何网站，基本上孔

609
00:38:43,550 --> 00:38:47,580
该站点需要被填补可以通过任何一个人来说，也可能两者填补。

610
00:38:47,580 --> 00:38:50,210
你要确保有在你的团队没有漏洞。

611
00:38:50,210 --> 00:38:51,180
没关系，如果有一点重叠。

612
00:38:51,180 --> 00:38:53,670
换句话说，如果你有2人是既具有良好的后端，

613
00:38:53,670 --> 00:38:57,250
这可以很好的为好，因为他们可以互相帮助与问题

614
00:38:57,250 --> 00:38:58,820
他们是有。

615
00:38:58,820 --> 00:39:02,590
它可以是一个问题，如果你只有1人谁负责某一件事

616
00:39:02,590 --> 00:39:06,650
他们碰到的一个问题，所以你希望有重叠一点点

617
00:39:06,650 --> 00:39:10,760
但你最重要的是要确保所有可能的孔被填充。

618
00:39:10,760 --> 00:39:17,550
>> 最后一件事 - 这应该是显而易见的，但它往往并非如此。

619
00:39:17,550 --> 00:39:19,550
你真的想要获得乐趣。

620
00:39:19,550 --> 00:39:23,360
在CS50这最后的项目点和网络的发展往往是在一般的点

621
00:39:23,360 --> 00:39:26,360
是不是只是做一个工作，因为它需要做的事情。

622
00:39:26,360 --> 00:39:29,140
你真的想要获得乐趣，并且你想成为使一些

623
00:39:29,140 --> 00:39:31,180
这是激励你的工作就可以了。

624
00:39:31,180 --> 00:39:33,650
如果无论你正在做的是一件痛苦的坐下来工作，

625
00:39:33,650 --> 00:39:35,650
那么你就不能选择合适的项目。

626
00:39:35,650 --> 00:39:37,730
你要选择一个你觉得有趣的东西，

627
00:39:37,730 --> 00:39:41,150
你真的想看到的结果，你很高兴，当你得到关于一个新的想法

628
00:39:41,150 --> 00:39:44,700
一些你可以做的 - 所以有各种各样的项目有，我敢肯定，

629
00:39:44,700 --> 00:39:47,290
你可以找到 - 每个人都有的东西，真的会他们的阴谋

630
00:39:47,290 --> 00:39:49,290
如果他们正在做一个基于Web的项目。

631
00:39:49,290 --> 00:39:52,210
我再说一遍，现在。

632
00:39:52,210 --> 00:39:54,520
如果你的项目似乎是一个痛苦，你不想要工作就可以了，

633
00:39:54,520 --> 00:39:57,260
选择其他项目。选择一些真正激励你。

634
00:39:57,260 --> 00:40:00,260
>> 本提到迭代有点这个概念，我想通过它去了一下。

635
00:40:00,260 --> 00:40:08,250
这真的很重要，你得到的东西喷功能的工作。

636
00:40:08,250 --> 00:40:13,420
它可以是伟大的，如果你有这样的计划，一个网站，会做A，B和C，

637
00:40:13,420 --> 00:40:16,000
并最终会到达那里。

638
00:40:16,000 --> 00:40:18,600
但你停留在这个阶段，你正在使用它，处理它，

639
00:40:18,600 --> 00:40:23,330
但什么也没有得到实现。你没有什么可看，有形的，功能性的东西。

640
00:40:23,330 --> 00:40:27,940
你真的想要，因为它似乎一种痛苦有时做尽可能多的什么

641
00:40:27,940 --> 00:40:32,300
对一些工作，然后有点糟糕的是关闭，因此它至少在一个稳定的，运行

642
00:40:32,300 --> 00:40:34,910
版本即使没有你想要的所有功能。

643
00:40:34,910 --> 00:40:37,690
也许有一些功能，你真的想加入，但你就是不能

644
00:40:37,690 --> 00:40:41,830
因为你想要得到这个网站的功能点。

645
00:40:41,830 --> 00:40:44,400
所以你想要那种把整个开发过程看起来像他一样。

646
00:40:44,400 --> 00:40:47,810
你想从某个地方开始功能 - 或者根本就什么也没有 - 

647
00:40:47,810 --> 00:40:49,890
但你想要得到的地方非常基本的和功能。

648
00:40:49,890 --> 00:40:54,940
然后再次，做一个排序跳，再次得到的地方发挥作用。

649
00:40:54,940 --> 00:40:59,190
你会慢慢建立起来，它可能会去会比其他慢一点，

650
00:40:59,190 --> 00:41:03,000
但是从长远来看，如果你经常停留在这个中间地带阶段，你

651
00:41:03,000 --> 00:41:06,380
实际上没有任何工作，它可以是一个真正的大挫折

652
00:41:06,380 --> 00:41:09,970
在你的项目中工作，因为你总是如此接近得到它的工作，

653
00:41:09,970 --> 00:41:12,130
而且它从来没有真正的工作。

654
00:41:12,130 --> 00:41:14,810
你想在这些功能苗头工作，

655
00:41:14,810 --> 00:41:17,950
而你也希望每个人以后做一些反思。

656
00:41:17,950 --> 00:41:21,260
换句话说，一旦你在一个点，该网站是现在的工作 - 

657
00:41:21,260 --> 00:41:24,790
它没有你喜欢的一切，但它做一些事情 - 

658
00:41:24,790 --> 00:41:28,870
你要想想，还好，就是这个网站办成，我所要做的目标是什么？

659
00:41:28,870 --> 00:41:33,410
换句话说，如果该网站将做X，是我在X方向有工作？

660
00:41:33,410 --> 00:41:36,450
都是，我想那里的功能呢？

661
00:41:36,450 --> 00:41:39,340
，而且，它是服务，我想整体的目的是什么？

662
00:41:39,340 --> 00:41:43,200
如果你发现你的网站已开始在不同的方向来改变方向

663
00:41:43,200 --> 00:41:47,330
也许事情就有种不工作了，它可能是时间换挡一点点。

664
00:41:47,330 --> 00:41:51,700
换句话说，这是值得考虑 - 这是值得扔出去的想法，如果有必要

665
00:41:51,700 --> 00:41:57,950
并考虑我真的努力争取我想要的。

666
00:41:57,950 --> 00:42:00,760
>> 我相信这是我的下一点。不要害怕放弃的想法。

667
00:42:00,760 --> 00:42:03,750
仅仅因为你花了很多时间工作的一个特点

668
00:42:03,750 --> 00:42:07,890
终于得到了它的工作，但它确实是不会这么好 - 

669
00:42:07,890 --> 00:42:12,690
就像是没有多大用处的，或用户正在使用它遇到了麻烦 - 诸如此类的事情 - 

670
00:42:12,690 --> 00:42:15,300
不要害怕把它扔掉。

671
00:42:15,300 --> 00:42:17,650
它吮吸你已经花了很多时间工作就可以了，

672
00:42:17,650 --> 00:42:21,870
但最终你不想要一个网站那种的放在一起，这些片段，

673
00:42:21,870 --> 00:42:25,380
这类工作，但都不是很好的服务。

674
00:42:25,380 --> 00:42:27,990
另外，不要害怕接受新的想法。

675
00:42:27,990 --> 00:42:30,050
如果有人走来，说，哎，该网站看起来真的很酷，但

676
00:42:30,050 --> 00:42:32,290
那岂不是即使是伟大的，如果它也这样做？

677
00:42:32,290 --> 00:42:36,220
只是因为这件事情，你不打算和东西是不是在你的

678
00:42:36,220 --> 00:42:37,900
规格，东西，你有没有下决心做，

679
00:42:37,900 --> 00:42:40,860
不要害怕把它，然后使用它。

680
00:42:40,860 --> 00:42:43,680
因为往往你在整个发展过程中运行思路

681
00:42:43,680 --> 00:42:47,630
最终成为该网站的很酷的功能。

682
00:42:47,630 --> 00:42:49,630
>> 我之前已经说过了这一点。我再说一遍。

683
00:42:49,630 --> 00:42:51,630
测试人员是超级，超级有用。

684
00:42:51,630 --> 00:42:56,350
试图让人们谁从未见过的网站之前登录并查看发生了什么事情

685
00:42:56,350 --> 00:42:59,080
因为他们不仅可以测试网站和用户体验的实用性，

686
00:42:59,080 --> 00:43:02,070
但他们也可以的方式，你不能测试功能。

687
00:43:02,070 --> 00:43:06,430
如果你做了一些功能，做某一件事

688
00:43:06,430 --> 00:43:11,620
你知道它会做正确的事情一样，每一次，这是伟大的。

689
00:43:11,620 --> 00:43:16,610
但它往往很难占到角落情况下，一个用户可能

690
00:43:16,610 --> 00:43:19,500
因为你准确的界定 - 键入的东西，你没有想到

691
00:43:19,500 --> 00:43:21,500
自己的特点。

692
00:43:21,500 --> 00:43:23,730
所以，有一个人过来对谁没有知道如何使用该网站

693
00:43:23,730 --> 00:43:26,840
而刚刚打破它以任何方式，他们可以做的是真正有用的，因为你

694
00:43:26,840 --> 00:43:30,340
从您的网站什么是工作的一个完全不同的角度得到一个想法

695
00:43:30,340 --> 00:43:33,300
什么需要修理。

696
00:43:33,300 --> 00:43:37,070
>> 最后，我要谈的一些好的做法，

697
00:43:37,070 --> 00:43:42,470
你已经看到了很多这些在CS50，但他们也非常非常适用于项目的设置。

698
00:43:42,470 --> 00:43:47,600
一个是注释。总是特别注释你的代码，如果你正在做一个大的团队。

699
00:43:47,600 --> 00:43:51,230
它可以是那么讨厌，只是有一个代码块巨大的，有人是写

700
00:43:51,230 --> 00:43:54,230
也许奏效，也许没有，但你不知道它做什么，

701
00:43:54,230 --> 00:43:58,010
所以你不知道它是否有用与否，或是否应该存在与否，

702
00:43:58,010 --> 00:44:00,200
如果你工作在别的东西，你的工作就它甚至有可能

703
00:44:00,200 --> 00:44:06,590
同样的事情，所以只是非常，非常小心，要体谅你的同伴

704
00:44:06,590 --> 00:44:09,710
和写代码，是有据可查的。

705
00:44:09,710 --> 00:44:13,580
你不必跑那么远的做，如果你增加地方喜欢整个事情

706
00:44:13,580 --> 00:44:16,620
计数器有一个评论，说，我添加1到这个计数器。

707
00:44:16,620 --> 00:44:20,450
这并不一定是因为详细，但对于你曾经编写任何功能

708
00:44:20,450 --> 00:44:23,160
你应该有一个什么样的功能究竟做了一些文档，

709
00:44:23,160 --> 00:44:25,140
什么它的输入，以及它应该返回。

710
00:44:25,140 --> 00:44:27,800
这样，你可以使用该网站的其他人的组件

711
00:44:27,800 --> 00:44:31,990
你可以朝着建设事大工作。

712
00:44:31,990 --> 00:44:34,100
>> 另一个重要的事情是你想要做定期清除。

713
00:44:34,100 --> 00:44:40,490
代码就会变得混乱。不要难过，如果你的代码仅仅是完全不可读和一个巨大的烂摊子。

714
00:44:40,490 --> 00:44:42,770
这种情况发生在web开发中始终。

715
00:44:42,770 --> 00:44:46,530
你添加新的功能，删除旧的。东西是要在那里不应该。

716
00:44:46,530 --> 00:44:49,330
这很好，但你要确保处理定期。

717
00:44:49,330 --> 00:44:53,430
你不想让它建立到这种地步，你就不能发现什么

718
00:44:53,430 --> 00:44:56,430
在你的代码，而你不知道是什么东西呢。

719
00:44:56,430 --> 00:44:58,430
这是用HTML的情况。

720
00:44:58,430 --> 00:44:59,490
有时，你会最终与不​​包含任何对象，

721
00:44:59,490 --> 00:45:01,320
你会想摆脱那些。

722
00:45:01,320 --> 00:45:04,610
在CSS中，你可以指的是不存在了的元素，

723
00:45:04,610 --> 00:45:06,340
所以你想摆脱的代码。

724
00:45:06,340 --> 00:45:09,900
在JavaScript中，你可能已经删除从HTML的东西。

725
00:45:09,900 --> 00:45:13,150
所以，你要确保你总是清理，使美丽的东西

726
00:45:13,150 --> 00:45:17,450
就像你可以定期。

727
00:45:17,450 --> 00:45:21,060
>> 我不认为另一个非常有用的东西概述十分CS50

728
00:45:21,060 --> 00:45:23,430
但它是值得进入的是版本控制。

729
00:45:23,430 --> 00:45:27,180
版本控制的想法是，当你基本上保持跟踪所有的进展

730
00:45:27,180 --> 00:45:30,820
你做对您的网站，如果在任何时候你意识到，哦，这是工作

731
00:45:30,820 --> 00:45:35,220
前一段时间，但它不工作的更多，你可以回到以前的版本

732
00:45:35,220 --> 00:45:37,720
看看从那时起，诸如此类的事情发生了什么变化。

733
00:45:37,720 --> 00:45:41,670
主要的办法做到这一点是使用Git，以及Git是这整个种类的系统来

734
00:45:41,670 --> 00:45:46,390
我相信汤米MacWilliam了一个关于去年的研讨会。

735
00:45:46,390 --> 00:45:51,520
如果你去到CS50研讨会于2011年，你可以看到他的研讨会上说。

736
00:45:51,520 --> 00:45:57,070
混帐的想法基本上是每隔一段时间你正在做这些承诺

737
00:45:57,070 --> 00:46:01,430
这是说该网站是在一个相当稳定的版本，现在这样的方式

738
00:46:01,430 --> 00:46:05,910
我把它包装起来并把它发送到了服务器，那么你可以去到该服务器

739
00:46:05,910 --> 00:46:07,910
看看你的代码之前的所有版本，看看它是如何进展

740
00:46:07,910 --> 00:46:12,210
和所有诸如此类的好东西。

741
00:46:12,210 --> 00:46:14,210
所以，这是基本的。

742
00:46:14,210 --> 00:46:17,870
至于网络的发展，我们很高兴留下来，回答任何

743
00:46:17,870 --> 00:46:20,570
的问题，据我们的介绍。

744
00:46:20,570 --> 00:46:22,900
就是这样。谢谢。 >> [奔]谢谢。

745
00:46:22,900 --> 00:46:28,480
[鼓掌]

746
00:46:28,480 --> 00:46:30,950
>> [比利]工作人员，有没有人想过这事我们已经讨论的事情有任何疑问

747
00:46:30,950 --> 00:46:33,950
或者说我们还没有涉及，他们希望事情我们会覆盖？

748
00:46:33,950 --> 00:46:35,950
我们很乐意回答这些。任何人吗？

749
00:46:35,950 --> 00:46:50,360
[听众]什么是使用Ruby或使用Python的利弊？

750
00:46:50,360 --> 00:46:58,660
[奔]现在的问题是，什么是使用Ruby或Python的利弊

751
00:46:58,660 --> 00:46:59,900
而不是像PHP。

752
00:46:59,900 --> 00:47:11,340
优点是Ruby和Python是比PHP更好的语言。

753
00:47:11,340 --> 00:47:14,920
至少在我看来，我想了很多别人的意见为好。

754
00:47:14,920 --> 00:47:20,990
他们的目的多用于做复杂的东西，

755
00:47:20,990 --> 00:47:25,380
少的重击在一起网页真的很快与

756
00:47:25,380 --> 00:47:28,400
动态内容一点点。

757
00:47:28,400 --> 00:47:35,180
的缺点是有一点点 - 有更多的学习曲线

758
00:47:35,180 --> 00:47:37,220
，让他们建立起来。

759
00:47:37,220 --> 00:47:41,010
也就是说，想在PHP中，你可以有一个HTML文件，你写的小于，

760
00:47:41,010 --> 00:47:43,060
问号，然后写一些代码，然后你写的问号，

761
00:47:43,060 --> 00:47:45,700
大于号，然后就大功告成了。

762
00:47:45,700 --> 00:47:50,300
在其他语言如Ruby或Python，

763
00:47:50,300 --> 00:47:56,810
你必须要经过更多的工作来获取初始站点运行。

764
00:47:56,810 --> 00:48:02,730
还有 - 至少它曾经是如此 - 那还有更多的文档

765
00:48:02,730 --> 00:48:05,480
可用于PHP的，只是因为有使用它更多的人。

766
00:48:05,480 --> 00:48:09,370
我认为这不是太大的问题了。

767
00:48:09,370 --> 00:48:12,520
有肯定是非常好的文档东西像Ruby on Rails的

768
00:48:12,520 --> 00:48:16,080
或者Django对于Python是等价的。

769
00:48:16,080 --> 00:48:25,910
PHP是每个人都已经使用了多年的一个，你知道它是如何工作的。

770
00:48:25,910 --> 00:48:28,460
Ruby和Python都有点不太成熟。

771
00:48:28,460 --> 00:48:33,130
>> [听众]如果你是其中之一之间进行选择学习或回暖，

772
00:48:33,130 --> 00:48:36,130
你会选哪个？

773
00:48:36,130 --> 00:48:38,870
老实说，我认为取决于人。

774
00:48:38,870 --> 00:48:45,450
对不起。现在的问题是这会你挑人来学习呢？

775
00:48:45,450 --> 00:48:50,230
我发现Python的个人的最好。

776
00:48:50,230 --> 00:48:55,360
有很多人谁 - 我做了Python和Django的我的第一个web开发项目。

777
00:48:55,360 --> 00:49:00,300
有很多人谁喜欢的Ruby on Rails也。

778
00:49:00,300 --> 00:49:02,650
或许更多的人谁on Rails的了解Ruby。

779
00:49:02,650 --> 00:49:05,270
老实说，我只想去任何你周围的人都知道

780
00:49:05,270 --> 00:49:09,680
这样你才有人来问问题。

781
00:49:19,640 --> 00:49:24,170
>> 现在的问题是 - 在共享服务器上是种很难工作的Python呢？

782
00:49:24,170 --> 00:49:26,170
这取决于您的主机。

783
00:49:26,170 --> 00:49:29,400
有许多网络主机，将发布Python的东西。

784
00:49:29,400 --> 00:49:31,400
WebFaction这样做，对吗？

785
00:49:31,400 --> 00:49:34,400
WebFaction是一个比利和我已经用于一些项目。

786
00:49:34,400 --> 00:49:37,750
他们是真正伟大的。它们支持大多数语言。

787
00:49:37,750 --> 00:49:40,020
但它是真实的，PHP是更广泛的支持。

788
00:49:40,020 --> 00:49:45,210
所以，如果你坚持一个虚拟主机，只做对的PHP，这是使用PHP一个很好的理由。

789
00:49:45,210 --> 00:49:56,010
>> [听众]我刚坐进学习如何查询一些数据库，

790
00:49:56,010 --> 00:50:00,680
我知道我的SQL是所有的地方，但是我最近得到了暴露 - 

791
00:50:00,680 --> 00:50:04,470
你指了出来。你看，JSON和可扩展数据库。

792
00:50:04,470 --> 00:50:14,580
我的SQL仍然是所有的地方。你怎么看这种事情发生？

793
00:50:14,580 --> 00:50:21,330
是否有将要为更多的扩展（听不清）成为增长的趋势？

794
00:50:21,330 --> 00:50:30,100
现在的问题是 - 我觉得有将是对非SQL数据库的趋势。

795
00:50:30,100 --> 00:50:33,850
举例来说，像MongoDB的。我认为这是绝对真实的。

796
00:50:33,850 --> 00:50:38,730
我的建议是在这里大多是MySQL相关，只是因为MySQL是

797
00:50:38,730 --> 00:50:40,950
行业标准。

798
00:50:40,950 --> 00:50:45,950
就个人而言，我更喜欢那些没有像MongoDB的schemos数据库

799
00:50:45,950 --> 00:50:49,520
在那里你没有问题，呵呵，我需要添加另一列。

800
00:50:49,520 --> 00:50:51,600
祸是我，就像不管我该怎么做？

801
00:50:51,600 --> 00:50:55,840
这是很难做到这一点的MySQL，但是当你有像蒙戈

802
00:50:55,840 --> 00:50:57,840
它更漂亮。

803
00:50:57,840 --> 00:51:03,780
关于蒙戈的其他好处是，你的记录实际上是JavaScript对象。

804
00:51:03,780 --> 00:51:10,110
有没有排序的转换步骤，你需要把这些数据库中的行

805
00:51:10,110 --> 00:51:13,140
并把他们变成一个JavaScript对象，然后将它们发送过来的电线。

806
00:51:13,140 --> 00:51:20,290
我觉得这样的东西将是非常，非常有用的快速Web开发的未来。

807
00:51:20,290 --> 00:51:23,060
>> [比利]东西我想补充这仅仅是一个普遍的观点是，

808
00:51:23,060 --> 00:51:26,580
不要觉得你应该已经学会了所有我们已经讨论过的语言

809
00:51:26,580 --> 00:51:28,580
从我们的研讨会。

810
00:51:28,580 --> 00:51:30,560
很显然的一点是给你一个什么样的在那里一个想法，

811
00:51:30,560 --> 00:51:33,450
如果你被任何我们已经提到的东西很感兴趣你可以Google他们

812
00:51:33,450 --> 00:51:35,830
并在他们读了。

813
00:51:35,830 --> 00:51:38,750
正如我所提到的，还有一些处理正是这些东西了几个研讨会。

814
00:51:38,750 --> 00:51:41,660
还有，我没有提到，可能进入更加研讨会

815
00:51:41,660 --> 00:51:43,660
这个东西也是如此。

816
00:51:43,660 --> 00:51:46,610
我们的想法是，如果你要处理的东西，这里是在您的处置工具。

817
00:51:46,610 --> 00:51:51,630
如果你真的不知道什么这些工具做完全不觉得不堪重负，

818
00:51:51,630 --> 00:51:54,830
但要知道，他们是在那里，你可以使他们的广泛使用

819
00:51:54,830 --> 00:51:56,830
由谷歌。

820
00:51:56,830 --> 00:51:59,960
>> [听众]你需要什么样的事情要做，以确保您的网站

821
00:51:59,960 --> 00:52:02,530
在移动设备上看起来不错？

822
00:52:02,530 --> 00:52:05,590
[比利]移动设备是有点硬。

823
00:52:05,590 --> 00:52:07,590
有2种方式可以接近它。

824
00:52:07,590 --> 00:52:11,500
第一种方式是，你实际上有一个移动网站。

825
00:52:11,500 --> 00:52:14,660
换句话说，就在开始时执行某种检测

826
00:52:14,660 --> 00:52:18,830
当浏览器发出请求到您的网站，或者说

827
00:52:18,830 --> 00:52:25,240
返回这个观点 - 这将是该视图的台式机或笔记本电脑的浏览器 - 

828
00:52:25,240 --> 00:52:27,710
这另一种观点适用于移动设备。

829
00:52:27,710 --> 00:52:33,090
这是一个地方的意见是非常好的在您几乎可以互换的

830
00:52:33,090 --> 00:52:37,580
两头在外，并有作品真的很好地在移动设备上的接口

831
00:52:37,580 --> 00:52:40,770
并有一个完全不同的一个很好地工作在浏览器中的设备。

832
00:52:40,770 --> 00:52:43,770
与该问题是它需要很长的时间，因为这意味着编码

833
00:52:43,770 --> 00:52:47,060
一个完全不同的接口。

834
00:52:47,060 --> 00:52:49,720
你可以做到这一点的另一种方式是 - 

835
00:52:49,720 --> 00:52:55,250
很多现代的手机将显示网站和尝试，使它们像浏览器那样，

836
00:52:55,250 --> 00:52:57,680
和他们做最好的自己。

837
00:52:57,680 --> 00:53:04,340
有种你可以尽量留在光的jQuery的JavaScript您使用的金额

838
00:53:04,340 --> 00:53:07,360
这往往是那里的东西可以去错了一点点。

839
00:53:07,360 --> 00:53:13,430
这是那种你应该使用，如果你没有那么多时间的方式。

840
00:53:13,430 --> 00:53:18,540
如果你有工作，在移动界面上的时间，这显然是最好的选择。

841
00:53:18,540 --> 00:53:23,320
>> 我觉得一般的CS50项目，你会希望选择一个或另一个。

842
00:53:23,320 --> 00:53:27,990
换句话说，你想使一个移动应用程序或者你想在桌面网站。

843
00:53:27,990 --> 00:53:32,200
排序并决定你要去哪里这一点。

844
00:53:32,200 --> 00:53:35,360
但是，如果你想在以后展开了，可能是你最好的赌注是

845
00:53:35,360 --> 00:53:37,360
作为其他的另一个接口。

846
00:53:51,650 --> 00:53:56,340
我的WordPress的开发为基础的网站的一点点经验。

847
00:53:56,340 --> 00:53:58,670
我托管在WordPress的个人网站一段时间。

848
00:53:58,670 --> 00:54:02,310
这些类型的框架可能是好的，就像很基本的东西。

849
00:54:02,310 --> 00:54:07,050
通常情况下你会正好碰上了很多定制性的问题虽然。

850
00:54:07,050 --> 00:54:10,940
你想拥有的东西看起来某种方式或一定的方式

851
00:54:10,940 --> 00:54:14,510
你只是不能因为它是硬连接到系统中

852
00:54:14,510 --> 00:54:17,480
你这是怎么要做的事情，可能是有点问题的。

853
00:54:17,480 --> 00:54:22,020
那种从那时起我一直更倾向于从地上爬起来地盘工作。

854
00:54:22,020 --> 00:54:26,840
的事情，比如博客数据库和诸如此类的事情它真的不是那么难建立一个框架。

855
00:54:26,840 --> 00:54:29,970
如果你真的对捉襟见肘的时候，你当然可以使用像WordPress的

856
00:54:29,970 --> 00:54:33,120
或者诸如此类的事情一个博客。

857
00:54:33,120 --> 00:54:38,790
这样的东西，博客存储和做是不是真的够硬的

858
00:54:38,790 --> 00:54:41,500
如果你运行任何这些类型的东西，你可能最好只是为了

859
00:54:41,500 --> 00:54:43,500
做一个内部版本。

860
00:54:43,500 --> 00:54:48,350
>> 我认为这是它，所以再次感谢您的到来。

861
00:54:48,350 --> 00:54:51,960
我们非常喜欢你说话的家伙，希望你学到了一些东西。

862
00:54:51,960 --> 00:54:55,350
[奔]我们很乐于交谈 - 我们必须去，但我们很乐意多谈外

863
00:54:55,350 --> 00:55:01,650
如果你有另外一个问题。再次感谢。 [鼓掌]

864
00:55:03,750 --> 00:55:06,000
[CS50.TV]