To “transform” a monolithic, legacy app into an agile, slender, responsive set of microservices, requires months of evaluation of every subroutine.
While the result of the transformation may be an agile app, the process of getting there is not much different than writing the monolithic app in the first place.
It does not have to be this way.
Fractal is the next step beyond microservices, containers and object-oriented programming. Instead of delivering a collection of microservices, it delivers a collection of small, fully containerized, independent micro apps.
Its disruptive outcomes are possible because the micro apps are freed from the current, legacy underlying tech stack.
Fractal provides a minimalist software stack with persistent storage (database) at the bottom of the stack, distributed processing middleware in the middle of the stack, and GUI widgets at the top of the stack.
The Fractal software stack can run anywhere – from large servers to inexpensive hardware at the network edge. The Fractal software stack minimizes I/O which enables micro apps to run at near silicon speed.
Fractal technology consists of simultaneous innovations in:
- Distributed processing
- Database architecture
- Stream processing
- Object oriented programming
- Microservices architecture
- Full stack development (at macro and micro scale)
- Compiler design
Building micro apps, with Fractal is an entirely different experience from rewriting/recoding a legacy app.
Many legacy apps have evolved into code thorn beds which do not provide what the business or government needs. Many organizations have adapted their business to the constraints of their legacy apps, because the apps do not natively match their desired business processes.
Such monolithic apps are so onerous, so dangerous to change, little if any innovation can take place in their boundaries.
Just think of it: the most important customer-intimate systems cannot be touched without fear of disaster.
Fractal offers a very different alternative.
A Fractal micro app can be developed and delivered at full production scale in a single business quarter.
In Fractal, a single engineer builds a micro app which has the core functionality required for billing, or check processing, or customer care management, or whatever the required business functionality might be.
The micro app is developed as a single node (running on the engineer’s desktop) and then, with the push of a button, is replicated across all nodes in the system and with aggregate access to the full production scale data collection.
Software systems that once took 18 months to 36 months to build with large teams, can now be delivered in a single business quarter, with a few full system developers, at a fraction of the cost.
No one needs to touch or modify the fragile, scary legacy system.
There are now two systems – identical in features – running in parallel.
With two systems running in parallel, you now have two systems independently calculating customer bills, taxes or fees. If the systems agree, there is certainty the bill is correct. If they disagree, you have a flagged a problem BEFORE the customer sees the bill.
A parallel system can also serve as the QA system for new billing or customer care features.
The parallel dystem can run in parallel forever as a QA system – or, after 6 months or a year, with every transaction being tested and reconciled, it can replace the onerous (and expensive!) legacy system.
Fractal Computing frees states, governments and corporations from paying the never ending “budget tax” of Oracle, VMware, and other legacy technologies.