WEBVTT

00:00:01.362 --> 00:00:04.346
设计本身就带着一种矛盾

00:00:04.346 --> 00:00:09.557
一方面，你想要尽快从别人身上得到反馈

00:00:09.557 --> 00:00:15.620
另一方面，你得有东西让他们能够作出评价

00:00:15.620 --> 00:00:19.371
你已经学会了如何运用纸上原型来快速构建原型

00:00:19.371 --> 00:00:23.856
今天我们就来讲一讲如何跟用户测试快速原型

00:00:24.856 --> 00:00:26.667
那么，我们想象一下……

00:00:26.667 --> 00:00:31.747
如果可能的话，不用写任何的代码就能创建一个交互的程序

00:00:31.747 --> 00:00:35.943
而且能够快速的得到用户的反馈会怎样？

00:00:35.943 --> 00:00:40.757
我觉得这会是一个非常强大的梦，而且就像Dorothy从“绿野仙踪”中学到的一样

00:00:40.757 --> 00:00:45.704
梦境可以非常强大，并且有时候，他们甚至能成真。

00:00:45.704 --> 00:00:49.269
Dorothy还学到了一些其他内容，我们今天便会讲到

00:00:49.269 --> 00:00:51.464
如果你看过电影《绿野仙踪》，你就知道

00:00:51.464 --> 00:00:54.700
当Dorothy和她的同伴进入翡翠国的时候，

00:00:54.700 --> 00:00:58.741
他们看到了一个可怕的巨型男巫，而且吓坏了

00:00:59.633 --> 00:01:03.492
但后来他们发现其实那个男巫只是一个在幕后的小人装的，

00:01:04.077 --> 00:01:08.440
而且那个幕后的小人上演这么一个大型真人秀的能力，

00:01:08.440 --> 00:01:13.356
对于翡翠城的游客来说，可是看起来非常真实和强烈

00:01:13.356 --> 00:01:17.527
而这也正是我们今天要从视频中学到的构建原型技术。

00:01:18.819 --> 00:01:20.579
所以，幕后操作原型构建的意思呢，

00:01:20.579 --> 00:01:24.373
就是我们要由电脑屏幕后的操作员来虚拟

00:01:24.373 --> 00:01:28.909
我们产品的交互行为和机器操作

00:01:29.571 --> 00:01:32.596
如果你想知道这样能够做到如何逼真，

00:01:32.596 --> 00:01:36.381
，那么我们就来看看来自“Seinfeld”的朋友做的“电影电话程序“的例子，

00:01:36.396 --> 00:01:39.978
这个程序是用作查询电影在何时何地放映的。

00:01:40.747 --> 00:01:44.537
（您好，欢迎使用电影电话。

00:01:44.537 --> 00:01:48.655
如果您知道想观看电影的名称，请按1.

00:01:48.655 --> 00:01:50.487
【哔】快点儿快点儿……

00:01:50.487 --> 00:01:56.156
请使用触摸式键盘，按下电影名称的前三个字幕，请输入！

00:01:56.156 --> 00:01:58.179
【哔，哔】

00:01:58.179 --> 00:02:05.796
您选的是《零号特工》。如果正确，请按1.

00:02:05.796 --> 00:02:07.753
啥？！

00:02:07.753 --> 00:02:09.843
呃……

00:02:09.843 --> 00:02:13.468
就是说George以为他打的是自动的电影电话程序，

00:02:13.468 --> 00:02:17.310
但是其实在电话后面，是Kramer在扮演男巫的角色

00:02:17.310 --> 00:02:20.070
并且假装他就是一个机器。

00:02:20.070 --> 00:02:23.876
老实说，他扮的可不怎么样……我觉得你们都能比他做的好！

00:02:24.630 --> 00:02:28.049
幕后操作的技术首先用于语音识别界面。

00:02:28.049 --> 00:02:34.353
”幕后操作“这个术语在1980年左右由Jeff Kelly在他的Phd论文中首次提出.

00:02:34.353 --> 00:02:36.447
Jeff在John Hopkins大学做的布置，跟绿野仙踪的接近程度

00:02:36.447 --> 00:02:40.101
可能比你想的还类似；

00:02:40.101 --> 00:02:45.778
就是说，除了一些单象镜子和其他的东西，那儿真有一个帘子，

00:02:45.778 --> 00:02:50.871
用来隔开Jeff，就是”男巫”，和其他测试语言界面的用户。

00:02:50.871 --> 00:02:55.070
而这些“幕后模拟”原型对于理解如何使用一个高效的语音识别界面，

00:02:55.070 --> 00:02:57.471
来说非常重要。

00:02:57.471 --> 00:03:01.365
因为在那个时代，用来识别的算法还不算很好，

00:03:01.365 --> 00:03:03.253
但是我们知道算法会变得更好。

00:03:03.253 --> 00:03:05.739
Jeff问了一些重要的问题，比如：

00:03:05.739 --> 00:03:10.763
“如果我们的识别算法已经成熟，那么它的用户交互该是怎样，

00:03:10.763 --> 00:03:13.612
怎么样的设计策略最有效呢？“

00:03:13.627 --> 00:03:17.086
所以通过”幕后操作“，Jeff能够穿梭到未来，

00:03:17.086 --> 00:03:20.625
语音识别技术已经成熟的时候。

00:03:20.625 --> 00:03:24.329
来尝试并理解那个领域的用户体验会有哪些问题。

00:03:25.862 --> 00:03:29.380
总的来说，一个”幕后操作“原型是由几个零件组成：

00:03:29.380 --> 00:03:33.362
首先，你得有类似的用户界面用来传递用户你的理念-

00:03:33.362 --> 00:03:41.790
即使只是……一些草稿或者一些特定的词语。

00:03:41.790 --> 00:03:47.036
并且同时，界面并不是由任何或少量的代码写出来，

00:03:47.036 --> 00:03:53.856
代码和交互性其实都是由人所创造出来的反映。

00:03:53.856 --> 00:03:57.561
有时候”男巫“创造的界面，

00:03:57.561 --> 00:04:00.656
那些零零散散拼建的能起到很大的作用-

00:04:00.656 --> 00:04:05.480
事实上2000年的时候，那时候我Berkeley的校友和我做了一个建了一个叫”Suede“的系统,

00:04:05.480 --> 00:04:09.330
用来测试自动化”幕后操作“和语音识别界面。

00:04:09.330 --> 00:04:15.513
如果”幕后操作“比建一个真实的系统更快更廉价的话，它就很有用。

00:04:15.513 --> 00:04:20.465
尤其是当你的产品涉及到基于识别的用户界面，

00:04:20.465 --> 00:04:23.767
或者是面对用户的个人化设定的时候。

00:04:24.490 --> 00:04:28.874
是否”幕后操作“更便宜，快捷和容易也都取决于你得能力；

00:04:28.874 --> 00:04:33.293
有些东西你如何快速简单的完成，那么你就直接去做了，

00:04:33.293 --> 00:04:37.601
还有些东西，你是知道有些难度，比较耗费时间，

00:04:37.601 --> 00:04:40.044
这些东西你就可以选择”幕后操作“来虚拟。

00:04:40.644 --> 00:04:46.192
和其他别的原型技术类似，”幕后操作“原型既能高度也能低度的仿真。

00:04:46.192 --> 00:04:48.729
这个时候也有些重要的权衡-

00:04:48.729 --> 00:04:53.081
原型越高度仿真，对于用户来说它就更真实-

00:04:53.081 --> 00:04:58.982
事实上，有时候，你做的界面用户甚至都不知道它是人模拟的，

00:04:58.982 --> 00:05:04.036
就比如那个有名的”土耳其下棋傀儡“，实际上就是由人坐在象棋机器里面假扮的。

00:05:04.467 --> 00:05:09.209
不管怎样，做一个高度仿真的用户界面要花很多时间，

00:05:09.209 --> 00:05:15.022
用户可能也不会更愿意对一个高度仿真的用户界面作出批评，

00:05:15.022 --> 00:05:20.600
所以说，早期的时候，我觉得纸上原型就是”幕后操作“

00:05:20.600 --> 00:05:22.520
最简单快捷的方法。

00:05:22.520 --> 00:05:25.600
因为用户觉得他们可以给你任何的反馈，

00:05:25.600 --> 00:05:28.272
因为很明显你还没有花很多时间去做它，

00:05:28.272 --> 00:05:33.110
而且你做它也很容易，所以你其实没有花很多时间做它.

00:05:33.772 --> 00:05:37.213
几年前，我的朋友Sep Kamvar开了一个公司叫Aardvark,

00:05:37.213 --> 00:05:39.926
做的是一个社交搜索引擎。

00:05:39.926 --> 00:05:45.494
它用来通过你的社交网络帮你从他人处找到答案。

00:05:45.971 --> 00:05:50.576
就是说它通过及时通讯程序，比如说谷歌聊天提出一个问题；

00:05:50.576 --> 00:05:55.621
然后这个问题立即被自动传播给你的朋友，或者朋友的朋友了，

00:05:55.621 --> 00:05:58.601
任何能有知识回答这个问题的人。

00:05:58.601 --> 00:06:04.336
构建这个服务的一个难点在于：你如何做到问题的传播？

00:06:04.336 --> 00:06:08.017
最终他们写了一个算法来完成这个系统；但是在开始-

00:06:08.017 --> 00:06:10.384
既要找到写这个算法的方法，

00:06:10.384 --> 00:06:15.228
又要在他们做任何东西之前搞清楚如何完善用户体验，

00:06:15.228 --> 00:06:17.716
他们做了一个”幕后操作“原型。

00:06:17.716 --> 00:06:21.476
所以他们想的方法就是，Aardvark的雇员先想了一些问题，

00:06:21.476 --> 00:06:25.332
然后他们手工的选择他们想被传播到问题的人，

00:06:25.332 --> 00:06:29.200
Damon Horowitz，Aardvark的共同创始人，在一个会议中是这么提到的，

00:06:29.200 --> 00:06:33.923
他说，”如果人们喜欢在这种超级简陋的形式下做的东西，那么它就值得做，

00:06:33.923 --> 00:06:38.261
因为我们要是做出真的东西来了他们会更喜欢！”

00:06:38.277 --> 00:06:43.708
那么，如果你想要像Kramer或Aardvark一样，你该怎么做一个“幕后操作”原型呢？

00:06:43.708 --> 00:06:46.738
下面就是你需要做的五个简单的步骤：

00:06:47.246 --> 00:06:49.582
首先，搞清楚你的产品基于什么情景下被使用。

00:06:49.582 --> 00:06:54.363
建一个功能有限的“幕后操作”原型相对简单很多，

00:06:54.840 --> 00:06:56.372
我喜欢“幕后操作”原型

00:06:56.372 --> 00:06:59.892
因为他迫使你搞清楚面对真人，机器该如何反应。

00:07:00.847 --> 00:07:03.717
然后，把一些用户界面的构架聚合在一起，

00:07:03.717 --> 00:07:06.239
那些终端用户最后要看到的是什么。

00:07:06.593 --> 00:07:11.266
第三，如果你有一个远程的幕后操作人，给他们建立一个可以跟用户沟通的桥梁，

00:07:11.266 --> 00:07:15.277
或者他们能够在幕后控制一些软体功能。

00:07:16.046 --> 00:07:17.485
第四，接着前面的说，

00:07:17.485 --> 00:07:21.491
你需要确切的搞清楚"幕后操作人"能够输入什么类型的信息：

00:07:21.491 --> 00:07:26.847
他们能够从一系列的选项中选择吗？提供任何形式的回应？说出文字？

00:07:26.847 --> 00:07:31.228
你会给他们提供决策树用来控制他们的行为吗？

00:07:31.228 --> 00:07:33.617
或者你要让他们更加自由的行动？

00:07:33.617 --> 00:07:36.917
如果你有一个纸上原型，他们的角色也将更为手动-

00:07:36.917 --> 00:07:40.886
加上一些微件和移动滑块，然后让界面能够运行。

00:07:41.733 --> 00:07:43.741
当你做这些的时候，一定要记住，

00:07:43.741 --> 00:07:49.577
最终，你现在幕后操作的功能都将由电脑取代，

00:07:49.577 --> 00:07:53.818
并且在最终某一时刻，你必须要做出软件让这些功能能够运行。

00:07:53.818 --> 00:07:58.776
这很重要，因为要虚拟一个永远不能完成的东西很容易。

00:07:59.469 --> 00:08:03.430
并且最后一点，和任何你要和真人测试的原型一样，

00:08:03.430 --> 00:08:07.170
首先让一个朋友或同学使用你“幕后操作”的程序-

00:08:07.170 --> 00:08:10.095
他们可能会做出一些你不会做出的用户行为-

00:08:10.095 --> 00:08:15.442
并且同时，搞清楚什么样的情况下最有效，你需要提供什么样的操作给用户。

00:08:15.442 --> 00:08:19.823
在你跟真实的用户测试前，先解决用户界面的一些基本的漏洞。

00:08:20.300 --> 00:08:25.641
现在你应该准备好测试你得用户界面了：就像我之前说的，你得先跟一个朋友测试。

00:08:27.380 --> 00:08:32.118
一旦你能把一些非常明显的小插曲解决掉，那么你接下来的任务就通顺了很多。

00:08:32.118 --> 00:08:35.180
然后就是时候募集一些人来测试你的原型。

00:08:35.180 --> 00:08:41.568
你甚至能去一些比如，车站，机场，街道口，或者咖啡店之类的地方，

00:08:41.568 --> 00:08:45.814
作为接近你的产品的潜在用户的方式。

00:08:47.230 --> 00:08:50.428
在“幕后操作”原型中有两个角色：

00:08:50.428 --> 00:08:53.270
你需要一个跟你的用户交流的协作人，

00:08:53.270 --> 00:08:55.871
然后你需要一个操作你原型的“幕后操作人”。

00:08:55.871 --> 00:09:00.091
如果你有一个超豪华的团队，有这么两个人就最好了，

00:09:00.091 --> 00:09:03.745
一部分是因为你的脑海中已经挤满你要做的各种事情了，

00:09:03.745 --> 00:09:08.696
如果你能把这两个角色分开，每个人就能够更为集中的完成各自的任务，

00:09:08.696 --> 00:09:13.568
而且如果你有两个人能够各自观察用户的行为，你能学到更多。

00:09:14.584 --> 00:09:18.920
但是如果情不得已，你也能自己身居双职-这些也能一人同时担任两个角色。

00:09:19.597 --> 00:09:22.375
如果你想让别人相信这就是一个真实的系统，

00:09:22.375 --> 00:09:27.031
那么你就需要你的“幕后操作人”藏起来或者远程的和用户联系，就像前面提到的Aardvark的例子一样。

00:09:27.354 --> 00:09:29.492
然后想一想你想怎么从用户那里去的反馈-

00:09:29.492 --> 00:09:33.477
这是我们在讲授这个课程中间要多次接触的话题。

00:09:33.477 --> 00:09:36.985
就现在来说，想一想你是否想要获得脱口而出的回馈-

00:09:36.985 --> 00:09:39.913
它的意思是，当有人使用这个原型的时候，

00:09:39.913 --> 00:09:45.436
让他们直接说出他们脑子里的想法，他们做出的选择和为什么这么做，

00:09:45.436 --> 00:09:51.013
当他们碰壁的时候却不知道如何解决的问题。

00:09:51.721 --> 00:09:58.111
脱口而出的方式很适合用来了解问题，不然你可能不会知道或意识到问题。

00:09:58.111 --> 00:10:03.067
但是，你可能也会意识到，脱口而出的方式可能也会改变人们和原型交互的方式。

00:10:03.067 --> 00:10:07.325
不然，如果脱口而出的方式有点扰乱用户的思绪，你也能在测试的最后问用户，

00:10:07.325 --> 00:10:09.865
他们脑子里的想法和想到了什么-

00:10:09.865 --> 00:10:11.821
这种方法叫做，回忆启发。

00:10:11.821 --> 00:10:14.402
你要是想的话，还可以给用户看他们使用产品时的视频，

00:10:14.402 --> 00:10:18.716
然后问问题比如，“当你在这个地方卡住的时候，你碰到了什么问题？”

00:10:19.609 --> 00:10:24.051
第三，如果你有特定的问题你想弄清楚，用来确定你的界面工作流畅，

00:10:24.051 --> 00:10:30.155
你可以有分类的问题和启发式的问题来让你的用户特别注意。

00:10:30.155 --> 00:10:34.622
启发式测评我们在这个课程的之后还会涉猎到。

00:10:35.499 --> 00:10:38.065
一旦你完成了测试，请务必感谢你的用户抽出时间。

00:10:38.065 --> 00:10:43.162
你可以给他们一个礼品卡，冰淇淋，或者其它类型的感谢方式。

00:10:44.209 --> 00:10:49.711
并且，如果你还没告诉他们事实上你的界面是由屏幕后的幕后人员操作的，

00:10:49.711 --> 00:10:52.311
实验的最后也许是一个非常好的时机-

00:10:52.311 --> 00:10:54.750
你需要对你的测试用户诚实。

00:10:54.750 --> 00:10:57.974
你可以在你的产品开发阶段一直使用“幕后操作”，

00:10:57.974 --> 00:10:59.942
不一定非得在最开始的阶段。

00:10:59.942 --> 00:11:06.066
那么，如果你在这点做出了最终的产品，在你不断的完成你的软件的同时，

00:11:06.066 --> 00:11:10.274
你能用“幕后操作”来填补任何那个阶段还未完成的内容。

00:11:10.274 --> 00:11:13.523
所以，“幕后操作”能够在开发的最开始阶段实现所有的交互，

00:11:13.523 --> 00:11:16.201
然后，在你的项目越来越接近终点的同时，

00:11:16.201 --> 00:11:19.918
你也能用“幕后操作”来填补还未完成的部分。

00:11:20.441 --> 00:11:24.047
就你也能发现到，“幕后操作”原型有很多优势：

00:11:24.463 --> 00:11:27.791
它们能够快速的被实现，因此说它们造价低廉，

00:11:27.791 --> 00:11:31.121
也就说你能花更多精力用来反复构思。

00:11:32.429 --> 00:11:35.618
因为它们做的快，你也能快速的做几个不同的方案。

00:11:35.618 --> 00:11:39.078
或者你想要你最终的实现方案使用和初衷不同的原理，

00:11:39.078 --> 00:11:42.649
你只需要给你的“幕后人员”另一套操作方案；完全不需要重写代码。

00:11:43.511 --> 00:11:45.141
因为它某种意义上来说就是可交互的，

00:11:45.141 --> 00:11:49.002
它显得更真实，并且比你从纸上原型获取的用户反馈好很多，

00:11:49.002 --> 00:11:52.135
尽管用纸上原型作为“幕后操作”的基础，

00:11:52.135 --> 00:11:55.724
是设计流程开始的一个极佳的策略。

00:11:56.308 --> 00:12:00.865
它是在你设计用户界面的过程中用来获得用户对于问题和漏洞的反馈，非常好的方式。

00:12:00.865 --> 00:12:05.160
就我所做的，和我所看到的任何一个用户界面，

00:12:05.160 --> 00:12:08.591
或者是我的学生做的任何一个界面，一开始都有漏洞。

00:12:08.591 --> 00:12:11.325
一开始就没问题实在太困难了。

00:12:11.325 --> 00:12:15.543
你必须重复实践并且尽早的发现问题，这样你才能更早的成功。

00:12:15.543 --> 00:12:18.914
而且“幕后操作”是用来实践它的一个极佳的工具。

00:12:20.053 --> 00:12:22.544
因为你想尽早的从用户那里获得反馈，

00:12:22.544 --> 00:12:26.437
这是一种将用户放在开发核心的极佳方式。

00:12:27.006 --> 00:12:29.911
这对于前瞻性的程序也非常有用。

00:12:29.911 --> 00:12:34.608
当我们开始考虑探测器，摄像头和其它未来科技

00:12:34.608 --> 00:12:37.214
可能用来启发新型的用户界面的时候。

00:12:37.214 --> 00:12:42.230
你能通过建造“幕后操作”来想象这些。

00:12:42.522 --> 00:12:46.023
最后，可能听起来奇怪，你确实能学到很多

00:12:46.023 --> 00:12:50.120
关于你的界面应该有的逻辑，和行得通的方法，

00:12:50.120 --> 00:12:54.268
通过扮演“幕后操作人”和将那个角色在系统中实体化。

00:12:54.991 --> 00:12:58.281
但是也有缺点：

00:12:58.281 --> 00:13:03.175
它也很容易掩盖掉技术上的问题，并且最终毁掉你-

00:13:03.175 --> 00:13:06.641
就拿语音识别系统举例。

00:13:06.656 --> 00:13:11.635
如果，在最后，你在你的语音识别系统中发现一些漏洞，

00:13:11.635 --> 00:13:14.447
你希望确信你的“幕后操作”原型能够模拟出

00:13:14.447 --> 00:13:16.883
你的语音识别系统出现的同样的问题。

00:13:16.883 --> 00:13:20.050
不要假设你的系统一直会顺利工作。

00:13:20.050 --> 00:13:24.716
因为如果你不仔细，你最终就只是模拟一个永远不会存在的技术了。

00:13:25.393 --> 00:13:27.806
人类，不论好坏，都不是从一而终的，

00:13:27.806 --> 00:13:32.888
那么为了让他们能够扮演好“幕后操作人”的角色，就需要一些训练，也就要花很长一段的时间。

00:13:32.888 --> 00:13:35.997
因为你必须有一个真人来“幕后操作”，

00:13:35.997 --> 00:13:38.193
你的实际操作效率也就更低下，

00:13:38.193 --> 00:13:42.159
你的“幕后操作者”的人也更为沮丧。

00:13:42.159 --> 00:13:46.981
“幕后操作”对于某些功能，比如说Kramer的语音操作界面来说非常有用，

00:13:46.981 --> 00:13:51.370
但是对于其它，你能用“幕后操作”界面能搞清的就极为有限了。

00:13:51.370 --> 00:13:56.233
它也不一定有效率-它也可能很迟钝。

00:13:56.233 --> 00:13:57.964
或者干脆就不适合-

00:13:57.964 --> 00:14:05.845
有些情况下，“幕后操作”可能就……不理想。

00:14:05.845 --> 00:14:09.097
总的来说，我认为“幕后操作”是一种非常有效的技术，

00:14:09.097 --> 00:14:11.523
而且是一种能够开发你的创作力的，一种非常有趣的方式，

00:14:11.523 --> 00:14:17.075
通过一个“幕后操作”的原型你能想象出什么样的用户界面呢？

00:14:17.075 --> 00:14:19.761
我想感谢Stephen Dow开创这个课程-

00:14:19.761 --> 00:14:24.461
我用到了很多他在描写和讲述“幕后操作”原型时所使用的材料。

00:14:24.461 --> 00:14:30.918
如果你对“幕后操作”有兴趣，你可以在这里看到这些资源。