I have been reading "Clean Code" by Robert Martin to hopefully, become a better programmer.  While none of it so far has been really ground breaking it has made me think differently about the way I design applications and write code.

There is one part of the book that I not only don't agree with, but doesn't make sense to me, specifically in regards to interface naming conventions.  Here's the text, taken directly from the book.  I have bolded the aspect of this I find confusing and would like clarification on.


  I prefer to leave interfaces unadorned. The preceding I, so common in today’s legacy wads, is a distraction at best and too much information at worst. I don’t want my users knowing that I’m handing them an interface.


Perhaps it is because I'm only a student, or maybe because I have never done any professional or team based programming but I would want the user to know it is an interface.  There's a big difference between implementing an interface and extending a class.

So, my question boils down to, "Why should we hide the fact that some part of the code is expecting an interface?"

Edit

In response to an answer:


  If your type is an interface or a class is your business, not the business of someone using your code. So you shouldn't leak details of your code in this thrid party code.


Why should I not "leak" the details of whether a given type is an interface or a class to third-party code?  Isn't it important to the third-party developer using my code to know whether they will be implementing an interface or extending a class?  Are the differences simply not as important as I'm making them out to be in my mind?

If you stop to think about it, you'll see that an interface really isn't semantically much different from an abstract class:


Both have methods and/or properties (behaviour);
Neither should have non-private fields (data);
Neither can be instantiated directly;
Deriving from one means implementing any abstract methods it has, unless the derived type is also abstract.


In fact, the most important distinctions between classes and interfaces are:


Interfaces cannot have private data;
Interface members cannot have access modifiers (all members are "public");
A class can implement multiple interfaces (as opposed to generally being able to inherit from only one base class).


Since the only particularly meaningful distinctions between classes and interfaces revolve around (a) private data and (b) type hierarchy - neither of which make the slightest bit of difference to a caller - it's generally not necessary to know if a type is an interface or a class. You certainly don't need the visual indication.

However, there are certain corner cases to be aware of. In particular, if you're using reflection, interception, dynamic proxies/mixins, bytecode weaving, code generation, or anything that involves messing directly with the environment's typing system or code itself - then it's very helpful and sometimes necessary to know right off the bat whether you're dealing with an interface or a class. You clearly don't want your code to mysteriously fail because you tried to add a class, rather than an interface, as a mixin.

For typical, vanilla, run-of-the-mill business logic code, though, the distinctions between abstract classes and interfaces do not need to be advertised because they'll never come into play.

All of this being said, I tend to prefix my C# interfaces with I anyway because that is the .NET convention used and advocated by Microsoft. And when I'm explaining coding conventions to a new developer, it's far less hassle to just use Microsoft's rules than to explain why we have our own "special" rules.
