Model-view-controller from the view, and instructs both the model

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.  Alternative
Approaches to Web Application:There are several options for applications
development and all depends on customer needs and requirement. Alternative
approaches to web application development are build either desktop application
or mobile application with same functionality as provided by web application
for the end user. A standalone/desktop or thick client refers to an
application running on a desktop environment such as windows, Linux or Mac
platforms. The thick client architecture, where the code runs on the client as
well as the processing of data, was once the norm. With the spreading of
internet the thin client model become more popular. The thin client also became
more popular because the standalone applications grew more complex and depended
on third party controls.Everything has some limitations, and that also
includes thick clients. One of the top arguments against thick clients is when
it comes to deployment. Imagine a thousand clients that must be updated. This
is not an easy task and it takes a lot of time to update all clients. Another
problem with a standalone/desktop application is the platform dependency. A
thick client requires a local runtime environment. For example a Windows form
application will only run on a windows platform with the .Net framework
installed. These limitations are overcomes with the ability to work offline. It
is possible for the application to run offline but it can only work with local
data due to the non-existing internet connection.There are some factors of an application that is going to be developed
depends on application performance, security, usability, and implementation.The Web has very rapidly become central to many
applications in diverse areas. As our reliance on Web-based applications
continues to increase and the Web systems supporting these applications become
more complex, there is growing concern about the manner in which the Web-based
systems/applications are created and their quality, integrity and
maintainability. Web performance problem occurs when the web browser request
data from a server that then returns the result, the traffic over the network
can become large. This can lead to congestion which then leads to long transfer
time. And the fact that you get the result from the server means that you
always have to be connected to the internet. Another performance problem lies
on the server. When requesting a page, the server needs to make some
computation. If you have a lot of users making requests at the same time the
server can get heavily loaded.

A thick client provides a lot of functionality which is not possible on
a web application. If we decide to implement a web application we will have to
consider that we will lose some functionality because of the limitations of the
web. The main advantage of a web based solution is that it is centralized. This
has its advantages in easy update and deployment. Another advantage is that a
web application is platform independent.

x

Hi!
I'm Mack!

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

Check it out