Software development and runtime environment implementing an advanced architecture-first paradigm.

Arinas Platform aims to provide architects and engineers with a clear and full overview of the software architecture of their solution. It achieves this by organising the programs into a tree hierarchy of module instances.The project began in 2013 with the development of a prototype for a web application implementing this paradigm. After completing various smaller projects, the platform served as the basis for a complex information system for a securities firm. The production phase of this information system took over 6 years and presented an invaluable opportunity for the platform to mature into a solid and useful development tool.
Emerging with more advanced architectural concepts and paradigms, the promising advantage of code or component reuse often clashes with reality, where a pile-up of shortcut solutions effectively hinders the efficient extraction of a component from an existing project to be reused in a similar context somewhere else. The problem is not library components designed for reuse upfront; it is the natural evolution of tailored components designed for a specific use case that can be effectively reused later, even within the same system.Can we impose boundaries on the impact a component will have within the system? And simultaneously, is there a way to organise software so flexibly that we can easily improve its architecture with confidence that the system will remain stable?Could the architecture be actually browsable?
To capture the architecture and organise it in a way which is both simple to review and easy to maintain requires a structure which is neither cyclic nor static. A tree data structure fulfils both conditions and, additionally, represents an ideal way to introduce order and hierarchy.With the design of a highly expressive tree-oriented DSL that facilitates the convenient writing of both program logic and structure, we get unprecedented synergy.


The implementation of the platform began with the idea of designing well-structured, easily maintainable web applications. To address the challenge in this regard in a useful way, you need a couple of obvious components:
web server with an event-loop
configurable request handler
engine executor (program traverser)
tree-based language interpreter
interface to the host tech stack
web-based IDE
The solution highlight is a tree-based domain-specific interpreted language called LeS, which effectively expresses both the logic of the operations and allows for notating and modifying the program structure.Extensible via built-in commands implemented in the host programming language.The LeS language comprises:
control structures
tree context binding
value handling and assignment
exception handling
jump statements
object hierarchy tests and traversal





The entire technology stack for software running on the Arinas Platform is designed to be completely open-source: from the very first line of the operating system kernel to the last line of JavaScript code running in the client browser.The server, configuration loader, request handler, traverser engine, and the LeS language lexer, parser and interpreter are all written in the D programming language.The reasons for this rather niche choice were the multi-paradigm support, system language with native compilation, and the availability of open-source components in its ecosystem.
The current solution already provides multiple key advantages and benefits:
visible and browsable architecture
dynamic code and structure modification
top-down design experience
gradual architecture sanitation for legacy systems
controlled refactoring and impact management
unified representation of data, logic and structure

Architecture that is actually browsable
Over 6 years of stable production in a critical FinTech environment — dynamic changes, full architecture control.
Encountering the brilliant idea of organising the program structure into a tree hierarchy, while simultaneously maintaining orthogonal layering and managing cyclic references reasonably in the architecture, changed my approach to software forever.Returning to conventional object-oriented design was like going back to crawling once you have learned how to walk. I therefore decided to implement this idea in a tech environment that would capitalise on the potential of this concept at the level of abstraction and also deliver top-notch performance.
Although the underlying idea is rather simple, the challenge here lies in a substantially different approach to the modelling of a solution. This approach enables, for example, the use of new design patterns and different testing strategies, introduces a reliable system in chaotic domains, but always demands further exploration, despite the numerous benefits you already gained from it.
Interested in a hands-on demonstration of the paradigm or the Arinas Platform or would you like to leverage this for your project? Contact me.