In addition to separating depending on the services they offer, client-server applications can be distinguished depending on how the application is distributed between the client and the server. The powerful server model gives more functions to the server. The powerful client model gives more functionality to the client. Web servers are examples of powerful servers. Database and file servers are examples of powerful clients.
Powerful clients are the most traditional types of clients-servers. The main body of the application runs on the side of the equation, belonging to the client. At the same time on the file server and the database server, clients know how the information on the server side is organized and stored. They offer flexibility and opportunities to create tools that allow end users to create their own applications.
Applications of powerful VPS servers are easier to manage and deploy on the network because most of the code runs on the servers. Powerful servers try to minimize network exchanges by creating more essential levels of service. “Transaction” servers, for example, compact the database. Instead of extracting unneeded information, they export the processes that handle that information. The client in the powerful client model offers GUI and interacts with the server through Remote Procedure Calls (RPCs).
Each client-server model has its usefulness. In many cases, models complement each other and it is not uncommon for them to coexist in an application. For example, an application could require a server that combines file, database, and transaction servers.
Two-tier (2-layer) and Three-tier (3-layer) client-server architectures
Many times it is preferred to use terms such as 2-tier, 3-tier client-server architectures instead of terms strong clients and powerful servers. But essentially these terms are based on the same basic idea. They have to do with how the client-server application is divided into functional modules, which can then be assigned either to the client or to one or more servers.
Two-tier client-server computing
First-generation client-server applications were generally run with two logical layers. This model often has two layers of material. This is not the case where the client and the server run simultaneously on the same computer.
The two-tier client-server divides the application into two specific parts (the tiers), where a segment runs on the client computer and a separate part runs on the server. It is worth noting that the client and server code does not update, nor does it know if they are running on the same computer or not. Additionally, the application is divided along the client and server.
The amount of application logic that works on the client or server determines whether this is impossible or powerful. The impossible indicates that there is little development of the application and the powerful that a large part of the logic of the application occurs. There are a lot of gradations of weak and strong. Weak client is attractive when the client computer has limited performance. There are no MIPS to handle a GUI, communications and a significant portion of application development.
Two-tier clients-server appears to be more difficult to develop and maintain than normally expected. Two-tier applications don’t scale well. Also, client-server tools took time to develop. Visual Basic, Delphi, and PowerBuilder are specific examples of this type of tool. Most of these tools are on a development path for three-tier support.
