Ask HN: Which CS publication used term “object-oriented” for the first time? | Hacker News Reader

Ask HN: Which CS publication used term “object-oriented” for the first time?

12 pointsRochus19 comments

I'm curious which computer science publication explicitly used the term "object-oriented" for the first time.

So far I didn't find an earlier one than Dan Ingalls' "The Smalltalk-76 Programming System" (https://dl.acm.org/doi/10.1145/512760.512762) published in January 1978, what surprised me.

Remarkably the term is also used in developmental psychology, especially for child development; I found publications about "object-oriented behaviour" from the sixties, e.g. http://www.jstor.org/stable/1126427 from 1966.

Does anyone have earlier CS literature references than 1978?

View on HN

***** FINAL CONCLUSION *****

First of all, I would like to thank everyone here and on Reddit who researched and provided references for their efforts and contributions.

Here is the summary of the findings as they stand today:

1) The term "object-oriented" was known and used throughout the sixties and seventies in various domains, such as developmental psychology, library and information science, and systems engineering.

2) The term was also used in computer science, at least since 1971, e.g. applied to database systems, operating systems, structured exception handling and structured analysis; see e.g. https://archive.org/details/databasesystems0000cour.

3) The term "object-oriented" was applied to a programming language for the first time in the MIT CSG Memo 137 (April 1976) by Anita K. Jones and Barbara H. Liskov; a similar text was published in the IEEE Transactions on Software Engineering later in the year (see see https://ieeexplore.ieee.org/document/1702384).

This is an amazing result and sheds new light on the history of object-oriented programming terminology.

If you want to have a look at the references and discussions yourself, see the comments here and on Reddit: https://old.reddit.com/r/ProgrammingLanguages/comments/156ng....

Not necessarily CS object-oriented, but Aristotle's 'mathematical objects' discussed in Metaphysics demonstrates that the idea has been around for some time. As for CS, a discussion recorded by Randell & Russell in 1961 with Edsger Dijkstra[1] mentions the 'Object Program'.

[1]: http://homepages.cs.ncl.ac.uk/brian.randell/Papers-Articles/....

Thanks. But I really mean "object-oriented", which has a (quite) specific meaning in CS; there are a lot of uses of the term "object" even in CS, with different meanings. The referenced report [1] from 1961, as far as I understand, uses the term "object program" for the output of the Algol compiler, something we call "object file" today; this use of the term seems to have been common in the sixties; e.g. in the book "ALGOL 60 IMPLEMENTATION" (https://dl.acm.org/doi/10.5555/1095699) from 1964 we can read on page 8 "An ALGOL translator is a program which takes as its input the coded representation of an ALGOL source program and produces as its output an object program (which may or may not be in machine code)". Only Simula 67, which is an extension of Algol 60, was object-oriented, but its authors didn't use the term back then.

I'll keep digging, but it seems to have taken off sometime early 60's and further popularised by Kay. Although with 'structured programming' and 'object programs' already in use at the time (different concepts I know, but preceding OOP), the first journal mention may postdate the phrase by some years during this transition.

Both Dahl et al.'s Simula as you mentioned (1968)[1] and J.H. Morris (1968; 9-10)[2] allude to it without explicitly mentioning OO by name, following earlier mentions of atomics by Fox et al. (1960)[3]. If you need something more explicit, I'll try to do some more digging tomorrow in architecture diagrams and lecture notes.

1: https://repository.lib.ncsu.edu/bitstream/handle/1840.4/5681...

2: https://dspace.mit.edu/bitstream/handle/1721.1/149376/MIT-LC...

3: http://history.siam.org/sup/Fox_1960_LISP.pdf

> allude to it without explicitly mentioning OO by name

Right, that's the point; they were talking about classes and objects; the term "inheritance" was not yet used ("prefix" instead), neither the term "object-oriented"; it was a completely new paradigm and the terminology had first to be developed. Kay in his 1993 paper claims that he called his approach, as manifested in Smalltalk-72, "object-oriented". So I would expect publications to use the term after 1972. As I said I found it in Ingall's 1978 (written end of 1977) paper.

Concerning your reference 3 (Lisp) the term "object" is apparently used to refer to atomic symbols; Lisp entered the OO age with Flavors, CommonLoops and CLOS in the eighties.

In Lisp (and similar) sometimes the term object is used, since it's not the variable that's important, but the data object which is returned from a function and which has an identity. A symbol has by definition an entity.

A symbol also has a property list, which is a mutable storage with keys and values.

Since knowledge representation was an early topic, using property lists was not unusual. Then various forms of procedural invocations were tried. For example 'access oriented' style was by invoking functions (if-needed, if-added, if-removed, ...) when a slot was accessed. So-called slot-demons. That lead to frame systems, like FRL from 1977.

Using a property list for key/values :

  CL-USER 21 > 'bladerunner
  BLADERUNNER

  CL-USER 22 > (setf (get 'bladerunner 'is-a) 'movie)
  MOVIE

  CL-USER 23 > (push 'harrison-ford (get 'bladerunner 'actors))
  (HARRISON-FORD)

  CL-USER 24 > (push 'sean-young (get 'bladerunner 'actors))
  (SEAN-YOUNG HARRISON-FORD)

  CL-USER 25 > (push 'rutger-hauer (get 'bladerunner 'actors))
  (RUTGER-HAUER SEAN-YOUNG HARRISON-FORD)

  CL-USER 26 > (symbol-plist 'bladerunner)
  (ACTORS (RUTGER-HAUER SEAN-YOUNG HARRISON-FORD)
   IS-A   MOVIE)

For example "SIR: a computer program for semantic information retrieval" by Bertram Raphael, 1964:

https://dspace.mit.edu/handle/1721.1/6904

Page 45:

"The model in SIR is based largely upon the use of description-lists. A description-list is a sequence of pairs of elements, and the entire list is associated with a particular object. The first element of each pair is the name of an attribute applicable to a class of objects, and the second element of the pair is the value of that attribute for the object described."

There we already see the terms used: OBJECT, CLASS, ATTRIBUTE, VALUE

Then he introduces the "is" set-inclusion relation. There is also a part-whole relationship. And more... 'basic objects' are words.

Later research then added the idea of procedure invocations by various means.

Interesting, thanks.

> A symbol has by definition an entity.

oops. entity -> identity

A direct reference to program closures in relation to 'abstract object languages' can be found on page 92 of Landin (1965)[1].

1: https://dl.acm.org/doi/pdf/10.1145/363744.363749

Landin seems to use the term "abstract object language" for what we would call a "core language" today, which he used to decribe Algol "from first principles"; this is not the same thing as "object-oriented".

True, but the closure concept does appear alongside it. Are you chasing the etymological or conceptual origin of the phrase?

A closure is a separate concept from OO; you can have OO languages with or without closures.

I am looking for the first CS publication that literally used the term "object-oriented". The conceptual origin of OO is well known and documented in CS literature.

Tracing the etymology of the first journal-published use of object-oriented in the context of CS and adjacent fields:

[1]: Page 67 in *Edwards, T. (1970). Library & Information Science Abstracts* mentions: "There are 2 retrieval systems: the first is ALBUM, an object-oriented retrieval system for the print-out of indices, names and subjects and their thematic relations."

https://archive.org/details/sim_library-information-science-...

[2]: Page 140 in *Rustin, R. (1971). Computer Science Symposium Courant 6: Data base systems* mentions: "I feel that there is no inherent antagonism between the relational point of view and the object-oriented network viewpoint in database management."

https://archive.org/details/databasesystems0000cour/mode/2up...

[3]: Series 2 (1963-2001) and Series 3 (1972-2001) of the *Jon L. White collection on Common Lisp at the Computer History museum* contain records of early Lisp developments and object-oriented programming.

https://archive.computerhistory.org/resources/access/text/fi...

[4]: Series 1 (1973-2010) of the *Adele Goldberg papers at the Computer History Museum* contains records related to early SmallTalk development and object-oriented programming.

https://archive.computerhistory.org/resources/access/text/fi...

[5]: Page 4 of *Redell, D. (1974). Naming and Protection in Extended Operating Systems* mentions: "... we can regard the function of the operating system as being the transformation of the basic hardware resources of the computer into a universe of abstract resources or objects, and a set of operations for manipulating those objects. This point of view is often referred to as the object-oriented approach."

https://apps.dtic.mil/sti/tr/pdf/ADA001721.pdf

[6]: A project report by *Eisner, T. (1975). SmallTalk-AT: An Object-Oriented Program development* contains ample mentions of OO.

https://archive.computerhistory.org/resources/access/text/20...

[7]: Table 1 of *Goodenough, J. B. (1975). Structured Exception Handling* contains two mentions of OO.

https://dl.acm.org/doi/pdf/10.1145/512976.512997

[8]: Lastly, page 2 of *Capretz, L. F. (2003). A Brief History of the Object-Oriented Approach* mentions how the object-oriented paradigm amalgamated from some of the earlier references we discussed: "Despite the early innovation of Simula, the term object-oriented became prominent from Smalltalk."

https://ir.lib.uwo.ca/cgi/viewcontent.cgi?article=1047&conte...

I would say the term floated around for a while before some of the explicit mentions above, especially if we include fields as philosophy, psychology and linguistics. I will report back if I come across earlier mentions.

Wow, what an effort, thank you very much.

Ref [1] is not computer science, but demonstrates the early use of the term in yet another discipline.

Ref [2] is definitely a hit; it's a text by Robert J. Bobrow about an experimental database system, published in 1972.

Refs [3] and [4] are documents collected by White and Goldberg, as far as I understand, not really publications; Goldberg started to publish in 1977, White in 1982.

Ref [5] is again a hit; it's a documented use of the term in a published MIT report from 1974 about operating systems.

Ref [6] seems to have been published much later; if you look at the bibliography on page 19 there are references from 1987.

Ref [7] is again a hit; it's a paper published at the POPL 1975 conference about structured exception handling.

Ref [8] is an interesting paper, but from 2003

*** Interim conclusion:

With reference [2] we have the earliest documented use of the term "object-oriented" in a CS publication; it's in a book about a symposium which happened in May 1971. The first ever Smalltalk was conceived in the same year.

The first use of the term related to an object-oriented programming language seems to be in MIT CSG Memo 137 by Jones and Liskov in 1976, as found by a fellow on Reddit (see https://old.reddit.com/r/ProgrammingLanguages/comments/156ng...).

Not a problem, happy to help:) I've also been skimming some MIT and DARPA memos, barring explicit mentions.

Re: [1] we can infer that earlier references may exist (seeing how they discuss an existing system), even though 'object-oriented' may have connoted something different at the time.

Re: [5] similarly implies the term had been in use among CS-practitioners between '70 and '74.

I also want to add that the '...-oriented' affix was frequently used in the 60's. For instance, 'task-oriented', 'problem-oriented', 'business-oriented', 'simulation-oriented'.[1][2] It stands to reason that 'object-oriented' would have been part of CS-parlance at the time, seeing how LISP and MACLISP implemented early 'objects'.

[1] R. F. Clippinger (1962). COBOL, The Computer Journal, Volume 5, Issue 3, November 1962, Pages 177–180, https://doi.org/10.1093/comjnl/5.3.177.

[2]: Knuth, D. E., & McNeley, J. L. (1964). A formal definition of SOL. IEEE transactions on electronic computers, (4), 409-414: "Within a given process it is possible to have several actions going on at once; therefore, we may think of several objects on which the action takes place each in its own place in the process at any given time" (p. 409).

> that the '...-oriented' affix was frequently used in the 60's.

That's actually what also IEEE stated on their Simula Milestone, see https://ethw.org/Milestones:Object-Oriented_Programming,_196... section "Features that set this work apart from similar achievements", which says:

"For instance, terminology involving "objects", "oriented", and "instance" first appeared at MIT in the late 1950s and early 1960s..."

Seven more, one from the illusive Management Information Systems Handbook (1968): "The consideration of object oriented grouping, i.e. product or customer oriented, will lead to a consolidated file in which practically any element is stored only once" (p. 24)[1].

One near hit in a report from RAND Corp (1969), mentioning the "block-structure/procedure orientation of SIMULA" (p. 13)[2].

A really old one, comparing programming language characteristics (1961, p. 337)[3]: "The group also decided that the following language classification methods are relevant:

- Object, descriptive, command, and mixed languages;

- Languages with stratified and unstratified control;

- Sequential and simultaneous communication languages;

- Problem oriented (behavioral) and machine oriented (structural) languages"

Ref [3] also contains a nice comparison table.

Another compares simulation languages of the time, and from eyeing the tables it seems 'object simulation' may have been the ancestral term (1966): "The basic use of a record is to describe an object in the simulated world. The data in the fields of a record describe the 'properties' of the object. The record and its fields are usually given names or identifications; it is conventional to use names which are mnemonics for the object being represented." (p. 729)[4]

Ref [4]'s language comparison tables are also useful here (p. 730-733).

The next talks about objects in a now familiar way (1967): "We do this by defining the objects that 'live' in the system and assigning attributes to them." (p. 32)[5]

The 'object simulation' ancestry is further supported by the following quote from (1963): "Dynamic representation of an object system. A simulation model of an object system is itself a system whose behavior may be interpreted according to a rule which renders a description appropriate to the behavior of the object system." (p. 2)[6]

More evidence for this from (1964): "The system to be simulated may be regarded as a set of actions which manipulate a set of objects." (p. 328)[7]

[1]: The Archive.org entry says 1969 but the book preface dates 1968. *Hartman, W., Matthes, H., & Proeme, A. (1968). Management Information Systems Handbook: Analysis, Requirements Determination, Design and Development, Implementation and Evaluation (MIS: ARDI). McGraw Hill Text.*

https://archive.org/details/managementinform00hart/page/n565...

[2]: *Kiviat, P. J., & Rand Corporation. (1969). Digital computer simulation: Computer programming languages (p. 0109). Santa Monica, CA: Rand Corporation.*

https://apps.dtic.mil/sti/tr/pdf/AD0684124.pdf

[3]: *Gorn, S. (1961). Some basic terminology connected with mechanical languages and their processors: a tentative base terminology presented to asa x3. 4 as a proposal for subsequent inclusion in a glossary. Communications of the ACM, 4(8), 336-339.*

https://dl.acm.org/doi/pdf/10.1145/366678.366682

[4]: *Teichroew, D., & Lubin, J. F. (1966). Computer simulation—discussion of the technique and comparison of languages. Communications of the ACM, 9(10), 723-741.*

https://dl.acm.org/doi/pdf/10.1145/365844.365851

[5] *Kiviat, P. J. (1967). Digital computer simulation: Modeling concepts. Santa Monica, Califorinia: Rand Corporation.*

https://apps.dtic.mil/sti/pdfs/AD0658429.pdf

[6]: *Lackner, M. R. (1963). The dependency of a simulation language on a theory of systems. System Development Corporation.*

https://apps.dtic.mil/sti/pdfs/AD0296590.pdf

[7]: *Williams, J. W. J. (1964). ESP The Elliott Simulator Package. Comput. J., 6(4), 328-331.*

https://academic.oup.com/comjnl/article/6/4/328/375742

Thanks again for your effort.

I had a look at all references, but still consider Robert J. Bobrow's 1971 text the first use of the term "object-oriented" in a CS publication.

Ref [1] looks like yet an earlier hit, but the book is about systems engineering and management, not computer science; though I did only have access to a few pages of the book, so it could be a borderline case; the PREFACE says, that "Volume 6 comprises a collection of authoritative papers on techniques and standards specific to systems engineering, or on [...] organization therory, psychology, operations research and mathematics". Your hit apparently is in Volume 6.

Ref [2] is not a hit from my point of view; it uses the terms "object" and "class", which was the official terminology of Simula 67 at that time. The use of "block-structure/procedure orientation" looks like an early attemtpt for a term to differentiate Simula from the other contenders, but it's definitely not related with the term "object-oriented".

Refs [3] to [7] document the early use of the term "object" in computer sciences, but not "object-oriented".

So I think we can conclude the search in the sixties, and in any case you deserve credit for finding the earliest use of the term in 1971. I will next focus on the earliest use of the term for a programming language, which so far seems to be - as already mentioned - the 1976 MIT CSG Memo 137 by Jones and Liskov; I will check other publications by Liskov from that time.

Reply on news.ycombinator.com