Abstract
Programming languages have developed significantly over the past century to provide complex models to think about and describe the world and processes of computation. Out of Alan Kay’s Smalltalk and a number of earlier languages, object-oriented programming has emerged as a preeminent mode of writing and organizing programs. Tracing the history of object-oriented programming from its origins in Simula and Sketchpad through Smalltalk, particularly its philosophical and technical developments, offers unique insights into philosophical questions about objects, language, and our digital technologies. These early attempts to understand objects as basic elements of computation demonstrate the ways in which language, while firmly planted in the material reality of computation, must delimit objects from each other. This essay critically explores this history and explicates a theory of objects suggested by the development of object-oriented programming languages, which insists on the importance of language for representing and delimiting objects. It argues that the philosophies behind object-oriented programming are ultimately opposed to the claims of object-oriented ontology and find themselves more closely allied with philosophies that insist on the mediation of what exists through language.
This is a preview of subscription content, log in via an institution to check access.
Similar content being viewed by others
Notes
Abadi and Cardelli (1996) outline a taxonomy that attempts to account for the variety of object-oriented languages while suggesting a unifying system for explaining them. The complexity of this taxonomy and the changes that “objects” have undergone over the course of their history suggest that the very concept of an object is not fixed and must be worked out in language.
Krogdahl (2003) provides an extensive history of Simula. Priestley (2011) traces the history of both Simula and Smalltalk. Manovich (2013) explores the history of Kay’s work on Smalltalk with a focus on the development of the Dynabook. Kay (1996) provides one of the most comprehensive overviews of the history of Smalltalk. It appears that little has been written about the history of Sketchpad. While informative, what has been written has largely traced the history of computer graphics, such as Yares (2013). Additional histories, many of the most instructive for present purposes written by those involved in designing these languages, are cited below.
Smalltalk is especially fruitful as an object of study in this regard, as Kay and his collaborators strove to maintain a philosophical coherence to their language that reflected a complete theory of how computing could be understood. Priestley (2011) notes that many later object-oriented programming languages, such as C++, abandoned the rigorousness of Kay’s work in order to include elements of earlier styles of programming.
In addition to the below discussion of the negotiations and changes surrounding the development of Simula, Sketchpad, and Smalltalk, see for example the changes made to the Java Memory Model in Goetz (2004).
I use the term “real” to describe the material aspects of computation following Kittler’s Lacanian-influenced media-historic materialism (Kittler 1999).
Priestley (2011, 225) suggests that while Algol was not very successful in practical terms, “what changed the face of programming was not simply the Algol 60 language but rather a coherent and comprehensive research program within which the Algol 60 report had the status of a paradigmatic achievement, in the sense defined by the historian of science Thomas Kuhn.”
See, for example, Dean and Ghemawat (2008).
Priestley (2011) argues that Algol was exemplary in attempting to unify a logical and mathematical structure of programming that Smalltalk ultimately broke with. Moreover, there are still major developments in computer science and programming that stress the mathematical nature of programming, for instance, Milner’s (1999) π-calculus or Abadi and Cardelli’s description of an “object-calculus” (1995). Likewise, the growing importance of encryption for computing has relied heavily upon and even pushed the development of number theory. While all of these suggest an intimate relation between programming and mathematics, the development of these languages and the purposeful abandonment of the language of mathematics in Simula and also later in Smalltalk (Priestley, 2011) point to at the very least a conception of programming that moves away from mathematics, even if it could potentially be recuperated.
The mathematical study of the semantics of programming languages functions as a possible “third way” between mathematical and computation practices by attempting to mathematically define the emergent structures of computation based on various programming languages. Moreover, the semantic descriptions of programming languages have then been used to attempt to design future languages. In addition to Milner and Abadi and Cardelli’s work (fn. 8), see White (2004).
Stephen Wolfram is one of the most vocal proponents of this notion of a computational rather than a mathematical universe. For instance, see Wolfram (2002).
Hoare’s presentation at the NATO Vilard-de-Lans Summer School, where Dahl and Nygaard also presented their work on Simula I is available:
C.A.R. Hoare, “Record Handling,” http://archive.computerhistory.org/resources/text/knuth_don_x4100/PDF_index/k-9-pdf/k-9-u2293-Record-Handling-Hoare.pdf
While many of the ideas developed in Simula were aimed at concurrent processing, they were likely abandoned in part because of the difficulty of constructing systems where objects can potentially end up dead-locked, as in the dining philosopher’s problem, waiting for other objects who are waiting on them. Despite the movement away from concurrency and simulation in many object-oriented programming languages, there is a continued interest in the development of concurrent object-oriented programming languages. For a description of some approaches and issues related to concurrency in OOP, see Kafura and Lavender (1993).
Dahl (2004) spells out an example of how this could be implemented.
Ross (1961) even suggests that one can use the control point in a program’s execution as a way of storing information as there are certain parts of the program that can only be reached if certain conditions are true. Thus, in a way, the temporal execution of the program becomes spatialized into a geography of information.
As Priestley (2011) argues, this decision to rely on messages further moved computation away from mathematics as the interpretation of a given message was left up to the object that received it. For example, a number could interpret “+” as mathematical addition, while a string could interpret it as concatenation (1 + 2 would return 3, while “a” + “b” would return “ab”).
Kay discusses this decision in Kay and Ram (2003).
For example, a major element of many object-oriented programming languages is the notion of inheritance, which allows a programmer to specify modified versions of a class. For example, one could define a class for “animal” of which a “cat” would be a subclass, but it would inherit certain properties from the vehicle. Hoare suggested such a model as part of his record classes (see fn. 10), and Simula 67 contained “prefix classes,” which functioned roughly in this manner. While inheritance can greatly ease the amount of work that goes into creating programs, it risks breaking encapsulation (see Bloch 2001, item 14, for a technical explanation of this relationship), in so much as a class, and the objects created from it now rely on code that exists elsewhere. In short, external taxonomies in language (in so much as inheritance creates a taxonomy of classes and subclasses) ultimately reach inside and affect the internal functioning of objects. Thus, through the very demands of writing and language, these objects are pulled outside of themselves, and we see the threat to autonomy and solidity that both define and besiege objects.
References
Abadi, M. and Cardelli L. (1995). An imperative object calculus. TAPSOFT’95: Theory and Practice of Software Development, 469–485.
Abadi, M., & Cardelli, L. (1996). A theory of objects. New York: Springer.
Alt, C. (2011). Objects of our affection: how object orientation made computers a medium. In E. Huhtamo & J. Parrika (Eds.), Media archaeology: approaches, applications, and implications. Oakland: University of California Press.
Barad, K. (2007). Meeting the universe halfway: quantum physics and the entanglement of matter and meaning. Durham: Duke University Press.
Blackwell, A. and Rodden, K. (2003). Preface in Sutherland, (pp. 3–6).
Bloch. (2001). Effective Java. Boston: Addison-Wesley.
Dahl, O. (2004). The birth of object orientation: the Simula Languages in from object-orientation to formal methods, lecture notes in computer science, 2635 of the series Lecture Notes in Computer Science, 15–25
Dean, J., & Ghemawat, S. (2008). MapReduce: simplified data processing on large clusters. Communications of the ACM, 51(1), 107–113.
Derrida, J. (1993). Circumfessions. In G. Bennington, & J. Derrida (Eds.), Jacques Derrida (pp. 3–315). Chicago: University of Chicago Press.
Evens, A. (2006). Object-oriented ontology, or programming’s creative fold. Angelaki: Journal of Theoretical Humanities, 11(1), 89–97.
Galloway, A. (2004). Protocol: how control exists after decentralization. Cambridge: MIT Press.
Galloway, A. (2006). Language wants to be overlooked: on software and ideology. Journal of Visual Culture, 5(3), 315–331.
Galloway, A. (2013). The poverty of philosophy: realism and post-Fordism. Critical Inquiry, 39(2), 347–366.
Goetz, B. (2004). Java theory and practice: fixing the Java memory model, Part 2. IBM. https://www.ibm.com/developerworks/library/j-jtp03304/j-jtp03304-pdf.pdf
Golumbia, D. (2009). The cultural logic of computation. Boston: Harvard University Press.
Harman, G. (2011). On the undermining of objects: grant, Bruno, and radical philosophy. In L. Bryant, N. Srnicek, and G. Harman (Eds.), The speculative turn: continental materialism and realism (pp. 21–40). Victoria: re. Press, 2011.
Hayles, K. (1999). How we became posthuman: virtual bodies in cybernetics, literature, and informatics. Chicago: University of Chicago Press.
Holmevik, J. (1994). Compiling SIMULA: a historical study of technological genesis. IEEE Annals of the History of Computing, 16(4), 25–37.
Kafura, D., & Lavender, G. (1993). Concurrent object-oriented languages and the inheritance anomaly. In M. Quinn (Ed.), Parallel computers: theory and practice (pp. 221–264). New York: McGraw-Hill.
Kay, A. (1996). The early history of Smalltalk in history of programming languages II (pp. 511–598). New York: Association for Computing Machinery.
Kay, A. and Ram, S. (2003). On the meaning of “object-oriented programming.” E-mail exchange. http://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_en. Accessed: 15 December 2015
Kittler, F. (1995). There is no software. CTheory, 10(18), 147–155.
Kittler, F. (1999). Gramophone, film, typewriter. Translated by Winthrop-Young, G. and Wutz, M. Stanford: Stanford University Press.
Krogdahl, S. (2003). The birth of Simula. HiNC 1 (History of Nordic Computing) Conference.
Manovich. (2013). Software takes command. New York: Bloomsbury.
Milner, R. (1999). Communicating and mobile systems: the π-calculus. Cambridge: Cambridge University Press.
Nygaard, K., & Dahl, O. (1978). The development of the SIMULA languages I. ACM SIGPLAN Notices, 13(8), 245–272.
Meillassoux, Q. (2008). After finitude: an essay on the necessity of contingency. Translated by Brassier, R. London: Continuum.
Priestley, M. (2011). A science of operations. New York: Springer.
Robson, D. (1981). Object-oriented software systems. Byte Magazine, 6(8), 74–82.
Ross, D. (1961). A generalized technique for symbol manipulation and numerical calculation. Communications of the ACM, 4(3), 147–150.
Salomon, D. (1993). Assemblers and loaders. West Sussex: Ellis Horwood. Available: http://www.davidsalomon.name/assem.advertis/asl.pdf.
Smith, B. (1996). On the origin of objects. Cambridge: MIT Press.
Sutherland, I. (2003). Sketchpad: a man–machine graphical communication system. Cambridge: University of Cambridge.
Thacker, E. (2004). Foreword: protocol is as protocol does in Galloway, a. protocol: how control exists after decentralization (pp. xi-xxii). Cambridge: MIT Press.
White, G. (2004). The philosophy of computer languages in Floridi, L. The Blackwell Guide to the Philosophy of Computing and Information (237–247). Oxford: Blackwell Publishing.
Wolfram, S. (2002). A new kind of science. Champaign: Wolfram Media.
Yares, E. (2013). 50 years of CAD. Design World, February 13, 2013
Author information
Authors and Affiliations
Corresponding author
Rights and permissions
About this article
Cite this article
Joque, J. The Invention of the Object: Object Orientation and the Philosophical Development of Programming Languages. Philos. Technol. 29, 335–356 (2016). https://doi.org/10.1007/s13347-016-0223-5
Received:
Accepted:
Published:
Issue Date:
DOI: https://doi.org/10.1007/s13347-016-0223-5