Jitar enables front- and back-end components to live next to each other. This means that IntelliSense is available throughout the whole application. This makes developing and maintaining applications much easier and safer. It also provides the opportunity to use a single application code base for the browser and Node.js.
Jitar is an abbreviation of just-in-time architecture, a flexible architecture style that is a part of Masking Technology’s vision on building future-proof applications. Its intent is to close the gap between front- and back-end and provide a more cost efficient and flexible alternative to the microservice and serverless architecture (function as a service) types. With Jitar, applications can start as a monolith and be broken into smaller distributable pieces. It reduces the need for up-front architectural design and simplifies orchestration and deployment.
When to use
Jitar is a great tool for building applications that are expected to grow and change over time. It can be used for building small to large API driven (web) applications, like:
- Full-stack applications
For existing applications, Jitar can be of great assistance for load balancing (parts) of the application, or adding multi-version support.
How it works
In short, it comes down to this:
- Applications are broken down into components (procedures and objects).
- Components are grouped together in one or multiple segments and stored in a repository.
- Segments are deployed independently to one or multiple nodes (like a microservice, but dynamically composed).
- The Repository provides the actual or remote implementation of components to nodes (depending on their segment).
- Nodes load segments and runs their procedures when called by a client or gateway.
- The gateway keeps track of the available nodes and its components (locator).
The repository plays the biggest role when it comes to splitting applications. It holds the actual and a remote implementation for each segmented procedure. When starting a node, it loads the configured segments from the repository. If one of the segment components depends on (imports) a component from another segment, the repository will provide the remote implementation that calls the procedure using the gateway.
After a node starts successfully it will register itself to the gateway with all loaded procedures. If a procedure gets registered by multiple nodes, the gateway will automatically load balance the calls between them (round robin). When a node goes down it will automatically be unregistered. This means that it’s possible to scale up and down nodes without any downtime.