Networking, Games, and Virtual Environments

I believe every time you use a class you reuse its code. In procedural programming, every time you call a procedure you reuse its code. It's hard to imagine any piece of modern code that does not call any class or procedure, so it's hard to imagine how to write any piece of software without reusing code. Imagine how would you write even a simple program in .Net without reusing Framework Class Library. As even value types in .Net are represented by objects (well, even without boxing, value types in .Net map to IL types which are an abstraction in the sence that they need to be mapped to processor-understandable types prior to execution, and during that process objects are used anyway), you wouldn't actually write any line of compilable code without reusing objects, and logically their code.

Yet it requires effort and thinking to organize your own code in such a way that maximizes its reusage. The higher % of your code is reusable, the more skilful developer you are.

For what it's worth, at one point in time I was squarely in your camp, claiming the same things, as I NEVER saw any real code re-use.

I initially identified what I believed to be the sole reason for this.  After writing something one way, all of the best programmers I know look at the code they produced and immediately know of a better way to do it the next go around.  Thus they all purposely do not re-use anything, as even if they wanted to use "similar" functionality, they would re-write the prior implementation in the better way that they identified at the end of the prior implementation.

But, for as much as I still believe the above is a serious factor in the lack of re-use, I have also come to fully understand what "low coupling" and "high cohesion" really mean with respect to OOP.  Ignoring those two factors, code isn't close to re-usable in the first place.  Taking them into consideration will produce significantly more re-usable code, and thus code that would be re-used.

And if you don't REALLY understand the whole "low coupling" and "high cohesion" deal, then no, from the get go, your OO code will not even be close to re-usable.  FYI, read up on TDD, Inversion of Control, Refactoring, and Patterns just to start for more detailed information.

Strangely enough, in my arena, OOP isn't being used only to promote re-usability.  It is primarily being used from the angle of TDD, in an effort to produce highly testable code.  As one great blogger recently wrote, the utmost characteristic of "great code" is "how testable is it".  IMHO, this is where you should be focusing, not on the re-usability factor.