Designing robust system architecture it is critical for the success of the application. All the interconnections between components, their divisions in layers must be the focus of the architecting process.
A short history over the application architectures sounds like this: first there were the standalone applications (if they wanted however to manipulate data, they were doing this by accessing a set of database libraries which let them manipulate local data files, or they actually were databases.); after this, client/server architecture came in the use (the clients performed the business logic, while the databases were used strictly to retrieve data) but as the people started to use more the data base servers in the form of accessing a business logic component, it began familiar for including business logic in databases through writing stored procedures. Then, another architecture model emerged from developing the previous one: three tiers and even n-tier applications model, which will be described bellow. The last model that is in discussion is the Migratory architecture, which will comprise intelligent agents that will process data where and when it is needed, distributed analytics and calculations, and ubiquitous computing devices.
All web-applications are using the n-tier architectures. The characteristics of a web-application involve several familiar parts: a certain number of clients, an application server and a database server. Practically, the client/server architecture is combined with Layered Architecture.
To give a proper definition to the tier term, we should look at it equivalent with a a group of layers, where tiers are commonly physically apart one form each-other. In the dictionary sense, a tier represents "one of a series of rows placed one above another".
The first tire-based model is the two-tier architecture:
1. 2-tier architecture
A two-tiered application is a simple client-server application in which the processing workload falls onto the client computer\'s business and the server simply acts as a traffic controller between the client and the data.
Fig. 5 Two-tier application architecture
The "fat clients" are involved in such a model as they holds all the responsibilities and requirement processing, which is thus at the clients side. The client is responsible for data access, applying business logic, converting the results into a format suitable for display, displaying the desired interface to the user, and accepting user input.
In this architecture, the presentation layer and the business logic layer are hosted in one tier and the data layer is on another tier. This is still typical in small environments applications, with a maximum of fifty users. Starting from hundreds or thousands of users, the system will require another reliable architecture.
The drawbacks of such a model will be observed when the number of clients in the system will increase. So scaling up the number of clients can produce damage to the system as the server becomes overwhelmed because each client makes multiple requests for data to the server increasing the traffic network. Another drawback consists in the way the clients' computers have to be: powerful processing. This is needed because the whole processing is being done at the client side (fat client).
2. 3-tier architecture
To solve the problems resulted from using the 2-tier architecture, another type of architecture was developed, the most popular one which is now used in the most web-applications. This is the 3-tier architecture, which is practically inherited form the previous model, but divided on 3 tiers with specific layers on them.
Fig. 6 Three-tier application architecture
This architecture introduces an "agent" sever between the client side and the server (ex: data base server) which can have different roles like: it can provide translation services (as in adapting an application to a client/server environment), metering services (as in acting as a transaction monitor to limit the number of simultaneous requests to a given server), or intelligent agent services (as in mapping a request to a number of different servers, collecting the results, and returning a single response to the client).
In this case of architecture the client is thin as it has no business logic to be involved with. Another observation is that the tiers can either be on one machine, or spread over the network on different machines.
2.1 Components and connections
The tiers in this architecture can be exemplified as below:
Tier no. Denomination Component Details
1st tier Front end Browser GUI Interface (at the client side)
2nd tier Middle tier Application Server set of application programs
3rd tier Back end Database server storage data
Fig. 7 Table with denomination of tiers and components
As it can be seen from the table above, the first tier in the architecture represents the presentation layer; as a component in the presentation layer, for an E-Learning application, where the clients must connect to the Internet and access the system for entering in the network, the Browser is the one who facilitate the connection to the system services. The requests are made through the browser under the HTTP protocol, the client being waiting for an answer from the server.
As for the second tier, an Application Server is needed, which plays the role of the "agent" which manages the connections between data source and client. Application servers are mainly used in web based applications that have three-Tier architecture.
To give an explicit definition of an Application server this is a server program that resides in the server and provides the business logic for the application. The server can be a part of the network, more precisely the part of the distributed network. Defining next the server program, this is a program that provides its services to the client program that resides either in the same computer or on another computer connected through the network. Examples of application servers are: JBoss (Red Hat), WebSphere (IBM), Oracle Application Server 10g (Oracle Corporation), Sun Java System Application Server (part of the Solaris System), WebLogic (BEA), JOnAS (ObjectWeb); Tomcat (Apache); .NET (Microsoft)
This application server is combined with the We server, to process together the clients' requests. The flow chart of request - response in a three-tier application is represented in the following steps: the client makes a request, the request is send to the Web-server which sends the request to the Application Server; the latest process the request and take appropriate action, maybe calling information from the database; the flow goes back as it came, starting with application server and ending with outputting the information, the response, to the client browser.
Web servers are using diverse technology for forwarding or receiving back the processed information. The most common approaches are: CGI (Common Gateway Interface) -it can be developed in Java, C, C++ and Perl; FastCGI (Improved CGI programming in which each request is not handled as a different process like CGI); ASP (Active Server Pages) - which is a technology developed by Microsoft; JSP (Java Server Pages), Java Servlets - which is a technology developed by Sun and others.
To combine the web module with the application module, one example of server could be Tomcat which provides the opportunity for having a container where web components like JSP and servlets can be put into. This is the server that it is used for developing the STONE project.
A general view of the flow-chart will show as below:
Fig 8 3-tier architecture possible flow chart
3. n-tier architecture
N-tier architecture (with N more than 3) is actually a three-tier architecture in which the middle tier is split up into new tiers. Thus, the application tier is broken down into separate parts and this is done for achieving more flexibility then in the three-tier architecture. Simplistically speaking, the scheme for this kind of architecture can look like below:
Fig 9 N-tier application
An n-tier application could provide separate layers for each of the following services:
o User interface: this handles the user interaction with the application (in a web- application, a web browser performs this, rendering HTML tags.
o Presentation logic: here is defined what the user interface displays and how user requests are handled.
o Business logic: This tier manages the application business logic.
o Infrastructure services: These provide additional functionality required by the application components; possibility of connection and integration with back-end systems
The layered approach for developing software systems architectures is very appropriate in enterprise solutions that have a wide range of scalability. Each tier has a specific role, making easer the application changes.
