DEV Community: Sandeep Borhade

Token based Auth

Sandeep Borhade — Tue, 11 Feb 2025 09:08:21 +0000

There are multiple ways to manage token-based authentication in microservices, and the choice of approach depends on your application’s specific needs and security requirements. Here are some other common approaches that can be considered based on your use case:

1. Single Token for All Services (Shared JWT Token)

In this approach, you have a single JWT token for both user authentication and inter-service communication. The same token can be used across the API Gateway, client-to-service communication, and service-to-service communication.

Pros:

Simplifies the implementation, as you don't need to generate different tokens for each service.
Easy to manage a single token lifecycle.

Cons:

Less flexible: All services would be tied to the same token's audience (aud).
It can lead to security risks if a token meant for a user is accidentally used for inter-service communication.

How it Works:

The user logs in and receives a single JWT token.
The API Gateway forwards the token as-is to services for both user and inter-service requests.
Services use the same token to authenticate and authorize both user and inter-service communications.

Example: The token is validated at the API Gateway, and each microservice checks its validity based on a shared secret or key.

2. Opaque Tokens with Token Introspection

Instead of passing a JWT token, you can use opaque tokens (a token that has no inherent meaning) and perform token introspection to verify the validity and retrieve the user/service information.

Pros:

Secure, as the token has no directly readable claims and can’t be tampered with by external parties.
Easier to manage as you can keep centralized token information.

Cons:

Requires an additional introspection service to verify the validity and retrieve user/service details.
Adds latency as each request requires a call to the introspection service.

How it Works:

The API Gateway or each service will send an opaque token (a reference token) to an Auth Server to validate and retrieve the associated claims.
The Auth Server returns user/service information after introspecting the token.

3. Token Exchange Pattern

This pattern involves exchanging an initial token (usually a user token) for a service-specific token.

Pros:

Each service has a token specific to its requirements and audience (aud).
It provides flexibility to have different expiration times, claims, and scopes for different services.

Cons:

Additional complexity in handling token exchanges.
You need an exchange service that can transform a user token into service-specific tokens.

How it Works:

The client authenticates via the Auth Service, receiving a user token.
When a microservice needs to make a request to another service, it exchanges the user token for a service-specific token, typically via a token exchange endpoint.
The service token is then used for inter-service communication.

4. Service Accounts (Client Credentials Flow)

This approach involves using service accounts with client credentials to authenticate services. Each microservice has its own client ID and secret to authenticate and obtain an access token.

Pros:

More secure for inter-service communication, as services don’t rely on user tokens.
No need for token introspection or validation based on user context.

Cons:

Each service must be configured with its own client credentials.
The lifecycle of service tokens has to be managed independently from user tokens.

How it Works:

The API Gateway requests access tokens from the Auth Service using service account credentials.
The Auth Service issues a service-specific token.
Microservices use this token for authentication and authorization during inter-service communication.

5. JWT with Scopes and Claims (Fine-Grained Permissions)

Instead of creating separate tokens for each service, you can manage scopes and claims inside a single JWT token to indicate the level of access a user or service has.

Pros:

Simplifies token management (no need for multiple tokens).
Fine-grained control over permissions and access for both users and services.

Cons:

More complex token parsing and validation for each service.
May require additional logic to handle scopes/permissions effectively.

How it Works:

The JWT token contains claims that indicate the user’s or service’s permissions (e.g., scope, role, audience).
Each service validates the token and checks the relevant claims to determine if the request is authorized.

6. OAuth2 with Multiple Authorization Servers

In this setup, OAuth2 is used for authorization, and different authorization servers issue tokens based on the client’s needs (user vs. service).

Pros:

Highly flexible and scalable.
OAuth2 provides standardization and is widely used for microservice architectures.

Cons:

Requires additional OAuth2 infrastructure and configuration.
More complex implementation.

How it Works:

The OAuth2 Authorization Server issues tokens based on different clients: one for user authentication and another for service authentication.
The API Gateway verifies the tokens and ensures that the appropriate token is used for the respective service.

Conclusion:

The two-token approach (user token and service token) with audience validation is commonly used and is a production-grade solution for handling user authentication and inter-service communication separately.
However, depending on your system architecture, scale, and security requirements, you could explore alternatives like single token approaches, token exchange, or even OAuth2 with service accounts.

Each approach has its pros and cons, so the choice depends on your application’s complexity and specific requirements. For production-grade microservices, the audience-based token approach is widely adopted for separating concerns and ensuring a scalable, secure system.

Database Table Normalization

Sandeep Borhade — Wed, 29 Jan 2025 13:54:26 +0000

By using normalization, we can organize database to reduce redundancy and improve data integrity.

Business Scenario: Customer Orders

Unnormalized Table

Suppose you have an unnormalized table that stores customer orders along with their order details:

CREATE TABLE CustomerOrders (
    OrderID INT,
    CustomerName VARCHAR(100),
    OrderDate DATE,
    ProductIDs VARCHAR(100),
    ProductNames VARCHAR(100),
    Quantities VARCHAR(100)
);

-- Sample data
INSERT INTO CustomerOrders (OrderID, CustomerName, OrderDate, ProductIDs, ProductNames, Quantities)
VALUES (1, 'Alice', '2025-01-01', '101,102', 'Laptop,Mouse', '1,2');

In this example, the ProductIDs, ProductNames, and Quantities columns contain multiple values separated by commas, which violates the 1NF rule.

First Normal Form (1NF)

To achieve the First Normal Form (1NF), ensure that each column contains atomic values and there are no repeating groups. We need to separate the order details into individual rows:

CustomerOrders Table:

CREATE TABLE CustomerOrders (
    OrderID INT,
    CustomerName VARCHAR(100),
    OrderDate DATE
);

-- Sample data
INSERT INTO CustomerOrders (OrderID, CustomerName, OrderDate)
VALUES (1, 'Alice', '2025-01-01');

OrderDetails Table:

CREATE TABLE OrderDetails (
    OrderDetailID INT PRIMARY KEY,
    OrderID INT,
    ProductID INT,
    ProductName VARCHAR(100),
    Quantity INT,
    FOREIGN KEY (OrderID) REFERENCES CustomerOrders(OrderID)
);

-- Sample data
INSERT INTO OrderDetails (OrderDetailID, OrderID, ProductID, ProductName, Quantity)
VALUES 
    (1, 1, 101, 'Laptop', 1),
    (2, 1, 102, 'Mouse', 2);

Second Normal Form (2NF)

To achieve the Second Normal Form (2NF), remove partial dependencies. This means that non-key attributes should depend on the whole primary key. We need to separate the customer and order details into two tables:

CustomerOrders Table:

CREATE TABLE CustomerOrders (
    OrderID INT PRIMARY KEY,
    CustomerName VARCHAR(100),
    OrderDate DATE
);

-- Sample data
INSERT INTO CustomerOrders (OrderID, CustomerName, OrderDate)
VALUES 
    (1, 'Alice', '2025-01-01'),
    (2, 'Bob', '2025-01-02');

OrderDetails Table:

CREATE TABLE OrderDetails (
    OrderDetailID INT PRIMARY KEY,
    OrderID INT,
    ProductID INT,
    ProductName VARCHAR(100),
    Quantity INT,
    FOREIGN KEY (OrderID) REFERENCES CustomerOrders(OrderID)
);

-- Sample data
INSERT INTO OrderDetails (OrderDetailID, OrderID, ProductID, ProductName, Quantity)
VALUES 
    (1, 1, 101, 'Laptop', 1),
    (2, 1, 102, 'Mouse', 2),
    (3, 2, 103, 'Keyboard', 1);

Third Normal Form (3NF)

To achieve the Third Normal Form (3NF), remove transitive dependencies. This means that non-key attributes should not depend on other non-key attributes. We need to separate the product details into another table:

Products Table:

CREATE TABLE Products (
    ProductID INT PRIMARY KEY,
    ProductName VARCHAR(100)
);

-- Sample data
INSERT INTO Products (ProductID, ProductName)
VALUES 
    (101, 'Laptop'),
    (102, 'Mouse'),
    (103, 'Keyboard');

OrderDetails Table (Updated):

CREATE TABLE OrderDetails (
    OrderDetailID INT PRIMARY KEY,
    OrderID INT,
    ProductID INT,
    Quantity INT,
    FOREIGN KEY (OrderID) REFERENCES CustomerOrders(OrderID),
    FOREIGN KEY (ProductID) REFERENCES Products(ProductID)
);

-- Sample data
INSERT INTO OrderDetails (OrderDetailID, OrderID, ProductID, Quantity)
VALUES 
    (1, 1, 101, 1),
    (2, 1, 102, 2),
    (3, 2, 103, 1);

Boyce-Codd Normal Form (BCNF)

BCNF is a stricter version of 3NF. To achieve BCNF, ensure that for every functional dependency (A -> B), A is a superkey. The tables above are already in BCNF.

Fourth Normal Form (4NF)

To achieve the Fourth Normal Form (4NF), remove multi-valued dependencies. This means that a record should not contain two or more independent multi-valued facts about an entity. Suppose we have a table that stores employee skills and projects:

EmployeeSkillsProjects Table:

CREATE TABLE EmployeeSkillsProjects (
    EmployeeID INT,
    Skill VARCHAR(100),
    Project VARCHAR(100)
);

-- Sample data
INSERT INTO EmployeeSkillsProjects (EmployeeID, Skill, Project)
VALUES 
    (1, 'C#', 'ProjectA'),
    (1, 'SQL', 'ProjectB'),
    (2, 'Java', 'ProjectA');

To achieve 4NF, we separate the skills and projects into two tables:

EmployeeSkills Table:

CREATE TABLE EmployeeSkills (
    EmployeeID INT,
    Skill VARCHAR(100)
);

-- Sample data
INSERT INTO EmployeeSkills (EmployeeID, Skill)
VALUES 
    (1, 'C#'),
    (1, 'SQL'),
    (2, 'Java');

EmployeeProjects Table:

CREATE TABLE EmployeeProjects (
    EmployeeID INT,
    Project VARCHAR(100)
);

-- Sample data
INSERT INTO EmployeeProjects (EmployeeID, Project)
VALUES 
    (1, 'ProjectA'),
    (1, 'ProjectB'),
    (2, 'ProjectA');

Fifth Normal Form (5NF)

To achieve the Fifth Normal Form (5NF), ensure that the table is free from join dependencies. This means that the table should not contain any non-trivial join dependencies. The tables above are already in 5NF.

SQL query optimization techniques

Sandeep Borhade — Wed, 29 Jan 2025 13:46:17 +0000

Sure! Here are examples for each of the SQL query optimization techniques:

1. Indexing

Create Indexes:

CREATE INDEX idx_employee_name ON Employees(Name);

Use Appropriate Indexes:

SELECT * FROM Employees WHERE Name = 'John';

2. Query Optimization

Avoid SELECT *:

SELECT Name, Age FROM Employees;

Use Joins Efficiently:

SELECT e.Name, d.DepartmentName
FROM Employees e
INNER JOIN Departments d ON e.DepartmentID = d.DepartmentID;

Filter Early:

SELECT Name, Age FROM Employees WHERE Age > 30;

3. Query Execution Plan

Analyze Execution Plan:

EXPLAIN SELECT Name, Age FROM Employees WHERE Age > 30;

4. Avoiding Subqueries

Use Joins Instead of Subqueries:

SELECT e.Name, d.DepartmentName
FROM Employees e
INNER JOIN Departments d ON e.DepartmentID = d.DepartmentID;

Use EXISTS Instead of IN:

SELECT Name FROM Employees WHERE EXISTS (SELECT 1 FROM Departments WHERE Employees.DepartmentID = Departments.DepartmentID);

5. Caching and Materialized Views

Cache Results:

-- Application-level caching example

Use Materialized Views:

CREATE MATERIALIZED VIEW mv_employee_summary AS
SELECT DepartmentID, COUNT(*) AS EmployeeCount
FROM Employees
GROUP BY DepartmentID;

6. Database Configuration

Optimize Database Settings:

-- Adjust buffer size, cache size, etc. in database configuration

Partitioning:

CREATE TABLE Employees_Partitioned (
    EmployeeID INT,
    Name VARCHAR(100),
    Age INT,
    DepartmentID INT
) PARTITION BY RANGE (Age) (
    PARTITION p0 VALUES LESS THAN (30),
    PARTITION p1 VALUES LESS THAN (60),
    PARTITION p2 VALUES LESS THAN (MAXVALUE)
);

7. Avoiding Redundant Data

Normalize Data:

-- Example of normalizing data into separate tables

Denormalize for Read Performance:

-- Example of denormalizing data for read performance

8. Monitoring and Profiling

Monitor Query Performance:

-- Use database monitoring tools to track query performance

Profile Queries:

-- Profile queries to understand performance characteristics

Sure! Here are examples for the additional SQL query optimization techniques:

9. Use Stored Procedures

Stored Procedures: Use stored procedures for frequently executed queries. They are precompiled and can improve performance by reducing the parsing and execution time.

CREATE PROCEDURE GetEmployeeById
    @EmployeeID INT
AS
BEGIN
    SELECT * FROM Employees WHERE EmployeeID = @EmployeeID;
END

10. Avoid Cursors

Avoid Cursors: Instead of using cursors, use set-based operations.

-- Instead of using a cursor to update rows one by one
-- Use a set-based operation to update all rows at once
UPDATE Employees
SET Salary = Salary * 1.1
WHERE DepartmentID = 1;

11. Optimize Joins

Join Order: Optimize the order of joins to ensure that the most restrictive joins are performed first.

SELECT e.Name, d.DepartmentName
FROM Employees e
INNER JOIN Departments d ON e.DepartmentID = d.DepartmentID
WHERE e.Age > 30;

Join Conditions: Ensure that join conditions are indexed to improve performance.

CREATE INDEX idx_employee_department ON Employees(DepartmentID);

12. Use Appropriate Data Types

Data Types: Use appropriate data types for columns to reduce storage requirements and improve query performance. Avoid using larger data types than necessary.

-- Use VARCHAR(50) instead of VARCHAR(255) if the maximum length is 50
CREATE TABLE Employees (
    EmployeeID INT,
    Name VARCHAR(50),
    Age INT,
    DepartmentID INT
);

13. Limit Result Sets

LIMIT/OFFSET: Use LIMIT or OFFSET clauses to limit the number of rows returned by a query, especially when dealing with large datasets.

SELECT Name, Age FROM Employees WHERE Age > 30 LIMIT 10 OFFSET 20;

LIMIT 10: Limits the result set to 10 rows.

OFFSET 20: Skips the first 20 rows and starts returning rows from the 21st row.

14. Regular Maintenance

Maintenance Tasks: Perform regular database maintenance tasks such as updating statistics, rebuilding indexes, and checking for fragmentation to ensure optimal performance.

-- Update statistics
UPDATE STATISTICS Employees;

-- Rebuild indexes
ALTER INDEX ALL ON Employees REBUILD;

Task and Parallel

Sandeep Borhade — Sun, 26 Jan 2025 03:49:41 +0000

Difference between Parallel.ForEach and Tasks (specifically Task.WhenAll, Task.Run, etc.) lies in their usage, behaviour, and the types of tasks they are designed to handle. Both allow for concurrent or parallel execution of code, but they operate in slightly different ways.

Parallel.ForEach
Parallel.ForEach is a method from the System.Threading.Tasks namespace that enables parallel iteration over a collection. It automatically divides the work among available threads in the thread pool, making it particularly useful for CPU-bound tasks.

Key Characteristics:
Parallel Execution: Executes iterations in parallel on multiple threads.
Thread Pool Usage: It utilizes the thread pool, which means you don’t control how many threads are created or their lifetimes.
Synchronous by Default: It runs synchronously, meaning you call it, and it blocks until the entire collection is processed.
Optimized for CPU-bound Tasks: Best suited for CPU-intensive operations where multiple threads can operate independently and in parallel.

using System;
using System.Threading.Tasks;

class Program
{
   static void Main(string[] args)
   {
      var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

     Parallel.ForEach(items, item =>
     {
      // Simulate a CPU-intensive task (e.g., complex calculation)
        Console.WriteLine($"Processing item: {item} on thread 
        {Task.CurrentId}");
     });

    Console.WriteLine("All items processed.");
  }
}

Parallelism: Each item in the array is processed in parallel on separate threads (depending on the availability of CPU cores).
Blocking: The method doesn't return until all items are processed.

Tasks (e.g., Task.Run, Task.WhenAll)
Task.Run and Task.WhenAll provide more fine-grained control over asynchronous and parallel execution. While Task.Run can be used to offload CPU-bound work onto separate threads, it's often used in conjunction with asynchronous code for I/O-bound tasks.

Key Characteristics:
Asynchronous Execution: Task is primarily used for asynchronous programming, often for I/O-bound tasks (e.g., making network calls, accessing databases).
Task Control: You can manually create tasks, manage their execution, and wait for them explicitly (Task.WhenAll, Task.WhenAny).
More Flexibility: You can create and manage tasks individually or in groups, allowing for finer control over how tasks are executed.
Optimized for I/O-bound Tasks: Although Task.Run can be used for CPU-bound tasks, it's better suited for scenarios where asynchronous behavior is needed.

using System;
using System.Threading.Tasks;

class Program
{
  static async Task Main(string[] args)
  {
    var tasks = new[]
    {
      Task.Run(() => ProcessItem(1)),
      Task.Run(() => ProcessItem(2)),
      Task.Run(() => ProcessItem(3)),
     };
   await Task.WhenAll(tasks);  // Wait for all tasks to complete
   Console.WriteLine("All tasks completed.");
 }

 static void ProcessItem(int item)
 {
   // Simulate some work (e.g., CPU or I/O operation)
   Console.WriteLine($"Processing item {item} on thread 
   {Task.CurrentId}");
 }
}

Key Differences:

Feature	`Parallel.ForEach`	`Task.Run` / `Task.WhenAll`
Primary Use Case	Parallel iteration over collections for CPU-bound tasks.	Asynchronous and parallel execution for both CPU and I/O tasks.
Control Over Threads	Less control over threads; handled by the thread pool.	Full control over task creation and execution.
Execution Type	Runs synchronously. Blocks until all iterations are complete.	Runs asynchronously. Tasks are non-blocking unless awaited.
Task Type	CPU-bound tasks (parallel for loop).	General-purpose tasks (can be CPU-bound or I/O-bound).
Parallelism/Concurrency	Parallelism — multiple threads execute simultaneously.	Can be parallel (using `Task.Run`) or asynchronous (I/O-bound).
Error Handling	Exceptions are thrown for each iteration.	`Task.WhenAll` aggregates exceptions from all tasks.
Performance Tuning	Automatically tunes performance based on hardware (number of cores).	You have to manually manage how tasks are distributed.

Which to Use When?

Use Parallel.ForEach when:
- You have a CPU-bound task that can be split into independent units of work (e.g., performing calculations on multiple items in a collection).
- You want to automatically parallelize the execution over multiple threads.
- You don’t need to control individual tasks and can handle synchronous execution.
Use Task.Run / Task.WhenAll when:
- You are dealing with I/O-bound tasks (e.g., making HTTP requests, database queries, file operations).
- You need more control over task management, cancellation, or synchronization.
- You want to combine parallelism and asynchrony, such as running multiple independent tasks that perform I/O-bound operations concurrently.

Summary

Parallel.ForEach is great for CPU-bound tasks that can be processed in parallel over multiple threads with minimal control.
Task.Run / Task.WhenAll offers more flexibility, making it ideal for both CPU-bound and I/O-bound tasks, allowing you to combine concurrency and parallelism with fine control.

Understanding Async and Await in C#

Sandeep Borhade — Sat, 25 Jan 2025 03:20:04 +0000

Lot of time I have been asked the question around Async and Await during interviews.
Here is I am trying to consolidate my understanding around these keywords with some snippets.

What is Asynchronous Programming?:
In Asynchronous programming methods are run without blocking the main thread.

**Async **Keyword: Marks a method as asynchronous, allowing the use of await.
**Await **Keyword: Suspends execution until the awaited task is complete.
Task and Task: Core types representing asynchronous operations.

Why Use await in Methods?
The await keyword is used to pause execution of the calling method until the awaited asynchronous operation completes. This allows other tasks (like UI updates or other background operations) to run without blocking the thread.

When Not to Use await

In some cases, you might not need await:

Fire-and-Forget: When the result of a task isn’t needed, you can call it without await.

LogDataAsync("Message"); // Fire-and-forget (but use cautiously)

Aggregating Multiple Tasks: You can combine tasks using Task.WhenAll without awaiting each individually.

var tasks = new[] { Task1(), Task2() };
await Task.WhenAll(tasks);

Returning Tasks: When a method simply returns a task to its caller, you don't need await unless you want to handle exceptions or perform additional work.

static Task<string> FetchDataAsync() => Task.FromResult("Data");

To make the operations parallel or concurrent, you need to execute multiple tasks simultaneously without waiting for one task to complete before starting the next. This can improve performance, especially for I/O-bound operations like database calls, API requests, or file logging.

In the banking example, here’s how parallelism or concurrency can be applied:

Understanding Parallelism vs Concurrency

Parallelism: Tasks run at the same time on multiple threads, often leveraging multiple CPU cores. It’s best for CPU-bound tasks.
Concurrency: Tasks appear to run simultaneously by interleaving execution, often best for I/O-bound tasks (e.g., waiting for a database or API response).

In financial example:

Concurrent tasks: Fetching account balance, calling external APIs, and logging transactions.
Parallel tasks: Performing multiple transfers or operations simultaneously.

Banking Example for Parallelism

Scenario

We'll make the following tasks run concurrently:

Checking the account balance.
Making the API call for fund transfer.
Logging the transaction.

These tasks are independent and can run simultaneously.

Updated Code

using System;
using System.IO;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

class BankingService
{
    private static readonly HttpClient _httpClient = new HttpClient();

    public async Task MainAsync()
    {
        Console.WriteLine("Transaction started...");

        // Step 1: Run tasks concurrently
        var checkBalanceTask = CheckAccountBalanceFromDbAsync("123456");
        var transferTask = TransferFundsToExternalBankAsync("123456", "654321", 500);
        var logTask = LogTransactionAsync("123456", "654321", 500);

        // Step 2: Await all tasks to complete
        await Task.WhenAll(checkBalanceTask, transferTask, logTask);

        Console.WriteLine("Transaction completed successfully.");
    }

    // Simulate checking account balance (database operation)
    private async Task<decimal> CheckAccountBalanceFromDbAsync(string accountId)
    {
        Console.WriteLine("Querying account balance from database...");
        await Task.Delay(500); // Simulate delay for database query
        Console.WriteLine("Account balance fetched.");
        return 1000.00m; // Assume a balance of $1000
    }

    // Simulate transferring funds to another bank using an external API
    private async Task TransferFundsToExternalBankAsync(string fromAccountId, string toAccountId, decimal amount)
    {
        Console.WriteLine($"Transferring ${amount} from {fromAccountId} to {toAccountId}...");

        var payload = new
        {
            fromAccountId,
            toAccountId,
            amount
        };

        var jsonPayload = JsonSerializer.Serialize(payload);
        var content = new StringContent(jsonPayload, System.Text.Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync("https://mock-bank-api.com/transfer", content);

        if (response.IsSuccessStatusCode)
        {
            Console.WriteLine("Funds transferred successfully.");
        }
        else
        {
            Console.WriteLine("Transfer failed.");
        }
    }

    // Simulate logging the transaction (write to a file)
    private async Task LogTransactionAsync(string fromAccountId, string toAccountId, decimal amount)
    {
        string logMessage = $"Transaction: ${amount} from {fromAccountId} to {toAccountId} at {DateTime.Now}\n";
        Console.WriteLine("Logging transaction...");
        await File.AppendAllTextAsync("transaction_log.txt", logMessage);
        Console.WriteLine("Transaction logged.");
    }
}

// Entry point
class Program
{
    static async Task Main(string[] args)
    {
        var service = new BankingService();
        await service.MainAsync();
    }
}

How This Works

Concurrent Execution:
- Task.WhenAll allows multiple tasks to run concurrently.
- The following three tasks start simultaneously:
  - Checking the account balance.
  - Transferring funds.
  - Logging the transaction.
Efficiency:
- Each task is asynchronous and doesn’t block the thread while waiting for I/O operations (e.g., database query, HTTP request, or file writing).
- The tasks do not depend on each other and can run independently.
Result Handling:
- If you need the result from CheckAccountBalanceFromDbAsync, you can await it separately while other tasks still execute:
```
 decimal balance = await checkBalanceTask;
```

Key Concepts:

`Task.WhenAll`

Waits for all tasks to complete.
If any task fails, it throws an AggregateException containing details of all failures.
Example:

  await Task.WhenAll(task1, task2, task3);

`Task.WhenAny`

Waits for the first task to complete (useful for racing or fallback scenarios).
Example:

  var firstCompletedTask = await Task.WhenAny(task1, task2, task3);

Advantages of Parallel/Concurrent Execution

Improved Performance:
- Independent tasks run simultaneously, reducing the overall time.
Non-Blocking Execution:
- The main thread remains free to handle other work.
Scalability:
- Particularly useful in high-throughput systems like financial applications.

Encapsulation vs Abstraction

Sandeep Borhade — Thu, 23 Jan 2025 08:17:26 +0000

Abstraction vs Encapsulation in C#

What is Abstraction?

Definition: Explain abstraction as the process of hiding implementation details and showing only the essential features of an object.
- Focuses on what an object does rather than how it does it.
- Achieved through abstract classes, interfaces, and polymorphism.
Real-World Analogy: E.g., Using a TV remote—users know the buttons to press but not the internal mechanics.
Practical Example in C#:

// Abstract class
abstract class Animal
{
    public abstract void Speak();
}

// Derived classes
class Dog : Animal
{
    public override void Speak() => Console.WriteLine("Bark");
}

class Cat : Animal
{
    public override void Speak() => Console.WriteLine("Meow");
}

// Usage
class Program
{
    static void Main()
    {
        Animal dog = new Dog();
        dog.Speak(); // Output: Bark

        Animal cat = new Cat();
        cat.Speak(); // Output: Meow
    }
}

What is Encapsulation?

Definition: Encapsulation is the process of wrapping data (fields) and code (methods) together into a single unit, often restricting access to some components.
- Focuses on controlling access using access modifiers (public, private, protected, internal).
- Protects the integrity of an object’s state by restricting direct access to its fields.
Real-World Analogy: E.g., Bank account system where only authorized operations are allowed through an interface.
Practical Example in C#:

class BankAccount
{
    private decimal balance;

    public decimal GetBalance() => balance;

    public void Deposit(decimal amount)
    {
        if (amount > 0)
        {
            balance += amount;
        }
    }

    public void Withdraw(decimal amount)
    {
        if (amount > 0 && amount <= balance)
        {
            balance -= amount;
        }
    }
}

// Usage
class Program
{
    static void Main()
    {
        BankAccount account = new BankAccount();
        account.Deposit(1000);
        account.Withdraw(500);
        Console.WriteLine(account.GetBalance()); // Output: 500
    }
}

Key Differences Between Abstraction and Encapsulation

Aspect	Abstraction	Encapsulation
Focus	Hiding implementation details.	Hiding object state and protecting it.
Achieved Using	Abstract classes, interfaces.	Access modifiers (private, public, etc.).
Purpose	Simplifies complex systems.	Ensures controlled access and security.
Example	Animal classes showing behavior.	Bank account managing balance.

How Abstraction and Encapsulation Work Together

Highlight how abstraction defines the behavior and encapsulation protects the data.
Provide a combined example:


csharp
abstract class Employee
{
    public abstract string GetRole();
}

class Developer : Employee
{
    private string name;
    private decimal salary;

    public Developer(string name, decimal salary)
    {
        this.name = name;
        this.salary = salary;
    }

    public override string GetRole() => "Developer";

    public decimal GetSalary() => salary;
}

// Usage
class Program
{
    static void Main()
    {
        Employee dev = new Developer("Alice", 60000);
        Console.WriteLine(dev.GetRole()); // Output: Developer
        // Cannot access salary directly; encapsulated for protection.
    }
}

Concurrency vs Parallelism

Sandeep Borhade — Wed, 22 Jan 2025 05:33:27 +0000

Concurrency:

Concurrency is achieved through the interleaving operation of processes on the central processing unit (CPU) or in other words by the context switching.
An application that is processing more than one task at the same time.
Concurrency is an approach that is used for decreasing the response time of the system by using the single processing unit.
Concurrency creates the illusion of parallelism, however actually the chunks of a task aren’t parallelly processed, but inside the application, there are more than one task is being processed at a time.

Parallelism:

An application where tasks are divided into smaller sub-tasks that are processed simultaneously or parallel.
It is used to increase the throughput and computational speed of the system by using multiple processors.
It enables single sequential CPUs to do lot of things simultaneously.

Difference between Concurrency and Parellelism:
Parallelism leads to overlapping of tasks in one process with tasks of another process.
Whereas in concurrency the speed is increased by overlapping the input-output activities of one task with CPU process of another task.

web sockets

Sandeep Borhade — Tue, 21 Jan 2025 03:30:18 +0000

Introduction

WebSockets have revolutionized the way we build real-time web applications. Unlike traditional HTTP, which follows a request-response model, WebSockets enable full-duplex communication, allowing data to be sent and received simultaneously. This makes WebSockets ideal for applications that require low latency and real-time updates.

What is WebSocket?

WebSocket is a protocol that provides a persistent connection between a client and a server. This connection allows for continuous data exchange without the need for repeated HTTP requests. WebSockets use a single TCP connection, which remains open, enabling real-time communication.

How WebSocket Works

Handshake: The communication begins with a handshake between the client and the server. The client sends an HTTP request to upgrade the connection to WebSocket. The server responds with an HTTP 101 status code, indicating the protocol switch.
Persistent Connection: Once the handshake is complete, a persistent connection is established. This connection remains open, allowing for continuous data exchange.
Full-Duplex Communication: WebSocket enables full-duplex communication, meaning data can be sent and received simultaneously.
Data Frames: Data is transmitted in the form of frames, which can be text, binary, or control frames. These frames allow for efficient and flexible data transfer.

Technical Benefits of WebSockets

Persistent Connection:
- Why: Traditional HTTP requires a new connection for each request-response cycle, which adds overhead and latency.
- How: WebSockets establish a single, long-lived connection that remains open, allowing continuous data exchange without the need to repeatedly open and close connections. This reduces the overhead associated with connection setup and teardown, leading to more efficient communication.
- Example: In a live chat application, once the WebSocket connection is established, messages can be sent and received instantly without the need to establish a new connection for each message. This results in a smoother and more responsive chat experience.
Low Latency:
- Why: Establishing a new connection for each HTTP request introduces latency due to the connection setup time.
- How: With WebSockets, the connection is already established, so data can be sent and received instantly. This is particularly beneficial for real-time applications where low latency is crucial, such as live chats and online gaming. The persistent connection ensures that data can be transmitted with minimal delay.
- Example: In an online multiplayer game, WebSockets allow for real-time updates and interactions between players. The low latency ensures that actions taken by one player are immediately reflected in the game for all other players, providing a seamless gaming experience.
Full-Duplex Communication:
- Why: Traditional HTTP follows a request-response model, where the client sends a request and waits for the server's response, limiting the communication to one direction at a time.
- How: WebSockets support full-duplex communication, allowing the client and server to send and receive data simultaneously. This enables more interactive and responsive applications, as both parties can communicate in real-time without waiting for each other's responses.
- Example: In a stock ticker application, WebSockets allow the server to push real-time stock price updates to the client without the client having to request each update. This ensures that users receive the latest stock prices instantly.
Efficient Resource Utilization:
- Why: Repeatedly opening and closing connections in HTTP consumes server and network resources.
- How: By maintaining a persistent connection, WebSockets reduce the need for repeated connection setups and teardowns. This leads to more efficient use of server and network resources, as the overhead of connection management is minimized. The server can handle more connections simultaneously without being overwhelmed.
- Example: In a real-time collaboration tool, WebSockets allow multiple users to edit a document simultaneously. The persistent connection ensures that changes made by one user are instantly reflected for all other users, without the need for repeated connection setups.
Reduced Overhead:
- Why: Each HTTP request includes headers that add to the data being transmitted, increasing the overall data size and reducing efficiency.
- How: WebSockets use a single TCP connection for continuous data exchange, which reduces the overhead of HTTP headers. This makes WebSockets more efficient for applications that require frequent updates or large volumes of data. The reduced overhead allows for faster and more efficient data transmission.
- Example: In a real-time notification system, WebSockets allow the server to push notifications to the client without the overhead of HTTP headers. This ensures that notifications are delivered quickly and efficiently.
Scalability:
- Why: Handling a large number of simultaneous connections with traditional HTTP can be challenging and resource-intensive.
- How: WebSockets can handle a large number of simultaneous connections more efficiently. This scalability is essential for modern web applications that need to support real-time interactions with multiple users. WebSockets can manage high traffic and multiple users without significant performance degradation.
- Example: In a live streaming platform, WebSockets allow the server to handle thousands of simultaneous viewers. The efficient handling of connections ensures that all viewers receive the live stream with minimal delay and high quality.

Conclusion

WebSockets provide a powerful solution for real-time web applications, offering low latency and efficient communication. While they have some limitations, their advantages make them a valuable tool for modern web development.

Additional Resources

Sytem design problem categories

Sandeep Borhade — Mon, 20 Jan 2025 06:43:28 +0000

System design problems:

Video Streaming Systems: Netflix
Real-Time Communication Applications: WhatsApp
Ride-Sharing Systems: Uber
Newsfeed/Social Networks: Facebook
Cloud-Based Collaborative/Editing Systems: Google Docs
E-commerce Systems: Amazon
Search Engines: Google Search
Payment Processing Systems: PayPal
Content Management Systems (CMS): WordPress
IoT (Internet of Things) Systems: Smart Home Devices (e.g., Amazon Alexa)

WhatsApp System Design

Sandeep Borhade — Mon, 20 Jan 2025 04:11:20 +0000

Design of WhatsApp messenger specific scenarios wise.
We'll try to cover the following scenarios:

User Registration and Authentication
Sending and Receiving Messages
Media Sharing
Group Chats
Notifications
Status Updates

Scenario 1: User Registration and Authentication

Requirements:

Users should be able to register with their phone number.
Users should receive a verification code via SMS.
Users should be able to log in securely.

Design:

Client Application: The user enters their phone number and receives a verification code.
API Gateway: Routes the registration request to the Authentication Service.
Authentication Service:
- Generates a verification code and sends it via SMS using a third-party service (e.g., Twilio).
- Verifies the code entered by the user.
- Creates a new user record in the database.

Scenario 2: Sending and Receiving Messages

Requirements:

Users should be able to send and receive text messages in real-time.

Design:

Client Application: The user sends a message.
API Gateway: Routes the message to the Messaging Service.
Messaging Service:
- Uses WebSocket connections to establish real-time communication.
- Stores the message in a database (e.g., MongoDB).
- Delivers the message to the recipient's device.

Scenario 3: Media Sharing

Requirements:

Users should be able to share images, videos, and audio messages.

Design:

Client Application: The user selects a media file to share.
API Gateway: Routes the media upload request to the Media Service.
Media Service:
- Uploads the media file to a storage service (e.g., AWS S3).
- Generates a URL for the media file.
- Stores the URL in the database along with the message metadata.
- Delivers the media URL to the recipient's device.

Scenario 4: Group Chats

Requirements:

Users should be able to create and participate in group chats.
Messages should be delivered to all group members.

Design:

Client Application: The user creates a group and adds members.
API Gateway: Routes the group creation request to the Group Management Service.
Group Management Service:
- Creates a new group record in the database.
- Manages group membership and permissions.
Messaging Service:
- Handles the delivery of messages to all group members.
- Uses WebSocket connections for real-time communication.

Scenario 5: Notifications

Requirements:

Users should receive notifications for new messages and updates.

Design:

Client Application: Registers for push notifications.
API Gateway: Routes notification requests to the Notification Service.
Notification Service:
- Uses a push notification service (e.g., Firebase Cloud Messaging) to send notifications to users' devices.
- Manages notification preferences and delivery.

Scenario 6: Status Updates

Requirements:

Users should be able to post and view status updates.

Design:

Client Application: The user posts a status update.
API Gateway: Routes the status update request to the Status Service.
Status Service:
- Stores the status update in the database.
- Retrieves status updates for display to other users.

By breaking down the design into specific scenarios, we can ensure that each aspect of the WhatsApp messenger is thoroughly covered and designed to meet both functional and non-functional requirements.