I am looking for a term that I would call ontological evasion (or ontlogical elision if we wish to sound more neutral) but I dont find anything like it in the standard places — IEP/SEP/wikipedia.

The context

This is in the technical computer science (CS) context of semantics of programming languages [Not remotely political!]

The question arises in certain high level languages in the context of semantics of memory. Lower level languages like C explicitly have a concept (ontology) called pointer, dereferencing it yields a piece of memory.

Languages that lay claim to be more high level do not have a concept of pointer but they still need to have (a model for) memory and so the pointer which is simply a pre-reification of memory willy-nilly gets into the meta-level semantics even if its elided in the manual, ie. the object level.

This (looooong) thread on the Python mailing list displays the dispute:

Marko: Everything in Python evaluates to a pointer
Chris: Python has no such thing as pointer

Some further notes

  1. C++ has the situation reified within the language:
    • frank pointers as in C are called, well pointers!
    • elided pointers are called references
    • there are all sorts of others like smart pointers, member pointers etc
  2. So different languages (try to) do these things differently with Python avoiding the ontology and C++ making fine distinctions, and so on. While the question here is not regarding fine CS distinctions, some other nearby generic terms (I can come up with!) are reference, address, handle, descriptor, indirection, alias, link, proxy.
  3. Mentioning the list of alternate terms above because reference and reification — sometimes called first-class in CS — are terms of art in philosophy and are vaguely related to pointer, and dereferencing.

Addendum 1

  1. For those claiming this to be inappropriate to this site since its about programming, here is George Carlin describing evasion without any CS stuff. It comes quite close to what I am looking for except that I want a description for Fine talking of X; avoid talking of Y; even though X-Y are inseparable.
    Also I'd rather stay away from a political flavor
  2. Conversely, for those giving computer-sciency answers, see here. It demonstrates that both memory and pointers are inextricably linked to the issue.
  3. Also this is not specifically about Python. Java, Ruby, Javascript etc., all have the same issue with small variations in terminology.

Addendum 2 — Reformulation

Thanks to the comments below it occured to me I could reforulate the question more positively. Instead of 'trick', 'evasion' etc., lets talk of...

The Jigsaw Effect

  • A completed jigsaw is a completed jigsaw.
  • More significantly, an incomplete jigsaw is not a completed jigsaw, even if one piece of of 200 is removed

Some standard egs from philosophy (no relation of CS!)

The Semiotic Ontology


Saussure offered a 'dyadic' or two-part model of the sign. He defined a sign as being composed of:

  • a 'signifier' (signifiant) - the form which the sign takes; and
  • the 'signified' (signified) - the concept it represents.


For Peirce, then, any instance of signification contains a (1) sign-vehicle, (2) an object and (3) interpretant. This triadic structure... is present in all of Pierce's accounts.

The fact that we talk of Sassurean and Piercean semiotics means they are different!

Essential Christianity

The Nicene Creed runs:

I believe in One God, the Father almight...
I believe in One Lord, Jesus Christ, the Only begotten Son of God,
I believe in the Holy Spirit, the Lord, the giver of life... who has spoken through the prophets...

Now say a person says Christ the Son is enough for me; I dont need Father — I am an atheist — and whoever runs after ghosts, holy or otherwise!

Would he be a Christian in any reasonable sense?


[Tnx to Bumble]

Bumble: ...we can account for language about objects at one level in terms of language about objects at a lower level...
Answer: And we can do that reductionism improperly with category errors eg Saying Everything is {Hydrogen, Helium... Plutonium, Californium} is ok; Saying Everything is {electrons, protons, neutrons} is ok — another level. But what if we say Everything is electrons protons and hydrogen?

This wrong way of building ontologies is what I want a term for.

For now and for this forum we can put aside memory/pointers and CS questions in general


7 Answers 7


This technique is called abstraction in computer science. We say that the programming language implements an abstraction on top of the hardware, and that the abstraction is a higher-level language.

You seem to be equivocating between the abstraction and the implementation. C++ references and Python objects may be implemented in terms of pointers but in terms of the language abstraction they are not pointers. Language values may be implemented by storing a representation of them in computer memory, but the computer memory itself is not part of the language abstraction (at least it is understood at the assembly-language level; C++ does support the notion of chunks of memory that other objects can be implemented in).

When someone says that Python does not have pointers, they are talking about the language abstraction. If they were talking about the implementation--how the language abstraction is realized on hardware--then this would be surprising (not impossible, though). But as far as that goes, even pointers are an abstraction. At the level of assembly language, there are only integers which can be used to index into RAM. But even that is an abstraction. At the machine architecture level, there are only bits laid out in arrays that can be interpreted as integers. But even that is an abstraction. At the logic level there are only gates and other logic circuits. But even that is an abstraction. At the electronics level, there are only transistors and other circuit elements. But even that is an abstraction...

As you can see, pointers are not fundamental part of programming. They are just a convenient abstractions used in some programming languages for some purposes. If a language abstraction doesn't have pointers, then there is probably no value to trying to look under the hood to see pointers underneath.

ADDENDUM: In discussion you cite, Marko seems to be using the word "pointer" when he should be using the word "reference" and this is causing confusion; the two people are talking past each other. A pointer is a first-class language object; a reference is not. A first-class object is something that you can do the usual things on just like integers and strings. There are operators that can be used on them (in non-C languages, you can at least dereference a pointer), you can pass them to functions, and return them from functions just like any other value. There is no dereference operation in Python and although you can describe what Python does as passing and returning references, it doesn't pass and return references in the same sense as it passes and returns integers and strings.

  • 3
    You are giving a CS-ist's answer, Tnx for that — but I want a philosopher's answer. 😀 You can check that I have an expanded version of your penultimate paragraph here a second answer is also relevant. My (CSist) point is that you cant say pointers are non-fundamental and yet say memory is. [V hlls like Haskell actually succeed in throwing out both]. I want this "sleight-of-hand" described in general/generic philosophical terms
    – Rushi
    May 7 at 7:53
  • 2
    Since you use the term abstraction in the CS sense, my response would be Spolsky's law : The abstraction leaks. You will see (if you go through the long thread I referenced) that disputants there are saying exactly what you are: A: The pointer in the underlying implementation is not relevant to the abstraction. B: You cannot talk of the language without it. So it very much is. I'm hoping a philosopher can give me a fallacy of logic/trick of rhetoric etc that describes the argument
    – Rushi
    May 7 at 8:01
  • 3
    I've added an addendum. As to the philosophical issue, there is none. No one is using a trick here; people are just talking past each other. May 7 at 8:45
  • 4
    No trick here Respectfully, I disagree.See for why one cannot understand Python without understanding memory refs. Now you can choose to call reified refs as pointers and unrefied as just refs. But that just amounts to using C++ as a metalanguage to describe. Nothing wrong with that (in a CS context). But in a philosophy context reference is the more reified term. The "trick" is the language spec not bringing in an ontology necessary to understand key features of the language
    – Rushi
    May 7 at 9:43
  • 3
    @Rushi, as to the ontology of computer languages, you might find this interesting: unobtainabol.com/2014/09/… May 7 at 17:41

Languages that lay claim to be more high level do not have a concept of pointer but they still need to have (a model for) memory

I'd agree (with you: I haven't actually dug into the dispute) that, if -say- the Python language spec has "pointers", then there are "pointers" in Python, otherwise there just aren't: and mixing the language spec with the terms of a language implementation, in a dispute as in a language spec, I'd call mixing levels of abstractions, itself maybe an instance of categorical errors.

Along that line, I find incorrect that "high level [languages] still need to have (a model for) memory": the high(er)-level concept exists and is "data".

  • Your point about data is very correct. +1 As Codd outlined, a data model is not properly mathematical (he called it relational) if it didn't meet some desiderata. The eighth rule is about the requirement to be independent of physical representation.
    – Rushi
    May 7 at 13:44
  • As for para 2, I must repectfully disagree. Language designers/implementors happen to be human beings. They can make mistakes (I should know, I'm one of them Because an implementation is itself a program, one category of errors are the usual bugs programmers make. The other category are design errors.
    – Rushi
    May 7 at 13:45
  • If "term" is there in the spec it's there in the language. If it's not it's not. (my paraphrase). My question is fundamentally about this: What if the term is absent but the concept unavoidable?
    – Rushi
    May 7 at 13:51
  • "What if the term is absent but the concept unavoidable?" (IMO) there is no such thing: "leaky abstractions" I think you have called them, and I do think that's all those are. May 7 at 13:55
  • 1
    Well I used to have a smoking gun but I've misplaced it... there was reference to address in version n which disappeared in n + 1. I don't want to go there because it becomes orwellian — newspeak — but we are living in such inflammatory times I'd rather avoid that line 😇. By n large I like to stick to Hanlons razor: They know not...
    – Rushi
    May 7 at 14:13

You state that pointers are references in memory, than all memory can be pointers. Higher level languages claim to not use pointers but that seems impossible because it has to use memory. It can't create anything that references itself outside of itself.

This is called self-deception: one convinces oneself there is no need for references/pointers only to make a claim for a higher level of abstraction.

This IS an ontological argument in itself, using an analogy would make it clearer that it is an ontological claim: Someone wants to believe that there is something outside of reality/existence. So they deceive themselves that references to reality can be made that do not come from reality/existence despite the fact that for something to make a reference it has to exist.

  • This question is about ontology not CS. Please see reformulation at the end of the question
    – Rushi
    May 8 at 7:22
  • @Rushi I'm using your CS example to explain the ontological argument that you are trying to make which I believe is panpsychism. So my answer isn't about CS it's about ontology and I think the example you illustrate takes a panpsychist's stance. May 8 at 7:27
  • @Rushi My phrasing of my answer is wrong. I should have said that if you state that pointers are references in memory, than all memory can be pointers. Higher level languages claim to not use pointers but that seems impossible because it has to use memory. It can't create anything that references itself outside of itself. May 8 at 7:36
  • Um... The last comment is better than your answer
    – Rushi
    May 8 at 7:51
  • @Rushi I agree. You aren't claiming Panpsychism because you don't assume that everything is a pointer simply that everything CAN be a pointer. I think the phrase you are looking for is self-deception. I edited my answer. I hope you find it satisfactory. May 8 at 8:40

There are two good answers so far, but you've asked for a philosophical bent to it. I'd invoke a Nietzsche quote to question your use of ontology:

"Truths are illusions we have forgotten are illusions."

You are arguing that all of these "higher level" concepts like references are things people claim are true, but you see them as illusions, built on top of pointers.

Need I remind you that a pointer is an illusion on top of bytes? In the end, the difference between a pointer and a 32 or 64 bit number is merely that a pointer appears at the root of an indirect memory access opcode like mov (eax), ecx. And those illusions of bytes are really just voltages constructed from conglomerations of charges on small isolates sections of silicon.

Other answers have suggested the word you look for is "abstraction" and I agree. All we are talking about here are patterns which can be implemented in many ways. In the case of references/smart-pointers/etc., one way to implement them is with pointers. But there's no reason to believe that is the only way.

Indeed, if you look at the C++ spec, you will find shared_ptr carefully speaks around some of these topics. It talks of "owning" data, without referring to the underlying ref-counting techniques that are used by basically every implementation in existence.

  • Pls see my reformulation. I can add more details on the CS facet. But I really want to concentrate on the ontology facet
    – Rushi
    May 8 at 7:27
  • You are arguing that all of these "higher level" concepts like references are things people claim are true, but you see them as illusions, built on top of pointers Thats not what I am claiming. I am claiming that pointers (addresses/references/...) and memory are the same level. You can have both or elide both. Pure data in the RDBMS sense is memory reference and location agnostic. See Coods rules
    – Rushi
    May 8 at 7:55
  • The problem with those "higher level" concepts is not that they are illusions, the problem is that they are pointers in disguise. I.e. they function as pointers, they behave as pointers, for all intents and purposes they are pointers, but don't you ever dare to call them pointers! May 8 at 14:27
  • @Rushi In my mind, the high-level meaning of 'pointer' is "something that points". IMO, a FK in a RDMBS is a pointer at that level. In other words, a C-pointer is simply concrete implementation of the high-level concept of 'pointer' just like a 'chef's knife' and a 'putty knife' are both knives even though they are very different in form and use. The problem with 'pointer' here is that people get all Crocodile Dundee about it: "that's not a knife, this is a knife"
    – JimmyJames
    May 8 at 15:26
  • @cmaster-reinstatemonica: What is the difference between a disguise and an illusion?
    – Kevin
    May 8 at 23:31

I feel the example given here is one of semantics rather than anything dealing with ontology. This is true about many debates. It is possible to argue for either side on the example depending on ones definition of pointer. For example wikipedia starts with the definition pointers as:

a pointer is an object in many programming languages that stores a memory address.

I would argue that python does not have such an object. Everyone agrees with the underlying existence of memory to hold data so ontologically there is no disagreement.

The idea of ontological evasion would come about with such things as the existence of god.

Another term would be ontological skepticism.

Addendum: Thinking on this more a local variable b=3 also references memory and I do not consider it a pointers, so I can state: According to my current definition of pointer (similar to wikipedia) python doesn't have pointers.


Isn't "abstraction" the term you are looking for, at least in CS? In programming we hide irrelevant (at some level) information behind an interface so we don't need to think about it.

For example in Java a reference is a "handle" that we can use to refer to a specific variable (array or object), however the Java Programming Language does not specify how it should be implemented. Most Java Virtual Machines (JVMs) implement references using pointers (the numeric address at which the variable is located), however that is not the only possible implementation. The important idea is that the behaviour of your program does not depend on how references are implemented. This is a good thing as it means ensuring the correctness of the program does not depend on irrelevant low-level details, such as how memory is laid out or allocated in hardware.

The discussion of C++ pointers and references etc. contains some statements that are not correct, so I don't think it provides a good example for asking the question.

  • "elided pointers are called references" [from your other comment] Ok I was being a bit fast and loose. Slightly more expanded it would be something like "... C++ references allow the programmer to elide the star (*)... which among other things means it takes care of the fact that «p != NULL and use *p is builtin»"
    – Rushi
    May 16 at 16:42
  • @Rushi that is better, but the point is that references and pointers are not the same thing in C++, avoiding pointer notation is a USE of references, but it isn't the only use and there are other fundamental differences (such as the compiler won't let you create an uninitialised reference, and that references don't have any memory allocated to them) that means they have other uses for which pointers are a poor substitute. May 16 at 16:45
  • Anyways... C++ (and C#) are the examples of better behaved languages. Its Python, Ruby, Java, Javascript etc that are the problem cases, in that the programmer needs to understand the standard linked list diagrams without being given the ontology to understand it. SO if you want to call it an abstraction its a failed (leaky) abstraction
    – Rushi
    May 16 at 16:46
  • @Rushi I disagree, you can teach linked lists in Java perfectly well without pointers. In Java the details are abstracted away but linked list diagrams are still perfectly understandable if you know a reference tells you where to find an object (somewhere). The details of the actual memory address is irrelevant, and not usually shown in the diagram. BTW I was originally an electronic engineer and from a low-level C background, but I now teach Java/C/C++/whatever programming to computer scientists. Some like abstractions, some like to keep it concrete, best if you can do both. May 16 at 16:48
  • I will add clarifications to the question in a bit... but bit tight for time now. Your last statement Some like some dont I can heartily agree with. The rest is a loooooong story and not very appropriate here
    – Rushi
    May 16 at 16:52



a person who denies the existence, truth, or validity of something despite proof or strong evidence that it is real, true, or valid


Psychosis refers to a collection of symptoms that affect the mind, where there has been some loss of contact with reality.

Semantic Discord


Semantic discord is the situation where two parties disagree on the definition of a word(s) that is essential to communicating or formulating the concept(s) being discussed.

I would map the dispute over whether pointers exist or do not exist in some programming context to the category of semantic discord.

  • Denialist... Umm... thats close And yet too strong an emotional/political over/undertone
    – Rushi
    May 16 at 16:57
  • @Rushi One would have to develop a definition of pointer that all parties accept. Then compare that to the structures that exist or do not exist at some layer of abstraction. The resulting disagreements would map to other concepts such as psychosis, denialism, or semantic disagreement, etc. There is no one way to resolve the ontological disputes it is a product of the process of distributed human intelligence (DHI). Humans generate these disputes due to inherent limits of how we each recognize patterns, make efforts to reason, and use language. We use DHI to describe distributed AI or DAI! May 16 at 17:34

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .