The Minds Behind Object-Oriented Programming – 7 People Redefining Software

TL;DR

Object-oriented programming did not spring from one language or one definition. It began with Ole-Johan Dahl and Kristen Nygaard’s Simula work, where classes, objects, inheritance, and virtual behavior emerged from the practical need to model complex simulations. Alan Kay then pushed a broader vision in which computation consisted of communicating objects; Dan Ingalls and Adele Goldberg helped turn that vision into the Smalltalk systems and environments that made object-oriented personal computing tangible. Bertrand Meyer later tied objects to contracts and systematic software engineering through Eiffel, while Brad Cox adapted Smalltalk-inspired messaging to C in Objective-C, helping carry object ideas into mainstream commercial systems.^[1][3][7]

Why you should read it anyway

The compelling reason to read this story is that object orientation changed more than syntax. It offered programmers a different unit of thought. Instead of beginning with a sequence of operations over global data, developers could model entities that owned state and exposed behavior. That approach fit simulations, graphical interfaces, interactive systems, and large software frameworks especially well. The seven people here show OOP evolving through three stages: invention of the fundamental concepts, reinvention around interactive personal computing, and engineering methods that made the paradigm portable across organizations and languages.^[1][4]

Imagine where Object-Oriented Programming would be without them

Without these contributors, modular programming and abstract data types would still have advanced, but the specific object model that came to dominate mainstream software might have arrived later or looked different. Graphical interfaces, application frameworks, simulations, and reusable class libraries all benefited from thinking in terms of persistent interacting entities. The delay would not be the absence of modular software; it would be slower convergence on a shared object vocabulary across education, languages, tools, and commercial platforms.^[1][5]

Time Estimate of how many years we would be hindered without them for human progress

Counterfactual estimate: 5–10 years. This is an editorial estimate. Many of OOP’s ingredients had parallels elsewhere, but Simula and Smalltalk created unusually complete demonstrations. Without them, the industry might have needed another generation of languages to recombine encapsulated state, dynamic dispatch, inheritance, interactive environments, and reusable frameworks into a coherent mainstream paradigm.

The 7 people behind Object-Oriented Programming

1. Ole-Johan Dahl

Why they matter: Dahl, together with Kristen Nygaard, designed Simula I and Simula 67. Their work established core concepts that ACM later described as fundamental to the emergence of object-oriented programming: objects, classes, inheritance, and virtual mechanisms. Dahl contributed exceptional implementation and language-design skill, helping turn a simulation requirement into a general programming model that later language designers could recognize and reuse.^[1][2]

2. Kristen Nygaard

Why they matter: Nygaard brought the modeling problem that made objects necessary. His operations-research and simulation interests demanded a way to represent many interacting real-world entities over time. Working with Dahl, he helped transform that need into Simula’s class/object architecture. Nygaard’s role reminds us that OOP began not as a fashionable software pattern but as an attempt to make computer models correspond more naturally to complex systems.^[1][2]

3. Alan Kay

Why they matter: Kay reinterpreted object orientation for personal computing. ACM’s Turing Award material recognizes him for pioneering ideas at the roots of object-oriented programming and personal computing. In Kay’s Smalltalk vision, objects were less about static class hierarchies than about autonomous components communicating through messages. That emphasis helped connect OOP to graphical interfaces, educational computing, and highly interactive systems.^[5]

4. Dan Ingalls

Why they matter: Ingalls was one of the engineering forces that made Smalltalk real. ACM credits him, with Kay and Goldberg, for foundational Smalltalk work. He designed and implemented major parts of the language, virtual machine, graphics, and development environment. Ingalls’s role shows why programming paradigms need systems builders: a beautiful object model becomes influential when programmers can experience it as a fast, coherent environment rather than merely read about it.^[3]

5. Adele Goldberg

Why they matter: Goldberg helped develop, document, and spread Smalltalk-80. Computer History Museum describes her leadership in the Xerox PARC Smalltalk effort and her role in bringing object-oriented concepts to a wider world. She connected research system, educational material, and external adoption—critical work because a language paradigm becomes an ecosystem only when people outside its birthplace can learn it, implement it, and build on it.^[4]

6. Bertrand Meyer

Why they matter: Meyer pushed object orientation toward rigorous software engineering. Through Eiffel he emphasized abstraction, inheritance, genericity, and especially Design by Contract: explicit preconditions, postconditions, and invariants attached to software components. That made OOP not just a technique for organizing code but a framework for specifying obligations between components. Meyer’s contribution strengthened the link between object modularity and correctness.^[6]

7. Brad Cox

Why they matter: Cox helped make object orientation compatible with the enormous installed world of C. He created Objective-C by adding Smalltalk-style messaging and objects to C, a pragmatic bridge between two programming cultures. Computer History Museum’s account of Objective-C and NeXT shows how that bridge became commercially consequential: it traveled through NeXT into Apple’s software lineage. Cox’s work demonstrates that adoption often depends on hybrid languages that preserve existing investments while introducing new abstractions.^[7]

How they each differ from one another

Dahl and Nygaard invented the foundational model through simulation; Kay reconceived objects as a universal medium of communicating components; Ingalls made that vision performant and usable; Goldberg made it teachable and transferable; Meyer added specification discipline; Cox built a migration bridge into C ecosystems. Their differences explain why OOP spread: it had a conceptual foundation, an interactive demonstration, engineering rigor, and practical routes into existing software worlds.^[1][3][7]

Final Take

Object-oriented programming became so widespread that its vocabulary—object, class, method, message, inheritance, interface—can feel inevitable. It was not. Those concepts emerged from concrete problems, were reinterpreted by later researchers, and were repeatedly rebuilt for new environments. The seven people here show a paradigm evolving rather than being invented once. Their shared achievement was giving programmers a durable way to model software as a society of components with identity, state, behavior, and obligations.^[1][4]

RESEARCH / PROVENANCE

Works Cited

7 SOURCES

1. 01
   ACM — Ole-Johan Dahl A.M. Turing Award Citation ↗ethw.org
2. 02
   Computer History Museum Software Preservation — History of ALGOL / SIMULA Session ↗softwarepreservation.computerhistory.org
3. 03
   ACM — Dan Ingalls Award Profile ↗awards.acm.org
4. 04
   Computer History Museum — Adele Goldberg ↗computerhistory.org
5. 05
   ACM — A.M. Turing Award Fact Sheet ↗acm.org
6. 06
   Eiffel Software — Bertrand Meyer and Eiffel ↗eiffel.com
7. 07
   Computer History Museum — Steve Jobs, NeXTSTEP, and Early Object-Oriented Programming ↗computerhistory.org

CodeHistory is a living archive. Citations document the evidence used for this edition; later evidence may refine the account.