Requirement Specification vs User Stories

Continuous Delivery
10 Aug 202217:34

Summary

TLDRDave Farley 在视频中探讨了软件开发中常见的问题,包括过度依赖手动测试和错误的需求获取。他强调了清晰定义软件需求的重要性,并解释了用户故事与需求之间的关系。Farley 认为,用户故事是一种有效的方法,可以帮助团队从模糊的愿望转变为具体的计算机程序。他建议开发团队应该拥有责任,不仅要关注技术细节,还要理解并引导产品开发的方向。此外,他还讨论了如何正确地使用用户故事来避免技术细节,从而更好地满足用户需求并提高软件开发效率。

Takeaways

  • 🔍 软件开发中最常见的问题是过度依赖手动测试和需求定义错误。
  • 📝 需求定义错误是软件开发中问题频发的主要原因之一,需要通过有效沟通来明确软件要实现的功能。
  • 👥 大多数团队采用敏捷方法,通过用户故事来定义需求,但用户故事与需求并不等同,而是需求定义方式不当。
  • 📚 IEEE定义需求为用户解决问题或实现目标所需的条件或能力,这与常见的实施导向的需求描述不符。
  • 🛠️ 开发团队不应期望产品所有者或用户能精确定义需求,因为需求本质上是猜测,需要通过开发过程来明确。
  • 💡 优秀的开发团队不仅负责技术细节,还应负责产品的开发方向,基于对问题的理解来引导产品发展。
  • 🤔 用户或产品所有者通常只知道他们想要的大致方向,而不是具体需求,需求过程的目的是将这些模糊的愿望转化为计算机可执行的描述。
  • 📈 将需求过程分为两个独立步骤:明确用户想要什么(需求),以及如何实现(解决方案)。
  • 📘 用户故事是有效定义需求的方法,其真正价值在于帮助我们关注用户的目标,而不是系统的具体实现。
  • 🏄‍♂️ 以用户的角度思考,可以发现用户的真实需求和问题,从而设计出更好的软件解决方案。
  • 📖 用户故事应该描述用户的目标和系统在不同情况下的行为,而不是具体的用户界面或技术实现。
  • 🔑 用户故事的目的是使用户、开发人员和其他利益相关者能够用共同的语言讨论软件的目标和功能。
  • 📝 良好的用户故事应该是高层次的,足够精确以捕捉目标,同时足够模糊以允许多种实现方式。

Q & A

  • 软件开发中常见的两个问题是什么?

    -软件开发中常见的两个问题是过度依赖手动测试和最初就错误地获取需求。

  • 为什么需求获取会成为一个棘手的问题?

    -需求获取成为一个棘手的问题,因为很多团队对需求的理解是错误的,他们将需求视为复杂、以实现为中心的系统描述,而不是用户需要解决的问题或实现目标的条件或能力。

  • IEEE对需求的定义是什么?

    -IEEE定义需求为用户为解决一个问题或实现一个目标所需要的条件或能力。

  • 为什么说许多团队没有真正的需求?

    -许多团队没有真正的需求,因为他们没有将需求传达给开发团队,而是提供了实际上是解决方案的高级描述。

  • 开发团队在需求误解中扮演了什么角色?

    -开发团队在需求误解中常常是共犯,他们有时会拒绝接受工作,除非需求被更精确地指定,这通常发生在初级团队或官僚组织中。

  • 软件开发的真正任务是什么?

    -软件开发的真正任务是将模糊的愿望转化为足够具体的描述,使其能够在计算机上执行。

  • 为什么说用户故事是解决需求问题的有效方式?

    -用户故事是解决需求问题的有效方式,因为它们帮助团队专注于用户想要什么,而不是系统如何工作,从而允许团队在找到更好的方法或用户不喜欢早期尝试时尝试不同的解决方案。

  • 如何理解用户故事的真正价值?

    -用户故事的真正价值在于它们迫使我们从用户的角度思考,关注用户的目标,并使用用户的语言来捕捉这些目标,从而使非技术团队成员能够更清楚地了解每个故事的含义。

  • 为什么说用户故事应该避免包含技术规格?

    -用户故事应该避免包含技术规格,因为它们应该描述用户想要软件做什么,而不是系统如何实现它。这样可以保持故事的通用性和灵活性,允许开发团队选择最合适的解决方案。

  • 如何测试一个用户故事是否写得好?

    -要测试一个用户故事是否写得好,可以想象一个完全不同的系统提供相同的客户成果,如果故事仍然有意义,那么它就是一个好故事。

  • 用户故事的目的是是什么?

    -用户故事的目的是故意保持高层次,准确捕捉目标,同时足够模糊,以允许多种不同的实现方式。

Outlines

00:00

😀 软件开发常见问题及用户故事的重要性

Dave Farley在视频中讨论了软件开发中常见的两个问题:过度依赖手动测试和需求错误。他强调了需求文档的重要性,并指出许多团队对需求的理解存在误区,将其视为具体的解决方案而非用户解决问题的条件或能力。Dave提出,需求应简洁明了,指导软件开发,而非详细描述系统如何工作。他还提到,开发团队往往参与到这种错误的思维方式中,他们要求需求被精确定义,这在初级团队或官僚组织中尤为常见。Dave认为,软件开发的本质是将模糊的愿望转化为计算机可执行的描述,而优秀的开发团队应该承担起产品开发的责任,而不是仅仅依赖于产品所有者或用户的精确指导。

05:01

🤔 用户故事与需求分离的重要性

Dave Farley在本段中继续探讨了用户故事的价值,他认为用户故事是将需求从解决方案中分离出来的有效方法。他强调,需求过程的目的是将模糊的愿望转化为计算机上可行的解决方案,但这需要分两步进行:首先明确用户想要什么,然后探索解决问题的不同方案。Dave指出,将需求固定在解决方案上是一个糟糕的主意,因为这限制了开发团队的灵活性和创新能力。他通过一个科学仪器的案例说明了如何从用户的角度思考问题,并提出了改善用户体验的设计思路。Dave认为,用户故事应该关注用户的目标,而不是用户界面或技术细节,这样可以帮助团队更好地理解问题并设计出更符合用户需求的系统。

10:01

🏄‍♂️ 从用户角度出发设计软件

Dave Farley通过一个科学仪器的案例,展示了如何从用户的角度出发来设计软件。他提出了一个假设,即用户在使用该仪器时,他们的目标是完成工作,而不是进行长时间的校准过程。Dave建议,如果从用户的需求出发,可能会发现校准时间过长的问题,并思考如何缩短这个过程。他还提出了一些用户故事,如用户在开始校准后去冲浪,但回来后发现校准失败,这启示开发团队需要提供反馈机制,让用户知道校准已经开始,并在失败时及时通知用户。Dave强调,用户故事应该描述用户的目标和他们需要知道的信息,而不是系统的具体工作方式。通过这种方式,可以激发开发团队思考问题和解决方案,从而设计出更好的软件。

15:03

📚 用户故事的撰写与价值

在视频的最后部分,Dave Farley讨论了如何撰写有效的用户故事,并强调了它们在软件开发中的价值。他认为,用户故事应该简洁、以用户为中心,并且避免包含任何技术细节。Dave提供了一些撰写用户故事的指导原则,比如使用非技术性的语言,确保故事在不同系统下仍然有意义,以及测试故事是否能够被非技术团队成员理解。他还指出,好的用户故事应该是高层次的,足够准确以捕捉目标,同时又足够模糊以允许多种实现方式。Dave总结说,通过关注用户想要的结果,并使用他们的语言来捕捉这些结果,可以提高项目的清晰度,并帮助团队成员更有效地沟通和协作。

Mindmap

Keywords

💡软件测试

软件测试是软件开发过程中的一个重要环节,它用于验证软件是否满足特定的需求并且能够正常运行。在视频中,提到过度依赖手动测试是软件开发中出现问题的一个常见原因,因为它可能导致测试不充分和效率低下。

💡需求错误

需求错误指的是在软件开发过程中对用户需求理解的偏差或错误。视频中强调,需求错误是软件开发中问题频发的另一个主要原因,正确的需求管理对于避免这些问题至关重要。

💡用户故事

用户故事是一种敏捷开发中用来描述用户需求的简短文本模板。视频中提到,用户故事经常被误用,其实它们是需求的一种形式,并且是引导开发团队理解用户需求的有效工具。

💡可执行规范

可执行规范是指可以自动验证的软件需求描述,它允许开发团队通过自动化测试来确保软件满足这些需求。视频中提到,通过用户故事可以帮助团队向可执行规范迈出下一步。

💡敏捷方法

敏捷方法是一种迭代和增量的软件开发方法论,它强调适应性、协作和快速响应变化。视频中提到,大多数团队认为自己正在应用敏捷方法,并且在定义需求时使用用户故事。

💡需求重定义

需求重定义是指重新思考和定义软件需求的过程,以更准确地反映用户的实际需要。视频中指出,许多团队对需求的处理方式是错误的,导致了需求的重定义,这与IEEE对需求的定义相悖。

💡技术团队的责任

技术团队的责任不仅仅是实现功能,还包括对产品的所有权和方向的引导。视频中强调,优秀的开发团队应该承担起从理解问题到指导产品开发的责任。

💡用户视角

用户视角是指从用户的角度出发来考虑问题和设计解决方案。视频中通过一个科学仪器的例子说明了从用户视角出发可以带来更好的设计和用户体验。

💡需求与解决方案的分离

需求与解决方案的分离是指在软件开发过程中明确区分用户需要软件做什么(需求)和软件如何做(解决方案)。视频中提到,将这两者分离可以提高软件的灵活性和适应性。

💡用户故事的价值

用户故事的价值在于它们能够帮助团队集中关注用户的需求,而不是过早地陷入具体的实现细节。视频中解释了用户故事如何作为一种有效的手段来固定问题,而不是解决方案。

💡用户故事的字面意义

用户故事的字面意义是指用户故事应该像讲述一个真实的故事一样,有角色、背景、情节和结局。视频中强调,用户故事应该用来描述用户的目标和需求,而不是系统的具体工作方式。

💡技术规格

技术规格是指详细描述软件系统应该如何工作的文档,通常包括数据库、输入字段或用户界面等技术细节。视频中提到,好的用户故事不应该包含技术规格,以避免限制解决方案的可能性。

Highlights

软件开发中最常见的两个问题是过度依赖手动测试和初始需求错误。

需求问题之所以棘手,以及如何修复它们,用户故事究竟是什么。

大多数团队采用敏捷方法,用用户故事来定义需求。

用户故事实际上就是需求,但许多团队对需求的处理方式是错误的。

软件中对需求的常见理解与IEEE定义的需求相悖。

需求应是用户解决问题或实现目标所需的条件或能力。

开发团队常常与产品所有者一样,对需求的错误理解负有责任。

软件开发的本质是将模糊的愿望转化为计算机可以执行的具体描述。

优秀的开发团队不仅负责技术细节,也负责他们构建的产品。

用户故事的目的是开始将模糊的愿望转化为计算机上可行的解决方案。

需求过程的职责是帮助我们清晰地理解用户想要什么。

用户故事是有效的方法来解决固定需求与解决方案的问题。

用户故事的真正价值在于它们迫使我们分离关于“什么”和“如何”的思考。

用户故事应关注用户目标,而非用户界面或技术实现细节。

用户故事帮助我们从用户的角度思考,从而得出更好的设计。

用户故事应描述用户可见的结果,帮助我们集中精力在真正的目标上。

用户故事应使用非技术性语言,以便所有相关方都能理解。

优秀的用户故事足够精确以捕捉目标,足够模糊以允许多种实现方式。

Transcripts

play00:00

i am often asked to advise companies on

play00:02

how to do a better job of software

play00:04

development there are obviously lots of

play00:06

things that can go wrong with something

play00:07

as complicated as software development

play00:10

but the two commonest causes of problems

play00:12

that i see are an over reliance on

play00:14

manual testing and the topic of today's

play00:17

episode getting the requirements wrong

play00:19

in the first place

play00:20

so why are the requirements so

play00:22

problematic and what can we do to fix

play00:25

them and what is the points of user

play00:27

stories anyway

play00:32

[Music]

play00:37

hi i'm dave farley of continuous

play00:38

delivery welcome to my channel if you

play00:40

haven't been here before please do hit

play00:42

subscribe and if you enjoy the content

play00:44

today hit like as well

play00:47

i'd like to begin by thanking our

play00:48

sponsors equal experts octopus trycentis

play00:53

and transfik they've been supporting our

play00:55

channel for a while so please do support

play00:57

them in turn by checking out their links

play00:58

in the description below

play01:01

if you'd like to learn more about user

play01:03

stories and how they can help you to

play01:05

take the next step to executable

play01:07

specifications i've got a new training

play01:09

course coming out soon check out the

play01:12

links below for more details and while

play01:14

you're there also check out our great

play01:16

summer sale on our current course lineup

play01:20

software development is structured

play01:22

around three activities deciding on what

play01:24

we want building it and verifying that

play01:27

what we build does what we want

play01:29

to do a good job of all of these things

play01:31

then it's important to get a good start

play01:34

by communicating effectively what it is

play01:36

that we want our software to do this

play01:38

shapes everything else that we do really

play01:41

if we get this wrong it can make it

play01:43

difficult or even impossible to do a

play01:45

good job

play01:46

i think that most teams that build

play01:48

software these days would think of

play01:50

themselves as applying an agile approach

play01:52

and so nearly everyone talks about

play01:54

defining requirements in terms of user

play01:57

stories

play01:58

some people argue that user stories

play02:00

aren't the same thing as requirements i

play02:02

confess that i've said stuff like this

play02:04

myself in the past

play02:06

but actually i think that i was and they

play02:09

are mistaken

play02:10

it's not that user stories aren't

play02:13

requirements but rather that so many

play02:16

teams approach to requirements he's so

play02:18

wrong

play02:20

to the extent that we've done something

play02:22

that we often seem to do in software

play02:23

we've redefined the term

play02:25

the common use of the term requirements

play02:28

in software doesn't match what the word

play02:31

or even our own definitions of it say it

play02:33

means

play02:34

in software we often think of

play02:35

requirements as big complex

play02:38

implementation focused descriptions of

play02:41

how a system should work

play02:43

a kind of painting by numbers

play02:45

description of how to build the system

play02:48

this is a complete misrepresentation of

play02:50

the idea of a requirement

play02:53

here's how the ieee defines them

play02:56

a condition or capability needed by a

play02:58

user to solve a problem or achieve an

play03:01

objective

play03:02

i'm pretty happy with that it aligns

play03:04

very well with how i think about things

play03:07

to guide our work we need a description

play03:10

ideally a brief description of what we

play03:13

need our software to do

play03:15

please note that this definition leaves

play03:17

very little room to misinterpret this to

play03:20

mean a detailed description of how to

play03:22

solve some unstated problem which is

play03:25

what most requirements that i see look

play03:27

like

play03:28

if your requirements prescribe how the

play03:31

system works they aren't really

play03:33

requirements at all

play03:34

i see lots of organizations that by my

play03:37

and ieee's definition don't have any

play03:38

requirements at all or at least none

play03:41

that are communicated to the development

play03:42

teams

play03:44

instead they have collections of what

play03:46

are effectively high level descriptions

play03:48

of a solution

play03:50

the dev team don't get off the hook here

play03:52

though this isn't about a rant about

play03:54

evil product owners

play03:56

as usual it's a bit more complicated

play03:58

than that dev teams are often complicit

play04:01

in this thinking

play04:03

i've seen development teams refuse work

play04:05

on a feature unless it is more precisely

play04:08

specified

play04:09

this often happens in junior teams who

play04:11

are feeling a little bit lost

play04:13

and in bureaucratic organizations where

play04:16

it's really more about ass covering than

play04:19

doing a good job making sure that no

play04:21

blame can stick because we're doing what

play04:23

we're told

play04:24

let's clear the decks and get one bad

play04:27

idea off the table here unless you're

play04:29

working on a deeply constrained unusual

play04:32

kind of problem where you're interfacing

play04:34

to a technical well-defined

play04:35

communication protocol of some kind

play04:38

no one knows what the requirements are

play04:40

they're all just guesses

play04:42

it's common for dev teams to bemoan

play04:45

software failures and blame the failure

play04:46

on somewhere else if only they'd told us

play04:49

what they really wanted

play04:50

but they whoever they are can't tell us

play04:53

what they want because they don't know

play04:55

what they want

play04:56

at least not in enough detail to

play04:58

implement a software system

play05:00

in reality our job and the whole process

play05:03

of software development really is to

play05:06

translate vague wishes into a

play05:08

sufficiently concrete description that

play05:11

it can execute on a computer

play05:13

this is all that a computer program is

play05:16

so the only way for our users or our

play05:18

product owners or whoever to precisely

play05:21

specify what they need is to write the

play05:24

code for themselves

play05:26

and that's kind of what great teams do

play05:29

great development teams own the

play05:31

responsibility not just for the

play05:32

technicalities but for the products that

play05:35

they build too

play05:36

they may be informed by people who

play05:38

understand the problem better

play05:40

but they understand the problem and

play05:42

steer the development and direction of

play05:44

the product

play05:45

as a team based on that understanding

play05:48

none of this means that we shouldn't

play05:50

listen to our users but rather that we

play05:53

shouldn't assume that they know what it

play05:55

is that they want other than in vague

play05:57

general terms

play05:59

it's an illusion that anyone really

play06:01

knows that the requirement what the

play06:03

requirements are so it's not much point

play06:05

blaming product owners or users for not

play06:07

knowing what they want or for changing

play06:09

their minds once they've seen our latest

play06:11

creation

play06:13

that simply is the game that we are in

play06:16

so the job of the requirements process

play06:19

is to begin this process of translation

play06:22

from a vague wish into something that

play06:25

works on a computer

play06:27

not by attempting to solve it in a

play06:28

single step though

play06:30

but first

play06:32

making sure that we're clear about what

play06:34

users want as far as we and they

play06:37

understand it

play06:39

our job is to explore the problems that

play06:42

we are trying to solve and leave

play06:43

ourselves free to try out different

play06:46

solutions when we find better ways or

play06:48

our users dislike our early attempts

play06:51

what all this really means

play06:53

is that it's really a terrible idea to

play06:56

fall into the alluring trap of rigidly

play06:59

fixing the requirements process to the

play07:02

solution

play07:03

these should be treated as two

play07:06

distinctly separate steps on the journey

play07:09

of translation from wishes to working

play07:11

software

play07:12

we separate what the system needs to do

play07:14

from how it actually does it

play07:16

we will still get the what wrong

play07:18

sometimes but usually mostly if we're

play07:22

cautious in how we express the what

play07:25

it is the how that is more painful to

play07:27

change so if we focus on describing only

play07:30

what in our requirements and immediately

play07:33

jump on on any sign

play07:36

that we're describing how rather than

play07:39

what and eradicate it

play07:41

we will give ourselves a better chance

play07:43

of being able to change the how when we

play07:45

need to

play07:48

if our aim is to build better software

play07:50

faster this is a very important thing to

play07:53

get right

play07:55

user stories are an effective way to fix

play07:58

this problem

play07:59

but you still need to understand where

play08:01

their real value lies

play08:03

i think that the idea of user stories is

play08:05

a kind of shortcut to this bigger idea

play08:08

it's an effective extremely valuable

play08:11

shortcut

play08:12

but the other idea is still bigger

play08:15

a few years ago i was working with a

play08:17

team that was building some low-level

play08:19

software for a complex hardware system

play08:22

they were building the firmware and

play08:24

device driver layers of code for a

play08:26

scientific instrument

play08:28

at one point the tech lead said user

play08:30

stories don't work for us

play08:33

he went on to explain that the bulk of

play08:35

their work was on a single user story

play08:38

the user pressed a button the machine

play08:40

ran through a calibration sequence that

play08:42

took six hours and represented three

play08:44

years worth of software development

play08:47

fair enough this rather challenged some

play08:49

of my assumptions then and now i

play08:52

generally start from the assumption that

play08:54

you can always find a story if you look

play08:56

hard enough even after this experience i

play09:00

still hold this view

play09:02

i think that my friend the tech lead was

play09:04

partly wrong and partly right if you

play09:06

think from the perspective of the user

play09:09

you will end up with a better design but

play09:12

what many developers and development

play09:14

teams do at this point is to take a

play09:17

rather technical view of what it means

play09:19

to focus on what the user wants they

play09:22

don't really think about the user

play09:24

i think they think about the user

play09:26

interface and this is wrong

play09:29

our aim is to tell stories about a

play09:31

user's goals and only then figure out

play09:33

how to meet those goals so let's carry

play09:36

on with our scientific black box as an

play09:38

example

play09:39

at the point when the user walks up to

play09:41

this device they aren't thinking i want

play09:44

to push the initialization button to

play09:46

start calibration

play09:48

they're really thinking i want to use

play09:50

the machine to do some work

play09:52

pushing the initialization button is an

play09:54

annoying side effect really an

play09:56

implementation detail that is forced on

play09:58

them by some technical constraints

play10:00

presumably

play10:02

the constraints are probably real

play10:04

but my first thought if i'm thinking

play10:06

from a user's perspective is i bet

play10:08

they'd like our system more if it didn't

play10:10

take so long to get going

play10:13

we are imposing something on our users

play10:15

that none of them really want so my user

play10:17

focus has started me wondering if i

play10:20

could shorten this calibration time

play10:22

let's put that aside for now let's

play10:25

imagine that you are the user you walk

play10:27

up to the machine press the button and

play10:29

then head off to go surfing while the

play10:31

machine starts up

play10:32

six hours later you return and the

play10:34

machine isn't running you didn't press

play10:36

the button properly

play10:37

don't that would be a terrible design

play10:40

given the way that the machine works

play10:43

necessitates this long startup as a user

play10:46

i'd at least like some feedback that the

play10:48

calibration sequence had started

play10:50

properly when i pressed the button and

play10:51

before i got my surfboard out

play10:54

so now we have a user need that we can

play10:57

use to inform our design

play10:59

as a surfing scientist i'd like to be

play11:01

able to start calibration to get and get

play11:03

confirmation that calibration is

play11:04

underway so that i can go surfing

play11:07

if the calibration process takes six

play11:09

hours we can be pretty sure that there's

play11:11

a lot going on six hours of work for a

play11:14

modern computer is a lot of work if we

play11:16

think about this from our user's

play11:18

perspective again

play11:19

it's pretty clear that we can think of

play11:21

lots of examples stories about stuff

play11:23

going wrong for example that would

play11:26

inform our design choices and soon as we

play11:30

start thinking like this it also

play11:32

challenges some of our assumptions about

play11:33

our design perhaps

play11:35

let's take our tech league statement at

play11:38

face value in reality the team had done

play11:40

some of this thinking of course they

play11:42

just hadn't thought of it in terms of

play11:43

user stories six hours of work obviously

play11:46

the system was running through a lot of

play11:48

steps once the process was started sure

play11:51

there wasn't any use any more user input

play11:54

but we can certainly imagine scenarios

play11:56

stories about times when some output

play11:58

would be nice

play11:59

i go for coffee and come back and find

play12:02

that the startup failed because i forgot

play12:04

to add the correct carefully measured

play12:05

calibration sample

play12:07

if that is our story our job as a

play12:10

development team is to figure out how to

play12:12

inform our user that the sample was

play12:14

wrong and maybe decide how they should

play12:16

progress from here or have they got to

play12:18

go back to the beginning and start all

play12:20

over again

play12:21

this defines how our system interacts

play12:24

with our user

play12:25

again from a user's perspective it would

play12:27

be really nice to know if the

play12:29

calibration failed early if i'm off

play12:32

surfing for the day but the calibration

play12:34

failed 10 minutes after i left my boss

play12:36

is going to be pretty angry because i

play12:38

could have spent the time fixing the

play12:39

problem instead of catching waves

play12:42

how much nicer if there is a way that i

play12:44

could monitor progress or be informed of

play12:47

failures

play12:48

we don't need to say anything about how

play12:50

any of this works but knowing that it's

play12:53

something that would be useful to our

play12:55

users

play12:56

is what gets software developers

play12:57

thinking about what is needed and ways

play13:00

of solving this problem

play13:02

the idea of a user story is not to

play13:05

define a user interface more it is to

play13:08

define the user's mental model of the

play13:10

context of the system

play13:13

when i approach the system what is my

play13:15

goal when the system is working what do

play13:18

i need to be aware of when the system

play13:20

fails what do i need to know and what do

play13:22

i need to be able to do to carry on

play13:25

these are all what questions and none of

play13:28

them do or should say anything at all

play13:31

about how the system actually works

play13:34

this user focus is a fantastically

play13:37

effective tool at making us take this

play13:40

external perspective

play13:42

but as soon as we ignore this deeper

play13:44

meaning

play13:45

we lose nearly all of the value of user

play13:47

stories

play13:48

thinking of user visible outcomes

play13:51

focuses us on our real goals so we end

play13:54

up with a better chance of describing

play13:56

effective requirements that leave us

play13:58

free to later think about lots of

play14:01

different solutions that may fit those

play14:03

requirements

play14:05

user stories are a kind of trick to

play14:07

force us to separate thinking about what

play14:10

from thinking about how so the real

play14:12

difference here is less about stories

play14:14

versus requirements and much more about

play14:17

requirements versus bad requirements

play14:21

so that's the use a bit what about the

play14:23

stories

play14:25

i think of this in a more literal terms

play14:27

than many people seem to the stories in

play14:30

our user stories are literally stories

play14:33

about the use of the system

play14:35

one day joe came and bought a book

play14:37

called modern software engineering

play14:39

that's a story okay it may not be a very

play14:42

exciting story but the real goal here is

play14:45

to put the need that the story expresses

play14:47

into context

play14:48

it's like a real story it has characters

play14:51

the people who will gain if we add the

play14:53

thing that they need it has a title so

play14:56

that we can talk about it and maybe even

play14:58

recommend it to our friends it has a

play15:00

narrative the explanation that describes

play15:03

the context and the need and it has a

play15:05

resolution ways in which we can see that

play15:08

everything worked out well in the end

play15:11

when we get this right our stories are

play15:13

more durable

play15:14

in fact they don't change until our view

play15:17

of what the user wants changes

play15:20

by focusing on the outcomes that our

play15:22

users want and using their language to

play15:24

capture these outcomes

play15:26

we're communicating in language that is

play15:29

or should be accessible to everyone

play15:31

non-technical people get a clearer view

play15:34

of what each story means so that they

play15:36

have a clearer view of where the project

play15:38

stands and what needs to be done for the

play15:40

users a common side effect of this

play15:43

improved clarity is that it's easier for

play15:45

these people to see ways to cut scope

play15:47

and better prioritize work

play15:50

technical people get a better view of

play15:51

the context too

play15:53

this means that they can have more

play15:55

effective more useful conversations with

play15:57

non-technical people

play15:58

it means that their understanding of the

play16:00

problem that they're trying to solve

play16:02

with their software deepens over time

play16:05

and this gives them more freedom to pick

play16:08

the most appropriate solution at any

play16:10

time

play16:11

to write great software

play16:13

developers need a good description of

play16:16

what we need the software to do

play16:18

the best way to do this is with succinct

play16:21

user stories not long-winded technical

play16:24

requirements

play16:25

user stories describe what a user wants

play16:27

the software to do

play16:29

good user stories don't include

play16:31

technical specifications so eliminate

play16:34

any idea that is specific to your system

play16:36

no mention of databases input fields or

play16:39

even clicking buttons

play16:40

if you think you have written a good

play16:42

user story test it out imagine a

play16:45

completely different system delivering

play16:47

the same outcome for the customer does

play16:50

your story still make sense for a for a

play16:52

voice or even a thought controlled

play16:54

system

play16:55

use language that a non-technical person

play16:57

can understand imagine asking or ask

play17:00

somebody who understands the problem but

play17:02

knows nothing about your system

play17:04

to read your story

play17:06

would it still make sense to them

play17:10

the goal of user stories is to be

play17:12

intentionally deliberately high level a

play17:15

good user story is accurate enough to

play17:18

capture the goal and vague enough to

play17:21

allow lots of different ways to achieve

play17:23

the goal

play17:24

thank you very much for watching

play17:28

[Music]

play17:33

you

Rate This

5.0 / 5 (0 votes)

Related Tags
软件开发需求定义用户故事敏捷方法持续交付技术团队产品开发设计思维问题解决软件工程
Do you need a summary in English?