I'm aware that 'class.method' works, but this doesn't give the same proxy feature super does. But in essence, i disagree it's the most correct way to do it. I think it's very likely the most correct *automatic* way of doing it tho. And that's my point, why does it have to be automatic? Also, it doesn't ultimately make sense to order an inheritance tree, as much as it doesn't make sense to order left and right when you're going up and down, that's simply another dimension of your problem. But assuming it make sense (i'm not blind to the sense it makes, i'm just arguing my point), why would this order be the specialisation order? a child is more specialized than it's parent, of course, but one parent is more than the other? why would it be? and i mean, that's not the idea that most people have when they do multiple inheritence, if they think one is more specialized than the other, they make one inherit from the other, they don't set them both as parent of a third. Tho, to make it clear, i've no doubt it's doable without super today. My point is that MRO as it is, has some flaws. Also, Eventual hierarchy where the rule won't fit are simply not allowed today, no matter your use of super. take this one for example : ``` class A(X, Y): pass class B(Y, X): pass class C(A, B): pass ``` This code fails, you can overcome it through composition, but nevertheless, this doesn't justify this problem. Essentially it's a case of "this is broken, but something else close enough isn't". It works, but it's still broken Oh and just to make it more explicit, MRO and super are two different concern of mine here. They could be addressed separately, but since those feature are related, i felt like sharing it in one post