Chapter 17 talks about ontologies and how useful they become for the org and for working with AI. And, being honest, I agree with the fundamental point made there, even if I don't fully grasp the minutia.
The chapter itself sounds a bit similar to Domain Driven Design Concepts to me. In a nutshell:
- Ontologies establish universal definitions. Which are useful for ALL sorts of communication and verification
- Terms should be precise and clear (ambiguity creates chaos)
In practical terms, one should:
- Define the Core Entities (the Nouns, similar to DDD's ubiquitous language)
- Define the Invariants (system rules, axioms of sorts). The author divides rules into "coverage" (meaning no loose ends), arithmetic (aggregations should be consistent), determinism (given the same inputs, the system should have the same outputs)
- Remember to have a universal log structure and ensure there is also lineage in there (versioning of system aspects)
The author also proposes organizing CI gates into three layers:
- Deterministic (reproducible pipeline - including invariants, given certain fixtures, we can get the same output 100% of the time)
- Simulation (take the AI's suggestion with the predicted output and run through the deterministic engine to see if it holds)
- Semantic (the scoring of how AI's explains the system/interactions, with a confidence threshold)
The chapter covers a bit more, but I won't get into these other aspects. As I've said before, I agree with the idea, but I don't fully get the mechanics. So I'll just lay out a few random thoughts:
- It is a good idea to think in terms of "deterministic" vs "non-deterministic"
- Deterministic is the good old SWE stuff
- Non-deterministic are features we can't REALLY know the output (we know its intent)
- Simulations are an amazing idea to validate non-deterministic pieces of the system. Reminds me of Deterministic Simulation Tests (which I came to know via tigerbeetle's architecture)
- Ontologies themselves are another spin into the old and important idea that everyone should use the same language and be as precise as possible
I'll probably need to re-read this chapter once I actually need its concepts, but it is good to know it is there.