Classification of client server system

Ans)

there are three types of Client/Server systems in existence.

(i) Two-tier
(ii) Three-tier
(iii) N-Tier

Two-tier Client/Server Model:-

Two tier architectures A two-tier architecture is where a client talks directly to a

server, with no intervening server. It is typically used in small environments(less
than 50 users).
In two tier client/server architectures, the user interface is placed at user's desktop
environment and the database management system services are usually in a server
that is a more powerful machine that provides services to the many clients.
Information processing is split between the user system interface environment and
the database management server environment.

There are several advantages of two-tier systems:

• Availability of well-integrated PC-based tools like, Power Builder, MS Access, 4 GL tools provided
by the RDBMS manufacturer, remote SQL, ODBC.
• Tools are relatively inexpensive.
• Least complicated to implement.
• PC-based tools show Rapid Application Development (RAD) i.e., the application can be developed
in a comparatively short time.
• The 2-tier Client/Server provides much more attractive graphical user interface (GUI) applications
than was possible with earlier technology.
• Architecture maintains a persistent connection between the client and database, thereby
eliminating overhead associated with the opening and closing of connections.
• Faster than three-tier implementation.
• Offers a great deal of flexibility and simplicity in management.
Conversely, a two-tier architecture has some disadvantages:
• As the application development is done on client side, maintenance cost of application, as well as
client side tools etc. is expensive. That is why in 2-tier architecture the client is called ‘fat client’.
• Increased network load: Since actual processing of data takes on the remote client, the data has to
be transported over the network. This leads to the increased network stress.
• Applications are loaded on individual PC i.e. each application is bound to an individual PC. For this
reason, the application logic cannot be reused.
• Due to dynamic business scenario, business processes/logic have to be changed. These changed
processes have to be implemented in all individual PCs. Not only that, the programs have to undergo
quality control to check whether all the programs generate the same result or not.
 • Software distribution procedure is complicated in 2-tier Client/Server model. As all the application
logic is executed on the PCs, all these machine have to be updated in case of a new release. The
procedure is complicated, expensive, prone to errors and time consuming.
• PCs are considered to be weak in terms of security i.e., they are relatively easy to crack.
• Most currently available drivers require that native libraries be loaded on a client machine.
• Load configurations must be maintained for native code if required by the driver.
• Problem areas are encountered upon implementing this architecture on the Internet.

2) Three tier architectures The three tier architecture is introduced to overcome

the drawbacks of the two tier architecture. In the three tier architecture, a
middleware is used between the user system interface client environment and the
database management server environment.
These middleware are implemented in a variety of ways such as transaction
processing monitors, message servers or application servers. The middleware
perform the function of queuing, application execution and database staging. In
addition the middleware adds scheduling and prioritization for work in progress.
The three tier client/server architecture is used to improve performance for large
number of users and also improves flexibility when compared to the two tier
approach.
The drawback of three tier architectures is that the development environment is
more difficult to use than the development of two tier applications.
The widespread use of the term 3-tier architecture also denotes the following
architectures:
• Application sharing between a client, middleware and enterprise server
• Application sharing between a client, application server and enterprise database
server.
i) Three tier with message server. In this architecture, messages are processed
and prioritized asynchronously. Messages have headers that include
priority information, address and identification number. The message server links to
the relational DBMS and other data sources. Messaging systems are alternative for
wireless infrastructures.
ii) Three tier with an application server This architecture allows the main body
of an application to run on a shared host rather than in the user system interface
client environment. The application server shares business logic, computations and a
data retrieval engine. In this architecture applications are more scalable and
installation costs are less on a single server than maintaining each on a desktop
client.
3-tier architecture provides
• A greater degree of flexibility
• Increased security, as security can be defined for each service, and at each level
• Increased performance, as tasks are shared between servers
1.2.3 N-tier Client/Server Model
N-tier computing obliges developer to design components according to a business schema
that represents entities, relationship, activities roles, and rules, thereby enabling them to
distribute functionality across logical and physical tiers, allowing better utilization of
hardware and platform resources, as well as sharing of those resources and the components
that they support to serve several large applications at the same time.
Another aspect of splitting tiers is that application developers and administrators are

able to identify bottlenecks and throw hardware at them to enable load-balancing and fail-
over of certain nodes. The splitting may be between application logic components, security

logic, and presentation logic, computational-intensive and I/O-intensive components and

so on. The most common approach used when designing N-tier system is the three-tier
architecture. Three-tier and N-tier notations are similar, although N-tier architecture
provides finer-grained layers. Architectures often decide to layout much more than three
-tiers to deploy services (An infrastructure that supports three-tier is often made of several
machines and services whose functionalities aren’t part of the three-tier design).