Invention of OOPs

In the late 1950s and early 1960s, programs were written as long sequences of procedures operating on shared global data. This approach broke down as programs grew larger, with any function potentially changing any data, causing bugs to spread across the entire codebase. Real-world entities such as ships, customers, and bank accounts had no single home in the code; their data and behavior were scattered throughout.

Researchers sought a way to model the world as a set of self-contained things that could communicate with each other. This idea led to the development of object-oriented programming (OOP). The story of OOP spans several key milestones and individuals.

In 1963, Ivan Sutherland at MIT created Sketchpad, a graphics system featuring master drawings and instances, which can be considered an early form of class/object. Between 1962 and 1967, Ole-Johan Dahl and Kristen Nygaard at the Norwegian Computing Center in Oslo developed Simula I and Simula 67, marking the first OOP language. Simula 67 introduced classes, objects, inheritance, subclasses, and virtual methods, providing the foundations for OOP.

The term "object-oriented" was coined by Alan Kay in 1966-1967, inspired by Sketchpad, Simula, and biological concepts of cells communicating via messages. In 1972-1980, Xerox PARC developed Smalltalk, a pure OOP language where everything is an object that communicates by sending messages. Smalltalk also introduced the graphical user interface (GUI), windows, and the Model-View-Controller (MVC) architecture.

Bjarne Stroustrup at Bell Labs introduced C with Classes in 1979, followed by the release of C++ in 1983. Stroustrup incorporated Simula's ideas into C, making OOP more accessible for mainstream industry use. Objective-C, developed by Brad Cox and Tom Love in 1984, brought Smalltalk-style messaging to C, laying the groundwork for NeXT and Apple's platforms.

In 1994, Gamma, Helm, Johnson, and Vlissides published "Design Patterns," a catalog of 23 reusable OOP design solutions. This work turned OOP into a design discipline, and in 1995, James Gosling at Sun Microsystems introduced Java, emphasizing write once, run anywhere and making class-based OOP the default for enterprise software.

Over time, principles such as SOLID have emerged to guide the construction of maintainable object-oriented systems. These principles include Single Responsibility, which ensures a class has only one reason to change; Open/Closed, which allows classes to be open for extension but closed for modification; Liskov Substitution, which ensures that subtypes can replace their base types without altering correctness; Interface Segregation, which promotes many small interfaces rather than one large one; and Dependency Inversion, which advocates depending on abstractions rather than concrete implementations.

OOP plays a crucial role in system design, serving as the language for low-level design (LLD) where classes, interfaces, relationships, and patterns are defined. By representing domain concepts as objects and defining relationships between them, OOP allows developers to map real-world systems to software architecture. This mapping aids in creating clear, modular, and maintainable systems.

There are two main schools of thought in OOP: the Simula/C++/Java approach, which focuses on classes and inheritance, and the Smalltalk/AI approach, which emphasizes objects sending messages. Both perspectives highlight the importance of messaging as the fundamental concept of OOP, echoing modern architectural patterns like microservices and actor systems.