Re: Duplicate identifiers in a single namespace

On 10/16/2024 4:00 AM, albert@spenarnc.xs4all.nl wrote:

In article <vdbgch$1ob5k$1@dont-email.me>,
Don Y  <blockedofcourse@foo.invalid> wrote:

How does (e.g., Windows) tolerate/differentiate between
multiple *identical* identifiers in a given namespace/context?
>
And, what *value* to supporting this capability?

>
This is not a Windows question. It is a language question.
C
C is weird. Some identifiers can be declared multiply
as forward. You can have the same name sometimes for
things that are of different type. Not to speak of macro's

As well as within different scopes created by the user.
A scope effectively creates a new namespace.

Pascal
If you declare multiple identifiers in the same namespace
you are hit on the head. You can have nested namespaces
and there is no conflict, the inner namespace counts.

The same applies in C.  But, in each of these cases, the
developer is aware that there *are* different namespaces
even though the same name APPEARS to be used for different
things "on the same piece of paper".

Forth
You can use the same name for multiple objects.
The name last defined counts. You get at most a warning.

It is more abstract than that.
What "(programming) language" do you associate with a file system
hierarchy (the most common/legacy "namespace" in use in computers)?
Why must "/a/file/name" refer to *exactly* one object (note objects
are often not "files" in the strictest sense of the word)?  In a
union mount, there can be two (or more) such "name" objects sourced
from different parts of the filesystem (fore example, "/a/file/name"
and "/another/name") with different schemes using to determine which
object is accessed as "name" in that namespace.
But, if you think about it, why is such disambiguation necessary?
Ignoring computers (as there is nothing special about
"namespaces" that confines them to use *in* computers),
what are the individual names (identifiers) of the 12 eggs
in this carton in my refrigerator?  Or, the drinking
glasses in the cupboard?
I.e., we are perfectly capable of dealing with items that
have non-unique identifiers everyday.  We aren't paralyzed when
confronted with the task of fetching "egg", so, why impose
that constraint on objects?
[In the computer context, the uniqueness is a consequence of
legacy approaches to system designs where there was only one
way to reference an object]