An enterprise application is a software which fulfills 4 core quality attributes:
Reliability
Flexibility
Reusability
Maintainability
Reliability is the ability of a system or component to perform its required functions under stated conditions for a specific period of time. Because there are no ways more than testing to make sure a system is reliability, we can exchange the term reliability with the term testability.
Flexibility is the ability of changing a system's core features without violating unrelated features or components. Although flexibility can helps us to achieve interoperability easily but the opposite is not true. For example, a program might run on multiple platforms, contains logic for many scenarios but that wouldn't mean it was flexibility if it forces us rewrite code in all components when we just want to change some aspects of a feature it had.
Reusability is the ability of sharing one or more system's components for another system. We should just open a component's reusability in the context in which it is used. For example, we write classes that implement UI logic and deliver them to only classes which implementing UI.
Maintainability is the ability of adding or removing features to a system after it was released. Maintainability consists of many factors such as readability, analyzability, extensibility therein extensibility is critical. Maintainability requires us to write code that is longer and complexer than normal but it doesn't mean we introduce unneccessarily complex code. We always try to make our code clear and transparent to everyone.
An application enterprise is built on an enterprise design which consists of two parts: low-level design and high-level design.
At low-level design, it focuses on building loose-coupled classes or components. Particularly, it recommends:
Each class or component undertakes only single responsibility (design based on unit test)
Classes or components implement and work through interfaces (design based on contract)
Dependency relationship between classes and components could be injected at run-time (design based on dependency)
At high-level design, it focuses on architecting system into tiers and layers. Particularly, it recommends:
Divide system into subsystems for deployment. Each subsytem is called a tier. Typical, an enterprise application would have 3 tiers as illustrated in the following figure:
Arrange classes and components to logical containers called layers. Typical, an enterprise application would have 5 layers as illustrated in the following figure
