Object-Oriented Primitives (In-Process Primitives)
As a Java developer, I'm well familiar with object-oriented concepts such as class, object, inheritance, encapsulation, polymorphism, etc. In addition to the object-oriented concepts, I'm also well familiar with the Java runtime, what features it provides, how I can tune it, how it manages my applications, what would be the lifecycle of my object and the application as a whole, etc.
And for over a decade, all that has been the primary tools, primitives, and building blocks I've used a developer to create applications. In my mental model, I would use classes as components, which would give birth to objects that are managed by the JVM. But that model has started to change recently.
Kubernetes Primitives (Distributed Primitives)
In the last year, I began to run my Java applications on Kubernetes, and that introduced new concepts and tools for me to use. With Kubernetes, I don't rely only on object-oriented concepts and JVM primitives to implement the whole application behavior. I still need to use the object-oriented building blocks to create the components of the application, but I can also use Kubernetes primitives for some of the application behavior.
The Distributed Mental Model
Having in-process primitives, in the form of object-oriented concepts and the JVM features, combined with distributed out-of-process primitives, provided by Kubernetes, gives developers a richer set of tools to create better applications. When building a distributed application, my mental model is no longer limited to a JVM, but spreads across a couple of nodes with multiple JVMs running in coordination.
The in-process primitives and the distributed primitives have commonalities, but they are not directly comparable and replaceable. They operate at different abstraction levels and have different preconditions and guarantees. Some primitives are supposed to be used together. For example, we still have to use classes to create objects and put them into container images. But some other primitives such as CronJob in Kubernetes can replace the ExecutorService behavior in Java completely. Here are few concepts that I've found commonalities for between the JVM and Kubernetes, but don't take that any further.
With time, new primitives give birth to new ways of solving problems, and some of these repetitive solutions become patterns. Check out my in-progressKubernetes Patterns
book for this line of thinking.