1
00:00:00,000 --> 00:00:11,370

2
00:00:11,370 --> 00:00:12,370
JEFFREY LICHT：您好。

3
00:00:12,370 --> 00:00:13,550
我杰弗里·利希特。

4
00:00:13,550 --> 00:00:17,890
而我在这里跟大家介绍一下
哈佛大学图书馆和建筑明天的

5
00:00:17,890 --> 00:00:20,870
今天的图书馆，我猜。

6
00:00:20,870 --> 00:00:23,040
所以这里的背景下，
本届会议的球场

7
00:00:23,040 --> 00:00:26,930
本质上是有
很多书目数据

8
00:00:26,930 --> 00:00:28,400
可在哈佛图书馆。

9
00:00:28,400 --> 00:00:33,434
并有机会，
通过一些工具

10
00:00:33,434 --> 00:00:36,350
而这正在开发的一个项目，
以获得信息的访问

11
00:00:36,350 --> 00:00:42,430
并把它带到的地方是，
哈佛大学图书馆是不是现在做，

12
00:00:42,430 --> 00:00:45,460
做新的东西呢，实验
并发挥与它周围。

13
00:00:45,460 --> 00:00:52,413
>> 这样的入口点，这是一个API
所谓哈佛图书馆云，这

14
00:00:52,413 --> 00:00:57,650
是一个开放的元数据服务器，
我就说说现在。

15
00:00:57,650 --> 00:01:02,595
这样的背景是，有一
很多东西在哈佛图书馆。

16
00:01:02,595 --> 00:01:07,150
我们有超过13万条书目
记录，数以百万计的图像，

17
00:01:07,150 --> 00:01:11,090
和成千上万的检索工具，它
基本上文件描述

18
00:01:11,090 --> 00:01:15,500
收藏，说什么
在他们的论文盒

19
00:01:15,500 --> 00:01:21,080
等等，代表了
一万个人文件。

20
00:01:21,080 --> 00:01:24,290
而且还有一个很大的
信息库中有

21
00:01:24,290 --> 00:01:28,180
有关内容如何使用的
可能是感兴趣的人

22
00:01:28,180 --> 00:01:32,400
谁可能要与它合作。

23
00:01:32,400 --> 00:01:36,150
>> 因此，所有的信息
图书馆有元数据。

24
00:01:36,150 --> 00:01:39,500
这样的元数据是关于数据的数据。

25
00:01:39,500 --> 00:01:42,070
所以，当我们谈论
这就是信息

26
00:01:42,070 --> 00:01:44,890
可通过库
云的提供，

27
00:01:44,890 --> 00:01:47,760
它不一定
实际文件

28
00:01:47,760 --> 00:01:53,060
本身，不一定全
书籍或完整的图像文字，

29
00:01:53,060 --> 00:01:54,890
虽然实际上可能是这种情况。

30
00:01:54,890 --> 00:01:57,550
但它确实
关于数据的信息。

31
00:01:57,550 --> 00:02:00,909
>> 所以，你能想到的编目
信息，电话号码，科目，

32
00:02:00,909 --> 00:02:02,700
多少的副本
本书有什么

33
00:02:02,700 --> 00:02:06,380
是的版本，有哪些
格式，作者，等等。

34
00:02:06,380 --> 00:02:12,250
因此，有大量的信息约
集合中的信息，

35
00:02:12,250 --> 00:02:14,400
本身就是一种天生有用。

36
00:02:14,400 --> 00:02:19,230
虽然如果你
做了深入的研究，

37
00:02:19,230 --> 00:02:25,160
你显然希望得到实际
内容本身看数据，

38
00:02:25,160 --> 00:02:30,140
在方面的元数据是非常有用的
既胼分析作为一个整体，

39
00:02:30,140 --> 00:02:33,870
像集合中有什么事情。

40
00:02:33,870 --> 00:02:35,520
他们如何与？

41
00:02:35,520 --> 00:02:39,482
它可以帮助你真正找到其他的东西，
这是它真正的主要目的。

42
00:02:39,482 --> 00:02:41,190
的点
元数据和目录

43
00:02:41,190 --> 00:02:43,230
是帮助你找到所有
这就是信息

44
00:02:43,230 --> 00:02:46,590
现有的馆藏之内。

45
00:02:46,590 --> 00:02:53,690
>> 因此，这是元数据的一个例子
一本书的哈佛大学图书馆。

46
00:02:53,690 --> 00:02:56,370
所以它的存在。

47
00:02:56,370 --> 00:02:59,850
你可以看到它的
实际上中等复杂。

48
00:02:59,850 --> 00:03:04,610
和元数据的价值的一部分
哈佛图书馆系统内

49
00:03:04,610 --> 00:03:09,320
是，它已经排序
建成了由编目

50
00:03:09,320 --> 00:03:12,720
组装应用的人
大量的专业知识和技能

51
00:03:12,720 --> 00:03:20,030
并认为随着时间的推移，
其中有一个很大的价值。

52
00:03:20,030 --> 00:03:25,450
>> 所以，如果你看看这个纪录
附注的爱丽丝，你可以找到

53
00:03:25,450 --> 00:03:32,590
你已经拿到了冠军，谁写的，在
作者和所有不同的科目

54
00:03:32,590 --> 00:03:35,380
人们已编目成。

55
00:03:35,380 --> 00:03:40,110
你可以看到另外还有，在
除了很多好的信息

56
00:03:40,110 --> 00:03:42,852
在这里，有一些重复。

57
00:03:42,852 --> 00:03:45,560
有很多复杂的那
通过元数据反映

58
00:03:45,560 --> 00:03:46,300
你有。

59
00:03:46,300 --> 00:03:50,320
>> 因此，这本书的一个标题是
爱丽丝梦游仙境。

60
00:03:50,320 --> 00:03:53,880
所以这是一个带注释
版本的书。

61
00:03:53,880 --> 00:03:56,380
但它也被称为注释
爱丽丝，爱丽丝梦游

62
00:03:56,380 --> 00:03:58,570
仙境因为
它的一些东西，

63
00:03:58,570 --> 00:04:00,430
马丁·加德纳写道：
并注明了这本书。

64
00:04:00,430 --> 00:04:03,369
并有很多伟大的信息
关于逻辑谜题和东西

65
00:04:03,369 --> 00:04:05,410
在爱丽丝你
大概不知道。

66
00:04:05,410 --> 00:04:07,000
所以，你应该去阅读它。

67
00:04:07,000 --> 00:04:11,940
>> 但是你可以看到有
很多细节在这里，

68
00:04:11,940 --> 00:04:15,340
包括标识符，当它
创建，它是从哪里来的，

69
00:04:15,340 --> 00:04:17,420
在哈佛的条款
系统，等等。

70
00:04:17,420 --> 00:04:20,350
所以这是一个样本
元数据的类型

71
00:04:20,350 --> 00:04:24,340
你可能会看到一本书中
哈佛大学图书馆收藏。

72
00:04:24,340 --> 00:04:26,680
>> 这是完全不同的东西。

73
00:04:26,680 --> 00:04:32,610
因此，有一个叫做系统
VIA哈佛，基本上

74
00:04:32,610 --> 00:04:39,990
被编目的图像和艺术对象
并在整个哈佛视觉的东西，

75
00:04:39,990 --> 00:04:44,010
并增加了一些元数据
对他们来说，他们的分类，

76
00:04:44,010 --> 00:04:49,200
并且，在某些情况下，提供
小缩略图

77
00:04:49,200 --> 00:04:51,250
你可以采取
看看，如果你愿意的话。

78
00:04:51,250 --> 00:04:54,240
>> 因此，这是一个例子
你有一个板块的元数据

79
00:04:54,240 --> 00:04:57,840
从，据推测，爱丽丝梦游仙境。

80
00:04:57,840 --> 00:05:00,499
你可以看到有
少在这里的元数据。

81
00:05:00,499 --> 00:05:02,040
这只是一个不同类型的对象。

82
00:05:02,040 --> 00:05:03,425
所以有较少的信息。

83
00:05:03,425 --> 00:05:07,790
>> 你大多有一个事实，即，呼叫
数，基本上是谁创造了​​它， - 

84
00:05:07,790 --> 00:05:10,410
>> 我们不知道在创建时。

85
00:05:10,410 --> 00:05:13,320
>>  - 兼标题。

86
00:05:13,320 --> 00:05:14,300
>> 另一个例子。

87
00:05:14,300 --> 00:05:16,380
这是一个发现的援助。

88
00:05:16,380 --> 00:05:19,030
所以这是刘易斯的集合
卡罗尔的论文在哈佛。

89
00:05:19,030 --> 00:05:23,601
因此，这说明了什么
在该集合。

90
00:05:23,601 --> 00:05:26,100
所以有人走过，并
通过所有的箱子看

91
00:05:26,100 --> 00:05:32,220
而其编，给予一定的背景，
写的什么是这里的总结。

92
00:05:32,220 --> 00:05:35,290
如果你看看
进一步在此，本

93
00:05:35,290 --> 00:05:39,620
那张页面和页面
和页面，但会告诉你

94
00:05:39,620 --> 00:05:41,860
什么信什么
建于什么样箱

95
00:05:41,860 --> 00:05:44,289
存在于整个集合。

96
00:05:44,289 --> 00:05:46,330
不过这是后话
，如果你在哈佛，

97
00:05:46,330 --> 00:05:50,720
你可以去和实际的物理期待
起来，大概看看。

98
00:05:50,720 --> 00:05:53,440
>> 所以这是所有伟大的。

99
00:05:53,440 --> 00:05:54,450
这种元数据的有用。

100
00:05:54,450 --> 00:05:56,327
这是哈佛图书馆系统。

101
00:05:56,327 --> 00:05:58,910
有在线工具，你在哪里
可以去看看它，

102
00:05:58,910 --> 00:05:59,993
看到它，并搜寻它。

103
00:05:59,993 --> 00:06:02,810
你可以切片和切块
它在许多不同的方式。

104
00:06:02,810 --> 00:06:06,920
>> 但它确实只有当
你是一个人坐下

105
00:06:06,920 --> 00:06:12,600
在Web浏览器或某事或
你的手机，并通过它浏览。

106
00:06:12,600 --> 00:06:16,730
它不是在真正可用
任何一种可用的时尚

107
00:06:16,730 --> 00:06:19,520
对于其它系统，或
其他计算机使用，

108
00:06:19,520 --> 00:06:21,500
不与内部系统
哈佛图书馆

109
00:06:21,500 --> 00:06:24,890
但在外界系统，
只是其他人一般。

110
00:06:24,890 --> 00:06:30,210
所以，问题是，我们如何能
使其向计算机提供

111
00:06:30,210 --> 00:06:33,560
这样我们就可以做更多有趣的
东西与它不仅仅是

112
00:06:33,560 --> 00:06:36,550
浏览它自己呢？

113
00:06:36,550 --> 00:06:39,766
>> 那么，为什么要这么做？

114
00:06:39,766 --> 00:06:41,140
有很多的可能性。

115
00:06:41,140 --> 00:06:43,980
一个是你可以建立一个完全
浏览不同的方式

116
00:06:43,980 --> 00:06:46,962
这是可用的内容
通过哈佛大学图书馆。

117
00:06:46,962 --> 00:06:48,670
我会告诉你一
后来被称为Stacklife，

118
00:06:48,670 --> 00:06:52,440
它有一个完全不同的
承担寻找的内容。

119
00:06:52,440 --> 00:06:54,560
>> 你可以建立一个推荐引擎。

120
00:06:54,560 --> 00:06:57,955
所以哈佛库不处于
说法业务，你喜欢这本书。

121
00:06:57,955 --> 00:07:01,080
然后去看看这17等
你可能会感兴趣的图书

122
00:07:01,080 --> 00:07:03,200
或者这18其他图像。

123
00:07:03,200 --> 00:07:06,040
但是，可以肯定
是一个有价值的功能。

124
00:07:06,040 --> 00:07:09,272
并给出了元数据，它可能
有可能把该在一起。

125
00:07:09,272 --> 00:07:11,980
你可能有不同的需求
搜索的内容方面，

126
00:07:11,980 --> 00:07:16,200
如可能，尽管工具
可用的库使

127
00:07:16,200 --> 00:07:18,450
可用，您可能希望
以不同的方式来搜索

128
00:07:18,450 --> 00:07:21,847
或优化用于特定用途的情况下，
这也许是非常专业的。

129
00:07:21,847 --> 00:07:23,930
也许只有少数
人在世界上谁

130
00:07:23,930 --> 00:07:25,846
要搜索的内容
以这种方式，但它

131
00:07:25,846 --> 00:07:28,985
将是巨大的，如果我们
可以让他们做到这一点。

132
00:07:28,985 --> 00:07:30,860
有很多的分析
在短短的人们如何

133
00:07:30,860 --> 00:07:33,860
使用这将是真正的内容
有趣的了解，找出

134
00:07:33,860 --> 00:07:37,280
什么书都被使用，
什么都没有，等等。

135
00:07:37,280 --> 00:07:41,670
然后还有很多的
机会整合

136
00:07:41,670 --> 00:07:45,210
与其他信息
那是在那里在网络上。

137
00:07:45,210 --> 00:07:46,880
所以我们have--

138
00:07:46,880 --> 00:07:50,260
>> 例如，NPR有
书评段，

139
00:07:50,260 --> 00:07:53,090
他们采访
有关书籍的作者。

140
00:07:53,090 --> 00:07:56,837
因此，这将是巨大的，如果你是
找了一本书，在哈佛

141
00:07:56,837 --> 00:07:59,670
图书馆，和你说，OK，还有
过了笔者的采访。

142
00:07:59,670 --> 00:08:00,878
让我们去看看那个。

143
00:08:00,878 --> 00:08:05,461
或者有一个维基百科页面，作为
权威，学术参考

144
00:08:05,461 --> 00:08:07,710
关于这本书，你
可能要看一看。

145
00:08:07,710 --> 00:08:12,600
>> 有这些类型的源
遍布网络。

146
00:08:12,600 --> 00:08:16,555
并把它们放在一起
可能是一个伟大的使用

147
00:08:16,555 --> 00:08:18,930
给别人看的
内容寻找的东西。

148
00:08:18,930 --> 00:08:20,180
但它也没有
之类的话，你会

149
00:08:20,180 --> 00:08:23,205
希望库负责
对于下降和追捕

150
00:08:23,205 --> 00:08:25,455
所有这些不同的来源
和堵塞在一起

151
00:08:25,455 --> 00:08:28,920
因为他们是不断变化的。

152
00:08:28,920 --> 00:08:33,570
他们认为什么是重要的5月
不是你的想法是很重要的。

153
00:08:33,570 --> 00:08:36,929
>> 甚至更多的话，基本上有一个
很多东西我们都没有想到呢。

154
00:08:36,929 --> 00:08:42,222
因此，如果我们可以打开这件事，更
除了半打左右的人，

155
00:08:42,222 --> 00:08:45,174
谁在看这一个
定期能想到的想法

156
00:08:45,174 --> 00:08:47,340
和按摩的数据，并
做他们想做的事情。

157
00:08:47,340 --> 00:08:49,920

158
00:08:49,920 --> 00:08:54,045
>> 所以，我们想使这个
提供给世界的数据。

159
00:08:54,045 --> 00:08:55,670
嗯，有一对夫妇的并发症。

160
00:08:55,670 --> 00:08:58,540
之一是，该元数据
是在不同的系统。

161
00:08:58,540 --> 00:09:01,110
它在不同的格式。

162
00:09:01,110 --> 00:09:04,719
所以有一些正常化
这需要发生，

163
00:09:04,719 --> 00:09:08,010
这是正常化的过程
把东西从不同的格式

164
00:09:08,010 --> 00:09:12,940
并将其映射到一个单一格式
使得字段将匹配。

165
00:09:12,940 --> 00:09:15,160
>> 有一些版权限制。

166
00:09:15,160 --> 00:09:21,010
奇怪的是，目录条目
一本书是对版权负责。

167
00:09:21,010 --> 00:09:24,060
因此，即使它只是
从书中获得的信息，

168
00:09:24,060 --> 00:09:25,330
它的版权保护。

169
00:09:25,330 --> 00:09:28,400
并根据究竟是谁
创建元数据，

170
00:09:28,400 --> 00:09:32,175
有可能是在谁的限制
可以分发，类似to--

171
00:09:32,175 --> 00:09:33,402
>> 我不知道。

172
00:09:33,402 --> 00:09:36,110
它可以是或可以不是类似于
这首歌的歌词的情况下，

173
00:09:36,110 --> 00:09:36,610
例如。

174
00:09:36,610 --> 00:09:38,560
所以，我们都知道该如何平移出。

175
00:09:38,560 --> 00:09:40,450
所以，你需要避开这个问题。

176
00:09:40,450 --> 00:09:44,910
>> 然后另一块是
这有很多的数据。

177
00:09:44,910 --> 00:09:52,420
所以，如果我是一个谁愿意工作
与数据或有一个很酷的想法，

178
00:09:52,420 --> 00:09:55,350
处理14000000
我的笔记本电脑记录

179
00:09:55,350 --> 00:09:57,487
可能是有问题的
并且难以管理。

180
00:09:57,487 --> 00:09:59,320
所以，我们要减少
为人们的障碍

181
00:09:59,320 --> 00:10:02,130
要能够与数据一起工作。

182
00:10:02,130 --> 00:10:07,880
>> 因此，办法，希望地址
所有这些问题是两部分。

183
00:10:07,880 --> 00:10:11,770
其中之一就是建立一个平台，需要
从所有这些不同来源的数据

184
00:10:11,770 --> 00:10:14,350
并加剧它，规范化，
丰富它，使

185
00:10:14,350 --> 00:10:16,650
它在一个位置可用。

186
00:10:16,650 --> 00:10:20,950
它使得它可以通过
一个公共API，人们可以调用。

187
00:10:20,950 --> 00:10:24,430
>> 因此，一个API是应用程序
编程接口。

188
00:10:24,430 --> 00:10:28,930
它基本上是指一种
端点系统或技术

189
00:10:28,930 --> 00:10:31,720
可以调用和找回数据的
的方式结构化格式

190
00:10:31,720 --> 00:10:32,900
它可以被使用。

191
00:10:32,900 --> 00:10:36,060
因此，它不依赖
要去网站

192
00:10:36,060 --> 00:10:37,970
刮数据关闭
它，例如。

193
00:10:37,970 --> 00:10:40,690

194
00:10:40,690 --> 00:10:45,010
>> 所以这是的主页
图书馆云项目API，

195
00:10:45,010 --> 00:10:47,220
这实质上是它的两个版本。

196
00:10:47,220 --> 00:10:50,130
所以它的第二次迭代
试图让所有的数据

197
00:10:50,130 --> 00:10:53,280
提供给世界。

198
00:10:53,280 --> 00:10:59,560
所以它的
http://api.lib.harvard.edu/v2/items。

199
00:10:59,560 --> 00:11:03,830
而刚刚打破下来
一点点，这是什么意思

200
00:11:03,830 --> 00:11:06,115
是，这是在API两个版本。

201
00:11:06,115 --> 00:11:08,490
有一个版本的一个，这
我不想多谈。

202
00:11:08,490 --> 00:11:09,750
但有一个版本之一。

203
00:11:09,750 --> 00:11:14,740
>> 如果你调用这个
API，你得到的物品。

204
00:11:14,740 --> 00:11:20,640
和的想法的一部分
API是一个API是一个合同。

205
00:11:20,640 --> 00:11:23,440
这件事情，是
不会改变的。

206
00:11:23,440 --> 00:11:24,850
因此，例如， - 

207
00:11:24,850 --> 00:11:27,410
>> 其原因是，如果我
建立某种制度的

208
00:11:27,410 --> 00:11:33,210
将要使用的库云API
显示书籍或帮助人们找到

209
00:11:33,210 --> 00:11:36,190
以独特的方式信息，
我们不希望发生

210
00:11:36,190 --> 00:11:38,940
是我们去如何改变
该API的工作，突然

211
00:11:38,940 --> 00:11:41,340
一切打破在终端用户侧。

212
00:11:41,340 --> 00:11:46,710
所以，如果你正在做API的一部分
提供给世界，这是

213
00:11:46,710 --> 00:11:49,396
很好的做法，把
在它的版本号这样的人

214
00:11:49,396 --> 00:11:51,020
知道是什么版本，他们正在处理。

215
00:11:51,020 --> 00:11:54,300
>> 所以，如果我们决定找到一种更好的方法
使提供这些信息的，

216
00:11:54,300 --> 00:11:57,295
我们可能会改变，要
调用三个版本。

217
00:11:57,295 --> 00:11:59,920
所以大家谁仍然是使用
2版本，还是会正常工作。

218
00:11:59,920 --> 00:12:03,490
但是，版本3将
所有的新东西。

219
00:12:03,490 --> 00:12:06,680

220
00:12:06,680 --> 00:12:09,210
>> 所以这是一个API，但是这
真的看起来像一个URL。

221
00:12:09,210 --> 00:12:11,680
还等什么，这是一个
例如是什么

222
00:12:11,680 --> 00:12:16,615
称之为REST API，它可
以上只是一个普通的网络连接。

223
00:12:16,615 --> 00:12:19,680
你其实可以
去它在浏览器中。

224
00:12:19,680 --> 00:12:28,550
>> 所以在这里我只是打开了Firefox和
去api.lib.harvard.edu/v2/items。

225
00:12:28,550 --> 00:12:31,560
所以我在这里买到
基本上在第一页

226
00:12:31,560 --> 00:12:34,740
从整个结果
设置，我们已经有了项目。

227
00:12:34,740 --> 00:12:37,460
而且它在这里的XML格式。

228
00:12:37,460 --> 00:12:40,130

229
00:12:40,130 --> 00:12:42,210
而且它也被
通过Firefox的美化。

230
00:12:42,210 --> 00:12:45,850
它实际上并不具备所有这些
小扩张和收缩

231
00:12:45,850 --> 00:12:47,880
doohickeys这里。

232
00:12:47,880 --> 00:12:52,520
这是形式的更好
版本的方式来看待它。

233
00:12:52,520 --> 00:12:57,040
>> 但是，这是告诉我们的是
我已经要求所有的项目。

234
00:12:57,040 --> 00:13:03,120
因此，有13289475项。

235
00:13:03,120 --> 00:13:06,150
我期待在第一次
10，起始位置为零

236
00:13:06,150 --> 00:13:09,760
因为在计算机科学
我们总是从零开始。

237
00:13:09,760 --> 00:13:15,150
而我在这里，如果我只是崩溃
这一点，你会看到我已经得到了10个项目。

238
00:13:15,150 --> 00:13:20,410

239
00:13:20,410 --> 00:13:25,210
>> 如果我来看看一个项目，我可以
看到我有关于它的信息。

240
00:13:25,210 --> 00:13:27,400
这是什么所谓MODS的形式。

241
00:13:27,400 --> 00:13:30,860
所以我要切换
回到这里了一会儿。

242
00:13:30,860 --> 00:13:33,750
好不好。

243
00:13:33,750 --> 00:13:37,447
>> 因此，让我们寻找的东西
具体的，因为第一项

244
00:13:37,447 --> 00:13:40,030
发生时，你要拿出
通过整个集合

245
00:13:40,030 --> 00:13:41,750
是，根据定义，是随机的。

246
00:13:41,750 --> 00:13:44,550
因此，让我们来看看一些甜甜圈。

247
00:13:44,550 --> 00:13:46,830
呵呵。

248
00:13:46,830 --> 00:13:49,190
>> 好不好。

249
00:13:49,190 --> 00:13:49,940
所以甜甜圈。

250
00:13:49,940 --> 00:13:55,360
因此，我们发现有80项
引用甜甜圈的集合。

251
00:13:55,360 --> 00:13:57,150
我们期待在第一次10人。

252
00:13:57,150 --> 00:14:01,890
现在，你可以在这里看到的方式，
我说我要找的甜甜圈，

253
00:14:01,890 --> 00:14:04,400
我只是说的东西
URL的查询字符串。

254
00:14:04,400 --> 00:14:09,680
所以，Q等于甜甜圈，你可以
看到更容易在这里一点点。

255
00:14:09,680 --> 00:14:12,131
>> 这基本上意味着有
一个规范的API，这

256
00:14:12,131 --> 00:14:13,880
定义了所有的东西
这些参数的意思。

257
00:14:13,880 --> 00:14:17,150
这意味着我们要
搜索一切为了甜甜圈。

258
00:14:17,150 --> 00:14:24,910
>> 因此，第一项在这里我们有
你可以看到标题是甜甜圈，

259
00:14:24,910 --> 00:14:29,310
并且有一个叫做一个字幕
美国的激情，这一点，我想，

260
00:14:29,310 --> 00:14:31,610
适当的。

261
00:14:31,610 --> 00:14:36,134
有很多的different--

262
00:14:36,134 --> 00:14:38,050
一旦你到了点
获得的数据，

263
00:14:38,050 --> 00:14:41,020
有很多不同的
格式，你可以让它进入。

264
00:14:41,020 --> 00:14:44,050
并有不同的长处
和弱点为所有这些。

265
00:14:44,050 --> 00:14:49,000
所以这一块，你可以看到
在这里，这种形式非常丰富。

266
00:14:49,000 --> 00:14:51,946
和它的标准化。

267
00:14:51,946 --> 00:14:55,040
>> 所以这是一个特定的标题
场，字幕字段。

268
00:14:55,040 --> 00:14:58,950
还有一个备用
标题，一个美国人激情。

269
00:14:58,950 --> 00:15:01,650
有一个与它相关联的名称。

270
00:15:01,650 --> 00:15:03,120
资源类型是文本。

271
00:15:03,120 --> 00:15:06,070
有大量的信息
这里在这种格式。

272
00:15:06,070 --> 00:15:09,480
>> 但也有一堆
不同的格式。

273
00:15:09,480 --> 00:15:11,920
所以我们刚才什么
看着是一种格式

274
00:15:11,920 --> 00:15:17,700
所谓MODS，它代表
元数据对象描述服务，

275
00:15:17,700 --> 00:15:18,250
有可能。

276
00:15:18,250 --> 00:15:23,030
我其实不太肯定的
S.但它是一个相当复杂的格式。

277
00:15:23,030 --> 00:15:24,240
它的默认格式。

278
00:15:24,240 --> 00:15:30,260
>> 但它是一个信守
的所有数据的丰富性

279
00:15:30,260 --> 00:15:33,820
该图书馆有，因为
它非常接近于

280
00:15:33,820 --> 00:15:35,110
图书馆内部使用。

281
00:15:35,110 --> 00:15:39,030
这是一个标准，它是
在全国范围内使用，

282
00:15:39,030 --> 00:15:40,944
世界各地的高校图书馆。

283
00:15:40,944 --> 00:15:42,110
而且它是非常互通。

284
00:15:42,110 --> 00:15:44,852
所以，如果你已经有了一个文件
这是MODS的格式，

285
00:15:44,852 --> 00:15:47,560
你可以把那个给别人
其系统的理解MODS，

286
00:15:47,560 --> 00:15:48,518
他们可以将其导入。

287
00:15:48,518 --> 00:15:50,840
所以这是一个标准。

288
00:15:50,840 --> 00:15:54,250
这是非常明确的，非常具体。

289
00:15:54,250 --> 00:15:58,980
那是什么使得它
可互操作的，因为如果有人说，

290
00:15:58,980 --> 00:16:04,930
这是一个在备用标题
记录，每个人都知道这意味着什么。

291
00:16:04,930 --> 00:16:07,740
在另一面，这是非常复杂的。

292
00:16:07,740 --> 00:16:13,160
>> 所以，如果你看一看
在这里这个纪录，

293
00:16:13,160 --> 00:16:15,320
如果我只是想获得
这个文件的标题，

294
00:16:15,320 --> 00:16:21,150
这本书，这可能是甜甜圈，
美国的激情，解析出来

295
00:16:21,150 --> 00:16:22,940
有点复杂。

296
00:16:22,940 --> 00:16:27,380
而还有另一种
格式被称为都柏林核心，

297
00:16:27,380 --> 00:16:29,730
这是一个非常非常简单的格式。

298
00:16:29,730 --> 00:16:33,764
>> 所以你在这里看到，有没有
标题，副标题，替​​代称号。

299
00:16:33,764 --> 00:16:35,930
这里还有称号，
甜甜圈，一个美国人激情，

300
00:16:35,930 --> 00:16:38,780
而另一个标题，美国的激情。

301
00:16:38,780 --> 00:16:42,907
所以，当你在看什么形式
你想要得到的数据出来，

302
00:16:42,907 --> 00:16:44,740
很多取决于如何
你要使用它。

303
00:16:44,740 --> 00:16:46,573
您使用的
互操作性还是你

304
00:16:46,573 --> 00:16:49,970
想要的东西，简单的说
可能是比较容易的工作？

305
00:16:49,970 --> 00:16:56,002
>> 在另一面，很多的
排序方式压扁了。

306
00:16:56,002 --> 00:16:58,460
你可能会失去的细微差别
什么是特定领域的手段

307
00:16:58,460 --> 00:17:02,960
如果你正在处理的都柏林核心，
你不会得到与MODS。

308
00:17:02,960 --> 00:17:06,462
因此，这些都是两个格式
你可以走出API的。

309
00:17:06,462 --> 00:17:08,920
基本上，我们保持
其背后的MODS的场景。

310
00:17:08,920 --> 00:17:14,179
但是，我们可以给你它和MODS
都柏林核心和其他任何为好。

311
00:17:14,179 --> 00:17:16,470
其他考虑因素
你要找的数据

312
00:17:16,470 --> 00:17:21,210
是你能得到它的无论是JSON，这
代表JavaScript对象符号，

313
00:17:21,210 --> 00:17:24,720
或XML，它代表
可扩展标记语言。

314
00:17:24,720 --> 00:17:30,080
而这些数据均表示
具有完全相同的数据，正好

315
00:17:30,080 --> 00:17:31,080
相同的字段。

316
00:17:31,080 --> 00:17:33,644
但他们只是
语法不同。

317
00:17:33,644 --> 00:17:40,401
>> 因此，这是A--

318
00:17:40,401 --> 00:17:41,400
那么，就让我们进行切换。

319
00:17:41,400 --> 00:17:47,490
所以这是我们查询
甜甜圈的XML格式。

320
00:17:47,490 --> 00:17:53,470
如果我只是切换这是JSON，
我可以看到它看起来不一样。

321
00:17:53,470 --> 00:17:58,580
所以，现在，这是同样的内容，
但不同的结构。

322
00:17:58,580 --> 00:18:00,080
有较少的尖括号。

323
00:18:00,080 --> 00:18:02,530
还有更简洁。

324
00:18:02,530 --> 00:18:06,440
>> 而这是一个格式，如果
工作在网络环境下，

325
00:18:06,440 --> 00:18:09,680
你最有可能会
到想要使用，因为一个

326
00:18:09,680 --> 00:18:12,630
的好东西大约是JSON
它是用JavaScript兼容。

327
00:18:12,630 --> 00:18:17,680
所以，如果我写的Web应用程序，我可以拉
在JSON，只是用它直接工作。

328
00:18:17,680 --> 00:18:20,187
而使用XML，这是一个
稍微有点复杂。

329
00:18:20,187 --> 00:18:21,520
如此反复，这些都是有用的。

330
00:18:21,520 --> 00:18:26,387
他们只是在不同的使用情况
人们可能会想使用它们。

331
00:18:26,387 --> 00:18:26,886
好不好。

332
00:18:26,886 --> 00:18:29,810

333
00:18:29,810 --> 00:18:31,680
所以回API。

334
00:18:31,680 --> 00:18:32,900
所以，我们可以搜索for--

335
00:18:32,900 --> 00:18:36,220
>> 我举一个例子
寻找甜甜圈。

336
00:18:36,220 --> 00:18:39,330
我们还可以搜索只是在一个
在此范围内特定领域。

337
00:18:39,330 --> 00:18:41,310
因此，而不是搜索
整个记录，

338
00:18:41,310 --> 00:18:43,870
我可以只搜索标题字段。

339
00:18:43,870 --> 00:18:48,810
所以现在有25个东西，
具有甜甜圈的称号，其中之一

340
00:18:48,810 --> 00:18:52,430
即将恢复
管理湿地

341
00:18:52,430 --> 00:18:54,990
在圆环的孔的
计划，这可能是

342
00:18:54,990 --> 00:18:58,970
我们期待并不一定是什么
因为当我们正在寻找甜甜圈。

343
00:18:58,970 --> 00:19:02,790

344
00:19:02,790 --> 00:19:05,490
>> 您还可以，当你
处理一个API--

345
00:19:05,490 --> 00:19:08,827
>> 有一个API的一部分是给
人们访问大数据集。

346
00:19:08,827 --> 00:19:11,410
并有不同的一对夫妇
工具，你可以用它来做到这一点。

347
00:19:11,410 --> 00:19:14,170
其一是，很简单，你
可浏览数据。

348
00:19:14,170 --> 00:19:17,340
所以，就像你做一个查询
通过Web界面，

349
00:19:17,340 --> 00:19:19,470
你可以看看一个页面，
第二页，第三页。

350
00:19:19,470 --> 00:19:22,040
你可以这样做
通过API的事情。

351
00:19:22,040 --> 00:19:24,150
你只需要在
明确的，你是怎么做到的。

352
00:19:24,150 --> 00:19:29,511
>> 因此，举例来说，如果我要找
我的第一个查询在这里，

353
00:19:29,511 --> 00:19:32,510
在那里我做了搜索的东西
在标题甜甜圈，我可以说，

354
00:19:32,510 --> 00:19:35,415
和极限等于20，这意味着
给我的第一个20条记录，而不是

355
00:19:35,415 --> 00:19:38,540
第10位，这是默认的，
因为我想看看20的时间。

356
00:19:38,540 --> 00:19:43,435
或者，我可以说，设置
开始等于20和限

357
00:19:43,435 --> 00:19:47,150
等于20，这将给
我记录了21至40。

358
00:19:47,150 --> 00:19:52,680
>> 所以我想的东西
带走这里

359
00:19:52,680 --> 00:19:57,290
我们使用的查询字符串
上设置的查询参数。

360
00:19:57,290 --> 00:20:02,760
它可以让你控制
你会得到什么。

361
00:20:02,760 --> 00:20:05,980
>> 您可以使用另一种工具 - 

362
00:20:05,980 --> 00:20:09,250
>> 这是真正有用的
条款探索数据。

363
00:20:09,250 --> 00:20:10,840
>> --is一些所谓的小面。

364
00:20:10,840 --> 00:20:15,530
所以说，小面是
不一定普遍。

365
00:20:15,530 --> 00:20:16,880
但是你们都见过。

366
00:20:16,880 --> 00:20:18,630
如果你看一看
亚马逊，例如

367
00:20:18,630 --> 00:20:20,870
你做一个搜索
甜甜圈的书籍，

368
00:20:20,870 --> 00:20:27,080
在这里，他们已经有了一个系列丛书，
他们正在按类别分组，

369
00:20:27,080 --> 00:20:30,470
你会得到不同的类别，
多少在每个类别的书籍

370
00:20:30,470 --> 00:20:31,330
显示。

371
00:20:31,330 --> 00:20:33,420
>> 因此，这基本上是一个方面。

372
00:20:33,420 --> 00:20:37,570
你把所有的书，1800
匹配甜甜圈亚马逊的书籍。

373
00:20:37,570 --> 00:20:39,820
其中12个是在
早餐类别。

374
00:20:39,820 --> 00:20:43,100
在糕点和烘焙21，
等，等等。

375
00:20:43,100 --> 00:20:47,670
>> 因此，这的确是一个非常有用
工具游览内容

376
00:20:47,670 --> 00:20:53,260
在图书馆内，以及
因为当你看一个方面，

377
00:20:53,260 --> 00:20:56,520
它给你什么科目的想法
存在的，喜欢什么类型的科目

378
00:20:56,520 --> 00:20:58,510
是你的查询集内最流行的。

379
00:20:58,510 --> 00:21:00,950
它可以帮助你赶走和探索。

380
00:21:00,950 --> 00:21:02,770
因此，我们可以做同样的事情。

381
00:21:02,770 --> 00:21:05,940
>> 如果我们要使用的
API，看看方面，

382
00:21:05,940 --> 00:21:08,950
我们添加另一个参数
我们的朋友的查询字符串。

383
00:21:08,950 --> 00:21:12,540
所以面等于逗号分隔
是我们想要的面名单。

384
00:21:12,540 --> 00:21:14,790
这样的刻面中的一个可能是主题。

385
00:21:14,790 --> 00:21:16,565
另一种可能是语言。

386
00:21:16,565 --> 00:21:19,665
所以，如果我们运行的查询，我们get--

387
00:21:19,665 --> 00:21:23,372

388
00:21:23,372 --> 00:21:24,830
它看起来非常这里一样。

389
00:21:24,830 --> 00:21:29,010
但是，我们已经添加到最后
列表的一组小刻面。

390
00:21:29,010 --> 00:21:34,060
因此，我们有一个叫做主题方面。

391
00:21:34,060 --> 00:21:40,250
因此，这是在告诉我们，如果我期待
在我80结果从甜甜圈查询，

392
00:21:40,250 --> 00:21:42,100
其中13个有
受到美国。

393
00:21:42,100 --> 00:21:43,684
有三个主题甜甜圈。

394
00:21:43,684 --> 00:21:45,600
有三个主题
湿地修复，

395
00:21:45,600 --> 00:21:47,720
这可能是我们在甜甜圈洞。

396
00:21:47,720 --> 00:21:51,780
他们两个人，辛普森，
等，等等。

397
00:21:51,780 --> 00:21:59,211
>> 因此，这可以是如果有用
要缩小搜索范围。

398
00:21:59,211 --> 00:22:00,210
它可以帮助你做到这一点。

399
00:22:00,210 --> 00:22:03,580
特别是如果你有
不止，说80的效果。

400
00:22:03,580 --> 00:22:05,980
>> 同样，我们也问
对于语言方面。

401
00:22:05,980 --> 00:22:14,790
因此，如果我们看看我们的结果，我们可以看到76
他们都是英文的，四家在法国，

402
00:22:14,790 --> 00:22:19,620
两人在西班牙，2，我认为这是
未定义或未知，荷兰和拉丁美洲。

403
00:22:19,620 --> 00:22:22,830
所以我觉得拉丁
甜甜圈结果，再次

404
00:22:22,830 --> 00:22:24,922
有无关焙烤食品。

405
00:22:24,922 --> 00:22:25,630
不过你去那里。

406
00:22:25,630 --> 00:22:31,420

407
00:22:31,420 --> 00:22:38,630
>> 如此这是那种你展示
如何将数据内容取回

408
00:22:38,630 --> 00:22:41,270
从API刚刚经历
网页浏览器，这是伟大的。

409
00:22:41,270 --> 00:22:44,320
但它不是真正的你会
通常是用在为它的API。

410
00:22:44,320 --> 00:22:48,710
你怎么这么一个例子
能真正做到这一点是我

411
00:22:48,710 --> 00:22:54,720
写了一个超小程序，
其中，再次，做我的甜甜圈搜索

412
00:22:54,720 --> 00:22:59,010
并选择了几个字段
并在表中显示它们。

413
00:22:59,010 --> 00:23:01,610
所以这是非常多的
同样的内容，我们只是

414
00:23:01,610 --> 00:23:04,830
锯了几场拉出。

415
00:23:04,830 --> 00:23:12,090
所以冠军，名单
什么样的书的位置

416
00:23:12,090 --> 00:23:15,120
大约是，语言，
等，等等。

417
00:23:15,120 --> 00:23:20,480
>> 那么如何实际发生的，因为
我想我们来看看一些代码，

418
00:23:20,480 --> 00:23:22,420
is--

419
00:23:22,420 --> 00:23:28,060
>> 我们在这里是一个简单的HTML
页面，该页面显示的文本，

420
00:23:28,060 --> 00:23:32,900
欢迎库云
然后显示结果的一个表。

421
00:23:32,900 --> 00:23:37,790
并有明显的没有结果的
当页面被加载该表。

422
00:23:37,790 --> 00:23:41,380
但是我们在做什么
是，首先，我们

423
00:23:41,380 --> 00:23:46,290
加载一个名为库
jQuery的，这基本上是

424
00:23:46,290 --> 00:23:52,030
一个JavaScript库，这使得它
很容易操纵的JavaScript

425
00:23:52,030 --> 00:23:58,780
本身，HTML和创建网页，
客户端逻辑和网页。

426
00:23:58,780 --> 00:24:01,595
>> 所以，我们在这里是jQuery的
有一个名为Get方法，

427
00:24:01,595 --> 00:24:05,270
基本上会去
一个URL，其​​中，在这种情况下，

428
00:24:05,270 --> 00:24:09,070
这是熟悉的期待URL。

429
00:24:09,070 --> 00:24:14,440
然后将得到的内容
该URL，然后在其上运行的功能。

430
00:24:14,440 --> 00:24:19,240
所以我们说去api.lib.harvard / EDU。

431
00:24:19,240 --> 00:24:20,060
搜索甜甜圈。

432
00:24:20,060 --> 00:24:21,300
给我们20个记录。

433
00:24:21,300 --> 00:24:28,590
然后运行该功能，
我选择，它传递的数据。

434
00:24:28,590 --> 00:24:34,430
并且该数据是JSON那
从API得到恢复。

435
00:24:34,430 --> 00:24:40,120
>> 然后我们在说，内
数据有一个名为项目现场。

436
00:24:40,120 --> 00:24:48,117
如果我去看看回
这些结果是在这里的，

437
00:24:48,117 --> 00:24:49,200
有什么东西called--

438
00:24:49,200 --> 00:24:50,220
>> 好了，这就是所谓的项目。

439
00:24:50,220 --> 00:24:53,520
因此，这可能是因为。

440
00:24:53,520 --> 00:25:01,840
而它的作用是
经过每个项目

441
00:25:01,840 --> 00:25:05,300
然后调用另一个
功能上的每个项目。

442
00:25:05,300 --> 00:25:08,440
而且基本功能
走的是价值

443
00:25:08,440 --> 00:25:12,010
的项目，这是
基本上是个人记录

444
00:25:12,010 --> 00:25:18,220
使我们能够拉出来的称号，
覆盖率和语言。

445
00:25:18,220 --> 00:25:21,640
>> 因此，我们呼吁每一个函数
我们得到了来自API回来项目。

446
00:25:21,640 --> 00:25:25,397
如果你只是看看
在这一块就在这里，

447
00:25:25,397 --> 00:25:27,230
我们正在做的是什么
我们要创建一个字符串，

448
00:25:27,230 --> 00:25:31,810
这实质上是一些HTML标记
围着一张桌子，用value.title，

449
00:25:31,810 --> 00:25:35,790
这是在标题
对象，value.coverage，

450
00:25:35,790 --> 00:25:36,790
这是覆盖， - 

451
00:25:36,790 --> 00:25:38,225
>> 我们正在做的检查
在这里，看看谁是不确定的

452
00:25:38,225 --> 00:25:40,570
和隐藏它，如果它说不确定，
因为我们并不真正感兴趣

453
00:25:40,570 --> 00:25:41,600
在这一点。

454
00:25:41,600 --> 00:25:42,939
>>  - 并且那么语言。

455
00:25:42,939 --> 00:25:44,730
然后呢我们
做的是追加了

456
00:25:44,730 --> 00:25:48,510
表即
确定此字符串这里。

457
00:25:48,510 --> 00:25:50,790
和jQuery是如何工作的
正是这种在说

458
00:25:50,790 --> 00:25:56,420
在查找表的想法
结果这个文本添加到它。

459
00:25:56,420 --> 00:25:59,380
并且这是表与想法的结果。

460
00:25:59,380 --> 00:26:04,998
所以，你到底是什么了
同是这个页面在这里。

461
00:26:04,998 --> 00:26:06,206
而且为了查看source--

462
00:26:06,206 --> 00:26:11,310

463
00:26:11,310 --> 00:26:13,810
嗯，源实际上不是
更新时发生。

464
00:26:13,810 --> 00:26:18,740
所以你可以看到实际的
该表的结果，虽然在这里。

465
00:26:18,740 --> 00:26:24,770
>> 所以，这只是一个简单的例子
这样做对API一个很基本的查询

466
00:26:24,770 --> 00:26:29,020
且在一些其它显示信息
形成，并没有做什么太花哨。

467
00:26:29,020 --> 00:26:36,370
现在，另一个例子是像
申请由David温伯格

468
00:26:36,370 --> 00:26:39,120
作为演示的这一点，这
基本上显示你

469
00:26:39,120 --> 00:26:44,620
你如何混搭你的结果
从库云API获取

470
00:26:44,620 --> 00:26:46,250
有，说，谷歌图书。

471
00:26:46,250 --> 00:26:52,225
>> 这里的想法是，我可以
运行对谷歌图书的查询，

472
00:26:52,225 --> 00:26:56,060
得到一个完整的文本搜索，得到一些结果
背部，找出这些项目的

473
00:26:56,060 --> 00:27:01,180
实际存在的霍利斯，
图书馆系统，

474
00:27:01,180 --> 00:27:03,200
然后给我联系
回的那些项目。

475
00:27:03,200 --> 00:27:12,730
所以，如果我搜索，它是
月黑风高的夜晚，我

476
00:27:12,730 --> 00:27:16,210
拿回一堆结果
从谷歌，然后一个结果

477
00:27:16,210 --> 00:27:19,460
这是一个时间皱纹。

478
00:27:19,460 --> 00:27:29,330
这些都是存在的联系书籍
在哈佛图书馆系统。

479
00:27:29,330 --> 00:27:32,160
>> 所以我想在这里一点都不
这么多，这可能会或可能不会

480
00:27:32,160 --> 00:27:34,118
是你所希望的方式
搜索库，

481
00:27:34,118 --> 00:27:38,310
但它是一个完全不同的
方式是不提供给你

482
00:27:38,310 --> 00:27:42,884
之前，就像你有没有办法做
在书的全文搜索，即使

483
00:27:42,884 --> 00:27:44,550
是哈佛图书馆系统的一部分。

484
00:27:44,550 --> 00:27:46,870
所以现在这是一种
你能做到这一点。

485
00:27:46,870 --> 00:27:51,930
并且可以在显示它们
任何格式你想要的。

486
00:27:51,930 --> 00:27:55,990
因此，这里的问题是，基本上，
我们正在开拓的人新途径

487
00:27:55,990 --> 00:27:59,080
与数据一起工作。

488
00:27:59,080 --> 00:28:07,925
>> 另一块库云是
它有助于揭露一些使用数据的

489
00:28:07,925 --> 00:28:08,800
该图书馆有。

490
00:28:08,800 --> 00:28:12,630
所以，如果你去图书馆，
你正在寻找的书籍，

491
00:28:12,630 --> 00:28:15,770
你不一定
其实有一个想法，

492
00:28:15,770 --> 00:28:19,080
用于在所有项目
特定的主题，是什么

493
00:28:19,080 --> 00:28:21,200
是人在
社区，无论是

494
00:28:21,200 --> 00:28:24,890
定义为哈佛或
国家或你的类，

495
00:28:24,890 --> 00:28:26,421
他们有什么最有用？

496
00:28:26,421 --> 00:28:28,920
而图书馆实际上有一个
吨左右的信息是什么

497
00:28:28,920 --> 00:28:32,999
是最有用的，因为如果有很多
人们检查了一本书，

498
00:28:32,999 --> 00:28:34,040
告诉你一件事。

499
00:28:34,040 --> 00:28:36,498
一定有某种原因
他们想一探究竟。

500
00:28:36,498 --> 00:28:38,270
很多人把它放在储备。

501
00:28:38,270 --> 00:28:42,520
>> 如果是候补名单上的很多
类，告诉你一件事。

502
00:28:42,520 --> 00:28:45,960
如果教职员工正在检查它
出了很多，本科生都没有，

503
00:28:45,960 --> 00:28:47,200
告诉我的东西。

504
00:28:47,200 --> 00:28:49,280
反之亦然，这也
告诉你一件事。

505
00:28:49,280 --> 00:28:54,680
所以，这将是非常有趣的
把这些信息在那里，让

506
00:28:54,680 --> 00:28:59,969
人们用它来帮助他们找到
图书馆系统内工作。

507
00:28:59,969 --> 00:29:02,260
在另一面，这是
也有一些严重的隐私

508
00:29:02,260 --> 00:29:07,854
关注，因为所述一个
图书馆的核心原则

509
00:29:07,854 --> 00:29:10,770
是我们不打算在告诉
人什么其他人都在阅读。

510
00:29:10,770 --> 00:29:17,360
即使你是说这
本书是签出四倍

511
00:29:17,360 --> 00:29:20,070
在一个特定的月份，
可用于

512
00:29:20,070 --> 00:29:25,252
回链接到特定
人因去匿名数据

513
00:29:25,252 --> 00:29:26,710
并找出谁检查出来。

514
00:29:26,710 --> 00:29:30,792
这样的方式，我们可以avoid--

515
00:29:30,792 --> 00:29:33,750
我们可以尝试提取的方式
所有信息的某些信号

516
00:29:33,750 --> 00:29:36,740
不侵犯
任何人的隐私问题

517
00:29:36,740 --> 00:29:42,150
基本上我们看
10年使用数据， - 

518
00:29:42,150 --> 00:29:43,930
>> 因此，它是在一段很长的时间。

519
00:29:43,930 --> 00:29:50,639
>>  - 并且说，OK，让我们看看如何
很多时候，这工作时，

520
00:29:50,639 --> 00:29:52,930
和谁在这一时期
时间，然后基本

521
00:29:52,930 --> 00:29:56,300
还给了一些，我们称之为
一叠得分，这基本上

522
00:29:56,300 --> 00:29:59,910
代表多少的被使用。

523
00:29:59,910 --> 00:30:01,084
而且number--

524
00:30:01,084 --> 00:30:03,250
很多不同的计算
进入该号码。

525
00:30:03,250 --> 00:30:05,150
 - 但它是一个非常粗糙
公制，让你

526
00:30:05,150 --> 00:30:11,300
如何略知一二
社会可能重视这项工作。

527
00:30:11,300 --> 00:30:16,772
>> 所以另一种连
更充实的应用

528
00:30:16,772 --> 00:30:18,480
即利用
这是值得

529
00:30:18,480 --> 00:30:24,000
所谓Stacklife，这实际上是
可通过主哈佛

530
00:30:24,000 --> 00:30:24,880
图书馆门户网站。

531
00:30:24,880 --> 00:30:26,700
所以，你去library.harvard.edu。

532
00:30:26,700 --> 00:30:29,360
你会看到许多不同的
如何搜索库。

533
00:30:29,360 --> 00:30:32,300
及它们中的一个被称为Stacklife。

534
00:30:32,300 --> 00:30:38,980
>> 而这是一个应用程序
浏览该库的内容，

535
00:30:38,980 --> 00:30:43,490
但完全建立
关于这些API的顶部。

536
00:30:43,490 --> 00:30:46,910
因此，有没有什么特别的东西
怎么回事幕后。

537
00:30:46,910 --> 00:30:49,570
有没有访问
数据你没有。

538
00:30:49,570 --> 00:30:54,090
它使用的API，为您提供
一个完全不同的浏览

539
00:30:54,090 --> 00:30:55,480
的经验。

540
00:30:55,480 --> 00:30:58,570
>> 所以，如果我寻找爱丽丝
仙境在这种情况下，

541
00:30:58,570 --> 00:31:02,600
我得到的结果看起来像
这一点，这是非常much--

542
00:31:02,600 --> 00:31:05,430

543
00:31:05,430 --> 00:31:10,870
>> 它非常类似于任何其它搜索
你可能只是在这种情况下做的，

544
00:31:10,870 --> 00:31:15,730
我们通过排名的项目
stackscore，它给你

545
00:31:15,730 --> 00:31:19,850
如何普及这些略知一二
项目是在社区内。

546
00:31:19,850 --> 00:31:25,610
和这么清楚，爱丽丝梦游仙境
由沃尔特·迪斯尼是非常受欢迎的。

547
00:31:25,610 --> 00:31:36,570
但你也可以看到前四
这里是那些你可能不actually--

548
00:31:36,570 --> 00:31:39,220
>> 事情是高度使用，
但你马上可能不

549
00:31:39,220 --> 00:31:41,240
与爱丽丝梦游仙境连接。

550
00:31:41,240 --> 00:31:44,650
所以，我们的老朋友
注释爱丽丝在这里。

551
00:31:44,650 --> 00:31:46,350
这样我就可以看看它。

552
00:31:46,350 --> 00:31:52,010
现在我期待什么
在基本上是一个集of--

553
00:31:52,010 --> 00:31:53,760
我可以有注释
爱丽丝在这里。

554
00:31:53,760 --> 00:31:56,700
我有一些关于它的信息。

555
00:31:56,700 --> 00:32:00,230
我也有一个stackscore
的，在这种情况下，26。

556
00:32:00,230 --> 00:32:03,169
这告诉我这类的大致
我们是如何走到这stackscore，

557
00:32:03,169 --> 00:32:05,835
喜欢谁检查出来，怎么样
很多时候它被签出，

558
00:32:05,835 --> 00:32:08,440
像教师或本科生，怎么
许多副本的图书馆有，

559
00:32:08,440 --> 00:32:11,300
等，等等。

560
00:32:11,300 --> 00:32:16,460
>> 而且你还可以，够有趣
在这里，几乎浏览堆栈。

561
00:32:16,460 --> 00:32:19,550
因此，这里的数据，
是您展示排序

562
00:32:19,550 --> 00:32:23,547
一个虚拟的代表性
什么样的架子威力

563
00:32:23,547 --> 00:32:25,880
看，如果你要像
所有图书馆的馆藏

564
00:32:25,880 --> 00:32:28,940
并把它们放在一起
在一个无限的货架。

565
00:32:28,940 --> 00:32:30,990
而好处是，我们can--

566
00:32:30,990 --> 00:32:33,380
>> 首先，在
关于这些图书的元数据

567
00:32:33,380 --> 00:32:35,627
常常告诉你，当它被发表。

568
00:32:35,627 --> 00:32:37,085
它会告诉你多少页有。

569
00:32:37,085 --> 00:32:38,459
它可能会告诉你的尺寸。

570
00:32:38,459 --> 00:32:42,930
所以你可以看到这是这里反映
在书的大小方面。

571
00:32:42,930 --> 00:32:46,740
>> 然后我们可以使用
堆叠分数突出

572
00:32:46,740 --> 00:32:49,170
具有较高分数的堆栈的书籍。

573
00:32:49,170 --> 00:32:54,930
因此，如果它是更暗，这意味着，
据推测，它是用来更频繁。

574
00:32:54,930 --> 00:32:57,040
因此，在这种情况下，我
去猜测，这

575
00:32:57,040 --> 00:33:03,226
是爱丽丝梦游仙境的版本
这是非常常用并且最

576
00:33:03,226 --> 00:33:05,100
访问，该库
有一种最副本。

577
00:33:05,100 --> 00:33:06,975
所以，如果你正在寻找
为爱丽丝梦游仙境，

578
00:33:06,975 --> 00:33:10,220
这可能是一个良好的开端。

579
00:33:10,220 --> 00:33:13,500
>> 然后在这里你还可以链接出
于说，亚马逊购买图书，

580
00:33:13,500 --> 00:33:15,182
等，等等。

581
00:33:15,182 --> 00:33:17,140
这里的关键，同样，
与其说是这

582
00:33:17,140 --> 00:33:25,030
是浏览库的最佳方式
或合适的工具适合各种场合。

583
00:33:25,030 --> 00:33:28,400
但它这样做的另一种方式。

584
00:33:28,400 --> 00:33:31,359
并且通过使数据
可以通过一个API，它

585
00:33:31,359 --> 00:33:34,650
是由非常简单的积木，
它允许你搜索的内容，

586
00:33:34,650 --> 00:33:39,420
你可以建立的东西
这样，可以

587
00:33:39,420 --> 00:33:41,520
格外
有价值的一些人。

588
00:33:41,520 --> 00:33:46,640

589
00:33:46,640 --> 00:33:51,860
>> 这就是那种，就像我想
真正说的API是什么

590
00:33:51,860 --> 00:33:56,070
什么是暴露，有一个整体
一堆东​​西在幕后，这

591
00:33:56,070 --> 00:33:59,480
我只是触及简要
那种只是因为它是在这个

592
00:33:59,480 --> 00:34:03,720
从在一个完全不同的角
如何做这样的事情条款

593
00:34:03,720 --> 00:34:04,580
得到落实到位？

594
00:34:04,580 --> 00:34:10,820
>> 因此，一个API是一个标准
连接所有这些内容。

595
00:34:10,820 --> 00:34:13,820
但要得到它那里，
第一件事情，我们不得不这样做

596
00:34:13,820 --> 00:34:17,260
在齐心协力信息
书籍和影像

597
00:34:17,260 --> 00:34:21,580
和发现艾滋病，收集
来自哈佛大学的各种系统文件。

598
00:34:21,580 --> 00:34:23,929
阿列夫，VIA和OASIS是
该系统的名称。

599
00:34:23,929 --> 00:34:28,820
并且它们基本上进入一个
管线，一个处理管线。

600
00:34:28,820 --> 00:34:33,230
>> 所以首先，我们得到的出口
从所有这些系统的文件。

601
00:34:33,230 --> 00:34:35,130
我们将它们分割成不同的物品。

602
00:34:35,130 --> 00:34:39,360
因此，我们有一个文件，这是技嘉，
其中有一百万条记录。

603
00:34:39,360 --> 00:34:42,290
所以我们把它分解成单个项目。

604
00:34:42,290 --> 00:34:45,374
然后，对于每个项目，我们将其转换
到MODS，是因为其中的一些

605
00:34:45,374 --> 00:34:47,040
本身是MODS，其中一些则不是。

606
00:34:47,040 --> 00:34:49,204
所以我们让他们都来
是在相同的格式。

607
00:34:49,204 --> 00:34:51,120
然后有各个
浓缩步骤，在这里

608
00:34:51,120 --> 00:34:55,969
我们添加更多的信息，以将数据
比在图书馆提供。

609
00:34:55,969 --> 00:34:59,750
因此，我们需要添加的是，第一次
我们有什么库，持有它。

610
00:34:59,750 --> 00:35:02,250
我们经历的步骤
计算stackscore。

611
00:35:02,250 --> 00:35:07,112
我们经历的另一步
在条款中加入更多的元数据

612
00:35:07,112 --> 00:35:10,730
什么样的人的集合
有可能增加this--

613
00:35:10,730 --> 00:35:12,532
>> 人们在制作
项的集合。

614
00:35:12,532 --> 00:35:13,990
它属于什么收藏？

615
00:35:13,990 --> 00:35:17,220
如何有标记的人
在过去这内容？

616
00:35:17,220 --> 00:35:20,750
然后你过滤掉，而你限制
的记录，因为正如我所说，

617
00:35:20,750 --> 00:35:24,120
还有一些记录的，因为
版权原因，我们无法显示。

618
00:35:24,120 --> 00:35:26,700
然后我们加载它们
成一种叫

619
00:35:26,700 --> 00:35:31,680
Solr的，这不是一个拼写错误，但
是一个软件的名称

620
00:35:31,680 --> 00:35:35,710
，做搜索索引，其中
驱动所有的API背后的搜索。

621
00:35:35,710 --> 00:35:40,110
然后它变得可用来
该API，人们可以使用它。

622
00:35:40,110 --> 00:35:44,640
>> 因此，这就像一个相当
简单的过程。

623
00:35:44,640 --> 00:35:47,230
一个有趣的
事情大概是

624
00:35:47,230 --> 00:35:50,990
我们正在处理
13万条记录

625
00:35:50,990 --> 00:35:53,820
我们将要处理以上。

626
00:35:53,820 --> 00:36:01,260
我们希望能够处理
这些在一个相对快速的方式。

627
00:36:01,260 --> 00:36:03,630
这需要很长的时间来
处理1300万条记录。

628
00:36:03,630 --> 00:36:09,529
>> 因此，如何这条管道是
设置是你can--

629
00:36:09,529 --> 00:36:12,070
我猜的优势
管道，我们是问题

630
00:36:12,070 --> 00:36:15,580
想在这里解决，就是
所有的转换，所有的

631
00:36:15,580 --> 00:36:18,729
在这这些步骤
管道是分开的。

632
00:36:18,729 --> 00:36:19,645
有没有相关性。

633
00:36:19,645 --> 00:36:22,146
如果你正在处理
一本书的记录，

634
00:36:22,146 --> 00:36:24,270
有一个在没有依赖性
另一本书之间。

635
00:36:24,270 --> 00:36:27,760
>> 所以，我们可以做的是基本，
在管道中的每个步骤，

636
00:36:27,760 --> 00:36:30,470
我们把它放到云中的队列。

637
00:36:30,470 --> 00:36:32,250
我正好是在Amazon Web Services。

638
00:36:32,250 --> 00:36:35,140
因此，有列表，
说，万项

639
00:36:35,140 --> 00:36:38,100
需要进行归一化和
转换为MODS格式。

640
00:36:38,100 --> 00:36:41,620
我们旋转起来尽可能多的服务器
我们想，也许10台服务器。

641
00:36:41,620 --> 00:36:44,860
并且每个服务器只
坐在那里，看上去在队列中，

642
00:36:44,860 --> 00:36:46,730
看到这有一个需要
加工，拉它关闭队列，

643
00:36:46,730 --> 00:36:48,740
处理它，和棍棒
它的下一个队列。

644
00:36:48,740 --> 00:36:54,200
>> 还等什么，让我们
做的是应用，从根本上，

645
00:36:54,200 --> 00:36:58,110
尽可能多的硬件，因为我们希望这
的时间很短的时间的问题

646
00:36:58,110 --> 00:37:02,970
以最快的速度处理数据
可能的话，这恐怕是唯一的，

647
00:37:02,970 --> 00:37:08,220
现在在云计算的世界
我们可以提供基本的服务器

648
00:37:08,220 --> 00:37:09,890
瞬间，是有用的。

649
00:37:09,890 --> 00:37:12,260
因此，我们不必有
巨型服务器围坐

650
00:37:12,260 --> 00:37:16,700
所有的时间做加工
这一个星期可能发生一次。

651
00:37:16,700 --> 00:37:21,440
>> 所以这主要是它。

652
00:37:21,440 --> 00:37:27,590
有可用文档
对于图书馆云API项目

653
00:37:27,590 --> 00:37:31,960
在这个URL，这将
可后来。

654
00:37:31,960 --> 00:37:36,730
并请到看看
，看看是否有什么事，

655
00:37:36,730 --> 00:37:37,579
你有什么想法。

656
00:37:37,579 --> 00:37:38,120
玩它。

657
00:37:38,120 --> 00:37:38,830
鬼混。

658
00:37:38,830 --> 00:37:42,800
并希望你能来
与一些伟大的事情。

659
00:37:42,800 --> 00:37:44,740
谢谢。

660
00:37:44,740 --> 00:37:45,899