Responsability-Driven Object-Oriented Design is just Easier than MVC !

Object-Oriented Design is just Easier than MVC !

MVC will always lead to code bloat  and this is just a fact.

OOP will always lead to getting designs up and running faster and easier.  Case in point is this project.

Why waste time coding all that Model-View-Controller baggage when all one needs to do is focus on the Objects and their Responsibilities ?!?

Some people love MVC for the sake of MVC !

And this is the worst approach anyone could take with any project !

Loving anything for the sake of is wasteful should not be used.

Every single project is different and every single approach to every single project should be different.

This game is composed of a “wireframe” that has been coded to be a very small handful of Objects and only those objects that are required to make this game functional.  Had this game been coded using MVC I would have had to code 3 sets of objects with a whole lot more code to service the connections between the Model, the View and the Controller.

The OOP Approach takes less time to code

There is a Model.

There is a Controller.

And there is a View to be sure, all 3 must exists for every App.

The OOP approach is simpler than MVC because it requires only the smallest set of objects to be created and maintained. All things being equal the smallest set of objects will be the easier to build and maintain.

The Controller is built into the OOP design.

The Model is built into the OOP design.

The View is built into the OOP design.

Each Object is programmed to perform only those actions for which it has direct responsibility while cooperating with the other Objects.

There is no need for the View to issue messages to the Controller just to talk with the Model when OOP is being used.  There is a Controller and it does talk to the Model to be sure and the Controller does get messages from the View – the difference here is that MVC is built into the Objects rather than MVC being coded as separate objects.  Each Object can have its own MVC working within it and each MVC can communicate with the other Objects that each have their own MVC, as required to make the Application function.

OOP Rocks !

Object-Oriented Responsibility-driven Programming will always produce working code faster than the standard MVC programming model.

Object-Oriented Responsibility-driven Programming makes use of MVC it just does so in a more concise manner.

If you want to save time and money on your projects you might want to consider using Object-Oriented Responsibility-driven Programming rather than straight-up MVC.  When it is my time and money I will always use whatever technique gets me working code faster and at a lower cost than might have been required otherwise and let’s face it folks game programming while being fun and be costly for some to undertake.

Any wireframe can be dressed-up to look like anything the designer wants that wireframe to look like and when you know the tricks of the trade you can quickly and easily do this, as an individual.

From Concept to Game in less than a Week !

Beat that with straight-up MVC, if you can !


About Ray C Horn
See my profile at with more than 1286+ connections and growing all the time.

Comments are closed.

%d bloggers like this: