Article: e-SUAP - General software architecture (English)

1. Living Lab
e-SUAP
General Software
Architecture

2. Main objectives
 Designed with the cloud in the mind (but also available on-premise):
 Highly scalable, thanks to rich client implementation and SPA approach;
 Low bandwidth consumption for server round-trips:
 Once Javascript and views are downloaded and cached, only data (with
and without changetracking info) will go over the “wire”;
 Rich full-domain and data-centric API approach, similar to Microsoft .NET- or Java-
based smart clients and server applications;
 RAD development with deep integration with Visual Studio 2013 and Microsoft
TypeScript:
 Silverlight RIA Services-style HTML5 implementation: low bandwidth usage,
highly maintainable code base, etc.;
 Client-side development “experience”, very similar to WPF and Silverlight
implementation; based on MVVM pattern; rich experience for TDD (Test Driven
Development);
 Write once, deploy on many browsers/devices through methodical template mediation
techniques;
 Test driven development in every layer, thanks to rigorous MVVM implementation and
DDD principles:
 From the ubiquitous language description of the application to implement,
straight to the test-driven code and finally the application code;
 Business process-driven layer behind an Enterprise Service Bus, with an anticorruption
layer for high security implementation;
 Highly integrated test cases: enforces continuous integration.

3. Layered Architecture
Domain model, application and business logic, infrastructure, user interface and other layers are
highly isolated. Applications are organized in different domains, modules and layers. Every layer
is highly cohesive and depends only on the lower layers. For the same reason every layer is
highly decoupled from each other layer. Application and business logic is highly isolated from
user interface, application and infrastructure layers. Different domains are bound with service
interfaces and connected through publish and subscribe integration patterns through an
Enterprise Service Bus for major decoupling, scalability and distribution of workloads under
heavy demand:
 Entities and value objects define the state of every single object;
 Domain events flows through the Enterprise Service Bus and reaches consumers
through appropriate ports;
 Services and controllers makes the business logic reachable from the outside world
(with appropriate security concerns and informations every time);
 A modular architecture is provided for every component in its respective layers.
Each module has potentially independent deployment and operation policies and
is loosely coupled with other components in the system;
 Repository patterns decouple the business logic from the persistence and from
external services, through appropriate domain entities:
 Each consumer only see an in-memory collection of all objects and

4. aggregate types;
 Thanks to a global, well-known and extensible IRepository<> interface and
a corresponding unit of work (UOW) generic interface, each domain entity
is automatically addable, removable, searchable through rich criteria
objects (based on LINQ):
 As a direct result, developers can keep application logic strictly
focused on business requirements;
 Factory and Service Locators shift the responsibility for creating complex objects,
aggregates and services to separate objects that are part of the domain design
but have no responsibility in the domain model . Concrete classes and
implementations are not directly referenced, thanks to “opaque” interfaces which
abstract client users from the concrete implementation objects;
 Deep modeling: model-first approach gives the entire architecture a “Supple
design” characteristic. Using the development environment both for coding and
for designing gives developers a clearer perspective of what they are
implementing, by means of simpler refactoring and remodeling tools within the
development environment. The net effect is that 1)Behaviors are more obvious;
2)Cost of changes is reduced; 3)The working environment is more appealing to
software developers;
 Thanks to claim-based security, an orthogonal anti-corruption layer provides
stateless security features that flow with message-oriented datagrams through
several layers to the client, and back.

5. RAD Development
 Behavior and test-driven development: tests are integral parts of the delivered
application and are directly hosted in the development environment;
 Entirely designed with WPF and RIA Services experience in the mind;
 First-class Microsoft TypeScript support;
 Total Entity Framework Experience on the clientside, too;
 Client-side data entities generated through T4 templates directly from full Entity
Framework models:
 Entity Framework has been adopted as ORM, client-side TypeScript full-class
support: inheritance, abstraction, complex types, code-first or model-first
approach; client-side Object Change Tracking implemented directly in the
single-page application client, based on javascript; object identity and entity
graph serialization from and to Web-API layers, thanks to custom .NET <->
TypeScript serializer; JavaScript/TypeScript client-side, out of the box
support for one-to-many, many-to-one, many-to-many relations;

6.  Client-side offline scenarios with full data persistence and change tracking
support;
 Partial class support for data aggregates and UI-oriented value objects, via
serialization surrogates;
 Based on Open Source HOT-Towel template, Durandal, Knockout etc.:
 Fast and powerful user interface implementation, styling, MVVM testing and
many other goodies;
 Full browser- and device-specific HTML5 support;
 Each user interface “use case” is simply a template:
 Thanks to UI component “indirection”, you can switch views to different device
by just changing the template library, without editing the code;
 Rigorous template implementation pattern;
 Reuse of all user interface components, from individual templates up to a complex
views, thanks to Knockout and Durandal open source libraries;
 User interface has its own object model, just like XAML:
 Serialization and deserialization of user interface fragments is made possible by
powerful, custom Javascript reflection and serialization/deserialization
implementation, both part of the foundation classes;
 In browser - runtime user interface designer reads and writes JAML (abbreviation for
JSON Application Markup Language);
 Validation and other features supported through repository based techniques;
 Thanks to deep claim-based security implementation, at any time the security context
of the user who caused a transformation action is made available to the code
executed on the server side.
Business Processes
 Business process entities are defined in a common domain module;
 Proposed solution is not strictly bound to specific Business Process Engine;
 Adopters are free to choose different solutions for long-term business process
implementations;
 A straightforward implementation for Microsoft Biztalk Server is provided out of the box:
 Business Activity Monitoring;
 KPI: BAM projects support integration with MS SQL analysis services. BAM

7. portal furnishes pivot tables and cubes that can also be exported to or
attached from BI tools and can be integrated into Excel with real-time live
visualization of business process activities;
 Graphic IDE and Parties (users) can be handled with Visual Studio and BTS
Administration Console or programmatically, thanks to an Application
Programming Interface (API) that is available out of the box;
 Process components are assemblies that can be stored, distributed and reused
through internal, private and public port modifiers.