Requirement Specification vs User Stories
Summary
TLDRDave Farley 在视频中探讨了软件开发中常见的问题,包括过度依赖手动测试和错误的需求获取。他强调了清晰定义软件需求的重要性,并解释了用户故事与需求之间的关系。Farley 认为,用户故事是一种有效的方法,可以帮助团队从模糊的愿望转变为具体的计算机程序。他建议开发团队应该拥有责任,不仅要关注技术细节,还要理解并引导产品开发的方向。此外,他还讨论了如何正确地使用用户故事来避免技术细节,从而更好地满足用户需求并提高软件开发效率。
Takeaways
- 🔍 软件开发中最常见的问题是过度依赖手动测试和需求定义错误。
- 📝 需求定义错误是软件开发中问题频发的主要原因之一,需要通过有效沟通来明确软件要实现的功能。
- 👥 大多数团队采用敏捷方法,通过用户故事来定义需求,但用户故事与需求并不等同,而是需求定义方式不当。
- 📚 IEEE定义需求为用户解决问题或实现目标所需的条件或能力,这与常见的实施导向的需求描述不符。
- 🛠️ 开发团队不应期望产品所有者或用户能精确定义需求,因为需求本质上是猜测,需要通过开发过程来明确。
- 💡 优秀的开发团队不仅负责技术细节,还应负责产品的开发方向,基于对问题的理解来引导产品发展。
- 🤔 用户或产品所有者通常只知道他们想要的大致方向,而不是具体需求,需求过程的目的是将这些模糊的愿望转化为计算机可执行的描述。
- 📈 将需求过程分为两个独立步骤:明确用户想要什么(需求),以及如何实现(解决方案)。
- 📘 用户故事是有效定义需求的方法,其真正价值在于帮助我们关注用户的目标,而不是系统的具体实现。
- 🏄♂️ 以用户的角度思考,可以发现用户的真实需求和问题,从而设计出更好的软件解决方案。
- 📖 用户故事应该描述用户的目标和系统在不同情况下的行为,而不是具体的用户界面或技术实现。
- 🔑 用户故事的目的是使用户、开发人员和其他利益相关者能够用共同的语言讨论软件的目标和功能。
- 📝 良好的用户故事应该是高层次的,足够精确以捕捉目标,同时足够模糊以允许多种实现方式。
Q & A
软件开发中常见的两个问题是什么?
-软件开发中常见的两个问题是过度依赖手动测试和最初就错误地获取需求。
为什么需求获取会成为一个棘手的问题?
-需求获取成为一个棘手的问题,因为很多团队对需求的理解是错误的,他们将需求视为复杂、以实现为中心的系统描述,而不是用户需要解决的问题或实现目标的条件或能力。
IEEE对需求的定义是什么?
-IEEE定义需求为用户为解决一个问题或实现一个目标所需要的条件或能力。
为什么说许多团队没有真正的需求?
-许多团队没有真正的需求,因为他们没有将需求传达给开发团队,而是提供了实际上是解决方案的高级描述。
开发团队在需求误解中扮演了什么角色?
-开发团队在需求误解中常常是共犯,他们有时会拒绝接受工作,除非需求被更精确地指定,这通常发生在初级团队或官僚组织中。
软件开发的真正任务是什么?
-软件开发的真正任务是将模糊的愿望转化为足够具体的描述,使其能够在计算机上执行。
为什么说用户故事是解决需求问题的有效方式?
-用户故事是解决需求问题的有效方式,因为它们帮助团队专注于用户想要什么,而不是系统如何工作,从而允许团队在找到更好的方法或用户不喜欢早期尝试时尝试不同的解决方案。
如何理解用户故事的真正价值?
-用户故事的真正价值在于它们迫使我们从用户的角度思考,关注用户的目标,并使用用户的语言来捕捉这些目标,从而使非技术团队成员能够更清楚地了解每个故事的含义。
为什么说用户故事应该避免包含技术规格?
-用户故事应该避免包含技术规格,因为它们应该描述用户想要软件做什么,而不是系统如何实现它。这样可以保持故事的通用性和灵活性,允许开发团队选择最合适的解决方案。
如何测试一个用户故事是否写得好?
-要测试一个用户故事是否写得好,可以想象一个完全不同的系统提供相同的客户成果,如果故事仍然有意义,那么它就是一个好故事。
用户故事的目的是是什么?
-用户故事的目的是故意保持高层次,准确捕捉目标,同时足够模糊,以允许多种不同的实现方式。
Outlines
😀 软件开发常见问题及用户故事的重要性
Dave Farley在视频中讨论了软件开发中常见的两个问题:过度依赖手动测试和需求错误。他强调了需求文档的重要性,并指出许多团队对需求的理解存在误区,将其视为具体的解决方案而非用户解决问题的条件或能力。Dave提出,需求应简洁明了,指导软件开发,而非详细描述系统如何工作。他还提到,开发团队往往参与到这种错误的思维方式中,他们要求需求被精确定义,这在初级团队或官僚组织中尤为常见。Dave认为,软件开发的本质是将模糊的愿望转化为计算机可执行的描述,而优秀的开发团队应该承担起产品开发的责任,而不是仅仅依赖于产品所有者或用户的精确指导。
🤔 用户故事与需求分离的重要性
Dave Farley在本段中继续探讨了用户故事的价值,他认为用户故事是将需求从解决方案中分离出来的有效方法。他强调,需求过程的目的是将模糊的愿望转化为计算机上可行的解决方案,但这需要分两步进行:首先明确用户想要什么,然后探索解决问题的不同方案。Dave指出,将需求固定在解决方案上是一个糟糕的主意,因为这限制了开发团队的灵活性和创新能力。他通过一个科学仪器的案例说明了如何从用户的角度思考问题,并提出了改善用户体验的设计思路。Dave认为,用户故事应该关注用户的目标,而不是用户界面或技术细节,这样可以帮助团队更好地理解问题并设计出更符合用户需求的系统。
🏄♂️ 从用户角度出发设计软件
Dave Farley通过一个科学仪器的案例,展示了如何从用户的角度出发来设计软件。他提出了一个假设,即用户在使用该仪器时,他们的目标是完成工作,而不是进行长时间的校准过程。Dave建议,如果从用户的需求出发,可能会发现校准时间过长的问题,并思考如何缩短这个过程。他还提出了一些用户故事,如用户在开始校准后去冲浪,但回来后发现校准失败,这启示开发团队需要提供反馈机制,让用户知道校准已经开始,并在失败时及时通知用户。Dave强调,用户故事应该描述用户的目标和他们需要知道的信息,而不是系统的具体工作方式。通过这种方式,可以激发开发团队思考问题和解决方案,从而设计出更好的软件。
📚 用户故事的撰写与价值
在视频的最后部分,Dave Farley讨论了如何撰写有效的用户故事,并强调了它们在软件开发中的价值。他认为,用户故事应该简洁、以用户为中心,并且避免包含任何技术细节。Dave提供了一些撰写用户故事的指导原则,比如使用非技术性的语言,确保故事在不同系统下仍然有意义,以及测试故事是否能够被非技术团队成员理解。他还指出,好的用户故事应该是高层次的,足够准确以捕捉目标,同时又足够模糊以允许多种实现方式。Dave总结说,通过关注用户想要的结果,并使用他们的语言来捕捉这些结果,可以提高项目的清晰度,并帮助团队成员更有效地沟通和协作。
Mindmap
Keywords
💡软件测试
💡需求错误
💡用户故事
💡可执行规范
💡敏捷方法
💡需求重定义
💡技术团队的责任
💡用户视角
💡需求与解决方案的分离
💡用户故事的价值
💡用户故事的字面意义
💡技术规格
Highlights
软件开发中最常见的两个问题是过度依赖手动测试和初始需求错误。
需求问题之所以棘手,以及如何修复它们,用户故事究竟是什么。
大多数团队采用敏捷方法,用用户故事来定义需求。
用户故事实际上就是需求,但许多团队对需求的处理方式是错误的。
软件中对需求的常见理解与IEEE定义的需求相悖。
需求应是用户解决问题或实现目标所需的条件或能力。
开发团队常常与产品所有者一样,对需求的错误理解负有责任。
软件开发的本质是将模糊的愿望转化为计算机可以执行的具体描述。
优秀的开发团队不仅负责技术细节,也负责他们构建的产品。
用户故事的目的是开始将模糊的愿望转化为计算机上可行的解决方案。
需求过程的职责是帮助我们清晰地理解用户想要什么。
用户故事是有效的方法来解决固定需求与解决方案的问题。
用户故事的真正价值在于它们迫使我们分离关于“什么”和“如何”的思考。
用户故事应关注用户目标,而非用户界面或技术实现细节。
用户故事帮助我们从用户的角度思考,从而得出更好的设计。
用户故事应描述用户可见的结果,帮助我们集中精力在真正的目标上。
用户故事应使用非技术性语言,以便所有相关方都能理解。
优秀的用户故事足够精确以捕捉目标,足够模糊以允许多种实现方式。
Transcripts
i am often asked to advise companies on
how to do a better job of software
development there are obviously lots of
things that can go wrong with something
as complicated as software development
but the two commonest causes of problems
that i see are an over reliance on
manual testing and the topic of today's
episode getting the requirements wrong
in the first place
so why are the requirements so
problematic and what can we do to fix
them and what is the points of user
stories anyway
[Music]
hi i'm dave farley of continuous
delivery welcome to my channel if you
haven't been here before please do hit
subscribe and if you enjoy the content
today hit like as well
i'd like to begin by thanking our
sponsors equal experts octopus trycentis
and transfik they've been supporting our
channel for a while so please do support
them in turn by checking out their links
in the description below
if you'd like to learn more about user
stories and how they can help you to
take the next step to executable
specifications i've got a new training
course coming out soon check out the
links below for more details and while
you're there also check out our great
summer sale on our current course lineup
software development is structured
around three activities deciding on what
we want building it and verifying that
what we build does what we want
to do a good job of all of these things
then it's important to get a good start
by communicating effectively what it is
that we want our software to do this
shapes everything else that we do really
if we get this wrong it can make it
difficult or even impossible to do a
good job
i think that most teams that build
software these days would think of
themselves as applying an agile approach
and so nearly everyone talks about
defining requirements in terms of user
stories
some people argue that user stories
aren't the same thing as requirements i
confess that i've said stuff like this
myself in the past
but actually i think that i was and they
are mistaken
it's not that user stories aren't
requirements but rather that so many
teams approach to requirements he's so
wrong
to the extent that we've done something
that we often seem to do in software
we've redefined the term
the common use of the term requirements
in software doesn't match what the word
or even our own definitions of it say it
means
in software we often think of
requirements as big complex
implementation focused descriptions of
how a system should work
a kind of painting by numbers
description of how to build the system
this is a complete misrepresentation of
the idea of a requirement
here's how the ieee defines them
a condition or capability needed by a
user to solve a problem or achieve an
objective
i'm pretty happy with that it aligns
very well with how i think about things
to guide our work we need a description
ideally a brief description of what we
need our software to do
please note that this definition leaves
very little room to misinterpret this to
mean a detailed description of how to
solve some unstated problem which is
what most requirements that i see look
like
if your requirements prescribe how the
system works they aren't really
requirements at all
i see lots of organizations that by my
and ieee's definition don't have any
requirements at all or at least none
that are communicated to the development
teams
instead they have collections of what
are effectively high level descriptions
of a solution
the dev team don't get off the hook here
though this isn't about a rant about
evil product owners
as usual it's a bit more complicated
than that dev teams are often complicit
in this thinking
i've seen development teams refuse work
on a feature unless it is more precisely
specified
this often happens in junior teams who
are feeling a little bit lost
and in bureaucratic organizations where
it's really more about ass covering than
doing a good job making sure that no
blame can stick because we're doing what
we're told
let's clear the decks and get one bad
idea off the table here unless you're
working on a deeply constrained unusual
kind of problem where you're interfacing
to a technical well-defined
communication protocol of some kind
no one knows what the requirements are
they're all just guesses
it's common for dev teams to bemoan
software failures and blame the failure
on somewhere else if only they'd told us
what they really wanted
but they whoever they are can't tell us
what they want because they don't know
what they want
at least not in enough detail to
implement a software system
in reality our job and the whole process
of software development really is to
translate vague wishes into a
sufficiently concrete description that
it can execute on a computer
this is all that a computer program is
so the only way for our users or our
product owners or whoever to precisely
specify what they need is to write the
code for themselves
and that's kind of what great teams do
great development teams own the
responsibility not just for the
technicalities but for the products that
they build too
they may be informed by people who
understand the problem better
but they understand the problem and
steer the development and direction of
the product
as a team based on that understanding
none of this means that we shouldn't
listen to our users but rather that we
shouldn't assume that they know what it
is that they want other than in vague
general terms
it's an illusion that anyone really
knows that the requirement what the
requirements are so it's not much point
blaming product owners or users for not
knowing what they want or for changing
their minds once they've seen our latest
creation
that simply is the game that we are in
so the job of the requirements process
is to begin this process of translation
from a vague wish into something that
works on a computer
not by attempting to solve it in a
single step though
but first
making sure that we're clear about what
users want as far as we and they
understand it
our job is to explore the problems that
we are trying to solve and leave
ourselves free to try out different
solutions when we find better ways or
our users dislike our early attempts
what all this really means
is that it's really a terrible idea to
fall into the alluring trap of rigidly
fixing the requirements process to the
solution
these should be treated as two
distinctly separate steps on the journey
of translation from wishes to working
software
we separate what the system needs to do
from how it actually does it
we will still get the what wrong
sometimes but usually mostly if we're
cautious in how we express the what
it is the how that is more painful to
change so if we focus on describing only
what in our requirements and immediately
jump on on any sign
that we're describing how rather than
what and eradicate it
we will give ourselves a better chance
of being able to change the how when we
need to
if our aim is to build better software
faster this is a very important thing to
get right
user stories are an effective way to fix
this problem
but you still need to understand where
their real value lies
i think that the idea of user stories is
a kind of shortcut to this bigger idea
it's an effective extremely valuable
shortcut
but the other idea is still bigger
a few years ago i was working with a
team that was building some low-level
software for a complex hardware system
they were building the firmware and
device driver layers of code for a
scientific instrument
at one point the tech lead said user
stories don't work for us
he went on to explain that the bulk of
their work was on a single user story
the user pressed a button the machine
ran through a calibration sequence that
took six hours and represented three
years worth of software development
fair enough this rather challenged some
of my assumptions then and now i
generally start from the assumption that
you can always find a story if you look
hard enough even after this experience i
still hold this view
i think that my friend the tech lead was
partly wrong and partly right if you
think from the perspective of the user
you will end up with a better design but
what many developers and development
teams do at this point is to take a
rather technical view of what it means
to focus on what the user wants they
don't really think about the user
i think they think about the user
interface and this is wrong
our aim is to tell stories about a
user's goals and only then figure out
how to meet those goals so let's carry
on with our scientific black box as an
example
at the point when the user walks up to
this device they aren't thinking i want
to push the initialization button to
start calibration
they're really thinking i want to use
the machine to do some work
pushing the initialization button is an
annoying side effect really an
implementation detail that is forced on
them by some technical constraints
presumably
the constraints are probably real
but my first thought if i'm thinking
from a user's perspective is i bet
they'd like our system more if it didn't
take so long to get going
we are imposing something on our users
that none of them really want so my user
focus has started me wondering if i
could shorten this calibration time
let's put that aside for now let's
imagine that you are the user you walk
up to the machine press the button and
then head off to go surfing while the
machine starts up
six hours later you return and the
machine isn't running you didn't press
the button properly
don't that would be a terrible design
given the way that the machine works
necessitates this long startup as a user
i'd at least like some feedback that the
calibration sequence had started
properly when i pressed the button and
before i got my surfboard out
so now we have a user need that we can
use to inform our design
as a surfing scientist i'd like to be
able to start calibration to get and get
confirmation that calibration is
underway so that i can go surfing
if the calibration process takes six
hours we can be pretty sure that there's
a lot going on six hours of work for a
modern computer is a lot of work if we
think about this from our user's
perspective again
it's pretty clear that we can think of
lots of examples stories about stuff
going wrong for example that would
inform our design choices and soon as we
start thinking like this it also
challenges some of our assumptions about
our design perhaps
let's take our tech league statement at
face value in reality the team had done
some of this thinking of course they
just hadn't thought of it in terms of
user stories six hours of work obviously
the system was running through a lot of
steps once the process was started sure
there wasn't any use any more user input
but we can certainly imagine scenarios
stories about times when some output
would be nice
i go for coffee and come back and find
that the startup failed because i forgot
to add the correct carefully measured
calibration sample
if that is our story our job as a
development team is to figure out how to
inform our user that the sample was
wrong and maybe decide how they should
progress from here or have they got to
go back to the beginning and start all
over again
this defines how our system interacts
with our user
again from a user's perspective it would
be really nice to know if the
calibration failed early if i'm off
surfing for the day but the calibration
failed 10 minutes after i left my boss
is going to be pretty angry because i
could have spent the time fixing the
problem instead of catching waves
how much nicer if there is a way that i
could monitor progress or be informed of
failures
we don't need to say anything about how
any of this works but knowing that it's
something that would be useful to our
users
is what gets software developers
thinking about what is needed and ways
of solving this problem
the idea of a user story is not to
define a user interface more it is to
define the user's mental model of the
context of the system
when i approach the system what is my
goal when the system is working what do
i need to be aware of when the system
fails what do i need to know and what do
i need to be able to do to carry on
these are all what questions and none of
them do or should say anything at all
about how the system actually works
this user focus is a fantastically
effective tool at making us take this
external perspective
but as soon as we ignore this deeper
meaning
we lose nearly all of the value of user
stories
thinking of user visible outcomes
focuses us on our real goals so we end
up with a better chance of describing
effective requirements that leave us
free to later think about lots of
different solutions that may fit those
requirements
user stories are a kind of trick to
force us to separate thinking about what
from thinking about how so the real
difference here is less about stories
versus requirements and much more about
requirements versus bad requirements
so that's the use a bit what about the
stories
i think of this in a more literal terms
than many people seem to the stories in
our user stories are literally stories
about the use of the system
one day joe came and bought a book
called modern software engineering
that's a story okay it may not be a very
exciting story but the real goal here is
to put the need that the story expresses
into context
it's like a real story it has characters
the people who will gain if we add the
thing that they need it has a title so
that we can talk about it and maybe even
recommend it to our friends it has a
narrative the explanation that describes
the context and the need and it has a
resolution ways in which we can see that
everything worked out well in the end
when we get this right our stories are
more durable
in fact they don't change until our view
of what the user wants changes
by focusing on the outcomes that our
users want and using their language to
capture these outcomes
we're communicating in language that is
or should be accessible to everyone
non-technical people get a clearer view
of what each story means so that they
have a clearer view of where the project
stands and what needs to be done for the
users a common side effect of this
improved clarity is that it's easier for
these people to see ways to cut scope
and better prioritize work
technical people get a better view of
the context too
this means that they can have more
effective more useful conversations with
non-technical people
it means that their understanding of the
problem that they're trying to solve
with their software deepens over time
and this gives them more freedom to pick
the most appropriate solution at any
time
to write great software
developers need a good description of
what we need the software to do
the best way to do this is with succinct
user stories not long-winded technical
requirements
user stories describe what a user wants
the software to do
good user stories don't include
technical specifications so eliminate
any idea that is specific to your system
no mention of databases input fields or
even clicking buttons
if you think you have written a good
user story test it out imagine a
completely different system delivering
the same outcome for the customer does
your story still make sense for a for a
voice or even a thought controlled
system
use language that a non-technical person
can understand imagine asking or ask
somebody who understands the problem but
knows nothing about your system
to read your story
would it still make sense to them
the goal of user stories is to be
intentionally deliberately high level a
good user story is accurate enough to
capture the goal and vague enough to
allow lots of different ways to achieve
the goal
thank you very much for watching
[Music]
you
تصفح المزيد من مقاطع الفيديو ذات الصلة
Requirements Analysis
Lean vs Agile vs Waterfall | What is Lean | Difference between Waterfall and Agile | Intellipaat
第2集-指南-ChatGPT提示工程师|AI大神吴恩达教你写提示词
Psychology of Computing: Crash Course Computer Science #38
我 采 访 了 苏 妈 !| 专访AMD CEO Lisa Su【大咖谈芯09】
Save and persist data with UserDefaults | Todo List #4
5.0 / 5 (0 votes)