I found this a very interesting read: http://www.devmaster.net/articles/oo-game-design/
The author repeatedly says "Wow, this could be great, if implemented carefully. This is the future!". Well, not very useful. I need code, and most of all, I need a proof that this kind of design actually works.
Do you know of an example which implements some of the concepts mentioned in this article? Maybe a small open source game one could study? Or, at least, a place where similar concepts are discussed?
Through the wise use of inheritance and over-ridden methods, and thoughtful careful design of the implied base classes
Good design is good, of course, but virtual methods are certainly no panacea, and have a significant performance cost, especially on game consoles.
Reusable in such a way that two entities created oblivious to each other could, utilizing such a development system, work together with NO changes to their code
No. Any given entity in a real game will almost invariably have certain details that tie it to that game. It will depend on certain global render state (lighting conditions, shaders, shader parameters, etc.), and will be intimately tied to the core objects used by the physics system.
This system is currently in a prototype stage, yet it has the capacity to produce mid-range quality games in as little as three months.
A number pulled entirely from the author's nether orifice.
At the very least, such a system can be used to prototype games extremely rapidly, which has its own benefits.
This may be true, but even prototyping in games is challenging. It's impossible to evaluate a rough draft of a game if it's running at half speed. Performance always matters.
In short, he's got some OK ideas in there, but it sure as hell isn't the One True Way to make games. What he describes is a massively decoupled and fine-grained architecture. That sounds nice in principle but will almost invariably lead to poor performance and an unmaintainable soup of tiny classes.