Two of the main objectives of modern application architecture are to maximize code reusability and to minimize the impact of changes and maintenance.
Over the years, there have been a number of different architectures, such as client/server, three-tier, n-tier, multitiered, model-view-controller (MVC), and rich client to service-oriented (SOA).
Regardless of which of these architectures you select, they all share one common feature: They attempt to separate the application into distinct tiers.
For example, a three-tier design separates the presentation, logic, and data layers:
Each tier is an entity unto itself and has no knowledge of the contents or methodologies of the other tiers. There are published interfaces that allow for communication between tiers.
Theoretically, any tier can be changed or replaced without affecting any of the other tiers in the application.
Assuming that the current presentation layer is a traditional 5250-style interface, the concept of a tiered design means that a new presentation layer (for example, a web interface or a mobile interface) can be introduced without having to make any changes to the logic or data layers.
Although this example is at an application level, the principle can be carried down into each of the tiers, which can themselves be tiered. This principle can be carried down to the programming level, where encapsulation is used to implement a tiered design within the code.
The implementation of a tiered design ensures that changing or adding a tier (at the application or program level) has no affect on the other tiers.
Therefore, the main objectives of maximizing code reusability and minimizing the impact of changes and maintenance are met.
The exact architecture to be used can sometimes be influenced by other factors, such as the ISV tools, programming languages, and frameworks that are being used. Whichever architecture is being used, they all aim to achieve the same tiered principles.