Space-Based Architecture (SBA) in Software

Lecture

Space-based architecture ( SBA ) is an approach to distributed computing systems in which the various components interact with each other by exchanging tuples or records through one or more shared spaces. This differs from the more common approach of message queue systems , where the various components interact with each other by exchanging messages through a message broker. In a sense, both approaches exchange messages with some central agent, but the way they exchange those messages is very different.

Space-based architecture diagram

An analogy can be drawn: a message broker is like an academic conference , where each speaker presents on stage in the order set by the schedule; whereas a tuple space is like an informal conference , where all participants can write on a shared whiteboard at the same time and see it.

Tuple spaces
- Each space is like a «channel» in a messaging system that components can interact with as they choose.
- Some components can write a «tuple» or «record» into the space, while other components can read records/tuples from the space, but using more powerful mechanisms than message brokers.
- Writing items into a message space is usually not ordered as it is in a message broker, but it can be ordered if required.
- Developing applications with this approach is less intuitive for most people and can impose a greater cognitive load when evaluating and applying the resulting knowledge.
Message brokers
- Each broker typically supports several «channels» that components can interact with as they choose.
- Some components write messages into a channel, and other components read messages from the channel.
- Messages are usually written into a channel and, as a rule, they are read back in the same order.
- Developing applications with this approach is more intuitive for most people, in much the same way that NoSQL databases are more intuitive than SQL.

The key goal of both approaches is to build loosely coupled systems that minimize configuration, especially the sharing of information about who does what, which leads to improved availability, fault tolerance, scalability, and so on.

More specifically, SBA is a distributed computing architecture designed to achieve linear scalability of stateful, high-performance applications by using the tuple space paradigm. It follows many of the principles of REST ( Representational State Transfer ) architecture, service-oriented architecture (SOA), and event-driven architecture (EDA), as well as elements of distributed computing . In space-based architecture, applications are built from a set of self-sufficient units known as processing units (PUs). These units are independent of one another, so the application can scale by adding new units. The SBA model is closely related to other patterns that have proven effective at solving the application scalability problem, such as the Shared Nothing Architecture (SN) used by Google, Amazon.com, and other well-known companies. This model has also been applied by many firms in the securities industry to implement scalable electronic securities trading applications.

History

Space-based architecture (SBA) was originally invented and developed at Microsoft in 1997–98. Inside Microsoft it was known as the Youkon Distributed Caching platform (YDC). The first major web projects built on it were MSN Live Search (released in September 1999) and, later, the MSN customer marketing data warehouse (a multi-terabyte in-memory database used by all MSN sites), along with a number of other MSN sites released in the late 1990s and early 2000s. See US patents 6,453,404 and 6,449,695: and other patents based on them:

Components of space-based architecture

An application built on space-based architecture principles usually includes the following components:

Processing unit: The unit of scalability and fault tolerance. A processing unit is typically built on top of a POJO (Plain Old Java Object) container, such as the one provided by the Spring framework.
Virtual middleware: A single runtime and clustering model used across the entire middleware stack. The main middleware components in a typical SBA architecture are:

Component	Description
Messaging grid	Handles the flow of incoming transactions and also provides communication between services.
Data grid	Manages data in distributed memory, with the ability to synchronize that data with the underlying database.
Processing grid	A parallel processing component based on the "master/worker" pattern (also known as the "blackboard " pattern), which enables parallel event processing across different services.

POJO-based service model: A lightweight service model that can take any standard Java implementation and turn it into a loosely coupled distributed service. The model is ideally suited for interacting with services running in the same processor.
SLA-driven container: A container driven by service level agreements (SLAs) makes it possible to deploy an application across a dynamic pool of machines in accordance with those service level agreements. SLA definitions include the number of instances that must be running to satisfy the application's scaling and fault tolerance policies, as well as other policies.

Space-Based Architecture (SBA) in Software

History

Components of space-based architecture

See also

Comments

To leave a comment

Lectures and tutorial on "Software and information systems development"

Terms: Software and information systems development