Guest Column | July 28, 2020

Deliver Apps At 10X The Speed With Locality Of Logic

By Jay Valentine,

speed motion tunnel 450x300

Systems Oriented Programming is the next evolution of microservices and distributed computing. It shortens the development time of enterprise-class applications to a single business quarter.

Systems Oriented Programming enables application designers and implementors to make system-wide optimization for locality – Locality of Reference and Locality of Logic.

Locality of Reference is more commonly recognized. It refers to optimizing a distributed system so that within each running process, the process needs to only access data stored locally. By avoiding network requests in the middle of computation loops – the overall speed of the distributed system can be improved significantly. These performance improvements can be multiple decimal orders of magnitude.

Locality of Logic is a term fewer people are familiar with – however, its impact on app development is significant.

A "typical" non-trivial enterprise application may have a few hundred different relational database tables. These tables, and the interrelationships among them, are a tangle of object encapsulations resulting in complex application code layers.

No human can simultaneously understand hundreds of data tables and the permutations of their interrelationships. Thus, today’s major corporate applications take years to build and are maintenance nightmares.

Locality of Logic, in Systems Oriented Programming, takes a different approach.

Locality of Logic is usually implemented in object encapsulation (object-oriented programming). Here a programmer only needs to understand the inner workings of an object in the code that implements the object. When used as a building block in a larger application, programmers need only understand how the objects work “from the outside” rather than its internal implementation.

Object encapsulation benefits do not translate equally well to the system level.

In Systems Oriented Programming, 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 Systems Oriented Programming, these encapsulations fall from 100's to typically fewer than 10.

The first order result is SIMPLICITY.

Simplicity brings derivative benefits. One is simplified application code.

Systems Oriented Programming dictates application building block functionality/logic is implemented locally in a few schemes that 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.

While Locality of Reference simplifies by reducing I/O thrashing – Locality of Logic requires simple knowledge of a database scheme instead of knowledge of an intractable number of potential interactions among relational data tables.

Optimizing for Locality of Logic presents multiple data and compute models to the application developer. She can use the data model that most “naturally” fits the part of the application the developer is working on.

Needless complexity in traditional enterprise applications comes from forcing app data into a relational data storage model that may not be the most efficient way to represent the data.

When multiple data models easily co-exist, the application code becomes more intuitive, expressive, and smaller. Application logic building blocks can be embedded in the database scheme, not forced into layers built for computation into a database.

Such simplicity delivered by Locality of Logic makes application layer code significantly easier/faster to write. Empirical results show about a 10x time reduction to develop complex applications.

IT departments can deliver apps the user wants rather than apps that force the user to adapt her business to the application’s constraints.

Locality of Reference, which minimizes I/O wait states, can enable each server to do the work of 10 conventional servers.

Locality of Logic, with its simplicity and logic elevated to the system level, can enable each programmer to do the work of 10 conventional programmers who are forced to wade through jungles of hundreds of tables of interaction complexity.

The simultaneous optimization for both Locality of Reference and Locality of Logic can produce a 10-fold increase in resources for corporate IT.

Ten-fold increases in productivity and speed mean digital transformation may finally be a reality instead of a wishful dream.

About The Author

Jay Valentine is the CEO of, bringing disruptive tech products to market without venture capital and the VP of Sales for portfolio company Cloud-Sliver.