No Data Center, No Cloud Required
10x Performance Increase
No Data Center, No Cloud Required
10x Server Performance
Optimizing for Locality of Reference is all about reducing I/O wait states. This optimization occurs at two levels.
System level Optimizing the distributed system so that within each running process, the process needs to only access data that it has stored locally. By avoiding network requests in the middle of computation loops, the overall speed of the distributed system can be improved by multiple decimal orders of magnitude.
Process level Optimizing sequential data access so that pipeline processing/caching is utilized to efficiently move data from:
persistent storage to → RAM, to → layer-2 cache, to → CPU registers
10x Development Speedup
Locality of Logic has existed as a concept for some time. It is usually implemented in the form of object encapsulation (object oriented programming).
The basic idea Is that a programmer only has to understand the inner workings of an object in the code that implements the object. When other programmers use the object as a building block in a larger application, they only have to understand how the objects works “from the outside” and do not need to understand the details of how the object is implemented internally.
Does not translate While this is beneficial at the object level, object encapsulation does not translate equally well to the system level.
Reduce the number of DB schemes In a Fractal Computing™ deployment, both through the software run-time environment "plumbing" as well as design and implementation methodologies that are encouraged/enforced by the programming framework, the design of enterprise class applications is done with a vastly reduced number of database schemes. In Fractal Computing, the number of encapsulations in an enterprise class application fall from 100's to typically fewer than 10 .
App logic is embedded in DB schemes Fractal Computing dictates that application building block functionality/logic is implemented locally in a few schemes in what would be referred to as "stored procedures" in the relational database world. These stored procedures have Locality of Logic; the application logic is co-located with the storage scheme definition and typically requires knowledge of only that scheme or just one or two additional schemes.
Analog to Locality of Reference In much the same way that Locality of Reference improves computation performance by not requiring access to remote data during a calculation – Locality of Logic requires only local knowledge of a database scheme instead of knowledge of an intractable number of potential interactions between relational data tables.
Multi-model Optimizing for Locality of Logic, means that database layer code presents multiple data models and compute models to the application developer. This enables the application developer to use the data model that most “naturally” fits the part of the application the developer is working on.
Eliminating source of complexity A major cause of complexity in traditional enterprise applications, is the convoluted code that forces application data into a (relational) data storage model that may not be the most natural, intuitive, or concise way to represent the data. By making it easy for multiple data models and compute models to co-exist, the application code becomes more intuitive, expressive, and smaller. Building blocks of application logic can be embedded in the database scheme itself instead of having to sit above layers of code that massage the data into a form that is consumable at the application layer.
Development speed The reduction in complexity that results from optimizing for Locality of Logic makes application layer code significantly easier/faster to write. Empirical results show about a 10x reduction in time to develop complex applications.
Fractal Innovation
Wthout Frctal, a computer CPU that is "working" has short burts of activity followed by long periods of waiting (I/O wait states).
The long waiting periods are due to the fact that accessing data from memory, or long term storage devices, is spectacularly slower than processing data in the CPU core.
Fractal Locality Optimization organizes data and constructs software "pipelines" that move data, at the right time, in the rigt sequence, from longer term storage into the CPU core. Data that needs to be accessed together, is kept local to each other ("locality of reference") so that as an application runs, the CPU core accesses data from a cache layer instead of main memory or hard disk.
Fractal Locality Optimization enables orders of magnitude performance increases and a corresponding reduction in hardware requirements for large distributed systems.
Fractal Architecture
AI LLMs (Large Language Models) have been implemented to absorb as much data as possible (ie. everything on the web). Thse "global libraries" are an impressive technical feat, but they miss the mark for real-world business needs.
Business needs are better supported by deeper expertise in specific areas. For example, it's nice that a call center AI agent can quote Shakespeare, but what the business actually needs is simply expertise in the company's products and services.
A Fractal AI architecture enables the construction of collections of "branch libraries" that contain only the knowledge of a specific domain required for specific business needs. These are still non-trivial libraries, but they have orders of magnitude smaller computing requirements and smaller costs.
Architecture Innovation
An ecosystem for enterprise-scale system design, implementation and deployment beyond the cloud.
Fundamental building block Is a "Fractal" which has:
Each Fractal Is a small vertical software stack running in a loosely coupled process that is an independent processing entity in a distributed processing environment. Fractal Computing gives programmers explicit and granular control over sharding and partitioning of the distributed data. Fractals also constructs software data processing/caching pipelines to efficiently move data to the CPU core during run-time processing.
The performance of Fractal Apps™ is due to Locality Optimization™ technology:
Best use cases are enterprise-class applications that support mission critical repetitive business processes. Examples of this are: billing, forecasting, reconcilliation, and other customer care oriented applications.
Empirical results Locality of Reference optimization can reduce I/O wait-states in application layer code by multiple decimal orders of magnitude (compared to a similar legacy application implemented in a relational database). We have customers with production applications that are now running 1,000x to 1,000,000x faster than their legacy application.
Simultaneous innovation Fractal Computing consists of simultaneous innovations in:
Architecture Innovation
An ecosystem for enterprise-scale system design, implementation and deployment.
Fundamental building block is a Fractal. Each Fractal is a small vertical software stack running in a loosely coupled process that is an independent processing entity in a distributed processing environment.
Each Fractal contains the entire application A user, or another application, interacts with a Fractal via web services. The Fractal contains all of the data and code (including all user interface widgets) for the application that the user wishes to run. Each Fractal is a smaller scale version of the overall application.
Billing example if the user is running a billing application, an individual Fractal might be responsible for on the order of about 25,000 customers and all of their associated information. If the user asks the Fractal to "show a list of all customers" the Fractal will respond with a list of 25,000 customers. If the Fractal is running in a Fractal Computing™ ecosystem where it can communicate with all of the other Fractals -- then before the Fractal sends a response back to the user, it broadcasts a message to the other Fractals asking them if they also manage any customers. The Fractal takes all of their responses and folds them into its internal response before sending the final response back to the user. The mechanisms for dissiminating requests out to other Fractals and integrating their results into a core part of Fractal Computing™.
Spreadsheet example If the user wants to build an application with a "spreadsheet" implementation style, each Fractal is responsible for a section of the spreadsheet. Often these type of spreadsheets are organized as multiple "sheets" within the overall spreadsheet. Each Fractal is responsible for it's assigned sheet in the spreadsheet. This Fractal approach to spreadsheet implementation makes is possible to have "infinite" spreadsheets that enable a simple application implementation style (spreadhseet programming) to scale to very large data sets and to utilize massive amounts of parallel processing. Each Fractal manages its iSheet™ sheet in the aggregate spreadsheet in parallel and Fractal Computing provides the programmer with Locality Optimization™ tools to insure parallelism for optimal run-time performance.
Fractal Computing™ peer-to-peer architecture. Each Fractal contains a fully functional application with all of the data and application logic for performing some task. The user experience of interacting with an individual Fractal or the entire network of Fractals is exactly the same -- the result sets are either a fraction of the total data set (when interacting with only a single Fractal) or the entire data set (when interacting with a Fractal that, in turn, is communicating with the other Fractals).
All Fractals are the same A user can attach to any Fractal in the network to initiate a request. Each Fractal is capable of communicating with all of the other Fractals and assembing a complete result for the user. A Fractal Computing architecture enables massive parallel processing, fault-tolerance, and high availability of the overall application since failover and backup logic is also embedded in each Fractal as part of the Fractal Computing ecosystem.
Fractal Computing
Distributed MicroApps
Beyond The Cloud
