OutSystems ARCHITECTURE-SPECIALIST-11 - Questions & Answers

Screens as layouts that have placeholders and load content from blocks. The blocks come from CW modules.

Include the Common flow and Menu artifacts

Put CSS in blocks or screens. Allows better performance and seamless screen transitions

Blocks grouped in functional modules with independent life cycles

CSS should only be placed in the mobile theme module

Enforce the reference architecture.

Avoid error codes.

Normalize patterns.

Reveal the nature of each Module.

Compatibility : Compatibility was also added as a way to ensure that a piece of software can work together with other systems

Security : Security ensure software solutions can protect information and data

Integration : Integration to allow data exchange with other software

Reusable Core Services with public entities, actions, and blocks.

Isolated Business Logic (Actions) or Core Widgets (blocks), to manage complexity, composition or to
have its own lifecycle.

A BL becomes a Calculation Engine if it performs complex calculations, (e.g. an invoice calculation engine or an insurance simulator). Engines are usually subject to versions.

Logic to Synchronize data in CS's with an external system. Isolating this logic makes the CS completely system agnostic and it's easier to decouple or replace the external system.

Technical wrapper to expose an API to External consumers, keeping core services system agnostic and supporting multiple versions of the API.

Specialize a Built-in: Use when introducing changes to an existing theme for multiple apps.
First, create a custom theme that REFERENCE the Base Theme.
Second, clone a Custom Template from the Base Template but this custom theme will reference the
custom theme created previously.
Third, create new applications based on the Custom Theme and Custom Template

Built-in Style Guide: Uses Built-in style guide from Outsystems UI. Minor customizations to the Base Theme should be done inside the App Theme.
Build Your Own: Use when custom style guide cannot benefit from any existing theme.
Just like Clone a Built In scenario, clone both Custom Theme and Custom Template from the Base Theme and Base Template, however clone the Base Theme from Outsystems UI.

Since the theme is very basic, front-end developer will have to expand and design the theme from there.
Modify Built-in Style Guide: Use when only small changes are required for single application.
First, create a custom theme that REFERENCE the Base Theme.
Second, clone a Custom Template from the Base Template but this custom theme will reference the
custom theme created previously.
Third, reference that application to the custom Theme and Template.

Clone a Built-in: Use when introducing extensive changes to existing theme.
First, CLONE a custom theme from a Base Theme.
Second, clone a Custom Template from the Base Template but this custom theme will reference the
custom theme created previously.
Third, create new applications based on the Custom Theme and Custom Template.
Base Theme can be Outsystems UI or your own custom theme.

Having long synchronizations in a single transaction. It provides better UX as the app does not need to sync all the time and is prepared for constant offline mode or device standby.

Ensuring order and sync granularity. Sync incrementally by entity with partial commits. This way, synchronizations are prepared for constant interruptions and allow retries without repeating the entire synchronization from the start.

Monitoring & Logging: Effective monitoring and logging require a centralized service.

Inter-process Communication: Network latency and interruptions.

Complicated Debugging and Troubleshooting: The root cause may be deep within the chain of services.

Security: Requires management of credentials and access control.

Limited data mashup in memory and limited to APIs

Multiple Transactions: Committed independently.

Fault Tolerance: Communication errors and service consistency issues.

All of the above

Foundation

Ochestrator

End-User Layer

Core

Discovery automatically assigns a module to an Architecture Canvas layer, following the module's naming convention.

Discovery only validates architecture rules at the module level.

Discovery allows you to determine for every module, which elements are being consumed by other modules.

Discovery cannot categorise modules to domains

Limit server-side calls to online transactions or Synchronization. Perform the bulk of the operations on the Client Side before passing information to the Server Side.

Synchronize on every screen or online event for better granularity. Avoid direct calls to backend systems. Instead, make calls to OutSystems Core Services, which will handle the interaction with external backend systems.

Direct calls are bad from a security, performance, and maintainability standpoint. Direct calls require JavaScript code, which is harder to maintain.