Model in 2002, the use of the

Model
view controller (MVC) is a framework for web applications as well as
design-pattern and widely used now when developing a new, data intensive web
application. Mostly web application frameworks use the Model view controller
(MVC) pattern to separate the whole application’s business logic into different
tiers. For a long time this pattern has been a most usable choice amongst
developers designing web applications.

The
MVC design structural pattern supports 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.

The
MVC web framework appears in 2002, the use of the MVC pattern in web
application design became famous 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 after that 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.

a-   
Client
and Server Interaction within Web Application:

Client/server is a program communicates with one program
requests another program. Although the client/server architecture can be
used by programs within a single computer, it is a more important thought
for networking.

The basic model 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 the mixture of content and 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 document. The end
output 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 become better 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 mapped with one class and the client
side aspect with another class. A well-known relationship between web pages is
the hyperlink. A hyperlink in a Web application represents an activity path
through the system. This association always starts from a client page and
points to either a client or server side page. Hyperlinks are implemented in
the system as a request for a web page, which are mapped 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/protocols
(such as TCP over IP) to facilitate the sharing of information between them.
The client and server can be identified from one another by the differences in
tasks they perform. The client and server usually operates 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 start the dialogue by
requesting a service.

 

b-   
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 structure, 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. Consider 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 short comes can be 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 James!

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

Check it out