When we're having an architecture discussion, we'll talk about abstractions, using terms like "component", "module" and "layer". These abstractions reflect our mental model of a software system, which are useful when describing our architectural ideas and intent. These same abstractions don't typically exist in the programming languages we use though. There's no "layer" keyword in Java, for example. To implement these abstractions, we need to use a combination of the constructs available in our programming languages; such as classes, interfaces, objects, functions, packages, namespaces, files, and folders. In many cases, the code that is written doesn't end up reflecting the abstractions. This is the "model-code gap".
The model-code gap manifests itself in a number of ways. In obvious cases, the code doesn't match the architecture diagrams. Sometimes the problems are more subtle though. This session is about the model-code gap, and particularly how it relates to applications that are built from a single monolithic deployment unit. Regardless of how we choose to structure our code (layers, vertical slices, ports and adapters, etc), our best design intentions can be destroyed in a flash if we don't consider the intricacies of the implementation strategy. The devil is in the implementation details.