Question

I do not have any argument opposing why we need only a single universal class. However why not we have two universal classes, say an Object and an AntiObject Class.
In nature and in science we find the concept of duality – like Energy & Dark Energy; Male & Female; Plus & Minus; Multiply & Divide; Electrons & Protons; Integration & Derivation; and in set theory. There are so many examples of dualism that it is a philosophy in itself. In programming itself we see Anti-Patterns which helps us to perform work in contrast to how we use Design patterns.
We call it object-oriented programming. Is that a limiting factor or is there something fundamental I am missing in understanding the formation of programming languages?

Edit:
I am not sure, but the usefulness of this duality concept may lie in creating garbage collectors that create AntiObjects that combine with free or loose Objects to destruct themselves, thereby releasing memory. Or may be AntiObjects work along with Objects to create a self-modifying programming language – that allows us to create a safe self modifying code, do evolutionary computing using genetic programming, do hiding of code to prevent reverse engineering.
I’ve moved this question to Computer Science Site of Stack Exchange, as this is considered off-topic here. Please use that if you want to comment/answer this question.

Answer 1

The inheritance tree is commonly (as it is in C#) a tree, with a single root, for a number of reasons, which all seem to lead back to one big one:

• If there were multiple roots, there wouldn’t be a way to specify “any type of object” (aside from something like C++’s void *, which would be hideous as it tosses away any notion of “type”).
• Even the idea of “any type of object” loses some usefulness, as you can no longer guarantee anything about the objects you’ll be accepting. How do you say “all objects have properties a, b, and c” in such a way as to let programs actually use them? You’d need an interface that all of them implement…and then, that interface becomes the root type.
• GC’able languages would be useless if they couldn’t collect every type of object they manage. Oops, there goes that “any type of object” again!

All-around, it’s simpler to have one type be the root of the hierarchy. It lets you make contracts/guarantees/etc that apply to every object in the system, and makes fewer demands on code that wants to be able to deal with objects in a universal manner.

C++ gets away with having multiple root types because (1) C++ allows multiple inheritance, so objects can bridge the gaps between inheritance trees; (2) it has templates (which are far, far more able than generics to take any type of object); (3) it can discard and sidestep any notion of “type” altogether via means like void *; and (4) it doesn’t offer to manage and collect your objects for you.

C# didn’t want all the complexity of multiple inheritance and templates, and it wanted garbage collection.