Scrum题库

Sprint Backlog中包含哪些内容?
A:用户故事
B:任务
C:用例
D:测试
选B
一旦项目进行中,计划的方法是
A:计划不应该改变
B:随着项目的进展,需要计划和重新计划是正常的
C:计划只有在所有利益相关方完全同意的情况下才能改变
D:由于敏捷是增量式的,因此不需要计划
选B
(  )是七大浪费中最大的浪费,它除造成直观的浪费外,还会把“等待是浪费”隐藏起来,使管理人员漠视等待的发生
A:制造过剩的浪费
B:库存
C:生产不良的浪费
D:加工过剩的浪费
选B
Scrum日会上,Olivia提到,说她发现了一些开源代码,应该可以解决她正在处理的某个问题。她想马上就着手实现。下一步做什么最好
A:ScrumMaster让Olivia去准备一个样例以及给团队的演示,这样他们会考虑使用此代码
B:团队所有成员都要求评估Olivia的解决方案,下一次Scrum日会时向团队汇报情况
C:产品负责人记录下障碍,并在会后着手解决
D:开完Scrum日会之后,再单独开会讨论这个开源解决方案
选D
所有的敏捷方法有什么共同点?
A:规定的、固定的迭代(计时器)长度
B:迭代开发和增量交付
C:严格注重按时交付
D:一大套明确界定的角色
选B
敏捷开发方法通过()管理不可预测性
A:非常仔细地收集和定义需求
B:制定详细的开发计划
C:软件增量必须在较短周期内发布
D:软件过程必须逐渐适应变化
项目的特性清单(Product Backlog)最重要和必选的内容是(   )
A:每个特性的标题,优先级和估算
B:每个特性的标题,详细描述
C:每个特性的责任人和状态
D:以上都是
选A
SCRUM的骨架核心是什么?
A:SCRUM的所有实践都是围绕着一个迭代,增量的过程骨架展开
B:SCRUM的骨架为看板,核心为迭代
C:SCRUM的所有实践都是围绕着一张看板,随着增量的过程骨架展开
D:SCRUM的核心骨架在于迭代
选A
敏捷方式是:
A:尽早、渐进地生产出正确质量的工作产品
B:在文件签署后生产工作产品
C:尽早制作简单的原型,但直到项目结束时才制作成品
D:生产没有技术完整性的产品,但稍后重新设计
选A
以下哪个不符合敏捷宣言?
A:个体和交互 胜过 流程和工具
B:客户谈判 胜过 客户合作
C:可以工作的软件 胜过 面面俱到的文档
D:响应变化 胜过 遵循计划
选B
(  )是七大浪费中最大的浪费,它除造成直观的浪费外,还会把“等待是浪费”隐藏起来,使管理人员漠视等待的发生
A:制造过剩的浪费
B:库存
C:生产不良的浪费
D:加工过剩的浪费
选B
工作任务如何分配(    )
A:领导/经理指定每个人的工作(设计、编码、测试等),并及时进行沟通确认
B:成员一起来分解需求到任务和估算,并从任务列表领取他们将要进行的工作
C:成员直接领取需求,并承诺交付时间
D:以上都不是
选B
产品愿景应该具备哪些品质?
A:可追溯至IT投资相关整体性企业治理结构的概要
B:描绘一幅详细的概观,可以启发和赋予灵感
C:描述项目的追求所在,以及产品渴望达到的最终状态
D:提供一个投资回报方案的完整分解结构
选C
下面的()是错误的
A:软件交付的主要工作是将程序代码和相关文档交给用户
B:用户培训是帮助用户理解产品并掌握系统的使用和操作
C:软件部署是通过配置、安装和激活等活动保证软件系统的正常运行
D:持续集成是频繁持续地将团队成员的工作进行集成
选A
为什么建议产品负责人参加Scrum日会
A:确保团队还在向着sprint目标的方向努力
B:对团队进度发布意见
C:告诉团队接下来作哪个任务,并更新产品列表
D:查看已取得的进展,若团队需要帮助,应积极提出沟通
选D
在第一个sprint中团队做什么
A:交付设计文档
B:预先决定完整的架构和基础设施
C:完成Sprint目标
D:为后续的Sprint制定计划
选C
产品所有者的责任包括:
A:业务流程图表绘制
B:确定需求的优先次序
C:管理项目预算
D:以上全是
选D
应该何时更新发布燃尽图?
A:每天后
B:每周后
C:每个Sprint后
D:每次发布后
选C
在Sprint规划会议中,产品负责人……
A:决定团队如何完成其工作
B:把选定的故事分割为详细任务
C:展示他/她希望团队在sprint中完成的故事
D:决定在sprint结束时应该交付多少故事
选C
产品愿景应该具备哪些品质?
A:可追溯至IT投资相关整体性企业治理结构的概要
B:描绘一幅详细的概观,可以启发和赋予灵感
C:描述项目的追求所在,以及产品渴望达到的最终状态
D:提供一个投资回报方案的完整分解结构
选C
SCRUM一般采用多长时间的迭代周期?
A:一般来说,它采用2-4周的迭代周期
B:一般来说,它采用1-4周的迭代周期
C:一般来说,它采用3-5周的迭代周期
D:一般来说,它采用3-4周的迭代周期
选A
SCRUM中DOD下面描述的正确的是?
A:DOD完成的定义,它是不可变的
B:DOD是一个不可以被审视的列表
C:DOD是团队成员的主要状态参考依据
D:DOD是对软件有价值的活动的数据收集
选C
可持续的步伐意味着…
A:如果团队成员经常长时间工作,他们会习惯并能够维持下去
B:每周40小时仅适用于团队中较弱的成员,其他人可以做更多
C:团队应该建立一个可以在正常工作时间内维持的速度
D:长时间工作是准时交付的唯一途径
选C
冒烟测试的频度(  )
A:每天进行一次或者多次
B:每周一次
C:间隔大于一周
D:按照测试版本的需要临时构建
选A
下面哪个选项是错误的:
A:燃尽图展示的是各个时期下所剩余的工作量
B:迭代是指把一个复杂且开发周期很长的开发任务,分解为很多小周期可完成的任务
C:增量是一个 Sprint 及以前所有 Sprint 中完成的所有产品代办事项列表条目的总和
D:Scrum具体指整个系统开发的流程,而这个大流程又由一次迭代完成,一次迭代的过程称之为一个sprint
选D
sprint评审的主要目的是?
A:让利益相关者可以向团队施加压力,以确保sprint能够有所产出
B:让团队可以审阅他们的工作,并决定需要做些什么来完成下一批列表条目
C:让产品经理向利益相关者展现进度
D:让利益相关者审阅团队所创建的成果,并为后续计划提供信息
选D
Sprint推荐的最长周期是多少?
A:30天
B:60天
C:90天
D:提供一个潜在可交付产品增量需要多久,就是多久
选A
下面的()不是敏捷开发方法的特点
A:软件开发应该遵循严格受控的过程和详细的项目规划
B:客户应该和开发团队在一起密切地工作
C:通过高度迭代和增量式的软件开发过程响应变化
D:通过频繁地提供可以工作的软件来搜集人们对产品的反馈
选A
增量模型是()
A:适用于需求被清晰定义的情况
B:一种需要快速构造核心产品的好方法
C:一种不适用于商业产品的创新模型
D:已不能用于现代环境的过时模型
选B
CEO要求团队在当前Sprint中增加一个故事。团队该怎么办?
A:把故事加入下一个Sprint
B:尊重CEO的职权,不做任何调整直接把故事加入当前Sprint
C:把故事加入到当前Sprint,并丢弃一个相同大小的故事
D:通知产品负责人让他/她和CEO一起处理此事
选D
最应该参加迭代评估(演示)的人员(  )
A:项目经理
B:用户代表
C:开发人员
D:测试人员
选B
敏捷宣言是怎么看待客户协作的?
A:跟客户紧密地协作,确保在项目构建阶段之前完成所有功能的定义
B:定期及频繁的客户反馈是必要的
C:团队必须告知Sprint中他们将产出的功能以及有关发布的目标
D:新的功能性需求要进入Sprint,需要先得到客户的一致认同
选B
如下哪一条是良好团队的特征?
A:是自组织的
B:等待任务被分派下来
C:成员们技术能力水平全都很接近
D:向ScrumMaster寻求方向
选A
如果敏捷项目运行后出现新需求,应该是:
A:自动包含在项目的工作中
B:自动排除并保留至稍后的项目或增量
C:评估重要性,如果对业务来说足够重要,则包括在项目中,取代较不重要的要求
D:项目开发完成后,对照本轮的迭代任务,提交给项目干系人评审
选C
团队成员在执行相关迭代任务的时候,发现需求不明确,应该找谁?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队其他成员
选C
实行“看板方式”的基础是:(   )
A:准时化
B:自动化
C:流水线生产
D:均衡化生产
选C
“拉动”一词是指(  )
A:上工序带动下工序
B:下工序带动上工序
C:上、下工序同步进行
D:以上皆不是
选B
软件配置管理的目的是()
A:降低开发成本
B:控制软件修改
C:提高软件开发效率
D:提高正确率
选B
跟踪敏捷项目中的项目问题是(  )的主要责任
A:测试者
B:项目负责人
C:职能经理
D:团队
选D
使用Scrum时,谁主要负责在范围和进度之间作出权衡决策
A:ScrumMaster
B:团队
C:产品负责人
D:项目经理
选C
下面的()不属于产品负责人(Product Owner)的职责范围
A:组织每日站立会议
B:定义产品需求
C:确定需求优先级
D:验收迭代结果
选A
测试人员何时开展测试(   )
A:每个发布版本前(可能长于1个月)提交版本测试清单
B:每个迭代开发完成后(小于1个月)根据开发完成的特性清单来测试
C:开发人员交付任何特性则立即被测试
D:每天不断执行测试用例(不管代码是否存在),驱动开发人员进行开发
选C
项目内部的管理方式(   )
A:管理是正式的、结构化的,要求周期性进行,并且由一个独立机构进行技术审核
B:管理是非正式的,由高层管理者通过“走动式管理”完成
C:管理是共同承担责任。计划由所有团队成员和资深管理人员共同制定,从而不需要强制就可以共同遵从
D:项目经理管理Master(或组长),master(或组长)管理开发人员
选C
产品负责人的责任包括:
A:业务流程图表绘制
B:确定需求的优先次序
C:管理项目预算
D:以上全是
选D
SCRUM一般采用多少个冲刺周期?
A:一般来说,它采用2-4周的迭代周期
B:一般来说,它采用1-4周的迭代周期
C:一般来说,它采用3-5周的迭代周期
D:一般来说,它采用3-4周的迭代周期
选A
SCRUM的框架核心是什么?
A:SCRUM的所有实践都是围绕着一个迭代,增量的过程框架展开
B:SCRUM的框架为看板,核心为迭代
C:SCRUM的所有实践都是围绕着一张看板,随着增量的过程框架展开
D:SCRUM的核心框架在于迭代
选A
当一个敏捷团队成功…
A:应该鼓励,在项目结束时才能庆祝成功
B:应该鼓励,立即庆祝,即使是小小的成功
C:它不应该庆祝成功,因为这会浪费项目预算
D:它不应该庆祝成功,因为这会让不太成功的团队感觉不好
选B
计划的频度(   )
A:做很短的计划,很少超过一两周
B:做短期的迭代计划(1个月内)以及中长期的版本计划(几个月到1年),迭代计划比较细,版本计划只做概要计划
C:做长期计划,包括详细的任务和分工。后期可以根据实际进展修订
D:频繁的做及时性计划
选B
团队成员在执行相关迭代任务的时候,发现需求不明确,应该找谁?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队其他成员
选C
拉动系统的核心是(  )
A:5S
B:自动化
C:看板管理
D:准时化
选D
下面哪个选项是错误的:
A:燃尽图展示的是各个时期下所剩余的工作量
B:迭代是指把一个复杂且开发周期很长的开发任务,分解为很多小周期可完成的任务
C:增量是一个 Sprint 及以前所有 Sprint 中完成的所有产品代办事项列表条目的总和
D:Scrum具体指整个系统开发的流程,而这个大流程又由迭代组成,一次迭代的过程称之为一个sprint
选D
外部对项目的管理方式(  )
A:管理是正式的、结构化的,要求周期性进行,并且由一个独立机构进行技术审核
B:管理是非正式的,由高层管理者通过“走动式管理”完成
C:管理是共同承担责任。计划由所有团队成员和资深管理人员共同制定,从而不需要强制就可以共同遵从
D:不需要管理,每个人都是自管理
选A
什么是敏捷开发?
A:敏捷开发是一种以用户故事为核心、迭代、循序渐进的开发方法
B:敏捷开发是一种以人为核心、迭代、循序渐进的开发方法
C:敏捷开发是一种以人为核心、交付、循序渐进的开发方法
D:敏捷开发是一种以迭代为核心、循序渐进的开发方法
选B
()是Product backlog
A:产品负责人
B:产品代办事项列表
C:迭代
D:燃尽图
选B
以下不是精益生产主要特征的是(  )
A:拉动式生产
B:推动式生产
C:最大限度的减少库存
D:实现准时化生产
选B
如下哪一条是良好团队的特征?
A:是自组织的
B:等待任务被分派下来
C:成员们技术能力水平全都很接近
D:向ScrumMaster寻求方向
选A
如下哪一条属于产品负责人的职责
A:决定团队成功所必需的构成
B:决定合适的发布日期
C:决定恰当的项目技术方案
D:决定sprint的长度
选B
所有的敏捷方法有什么共同点?
A:规定的、固定的迭代(计时器)长度
B:迭代开发和增量交付
C:严格注重按时交付
D:一大套明确界定的角色
选B
制定迭代计划时(  )
A:应该用任务把开发人员的可用工作量填满
B:应该包括加班时间
C:应该保留20%左右的缓冲
D:应该加大开发人员的并发任务,来充分利用资源
选C
关于Sprint,下面的()是错误的
A:一个Sprint通常是一个1-4周的迭代
B:Sprint长度在开发过程中是可以调整的
C:需求在一个Sprint中是不允许变化的
D:sprint的产出是“完成”的、可用的、潜在可发布的产品增量
选B
敏捷项目应该有…
A:如果企业愿意接受较低的质量,则偶尔提前交付
B:以开发为重点的产品的定期交付模式
C:定期提供具有商业价值的增量的模式
D:不规则和不可预测的产品交付
选C
哪个角色最有可能在Scrum日会上提及一个障碍?
A:团队
B:ScrumMaster
C:产品负责人
D:干系人
选A
SCRUM框架下,哪个角色对软件的交付负责?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:开发团队
选D
在敏捷项目中,我们计划“边走边学”,因为……
A:它在开发人员和客户代表之间建立了更好的关系
B:许多项目是进化的,一个更好的解决方案就这样出现了
C:在项目开始时分析每件事都很费时
D:防止项目交付延误
选B
持续改善的基础是(  )的途径
A:标准化
B:制度化
C:目视化
D:通用化
选A
敏捷项目中的客户……
A:无法控制交付功能的优先级
B:完全控制功能的优先级
C:与开发人员在功能优先级上合作,但开发人员有最终决定权
D:与开发人员在功能优先级上合作,但业务有最终决定
选D
看板的三大作用不包括( )
A:传递生产信息
B:保证生产现场的标准操作
C:识别浪费
D:控制生产系统动态的自我完善
选B
以下不属于Scrum的三大支柱的是(  )
A:透明性
B:检验
C:观察
D:适应
选C
开发人员CheckIn代码的频率(   )
A:每人每天进行一次或者多次
B:项目组每天一次或多次
C:每周一次或多次
D:特性完成时CheckIn
选A
计划的频度(   )
A:做很短的计划,很少超过一两周
B:做短期的迭代计划(1个月内)以及中长期的版本计划(几个月到1年),迭代计划比较细,版本计划只做概要计划
C:做长期计划,包括详细的任务和分工。后期可以根据实际进展修订
D:频繁的做及时性计划
选B
敏捷过程…
A:鼓励团队定期开会
B:没有会议
C:有冗长的报告要求
D:没有报告要求
选A
应该何时更新发布燃尽图?
A:每天后
B:每周后
C:每个Sprint后
D:每次发布后
选C
工作任务如何分配(    )
A:领导/经理指定每个人的工作(设计、编码、测试等),并及时进行沟通确认
B:成员一起来分解需求到任务和估算,并从任务列表领取他们将要进行的工作
C:成员直接领取需求,并承诺交付时间
D:以上都不是
选B
敏捷项目中推荐的设计方法是:
A:没有预先设计
B:大的预先设计
C:前面有足够的设计
D:使用之前的设计——它将“足够好”
选C
对计划的发布版本应该(  )
A:按产品特性交付:需要交付的特性都必须交付,必要时要推迟发布时间
B:按日期交付:按照预定发布时间进行发布,必要时候裁剪部分功能特性
C:临时决定:我们会平衡一下,临时根据市场要求和开发进展来确定,可能会同时调整交付时间和特性
D:在迭代模式下,没有必要计划版本。每个迭代都应该完成可发布的版本,按照市场需要发布迭代版本即可
选B
以下不属于Scrum的三大支柱的是(  )
A:透明性
B:检验
C:观察
D:适应
选C
团队成员在工作中,对自己的职业规划和技术能力提升产生困惑,应该找谁?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队其他成员
选B
在接受敏捷项目的任何可交付成果方面,以下哪一个陈述是正确的?
A:团队应该只允许高级管理人员签署可交付成果
B:团队应该至少在每个迭代结束时从PO或用户处获得项目可交付成果的验收
C:项目结束时,团队应在UAT阶段接受用户的项目可交付成果
D:同时从所有干系人获得对该项目的任何特定交付物的验收
选B
()是用户故事的标准模板
A:作为一个<用户角色>,为了达到<目的>,我需要<功能>
B:作为一个<产品类型>,为了达到<目的>,我需要<功能>
C:作为一个<用户类型>,为了达到<目的>
D:作为一个<产品类型>,为了达到<目的>
选A
根据Scrum指南,谁负责招聘或分派新人到团队中去?
A:ScrumMaster
B:产品负责人
C:自管理团队
D:这超出了Scrum的范围
选D
根据Scrum指南,谁负责招聘或分派新人到团队中去?
A:ScrumMaster
B:产品负责人
C:自管理团队
D:这超出了Scrum的范围
选D
以下不属于Scrum的三大支柱的是(  )
A:透明性
B:检验
C:观察
D:适应
选C
关于Sprint,下面的()是错误的
A:一个Sprint通常是一个1-4周的迭代
B:Sprint长度在开发过程中是可以调整的
C:需求在一个Sprint中是不允许变化的
D:sprint的产出是“完成”的、可用的、潜在可发布的产品增量
选B
下列关于敏捷方法的叙述中,错误的是()
A:与传统方法相比,敏捷方法比较适合需求变化大或者开发前期对需求不是很清晰的项目
B:敏捷方法尤其适合于开发团队比较庞大的项目
C:敏捷方法的思想是适应性,而不是预设性
D:敏捷方法以原型开发思想为基础,采用迭代式增量开发
选B
团队沟通的主要方式(   )
A:需求和规格应该足够清晰和明确,并在开发前完成评审和确认,不需要下游人员反复再去询问
B:迭代早期只确定一个需求的标题,临到开发前一刻才进行沟通和确认需求细节
C:需求不需要提前定义,成员可以随时和其想交流的人员进行交流和确认
D:频繁(每天/每周)召开团队会议讨论需求,包括开发人员、分析人员、用户代表
选D
CEO要求团队在当前Sprint中增加一个故事。团队该怎么办?
A:把故事加入下一个Sprint
B:尊重CEO的职权,不做任何调整直接把故事加入当前Sprint
C:把故事加入到当前Sprint,并丢弃一个相同大小的故事
D:通知产品负责人让他/她和CEO一起处理此事
选D
谁负责优先处理产品待办列表?
A:产品负责人
B:项目经理
C:开发领导
D:业务分析师
选A
以下()不是SCRUM MASTER职责
A:保护团队不受外来无端影响
B:尽可能提高团队影响力
C:负责SCRUM价值观与过程的实现
D:SCRUM MASTER是牧羊犬、公仆
选B
以下哪个不符合敏捷宣言?
A:个体和交互 胜过 流程和工具
B:客户谈判 胜过 客户合作
C:可以工作的软件 胜过 面面俱到的文档
D:响应变化 胜过 遵循计划
选B
跟踪敏捷项目中的项目问题是……的主要责任
A:测试者
B:项目负责人
C:职能经理
D:团队
选D
sprint评审的主要目的是?
A:让利益相关者可以向团队施加压力,以确保sprint能够有所产出
B:让团队可以审阅他们的工作,并决定需要做些什么来完成下一批列表条目
C:让产品经理向利益相关者展现进度
D:让利益相关者审阅团队所创建的成果,并为后续计划提供信息
选D
自动化测试所占比例应该(  )
A:90%以上
B:大于60%
C:25%—-60%
D:小于25%
选B
下面的()是错误的
A:软件交付的主要工作是将程序代码和相关文档交给用户
B:用户培训是帮助用户理解产品并掌握系统的使用和操作
C:软件部署是通过配置、安装和激活等活动保证软件系统的正常运行
D:持续集成是频繁持续地将团队成员的工作进行集成
选A
软件配置管理的目的是()
A:降低开发成本
B:控制软件修改
C:提高软件开发效率
D:提高正确率
选B
精益管理的核心是( )
A:消除一切浪费
B:最大程度的减少浪费
C:尽量提高劳动效率
D:零故障、零不良
选A
迭代计划会议的主要议程是()
A:讨论系统物理架构
B:研讨系统逻辑架构
C:讨论产品代办事项列表最需优先完成的事项
D:讨论系统数据架构
选C
所有的敏捷方法有什么共同点?
A:规定的、固定的迭代(计时器)长度
B:迭代开发和增量交付
C:严格注重按时交付
D:一大套明确界定的角色
选B
Sprint推荐的最长周期是多少?
A:30天
B:60天
C:90天
D:提供一个潜在可交付产品增量需要多久,就是多久
选A
如果Sprint长30天,Sprint评审会议是多久?
A:最多4小时
B:4~8小时
C:最少8小时
D:要多久就多久
选A
下面的()不是敏捷开发方法的特点
A:软件开发应该遵循严格受控的过程和详细的项目规划
B:客户应该和开发团队在一起密切地工作
C:通过高度迭代和增量式的软件开发过程响应变化
D:通过频繁地提供可以工作的软件来搜集人们对产品的反馈
选A
敏捷开发的最终结果是:
A:适合业务需求的专业品质的产品
B:与瀑布式发展几乎一样好的产品
C:一种勉强达到目的并故意不能维护的产品
D:一个技术上完美的,重新考虑的解决方案
选A
项目的特性清单(Product Backlog)最重要和必选的内容是(   )
A:每个特性的标题,优先级和估算
B:每个特性的标题,详细描述
C:每个特性的责任人和状态
D:以上都是
选A
敏捷项目应该有…
A:如果企业愿意接受较低的质量,则偶尔提前交付
B:以开发为重点的产品的定期交付模式
C:定期提供具有商业价值的增量的模式
D:不规则和不可预测的产品交付
选C
敏捷宣言背后的原则对于架构的处理是如何建议的?
A:架构会浮现出来
B:架构不重要,但功能重要
C:架构是预先定义和计划的
D:架构的定义和实现在第一个迭代中完成
选A
Scrum最适合如下哪一类工作?
A:复杂的
B:低风险的
C:简单的
D:预定义的
选A
Sprint Backlog中包含哪些内容?
A:用户故事
B:任务
C:用例
D:测试
选B
对详细设计文档(  )
A:每个设计活动后应该完成设计文档并评审和归档
B:每个迭代结束前必须完成设计文档和归档
C:每个版本发布前必须完成设计文档的编写和归档
D:阶段性(比如开发阶段末,项目收尾前)通过逆向工程或总结完成设计文档并归档,做为后续维护的参考资料
选D
Sprint推荐的最长周期是多少?
A:30天
B:60天
C:90天
D:提供一个潜在可交付产品增量需要多久,就是多久
选A
可持续的步伐意味着…
A:如果团队成员经常长时间工作,他们会习惯并能够维持下去
B:每周40小时仅适用于团队中较弱的成员,其他人可以做更多
C:团队应该建立一个可以在正常工作时间内维持的速度
D:长时间工作是准时交付的唯一途径
选C
SCRUM一般采用多长时间的迭代周期?
A:一般来说,它采用2-4周的迭代周期
B:一般来说,它采用1-4周的迭代周期
C:一般来说,它采用3-5周的迭代周期
D:一般来说,它采用3-4周的迭代周期
选A
什么是看板?
A:团队禁止的活动列表,与团队规范有关
B:一组可以为一个项目提供故事集的东西
C:一个看得见的工作图,里面包括工作的进度和完成的工作
D:团队完成的任务图
选C
对发布版本计划(   )
A:每个版本的范围是固定的,不允许调整
B:不包括每个版本的发布时间、发布内容、迭代数量
C:每个版本计划都要准时完成,不能推迟发布
D:概念阶段/项目早期就开始制定版本计划,并每个迭代进行及时维护
选D
丰田生产方式的目的在于彻底杜绝各种浪费,以提高生产( )
A:周期
B:交付期
C:成本
D:效率
选D
以下()不属于迭代回顾的内容和要求
A:定期审视团队目前运作状况和存在的问题
B:在每个迭代结束前进行
C:通常60分钟至90分钟
D:全员参与
选C
在对项目进行估算时,开发人员应该:
A:全面参与估算过程
B:对估算过程进行完全控制
C:在团队负责人对团队的工作做出估算之后,进行咨询
D:除非已知速率,否则不进行估算
选A
敏捷项目中的客户……
A:无法控制交付功能的优先级
B:完全控制功能的优先级
C:与开发人员在功能优先级上合作,但开发人员有最终决定权
D:与开发人员在功能优先级上合作,但业务有最终决定
选D
项目的特性清单(Product Backlog)最重要和必选的内容是(   )
A:每个特性的标题,优先级和估算
B:每个特性的标题,详细描述
C:每个特性的责任人和状态
D:以上都是
选A
敏捷宣言是怎么看待客户协作的?
A:跟客户紧密地协作,确保在项目构建阶段之前完成所有功能的定义
B:定期及频繁的客户反馈是必要的
C:团队必须告知Sprint中他们将产出的功能以及有关发布的目标
D:新的功能性需求要进入Sprint,需要先得到客户的一致认同
选B
在敏捷项目中,我们计划“边走边学”,因为……
A:它在开发人员和客户代表之间建立了更好的关系
B:许多项目是进化的,一个更好的解决方案就这样出现了
C:在项目开始时分析每件事都很费时
D:防止项目交付延误
选B
计划的频度(   )
A:做很短的计划,很少超过一两周
B:做短期的迭代计划(1个月内)以及中长期的版本计划(几个月到1年),迭代计划比较细,版本计划只做概要计划
C:做长期计划,包括详细的任务和分工。后期可以根据实际进展修订
D:频繁的做及时性计划
选B
以下()不属于迭代回顾的内容和要求
A:定期审视团队目前运作状况和存在的问题
B:在每个迭代结束前进行
C:通常60分钟至90分钟
D:全员参与
选C
开发人员CheckIn代码的频率(   )
A:每人每天进行一次或者多次
B:项目组每天一次或多次
C:每周一次或多次
D:特性完成时CheckIn
选A
看板的三大作用不包括( )
A:传递生产信息
B:保证生产现场的标准操作
C:识别浪费
D:控制生产系统动态的自我完善
选B
以下哪个不符合敏捷宣言?
A:个体和交互 胜过 流程和工具
B:客户谈判 胜过 客户合作
C:可以工作的软件 胜过 面面俱到的文档
D:响应变化 胜过 遵循计划
选B
Scrum最适合如下哪一类工作?
A:复杂的
B:低风险的
C:简单的
D:预定义的
选A
敏捷开发过程鼓励(  )
A:团队定期开会
B:没有会议
C:有冗长的报告要求
D:没有报告要求
选A
敏捷宣言背后的原则对于架构的处理是如何建议的?
A:架构会浮现出来
B:架构不重要,但功能重要
C:架构是预先定义和计划的
D:架构的定义和实现在第一个迭代中完成
选A
如下哪一句准确地描述了产品负责人在Scrum日会中的角色?
A:产品负责人向团队提供如何实现可工作解决方案的指导
B:产品负责人大概介绍一下团队在这个Sprint中必须吸收的那些变更
C:产品负责人确保实际燃尽速率维护在估算时的程度
D:团队决定产品负责人如何参与
选D
冒烟测试的频度(  )
A:每天进行一次或者多次
B:每周一次
C:间隔大于一周
D:按照测试版本的需要临时构建
选A
产品所有者的责任包括:
A:业务流程图表绘制
B:确定需求的优先次序
C:管理项目预算
D:以上全是
选D
在第一个sprint中团队做什么
A:交付设计文档
B:预先决定完整的架构和基础设施
C:完成Sprint目标
D:为后续的Sprint制定计划
选C
SCRUM框架下,哪个角色对软件商业价值负责?________
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:开发团队
选C
如果需要重新设定迭代计划,对用户故事和任务重新排序,那么谁应该负责?
A:仅开发人员(他们知道客户需要什么)
B:产品负责人(开发人员只会选择简单的东西作为最重要的事情)
C:项目负责人(他们可以提供独立,务实的观点)
D:整个团队包括产品负责人和开发人员(他们一起可以考虑商业价值和实用性)
选D
如下有关障碍的描述哪一条是正确的?
A:运行缓慢的服务器不被认为是障碍
B:移除障碍是产品负责人的工作
C:团队不应该使用Scrum日会来报告障碍
D:移除障碍是ScrumMaster的当务之急
选D
应该何时更新发布燃尽图?
A:每天后
B:每周后
C:每个Sprint后
D:每次发布后
选C
增量模型是()
A:适用于需求被清晰定义的情况
B:一种需要快速构造核心产品的好方法
C:一种不适用于商业产品的创新模型
D:已不能用于现代环境的过时模型
选B
在敏捷项目中,我们计划“边走边学”,因为……
A:它在开发人员和客户代表之间建立了更好的关系
B:许多项目是进化的,一个更好的解决方案就这样出现了
C:在项目开始时分析每件事都很费时
D:防止项目交付延误
选B
请解释Scrum中的用户故事是什么?
A:是一个短小的,一般用一句话可以说明的对特性或者功能的描述
B:是一个短小的,一般用两句话可以说明的对特性或者功能的描述
C:是一个可延展的,一般用一句话可以说明的对特性或者功能的描述
D:是一个短小的,一般用一句话可以说明的对用户故事或者功能的描述
选A
制定迭代计划时(  )
A:应该用任务把开发人员的可用工作量填满
B:应该包括加班时间
C:应该保留20%左右的缓冲
D:应该加大开发人员的并发任务,来充分利用资源
选C
在接受敏捷项目的任何可交付成果方面,以下哪一个陈述是正确的?
A:团队应该只允许高级管理人员签署可交付成果
B:团队应该至少在每个迭代结束时从干系人获得项目可交付成果的验收
C:项目结束时,团队应在UAT阶段接受用户的项目可交付成果
D:同时从所有干系人获得对该项目的任何特定交付物的验收
选B
()是用户故事的标准模板
A:作为一个<用户角色>,为了达到<目的>,我需要<功能>
B:作为一个<产品类型>,为了达到<目的>,我需要<功能>
C:作为一个<用户类型>,为了达到<目的>
D:作为一个<产品类型>,为了达到<目的>
选A
“拉动”一词是指(  )
A:上工序带动下工序
B:下工序带动上工序
C:上、下工序同步进行
D:以上皆不是
选B
制定迭代计划时(  )
A:应该用任务把开发人员的可用工作量填满
B:应该包括加班时间
C:应该保留20%左右的缓冲
D:应该加大开发人员的并发任务,来充分利用资源
选C
团队成员在执行相关迭代任务的时候,发现需要申请一台测试机,应该找谁?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队其他成员
选A
测试人员何时开展测试(   )
A:每个发布版本前(可能长于1个月)提交版本测试清单
B:每个迭代开发完成后(小于1个月)根据开发完成的特性清单来测试
C:开发人员交付任何特性则立即被测试
D:每天不断执行测试用例(不管代码是否存在),驱动开发人员进行开发
选C
持续改善的基础是(  )的途径
A:标准化
B:制度化
C:目视化
D:通用化
选A
在Sprint规划会议中,产品负责人……
A:决定团队如何完成其工作
B:把选定的故事分割为详细任务
C:展示他/她希望团队在sprint中完成的故事
D:决定在sprint结束时应该交付多少故事
选C
ScrumMaster要引导团队和产品负责人之间的交流,哪个技术是一个有效的方法?
A:引导产品负责人学习Sprint中用到的技术
B:引导他们之间的协作式会议
C:引导团队在谈话中使用业务需求和目标的术语
D:如上所有
选D
在墙上制作看板,展现项目计划,对团队有什么影响?
A:它不需要为管理创建任何其他报告
B:不断沟通团队内部和其他利益相关者的进展
C:它允许项目经理分配任务给特定的团队成员
D:这是限制性的,因为它不允许团队创新和改变
选B
迭代计划会议的主要议程是()
A:讨论系统物理架构
B:研讨系统逻辑架构
C:讨论产品代办事项列表最需优先完成的事项
D:讨论系统数据架构
选C
工作任务如何分配(    )
A:领导/经理指定每个人的工作(设计、编码、测试等),并及时进行沟通确认
B:成员一起来分解需求到任务和估算,并从任务列表领取他们将要进行的工作
C:成员直接领取需求,并承诺交付时间
D:以上都不是
选B
PO创建需求的INVEST原则是什么?
A:独立性、可协商性、有价值、可以估算性、短小、可测性
B:独特性、可协商性、有价值、可以估算性、短小、可测性
C:独立性、可协商性、有价值、可以估算性、短小、可拆性
D:独立性、可协商性、有价值、不可估算性、短小、可测性
选A
项目内部的管理方式(   )
A:管理是正式的、结构化的,要求周期性进行,并且由一个独立机构进行技术审核
B:管理是非正式的,由高层管理者通过“走动式管理”完成
C:管理是共同承担责任。计划由所有团队成员和资深管理人员共同制定,从而不需要强制就可以共同遵从
D:项目经理管理Master(或组长),master(或组长)管理开发人员
选C
以下哪些角色不是SCRUM框架中定义的角色_________
A:ScrumMaster
B:开发团队
C:ProductOwner
D:架构师
选D
产品负责人的最佳描述是?
A:阻止干系人干扰团队
B:指挥团队的日常工作
C:管理项目,确保工作成果能够兑现向干系人作出的承诺
D:优化工作成果的业务价值
选D
以下哪项最能描述确定迭代(时间箱)长度的方法?
A:迭代(时间箱)应该总是30天
B:团队通过将故事点的总数除以团队的平均速度来确定迭代(时间箱)的长度
C:迭代(时间箱)应该总是两周
D:考虑到项目的规模和复杂性,团队应该迭代的长度(计时器)达成一致
选D
下面的()不属于产品负责人(Product Owner)的职责范围
A:组织每日站立会议
B:定义产品需求
C:确定需求优先级
D:验收迭代结果
选A
为什么建议产品负责人参加Scrum日会
A:确保团队还在向着sprint目标的方向努力
B:对团队进度发布意见
C:告诉团队接下来作哪个任务,并更新产品列表
D:查看已取得的进展,若团队需要帮助,应积极提出沟通
选D
实行“看板方式”的基础是:(   )
A:准时化
B:自动化
C:流水线生产
D:均衡化生产
选C
最应该参加迭代评估(演示)的人员(  )
A:项目经理
B:用户代表
C:开发人员
D:测试人员
选B
外部对项目的管理方式(  )
A:管理是正式的、结构化的,要求周期性进行,并且由一个独立机构进行技术审核
B:管理是非正式的,由高层管理者通过“走动式管理”完成
C:管理是共同承担责任。计划由所有团队成员和资深管理人员共同制定,从而不需要强制就可以共同遵从
D:不需要管理,每个人都是自管理
选A
“拉动”一词是指(  )
A:上工序带动下工序
B:下工序带动上工序
C:上、下工序同步进行
D:以上皆不是
选B
在敏捷项目中,我们计划“边走边学”,因为……
A:它在开发人员和客户代表之间建立了更好的关系
B:许多项目是进化的,一个更好的解决方案就这样出现了
C:在项目开始时分析每件事都很费时
D:防止项目交付延误
选B
SCRUM中335分别指的是什么?
A:3个角色、3个工件、5个会议
B:3个会议、3个工件、5个角色
C:3个工件、3张图表、5个会议
D:3个成员、3个会议、5个工件
选A
下面的哪一种说法是正确的?
A:故事点是一个绝对度量单位
B:故事点估算一定要做到非常精确
C:故事点表示开发一个用户故事或特性的复杂度
D:故事点表示开发一个用户故事或特性所要付出的工作量
选D
敏捷项目中推荐的设计方法是:
A:没有预先设计
B:大的预先设计
C:前面有足够的设计
D:使用之前的设计——它将“足够好”
选C
实行“看板方式”的基础是:(   )
A:准时化
B:自动化
C:流水线生产
D:均衡化生产
选C
Sprint推荐的最长周期是多少?
A:30天
B:60天
C:90天
D:提供一个潜在可交付产品增量需要多久,就是多久
选A
一旦项目进行中,计划的方法是
A:计划不应该改变
B:随着项目的进展,需要计划和重新计划是正常的
C:计划只有在所有利益相关方完全同意的情况下才能改变
D:由于敏捷是增量式的,因此不需要计划
选B
产品负责人的最佳描述是?
A:阻止干系人干扰团队
B:指挥团队的日常工作
C:管理项目,确保工作成果能够兑现向干系人作出的承诺
D:优化工作成果的业务价值
选D
敏捷宣言背后的原则对于架构的处理是如何建议的?
A:架构会浮现出来
B:架构不重要,但功能重要
C:架构是预先定义和计划的
D:架构的定义和实现在第一个迭代中完成
选A
什么是看板?
A:团队禁止的活动列表,与团队规范有关
B:一组可以为一个项目提供故事集的东西
C:一个看得见的工作图,里面包括工作的进度和完成的工作
D:团队完成的任务图
选C
以下哪些角色不是SCRUM框架中定义的角色_________
A:ScrumMaster
B:开发团队
C:ProductOwner
D:架构师
选D
以下哪个不符合敏捷宣言?
A:个体和交互 胜过 流程和工具
B:客户谈判 胜过 客户合作
C:可以工作的软件 胜过 面面俱到的文档
D:响应变化 胜过 遵循计划
选B
产品负责人的责任包括:
A:业务流程图表绘制
B:确定需求的优先次序
C:管理项目预算
D:以上全是
选D
Sprint何时结束?
A:当任务完成的时候
B:取决于团队的规模
C:当承诺的条目满足了它们的完成定义的时候
D:当时间盒耗尽的时候
选D
计划的频度(   )
A:做很短的计划,很少超过一两周
B:做短期的迭代计划(1个月内)以及中长期的版本计划(几个月到1年),迭代计划比较细,版本计划只做概要计划
C:做长期计划,包括详细的任务和分工。后期可以根据实际进展修订
D:频繁的做及时性计划
选B
关于Sprint,下面的()是错误的
A:一个Sprint通常是一个1-4周的迭代
B:Sprint长度在开发过程中是可以调整的
C:需求在一个Sprint中是不允许变化的
D:sprint的产出是“完成”的、可用的、潜在可发布的产品增量
选B
敏捷宣言背后的原则对于架构的处理是如何建议的?
A:架构会浮现出来
B:架构不重要,但功能重要
C:架构是预先定义和计划的
D:架构的定义和实现在第一个迭代中完成
选A
团队成员在执行相关迭代任务的时候,发现需求不明确,应该找谁?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队其他成员
选C
如下哪一句准确地描述了产品负责人在Scrum日会中的角色?
A:产品负责人向团队提供如何实现可工作解决方案的指导
B:产品负责人大概介绍一下团队在这个Sprint中必须吸收的那些变更
C:产品负责人确保实际燃尽速率维护在估算时的程度
D:团队决定产品负责人如何参与
选D
如果客户代表一再忙得没空参与开发过程,团队应该怎么办?
A:继续工作,记录假设并稍后询问客户
B:向客户发出书面警告,说明最终产品将按时完成,但可能无法满足他们的需求
C:允许PO担任代理客户代表的角色
D:将问题提请Scrum Master
选C
sprint评审的主要目的是?
A:让利益相关者可以向团队施加压力,以确保sprint能够有所产出
B:让团队可以审阅他们的工作,并决定需要做些什么来完成下一批列表条目
C:让产品经理向利益相关者展现进度
D:让利益相关者审阅团队所创建的成果,并为后续计划提供信息
选D
计划的频度(   )
A:做很短的计划,很少超过一两周
B:做短期的迭代计划(1个月内)以及中长期的版本计划(几个月到1年),迭代计划比较细,版本计划只做概要计划
C:做长期计划,包括详细的任务和分工。后期可以根据实际进展修订
D:频繁的做及时性计划
选B
SCRUM中335分别指的是什么?
A:3个角色、3个工件、5个会议
B:3个会议、3个工件、5个角色
C:3个工件、3张图表、5个会议
D:3个成员、3个会议、5个工件
选A
下面的哪一种说法是正确的?
A:故事点是一个绝对度量单位
B:故事点估算一定要做到非常精确
C:故事点表示开发一个用户故事或特性的复杂度
D:故事点表示开发一个用户故事或特性所要付出的工作量
选D
瀑布模型是()
A:适用于需求被清晰定义的情况
B:一种需要快速构造可运行程序的好方法
C:一种不适用于商业产品的创新模型
D:目前业界最流行的过程模型
选A
如果需要重新设定迭代计划,对用户故事和任务重新排序,那么谁应该负责?
A:仅开发人员(他们知道客户需要什么)
B:产品负责人(开发人员只会选择简单的东西作为最重要的事情)
C:项目负责人(他们可以提供独立,务实的观点)
D:整个团队包括产品负责人和开发人员(他们一起可以考虑商业价值和实用性)
选D
使用Scrum时,谁主要负责在范围和进度之间作出权衡决策
A:ScrumMaster
B:团队
C:产品负责人
D:项目经理
选C
SCRUM框架下,哪个角色对软件商业价值负责?________
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:开发团队
选C
最应该参加迭代评估(演示)的人员(  )
A:项目经理
B:用户代表
C:开发人员
D:测试人员
选B
为了良好沟通,敏捷项目应该……
A:保持团队规模较大,以避免利益相关者感到遗漏
B:将项目分解为小型,混合技能的自组织团队
C:与一个不到10人的团队合作
D:与独立的客户,开发人员和测试团队合作
选B
在对项目进行估算时,开发人员应该:
A:全面参与估算过程
B:对估算过程进行完全控制
C:在团队负责人(Scrum Master)对团队的工作做出估算之后,请进行咨询
D:除非已知速率,否则不进行估算
选A
团队沟通的主要方式(   )
A:需求和规格应该足够清晰和明确,并在开发前完成评审和确认,不需要下游人员反复再去询问
B:迭代早期只确定一个需求的标题,临到开发前一刻才进行沟通和确认需求细节
C:需求不需要提前定义,成员可以随时和其想交流的人员进行交流和确认
D:频繁(每天/每周)召开团队会议讨论需求,包括开发人员、分析人员、用户代表
选D
敏捷宣言是怎么看待客户协作的?
A:跟客户紧密地协作,确保在项目构建阶段之前完成所有功能的定义
B:定期及频繁的客户反馈是必要的
C:团队必须告知Sprint中他们将产出的功能以及有关发布的目标
D:新的功能性需求要进入Sprint,需要先得到客户的一致认同
选B
如果Sprint长30天,Sprint评审会议是多久?
A:最多4小时
B:4~8小时
C:最少8小时
D:要多久就多久
选A
团队成员在执行相关迭代任务的时候,发现需求不明确,应该找谁?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队其他成员
选C
增量模型是()
A:适用于需求被清晰定义的情况
B:一种需要快速构造核心产品的好方法
C:一种不适用于商业产品的创新模型
D:已不能用于现代环境的过时模型
选B
冒烟测试的频度(  )
A:每天进行一次或者多次
B:每周一次
C:间隔大于一周
D:按照测试版本的需要临时构建
选A
如下那一项是Sprint列表最主要的目的?
A:团队用于Sprint中管理他们自己
B:ScrumMaster用于Sprint中管理进展情况
C:团队用来管理Sprint中所花掉的那些小时数
D:产品负责人从中了解团队为Sprint承诺了什么
选A
哪个角色最有可能在Scrum日会上提及一个障碍?
A:团队
B:ScrumMaster
C:产品负责人
D:干系人
选A
看板的三大作用不包括( )
A:传递生产信息
B:保证生产现场的标准操作
C:识别浪费
D:控制生产系统动态的自我完善
选B
PO创建需求的INVEST原则是什么?
A:独立性、可协商性、有价值、可以估算性、短小、可测性
B:独特性、可协商性、有价值、可以估算性、短小、可测性
C:独立性、可协商性、有价值、可以估算性、短小、可拆性
D:独立性、可协商性、有价值、不可估算性、短小、可测性
选A
如果需要重新设定(迭代)计划需要在匆忙中重新排序,那么谁应该重新排序?
A:仅开发人员(他们知道客户需要什么)
B:产品负责人(开发人员只会选择简单的东西作为最重要的事情)
C:项目负责人(他们可以提供独立,务实的观点)
D:整个团队包括产品负责人和开发人员(他们一起可以考虑商业价值和实用性)
选D
燃尽图有哪两种类型()
A:产品发布燃尽图、任务燃尽图
B:产品发布燃尽图、迭代燃尽图
C:任务燃尽图、用户故事燃尽图
D:开发工作量燃尽图、产品发布燃尽图
选B
冒烟测试的频度(  )
A:每天进行一次或者多次
B:每周一次
C:间隔大于一周
D:按照测试版本的需要临时构建
选A
工作任务如何分配(    )
A:领导/经理指定每个人的工作(设计、编码、测试等),并及时进行沟通确认
B:成员一起来分解需求到任务和估算,并从任务列表领取他们将要进行的工作
C:成员直接领取需求,并承诺交付时间
D:以上都不是
选B
看板的三大作用不包括( )
A:传递生产信息
B:保证生产现场的标准操作
C:识别浪费
D:控制生产系统动态的自我完善
选B
Scrum日会上,Olivia提到,说她发现了一些开源代码,应该可以解决她正在处理的某个问题。她想马上就着手实现。下一步做什么最好
A:ScrumMaster让Olivia去准备一个样例以及给团队的演示,这样他们会考虑使用此代码
B:团队所有成员都要求评估Olivia的解决方案,下一次Scrum日会时向团队汇报情况
C:产品负责人记录下障碍,并在会后着手解决
D:开完Scrum日会之后,再单独开会讨论这个开源解决方案
选D
ScrumMaster要用于引导团队和产品负责人之间的交流,哪个技术是一个有效的方法?
A:教产品负责人学习Sprint中用到的技术
B:引导他们之间的协作式会议
C:教团队在谈话中使用业务需求和目标的术语
D:如上所有
选D
关于Scrum的每一次冲刺(Sprint),下面的()是正确的
A:Sprint是一个不超过4周的迭代,其长度一旦确定,将保持不变
B:Sprint的产出是一个可用的、潜在可发布的产品增量
C:Sprint在进行过程中,其开发目标、质量验收标准和团队组成不能发生变化
D:以上所有选项
选D
敏捷开发的最终结果是:
A:适合业务需求的专业品质的产品
B:与瀑布式发展几乎一样好的产品
C:一种勉强达到目的并故意不能维护的产品
D:一个技术上完美的,重新考虑的解决方案
选A
自动化测试所占比例应该(  )
A:90%以上
B:大于60%
C:25%—-60%
D:小于25%
选B
以下()不属于迭代回顾的内容和要求
A:定期审视团队目前运作状况和存在的问题
B:在每个迭代结束前进行
C:通常60分钟至90分钟
D:全员参与
选C
以下不属于Scrum的三大支柱的是(  )
A:透明性
B:检验
C:观察
D:适应
选C
Scrum的计划机制是(  )
A:提前做好计划,阶段性(按月和周)按照计划查看团队进展
B:每个迭代都制定计划和调整计划
C:每天都不断地做计划,当事情发生变化我们就会制定新的计划
D:没有必要做计划,只要不断滚动的从backlog中取出最高优先的需求来开发即可
选B
如果敏捷项目运行后出现新需求,应该是:
A:自动包含在项目的工作中
B:自动排除并保留至稍后的项目或增量
C:评估重要性,如果对业务来说足够重要,则包括在项目中,取代较不重要的要求
D:项目开发完成后,对照本轮的迭代任务,提交给项目干系人评审
选C
当团队认定很难在Sprint结束时交付任何价值的时候,Scrum鼓励的处理方式是?
A:为了容纳额外的工作,再延长Sprint几天
B:和产品负责人一起,关注可完成的部分,想办法做到每个Sprint结束时都能交付些价值
C:立刻上报给高级管理层
D:建议产品负责人异常地终止Sprint
选B
项目的特性清单(Product Backlog)最重要和必选的内容是(   )
A:每个特性的标题,优先级和估算
B:每个特性的标题,详细描述
C:每个特性的责任人和状态
D:以上都是
选A
对于敏捷项目的可交付成果的质量,以下哪项陈述是正确的?
A:敏捷项目生产的产品应该比任何其他方法生产的产品便宜,但质量会受到影响
B:这些产品比其他任何方法都贵,但是质量最好
C:产品适合用途,但可能无法满足客户的需求
D:根据整个开发过程中涉及的客户代表的指导,产品质量合适
选D
SCRUM框架下,测试工作应该由谁来完成?
A:ScrumMaster
B:测试人员
C:开发人员
D:开发团队
选D
Sprint推荐的最长周期是多少?
A:30天
B:60天
C:90天
D:提供一个潜在可交付产品增量需要多久,就是多久
选A
精益管理的核心是( )
A:消除一切浪费
B:最大程度的减少浪费
C:尽量提高劳动效率
D:零故障、零不良
选A
下列关于敏捷方法的叙述中,错误的是()
A:与传统方法相比,敏捷方法比较适合需求变化大或者开发前期对需求不是很清晰的项目
B:敏捷方法尤其适合于开发团队比较庞大的项目
C:敏捷方法的思想是适应性,而不是预设性
D:敏捷方法以原型开发思想为基础,采用迭代式增量开发
选B
以下哪些角色不是SCRUM框架中定义的角色_________
A:ScrumMaster
B:团队team
C:ProductOwner
D:架构师
选D
自动化测试所占比例应该(  )
A:90%以上
B:大于60%
C:25%—-60%
D:小于25%
选B
以下()不是SCRUM MASTER职责
A:保护团队不受外来无端影响
B:尽可能提高团队影响力
C:负责SCRUM价值观与过程的实现
D:SCRUM MASTER是牧羊犬、公仆
选B
如果Sprint长30天,Sprint评审会议是多久?
A:最多4小时
B:4~8小时
C:最少8小时
D:要多久就多久
选A
对发布版本计划(   )
A:每个版本的范围是固定的,不允许调整
B:不包括每个版本的发布时间、发布内容、迭代数量
C:每个版本计划都要准时完成,不能推迟发布
D:概念阶段/项目早期就开始制定版本计划,并每个迭代进行及时维护
选D
所有的敏捷方法有什么共同点?
A:规定的、固定的迭代(计时器)长度
B:迭代开发和增量交付
C:严格注重按时交付
D:一大套明确界定的角色
选B
迭代计划会议的主要议程是()
A:讨论系统物理架构
B:研讨系统逻辑架构
C:讨论产品代办事项列表最需优先完成的事项
D:讨论系统数据架构
选C
团队成员在执行相关迭代任务的时候,发现需要申请一台测试机,应该找谁?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队其他成员
选A
拉动系统的核心是(  )
A:5S
B:自动化
C:看板管理
D:准时化
选D
对详细设计文档(  )
A:每个设计活动后应该完成设计文档并评审和归档
B:每个迭代结束前必须完成设计文档和归档
C:每个版本发布前必须完成设计文档的编写和归档
D:阶段性(比如开发阶段末,项目收尾前)通过逆向工程或总结完成设计文档并归档,做为后续维护的参考资料
选D
如下有关障碍的描述哪一条是正确的?
A:运行缓慢的服务器不被认为是障碍
B:移除障碍是产品负责人的工作
C:团队不应该使用Scrum日会来报告障碍
D:移除障碍是ScrumMaster的当务之急
选D
SCRUM一般采用多少个冲刺周期?
A:一般来说,它采用2-4周的迭代周期
B:一般来说,它采用1-4周的迭代周期
C:一般来说,它采用3-5周的迭代周期
D:一般来说,它采用3-4周的迭代周期
选A
如下哪一条是良好团队的特征?
A:是自组织的
B:等待任务被分派下来
C:成员们技术能力水平全都很接近
D:向ScrumMaster寻求方向
选A
()是Product backlog
A:产品负责人
B:产品代办事项列表
C:迭代
D:燃尽图
选B
敏捷方式是:
A:尽早、渐进地生产出正确质量的工作产品
B:在文件签署后生产工作产品
C:尽早制作简单的原型,但直到项目结束时才制作成品
D:生产没有技术完整性的产品,但稍后重新设计
选A
项目内部的管理方式(   )
A:管理是正式的、结构化的,要求周期性进行,并且由一个独立机构进行技术审核
B:管理是非正式的,由高层管理者通过“走动式管理”完成
C:管理是共同承担责任。计划由所有团队成员和资深管理人员共同制定,从而不需要强制就可以共同遵从
D:项目经理管理Master(或组长),master(或组长)管理开发人员
选C
ScrumMaster要用于引导团队和产品负责人之间的交流,哪个技术是一个有效的方法?
A:教产品负责人学习Sprint中用到的技术
B:引导他们之间的协作式会议
C:教团队在谈话中使用业务需求和目标的术语
D:如上所有
选D
下面的()不是敏捷开发方法的特点
A:软件开发应该遵循严格受控的过程和详细的项目规划
B:客户应该和开发团队在一起密切地工作
C:通过高度迭代和增量式的软件开发过程响应变化
D:通过频繁地提供可以工作的软件来搜集人们对产品的反馈
选A
如果客户代表一再忙得没空参与开发过程,团队应该怎么办?
A:继续工作,记录假设并稍后询问客户
B:向客户发出书面警告,说明最终产品将按时完成,但可能无法满足他们的需求
C:允许PO担任代理客户代表的角色
D:将问题提请Scrum Master
选C
如下哪一条属于产品负责人的职责
A:决定团队成功所必需的构成
B:决定合适的发布日期
C:决定恰当的项目技术方案
D:决定sprint的长度
选B
持续改善的基础是(  )的途径
A:标准化
B:制度化
C:目视化
D:通用化
选A
当团队认定很难在Sprint结束时交付任何价值的时候,Scrum鼓励的处理方式是?
A:为了容纳额外的工作,再延长Sprint几天
B:和产品负责人一起,关注可完成的部分,想办法做到每个Sprint结束时都能交付些价值
C:立刻上报给高级管理层
D:建议产品负责人异常地终止Sprint
选B
瀑布模型是()
A:适用于需求被清晰定义的情况
B:一种需要快速构造可运行程序的好方法
C:一种不适用于商业产品的创新模型
D:目前业界最流行的过程模型
选A
对发布版本计划(   )
A:每个版本的范围是固定的,不允许调整
B:不包括每个版本的发布时间、发布内容、迭代数量
C:每个版本计划都要准时完成,不能推迟发布
D:概念阶段/项目早期就开始制定版本计划,并每个迭代进行及时维护
选D
敏捷开发过程鼓励(  )
A:团队定期开会
B:没有会议
C:有冗长的报告要求
D:没有报告要求
选A
对计划的发布版本应该(  )
A:按产品特性交付:需要交付的特性都必须交付,必要时要推迟发布时间
B:按日期交付:按照预定发布时间进行发布,必要时候裁剪部分功能特性
C:临时决定:我们会平衡一下,临时根据市场要求和开发进展来确定,可能会同时调整交付时间和特性
D:在迭代模式下,没有必要计划版本。每个迭代都应该完成可发布的版本,按照市场需要发布迭代版本即可
选B
当紧急需求变化时候(   )
A:PO重新排列特性清单中优先级,开发团队决定哪些工作要重新认领
B:项目经理增加紧急任务,扩大加班时间
C:开发团队拼命工作适应变化,并将项目拖回到正常轨道上来
D:紧急需求应该放到下一个迭代或防火墙团队,不应该干扰现有的任
选A
SCRUM框架下,哪个角色对软件商业价值负责?________
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:开发团队
选C
拉动系统的核心是(  )
A:5S
B:自动化
C:看板管理
D:准时化
选D
谁负责优先处理产品待办列表?
A:产品负责人
B:项目经理
C:开发领导
D:业务分析师
选A
拉动系统的核心是(  )
A:5S
B:自动化
C:看板管理
D:准时化
选D
团队沟通的主要方式(   )
A:需求和规格应该足够清晰和明确,并在开发前完成评审和确认,不需要下游人员反复再去询问
B:迭代早期只确定一个需求的标题,临到开发前一刻才进行沟通和确认需求细节
C:需求不需要提前定义,成员可以随时和其想交流的人员进行交流和确认
D:频繁(每天/每周)召开团队会议讨论需求,包括开发人员、分析人员、用户代表
选D
如下哪一句准确地描述了产品负责人在Scrum日会中的角色?
A:产品负责人向团队提供如何实现可工作解决方案的指导
B:产品负责人大概介绍一下团队在这个Sprint中必须吸收的那些变更
C:产品负责人确保实际燃尽速率维护在估算时的程度
D:团队决定产品负责人如何参与
选D
产品愿景应该具备哪些品质?
A:可追溯至IT投资相关整体性企业治理结构的概要
B:描绘一幅详细的概观,可以启发和赋予灵感
C:描述项目的追求所在,以及产品渴望达到的最终状态
D:提供一个投资回报方案的完整分解结构
选C
关于Sprint,下面的()是错误的
A:一个Sprint通常是一个1-4周的迭代
B:Sprint长度在开发过程中是可以调整的
C:需求在一个Sprint中是不允许变化的
D:sprint的产出是“完成”的、可用的、潜在可发布的产品增量
选B
在对项目进行估算时,开发人员应该:
A:全面参与估算过程
B:对估算过程进行完全控制
C:在团队负责人(Scrum Master)对团队的工作做出估算之后,请进行咨询
D:除非已知速率,否则不进行估算
选A
为了良好沟通,敏捷项目应该……
A:保持团队规模较大,以避免利益相关者感到遗漏
B:将项目分解为小型,混合技能的自组织团队
C:与一个不到10人的团队合作
D:与独立的客户,开发人员和测试团队合作
选B
CEO要求团队在当前Sprint中增加一个故事。团队该怎么办?
A:把故事加入下一个Sprint
B:尊重CEO的职权,不做任何调整直接把故事加入当前Sprint
C:把故事加入到当前Sprint,并丢弃一个相同大小的故事
D:通知产品负责人让他/她和CEO一起处理此事
选D
在Sprint规划会议中,产品负责人……
A:决定团队如何完成其工作
B:把选定的故事分割为详细任务
C:展示他/她希望团队在sprint中完成的故事
D:决定在sprint结束时应该交付多少故事
选C
计划的频度(   )
A:做很短的计划,很少超过一两周
B:做短期的迭代计划(1个月内)以及中长期的版本计划(几个月到1年),迭代计划比较细,版本计划只做概要计划
C:做长期计划,包括详细的任务和分工。后期可以根据实际进展修订
D:频繁的做及时性计划
选B
在敏捷项目中应该如何将工作分配给团队?
A:团队负责人(Scrum Master)应该将具体任务分配给个人
B:任务应该随机分配给团队成员,使用规划扑克
C:团队成员应自行选择适合其技能的任务
D:最复杂的任务应由团队负责人(Scrum Master)
选C
团队成员在执行相关迭代任务的时候,发现需要申请一台测试机,应该找谁?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队其他成员
选A
测试人员何时开展测试(   )
A:每个发布版本前(可能长于1个月)提交版本测试清单
B:每个迭代开发完成后(小于1个月)根据开发完成的特性清单来测试
C:开发人员交付任何特性则立即被测试
D:每天不断执行测试用例(不管代码是否存在),驱动开发人员进行开发
选C
产品负责人和ScrumMaster可以是同一个人么
A:不可以。一个人的时间不够用
B:不可以。这个人会拥有太多权力和职责,这会产生困扰
C:可以,只要这个人能够小心地平衡这两份职责就可以
D:可以,只要这个人有职权和能力可以完成所有的事情就可以
选B
下面的()不属于产品负责人(Product Owner)的职责范围
A:组织每日站立会议
B:定义产品需求
C:确定需求优先级
D:验收迭代结果
选A
对详细设计文档(  )
A:每个设计活动后应该完成设计文档并评审和归档
B:每个迭代结束前必须完成设计文档和归档
C:每个版本发布前必须完成设计文档的编写和归档
D:阶段性(比如开发阶段末,项目收尾前)通过逆向工程或总结完成设计文档并归档,做为后续维护的参考资料
选D
项目内部的管理方式(   )
A:管理是正式的、结构化的,要求周期性进行,并且由一个独立机构进行技术审核
B:管理是非正式的,由高层管理者通过“走动式管理”完成
C:管理是共同承担责任。计划由所有团队成员和资深管理人员共同制定,从而不需要强制就可以共同遵从
D:项目经理管理Master(或组长),master(或组长)管理开发人员
选C
如果需要重新设定迭代计划,对用户故事和任务重新排序,那么谁应该负责?
A:仅开发人员(他们知道客户需要什么)
B:产品负责人(开发人员只会选择简单的东西作为最重要的事情)
C:项目负责人(他们可以提供独立,务实的观点)
D:整个团队包括产品负责人和开发人员(他们一起可以考虑商业价值和实用性)
选D
燃尽图有哪两种类型()
A:产品发布燃尽图、任务燃尽图
B:产品发布燃尽图、迭代燃尽图
C:任务燃尽图、用户故事燃尽图
D:开发工作量燃尽图、产品发布燃尽图
选B
团队成员在工作中,对自己的职业规划和技术能力提升产生困惑,应该找谁?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队其他成员
选B
以下哪项最能描述确定迭代(时间箱)长度的方法?
A:迭代(时间箱)应该总是30天
B:团队通过将故事点的总数除以团队的平均速度来确定迭代(时间箱)的长度
C:迭代(时间箱)应该总是两周
D:考虑到项目的规模和复杂性,团队应该迭代的长度(计时器)达成一致
选D
敏捷过程…
A:鼓励团队定期开会
B:没有会议
C:有冗长的报告要求
D:没有报告要求
选A
()是PSP
A:潜在可交付的产品增量
B:可交付的产品增量
C:潜在不可交付的产品增量
D:不可交付的产品增量
选A
实行“看板方式”的基础是:(   )
A:准时化
B:自动化
C:流水线生产
D:均衡化生产
选C
为什么建议产品负责人参加Scrum日会
A:确保团队还在向着sprint目标的方向努力
B:对团队进度发布意见
C:告诉团队接下来作哪个任务,并更新产品列表
D:查看已取得的进展,若团队需要帮助,应积极提出沟通
选D
开发人员CheckIn代码的频率(   )
A:每人每天进行一次或者多次
B:项目组每天一次或多次
C:每周一次或多次
D:特性完成时CheckIn
选A
()是Product backlog
A:产品负责人
B:产品代办事项列表
C:迭代
D:燃尽图
选B
以下哪些角色不是SCRUM框架中定义的角色_________
A:ScrumMaster
B:团队team
C:ProductOwner
D:架构师
选D
请解释Scrum中的用户故事是什么?
A:是一个短小的,一般用一句话可以说明的对特性或者功能的描述
B:是一个短小的,一般用两句话可以说明的对特性或者功能的描述
C:是一个可延展的,一般用一句话可以说明的对特性或者功能的描述
D:是一个短小的,一般用一句话可以说明的对用户故事或者功能的描述
选A
敏捷计划时机(  )
A:提前做好计划,阶段性(按月和周)按照计划查看团队进展
B:每个迭代都制定计划和调整计划
C:每天都不断地做计划,当事情发生变化我们就会制定新的计划
D:没有必要做计划,只要不断滚动的从backlog中取出最高优先的需求来开发即可
选B
当一个敏捷团队成功…
A:应该鼓励在项目结束时才能庆祝成功
B:应该鼓励立即庆祝即使小小的成功
C:它不应该庆祝成功,因为这会浪费项目预算
D:它不应该庆祝成功,因为这会让不太成功的团队感觉不好
选B
如果敏捷项目运行后出现新需求,应该是:
A:自动包含在项目的工作中
B:自动排除并保留至稍后的项目或增量
C:评估重要性,如果对业务来说足够重要,则包括在项目中,取代较不重要的要求
D:项目开发完成后,对照本轮的迭代任务,提交给项目干系人评审
选C
ScrumMaster要引导团队和产品负责人之间的交流,哪个技术是一个有效的方法?
A:引导产品负责人学习Sprint中用到的技术
B:引导他们之间的协作式会议
C:引导团队在谈话中使用业务需求和目标的术语
D:如上所有
选D
敏捷的文档处理方法是:
A:没有文档,因为这个太浪费时间了
B:做大量的文档,证明你做得很好
C:做必要的文档以支持产品的开发和使用
D:比平常做更多的文档,因为敏捷是有风险的
选C
最应该参加迭代评估(演示)的人员(  )
A:项目经理
B:用户代表
C:开发人员
D:测试人员
选B
SCRUM中335分别指的是什么?
A:3个角色、3个工件、5个会议
B:3个会议、3个工件、5个角色
C:3个工件、3张图表、5个会议
D:3个成员、3个会议、5个工件
选A
()是用户故事的标准模板
A:作为一个<用户角色>,为了达到<目的>,我需要<功能>
B:作为一个<产品类型>,为了达到<目的>,我需要<功能>
C:作为一个<用户类型>,为了达到<目的>
D:作为一个<产品类型>,为了达到<目的>
选A
在墙上制作看板,展现项目计划,对团队有什么影响?
A:它不需要为管理创建任何其他报告
B:不断沟通团队内部和其他利益相关者的进展
C:它允许项目经理分配任务给特定的团队成员
D:这是限制性的,因为它不允许团队创新和改变
选B
冒烟测试的频度(  )
A:每天进行一次或者多次
B:每周一次
C:间隔大于一周
D:按照测试版本的需要临时构建
选A
当紧急需求变化时候(   )
A:PO重新排列特性清单中优先级,开发团队决定哪些工作要重新认领
B:项目经理增加紧急任务,扩大加班时间
C:开发团队拼命工作适应变化,并将项目拖回到正常轨道上来
D:紧急需求应该放到下一个迭代或防火墙团队,不应该干扰现有的任
选A
敏捷项目应该有…
A:如果企业愿意接受较低的质量,则偶尔提前交付
B:以开发为重点的产品的定期交付模式
C:定期提供具有商业价值的增量的模式
D:不规则和不可预测的产品交付
选C
如下那一项是Sprint列表最主要的目的?
A:团队用于Sprint中管理他们自己
B:ScrumMaster用于Sprint中管理进展情况
C:团队用来管理Sprint中所花掉的那些小时数
D:产品负责人从中了解团队为Sprint承诺了什么
选A
产品负责人的最佳描述是?
A:阻止干系人干扰团队
B:指挥团队的日常工作
C:管理项目,确保工作成果能够兑现向干系人作出的承诺
D:优化工作成果的业务价值
选D
敏捷项目中推荐的设计方法是:
A:没有预先设计
B:大的预先设计
C:前面有足够的设计
D:使用之前的设计——它将“足够好”
选C
()是用户故事的标准模板
A:作为一个<用户角色>,为了达到<目的>,我需要<功能>
B:作为一个<产品类型>,为了达到<目的>,我需要<功能>
C:作为一个<用户类型>,为了达到<目的>
D:作为一个<产品类型>,为了达到<目的>
选A
最应该参加迭代评估(演示)的人员(  )
A:项目经理
B:用户代表
C:开发人员
D:测试人员
选B
如果需要重新设定(迭代)计划需要在匆忙中重新排序,那么谁应该重新排序?
A:仅开发人员(他们知道客户需要什么)
B:产品负责人(开发人员只会选择简单的东西作为最重要的事情)
C:项目负责人(他们可以提供独立,务实的观点)
D:整个团队包括产品负责人和开发人员(他们一起可以考虑商业价值和实用性)
选D
(  )是七大浪费中最大的浪费,它除造成直观的浪费外,还会把“等待是浪费”隐藏起来,使管理人员漠视等待的发生
A:制造过剩的浪费
B:库存
C:生产不良的浪费
D:加工过剩的浪费
选B
下面的哪一种说法是正确的?
A:故事点是一个绝对度量单位
B:故事点估算一定要做到非常精确
C:故事点表示开发一个用户故事或特性的复杂度
D:故事点表示开发一个用户故事或特性所要付出的工作量
选D
一旦项目进行中,计划的方法是
A:计划不应该改变
B:随着项目的进展,需要计划和重新计划是正常的
C:计划只有在所有利益相关方完全同意的情况下才能改变
D:由于敏捷是增量式的,因此不需要计划
选B
下列关于敏捷方法的叙述中,错误的是()
A:与传统方法相比,敏捷方法比较适合需求变化大或者开发前期对需求不是很清晰的项目
B:敏捷方法尤其适合于开发团队比较庞大的项目
C:敏捷方法的思想是适应性,而不是预设性
D:敏捷方法以原型开发思想为基础,采用迭代式增量开发
选B
SCRUM中335分别指的是什么?
A:3个角色、3个工件、5个会议
B:3个会议、3个工件、5个角色
C:3个工件、3张图表、5个会议
D:3个成员、3个会议、5个工件
选A
计划的频度(   )
A:做很短的计划,很少超过一两周
B:做短期的迭代计划(1个月内)以及中长期的版本计划(几个月到1年),迭代计划比较细,版本计划只做概要计划
C:做长期计划,包括详细的任务和分工。后期可以根据实际进展修订
D:频繁的做及时性计划
选B
以下不是精益生产主要特征的是(  )
A:拉动式生产
B:推动式生产
C:最大限度的减少库存
D:实现准时化生产
选B
在第一个sprint中团队做什么
A:交付设计文档
B:预先决定完整的架构和基础设施
C:完成Sprint目标
D:为后续的Sprint制定计划
选C
为了良好沟通,敏捷项目应该……
A:保持团队规模较大,以避免利益相关者感到遗漏
B:将项目分解为小型,混合技能的自组织团队
C:与一个不到10人的团队合作
D:与独立的客户,开发人员和测试团队合作
选B
以下哪项最能描述确定迭代(时间箱)长度的方法?
A:迭代(时间箱)应该总是30天
B:团队通过将故事点的总数除以团队的平均速度来确定迭代(时间箱)的长度
C:迭代(时间箱)应该总是两周
D:考虑到项目的规模和复杂性,团队应该迭代的长度(计时器)达成一致
选D
SCRUM框架下,测试工作应该由谁来完成?
A:ScrumMaster
B:测试人员
C:开发人员
D:开发团队
选D
以下()不是SCRUM MASTER职责
A:保护团队不受外来无端影响
B:尽可能提高团队影响力
C:负责SCRUM价值观与过程的实现
D:SCRUM MASTER是牧羊犬、公仆
选B
瀑布模型是()
A:适用于需求被清晰定义的情况
B:一种需要快速构造可运行程序的好方法
C:一种不适用于商业产品的创新模型
D:目前业界最流行的过程模型
选A
在敏捷项目中应该如何将工作分配给团队?
A:团队负责人应该将具体任务分配给个人
B:任务应该随机分配给团队成员
C:团队成员应自行选择适合其技能的任务
D:最复杂的任务应由团队负责人完成
选C
产品负责人的最佳描述是?
A:阻止干系人干扰团队
B:指挥团队的日常工作
C:管理项目,确保工作成果能够兑现向干系人作出的承诺
D:优化工作成果的业务价值
选D
如果敏捷项目运行后出现新需求,应该是:
A:自动包含在项目的工作中
B:自动排除并保留至稍后的项目或增量
C:评估重要性,如果对业务来说足够重要,则包括在项目中,取代较不重要的要求
D:项目开发完成后,对照本轮的迭代任务,提交给项目干系人评审
选C
项目的特性清单(Product Backlog)最重要和必选的内容是(   )
A:每个特性的标题,优先级和估算
B:每个特性的标题,详细描述
C:每个特性的责任人和状态
D:以上都是
选A
敏捷宣言背后的原则对于架构的处理是如何建议的?
A:架构会浮现出来
B:架构不重要,但功能重要
C:架构是预先定义和计划的
D:架构的定义和实现在第一个迭代中完成
选A
SCRUM框架下,哪个角色对软件的交付负责?
A:ScrumMaster
B:部门经理
C:ProcuctOwner
D:团队
选D
———————
作者:可爱的小高高
来源:CSDN
版权声明:本文为博主原创文章,转载请附上博文链接!

Dunning kruger效应到底给了我们什么样的启示

生活中如果周围的人都不如自己,那么会很自然的将自己当做福尔摩斯般的存在。

这时候,很多人就会犯一些常识性的错误,比如本来可以游200米的冠军因为一直在和200米竞争,会惯性的认为各种游泳技巧都已经学会了,因而去尝试了一个也许正常人类无法超越的19英里个人游泳尝试,要知道超越英吉利海峡谈何容易?自然就会如图中那样了。但是是什么原因造成的会让我们莫名自大起来的呢?

正是由于我们超越或者高于身边人的时候,殊不知人外有人,用dunning kruger效应解释就是,你不知道你所不知。这种情况是最危险的

上图又是另一种情况了,我们很多的各行各业的知识工作者都会感悟到的,就是当你在通往一个学识高度的时候,不自觉的会产生过一段自大情节,只要你不停地学习读书,很快我们就会进入另一个情节,就是突然发现自己原来有那么多不知道的!有的人这时候就会开始气馁的,迷茫这个词是更多人的想法💡。

这时候,又会有一部分人开始思考,我到底知道些什么?比如首先认识自我,我到底需要什么?类似从哪里来,到哪里去的问题便油然而生。我们在这个阶段更多的应该是整理自己的知道,将自己所有知道的知识归类归档,这样你的知识逐步就成为了你的工具和武器了。我相信作为敏捷教练或者顾问,很多人都会有类似的经验吧。这会是一个持续的长期的过程,当我们逐步走向这个路径的时候,这条路径上的绝大部分人只要坚持,就在向着某一领域的专家在靠拢了。时间可长可短。但在这个阶段又很容易回到第一阶段,因为你可能只是超越了你的周围,这个周围半径也许就是你的格局限制。

最后总结一句,dunning kruger效应给我们的一个启示便是,至少我们可以清楚的认识,如果你并不是一个长期从事学术类工作的教职人员,大学教授等或者在某一领域工作经验非常丰富的专家,但却持有一种自己的学识天下第一或者自己经验十分丰富的时候,这便是一种值得警惕自己的一个信号,属于不自知范畴。

一言以蔽之,自知,而后觉知。

测试驱动开发TDD(转帖)

转帖来自:https://technologyconversations.com/2013/12/20/test-driven-development-tdd-example-walkthrough/

Test Driven Development (TDD): Example Walkthrough

medium_5927476303Test-driven development (TDD) is a software development process that relies on the repetition of a very short development cycle: first the developer writes an (initially failing) automated test case that defines a desired improvement or new function, then produces the minimum amount of code to pass that test, and finally refactors the new code to acceptable standards.

The following sequence of steps is generally followed:

  • Add a test
  • Run all tests and see if the new one fails
  • Write some code
  • Run tests
  • Refactor code
  • Repeat

There’s a plenty of articles written on TDD and Wikipedia is always a good start. This article will focus on the actual test and implementation using variation of one of the Roy Osherove Katas. Do not click the link until you’re finished with this article. This excercise is best done when not all requirements are known in advance.

Below you will find the test code related to each requirement and afterwards the actual implementation. Try to read only one requirement, write the tests and the implementation yourself and compare it with the results from this article. Remember that there are many different ways to write tests and implementation. This article is only one out of many possible solutions.

Let’s start!

Requirements

  • Create a simple String calculator with a method int Add(string numbers)
  • The method can take 0, 1 or 2 numbers, and will return their sum (for an empty string it will return 0) for example “” or “1” or “1,2”
  • Allow the Add method to handle an unknown amount of numbers
  • Allow the Add method to handle new lines between numbers (instead of commas).
  • The following input is ok: “1\n2,3” (will equal 6)
  • Support different delimiters
  • To change a delimiter, the beginning of the string will contain a separate line that looks like this: “//[delimiter]\n[numbers…]” for example “//;\n1;2” should return three where the default delimiter is ‘;’ .
  • The first line is optional. All existing scenarios should still be supported
  • Calling Add with a negative number will throw an exception “negatives not allowed” – and the negative that was passed. If there are multiple negatives, show all of them in the exception message stop here if you are a beginner.
  • Numbers bigger than 1000 should be ignored, so adding 2 + 1001 = 2
  • Delimiters can be of any length with the following format: “//[delimiter]\n” for example: “//[—]\n1—2—3” should return 6
  • Allow multiple delimiters like this: “//[delim1][delim2]\n” for example “//[-][%]\n1-2%3” should return 6.
  • Make sure you can also handle multiple delimiters with length longer than one char

Even though this is a very simple program, just looking at those requirements can be overwhelming. Let’s take a different approach. Forget what you just read and let us go through the requirements one by one.

Create a simple String calculator

Requirement 1: The method can take 0, 1 or 2 numbers separated by comma (,).

Let’s write our first set of tests.

[JAVA TEST]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.wordpress.technologyconversations.tddtest;
import org.junit.Test;
import com.wordpress.technologyconversations.tdd.StringCalculator;
public class StringCalculatorTest {
    @Test(expected = RuntimeException.class)
    public final void whenMoreThan2NumbersAreUsedThenExceptionIsThrown() {
        StringCalculator.add("1,2,3");
    }
    @Test
    public final void when2NumbersAreUsedThenNoExceptionIsThrown() {
        StringCalculator.add("1,2");
        Assert.assertTrue(true);
    }
    @Test(expected = RuntimeException.class)
    public final void whenNonNumberIsUsedThenExceptionIsThrown() {
        StringCalculator.add("1,X");
    }
}

It’s a good practice to name test methods in a way that it is easy to understand what is being tested. I prefer a variation of BDD with When [ACTION] Then [VERIFICATION]. In this case the name of one of the test methods is whenMoreThan2NumbersAreUsedThenExceptionIsThrown. Our first set of tests verifies that up to two numbers can be passed to the calculator’s add method. If there’s more than two or if one of them is not a number, exception should be thrown. Putting “expected” inside the @Test annotation tells the JUnit runner that the expected outcome is to throw the specified exception. From here on, for brevity reasons, only modified parts of the code will be displayed. Whole code divided into requirements can be obtained from the GitHub repository (tests and implementation).

[JAVA IMPLEMENTATION]

1
2
3
4
5
6
7
8
9
10
11
12
public class StringCalculator {
    public static final void add(final String numbers) {
        String[] numbersArray = numbers.split(",");
        if (numbersArray.length > 2) {
            throw new RuntimeException("Up to 2 numbers separated by comma (,) are allowed");
        } else {
            for (String number : numbersArray) {
                Integer.parseInt(number); // If it is not a number, parseInt will throw an exception
            }
        }
    }
}

Keep in mind that the idea behind TDD is to do the necessary minimum to make the tests pass and repeat the process until the whole functionality is implemented. At this moment we’re only interested in making sure that “the method can take 0, 1 or 2 numbers”. Run all the tests again and see them pass.

Requirement 2: For an empty string the method will return 0

[JAVA TEST]

1
2
3
4
@Test
public final void whenEmptyStringIsUsedThenReturnValueIs0() {
    Assert.assertEquals(0, StringCalculator.add(""));
}

[JAVA IMPLEMENTATION]

1
2
3
4
5
6
7
8
9
10
11
12
13
public static final int add(final String numbers) { // Changed void to int
    String[] numbersArray = numbers.split(",");
    if (numbersArray.length > 2) {
        throw new RuntimeException("Up to 2 numbers separated by comma (,) are allowed");
    } else {
        for (String number : numbersArray) {
            if (!number.isEmpty()) {
                Integer.parseInt(number);
            }
        }
    }
    return 0; // Added return
}

All there was to do to make this test pass was to change the return method from void to int and end it with returning zero.

Requirement 3: Method will return their sum of numbers

[JAVA TEST]

1
2
3
4
5
6
7
8
9
@Test
public final void whenOneNumberIsUsedThenReturnValueIsThatSameNumber() {
    Assert.assertEquals(3, StringCalculator.add("3"));
}
@Test
public final void whenTwoNumbersAreUsedThenReturnValueIsTheirSum() {
    Assert.assertEquals(3+6, StringCalculator.add("3,6"));
}

[JAVA IMPLEMENTATION]

1
2
3
4
5
6
7
8
9
10
11
12
13
public static int add(final String numbers) {
    int returnValue = 0;
    String[] numbersArray = numbers.split(",");
    if (numbersArray.length > 2) {
        throw new RuntimeException("Up to 2 numbers separated by comma (,) are allowed");
    }
    for (String number : numbersArray) {
        if (!number.trim().isEmpty()) { // After refactoring
            returnValue += Integer.parseInt(number);
        }
    }
    return returnValue;
}

Here we added iteration through all numbers to create a sum.

Requirement 4: Allow the Add method to handle an unknown amount of numbers

[JAVA TEST]

1
2
3
4
5
6
7
8
//  @Test(expected = RuntimeException.class)
//  public final void whenMoreThan2NumbersAreUsedThenExceptionIsThrown() {
//      StringCalculator.add("1,2,3");
//  }
    @Test
    public final void whenAnyNumberOfNumbersIsUsedThenReturnValuesAreTheirSums() {
        Assert.assertEquals(3+6+15+18+46+33, StringCalculator.add("3,6,15,18,46,33"));
    }

[JAVA IMPLEMENTATION]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static int add(final String numbers) {
    int returnValue = 0;
    String[] numbersArray = numbers.split(",");
    // Removed after exception
    // if (numbersArray.length > 2) {
    // throw new RuntimeException("Up to 2 numbers separated by comma (,) are allowed");
    // }
    for (String number : numbersArray) {
        if (!number.trim().isEmpty()) { // After refactoring
            returnValue += Integer.parseInt(number);
        }
    }
    return returnValue;
}

All we had to do to accomplish this requirement was to remove part of the code that throws an exception if there are more than 2 numbers. However, once tests are executed, the first test failed. In order to fulfill this requirement, the test whenMoreThan2NumbersAreUsedThenExceptionIsThrown needed to be removed.

Requirement 5: Allow the Add method to handle new lines between numbers (instead of commas).

[JAVA TEST]

1
2
3
4
@Test
public final void whenNewLineIsUsedBetweenNumbersThenReturnValuesAreTheirSums() {
    Assert.assertEquals(3+6+15, StringCalculator.add("3,6n15"));
}

[JAVA IMPLEMENTATION]

1
2
3
4
5
6
7
8
9
10
public static int add(final String numbers) {
    int returnValue = 0;
    String[] numbersArray = numbers.split(",|n"); // Added |n to the split regex
    for (String number : numbersArray) {
        if (!number.trim().isEmpty()) {
            returnValue += Integer.parseInt(number.trim());
        }
    }
    return returnValue;
}

All we had to do to was to extend the split regex by adding |\n.

Requirement 6: Support different delimiters

To change a delimiter, the beginning of the string will contain a separate line that looks like this: “//[delimiter]\n[numbers…]” for example “//;\n1;2” should take 1 and 2 as parameters and return 3 where the default delimiter is ‘;’ .

[JAVA TEST]

1
2
3
4
@Test
public final void whenDelimiterIsSpecifiedThenItIsUsedToSeparateNumbers() {
    Assert.assertEquals(3+6+15, StringCalculator.add("//;n3;6;15"));
}

[JAVA IMPLEMENTATION]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static int add(final String numbers) {
    String delimiter = ",|n";
    String numbersWithoutDelimiter = numbers;
    if (numbers.startsWith("//")) {
        int delimiterIndex = numbers.indexOf("//") + 2;
        delimiter = numbers.substring(delimiterIndex, delimiterIndex + 1);
        numbersWithoutDelimiter = numbers.substring(numbers.indexOf("n") + 1);
    }
    return add(numbersWithoutDelimiter, delimiter);
}
private static int add(final String numbers, final String delimiter) {
    int returnValue = 0;
    String[] numbersArray = numbers.split(delimiter);
    for (String number : numbersArray) {
        if (!number.trim().isEmpty()) {
            returnValue += Integer.parseInt(number.trim());
        }
    }
    return returnValue;
}

This time there was quite a lot of refactoring. We split the code into 2 methods. Initial method parses the input looking for the delimiter and later on calls the new one that does the actual sum. Since we already have tests that cover all existing functionality, it was safe to do the refactoring. If anything went wrong, one of the tests would find the problem.

Requirement 7: Negative numbers will throw an exception

Calling Add with a negative number will throw an exception “negatives not allowed” – and the negative that was passed. If there are multiple negatives, show all of them in the exception message.

[JAVA TEST]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test(expected = RuntimeException.class)
public final void whenNegativeNumberIsUsedThenRuntimeExceptionIsThrown() {
    StringCalculator.add("3,-6,15,18,46,33");
}
@Test
public final void whenNegativeNumbersAreUsedThenRuntimeExceptionIsThrown() {
    RuntimeException exception = null;
    try {
        StringCalculator.add("3,-6,15,-18,46,33");
    } catch (RuntimeException e) {
        exception = e;
    }
    Assert.assertNotNull(exception);
    Assert.assertEquals("Negatives not allowed: [-6, -18]", exception.getMessage());
}

There are two new tests. First one checks whether exception is thrown when there are negative numbers. The second one verifies whether the exception message is correct.

[JAVA IMPLEMENTATION]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private static int add(final String numbers, final String delimiter) {
    int returnValue = 0;
    String[] numbersArray = numbers.split(delimiter);
    List negativeNumbers = new ArrayList();
    for (String number : numbersArray) {
        if (!number.trim().isEmpty()) {
            int numberInt = Integer.parseInt(number.trim());
            if (numberInt < 0) {
                negativeNumbers.add(numberInt);
            }
            returnValue += numberInt;
        }
    }
    if (negativeNumbers.size() > 0) {
        throw new RuntimeException("Negatives not allowed: " + negativeNumbers.toString());
    }
    return returnValue;    
}

This time code was added that collects negative numbers in a List and throws an exception if there was any.

Requirement 8: Numbers bigger than 1000 should be ignored

Example: adding 2 + 1001 = 2

[JAVA TEST]

1
2
3
4
@Test
public final void whenOneOrMoreNumbersAreGreaterThan1000IsUsedThenItIsNotIncludedInSum() {
    Assert.assertEquals(3+1000+6, StringCalculator8.add("3,1000,1001,6,1234"));
}

[JAVA IMPLEMENTATION]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private static int add(final String numbers, final String delimiter) {
        int returnValue = 0;
        String[] numbersArray = numbers.split(delimiter);
        List negativeNumbers = new ArrayList();
        for (String number : numbersArray) {
                if (!number.trim().isEmpty()) {
                        int numberInt = Integer.parseInt(number.trim());
                        if (numberInt < 0) {
                                negativeNumbers.add(numberInt);
                        } else if (numberInt <= 1000) {
                                returnValue += numberInt;
                        }
                }
        }
        if (negativeNumbers.size() > 0) {
                throw new RuntimeException("Negatives not allowed: " + negativeNumbers.toString());
        }
        return returnValue;               
}

This one was simple. We moved “returnValue += numberInt;” inside an “else if (numberInt <= 1000)”.

There are 3 more requirements left. I encourage you to try them by yourself.

Requirement 9: Delimiters can be of any length

Following format should be used: “//[delimiter]\n”. Example: “//[—]\n1—2—3” should return 6

Requirement 10: Allow multiple delimiters

Following format should be used: “//[delim1][delim2]\n”. Example “//[-][%]\n1-2%3” should return 6.

Requirement 11: Make sure you can also handle multiple delimiters with length longer than one char

Give TDD a chance

This whole process often looks overwhelming to TDD beginners. One of the common complains is that TDD slows down the development process. It is true that at first it takes time to get into speed. However, after a bit of practice development using TDD process saves time, produces better design, allows easy and safe refactoring, increases quality and test coverage and, last but not least, makes sure that software is always tested. Another great benefit of TDD is that tests serve as a living documentation. It is enough to look at tests to know what each software unit should do. That documentation is always up to date as long as all tests are passing. Unit tests produced with TDD should provide “code coverage” for most of the code and they should be used together with Acceptance Test Driven Development (ATDD) or Behavior Driven Development (BDD). Together they are covering both unit and functional tests, serving as full documentation and requirements.

TDD makes you focus on your task, code exactly what you need, think from outside and, ultimately, a better programmer.

Test-Driven Java Development

7429OS_Test-Driven Java DevelopmentTest-Driven Java Development book wrote by Alex Garcia and me has been published by Packt Publishing. It was a long, demanding, but very rewarding journey that resulted in a very comprehensive hands-on material for all Java developers interested in learning or improving their TDD skills.

If you liked this article I am sure that you’ll find this book very useful. It contains extensive tutorials, guidelines and exercises for all Java developers eager to learn how to successfully apply TDD practices.

You can download a sample or purchase your own copy directly from Packt or Amazon.

photo credit: bałamut via photopin cc

版本控制之道

一说版本控制,就会思索着是不是来大谈svn git或者是branch model。
然而这些东西似乎已经被业界说烂了。网上几乎随处可见这些如何切分支的文章。而我们通常忽略的是为什么这么做,以及如何在一定的原则下去做,从而最大化的获得配置上和执行上的自由度。
现在社会,再谈版本就不再是过去我们从开发的角度来谈的版本了。而是说,这个软件产品对于用户来说的版本。过去我们会说这个产品在alpha或者beta,上线以后叫大版本就是几代几代之类的,小版本就是大版本的补丁了,会有固定的小版本号。
这些再对应入我们产品开发团队所对应的大小版本的发布周期以及发布计划。
为此我们给出一部分执行管理的原则,来帮助最大化减小发布错误的损失和风险。
  1. 大版本号,一定来自于产品团队对于商业发布的明确定义,需要定义清楚为什么那天发布,发布内容有什么商业意义。测试和开发团队需要商量此次的发布需要的测试以及质量指标。产品以及市场也要为此定义明确的验收指标。例如,产品的上线前必须完成80-90%的单元测试条件覆盖率。不允许有超过10个的critical缺陷。开发对于代码质量在交付给产品验收之前,需要完成代码扫描,不得超过多大的threshold就是门槛阈值。
  2. 小版本号,理论上说,开发提交的每一个变更号对应的就是一个明确的版本编号。这个版本编号就是我们的小版本号。也需要明确的需求说明,改动影响说明。
  3. 小版本号还可以细分,哪些是专门针对新需求的,哪些是专门针对线上紧急修复的,还有一部分是内部重构更新的。这些都要能有有全面的体现。
当理解这些基本客户诉求产生的原则后,我们需要考虑的就是如何给与足够的控制。通常这些我们是习惯于交给集成或者发布的专员进行的,但是过去这么做就无形中加大了许多集成和发布专员的劳动力,导致他们做了许多重复无用的劳动。为了减少这些无用的劳动,我们需要做如下调整
  1. 需求的提交由开发者自行维护自己需求的分支
  2. 缺陷的修复由集成或测试统一开具分支,当结束一个修复周期后进行合并。
  3. 大版本的上线由集成开具分支,并在对应的确切日期时间点进行切分支操作
  4. 所有分支在合并时,必须提交pull request指令等待专人审核后方可合并
  5. 缺陷,需求,重构等分支都要有明确的编号,便于快速识别。例如,缺陷修复版本bugfix,需求版本req,重构版本refactor等等。可以在具体的commit消息中严格规定。
  6. 内部发布给具体的测试服务器需要有明确的服务器发布版本的管理列表,例如,测试机01,目前版本bugfix009,测试预生产机01,目前版本req010。这样测试或者产品人员在验收时可以明确知道自己要测试的机器是否有自己所需要的版本的产品被部署了。
  7. 软件产品也应该在特定位置有明确标注当前最新的版本号。例如,大版本号,001,小版本号,req001。这样,万一我们没有及时找到版本列表,也可以最快的通过软件本身发现版本号。
如何执行,这个环节我们都知道知易行难。无数人无数组织倒在了开始行进的道路口,因为无从下手。我们的建议是
  • 明确哪些人,对哪些版本负责
  • 明确哪些版本需要做什么级别的测试
  • 明确发布各类不同需要的版本,大致的周期
  • 版本号规则的命名
  • 定义并且阶段调整版本计划。周知计划。
  • 建立版本的持续集成机制
  • 所有发布的历史需要有罗列

空谈用户体验设计方法论

本文定位就是空谈,因为用户体验设计是需要参与和共创的。而不是纸上谈兵,今天由于场地有限(根本就没场地),我也就只能在公众号来发表一下了。
首先我们需要理清楚我们整个系统与系统之间的用户体验旅程Customer Journey,目的是为了搞清用户们在这些系统中,最痛苦的部分在哪里
我们可以让用户代表用贴小纸条的方式将自己在这些用户体验旅程Customer Journey环节中的痛点描述出来,并按照一个给定的定级标准来量化这种痛苦的级别
然后让大家将写好的小纸条全部贴在对应的用户体验旅程Customer Journey中。大家一起来梳理一下,看看到底问题最大的环节是哪里,也就是告诉大家,哪里是最值得做用户体验改进的。因为用户体验并不是用来生搬硬套的。而是需要有明确的目的性才去探索的动作。
参看以下的Customer Journey
当锁定了之后,我们需要将定位分类的这些问题聚拢,大家可以采用投票的方式来定位,本次改进准备在哪里下手。
那么当锁定了之后,就开始放大定位的位置了。也就是具体的某一个子系统或者模块(总之一定在用户旅程中的一个环节)。
在这里,我们提前打开一个design thinking的流程,我们先要知道,面对这个具体的问题,我们应该以什么思路来解决目前的痛点。
我们首先具有同理心,理解为什么系统成为了现在这样的设计,是因为技术原因吗?还是因为当时的特殊情况,还是因为某些特殊业务需要造成这样的。我们由此来定位这个问题。接下来就是需要发散性探索型的思考了,让所有用户一起思考我们应该如何解决这个问题,先抛开解题思路,我们从用户根本诉求着手,让大家写出你最希望如何来操作或者系统应该如何运行,就可以解决目前的问题了。
这里推荐一个小方法,叫Crazy8,或者六顶思考帽
在此仅先推荐Crazy8
见Crazy8下图
每个人发散性思考,在8个格子内画出你所认为最棒的草图,来解决这个问题。
又是一轮思考和投票之后,我们来选出谁才是最佳方案。针对这个方案,我们按照design thinking的流程进行下一步动作,原型定义prototyping。
参与人员可以有用户,设计师,程序员一起来定义如何来做到这个最佳的方案。让大家一起讨论,画出草图,从草稿,到架构设计,到数据模型
接下来就是最重要的了,我们想要验证这么设计真的能够解决了这个问题。
方法就是,我们沿着customer journey,一条一条的给出验证的场景,用场景来验证现在提出的原型是正确的,我们再次让用户从场景开始,架构,技术,设计从验证的角度来思考,能不能承受用户提出的场景的考验。并且最终记录下,哪些可以做到哪些是一个需要调研的spike或者是不得不用绕道workaround的
最后我们需要收拾好今天一天的收获,回去准备implement了。
我们需要沉淀的是
  1. customer journey map
    • 客户旅程的路线图
    • 对于每个环节的痛点位置的定义,量化痛点
    • 每个路线环节的感受(易用,不舒适等等)
  2. 待办事项
    • 原型方案
    • 原型验证的场景
    • 原型验证后所产生的问题
  3. 回顾会
没错,最后我们需要做一个回顾会。总结今天收获了些什么。
沉淀后的思考 
用户体验设计与敏捷的融合

非常有用的转载:开发者容易陷入的 50 大误区!

我们总是在不断地犯错,然后从错误中学习。本文将帮助你梳理和反思软件开发领域的各种固有观点。因为有很多观点是错误的,或者存在误区的。

640?wx_fmt=jpeg&wxfrom=5&wx_lazy=1

接下来,将列举 50 个软件开发领域最常见的误区:

  1. 编写单元测试 = 测试驱动开发;
  2. 提供100%测试覆盖率报告 = 代码工作做得很好;
  3. 通过中央机器来构建和部署项目 = 持续集成;
  4. 每个开发人员通过远程将代码 check in 到中央仓库库分支中,该分支之后会合并到主分支 = 持续集成;
  5. 花更多时间编码 = 承诺;
  6. 写了很多代码的人 = 极客;
  7. 团队中被大家依赖的开发者 = 明星开发者;
  8. CTO 和架构师不会写代码;
  9. 承诺 = 估算;
  10. CTO 只负责管理开发团队,不需要理解业务;
  11. 大而全的产品 = 理所当然会成功;
  12. 想法很难得而且很珍贵,执行力则不值钱;
  13. 开发人员不需要了解业务领域,业务分析师和产品经理才应该了解业务;
  14. 开发人员很便宜,想换就换;
  15. MVP = 精益创业;
  16. 小而美的明星产品都源自精益创业;
  17. 初创公司不会做 TDD,因为他们没有时间;
  18. 大企业也不会做 TDD,因为他们雇用的开发人员都异常聪明,不需要 TDD;
  19. 初创公司希望雇用的开发人员自带销售潜能,并且没有给予员工足够的股权或工资;
  20. 企业希望凭借自己的品牌聘请优秀的开发人员;
  21. 不成熟的文化 = 开放的文化;
  22. 缩减组织层次中的级别 = 扁平化管理;
  23. 能够推测用户需求并向产品添加功能 = 产品管理;
  24. MBA 毕业生才能成为产品经理;
  25. 功能丰富 = UX 丰富;
  26. 销售产品并不难;
  27. 一款成功的产品主要原因是功能和性能,与设计无关;
  28. 代码性能比可读性更重要;
  29. 代码简洁比容易维护更重要;
  30. 产品经理 > BA > 开发人员 > UX 专家 > QA;
  31. 任务就是敏捷中的用户故事;
  32. 将故事点添加到 bug 中 = 改进速度;
  33. SAFe 是最安全的敏捷;
  34. 速度提高 = 灵敏度提高;
  35. TDD 纯粹是浪费时间,只有平庸的开发者会去用;
  36. 平庸的开发人员才需要结对编程;
  37. 拥有敏捷证书 = 敏捷专家;
  38. SAFe 是可扩展的敏捷;
  39. 推测最终用户需求 = 业务分析;
  40. 使用框架和编程语言能够解决可扩展性问题;
  41. 云 = 可扩展性;
  42. 机器学习只需熟悉算法,不需要业务领域知识;
  43. 分析与业务领域无关;
  44. 敏捷教练的优势在于他知道如何使用 Jira 等工具;
  45. 软件工艺就是使用 Jenkins、SonarQube 等工具;
  46. DevOps 团队也就是基础设施管理团队;
  47. 敏捷是管理开发人员的新方式;
  48. UX 和 UI 没区别;
  49. 全栈开发者 = 前端开发人员+后端开发人员+基础架构开发人员;
  50. 产品经理就是项目经理。

原文:https://hackernoon.com/50-common-misconceptions-in-the-world-of-software-development-7144566c54f9

作者:Karthik Sirasanagandla

译者:安翔,编辑:言则

浅谈约束理论

先从下定义来谈什么是约束理论,
约束理论(Theory of Constraints, TOC)是以色列物理学家、企业管理顾问戈德拉特博士(Dr.Eliyahu M.Goldratt)在他开创的优化生产技术(Optimized Production Technology,OPT)基础上发展起来的管理哲理,该理论提出了在制造业经营生产活动中定义和消除制约因素的一些规范化方法,以支持连续改进(Continuous Improvement)。
同时TOC也是对MRPIIJIT在观念和方法上的发展。
戈德拉特创立约束理论的目的是想找出各种条件下生产的内在规律,寻求一种分析经营生产问题的科学逻辑思维方式和解决问题的有效方法。可用一句话来表达TOC,即找出妨碍实现系统目标的约束条件,并对它进行消除的系统改善方法。
所以细心的读者乍一看似乎这个理论同木桶理论有许多相似的地方,都是寻找短板。
TOC强调必须把企业看成是一个系统,从整体效益出发来考虑和处理问题,TOC的基本要点如下:
  1.企业是一个系统,其目标应当十分明确,那就是在当前和今后为企业获得更多的利润
  2.一切妨碍企业实现整体目标的因素都是约束
  按照意大利经济学家帕拉图的原理,对系统有重大影响的往往是少数几个约束,为数不多,但至少有一个。约束有各种类型,不仅有物质型的,如市场、物料、能力、资金等,而且还有非物质型的,如后勤及质量保证体系企业文化管理体制、规章制度、员工行为规范工作态度等等,以上这些,也可称为策略性约束。
  3.为了衡量实现目标的业绩和效果,TOC打破传统的会计成本概念,提出了三项主要衡量指标,即有效产出、库存和运行费用。TOC认为只能从企业的整体来评价改进的效果,而不能只看局部。库存投资和运行费用虽然可以降低,但是不能降到零以下,只有有效产出才有可能不断增长(见下表)。
  
  TOC把主生产计划(MPS)比喻成”鼓”,根据瓶颈资源能力约束资源(Capacity Constraint Resources,CCR)的可用能力来确定企业的最大物流量,作为约束全局的”鼓点”,鼓点相当于指挥生产的节拍;在所有瓶颈和总装工序前要保留物料储备缓冲,以保证充分利用瓶颈资源,实现最大的有效产出。必须按照瓶颈工序的物流量来控制瓶颈工序前道工序的物料投放量。换句话说,头道工序和其它需要控制的工作中心如同用一根传递信息的绳子牵住的队伍,按同一节拍,控制在制品流量,以保持在均衡的物料流动条件下进行生产。瓶颈工序前的非制约工序可以用倒排计划,瓶颈工序用顺排计划,后续工序按瓶颈工序的节拍组织生产。
  5.定义和处理约束的决策方法
  TOC强调了三种方法,统称为思维过程(Thinking Processes,TP),见下表:
  
  应用TOC获得成功的企业很多,如美国得克萨斯食品公司深感缩短提前期在竞争上的必要性,从1992年就开始进行了TOC改善活动。它先以福特公司的电子事业部为样板引进了TOC,结果省去了为增产所需的数亿美元的投资。半导体乌耶哈工厂也引进了TOC,提前期在1年半内减少了75%,生产能力在同样的设备条件下提高了25%。
一切理论也有其原则
TOC的五层次结构
1.理论核心层
其包含TOC理论有关企业的目标、衡量标准、“约束”概念、管理原则等。
2.管理技术层
TOC不但继承了早期的生产计划系统,并应用于生产制造行业,从而发展形成了一套思维流程(ThinkingProcess,简称TP),能够广泛地应用于组织、企业乃至个人,以有效地识别和消除实现目标过程中的“约束”。这套流程按照一定的逻辑顺序,系统地回答了以下三个问题:改进什么?改成什么样子?怎样使改进得以实现?
3.基础工具层
TOC十分注重顺利开展日常管理工作,把其当做成功消除“约束”的前提条件和基础工作。基于这点,TOC与诸多管理理论思想相互支撑,相互融合,如经典管理理论所提及的管理方法:如何有效地沟通、如何双赢地解决冲突、如何搞好团队协作、如何持续改进等。
4.应用实践层
TOC理论在很多企业中广泛地应用,通过具体实际应用,总结出了各自应用领域的具有创新性的实证方案。这些领域涉及企业战略方向的设定、生产、分销、营销和销售、项目管理等各方面。
5.支撑环境层
以TOC理论为管理思想内涵的管理软件己经在西方国家得到较广泛的应用。软件、硬件、业务数据与企业管理人员的经验相结合,成为TOC管理思想得以落实的支撑环境。
TOC的九条生产作业计划制定原则:
  1. 不要平衡生产能力,而要平衡物流
  2. 非瓶颈资源的利用水平不是由自身潜力所决定,而是由系统的约束来决定
  3. 资源的利用与活力不是一码事
  4. 瓶颈损失1小时,相当于整个系统损失1小时
  5. 非瓶颈上节约开1小时,无实际意义
  6. 瓶颈制约了系统的产销率和库存
  7. 转运批量可以不等于1,而且在大多数情况下不应该等于加工批量
  8. 加工批量不是固定的,应该是随时间而变化
  9. 优先权只能根据系统的约束来设定,提前期是作业计划的结果(不是预先设定的)
TOC有一套思考的方法和持续改善的程序,称为五大核心步骤(Five Focusing Steps),这五大核心步骤是:
  第一步,找出系统中存在哪些约束。
  第二步,寻找突破(Exploit)这些约束的办法。
  第三步,使企业的所有其他活动服从于第二步中提出的各种措施。
  第四步,具体实施第二步中提出的措施,使第一步中找出的约束环节不再是企业的约束。
  第五步,回到步骤1,别让惰性成为约束,持续不断地改善。
 
最重要的就是如何运用,毕竟以上这些都是摘自MBA智库
我们刚刚提到五大核心步骤,我们用最简介的方式再来梳理总结一下。
这五步骤的思维流程可以通过三个必须问题的提问,帮助改进者以严格的因果逻辑和系统的观点看待存在的问题,这三个问题是:
(1)改进什么?
(2)改成什么样子?
 (3)怎样使改进得以实现?
首先应为:“找出系统中存在的约束。”因为五大步骤大部分应用在如下情况:约束并非来自一个具体的资源实体,所以无法得知哪些是约束。所以,要实现了解系统的现状。=
其次便是“改成什么样子”的问题。回答上述问题应遵循以下两步:
    第一找出克服当前约束的突破;
    第二,确保解决方案所实施的结果不会乱上添乱。
最后就是将那些计划转变为所需的行动方案。能动的“思维过程”就是要把那些受转变最大的人包括在内,企业需要主动去采集他们的意见,了解他们阻碍企业推进相关改进过程的根本原因。需要工人集思广益,保证实施能够顺利进行。

持续交付是什么,是种什么能力

理解
用我们如今的白话来描述最简单的就是,你提交一行修改某个bug的代码,发布系统会按照流程自动化的做完一系列的检查,然后发布一个版本到生产环境。这样用户在最短的时间内可以拿到修改的结果。
引用CI CD
这里有一些比较详尽的解释。
大概的意思就是从deploy到release之间的频繁部署交付的能力。
再次理解
敏捷只是一切的最自然的前提,然后是持续集成,伴随着持续测试,最后才是持续的交付。
所有的一切都是为了建立快速的持续反馈机制。这样市场或者用户可以更快速的给予反馈,开发和运维才可以快速的知道对在哪里和错在哪里。
如何应用
敏捷的形自然是很容易建立的,3-3-5-5。角色有了,体系有了,组织结构也有了。需要组织的支持自然有了一半。另一半就需要一整套体系的构建了。
最容易最快的,就是架设一套持续集成工具。加入单元测试,代码检查工具,引入Git分布式管理,建立pipeline的发布体系。
然后是持续测试,要达到持续测试,首先要做到有测试。我们刚才讲到了有单元测试,那么如果我们的单元测试可以做到TDD甚至是BDD,那么我们就越来越与用户及市场衔接起来了。也可以更有效的UAT抽样,而不是过去常常费时费力做的全量UAT。当然了,成型的测试策略也是必不可少的。甚至很多时候,测试策略是项目开始时候就需要的内容。有的成熟的团队,就可以在此加入自动化测试,识别自动化测试的用例。
最后就是持续交付了。需要持续交付,我们很多时候就需要依赖并且借助于云平台了。于是各大厂商都会推陈出新自己的云平台。IaaS和PaaS也是目前炒作的很热门的主题。开发和运维就可以更放心的将精力集中在横切面的监控和报表上了。从而把过去繁杂的设备运维交给云平台进行托管。也有的人习惯于在云平台之后再包装一层自己的平台,这个很多现在的互联网厂商也喜欢这么做。那么这个就是现今最热门的DevOps的SaaS平台了。集成了软件需求和快速交付的技术以及平台于一身。
总结
好了,这么些只言片语也只是点皮毛。但是希望各位能就此了结持续交付是什么,并且如何在现实世界运用的。每家公司最后的手段和策略都会有些差异。没有所谓的统一的做法。也是正是现今devops和敏捷最有魅力的部分。

些许的感悟

每个人的人生都在经历一次长跑,有的人喜欢在跑道里,而有的人喜欢在跑道以外。

有些人提早的看到了终点,有些人一个劲的在跑,从来没关注过终点在哪里。

跑多了,会累。跑方向错了,就需要折返跑。有些人从来没有迷失过,而有些人一直在迷失。

何为发布计划

发布计划是什么

In agile software development, a release plan is an evolving flowchart that describes which features will be delivered in upcoming releases. Each story in a release plan has a rough size estimate associated with it.
根据以上的描述,用我们大白话来说就是,发布计划是告诉我们哪个特性具体在哪次release会发布。
敏捷又是一个如此强调节奏感的方法体系,那么发布计划自然也是具有超强节奏感的,有的公司会按照2-3个sprint发布一次。也有的会每个sprint都发布一次。那么根据这样的节奏,我们就需要推算我们大概在第几个release可以发布我们需要的特性了。

具体怎么来计划呢?

其实没那么复杂,计划方法就是考虑几个项目管理的基本特性,时间,成本,功能性以及最重要的是质量。例如:限定的时间,可变的成本,我们如何安排最需要的功能上线?这只是一个例子,但是这样就需要我们的PO们用自己的方法进行调整,逐步的排出一份自己的计划。那么敏捷中又是强调release planning的,自然意味着我们的计划是可以动态的去调整的。

如何调整呢?

在面对多团队的时候,我们就更需要这份计划帮助建立一份团队间的alignment(一致性)。通过scrum of scrums的时候,大家来一起调整相应的计划。保证一份公开透明的计划可以公布给所有人。知道我们是朝着这个目标而去的。只有一起调整各自的计划,才能完成一个更大的路线图(产品路线图 product roadmap)

发布计划例子:

总结,

发布计划告诉我们,敏捷是通过短迭代不断的调整着自己的计划的,但是并不是说敏捷就没有计划了。发布计划正是一份可以取代过去甘特图的动态计划,并且让多团队各自快速达成一致性。