Framework-based Typical Architecture
While UI screen is still the focus of the final delivery, Code behind part (Controllers of MVC, or ViewModels of MVVM) are now more advanced. They not only separate behavioral concerns from presentation concerns, but they also provide many values, such as encapsulation of business logic away from UI screens, unit-testable code blocks (Controller or ViewModel is unit-testable), maintainability, and so on.
Advanced Architecture - Deja Vu
This section is not claiming that there is something wrong with the above typical application architectures. Instead, I want to suggest more advanced approach for consideration, only for complex projects that would not feel so comfortable with the above architectures and would look for something even more mature.
This architecture provides all the benefits of the full-fledged applications, such as:
- Layers are separated, so it's possible to focus on business concerns in separation from the UI concerns.
- Business logic is completely unit-testable, and thus can be as stable and reliable as we need.
- Business logic can be extended with new capabilities without affecting the existing UI screens.
- UI layer consists of both code behind (MVC or MVVM) and UI screens, so none of the existing benefits are lost, when comparing to the typical framework-based architectures.
- Finally, UI layer's Controller and ViewModel is not the center of the domain logic anymore; instead, code behind (Controller or ViewModel) just maps domain logic into UI screens; so UI layer has become much easier to maintain and to further extend with less code and less complexity buried into it.
As you can see, nothing extraordinary. Maybe you have even seen such architecture implemented in other platforms, that's why you would call it Deja Vu.