Term of art for ontological evasion

Question

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

Compare

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.

with

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?

Reductionism

[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

Answer 1

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.

Answer 2

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".

Answer 3

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.

Answer 4

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.

Answer 5

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.

Answer 6

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.

Answer 7

Denialist

https://www.merriam-webster.com/dictionary/denialist

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

Psychosis

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

Semantic Discord

https://en.wikipedia.org/wiki/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.