N-tier architectures make for fast processing and easy management

N-tier architectures make for fast processing and easy management

N-tier architectures are the logical evolution of programming design.

At first, monolithic architectures were the only game in town. A huge mainframe computer did all the processing. End users tapped into the mainframe from dumb terminals, so named because they had no processing power. The mainframe had to handle the input-output duties for the terminals in addition to crunching all the numbers.

Once desktop PCs arrived, the client-server programming paradigm became king. The client is an end user's PC; the server is a central store of data and shared programs. The amount of processing handled by the client determines whether it is designated a thin client or a fat client.

Here it is

Thin clients do little besides format and display the application interface. The central server does most of the work, handing off results to the client for display. In a fat-client architecture, the client does more work. Again, a big portion of its job is to format and display the application interface, but it also is responsible for crunching some numbers.

Here's a classic accounting example: figuring out how much the Senate spent last year on laser-printer paper and toner.

In a fat-client application, the server portion of the application retrieves all the appropriate numbers for each senator's office and returns them to the client. The client then adds up the numbers to get a total for the whole Senate and calculates each senator's use as a percentage of the total, perhaps throwing in a chart for good measure. In a thin-client application, all that work takes place on the server; the client only displays a chart.

In an n-tier architecture, the work is split up even further. In addition to a display tier and a server tier, there can be an application server. An application server handles the business logic for an application; it knows the rules for processing the data retrieved from the database.

When you build a Web-based n-tier application, the client tier is simplified even more. Web applications use Web browsers as the client.

The advantage of browsers is that they are merely standards-based rendering engines'they follow agreed-on rules for displaying the interface. Because of this, Web applications are almost always thin-client applications. The exception is when applets are downloaded to a browser, introducing some fat-client processing into the application.

Browsers render whatever they receive from the server, so if you need to change the interface for an application, you need only modify the central application's interface functions. In contrast, updating a classic client-server application for which a programmer wrote a proprietary interface involves going to every desktop PC and loading new software with the new interface instructions.

'Amy Helen Johnson

inside gcn

  • IoT analytics platform

    Modern data analytics for public safety IoT

Reader Comments

Please post your comments here. Comments are moderated, so they may not appear immediately after submitting. We will not post comments that we consider abusive or off-topic.

Please type the letters/numbers you see above

More from 1105 Public Sector Media Group