Chapter 2: Application Layer 4. Describe the four basic functions of an applicat
ID: 3752768 • Letter: C
Question
Chapter 2: Application Layer 4. Describe the four basic functions of an application software package. Using these differences, explain the differences between a host-based architecture and a three-tier client-server architecture. Give examples of each to illustrate the differences. Use an example (e.g., retrieving contents from http://charlottenc.gov/Pages/Home.aspx or http://www.vmlab.edu/test.html) to show how HTTP is used for communication 5. between client and server. Be sure to specify the applications used and explain the concept of the response-request cycle. What are the major parts of HTTP? What parts are required and what parts are optional? What purpose do the optional parts serve? Is HTML a required part of all HTTP messages? The information in the HTTP request header can be useful for a web server for interactive and efficient communications between various web browsers and the web server. Provide an example of how the server can use the information in the HTTP request header. What roles do SMTP and POP play in the sending and receiving of email over the Internet? Use an example (sending and receiving an email using Outlook Express or Mozilla Thunderbird client application and SMTP and POP3 server applications) to discuss the roles. Retrieving emails from a POP server is considered insecure, especially when you are using Wireless LAN (WiFi). Explain why. Then, suggest a solution to this security problem 6. 7. 8. 9. 10, Microsoft SMTP server we used for our Homework #2 does not require authentication (i.e., username and password). What problems would you expect if the server was deployed in real networks (the Internet)?Explanation / Answer
Host-Based Architectures
The specific first information correspondences systems created in the 1960s were have based, with the server (normally a huge centralized computer PC) playing out each of the four capacities. The customers (normally terminals) empowered clients to send and get messages to and from the host PC. The customers simply caught keystrokes, sent them to the server for handling, and acknowledged directions from the server on what to show (Figure 2.1).
This exceptionally basic design regularly works extremely well. Application programming is produced and put away on the one server alongside all information. On the off chance that you've at any point utilized a terminal (or a microcomputer with Telnet programming), you've utilized a host-based application. There is one purpose of control, since all messages move through the one focal server. In principle, there are economies of scale, since all PC assets are unified (yet more on cost later).
There are two major issues with have based systems. Initially, the server must process all messages. As the requests for more system applications develop, numerous servers wind up over-burden and unfit to rapidly process every one of the clients' requests. Organizing clients' entrance winds up troublesome. Reaction time turns out to be slower, and system chiefs are required to spend progressively more cash to redesign the server. Tragically, moves up to the centralized computers that more often than not are the servers in this design are "knotty." That is, overhauls come in extensive augmentations and are costly (e.g., $500,000); it is hard to update "a bit."
Customer Based Architectures
In the late 1980s, there was a blast in the utilization of microcomputers and microcomputer-based LANs. Today, in excess of 90 percent of most associations' aggregate PC handling power currently dwells on microcomputer-based LANs, not in concentrated centralized server PCs. Some portion of this development was filled by various minimal effort, exceedingly well known applications, for example, word processors, spreadsheets, and introduction designs programs. It was likewise energized to a limited extent by supervisors' dissatisfactions with application programming on have centralized computer PCs. Most centralized server programming isn't as simple to use as microcomputer programming, is undeniably costly, and can take a long time to create. In the late 1980s, numerous extensive associations had application advancement excesses of a few years; that is, getting any new centralized server application program composed would take years. New York City, for instance, had a six-year overabundance. Conversely, supervisors could purchase microcomputer bundles or create microcomputer-based applications in a couple of months.
With customer based structures, the customers are microcomputers on a LAN, and the server is typically another microcomputer on a similar system. The application programming on the customer PCs is in charge of the introduction rationale, the application rationale, and the information get to rationale; the server basically stores the information (Figure 2.2).
Host-based design
Figure 2.1 Host-based design
Customer based design
Figure 2.2 Client-based design
This straightforward design frequently works extremely well. In the event that you've at any point utilized a word processor and put away your record document on a server (or composed a program in Visual Basic or C that keeps running on your PC yet stores information on a server), you've utilized a customer based design.
The major issue in customer based systems is that all information on the server must go to the customer for preparing. For instance, assume the client wishes to show a rundown of all workers with organization disaster protection. Every one of the information in the database (or all the files) must go from the server where the database is put away over the system circuit to the customer, which at that point inspects each record to check whether it coordinates the information asked for by the client. This can over-burden the system circuits in light of the fact that significantly more information is transmitted from the server to the customer than the customer very.
Customer Server Architectures
Most associations today are moving to customer server models. Customer server structures endeavor to adjust the preparing between the customer and the server by having both do a portion of the rationale. In these systems, the customer is in charge of the introduction rationale, though the server is in charge of the information get to rationale and information stockpiling. The application rationale may either live on the customer, dwell on the server, or be part between both.
Figure 2.3 demonstrates the least complex case, with the introduction rationale and application rationale on the customer and the information get to rationale and information stockpiling on the server. For this situation, the customer programming acknowledges client asks for and plays out the application rationale that produces database asks for that are transmitted to the server. The server programming acknowledges the database demands, plays out the information get to rationale, and transmits the outcomes to the customer. The customer programming acknowledges the outcomes and presents them to the client. When you utilized a Web program to get pages from a Web server, you utilized a customer server engineering. In like manner, in the event that you've at any point composed a program that utilizations SQL to converse with a database on a server, you've utilized a customer server engineering.
Two-level customer server engineering
Figure 2.3 Two-level customer server engineering
For instance, if the client asks for a rundown of all representatives with organization life coverage, the customer would acknowledge the demand, arrange it so it could be comprehended by the server, and transmit it to the server. On getting the demand, the server scans the database for every single asked for record and after that transmits just the coordinating records to the customer, which would then present them to the client. The same would be valid for database refreshes; the customer acknowledges the demand and sends it to the server. The server forms the refresh and reacts (either tolerating the refresh or clarifying why not) to the customer, which shows it to the client.
One of the qualities of customer server systems is that they empower programming and equipment from various merchants to be utilized together. Yet, this is additionally one of their drawbacks, since it very well may be hard to get programming from various sellers to cooperate. One answer for this issue is middleware, programming that sits between the application programming on the customer and the application programming on the server. Middleware completes two things. To start with, it gives a standard method for imparting that can interpret between programming from various sellers. Numerous middleware devices started as interpretation utilities that empowered messages sent from a particular customer apparatus to be converted into a frame comprehended by a particular server instrument.
The second capacity of middleware is to deal with the message exchange from customers to servers (and the other way around) so customers require not know the particular server that contains the application's information. The application programming on the customer sends all messages to the middleware, which advances them to the right server. The application programming on the customer is along these lines shielded from any adjustments in the physical system. In the event that the system design changes (e.g., another server is included), just the middleware must be refreshed.
There are actually many measures for middleware, every one of which is bolstered by various sellers and every one of which gives diverse capacities. Two of the most essential principles are Distributed Computing Environment (DCE) and Common Object Request Broker Architecture (CORBA). Both of these models cover for all intents and purposes all parts of the customer server engineering yet are very extraordinary. Any customer or server programming that adjusts to one of these measures can speak with whatever other programming that complies with a similar standard. Another vital standard is Open Database Connectivity (ODBC), which gives a standard to information get to rationale.
Two-Tier, Three-Tier, and n-Tier Architectures There are numerous manners by which the application rationale can be apportioned between the customer and the server. The precedent in Figure 2.3 is a standout amongst the most widely recognized. For this situation, the server is in charge of the information and the customer, the application and introduction. This is known as a two-level design, since it utilizes just two arrangements of PCs, one arrangement of customers and one arrangement of servers.
A three-level design utilizes three arrangements of PCs, as appeared in Figure 2.4. For this situation, the product on the customer PC is in charge of introduction rationale, an application server is in charge of the application rationale, and a different database server is in charge of the information get to rationale and information stockpiling.
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.