Today, I got an e-mail about a webinar on requirements traceability. Come on, give me a break! Conceptually, the goal of traceability is a noble one. The ability to link artifacts back to stakeholder needs and forward to the design artifacts, source code and tests that realize those requirements help us, among other things, understand and assess the impact of change. But there’s some hidden challenges that blow traceability right out of the water.
There are two key requirements with traceability.
- Related artifacts must be linked together.
- Linked artifacts must maintain fidelity.
Every software artifact is an expression of some requirement. On a typical software project, a single requirement is expressed several different ways (use case, business rules, user story, test case, class diagram, source code). But regardless of how it’s expressed, it must convey the same meaning across all linked artifacts. That is, it must possess fidelity.
Establishing the links between artifacts is the easy part. Managing these relationships going forward is virtually impossible. We can only maintain fidelity across artifacts if we synchronize the artifacts anytime something changes. We all know that this doesn’t happen. When a test plan changes, we rarely go back and update requirements documentation. When the source code changes, we rarely update the design document.
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 maintains fidelity with other linked artifacts. The more things change, the more discipline that’s required. Most teams simply don’t have the time to maintain that discipline. The result is the outdated and irrelevant documentation that plagues many projects today. Again, establishing the links between artifacts is easy. Ensuring linked artifacts are synchronized and maintain fidelity is hard.
Many tools claim to offer support for full lifecycle traceability. Be careful. What many offer is the possibility to establish links between artifacts, with no guarantee that the correct links have been established and that the artifacts offer a consistent expression of a requirement. Traceability without fidelity will not make you happy.
So, is traceability attainable? Absolutely. But only if related artifacts are linked and the artifacts convey the same meaning. Since we don’t possess the discipline to do this manually, the only way to ensure both is through executable artifacts. Executable artifacts are artifacts that are executable against another artifact. Executable artifacts establish a link and enforce fidelity. The simplest example is an automated test against the code. If the code changes, the test may break, resulting in a lack of fidelity. Fortunately, this lack of fidelity raises an error condition and make it visible to the team, forcing them to fix the problem (i.e., synchronize).
Until tools support executable artifacts, the promise of traceability will go unfulfilled.