--- abrar arshad <ibrararshad@...> wrote:
> Yeah I know requirements traceability has always been related
> to formal requirements specification and in agile with don't
> have formal documentation. ... For instances, how do you know
> where to make changes if your client wants you to change a
> feature which already has been developed. There is a chance
> that changing one feature might effect the others as well.
> ...

I was involved in Document-Driven approaches for quite a few years before
joining the XP community. "Requirements Tracability" was always a promise of
the document-driven approach, used in part to justify its high cost. But
honestly, I have never seen it deliver as promised:

Requirements tracability advocates say that it will show you where to make a new
change, and that it will highlight conflicting requirements. I have never seen
this happen in practice.

Consider this example: We have a system that is computing hourly pay in several
divisions at several union plants. There is a fair amount of hard-coded
conditional code. We just renegotiated the overtime rates for one of the
divisions at two plants.

For requirements tracability to be useful, it has to be easier to find the
original requirements for these divisions and to trace these requirements down
to code than it would be to find the code directly. And to see conflicts, one
would have to go from all the requirements that are relevant to the code back to
the requirements documents -- and then somehow figure out what to do with a
whole bunch of requirements statements -- to see if they conflict or overlap in
any way, and how to resolve the issues.

Generally, in practice, it's pretty easy to find the relevant code, even without
any external requirements documentation. It's easier to find the code than to
trace through a tangled mess of requirement number references.

And to make the change... Add or change tests. Then change the code so that it
passes the tests. If there are conflicting requirements, other tests will fail.
You'll look at the other tests and probably learn something. Sometimes it's a
technical issue, easily solved. Sometimes it is a real conflict in the business
requirements. In that case, you will probably have to go back to the business
requirements and maybe to the people who specify them to resolve the business
issue.

So requirements tracability is not only costly and quickly out of date, it turns
out to not be very useful. About the only good thing I've seen requirements
tracability do is to serve as a checklist of all the things the system must do:
When they're all checked off, then you have reason to believe that the system
does everything that's been requested. User stories with automated acceptance
tests also do this -- with much higher justifiable confidence levels.