Object-oriented programming (OOP) isn't disappearing; it's evolving across different domains. The author reflects on the history of software development, noting that early programming was straightforward until the complexity of collaboration led to bugs. This prompted the introduction of interfaces to separate functions, which ultimately gave rise to concepts like encapsulation, inheritance, and polymorphism. While these ideas aren't exclusive to OOP, it has been the primary champion of them. The narrative shifts to the evolution of operating systems that began as friendly assistants but transformed into strict overseers, ensuring program safety. As software became more complex and developers less familiar with one another's work, the need for clear boundaries grew. This led to a shift from OOP to microservices and containerization, creating a system fraught with even greater challenges. The author points out that despite the skepticism surrounding OOP, the alternatives have similar flaws, now amplified. Technologies like OpenAPI and Kubernetes are cumbersome, introducing new failure modes and complexities that weren't present in traditional OOP structures. The author expresses skepticism about the benefits of both paradigms, suggesting that the new systems are not improvements but rather a different set of complications.