Blogger: Kirk Knoernschild
Full lifecycle traceability is SDLC’s nirvana. The ability to link requirements back to stakeholder needs and forward to the design artifacts, source code, and tests that realize those requirements is appealing. By linking the requirement back to the stakeholder, we are able to prioritize the requirement and determine how valuable a requirement is to a specific customer. Tracing the requirement forward allows us to understand and assess the impact of change, identify relevant artifacts that realize a requirement, and even determine if a feature of the system is needed depending on how much it is actually used.
Full Lifecycle Traceability is a good thing, and many software development teams bang their heads against the wall attempting to achieve it. Application Lifecycle Management (ALM) tools promise full lifecycle traceability, and a lot of software development teams have purchased integrated ALM tool suites hoping to achieve full lifecycle traceability. And they are still banging their heads. Why? Full lifecycle traceability is unattainable with today’s tool suites.
There are two key requirements to achieving traceability. The first is that related artifacts must be linked together. The second is that linked artifacts must convey the same message, albeit from a different perspective. A single requirement is expressed in many different ways (use case, business rules, user story, test case, class diagram, sequence diagram, source code, test case), but regardless of how it is expressed, it must convey the same meaning across all linked artifacts. For example, a use case or user story expresses a feature or requirement from the user’s perspective. A design model expresses that same requirement from the perspective of an architect or designer. The source code expresses the requirement from a developers perspective. And a test case expresses the requirement from the perspective of the tester. And each of these artifacts is linked to the other, related artifact. Herein lies the problem. Establishing and managing the links between all related artifacts is only theoretically possible and ensuring that each linked artifact conveys a consistent expression of a requirement, albeit from a slightly different perspective, is not possible.
Many tools claim to offer support for full lifecycle traceability. What they really offer is the possibility to establish links between artifacts, with no guarantee that the correct links have been established and leaving open the possibility that missing links exist. What they do not offer is the capability to ensure that each linked artifact offers a consistent expression of a requirement. The primordial force that makes traceability unattainable is the reliance on the power of human discipline to ensure that the correct links between artifacts are established and that each artifact offers a consistent expression of a requirement from a different perspective. The problem is only exacerbated by change. As change occurs, tools to not enforce the discipline necessary to ensure that all linked artifacts are updated accordingly, nor do they offer a way to guarantee that updated artifacts continue to offer consistent expressions of a requirement. The result is the outdated and irrelevant documentation that plagues many projects today.
Is full lifecycle traceability forever unattainable then? No. Traceability is attainable if related artifacts are linked *and* the artifacts convey the same message. The way to achieve full lifecycle traceability is through artifacts that are executable against other artifacts, or Executable Artifacts. Executable specifications, models, test plans, and more. Executable artifacts are any artifact that is executable against another executable artifact. Executable artifacts fulfill the key requirements to traceability. Because they are executable against each other, a link is intrinsically established. As change occurs, if not all linked artifacts are updated or express a requirement consistently, a failure condition arises. Until tool suites support executable artifacts, the promise of full lifecycle traceability will be left unfulfilled.
Comments