If you read his examples in his "book" , he actually assigns COM interfaces to object / class variables and then states he doesn't like them.
That's what gets me so angry. He has no clue.
I once again have to start by reminding that the first COM interface example (ref-counted) in my article does not assign interfaces to class variables. So the point you raise was addressed a long time ago. Just check the example in
http://michalis.ii.uni.wroc.pl/~michalis/modern_pascal_introduction/modern_pascal_introduction.html#_ugly_com_interfaces and notice how C1, C2 are only used through IMyInterface.
Only the next section "Using COM interfaces with reference-counting disabled" shows the usage through class references. But there we're deadling with non-ref-counted COM interfaces, and
your own writeup says "A non-refcounted interfaced object should be instantiated through an object (class) variable.".
And I still don't appreciate your tone -- learn to speak without insulting other people, otherwise it's just difficult to discuss.
Reference counted vs non-reference counted interfaces
The information that you can add reference-counting to CORBA interfaces is interesting, thank you. I will change the article to mention it, to make it clear that all interfaces can be ref-counted, just CORBA is by default not ref-counted.
Still, the CORBA interfaces are easier (and safer -- see below) way of achieving interfaces without ref-counting. The COM / CORBA difference is still not as independent from the ref-counted / non-ref-counted decision, like you suggest. The reason:
On COM interfaces, calling _AddRef and _ReleaseRef is not optional (because IUnknown already declares them). They have to be called always, regardless if _Add/ReleaseRef implementation follow the ref-counting concept or remove it.
So even if you turn off the reference counting for COM interfaces, it is
still dangerous to use them through class instances. You need to take special care to never leave any temporary interface variable "hanging" behind when you free the instance. I mentioned it explicitly in the article, with links to
http://freepascal.org/docs-html/ref/refse47.html . That's why the section "Using COM interfaces with reference-counting disabled" says it's not advised.
This is different from CORBA interfaces: you can use them through class instances safely (unless you add reference counting, of course). An extra reference to a non-ref-counted CORBA interface doesn't worry you (just like an extra reference to a class instance through a class variable), as long as it's not explicitly dereferenced in code.
So
if you want non-ref-counted interfaces, it's easier to go with CORBA, than "COM + special _Add/ReleaseRef implementations". That is my point, and I don't see how your writeup changes anything here.
I will change the article to note that you can make the CORBA with reference counting. The rest of the point still stands: if you want to have interfaces similar to what Java/C# offers, then go with CORBA interfaces (and do not add ref-counting).