Does anyone know how to visually diagram the ways in which the flow of control in code passes between code produced by different groups and how that affects the amount of code that needs to be carefully written/reviewed/tested for system properties to hold?
What I am trying to help people visualize are arguments of the form:
- For property P to hold, nd developers have to write application code, Ca, without certain kinds of errors, and nm maintainers have to make sure that the code continues to not have these kinds of errors over the project lifetime.
- We could reduce the error rate by educating nd developers and nm maintainers.
- For us to be confident that the property holds, ns specialists still need to test or check |Ca| lines of code and continue to test/check the changes by nm maintainers.
- Alternatively, we could be confident that P holds if all code paths that could violate P went through tool code, Ct, written by our specialists.
- In our case,
- test suites alone cannot give confidence that P holds
- nd ≫ ns
- nm > ns
- |Ca| ≫ |Ct|
or those conditions do not hold, so focusing on education and testing is preferable.
As a concrete example, suppose we want to ensure that our web-service only produces valid JSON output.
Our web-service provides several query and mutation operators that can be composed in interesting ways.
We could try to educate everyone who maintains those operations about the JSON syntax, the importance of conformance, and libraries available so that when they write to an output buffer, every possible sequence of appends results in syntactically valid JSON.
Alternatively, we don't expose an output stream handle to application code, and instead expose a JSON sink so that every code path that writes a response is channeled through a JSON sink that is written and maintained by a specialist who knows JSON syntax and can use well-written libraries to produce only valid output.
We need to make sure that a service that receives a URL from an untrusted source and tries to fetch its content does not end up revealing sensitive files from the file-system, like
If there is a single standard way that any developer familiar with the application language's libraries would use to fetch URLs, which has file-system access turned off by default, then simply educating developers about the standard mechanism, and testing that file probing fails for some inputs, will probably be sufficient.