In our last two blog posts, we discussed several powerful tools that help developers avoid technical debt while creating or updating apps. In this post, we’ll take a look at a truly revolutionary tool that gives you a visual overview of technical debt across your entire OutSystems app portfolio. It’s called Architecture Dashboard, and it will change the way you manage your portfolio of applications.
Technical debt accrues when developers bypass certain best practices — for example, creating a dependency between two apps or modules that add time and complexity to future modifications. A glance at the Architecture Dashboard will show software architects, engineers and developers which apps or modules hold technical debt with a simple red (critical), yellow (warning), or green (ready) system.
But as you might imagine, there’s a lot more going on behind the scenes. Here’s a brief overview of how the Architecture Dashboard works and how to use it to zap technical debt at the source.
OutSystems is designed to produce applications with a modular architecture that makes it possible to update one module without affecting any others. This is at the heart of a continuous improvement/continuous deployment (CI/CD) methodology that makes your IT organization extremely agile.
Your team can make changes to any application in response to market shifts or other imperatives quickly and easily. Your team also can work on multiple modules in parallel without interfering in one another’s work — and, thanks to OutSystems TrueChange, which incorporates Visual Merge, multiple developers can even work on the same module at the same time, resolving any coding conflicts with minimum fuss.
Modularity is itself based on enforcing the OutSystems multi-layer application architecture, where data management, business logic, and user interface (UI) exist in distinct layers: data and reusable, non-functional services at the bottom; UI at the top, and business logic processing the traffic between the two.
By segregating an application into layers, developers gain the ability to modify or build a specific layer without having to rework the entire application. In OutSystems, we refer to these layers as foundation, core, and end-user, respectively. Here’s a more detailed breakdown, from bottom to top:
- Foundation layer: In this layer, you implement all reusable non-functional requirements, such as services to connect to external systems, or to extend your framework using libraries of reusable UI patterns, and themes, for example.
- Core layer: You implement your core business services on top of the foundational layer, including those around business concepts, rules, entities, and transactions. These services are system-agnostic and based on the foundation services to abstract any integration detail. Combined, the foundation and core layers isolate all your reusable services or components.
- End-user layer: The top layer is where your user interacts with your application through interfaces and processes using the core and foundation services to support the user journey. To ensure total lifecycle independence, a module on this layer should never provide services to other modules.
Bringing It All Together in the Architecture Dashboard
This is where the (auto)magic happens: The Architecture Dashboard uses OutSystems AIFusion to sort your modules and applications into the three layers depending on function: foundation, core, or end-user. From there, the Dashboard automatically performs code and runtime analysis to reveal solutions for improving the performance, security, architecture, and user experience of applications.
Architecture Dashboard checks each service and application against a set of predefined rules to uncover undesirable code patterns in the following categories:
Redundant code spread across multiple modules in a large application portfolio is a common source of technical debt. Directly tackling this challenge, Architecture Dashboard includes a guided refactoring capability powered by the OutSystems CodeDNA engine to identify all of the opportunities for refactoring and code duplication across the portfolio.
It uses AI to detect, with incredible accuracy, where teams should focus on refactoring and ranks them by importance. The Dashboard uses the following validation rules to evaluate the architecture of your applications:
- No upward references. A service cannot depend on a module in a higher layer.
- No side references among end users. End-user modules must be independent of one another.
- No circular references between the foundation and core layers.
Architecture Dashboard also performs a runtime performance analysis to display the most relevant and urgent cases for improvement, effectively helping address runtime performance issues.
With all your technical debt flagged, it’s easy to drill down to root causes — all the way down to code — right from the Dashboard, so you can apply OutSystems TrueChange and other tools to fix it.
As organizations strive to improve time-to-market and empower non-professional developers (citizen developers) to create business apps themselves, controlling technical debt naturally becomes a top concern.
Architecture Dashboard helps your organization manage technical debt at every stage of the development lifecycle so that when departmental applications evolve to become enterprise-wide solutions, nothing needs to be rewritten. Architecture Dashboard gives your team a bird’s eye view of your organization’s technical debt to identify problem areas and prioritize accordingly. Imagine what your team can achieve with it.
To learn more about the ways in which OutSystems Architecture Dashboard helps your organization eliminate technical debt, visit StopTechDebt.com.