Diagram to show code responsibility

Question

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:

1. For property P to hold, n_d developers have to write application code, C_a, without certain kinds of errors, and n_m maintainers have to make sure that the code continues to not have these kinds of errors over the project lifetime.
2. We could reduce the error rate by educating n_d developers and n_m maintainers.
3. For us to be confident that the property holds, n_s specialists still need to test or check |C_a| lines of code and continue to test/check the changes by n_m maintainers.
4. Alternatively, we could be confident that P holds if all code paths that could violate P went through tool code, C_t, written by our specialists.
5. In our case,
   • test suites alone cannot give confidence that P holds
   • n_d ≫ n_s
   • n_m > n_s
   • |C_a| ≫ |C_t|
   so writing and maintaining C_t is economical, frees up our developers to worry about other things, and reduces the ongoing education commitment by our specialists.

or those conditions do not hold, so focusing on education and testing is preferable.

---

Example 1

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.

Example 2

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 file:///etc/passwd.

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.

Answer 1

There may be better ways to do this, but my first take would be to use some sequence diagrams and put boundaries (like alt or opt) around calls into different code sources. Most UML tools I have used will allow you make arbitrary boundaries like alt, opt, loop. So you can have "oss" "lib1" "lib2" etc

Once you have the call stack segregated into different buckets, you can then annotate the sections with code metrics like number of lines of code, or cyclomatic complexity in ppt so you can show whoever needs showing where the code allocation is.