Distributed Systems Patterns

Minaz Inamdar — Mon, 17 Jun 2024 02:45:53 +0000

Notes via ByteByteGo

1. Ambassador Pattern

Pros:

Simplifies communication between services.
Handles load balancing, traffic routing, and retries transparently.
Promotes decoupling of services.

Cons:

Adds an additional layer, which can introduce latency.
Requires configuration and management overhead.

Applications:

Kubernetes uses Envoy as an Ambassador.

2. Circuit Breaker Pattern

Pros:

Prevents cascading failures and improves system resilience.
Enhances fault tolerance by isolating failing components.
Provides fallback mechanisms to maintain system stability.

Cons:

Introduces complexity to manage circuit states.
May impact performance during high load or transient failures.

Applications:

Netflix's Hytrix library.

3. CQRS (Command Query Responsibility Segregation) Pattern

Pros:

Optimizes read and write operations independently.
Improves scalability and performance for read-heavy workloads.
Facilitates complex business logic on the write side.

Cons:

Increases architectural complexity.
Requires careful synchronization between command and query models.

4. Event Sourcing Pattern

Pros:

Provides a complete audit trail of system state changes.
Enables temporal queries and historical analysis.
Supports scalability and resilience through immutable event logs.

Cons:

Increased storage requirements due to storing all events.
Requires efficient replay mechanisms for state rebuilds.

5. Leader Election Pattern

Pros:

Establishes a single point of coordination in distributed systems.
Ensures high availability by quickly electing a new leader.
Facilitates scalability and fault tolerance.

Cons:

Adds overhead due to election algorithms and heartbeat mechanisms.
May introduce latency during leader changes.

Applications:

Apache zookeeper.

6. Publisher-Subscriber Pattern

Pros:

Supports asynchronous and real-time messaging.
Decouples publishers from subscribers, improving scalability.
Facilitates event-driven architectures.

Cons:

Requires robust message delivery mechanisms to ensure reliability.
May introduce complexity in managing message ordering and processing.

7. Sharding Pattern

Pros:

Improves scalability by distributing data across multiple nodes.
Enhances performance for read and write operations by reducing contention.
Allows horizontal scaling by adding more shards.

Cons:

Requires careful shard key selection and management.
Increases complexity in data distribution and query routing.
Introduces additional overhead for data rebalancing and maintenance.

Applications:

Cassandra and MongoDB

C# Interfaces

Minaz Inamdar — Wed, 26 Oct 2022 18:49:08 +0000

Abstraction

What does abstraction mean? In the simplest terms, it means hiding the convoluted implementations and exposing the crucial parts. But is that it?

Well yeah, that's it. Thanks for reading.

Object-oriented programming takes inspiration from the real world. The way I think of it is by looking around. Look around you, and come up with three things that you know how to use but do not know how it works internally.
I can name a few, a laptop, a smartphone, and a game controller.

Interface

Interface is one way of achieving abstraction, the other being abstract class.

Interfaces will only show the capabilities of a class.

Interfaces have only method declarations, not method implementation (Update : they can now have default implementation read more here Default Interface Method)
The methods within the interface are always public by default.
They cannot have fields, but they can have properties.
Class implementing the interface must provide a definition for the interface's method with the same method signature.
A single class can implement multiple interfaces. But extending multiple base classes are not allowed (The Diamond Problem)

Interface Chaining

When an Interface2 is implementing another Interface1, and class Dummy is implementing Interface2, class Dummy must provide implementation for all the members of both the interfaces.

https://replit.com/@inamdarminaz/InterfaceChaning

using System;
namespace InterfaceChaining{

  public interface Interface1
  {
      void Print1();
  }

  public interface Interface2 : Interface1 //chaining inheritance
  {
      void Print2();
  }

public class Dummy : Interface2
{
    // Implement Interface1 and Interface2 all members because Interface2 has chained inheritance from interface1
    public void Print1()
    {
        Console.WriteLine("Interface1.Print1();");
    }

    public void Print2()
    {
         Console.WriteLine("Interface2.Print2();");
    }
}
}


class Program {
  public static void Main (string[] args) {
    InterfaceChaining.Dummy dummy = new InterfaceChaining.Dummy();
    dummy.Print1();
    dummy.Print2();

   // We cannot create instance of an interface.
    //But an interface  reference variable can point to derieved class object.
    InterfaceChaining.Interface1 interface1 = new InterfaceChaining.Dummy();
    interface1.Print1();
  }
}

Explicit Interface

Consider two interfaces (Interface1 and Interface2) have same method name and signature. If these two interfaces are implemented by a single class then which method will it point to? Interface1's Print() or Interface2's Print()?

To avoid this confusion, developers use explicit interfaces which will specify which interface's method will be called.

Let's understand the ambiguity from below code

using System;
namespace ExplicitInterface{

  public interface Interface1
  {
      void Print();
  }

  public interface Interface2
  {
      void Print();
  }

public class Dummy : Interface1, Interface2
{
//Since the below method is implementing both the interfaces
//there won't be an error here. But when this function is called
//from main() which interface method will it point to?

// To avoid abiguity we need to implement Explicit Interface
    public void Print()
    {
        Console.WriteLine("Which interface am I pointing to?");
    }
}
}

This could solved by using explicit interfaces, by following these steps.

Get rid of access modifiers.
Set the method as "ReturnType InterfaceName.MethodName()"
Access the methods using interface refrence variables. https://replit.com/@inamdarminaz/ExplicitInterfaces


public class Dummy : Interface1, Interface2
{
    void Interface1.Print()
    {
        Console.WriteLine("Interface1.Print();");
    }
    void Interface2.Print()
    {
        Console.WriteLine("Interface2.Print();");
    }
}
}


class Program {
  public static void Main (string[] args) {
    //But an interface  reference variable can point to derieved class object.
    ExplicitInterface.Interface1 interface1 = new ExplicitInterface.Dummy();
    interface1.Print();
    ExplicitInterface.Interface2 interface2 = new ExplicitInterface.Dummy();
    interface2.Print();
  }
}

DEV Community: Minaz Inamdar

Distributed Systems Patterns

1. Ambassador Pattern

2. Circuit Breaker Pattern

3. CQRS (Command Query Responsibility Segregation) Pattern

4. Event Sourcing Pattern

5. Leader Election Pattern

6. Publisher-Subscriber Pattern

7. Sharding Pattern

C# Interfaces

Abstraction

Interface

Interface Chaining

Explicit Interface