Web Servers and Internet Applications.Client Server Communication.Goodyear (1999) - Essay Example

Evaluate Web servers and Internet applications Research area: Evaluate client Server communication in terms of services. Introduction Client/server is network architecture that separates a client application that generally deals with end user from a server that does the most work. Each instance of the client software can send requests to a server. Specific types of servers include: application servers, file servers, terminal servers, and mail servers. Their purposes and application may vary, but the basic architecture remains the same. A client is defined as a requester of services and a server is defined as the provider of services. A single machine can be both a client and a server depending on the software configuration. This technology description provides a summary of some common client/server architectures and, for completeness, also summarizes mainframe and file sharing architectures. Detailed descriptions for many of the individual architectures are provided elsewhere in the document. (Fastie 1999) Although this idea is applied in a variety of ways, on many different kinds of applications, the easiest example to visualize is the current use of web pages on the Internet. For example, if someone read a Web page, his computer and web browser is considered a client, and the computers, databases, and applications that make up the Web page are considered the server. History Goodyear (1999) brings following history of evolution of computing solutions: 1960's Batch Processing 1970's Online Transactions 1980's DBMS Integration 1990's Client/Server Architecture 2000's Netcentric The term client/server was first used in the 1980s in reference to personal computers (PCs) on a network. The actual client/server model started gaining acceptance in the late 1980s. The client/server software architecture is a versatile, message-based and modular infrastructure that is intended to improve usability, flexibility, interoperability, and scalability as compared to centralized, mainframe, time sharing computing. In the late 1980s, the actual client/server model started gaining acceptance. The client/server software architecture is a message based, versatile and modular communications that is intended to improve flexibility, usability, interoperability and scalability as compared to centralized, mainframe, time sharing computing. Client/server architecture illustrates the relationship between two computer programs in which one program is a client, which makes a service request to another program called as Server. Server provides service to the request. A single machine can be act as both, a client as well as server depending on the software configuration. Although the client/server architecture can be used within a single computer by programs, but it is a more important idea in a network. In a network, the client/server architecture allows efficient way to interconnect programs that are distributed efficiently across different locations. The common use of client/server model is in Computer transactions. For example, if you have to check a bank account from your computer, you have to send a request to a server program at the bank. That program process the request and forward the request to its own client program that sends a request to a database server at another bank computer to retrieve client balance information. The balance is sent back to the bank data client, which in turn serves it back to your personal computer, which displays the information of balance on your computer. (Jorvekar 2005) Literature Review Goodyear (1999) defines client/server computing as a style of computing that involves multiple processors, one of which is typically a workstation and across which a single business transaction is completed. Also he mentions the term "netcentric", which is actually a shortened version of "network centric". Client/server computing recognized that business users, and not a mainframe, were the real center of a business. Therefore, client/server was also "client-centric" computing. Today the concept of "business users" has expanded greatly, thanks to the linkages made possible by a near-universal network. Today's business computing solutions are network centric or netcentric. Netcentric takes the technological next step. Netcentric is an "evolution of client/server that expands the reach of computing both within and outside the enterprise, and that enables sharing of data and content between induviduals and applications." Goodyear (1999) Sadoski (1997) conciders that client/server architecture apperared as a result of the limitations of file sharing architectures. This approach introduced a database server to replace the file server. Using a relational database management system (DBMS), user queries could be answered directly. The client/server architecture reduced network traffic by providing a query response rather than total file transfer. It improves multi-user updating through a GUI front end to a shared database. In client/server architectures, Remote Procedure Calls (RPCs) or standard query language (SQL) statements are typically used to communicate between the client and server. (Sadoski 1997) Many authors (Sadoski 19997, Fastie 1999, Jorvekar 2005) distinguish following types of client/server architecture: Two tier architectures Three tier architectures. Two tier architectures With two tier client/server architectures, the user system interface is usually located in the user's desktop environment and the database management services are usually in a server that is a more powerful machine that services many clients. Processing management is split between the user system interface environment and the database management server environment. The database management server provides stored procedures and triggers. There are a number of software vendors that provide tools to simplify development of applications for the two tier client/server architecture. (Sadoski 1997) The two tier client/server architecture is a good solution for distributed computing when work groups are defined as a dozen to 100 people interacting on a LAN simultaneously. It does have a number of limitations. When the number of users exceeds 100, performance begins to deteriorate. This limitation is a result of the server maintaining a connection via "keep-alive" messages with each client, even when no work is being done. A second limitation of the two tier architecture is that implementation of processing management services using vendor proprietary database procedures restricts flexibility and choice of DBMS for applications. Finally, current implementations of the two tier architecture provide limited flexibility in moving (repartitioning) program functionality from one server to another without manually regenerating procedural code. (Sadoski 1997) Three tier architectures The three tier architecture (also referred to as the multi-tier architecture) emerged to overcome the limitations of the two tier architecture. In the three tier architecture, a middle tier was added between the user system interface client environment and the database management server environment. There are a variety of ways of implementing this middle tier, such as transaction processing monitors, message servers, or application servers. The middle tier can perform queuing, application execution, and database staging. For example, if the middle tier provides queuing, the client can deliver its request to the middle layer and disengage because the middle tier will access the data and return the answer to the client. In addition the middle layer adds scheduling and prioritization for work in progress. The three tier client/server architecture has been shown to improve performance for groups with a large number of users (in the thousands) and improves flexibility when compared to the two tier approach. Flexibility in partitioning can be a simple as "dragging and dropping" application code modules onto different computers in some three tier architectures. A limitation with three tier architectures is that the development environment is reportedly more difficult to use than the visually-oriented development of two tier applications. Recently, mainframes have found a new use as servers in three tier architectures. (Sadoski 1997) The most basic type of three tier architecture has a middle layer consisting of Transaction Processing (TP) monitor technology (see Transaction Processing Monitor Technology). The TP monitor technology is a type of message queuing, transaction scheduling, and prioritization service where the client connects to the TP monitor (middle tier) instead of the database server. The transaction is accepted by the monitor, which queues it and then takes responsibility for managing it to completion, thus freeing up the client. When the capability is provided by third party middleware vendors it is referred to as "TP Heavy" because it can service thousands of users. When it is embedded in the DBMS (and could be considered a two tier architecture), it is referred to as "TP Lite" because experience has shown performance degradation when over 100 clients are connected. TP monitor technology also provides ability to update multiple different DBMSs in a single transaction connectivity to a variety of data sources including flat files, non-relational DBMS, and the mainframe the ability to attach priorities to transactions robust security. (Sadoski 1997) Using a three tier client/server architecture with TP monitor technology results in an environment that is considerably more scalable than a two tier architecture with direct client to server connection. For systems with thousands of users, TP monitor technology (not embedded in the DBMS) has been reported as one of the most effective solutions. A limitation to TP monitor technology is that the implementation code is usually written in a lower level language (such as COBOL), and not yet widely available in the popular visual toolsets. (Sadoski 1997) Discuss on client server communication Depending the type of client server communication following types of clients may be distinguished: Fat clients Thin clients Hybrid clients (Wikipedia 2006) Fat clients A fat client (also known as a thick client or rich client) is a client that performs the bulk of any data processing operations itself, but does not necessarily rely on the server. The fat client is most common in the form of a personal computer, as the PC or laptops can operate independently. Thin clients A thin client is a minimal sort of client. Thin clients use the resources of the host computer. A thin client's job is generally just to graphically display pictures provided by an application server, which performs the bulk of any required data processing. Hybrid clients A hybrid client is a mixture of the above. Similar to fat client, it is processing locally, but rely on the server for the storage. This relatively new approach offers features from both the fat client (multimedia support, high performance) and the thin client (high manageability, flexibility). (Wikipedia 2006) Critical Review The number of tiers in a client/server application is determined by how tightly or loosely the three program layers are integrated. A one-tier application is one in which the three program layers are tightly connected. In particular, the presentation layer has intimate and detailed knowledge of the database structure. The application layer is often interwoven with both the presentation layer and the services layer. All three layers, including the database engine, almost always run on the same computer. One-tier applications are easy to design and write, especially with today's modern software tools. It's also possible to create a multiuser one-tier application by running the application on several PCs and having them share the database. The database can be stored either on one of the PCs (a peer solution) or on a file server. Note that each PC running the application has its own copy of the database engine; only the data is shared, not the database logic itself. Multiuser one-tier applications are okay until the number of users gets large. The problem is that all the database work is performed in each client. For example, if the program needs to list all clients with the last name of Smith, all the information (indexes and data records) needed to resolve that query to the database must be transferred over the network. For some complex queries, a significant amount of data must be examined, perhaps even the entire database. At a more technical level, it is difficult to manage independent database engines to be sure that no conflict arises when two clients attempt to access or update the same record. This is called the record-locking problem. (Fastie 1999) The solution for the performance and technical problems associated with multiuser one-tier programs is two-tier client/server architecture. This type of application is written in mostly the same way as a one-tier application, with the exception that the database service (engine) no longer runs with the client. Instead, it runs on the server computer that contains the database itself. Some method is used to communicate between the application logic layer and the database service. Today, the method that's most commonly used is the Structured Query Language (SQL), a language that can encapsulate complex database queries in relatively compact sentences. The SQL statement is sent to the database server, which performs the work locally on that physical computer and returns only the relevant information (the answer) to the client PC. Only the database services are separated from the application in a two-tier design. The presentation and business logic layers remain very intertwined, and both continue to have intimate knowledge of the database. (Fastie 1999) Two-tier applications are a bit more complex to write, but most development tools are equipped with a great deal of support in their integrated development environments to facilitate rapid programming. The tools are so good that two-tier programs can be developed almost as quickly as one-tier apps. The only downside is cost. Most tools provide database engines that can handle one-tier designs (such as the Jet engine, used with Access and Visual Basic), but two-tier applications require separate database products such as Oracle, IBM DB2, Sybase, or Microsoft SQL Server. (Fastie 1999) Three-tier client/server applications, as you may have guessed, break all three program layers into independent sections. We have already seen how the database service can run on a different computer. in three-tier designs, the business logic itself becomes a service, and that service can also be run on its own computer. When the business logic becomes a service, it is usually called an application server or simply app server. Quite often, the application server runs on the same physical server hardware as the database. Colocation can sometimes benefit performance, so it is usually a first choice. But a key advantage of having an application server is that it can be located in the best place to serve the need. If you run a business with sales regions, for example; some regions might have many salespeople sharing an app server that's running on a separate physical computer. However, the one salesperson in a remote region might run both the client and the app server on a single PC. No matter how the client and app server are configured, all app servers might receive database services from a centralized computer, perhaps a mainframe. And no matter how the app server is deployed, all users operate the application in exactly the same way from the client. The locations of the app server and the database server are irrelevant to the user. In a three-tier client/server application, the presentation layer usually does not have intimate knowledge of the database. Instead, the presentation layer communicates with its application server using a predifined message strategy. (Fastie 1999) The best way to understand this is to think about the Web. The browser knows absolutely nothing about the structure of the database at Amazon.com, for example, but you are nevertheless able to interact with that database when you order a book. This is the result of well-defined Internet protocols that allow the client (the browser) to talk to an application server (a Web site). (Fastie 1999) Three-tier applications are much more difficult to build than two-tier apps. The biggest obstacle is that the software tools' integrated development environments are not aware of the three-tier model the way they are about the two-tier model. As a result, much more hand-coding is required to write a three-tier application. Three-tier apps are also harder to design, because they are somewhat abstract compared with their more direct two-tier counterparts. Software tool vendors are starting to release new versions that tout three-tier or n-tier development support, but it's not mature development technology just yet. (Fastie 1999) One point of interest is that a two-tier relationship exists between an app server and its database server. In other words, even though the client in a three-tier application doesn't have intimate database knowledge, the app server does. The term "n-tier" is quite in vogue right now. In truth, three tiers are the maximum;"n- tier" refers to the fact that an application server can request services from many other services, and that the services themselves can ask for services as needed to respond properly to the client's original request. The message flows can get pretty complex. (Fastie 1999) Middleware is the term often used to describe the application or business logic present in an app server. Unfortunately, the same term is also used to describe generic services. For example, to communicate, the three tiers may use a messaging system. This is true middleware in the sense that it functions between, or in the middle of, the three tiers. When someone uses the term middleware, be sure you know what specific meaning is intended. (Fastie 1999) When designing and building a three-tier client/server application, most developers make conscious decisions about how much of the business logic to move into the independent app server. A good example of this is input-data validation. Most users like immediate feedback when a datum is invalid. If the app server lives on a different physical computer, there can be a delay before the presentaion layer in the client reports that an entry is invalid. To keep good performance, validation rules often live with the presentation layer in the client. (Fastie 1999) If little or no business logic remains in the client, meaning that it is exclusively a presentation layer, then the client is called thin. If the client has lots of business logic, then it is fat. The best example of a thin client is your Web browser. It is so thin that it can connect to entirely different applications of which it has no knowledge and still provide a suitable user interface. The whole concept of the network computer hinges on building the cheapest, smallest device that will run a Web browser. (Fastie 1999) Conclusion Client/server architecture generally includes server, multiple clients and communication channels between server and clients on hardware and software levels. On software level client/server architecture illustrates the relationship between two computer programs in which one program is a client, which makes a service request to another program called as Server. The client computer program transfers the request to client hardware, then it is transmitted via communication channel and is received on server. Server hardware retreives the request, then server software processes it. Then responses from server to client go the same way. First type of client/server architectures was two tier client/server architecture, where the user system interface is usually located in the user's desktop environment and the database management services was usually in a server that is a more powerful machine that services many clients Then the three tier architecture (also referred to as the multi-tier architecture) emerged to overcome the limitations of the two tier architecture. In the three tier architecture, a middle tier was added between the user system interface client environment and the database management server environment. References Goodyear, Mark (1999). Enterprise System Architectures: Building Client Server and Web Based Systems. Andersen Consulting. ISBN: 0849398363 Fastie, Will (1999). Understanding Client/Server Computing. PC Magazine; "Enterprize Computing;" February 9,1999; page 229-230 Jorwekar, Sandip (2005). Client Server Software Architecture. Retrieved December 2, 2006, from Buzzle.com. http://www.buzzle.com/editorials/2-20-2005-66015.asp Wikipedia (2006). Retrieved December 2, 2006, from http://en.wikipedia.org/wiki/Client_server Read More