architectural scalability distributed systems

Shared-Nothing

Reference Wikipedia ↗

The Shared-Nothing architecture is a distributed computing architecture where each node in the system has its own dedicated resources – CPU, memory, and disk – and does not share these resources with any other node. Nodes communicate with each other via a network, typically using message passing. This contrasts with shared-disk or shared-memory architectures where multiple nodes access the same storage or memory.

This pattern is crucial for building highly scalable and fault-tolerant systems. By eliminating resource contention, it allows for near-linear scalability as more nodes are added. It’s commonly used in large-scale data processing, databases, and cloud computing environments where handling massive datasets and high traffic volumes is essential. The lack of shared state simplifies failure handling, as a node failure doesn’t directly impact others.

Usage

The Shared-Nothing architecture is widely used in:

Massively Parallel Processing (MPP) Databases: Systems like Amazon Redshift, Snowflake, and Google BigQuery leverage this architecture to distribute data and query processing across many nodes.
Cloud Computing: Cloud providers like AWS, Azure, and Google Cloud use shared-nothing principles to isolate virtual machines and containers, ensuring that one tenant’s activity doesn’t affect others.
Distributed Caching: Systems like Memcached and Redis (in clustered mode) can be deployed in a shared-nothing configuration to distribute cached data across multiple servers.
Big Data Processing: Frameworks like Apache Spark and Hadoop (with HDFS) are designed to operate on clusters of machines with independent resources.

Examples

Amazon Redshift: Redshift is a fully managed, petabyte-scale data warehouse service. It employs a shared-nothing architecture with a cluster of compute nodes, each having its own CPU, memory, and storage. Data is distributed across these nodes, and queries are processed in parallel, enabling fast analysis of large datasets. There is no shared disk between nodes.
Snowflake: Snowflake is another cloud data platform built on a shared-nothing architecture. It separates storage, compute, and services layers. Compute nodes (virtual warehouses) are independent and scale independently of storage. Each virtual warehouse has its own resources, and data is accessed via shared storage but processed in isolation.
Apache Cassandra: Cassandra is a NoSQL distributed database designed to handle large amounts of data across many commodity servers, providing high availability with no single point of failure. Each node in a Cassandra cluster manages a portion of the data and operates independently, communicating with other nodes to replicate data and handle requests.

Specimens

15 implementations

Specimen 185.01 Dart View specimen ↗

The Shared-Nothing pattern emphasizes independent processes that don’t share any global state. Each process has its own dedicated resources – memory, disk – and communicates exclusively through message passing. This avoids contention and simplifies concurrency.

This Dart example models a simple distributed counter using isolates. Each isolate represents a worker with its private counter. The main isolate spawns multiple worker isolates and sends them increment/get requests via ReceivePort and SendPort. Isolates communicate by copying messages, enforcing the “shared-nothing” principle. Dart’s isolates are a natural fit for this pattern as they enforce memory isolation, and use message passing for communication, making it relatively straightforward to implement.

import 'dart:isolate';

void counterIsolate(SendPort sendPort) {
  int count = 0;
  sendPort.listen((message) {
    if (message == 'increment') {
      count++;
    } else if (message == 'get') {
      sendPort.send(count);
    }
  });
}

void main() async {
  final numIsolates = 3;
  final List<Isolate> isolates = [];
  final List<ReceivePort> receivePorts = [];

  for (int i = 0; i < numIsolates; i++) {
    final receivePort = ReceivePort();
    final isolate = await Isolate.spawn(counterIsolate, receivePort.sendPort);
    isolates.add(isolate);
    receivePorts.add(receivePort);
  }

  // Increment each counter a few times
  for (int i = 0; i < 5; i++) {
    for (var port in receivePorts) {
      port.send('increment');
    }
  }

  // Get the counts from each isolate
  for (int i = 0; i < numIsolates; i++) {
    final count = await receivePorts[i].first;
    print('Isolate $i count: $count');
  }

  // Shutdown isolates
  for (var isolate in isolates) {
    isolate.kill();
  }
}

Specimen 185.02 Scala View specimen ↗

This Scala example simulates a simple Shared-Nothing system with worker nodes processing tasks. Task represents a unit of work, and WorkerNode encapsulates processing logic. A TaskQueue (simplified here as a List) distributes tasks, with each node pulling work from the queue and processing it independently. Concurrency is managed by creating multiple WorkerNode instances, each operating on its own data. This design is idiomatic Scala due to its focus on immutability (tasks are treated as immutable data) and functional programming principles. The use of a List as a queue is illustrative; a more robust implementation would utilize concurrent data structures for production systems.

case class Task(id: Int, payload: String)

class WorkerNode(id: Int) {
  def processTask(task: Task): String = {
    println(s"Worker $id processing task $task.id")
    s"Worker $id processed task $task.id: ${task.payload.toUpperCase}" // Simulate work
  }
}

object SharedNothingExample {
  def main(args: Array[String]): Unit = {
    val tasks = List(
      Task(1, "data1"),
      Task(2, "data2"),
      Task(3, "data3"),
      Task(4, "data4")
    )

    val numWorkers = 2
    val workerNodes = (1 to numWorkers).map(i => new WorkerNode(i)).toList

    tasks.foreach { task =>
      // Simplistic task assignment - round robin
      val workerIndex = task.id % numWorkers
      val worker = workerNodes(workerIndex)
      val result = worker.processTask(task)
      println(result)
    }
  }
}

Specimen 185.03 PHP View specimen ↗

The Shared-Nothing pattern is an architecture where each worker (or node) in a distributed system has its own private memory and storage, and communication happens primarily through network calls. No shared resources like databases or file systems are directly accessed by multiple workers. This enhances scalability and fault isolation. The PHP example simulates this by creating independent worker classes, each handling its own data and communicating using message passing (here, simple function calls could be replaced by a queue system in a real implementation). This uses simple class structures and dependency injection, following standard PHP OOP principles, to showcase the isolation and communication aspects.

<?php

/**
 * Represents a worker in a shared-nothing system.
 */
class Worker
{
    private $id;
    private $data;

    public function __construct(int $id, array $data)
    {
        $this->id = $id;
        $this->data = $data;
    }

    public function getId(): int
    {
        return $this->id;
    }

    public function processData(): array
    {
        // Simulate processing the data.  In a real system this would be more intensive.
        $processedData = array_map(fn($item) => $item * 2, $this->data);
        return $processedData;
    }

    public function receiveMessage(string $message, ?array $payload = null): string
    {
        return "Worker {$this->id}: Received message '$message'";
    }
}


/**
 * A simple coordinator to manage workers.
 */
class Coordinator
{
    private $workers = [];

    public function addWorker(Worker $worker): void
    {
        $this->workers[] = $worker;
    }

    public function distributeWork(): array
    {
        $allResults = [];
        foreach ($this->workers as $worker) {
            $results = $worker->processData();
            $allResults[$worker->getId()] = $results;
        }
        return $allResults;
    }

    public function sendMessageToWorker(int $workerId, string $message, ?array $payload = null): string
    {
        foreach ($this->workers as $worker) {
            if ($worker->getId() === $workerId) {
                return $worker->receiveMessage($message, $payload);
            }
        }
        return "Worker with ID {$workerId} not found.";
    }
}

// Example Usage
$coordinator = new Coordinator();

$worker1 = new Worker(1, [1, 2, 3]);
$worker2 = new Worker(2, [4, 5, 6]);

$coordinator->addWorker($worker1);
$coordinator->addWorker($worker2);

$results = $coordinator->distributeWork();
print_r($results);

echo $coordinator->sendMessageToWorker(1, "Status update");

?>

Specimen 185.04 Ruby View specimen ↗

The Shared-Nothing architecture aims for scalability and fault tolerance by distributing the entire dataset across multiple independent nodes, each with its own dedicated resources (CPU, memory, disk). Nodes communicate via messaging, avoiding shared memory or centralized coordination. This Ruby example simulates a simplified Shared-Nothing system using threads, each thread representing a node operating on a unique portion of data. The data is split into chunks, and each thread processes its chunk independently. Results are aggregated at the end without any shared state during processing. This is idiomatic Ruby due to its strong support for concurrency via threads and its flexible data handling.

# frozen_string_literal: true

# A simplified Shared-Nothing example in Ruby using threads.
# Simulates processing a dataset across multiple independent nodes.

def process_chunk(chunk)
  # Simulate some processing on the chunk.
  chunk.map { |x| x * 2 }
end

def shared_nothing_processing(data, num_nodes)
  chunk_size = (data.size.to_f / num_nodes).ceil
  chunks = data.each_slice(chunk_size).to_a
  
  threads = []
  results = []

  chunks.each_with_index do |chunk, i|
    thread = Thread.new do
      processed_chunk = process_chunk(chunk)
      results[i] = processed_chunk
    end
    threads << thread
  end
  
  threads.each(&:join) # Wait for all threads to complete
  
  results.flatten
end

# Example usage:
data = (1..100).to_a
num_nodes = 4

processed_data = shared_nothing_processing(data, num_nodes)

puts "Original data: #{data[0..5]}"
puts "Processed data: #{processed_data[0..5]}"

Specimen 185.05 Swift View specimen ↗

The Shared-Nothing pattern aims for scalability and fault tolerance by distributing data and computation across multiple independent nodes, each with its own dedicated resources (CPU, memory, disk). There is no shared memory or storage between these nodes. Communication happens via message passing. This example simulates a simple distributed counter using Swift’s Actor concurrency model, which naturally lends itself to this pattern. Each actor represents a node, holding its own count and responding to increment/get requests. Actors provide isolated state and message-based communication, mirroring the independent nodes and message passing of Shared-Nothing.

import Foundation
import Dispatch

actor CounterNode {
    private var count: Int = 0

    func increment() {
        count += 1
    }

    func getCount() -> Int {
        return count
    }
}

class DistributedCounter {
    private let nodes: [Actor<CounterNode>]
    private let nodeCount: Int

    init(nodeCount: Int) {
        self.nodeCount = nodeCount
        self.nodes = (0..<nodeCount).map { _ in Actor.create(CounterNode()) }
    }

    func increment(nodeId: Int) {
        nodes[nodeId].send(increment)
    }

    func getTotalCount() async -> Int {
        var totalCount = 0
        for node in nodes {
            totalCount += await node.send(getCount)
        }
        return totalCount
    }
}

// Example Usage:
let counter = DistributedCounter(nodeCount: 5)

// Increment nodes concurrently
let increments = (0..<5).map { nodeId in
    Task {
        for _ in 0..<100 {
            counter.increment(nodeId: nodeId)
        }
    }
}

await all(increments, on: .main).completed // Wait for all increments to finish

let total = await counter.getTotalCount()
print("Total count: \(total)")

Specimen 185.06 Kotlin View specimen ↗

The Shared-Nothing pattern aims to achieve scalability by distributing data across multiple nodes, where each node has its own dedicated resources (CPU, memory, disk) and does not share them with any other node. Communication between nodes happens through explicit message passing. This example demonstrates a simple, in-memory, single-machine simulation using Kotlin coroutines to mimic distributed nodes. Each node (represented by a coroutine) owns a segment of data (a range of integers) and processes requests only pertaining to its segment. Independence and concurrency are key. Kotlin’s coroutines provide a lightweight way to simulate this concurrency.

import kotlinx.coroutines.*

data class Request(val id: Int)

sealed class Response {
    data class Result(val value: Int?) : Response()
    object NotFound : Response()
}

class SharedNothingData(private val data: Map<Int, Int>) {
    fun processRequest(request: Request): Response {
        data[request.id] ?: return Response.NotFound
        return Response.Result(data[request.id]!!)
    }
}

fun main() {
    val nodeCount = 3
    val totalDataSize = 10
    val dataPerNode = totalDataSize / nodeCount

    val nodesData = (0 until nodeCount).associateWith { i ->
        val start = i * dataPerNode
        val end = (i + 1) * dataPerNode
        (start until end).associate { it to it * 2 } // Sample data
    }

    val scope = CoroutineScope(Dispatchers.Default)
    val nodes = nodesData.map { (nodeId, data) ->
        val sharedNothingData = SharedNothingData(data)
        scope.launch {
            // Simulate processing requests
            val request = Request(nodeId * 2) // Request specific to this "node"
            val response = sharedNothingData.processRequest(request)
            println("Node $nodeId processed request ${request.id}: $response")

            val otherRequest = Request(9) // Request to another node
            val otherResponse = sharedNothingData.processRequest(otherRequest)
            println("Node $nodeId processed request ${otherRequest.id}: $otherResponse")
        }
    }

    runBlocking {
        nodes.joinAll()
    }
}

Specimen 185.07 Rust View specimen ↗

The Shared-Nothing architecture is a distributed computing model where each node in the system has its own private memory and communicates with other nodes solely via message passing. This avoids contention and locking issues inherent in shared-memory approaches.

This Rust code demonstrates a simplified Shared-Nothing system with two worker threads. Each worker receives tasks from a channel, processes them independently with its own data, and sends the results back through another channel. The main thread distributes tasks and collects results. Rust’s ownership and borrowing system, coupled with its message passing via channels (using the std::sync::mpsc module), naturally aligns with this pattern, ensuring data isolation and preventing race conditions without explicit locks. The use of thread::spawn creates independent execution contexts.

use std::sync::mpsc;
use std::thread;

fn main() {
    let num_workers = 2;
    let tasks = vec![1, 2, 3, 4, 5];

    let (tx, rx) = mpsc::channel();
    let (result_tx, result_rx) = mpsc::channel();

    for i in 0..num_workers {
        let rx_clone = rx.clone();
        let result_tx_clone = result_tx.clone();
        thread::spawn(move || {
            worker(i, rx_clone, result_tx_clone);
        });
    }

    // Send tasks to workers
    for task in tasks {
        tx.send(task).unwrap();
    }

    // Drop the original sender to signal no more tasks
    drop(tx);

    // Collect results
    let mut results = Vec::new();
    for _ in 0..tasks.len() {
        results.push(result_rx.recv().unwrap());
    }

    println!("Results: {:?}", results);
}

fn worker(id: usize, rx: mpsc::Receiver<i32>, result_tx: mpsc::Sender<i32>) {
    for task in rx {
        // Simulate some independent processing
        let result = task * (id + 1);
        result_tx.send(result).unwrap();
    }
}

Specimen 185.08 Go View specimen ↗

The Shared-Nothing architecture is a distributed computing paradigm where each node in the system has its own private resources (CPU, memory, disk) and communicates with other nodes via network messages. There is no shared memory or shared storage. This promotes scalability and fault tolerance.

This Go example simulates a simplified shared-nothing system with worker nodes processing independent tasks. Each worker receives a task from a central dispatcher via channels, processes it, and sends the result back. The dispatcher doesn’t share any state with the workers; it merely routes work. This leverages Go’s concurrency features (goroutines and channels) to implement a natural message-passing style, fitting the shared-nothing paradigm. Error handling isn’t exhaustive for brevity, but would be crucial in a production system.

package main

import (
	"fmt"
	"sync"
)

// Task represents a unit of work.
type Task struct {
	ID      int
	Payload int
}

// Result represents the outcome of a task.
type Result struct {
	TaskID  int
	Value   int
	Error   error
}

// Worker represents a processing node.
type Worker struct {
	ID     int
	Tasks  <-chan Task
	Results chan<- Result
}

// NewWorker creates a new worker.
func NewWorker(id int, tasks <-chan Task, results chan<- Result) *Worker {
	return &Worker{ID: id, Tasks: tasks, Results: results}
}

// Start begins processing tasks.
func (w *Worker) Start() {
	go func() {
		for task := range w.Tasks {
			result := w.processTask(task)
			w.Results <- result
		}
	}()
}

// processTask simulates work being done.
func (w *Worker) processTask(task Task) Result {
	// Simulate some work
	value := task.Payload * 2
	return Result{TaskID: task.ID, Value: value, Error: nil}
}

// Dispatcher manages task distribution.
type Dispatcher struct {
	Tasks  chan Task
	Results chan Result
	Workers []*Worker
}

// NewDispatcher creates a new dispatcher.
func NewDispatcher(numWorkers int) *Dispatcher {
	tasks := make(chan Task)
	results := make(chan Result)

	workers := make([]*Worker, numWorkers)
	for i := 0; i < numWorkers; i++ {
		workers[i] = NewWorker(i, tasks, results)
		workers[i].Start()
	}

	return &Dispatcher{Tasks: tasks, Results: results, Workers: workers}
}

// Run dispatches tasks and collects results
func (d *Dispatcher) Run(tasks []Task) {
	var wg sync.WaitGroup
	wg.Add(len(tasks))

	for _, task := range tasks {
		d.Tasks <- task
	}
	close(d.Tasks)

	for i := 0; i < len(d.Workers); i++ {
		go func(resultChan <-chan Result) {
			for result := range resultChan {
				fmt.Printf("Task %d: Value = %d\n", result.TaskID, result.Value)
				wg.Done()
			}
		}(d.Results)
	}

	wg.Wait()
	close(d.Results)
}

func main() {
	dispatcher := NewDispatcher(3)
	tasks := []Task{{ID: 1, Payload: 10}, {ID: 2, Payload: 20}, {ID: 3, Payload: 30}, {ID: 4, Payload: 40}, {ID: 5, Payload: 50}}
	dispatcher.Run(tasks)
}

Specimen 185.09 C View specimen ↗

This C example simulates a simplified shared-nothing system with two worker processes. Each process has its own data (an integer) and performs a simple calculation. They communicate using pipes to exchange data and results. This avoids any shared memory, adhering to the pattern. The use of fork() and pipes is a standard approach for inter-process communication in C, making it idiomatic. Error handling is included for robustness.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM_WORKERS 2

int main() {
    int pipes[NUM_WORKERS][2];
    pid_t worker_pids[NUM_WORKERS];
    int worker_data[NUM_WORKERS] = {10, 20};
    int results[NUM_WORKERS];

    // Create pipes
    for (int i = 0; i < NUM_WORKERS; i++) {
        if (pipe(pipes[i]) == -1) {
            perror("pipe");
            exit(EXIT_FAILURE);
        }
    }

    // Fork workers
    for (int i = 0; i < NUM_WORKERS; i++) {
        worker_pids[i] = fork();
        if (worker_pids[i] == -1) {
            perror("fork");
            exit(EXIT_FAILURE);
        }

        if (worker_pids[i] == 0) { // Worker process
            // Close unused pipe ends
            for (int j = 0; j < NUM_WORKERS; j++) {
                if (j != i) {
                    close(pipes[j][0]);
                    close(pipes[j][1]);
                }
            }

            // Read data from pipe
            read(pipes[i][0], &worker_data[i], sizeof(int));

            // Perform calculation
            int result = worker_data[i] * 2;

            // Send result back through the pipe
            write(pipes[i][1], &result, sizeof(int));

            close(pipes[i][0]);
            close(pipes[i][1]);
            exit(EXIT_SUCCESS);
        }
    }

    // Parent process
    for (int i = 0; i < NUM_WORKERS; i++) {
        // Send data to worker
        write(pipes[i][1], &worker_data[i], sizeof(int));

        // Read result from worker
        read(pipes[i][0], &results[i], sizeof(int));

        // Wait for worker process to finish
        waitpid(worker_pids[i], NULL, 0);

        // Close pipe ends
        close(pipes[i][0]);
        close(pipes[i][1]);

        printf("Worker %d: Input = %d, Result = %d\n", i, worker_data[i], results[i]);
    }

    return 0;
}

Specimen 185.10 C++ View specimen ↗

The Shared-Nothing architecture is a distributed computing model where each node in the system has its own private memory and storage, and communicates with other nodes via network messages. There is no shared memory or disk. This promotes scalability and fault tolerance as nodes are independent. This example simulates this using separate classes for data processing and coordination, with communication via simple message passing using standard output. Each ’node’ (represented by a Worker object) owns its data and performs computations independently. The Coordinator simply launches the workers and collects results via standard output, mimicking the message-passing aspect. This approach fits C++’s strength in object-oriented design and allows for explicit control over data ownership and communication.

#include <iostream>
#include <vector>
#include <thread>
#include <string>

// Represents a worker node in the shared-nothing system
class Worker {
public:
  Worker(int id, std::string data) : id_(id), data_(data) {}

  void processData() {
    // Simulate some processing on the private data
    std::string processedData = "Worker " + std::to_string(id_) + ": Processed " + data_;
    std::cout << processedData << std::endl; // "Message passing" via stdout
  }

private:
  int id_;
  std::string data_;
};

// Coordinates the work distribution
class Coordinator {
public:
  Coordinator(const std::vector<std::string>& data) {
    workers_.resize(data.size());
    for (size_t i = 0; i < data.size(); ++i) {
      workers_[i] = Worker(static_cast<int>(i), data[i]);
    }
  }

  void execute() {
    std::vector<std::thread> threads;
    for (auto& worker : workers_) {
      threads.emplace_back(&Worker::processData, &worker);
    }

    for (auto& thread : threads) {
      thread.join();
    }
  }

private:
  std::vector<Worker> workers_;
};

int main() {
  std::vector<std::string> inputData = {"Data 1", "Data 2", "Data 3", "Data 4"};
  Coordinator coordinator(inputData);
  coordinator.execute();
  return 0;
}

Specimen 185.11 C_sharp View specimen ↗

The Shared-Nothing architecture is a distributed computing model where each node in the system has its own private resources – CPU, memory, and disk – and communicates with other nodes solely through explicit network messages. This avoids contention and bottlenecks associated with shared resources. This C# example simulates a simplified shared-nothing system with worker nodes processing independent tasks. Each WorkerNode has its own TaskQueue and processes tasks without directly accessing the queues of other nodes. Communication happens via a central TaskDistributor which assigns tasks. This approach aligns with C#’s support for concurrency and asynchronous operations, leveraging async/await for non-blocking task distribution and processing.

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

// TaskDistributor: Assigns tasks to worker nodes.
public class TaskDistributor
{
    private readonly ConcurrentQueue<WorkerNode> _workers;

    public TaskDistributor(params WorkerNode[] workers)
    {
        _workers = new ConcurrentQueue<WorkerNode>(workers);
    }

    public async Task DistributeTask(int task)
    {
        if (_workers.TryDequeue(out var worker))
        {
            await worker.ProcessTaskAsync(task);
            _workers.Enqueue(worker); // Return worker to the pool
        }
        else
        {
            Console.WriteLine("No workers available.");
        }
    }
}

// WorkerNode: Represents a node in the distributed system.
public class WorkerNode
{
    private readonly ConcurrentQueue<int> _taskQueue = new ConcurrentQueue<int>();
    private bool _isProcessing = false;

    public async Task ProcessTaskAsync(int task)
    {
        _taskQueue.Enqueue(task);
        if (!_isProcessing)
        {
            _isProcessing = true;
            while (_taskQueue.Count > 0)
            {
                if (_taskQueue.TryDequeue(out int currentTask))
                {
                    Console.WriteLine($"Worker {Environment.CurrentManagedThreadId} processing task: {currentTask}");
                    await Task.Delay(100); // Simulate work
                }
            }
            _isProcessing = false;
        }
    }
}

// Example Usage:
public class Program
{
    public static async Task Main(string[] args)
    {
        var distributor = new TaskDistributor(new WorkerNode(), new WorkerNode(), new WorkerNode());

        for (int i = 1; i <= 10; i++)
        {
            await distributor.DistributeTask(i);
        }

        Console.WriteLine("All tasks distributed.");
    }
}

Specimen 185.12 TypeScript View specimen ↗

The Shared-Nothing pattern promotes scalability and resilience by avoiding shared state between components. Each component has its own private data and communicates with others via explicit message passing (typically function calls with data transfer). This eliminates contention points like locks, often found in shared-memory approaches.

This TypeScript example demonstrates a simple order processing system. OrderProcessor instances each manage their own orders array. When a new order is added, it’s copied (using spread syntax) to the specific processor’s state. The reportOrders function explicitly requests the order list from each processor; no shared list exists. This approach aligns well with TypeScript’s focus on type safety and explicit data handling, favoring immutable data structures and clear function contracts.

// order-processor.ts
interface Order {
  id: string;
  amount: number;
}

class OrderProcessor {
  private orders: Order[] = [];

  addOrder(order: Order): void {
    this.orders = [...this.orders, order];
  }

  getOrders(): Order[] {
    return [...this.orders]; // Return a copy to prevent external modification
  }
}

// main.ts
const processor1 = new OrderProcessor();
const processor2 = new OrderProcessor();

processor1.addOrder({ id: '1001', amount: 50 });
processor2.addOrder({ id: '1002', amount: 100 });
processor2.addOrder({ id: '1003', amount: 25 });

function reportOrders(processors: OrderProcessor[]): void {
  processors.forEach((processor, index) => {
    console.log(`Processor ${index + 1}:`, processor.getOrders());
  });
}

reportOrders([processor1, processor2]);

Specimen 185.13 JavaScript View specimen ↗

The Shared-Nothing pattern aims for scalability and concurrency by avoiding shared state between processing units. Each unit operates on its own private data and communicates results through passing messages or using a central aggregator. This eliminates the need for locks or other synchronization mechanisms, reducing contention.

This JavaScript example simulates a worker pool using Array.map and represents the core concept. Each ‘worker’ (map callback function) receives a unique section of the input data and calculates a result without accessing or modifying any shared variables. The final results are combined in the main thread. This is idiomatic JavaScript due to the reliance on functional concepts (map) and avoiding mutable shared state, favoring immutability and message passing (returning values from the function). While JavaScript’s single-threaded nature limits true parallelism without Web Workers, this approach reflects the pattern’s principle for asynchronous operations.

/**
 * Demonstrates the Shared-Nothing pattern using a simple worker pool.
 *
 * @param {number[]} data The input data to be processed.
 * @param {number} numWorkers The number of workers to use.
 * @param {function} workerFunction The function each worker will execute on its data.
 * @returns {number[]} The combined results from all workers.
 */
function sharedNothing(data, numWorkers, workerFunction) {
  const chunkSize = Math.ceil(data.length / numWorkers);
  const chunks = [];
  for (let i = 0; i < data.length; i += chunkSize) {
    chunks.push(data.slice(i, i + chunkSize));
  }

  const results = chunks.map(chunk => {
    // Each worker processes its own chunk of data.
    return chunk.map(workerFunction);
  });

  // Flatten the results array.
  return results.flat();
}

// Example Usage:
const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const numWorkers = 3;

// A simple worker function that squares a number.
const squareWorker = (num) => num * num;

const squaredData = sharedNothing(data, numWorkers, squareWorker);
console.log(squaredData); // Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Specimen 185.14 Python View specimen ↗

The Shared-Nothing architecture is a distributed computing model where each node has its own independent resources – CPU, memory, and disk – and communicates with other nodes solely through network connections. There’s no shared storage or shared memory. This promotes scalability and fault tolerance. My Python example simulates this using multiple processes, each with its own data and processing logic. A Worker class represents each node, receiving tasks via a queue and processing them independently. The main function spawns multiple worker processes, distributes tasks, and collects results. This aligns with Python’s multiprocessing capabilities and emphasizes isolating process state to mimic the “nothing shared” concept.

import multiprocessing
import random

class Worker:
    def __init__(self, worker_id, task_queue, result_queue):
        self.worker_id = worker_id
        self.task_queue = task_queue
        self.result_queue = result_queue

    def run(self):
        while True:
            task = self.task_queue.get()
            if task is None:
                break  # Signal to terminate worker
            
            # Simulate some processing
            result = self.process_task(task)
            self.result_queue.put(result)
            print(f"Worker {self.worker_id}: Processed task {task} and got result {result}")

    def process_task(self, task):
        # Replace with your actual task processing logic
        return task * 2


def main():
    num_workers = 3
    tasks = [random.randint(1, 10) for _ in range(5)]

    task_queue = multiprocessing.Queue()
    result_queue = multiprocessing.Queue()

    workers = []
    for i in range(num_workers):
        worker = Worker(i, task_queue, result_queue)
        process = multiprocessing.Process(target=worker.run)
        workers.append(process)
        process.start()

    # Feed tasks to the queue
    for task in tasks:
        task_queue.put(task)

    # Signal workers to terminate
    for _ in range(num_workers):
        task_queue.put(None)

    # Collect results
    results = []
    for _ in range(len(tasks)):
        results.append(result_queue.get())

    # Wait for workers to finish
    for process in workers:
        process.join()
        
    print("\nAll results:", results)

if __name__ == "__main__":
    main()

Specimen 185.15 Java View specimen ↗

The Shared-Nothing architecture is a distributed computing paradigm where each node in the system has its own private, dedicated resources – CPU, memory, and storage – and communicates with other nodes solely via explicit communication protocols (like network calls). It avoids shared resources to minimize contention and improve scalability.

This Java example simulates a basic shared-nothing system with two worker nodes processing tasks. Each WorkerNode has its own taskQueue and processes tasks independently. The Task class represents the work units. The TaskDispatcher distributes tasks to nodes via simple method calls (representing network communication in a real system). The code is object-oriented, following standard Java naming and class organization conventions, and focused on encapsulating the state and behavior of each independent node. Concurrency within each node is not explicitly shown for brevity, but would be a natural extension.

import java.util.LinkedList;
import java.util.Queue;
import java.util.List;
import java.util.ArrayList;

class Task {
    private final int id;
    private final String data;

    public Task(int id, String data) {
        this.id = id;
        this.data = data;
    }

    public int getId() {
        return id;
    }

    public String getData() {
        return data;
    }

    public void execute() {
        System.out.println("Executing task " + id + " with data: " + data);
    }
}

class WorkerNode {
    private final Queue<Task> taskQueue = new LinkedList<>();

    public void submitTask(Task task) {
        taskQueue.offer(task);
    }

    public void processTasks() {
        while (!taskQueue.isEmpty()) {
            Task task = taskQueue.poll();
            if (task != null) {
                task.execute();
            }
        }
    }
}

class TaskDispatcher {
    private final List<WorkerNode> workerNodes;

    public TaskDispatcher(List<WorkerNode> workerNodes) {
        this.workerNodes = workerNodes;
    }

    public void dispatchTask(Task task) {
        // Simple round-robin dispatch for demonstration
        WorkerNode node = workerNodes.get(task.getId() % workerNodes.size());
        node.submitTask(task);
    }

    public void startWorkers() {
        workerNodes.forEach(node -> new Thread(node::processTasks).start());
    }
}

public class SharedNothingExample {
    public static void main(String[] args) {
        List<WorkerNode> nodes = new ArrayList<>();
        nodes.add(new WorkerNode());
        nodes.add(new WorkerNode());

        TaskDispatcher dispatcher = new TaskDispatcher(nodes);
        dispatcher.startWorkers();

        for (int i = 0; i < 5; i++) {
            Task task = new Task(i, "Data for task " + i);
            dispatcher.dispatchTask(task);
        }
    }
}