Architecture

Hexagonal Architecture

Reading Time: 2 minutes As the 12 factor app states, that each component of an application should work independent of each other. This is required in order to make the update process simpler. This is where many developers use architectural pattern, commonly known as hexagonal architecture. The main aim of this architecture is to divide the application into loosely couple components. These components can then be connected using ports Continue Reading

Event Sourcing – Does it make sense for your business?

Reading Time: 5 minutes You would always get a ton of literature on Event Sourcing and CQRS. The key question is WHEN do you use it? Under what circumstances? Is your problem really in need of ES? I would not go into the details of what Event Sourcing and CQRS is. The industry stalwarts have covered that in adequate detail. This post delves into battle-tested scenarios on where we Continue Reading

Rebalancing in Akka Cluster Sharding

Reading Time: 4 minutes In this blog we will be discussing about one of the important feature of Akka Cluster Sharding which is Rebalancing. Before moving forward make sure you have some basic knowledge on Akka Cluster Sharding, if not then please read Introduction to Akka Cluster Sharding and Implementing Akka Cluster Sharding. Before directly diving into this amazing feature which akka sharding provides, lets first understand the need Continue Reading

MYSQL REPLICATION

Reading Time: 4 minutes MySQL replication is the continuous copying of data changes from one database (primary) to another database (replica). The two databases are generally located on different physical servers. The replica database can act as a read replica or a standby replica to provide failover capability. Generally, there are two ways of replication: Asynchronous Replication Synchronous Replication Synchronous vs. asynchronous replication The primary difference between synchronous replication Continue Reading

The 12 Factor App

Reading Time: 4 minutes This blog will explain the principles of the 12 factor app. These principle basically eliminate the unnecessary ache required while building your application. It makes the development process smooth, thus resulting in a robust and reliable application. 1. Codebase: A twelve-factor app states that a single app should not have multiple codebases, otherwise it is a distributed system instead of an app. Also, multiple apps Continue Reading

Learning about Reactive Messaging Patterns

Reading Time: 4 minutes Overview According to the Reactive Manifesto, a critical element in any Reactive system is that it is message-driven. But what does it mean to be message-driven? Message-driven systems are those that communicate primarily through asynchronous and non-blocking messages. Messages enable us to build systems that are both resilient, and elastic, and therefore responsive under a variety of situations. Message Driven Architecture We have various ways Continue Reading

Building Scalable Systems

Reading Time: 7 minutes Building a Reactive System is all about the balance between consistency and availability and the consequences of picking one over the other. This article mainly focuses on consistency and availability and how they impact the scalability of a system. What is Scalability, Consistency and Availability? A system is scalable if it can meet the increase in demand while remaining responsive.It is consistent if all the Continue Reading

Building an Ionic Application using Cordova for Android

Reading Time: 2 minutes Ionic Framework is an open-source UI toolkit for building performant, high-quality mobile, and desktop apps using web technologies (HTML, CSS, and JavaScript). Ionic Framework is focused on the frontend user experience, or UI interaction of an app (controls, interactions, gestures, animations). It’s easy to learn and integrates nicely with other libraries or frameworks, such as Angular, or can be used standalone without a frontend framework Continue Reading

Let’s get to know Data Streaming: A dev’s point of view

Reading Time: 5 minutes Streaming of data is the need of the hour. This blog focuses on the developer’s need to process this stream, benefits, and the challenges it introduces.

Diving Into Reactive Microservices

Reading Time: 4 minutes It would be beneficial if you understand the concepts of Reactive Architecture before diving into Reactive Microservices. You can read about Reactive Architecture here: Leaning Towards Reactive Architecture In this article we will cover transition from Monoliths to Service Oriented Architecture to Reactive Microservices by applying isolation techniques to the application. What are Monoliths? To start explaining the microservices it’s useful to compare it to Continue Reading

Git first cover

Git useful commands, code management

Reading Time: 6 minutes Hi all. In this blog, we will continue to explore some of the useful git commands. These commands would help when we are working on a remote shared repository. This is in continuation to my previous post on git working areas. So, I am assuming that all are familiar with git working areas, if not please go through the blog here. Let’s explore them now Continue Reading

Domain-Driven Design

Reading Time: 3 minutes Domain-Driven Design is an Architectural approach with which we can design large systems or say domains where we create a communication channel between the domain experts and the software developers by keeping the structure and language of our code related to Domain. Problem: The problem that we have with large domains is that they can be very hard to model. Breaking large domain into smaller Continue Reading