Mantra Development Paradigm
Mantra is based on some software and architecture development principles.
Each one of these principles, have great impact in the desing of a complex system but with them, we got:
- Big projects with a codebase extremely well organized.
- High maintenability.
- Easier evolutions.
- Simpler and incremental migrations.
- Extremely high reused of components.
- The framework which supports the project should be always backward compatible, especially for long-term projects.
These are the base principles:
The system is based on components.
A component is the minimal coding block.
Mantra acts as the glue between them (following microkernel architecture).
Data persistance is transparent based on simple json models.
Data models are extremely simple.
By default, a component can define: APIs, views, blocks, events, templates, middlewares, post and get routes, prerequests and access conditions, cron handlers and commands lines interfaces.
A component can extend the system defining new assets to be used by other components.
High level functionality is achieved with orchestrating functionality from low level components.
Decoupling of components are based on an event-driven design.
A Mantra project is composed by a number of components following Mantra paradigm.
The development paradigm for Mantra applications is based on the following rules:
- Any application is composed by independent coding blocks called components.
- A component should be as small as possible.
- A component defines and registers a number of features (APIs, views, blocks, templates, prerequests, etc.)
- A component implements a small number of consistent and coherent features.
- A component can access funcionality of other components using its exposed API.
- A component can have its own data repository.
- A component can define its own data model.
- The data model of a component should be as small as possible (only a few properties).
- Applications core data models to persist are extremely simple following "simple table designs" principle.
- Very high level functionality is developed orchestrating features of simpler components.
With this paradigm, the maintenability and incremental migration of any application is exponentially simpler.