Model-view-controller separation of concerns in the code base allowing

Model-view-controller
(MVC) is a web application framework as well as design-pattern and widely used
now when developing a modern, data intensive web application. Most web
application frameworks use the Model-view-controller (MVC) architectural
pattern to separate an application’s logic from its data and presentation. For
a long time this pattern has been a popular choice amongst developers designing
web applications.

The
MVC design architectural pattern promotes cohesion (classes that represent or
define only one type of object) and aims for low coupling (a measure of how
much classes are interrelated). In UI object oriented programming, it is
considered bad practice to mix presentation and data code. Instead, classes
called controllers are defined to mediate communication between presentation
and data classes. These Controller classes decouple the presentation layer and
the data layer classes, consequently allowing them to be defined more
specifically.

We Will Write a Custom Essay Specifically
For You For Only $13.90/page!


order now

Advantages
of high cohesion are said to be reduced module complexity, increased system
maintainability, and increased module reusability. High cohesion creates a
separation of concerns in the code base allowing developer specialization and
focus, and parallel development if working in teams.

Model-View-Controller
(MVC) is typically made up of three classes as mentioned in its name. The
controller is the intermediary class between the model and the view classes. It
control the flow of information by accepting user input from the view, and
instructs both the model and view to perform actions based on that information
as shown in the following figure.

 

 

 

 

 

 

 

 

 

 

 

 

The
model is responsible for the data management routines in the application. These
are commonly create, read, update, and delete (CRUD) database operations. The
view is responsible for presenting the data from the model, and normally
contains mostly mark-up displayed as web pages, for example RSS feeds.

The
MVC web framework appears 2002, the use of the MVC pattern in web application
design became popular after it was introduced in the spring web development
framework for the java programming language. It was then implemented for the
Ruby programming language in 2006 under the name Ruby on Rails, and later as
Django for the Python programming language; ASP.NET MVC for C#; along with
numerous implementations for PHP. These frameworks have evolved/adapted the
original MVC pattern into slightly different versions to better fit their
concept of application design for the web. Regardless of these variations, they
are still commonly known as MVC web development frameworks.

The
benefits of the MVC pattern in web development are Separating code into
categories such as models, views and controllers, allow the developer to
develop specific areas of project functionality. This will then lead to an
easier to manage, more readable code base, when a part of the application needs
to be fixed, tested, or extended. This is commonly known as separation of
concerns, and if one is working as part of a team, it is especially useful for
separating developer workloads as one can have for example, three developers
working on different areas in the same part of the application –the model, the
view, and the controller.

Client
and Server Interaction within Web Application:

Client/server is a program relationship in which one
program (the client) requests a service or resource from another program
(the server). Although the client/server model can be used by
programs within a single computer, it is a more important concept for networking.

The basic architecture of
a Web application is same like simple Client Server architecture and includes
browsers, a network, and a Web server. Browsers request Web pages from the
server. Each page is a mix of content and formatting instructions expressed
with HTML. Some pages include client side scripts that are interpreted by the
browser.

From
the client’s perspective, the Web page is always an HTML formatted document. On
the server, however, a Web page may manifest itself in a number of different
ways. The ultimate result of the client web request processing is an
HTML-formatted stream that is sent back to the requesting client. Business
logic is executed in the system while processing the file. During that time it
has the potential to interact with server side resources such as databases and
middle tier components.

 

Today’s
Web servers have improved upon this basic design. Current Web servers are much
more security aware, and include features like management of client state on
the server, transaction processing integration, remote administration, and
resource pooling. Web page (or the streamed HTML output of that page) on the
client has a completely different behavior and set of relationships. On the
client, a scripted page has relationships with the browser itself (via the
Document Object Model or DOM).

 

The
server side aspect of a Web page can be modeled with one class and the client
side aspect with another. A common relationship between Web pages is the
hyperlink. A hyperlink in a Web application represents a navigational path
through the system. This association always originates from a client page and
points to either a client or server page. Hyperlinks are implemented in the
system as a request for a Web page, which are modeled as components in the
Implementation View. A link association to a client page is essentially equivalent
to a link association to the server page that builds the client page. This is
because a link is actually a request for a page.

 

Client/server
is a computer architecture that divides functions into client (requestor) and
server (provider) subsystems, with standard communication methods (such as
TCP/IP) to facilitate the sharing of information between them. The client and
server can be distinguished from one another by the differences in tasks they
perform. The client and server usually operate on different computer platforms.
Either the client or server may be upgraded without affecting the other.
Clients may connect to one or more servers; servers may connect to multiple
clients concurrently. Clients always initiate the dialogue by requesting a
service.

x

Hi!
I'm Roxanne!

Would you like to get a custom essay? How about receiving a customized one?

Check it out