by

Understanding the CQRS Pattern: Empowering Scalability and Maintainability in .NET Development

Introduction:

In the realm of modern software development, architects and engineers face a perpetual challenge: how to design robust architectures that can effortlessly handle increasing complexities while maintaining optimum scalability and maintainability. Enter the Command Query Responsibility Segregation (CQRS) pattern, an architectural gem that has rapidly gained traction among experts in recent years. In this article, we will delve into the compelling world of CQRS, exploring its remarkable benefits with practical examples in .NET development, and witness how this paradigm can elevate your software solutions to unprecedented heights of efficiency.

Continue reading “Understanding the CQRS Pattern: Empowering Scalability and Maintainability in .NET Development” »
by

Building Scalable .NET Core Applications: The 12-Factor App with Clean Architecture

In today’s fast-paced world, developing scalable and maintainable software-as-a-service (SaaS) applications is crucial. The 12-factor app methodology provides a set of guidelines for building such applications, while Clean Architecture helps maintain a separation of concerns and promotes testability. In this blog post, we’ll explore how to implement the 12-factor app principles using .NET Core and the Clean Architecture pattern, with code examples.

Continue reading “Building Scalable .NET Core Applications: The 12-Factor App with Clean Architecture” »
by

How Clean Architecture Can Be Used to Build More Testable, Maintainable, and Evolvable Applications

What is Clean Architecture?

Clean Architecture is an architectural style that separates the concerns of your application into different layers. This makes it easier to test, maintain, and evolve your code.

The four layers of Clean Architecture are:

  • The Domain Layer contains the core business logic of your application. This layer should be independent of any other layers, so that it can be reused in other applications.
  • The Application Layer contains the code that orchestrates the flow of data between the Domain Layer and the Infrastructure Layer. This layer is responsible for calling the appropriate methods in the Domain Layer and passing the results back to the user.
  • The Infrastructure Layer contains the code that interacts with the outside world. This layer is responsible for things like database access, web services, and user interfaces.
  • The Presentation Layer is the user interface of your application. This layer is responsible for displaying data to the user and collecting input from the user.
Continue reading “How Clean Architecture Can Be Used to Build More Testable, Maintainable, and Evolvable Applications” »
by

Creating .Net Core Microservices using Clean Architecture

Microservices architecture has been gaining a lot of attention lately, and it’s not hard to see why. It offers many benefits, including scalability, resilience, and flexibility. .NET Core is a great platform for building microservices, and when combined with clean architecture, it can lead to even better results. In this blog post, we’ll explore the best practices for building .NET Core microservices using clean architecture, and we’ll touch on some of the tools and technologies that can help you achieve this.

Clean architecture is an approach to designing software systems that emphasizes separation of concerns and independence of implementation details. It has four main layers: the domain layer, the application layer, the infrastructure layer, and the presentation layer. Each layer has a specific role to play in the system, and they communicate with each other through well-defined interfaces.

Ecommerce Architecture

Github Link:- https://github.com/rahulsahay19/eShopping

Continue reading “Creating .Net Core Microservices using Clean Architecture” »
by

Complete Reference of Microservices

Hi Guys,

I am delighted to share with you the launch of my Microservices series, “Complete Reference of Microservices” which covers all the essential details of Microservices, from learning to implementation. The series is comprised of six courses, each focusing on a specific aspect of Microservices, along with a free course on clean architecture, which provides a brief introduction to clean architecture in practice. Here is the link to the free course, “Getting started with Clean Architecture using .Net Core” which teaches the fundamentals of Clean Architecture at a high level. After mastering the basics, you can delve into the following topics from scratch. I am offering the first 100 licenses for all six courses for free on a first-come, first-served basis. Please find the links to each course below.

1. Creating .Net Core Microservices using Clean Architecture

2. Securing Microservices using Identity Server 4

3. Implementing Cross Cutting Concerns

4. Versioning Microservices

5. Building Angular Application for MicroServices

6. Deploying Microservices to Kubernetes and AKS

Continue reading “Complete Reference of Microservices” »
by

SQL Vs NoSql

Hi Friends,

Its been long time since I last blogged. Hence, thought to come up with some design topics. In this case, I thought to present my take on Sql Vs NoSql. Therefore, we will be discussing the below agenda in this blog post.

  • Basics
  • Sharding
  • Replication
  • CAP Theorem
  • Different types of databases
  • Parameters to choose right database
Continue reading “SQL Vs NoSql” »
by

Hotstar like Video Ingestion

Hi Friends,

Its been a while since my last post. Nevertheless, let’s get started again with new series of posts. In this section, we will begin new journey and see how to design system. Before designing any scalable system, what are the factors, we need to take care of? Let’s consider a scenario, where in we are designing hotstar like video ingestion system. How would we approach this part? What are the basic questions which we need take into account. Let’s look at these scenarios. Before, jumping to discussion, one point to note here that in system design problems, no solution is 100% correct and no solution is 100% wrong. These questions are open ended questions and answers can vary entirely on different scenarios presented. Hence, without wasting time, let’s get started.

Continue reading “Hotstar like Video Ingestion” »

by

Async Task vs Task

Hi Friends,

In this section, thought to discuss one of the topics, which I come across too often and that is whether to do async task or simply keep as task?

Whenever, async-await gets loaded in the program, it also loads state machine which means eventually, its going to have some extra code. But that makes sense as it wraps error body as well in it. If you don’t wrap it around, then you will end up having tough time identifying or reproducing the issue as this will highlight error some where in program.cs rather than actual method.

Continue reading “Async Task vs Task” »

by

How to make Microservices communication more resilient?

Hi Friends,

In this section, I thought to discuss about one potential issue, which one can easily overlook and when your service really becomes busy, you will get this “Socket Exhaustion” exception. One thing to keep in mind that distributed systems are prone to error. Therefore, its always good to anticipate it before and take precautionary measures.

Continue reading “How to make Microservices communication more resilient?” »

by

Year 2020 in Review

Hi Friends,

This year has come to end, hence thought to share yearly review. First of all, Happy New Year to all. This year has, we have witnessed many things which never happened before and we hope that, it won’t come back again. Things are looking good at the moment, economy is coming back in track. Hopefully, we will come out of this pandemic phase very soon. Hence, I borrowed this HOPE-2021 calendar pic from Kiran Mazumdar Shaw.

Continue reading “Year 2020 in Review” »