Trustable Model and Methodology
Trustable provides a theoretical model for reasoning about critical requirements and a methodology for applying it to software projects in practice. The model and methodology are structured to permit an approximation of organizational confidence in XYZ automatically, in CI. Better still, by reasoning about multiple systems with the same model we can manage their interactions in a scalable manner.
Motivation and Approach
Poorly-written and poorly-organised requirements are a frequent problem for software projects. Where these projects contribute to critical systems, creating numerous requirements can worsen the very problems they are intended to solve.
Poorly-written requirements are characterised by imprecise or ambiguous language, unspecified contexts and implicit criteria. When exhibited in high-level requirements these problems can be propagated downwards: from architecture into design and ultimately implementation.
On the other hand, flaws can also propagate upwards. When teams begin work without requirements, or use prior art, the objectives, motivation and reasoning for that work are often lost. Integrating this work into the wider design or architecture represents an organizational challenge.
Traditional approaches in safety mitigate these risks by defining a complex multistage lifecycle through which XYZ and its requirements are created, maintained and refined throughout the life of the product. Such a lifecycle cannot be applied to FOSS as it is inherently pre-existing, rapidly evolving and not subject to a well-defined development lifecycle.
Trustable endeavours to provide an alternative solution for managing the critical requirements of complex systems that addresses these commonplace problems in a way that can be applied to FOSS. We start from a minimal theoretical model for requirements, from which all of our terminology, methodology and tools are derived. This provides an unambiguous approach to requirements that is flexible and extensible but always self-consistent. By following simple rules in our implementation, we aim to build a complex model of XYZ, whatever its state of development, that is meaningful, robust and rigorous.