The MVC design pattern

-

The Model View Controller Pattern is mainly used for separating the presentation logic from the business model.
This Pattern was first introduced in the Smalltalk way back in the 1970s, since then it has played an important role in most UI Frameworks.

Why MVC?

In Object oriented program, UI, database and other support code often gets written directly into the business object or the domain code (like business rules, policies, database manipulation etc.) and the UI code are coupled together in a single object.

This practice has been followed for one simple reason, it is easier to make things work in the short run.

This is a reasonable approach for quick prototyping and if the program is small in size and there is no plan for further enhancement.

The problem arises when the program grows in size, it becomes more difficult to add/extend new features,

the readability of the code is lost, the developer ends up writing duplicate code and it’s not easy to test the domain logic(in some cases impossible). UI logic tends to change more frequently than that of domain, for example existing views are shuffled around, which cause changes to the domain code as well. Complexity buries you quickly. The Program starts screaming for Separation!

There are many ways to achieve this separation of UI and the Domain code. The MVC is one of the widely used pattern to solve this problem.


How It Works ?

This pattern has below three key elements,


·         Model: The model is responsible to manage the data and behavior of the business domain. This is the place where all the business logic lives. It responds to the request for the information about its state (usually from the view) as well as to the instruction to change the state (usually from the controller).

Also it is responsible to notify if there are any changes to its state, this is done by the model with the help of Observer Pattern. Model shouldn’t have any knowledge about controller and view.


·         View: The view is where all the presentation logic goes, like how to present the information received from the model.


·         Controller: It acts as a glue between the view and the model. In most cases it abstracts away the “Model” from the “View”. Controller shouldn’t have any dependency on view.















In above diagram, notice that the model is notifying the view whenever it changes its state.
Doesn’t it look wrong? One of the motivation to use the MVC pattern is to solve this coupling problem between “View” and “Model”. If the model had to notify the view of changes, you would reintroduce the dependency you were looking to avoid. Here comes the savior the “Observer Pattern”, it has the mechanism to notify the other objects of sate change without introducing the direct dependency on them.

Below figure shows how it all works together,



Creating a program that can handle very complex tasks calls for separation of concerns.
Nonvisual objects are easier to test than that of visual ones. Separating Presentation logic from business objects allows you to test the business logic easily.

Comments

Post a Comment

Popular posts from this blog

Threading in .Net – Part I – The Basics.

-
Image
The Problems with Single Threaded Systems In early days of computers the entire operating system was executed on a single thread. The problem with these kind of systems back then was the long running tasks would prevent the execution of other tasks causing the other applications and OS to stop responding, And if the long running task has some bug in it, or if it goes to an infinite loop then the end user has no choice but to reset the system. This was a common problem for the 16-bit systems, as they were able to access only 1MB of memory. Microsoft knew that 16-bit Windows would not be a good enough operating system to keep Microsoft relevant in the industry, so they created a new OS to address the needs of Corporations and individual. Microsoft designed the new OS (Windows NT), they decided to run each instance of an application in its own Process. A Process is nothing but a collection of resources that is used by a single instance of an application. Each Process in windows has g...
Read more

Writing High Quality Functions

-
Image
Ever wonder how to write clean functions/methods? While searching for the answer you might have come across some metrics, stating your function should not be more than 25 lines of codes or it should not have more than 5 arguments passed to it etc. When it comes to quality, unfortunately such metric are bad indicator to measure the quality of the function. It will just trigger a flag that there is an issue, but it will not tell what the issue is. When writing a high quality function, the first and primary rule is functions should be small, it should only do one thing. Sounds like Single Responsibility Principle? (SRP) yes it is, you can apply SRP not only to class, but to functions as well and this is the only measure you can use to check if the function you have written is of high quality.  FUNCTIONS SHOULD DO ONE THING. THEY SHOULD DO IT WELL. THEY SHOULD DO IT ONLY.                               ...
Read more
-
Image
Domain Driven Design A good code base creates value for the organization and to the client. The better the code reflects the problem domain the more Money it is going to create for the organization. In his book (Domain-Driven Design: Tackling Complexity in the Heart of Software), Eric Evans first introduced the Philosophy of the Domain Driven design (DDD). While the full explanation would take a couple of 500-page books, the essence of DDD is profoundly simple: capture the domain model in domain terms, embed the model in the code, and protect it from corruption. Although let me warn you DDD is not A Silver bullet for every problem It is not the new Shiny/Trendy design pattern it is not a new template in the latest and greatest IDE’s And certainly not some coding standard/guidelines for the rookie software developers. Why one should explore and apply DDD practices? It always feels good when you look at the code which is written by you sometime back, and you are still able...
Read more