DEV Community: Aravind Venkatesan

7 Mindful Tips For Writing Clean Code

Aravind Venkatesan — Sun, 17 Mar 2024 02:43:10 +0000

Writing clean and maintainable code is essential for every single developer, whether they're just starting or have many years of experience.

Psstt… It’s hard to train AI bots to do mindful coding but not for humans like you and me !!! 🤖🤖🤖

Clean code improves readability, scalability, and maintainability, making it easier to work with. In this short article, let’s quickly explore some of the important practical tips to improve the quality of your overall project.

Tip 1 - Keep it Simple Stupid 😀

“Keeping it simple” is the single motto that every single developer should have in mind when they start to think about something.

The systems may be complex, frameworks may be gigantic but keeping the code simple at every level, helps the project to scale faster and makes the delivery more efficient.

Keeping it simple doesn’t mean NO BUGS. People write bugs most of the time, it is just that they are not aware of it.

Setting simple goals and outcomes for every task in your project and keeping the coding principles/guidelines consistent across the codebase will force the contributors in your team to write the desired code.

By reducing complexity it makes our life a lot easier.

Tip 2 - Don’t reinvent the wheel 🛞

Most of the developers that I work with always fall into this cycle. They want to build every single system, every minute feature from scratch. It may be good for your learning journey but it is not a really good practice when you want to build a working product. Don’t try to reinvent the wheel.

Example: Let’s say you want to write a program to convert your local time to UTC. It is better to use the available methods in your programming language libraries (frameworks) instead of writing your conversion logic.

This saves your time + makes your code less error-prone as well.

Tip 3 - Meaningful Variable Names 🎯

Choose variable names that accurately describe their purpose, avoiding cryptic abbreviations or single-letter names.

As Robert C. Martin said,

"The ratio of time spent reading (code) versus writing is well over 10 to 1."

Tip 4 - Modularization 🗃️

Break down your code into smaller, reusable functions or classes to promote reusability and simplify debugging.

Always follow the DRY method. Don’t Repeat Yourself. Make sure you write the code modular and reuse it when necessary. While performing code reviews try to institute the same habits across your team members.

This habit is highly effective and the effect will compound as the codebase matures by saving a lot of time and effort spent on the maintenance.

Tip 5 - Error Handling ❌✅

Implement r*obust error-handling mechanisms* in your code to handle exceptions gracefully and provide meaningful error messages.

I cannot stress this rule enough.

We may have urgent deadlines to complete the project. We may be providing support for multiple stakeholders at once within our software org.

But just step back, pause, and think for a moment.

Proper error handling will save a lot of time in debugging those weird, unknown issues. This habit will save you from the tiring on-call that lasts for hours with your whole war room squad, and finally to figure out that some config was not turned on!

Tip 6 - Mindful Refactoring 🏗️

Regularly refactor your code to eliminate duplication, improve readability, and maintain consistency.

Try to follow the Boy Scout Rule, which means, leave the place better than you found it. Instilling this practice across your software team will improve the code quality and less maintenance overhead during tough times.

Also, be very mindful when performing refactoring because you have no idea what your code is capable of doing when it has an organization-wide usage.

Remember, "Refactoring always comes with a cost."

Tip 7 - Observability as a practice 🕵🏼‍♂️

Observability in software engineering refers to the ability to understand the internal state of a system by examining its outputs or external behavior. This includes monitoring, logging, and tracing.

While working on your piece of task you may never think about observability. There is a high chance you may never even implement observability in your project. Please stop developing more features just right now and focus on adopting some basic observability tools available today.

This habit is also called predictive maintenance → which simply translates to faster debugging and troubleshooting of your code which resolves a lot of issues before the end user can spot it.

References

This article was originally published here.

Follow me here to read and learn new things !!!

Importance Of Scalability In Software

Aravind Venkatesan — Sat, 23 Sep 2023 06:03:31 +0000

🕸️Understanding practical use cases

Applications built today are scalable by default. Every developer must understand the importance of scalability in software.

From a general user perspective, scalability matters more. Just that they don’t know how to define it in technical terms. Usually, you hear them say,

The screen has been showing a loading symbol for a long time!!!
Within a blink of an eye, the wicket was gone and we lost the match. Looks like the match was frozen for a moment and then it was already over…
I wanted to buy the new phone released in last month's flash sale. But I had to wait a long time only to know that my app had crashed 😂

In the above 3 general user sentiments, as engineers, we were able to observe the level of expectations from the customer. They want your app to be working whenever they open it. Neat and Simple.

Starting from handling huge user traffic, serving streaming content without interruption, and giving the users a seamless experience to purchase from your app during peak sales periods.

Everything points to a very important concept called Scalability.

The number of users is increasing day by day in the online world. We as developers should accept the ground reality and try to design the system in a highly available and scalable manner.

Every single user of your application should have the same experience irrespective of the region (where) or time (when)

🙋🏽‍♂️ What is Scalability?

Scalability in simple words can be defined as,

A system should be able to handle the increasing amount of workloads → without a decrease in performance or efficiency of the system.

Here part one of the definition means, the system that you are building should be able to handle the dynamic workload. The system should not get stuck when the workload increases.

The second part of the definition specifies about the performance of the system. This means, that when the workload becomes heavy, the system should perform in the same efficient manner similar to the situation when the load was light.

Software Scalability is needed in most of the applications. Some of the common examples you can see are mentioned below;

Increase in the number of users for your web app (in general terms)
Increase in the number of API requests when a flash sale is happening
Increase in the number of financial transactions per second
Increase in the amount of data transferred

In all the above-mentioned situations, your system should be able to handle the increase in workload without affecting the performance of the system.

🎯How to achieve Scalability?

Let’s imagine we are building an app that sells Ice Cream. I mean why not?

An exclusive app to sell just Ice Cream!!!

Let’s try to understand the requirements first and try to follow the scalable design notion.

Main Consideration: Need to ensure that we meet the needs and demands before we build the system.

Scalability in software can be achieved in certain ways. Some of the main items are listed as follows,

🏗️ Distributed Architecture

Logically separate the responsibilities and make the system distributed which can cooperate to perform the duties. Develop separate microservices for user management, order processing, and payment handling. Each service can scale independently based on demand. By doing this, we can scale the components independently based on our needs.

Let’s say the number of users signing up is increasing at the moment, we have to scale only the user management service to handle the traffic. If a flash sale is happening the order management system has to be scaled on demand. This dynamic handling of workload is achievable by setting up scaling policies in your organization.

Apart from this the distributed architecture also has a lot of advantages such as failure isolation, easier development among huge teams of developers, and so on. Distributing the system into multiple services (microservices) also introduces lots of complexity such as sharding, partitioning, data replication, handling message queues, and failure management which are the usual pitfalls that software architects have to take into consideration while designing large-scale distributed systems.

⚖️ Load balancing

Your system should be able to balance the workload (set of tasks) among the available resources in an efficient manner. Distribute the traffic evenly among the server instances. Make sure there is no bottleneck in your system.

Implementing a load balancer that evenly distributes incoming requests to multiple server instances that are handling different microservices in your distributed system.

🔝🔛 Scaling Methods

Satisfy user demand at any given point in time. This can be done by vertical or horizontal scaling. Vertical scaling is growing the size of the server in the system. Horizontal scaling means adding more servers to the system. There is always a hardware limit on how big the server can grow.

Based on a case-to-case basis, apps decide on the type of scalable approach to follow. Let’s say in for our ice cream app we have users around the globe (since we don’t want to count the minions 😂), so we go ahead with horizontal scaling.

🤖 Autoscaling

Configure auto-scaling for server instances or containers based on CPU and memory usage metrics. Ensure that resources scale up during peak ordering times. Most of the cloud providers today offer autoscaling services which acts as fully managed service. The configuration options range from system-level metrics such as CPU and memory usage to business metrics such as click rates, time spent on checkout, and so on.

Scaling your web server instances is one side of the coin. Scaling DB instances is the other. Database scaling can be achieved by creating read replicas and write instances. Indexing the required data and optimizing the db queries also helps in improving the performance of the system on a larger scale.

🌵 Caching

Caching is one of the important parts of the system that can reduce the load on the server for frequently accessed data. Implement Redis caching for frequently accessed data like user sessions and ice cream menu items.

🏋🏽‍♂️ Load Testing

In larger organizations usually, the application is put into load testing. They conduct periodic load testing trial runs by simulating the high traffic that they expect to receive during peak hours. All the metrics should be captured and monitored properly.

Based upon these tests, we can identify the bottlenecks in your systems like slow API endpoints, inefficient db queries, cache misses, and so on. This will help us to accommodate for future changes.

🎰 Continuous Improvement

Finally, there should be continuous improvement. Monitor the app closely with the logging and metrics tools and adjust the requirements based on the need. Regularly review system performance and scalability requirements as and when the user base expands for your application.

Using these monitoring tools will help you track server response times, API time taken, server resource consumptions, db performance, and error rates hit in your system. Apart from this keep the technology stack up to date and consider incorporating new practices and effective tools that can improve the scalability of your application.

🍦A flow through the ice cream ordering app

Let’s try to keep the design as simple as possible and try to imagine a design flow for the ice cream ordering application.

Identify key components of your App → UI, Backend, DB, Message Queues, External Payment Integrations

User Interface: The place where your customers can place orders. It can be a website or mobile app.
Backend Server: Handles order processing, user authentication, and communication with the database.
Database: Stores user profiles, orders, inventory, and so on.
Message Queues: Handles async heavy tasks in both pre and post-ordering processes.
External Payment Gateway: Integrates with 3rd party payment services such as Stripe, PayPal, or some payment gateway.

Now that we have a basic understanding of our components in the system. Let’s try to understand the step-by-step flow of this app.

The Ice Cream Ordering Client Application is at the top. This is the UI part which is available to the customer where they can place their orders.
A Content Delivery Network (CDN) serves static assets like images of the ice cream available on our menu.
The next part is the Load Balancer. It distributes incoming traffic among the multiple available application servers. It also helps us to route the traffic and direct the requests to the respective service in your system.
- Let’s say if the request comes in to create a new order, it is directed to the order processing microservice.
- If another request comes in for payment, it is handed over to the payment service.
- The most important thing to understand at this time is scaling. Here each service can be independently scaled depending on the load at the current moment.
The application servers interact with a distributed database cluster which includes a distributed database like Cassandra for storing the order data and a simple relational database with read replicas for storing and retrieving the user profiles.
The message queues available in the system are kept for handling the asynchronous tasks both pre and post-ordering time.
- These are designed to handle all the asynchronous tasks in your system such as updating inventory, initiating the delivery process, sending notification emails, and so on.
- Apart from this if there are any heavy time-consuming tasks to be performed in your system, the event-based message queues are the best way to handle these scenarios.
There are also cache servers built into the system to help reduce the load on the application servers. Frequently accessed data are returned directly from the cache servers.

Please note that this is a high-level representation, and in a real-world scenario, there may be additional components, security systems, logging and monitoring tools, and more detailed interactions among different components of your system.

🤔What happens if there is no scalability?

If a system lacks scalability, it can lead to several significant issues and limitations, including:

Performance Degradation: Without scalability, as the user load or data volume increases, the system's performance may degrade significantly. Users may experience slow response times, timeouts, and a poor overall user experience.
Limited Growth Potential: Without scalability, the system's capacity is limited by its initial design and infrastructure. It becomes challenging to accommodate a growing user base, add new features, or adapt to changing business needs.
Resource Constraints: A non-scalable system may struggle to handle spikes in traffic or increased demand. This can lead to resource constraints, such as overutilized CPU and memory, causing system crashes or downtime.
Competitiveness: In a competitive environment, businesses that cannot scale their systems may struggle to meet customer expectations, innovate quickly, or expand their market share, ultimately putting them at a disadvantage.

In summary, a lack of scalability can lead to poor performance, resource limitations, affecting business growth, increased operating costs, and eventually running out of business.

🔗References Used

Originally this article was published here

Kindly support and subscribe to my newsletter and follow me here for future articles :)

Diving into AWS - Understanding IAM

Aravind Venkatesan — Sun, 03 Sep 2023 06:21:11 +0000

AWS has a plethora of services under its hood. Among them, one of the critical services that every developer should be familiar with is AWS IAM - Identity and Access Management. This service was initially launched in May 2011 and features were built incrementally to make it the primary identity system to use the AWS cloud platform and its services.

Yes, IAM is one of the crucial components of AWS.

Learning and understanding about IAM helps us to have a better understanding of how AWS handles its resources in an effective, safe, and secure manner.

🔐Authentication and Authorization

Before learning about IAM and its features, let's have a solid understanding of Authentication and Authorization.

In software applications, maintaining the security of the system is highly important. Both Authentication and Authorization are fundamental aspects of security for the software system that we want to build.

Authentication is the process of determining the identity of the user who is currently accessing the software system. Authorization on the other hand is the process of checking the permissions/rights of the user who is accessing the resources of the software system.

Authentication can be performed in multiple ways. One standard way of doing this is a username and password combination which we all use day-to-day. Authorization on the other hand also happens daily like a user is allowed to access a certain webpage or not.

Do note that authentication always happens before the authorization. The user’s privileges, permissions, or access rights cannot be determined before the user has logged in to the system.

Examples of Authentication are Username and password Auth, Passwordless Auth, 2FA or MFA (Multi-Factor Authentication), SSO (Single Sign-On), and so on.

Examples of Authorization are JWT (JSON Web Token Authorization), RBAC (Role Based Access), OpenID, OAuth, and so on.

🕸️Let’s learn about IAM

IAM stands for Identity and Access Management in AWS. It is one of the primary web services in AWS which helps to securely access and control the AWS resources.

When a person signs up for an AWS account for the first time, the created account is called the Root Account. This is the primary account of the user where they can manage all the secure controls and overall cloud platform management. It is a best practice not to use this root account to perform non-important activities.

From this root account, we can create multiple user accounts (via the IAM service) to perform the desired actions on the cloud platform and its services. Usually in big enterprises, IAM accounts will be managed by a team of administrators who provide access to the users only on a required or need-to-know basis.

A person should know only things that they should know!

IAM is also a global service in AWS which means that it is common across all regions in AWS. Yes, AWS has multiple regions 😃 (which we shall explore and learn about in future articles)

Here is the official documentation link to learn more about AWS IAM.

🤔Why IAM?

Let’s take a step back again to understand the importance of IAM. It is a crucial component of AWS's security infrastructure, and there are several compelling reasons why you would want to use AWS IAM.

Granular Access Control of your AWS environment.
Security for all environments, applications, and the data itself.
Compliance out of the box to abide by the standards and regulations.
Identity Federation features can help to integrate with any system to perform user management or act as an identity provider for your software system.
IAM provides out-of-the-box monitoring and auditing for all the activities performed on the platform by every user.
When your organization grows in size, the infrastructure also has to grow. Managing users at scale is one of the prime features provided by IAM.

🎬IAM in action

IAM is used behind the scenes when you want to access the AWS platform or any AWS service. There are 3 different ways by which we can access the platform. In all these ways we have to authenticate and authorize with IAM service which acts as the entry point or guardrail for the system.

AWS Management Console

AWS Management Console is the web-based interface where the users can access cloud resources. Usually, this will be IAM user login and password-based.

NOTE: AWS also supports MFA which means Multi-factor Authentication via different authentication mechanisms. It can be either a digital token generator app or a physical identity token generator.

AWS CLI

The next way is AWS CLI where the IAM users can access the resources. Since this is CLI-based it will be used by the pro users who know to work with the CLI.

To work with AWS CLI, we will need the access key and secret for that particular IAM user. So when we want to set up the console, aws configure command follows standard step-by-step instructions which help us to generate these credentials so that we don’t have to type the username and password every time. It can also be directly generated from the IAM page in the Management Console.

The Access Key is similar to the username and the Secret access key is similar to the password. We should always safeguard this information and provide high importance as we do for our general login credentials.

NOTE: If any of the unknown person has access to these keys, then they might use these to access your cloud platform and finally you might end up with a huge bill from AWS. It is the user’s responsibility to safeguard these keys.

AWS SDK

AWS SDK is another way of accessing cloud resources. These are built and provided by AWS and it supports different languages and platforms. These SDKs will be used by those developers to write software and perform certain actions in the platform via code. SDKs are used at the application level and hence authentication and authorization are a must at this level too. It can be done using the same access key and secret generated for the IAM user.

🔑Keywords In IAM

There are a few keywords that we have to understand to get a better understanding of how IAM works in general.

Users

Users. Yes, users are people like us who work in a project or company. Users are those people who belong to your organization. Users are the first class citizens in IAM and are considered to be the primary entity.

Groups

A group is nothing but a collection of users. They can be developers, testers, finance personnel, admin, etc. Multiple users come together to form a group. Users can belong to a single group or multiple groups. Yes, I am talking about that one critical resource in your team who is the developer, tester, and admin. LOL 😂

Roles

Roles can be defined as the standard assigned definition for a user or an AWS service to perform allowed actions on the AWS platform. Mostly it will be those automated cases where one of the AWS services assumes a standard role to perform some actions on another AWS service.

A few of the examples related to AWS roles are mentioned below,

A lambda function with a designated role to read objects present in a specific S3 bucket
An EC2 instance with a standard role to access another EC2 instance present in a different AWS region

📝Learn to write IAM Policies

Policy is a very simple concept to understand yet it can be complicated to write. These are JSON documents that contain all the permissions and rules. These policies can be assigned to a single user, a group of users, or even for an IAM role that is assigned to a user.

Policies are the standard set of instructions that are written in the form of JSON for AWS to understand who can access what in a standard way.

{
  "Version": "2012-10-17",
  "Id": "policy-0001-030923",
  "Statement": {
    "Sid": "s3-allow-all-statement",
    "Effect": "Allow",
    "Principal": "bruce-wayne",
    "Action": "s3:*",
    "Resource": "*"
  }
}

Let’s break down the syntax step by step,

Version - This is the version of the policy document that AWS maintains and understands. Let’s not touch this. This is a required property.
Id - An identifier for the policy that we are crafting. This is an optional field.
Statement - This is a required field. There can be one or more statements in a single policy. In the above example, there is only one statement called s3-allow-all-statement

Sid - This is the user-defined identifier for the policy statement. It can be anything as long as it makes sense and is understandable by your team members. Note this is an optional field.
Effect - It can either Allow or Deny.
Principal - Account or the User for this policy applies to. In the above example, it applies to batman 😰 I mean bruce-wayne
Action - This field describes the actions which can be performed. It can be a list of actions or a single action. This should follow the standard syntax statements as defined by AWS. In the above example, it says s3:* which means all actions are allowed on the S3 service.
Resource - This field refers to the list of resources this policy statement is applicable. Again this can specified to a granular level if needed.

So overall to explain the policy in a single sentence,

bruce-wayne is allowed to perform any action on the S3 service on all resources

Policy documents can be as complex as we want them. It can be nested with multiple statements to have fine-grained control of our resources in AWS.

NOTE: There are several AWS-defined policy documents already available which is more than what we need. Usually, these fine-grained policies will be crafted based on the user’s needs but for learning purposes, you can always use the pre-defined policy documents.

AWS also provides a live policy editor which can be done easily from UI that shows which permission the user has or not. In this editor, the JSON document can edited live both in raw JSON format or visual format with a long list of checkboxes.

📔End note

Ultimately what matters is,

The users should have permission to do only what they need rather than everything - The principle of least privilege.
Do not provide access to anything and everything.
Monitor the usage pattern of the users in your organization or project to understand the necessary permission for the users and fine-tune the parameters in the IAM service.

AWS always stresses the shared responsibility model which means both AWS and users have responsibility in maintaining the security of the cloud platform.

AWS is responsible for maintaining the infrastructure, and configurations and handling compliance based on the regulatory bodies and frameworks.

As a user, we are responsible for maintaining all the IAM resources, enabling security, enforcing password policies, making MFA mandatory, password rotation on a timely basis, auditing credential reports from time to time, analyzing the access pattern of your users, and so on.

For the readers who are preparing for AWS certifications, this article may serve as a starting point to learn about IAM. For a detailed guide try to follow some standard tutorials available on the internet. It can be from AWS itself or some other resources. For my exam prep, I read through the AWS documentation site and the TutsDojo blogs for my exam prep. Attended several mock exams from the website as well which helped me a lot to get AWS certified efficiently.

🔗References Used

Understanding Git and GitHub

Aravind Venkatesan — Sun, 20 Aug 2023 13:16:29 +0000

Version control is a term widely used in software engineering. In the software field, it is defined as the way of keeping track of changes and managing those changes in terms of computer programs, files, software, etc.

💡In simple words, it is a system to keep track of changes.

🕸️Introduction

Git is one of the version control systems. It is a free and open-source distributed version control system. It was developed by Linus Torvalds (the same legend who is behind the creation of Linux).

Git is designed to handle small-scale to large-scale projects with greater efficiency and speed. GitHub on the other hand is a cloud platform that uses Git for version control which is currently owned by Microsoft.

🎖GitHub = Git + Additional Features such as bug tracking, task management, wikis, automation workflows, etc.

One of the first Git terminologies which we have to understand is Repositories.

_Repository _- The place where the data is stored and managed. Think of it like an imaginary huge box where all of the files/folders can be stored and managed.

👩🏽‍💻👨🏽‍💻So why is Git a distributed system?

Software is NOT built by a single person. It is a collaborative effort. Be it open source, service software, or some cool awesome software products which you are developing in your free time. Git is the main enabler in building software from scratch in a collaborative environment. It is a distributed system that holds the code repositories where multiple people can jump in to develop software by holding the entire copy of the source code.

I found this interesting image on the internet (credits to the creator) which explains the reason simply.

Git is designed in such a way that every user who uses it has complete control over the repository.

As mentioned previously, Git is the technology and GitHub is a cloud platform offering a managed version control system. Some other famous alternative platforms include GitLab, Atlassian’s Bitbucket, AWS CodeCommit, etc which are used among the community.

💻Installing Git

Git can be directly installed from this website. (https://git-scm.com/)

Windows users can download the installer shown on the landing page and follow the on-screen instructions to install the software.

Mac users can use homebrew to install git or follow the instructions on this page for the preferred method of installation (https://git-scm.com/download/mac)

🎯Let's Learn Some Git Commands

Learning different git commands can be intimidating but at the same time, it is a required skill set for most of the developers. These are some of the important and heavily used git commands by the developers in their day-to-day workflow.

🗒 This can also be considered as a cheat sheet for interview prep or just for reference in future

Prerequisites: Remember to download and install git in your system before executing these commands.

🗒️Git Commands - Section 1

This is an introductory section that explains very basic Git commands and steps to get started.

To display the version of the git installed on your system,

git --version

To display the help menu for the git,

git --help

To list out the configurations of git installed on your system in a list format,

git config --list

We can set up the user name and email for our git repository. This can be configured for the repository level or global level. The below command sets the username and email in the global scope. (Remember to change your respective user name and email in the config command below)

git config --global user.name "Bruce Wayne"
git config --global user.email "brucewayne@gotham.com"

To check whether the configs are set properly as in the previous step we can use the below commands to display the respective key-value pairs.

git config user.email
git config user.name

To list all the commands available in git. Do check the output of this command and you will be surprised by the results.

git help -a

The commands in git are divided into 5 main categories such as,

Main Porcelain commands
Ancillary Commands - Manipulators and Interrogators
Interacting with others
Low-level commands - Manipulators, Interrogators, sync repos, and internal helpers
External Commands

Probably most of us would not have dug deep into Git commands before. This may be a starting point for us to explore a bit more.

To get help or read a manual about a command which interests you the most, then type out the following command,

git help <command>

git help init // to get help about the init command
git help help // to get help about the help command

Let’s say you plan to work on a project and you have decided to use a version control system to keep track of the changes in your project files - Git is the place where you should start first.

Let’s create a new folder for the project called as my-awesome-project

Now navigate into the project folder and open git-bash or any terminal of your choice in the project folder.

To initialize a git repository,

git init

To check the status of the git repository or shows the files which have to be committed,

git status

Now let's assume you are creating some files inside the my-awesome-project folder.

In Git, there are 3 main stages that a developer should be aware of.

Local - refers to the local repository location (i.e.) your personal computer folder where you are currently working with your files.
Staging - An intermediate area where you have added files that you want to commit.
Remote - Refers to the remote repository location which is the distributed version of your repository. (i.e.) GitHub or any other cloud service which stores the files and folders which the team of developers will work on.

To add a file to the repository you need to use the below command,

git add <FILE_NAME>

To show the difference in the files between the current state and v/s previous (committed) state.

git diff

To show the difference between the files that are committed and v/s files that are staged (in the staging area),

git diff —staged

To stage all files in a single cmd,

git add .

If you change the staged file now at this stage → You will have 3 copies of the file.

One in local which has the latest changes - this is not committed yet
One in the staging area - this is git added but not committed yet
The final one is the committed file itself

To understand how the add command works we can simulate its behaviour. This is a simple simulation command which shows what happens when git add . is performed.

git add —dry-run .

To perform a commit of the added files to the repository,

git commit -m "MSG"

The -m flag denotes the message for your commit. There are more flags that we can attach with commit commands.

Perform git add and git commit in a single command can be done as shown below,

git commit -am “MSG”

🗒️Git Commands - Section 2

In this section, we should commit ourselves to learning important commands in Git.

To display the logs (the distributed activity log for the repository),

git log

To show the log with files changed,

git log -- stat

To display logs in a single line,

git log --oneline

To show git history per commit in a single line for each commit,

git log --shortstat --oneline

To list files in the git repository,

git ls-files

Some of the git gui commands (which you may never use) are listed here as well for reference. The reason why we are not seeing common usage of these commands is mainly because of the powerful GUI clients and IDE integrations which are present today. Most of the developers, don’t even need these GUI clients/IDE integrations 😉

git gui // to start the GUI for git
gitk // start the log viewer for the git repo
git citool // start git gui to commit files

If you have added a file to the stage area and need to remove it, then use the following command,

git restore --staged FILE_NAME
(or)
git reset FILE_NAME

To remove the file from git indexing (after adding it to the staging area),

git rm -f FILE_NAME

To remove the file which is already committed (including removal of git indexing),

git rm FILE_NAME
// deleted: index.css - git will track this file as deleted

If we want to rename the file and git to track those changes then do the following,

git mv main.css index.css // rename arg1 to arg2 
// renamed: main.css -> index.css

Translate the branch or tag into its SHA ID,

git revparse <BRANCH_NAME>

I hope by this time you are very tired of typing commands. Don't give up. Take a small break 🍵

💡Let's learn a small trick that can save us from typing longer commands.

git config can help us set store some useful aliases. This will help us replace very long commands such as below,

To print the logs in a beautiful format 💅🏽 we will use this long command !!!

git log --graph --decorate --pretty=oneline --all --abbrev-commit

Now set the key as lol for the log command specified above,

git config --global alias.lol='log --graph --decorate --pretty=oneline --all --abbrev-commit'

Now the alias should be configured successfully. From now on we can just type,

git lol

If you are so lazy or tired to even type checkout then use shorter commands like this,

git config --global alias.co 'checkout'
git co <branch-name>

The below snippet shows the summary of Setting Command Aliases 📸

ORIGINAL_COMMAND:
git log --graph --decorate --pretty=oneline --all --abbrev-commit

CONFIGURING_ALIAS_COMMAND: (Here the configured alias is lol)
git config --global alias.lol "log --graph --decorate --pretty=oneline --a
ll --abbrev-commit"

EXECUTING_ALIAS_COMMAND:
git lol

REMOVING_ALIAS_COMMAND:
git config --global --unset alias.lol

🗒️Git Commands - Section 3

Let's diverge a bit here 😂 to learn about branches and tags !!!

Branching means you diverge from the mainline of development and continue to do work without messing with that mainline. Tags on the other hand are simple pointers that represent the significant point in the project development timeline.

To list all the branches in Git,

git branch

To create a new branch in Git,

git branch BRANCH_NAME

To checkout to the branch,

git checkout BRANCH_NAME

To delete the created branch,

git branch -d BRANCH_NAME

NOTE: The user cannot delete the branch in which the user is currently checked out. So need to first checkout to another branch and then perform the deletion.

git tag TAG_NAME -m TAG_MESSAGE SHAID
git tag V1.0 -m "This is the release 1.0 version" 5083a560
git show V1.0 // display the tag details
git tag // lists all the tags

Checkout using SHAID

git checkout SHAID -> We can checkout to any SHAID
this will create a detached HEAD state 
(because the current HEAD is changed on pointed to the newly checked out SHAID)
better to create new branches and perform the changes

Create and checkout a branch in a single command,

git checkout -b BRANCH_NAME

Create a sub-branch from the parent branch,

git checkout -b sub_branch master

Here the parent branch is the master or main. Usually, the parent can be anything and not necessarily be the master branch. The sub_branch is the subordinate branch created from the parent branch.

To track the steps we have taken in our local git bash terminal we can use the reflog command. It helps us to show the number of times we have switched between different branches and track our activities in the git repository.

git reflog

To stash out all of the work done in the local branch we can use the following command.

git stash

NOTE: After stashing we can still retrieve the stashed code and no need to worry. The changes are not removed permanently but instead stashed in the holding area of Git.

To display the list of stashed changes in our system,

git stash list

To stash the most recent version back to life use the below command,

git stash pop

To display the difference between the two branches,

git diff BRANCH1 BRANCH2

NOTE: This command displays the detailed changes along with the chunk.

To view limited changes or differences between 2 branches, we can use a flag called —name-status. Let's take a look at an example to understand the concept a bit more,

git diff --name-status master sub_branch

Here were are adding the —name-status flag for the git diff command. Now the terminal shows only the difference in files instead of detailed changes or chunks between the 2 branches which are specified.

This command helps to merge the changes between the branches.

git merge BRANCH2

As per this example the changes from BRANCH2 are merged into the current branch.

🗒️Git Commands - Section 4

So far, as you have observed we have never pushed or pulled code from the internet i.e.) remote repository. We have been locally working on our copy of the repository.

Software development is a collaborative process and to make it happen we have famous platforms such as GitHub. So to understand this in detail let’s take an example of how to push the code we created in our local repository and push it to the remote (GitHub).

In GitHub UI, let’s create a new repository and name it the same as our project folder my-awesome-project. Mark the repository as public and click on Create a new repository button. Leave other options as default.

Now you have created the big empty box (distributed repo) on the cloud which you can later on share with your teammates for collaboration. But first, you need to link your local with the remote.

To do that first, you must run the following command,

git remote add origin <https://github.com/OWNER/REPOSITORY.git>

This command will add a new upstream origin point for your repository pointing to the URL.

Now we can publish or push the code to the GitHub repository.

git push -u origin master

Here the -u shorthand flag represents upstream. By adding this we tell our local git to always push my upstream code to the configured GitHub origin URL. Do note we are allowed to add multiple remotes and set different upstream based on our project complexity. But from a beginner learning perspective let’s stick to a single upstream source.

One of your friends now wants to work on your project as well. You pass the GitHub URL and ask to clone the repository. This can be done by the following command,

git clone <https://github.com/OWNER/REPOSITORY.git>

Once the repository is cloned they can make their changes to the files in the repository and push those changes to the GitHub. Later on, if you want their changes also to be in your system, Yes you have guessed it right. You need to pull those changes from the remote to your local.

git pull

Woah!!! 🤸🏻‍♂️ Such an exhaustive list of git commands we have learned so far.

These are some of the important commands which a developer should know and be familiar with. But the list does NOT end here. There is always room for improvement and we can extend the learning to more complex commands.

🚀Next Steps

Up until now, we have learned a few important git commands, their usages, and practical use cases. For the next steps, I shall link a few resources which I have used for my preparation to learn about Git and GitHub.

In the list of resources, one of the very useful books I read was the book written by Rick Umali. It helped me to understand Git from a totally different perspective which inspired me in writing this article. For software developers like us reading books may not be the quickest form of knowledge gain compared to other resources, but it helps us to sit down, relax and inspire us about what and why we want to learn.

🔗Resources Used

Database Consistency Matters !!!

Aravind Venkatesan — Fri, 09 Apr 2021 10:20:16 +0000

The Need For Understanding 😀

The distributed databases in general are reliant on the major tuning parameters.

Consistency is one of the key parameters used to build distributed databases.

The range of consistency tuning indicates the values to be returned from the nodes connected in the distributed cluster.

Simply put the consistency of the database lies in the spectrum from Strong Consistency to Eventual Consistency.

Strong Consistency <-------------------> Eventual Consistency

The consistency level of the database defines the rules for the nodes to return a set of values that are visible to the client. This differs based on the case-to-case basis and also reliant on the application requirement.

Let me demonstrate this concept with a simple example to explain the difference between strong and eventual consistency and how to choose one over the other when you are choosing a database or even trying to build one.

Example ⚽

Let's consider a foosball game between 2 teams Team A and Team B. It is the annual game party at your company and you are planning to develop an app to display the scoreboard.

Team A / Team B : 0 / 0

Now let us assume there is a concept of scorecard status at different time intervals.

Initial Time (Game Started)
Progression Time (Game In Progress)
Final Time (Game Completed)

The scoreboard data is entered by you at different time intervals as the game progresses and you are required to display the scoreboard as well.

Strong Consistency 💪

When you opt for the Strong Consistency things you need to take care of,

At any point in time, you need to display the last written value.
Follow Rule No.1 STRONGLY.

The example below shows the series of writes done by you on the scorecard.

Write("TeamA", 1); Write("TeamB", 1); Write("TeamB", 2); Write("TeamA", 2); Write("TeamA", 3);

So when the read operation is carried out at the time intervals in the cluster, the latest written value is returned. This is because we have opted for a stronger consistency.

Simply put, whenever the read operation for the scorecard is issued to your app, you need to observe the changes in all the previous or past writes in order to return the best possible output.

InitialTime: Team A / Team B : 0 / 0 ProgressionTime1: TeamA / Team B : 1 / 0 ProgressionTime2: TeamA / Team B : 1 / 1 ProgressionTime3: TeamA / Team B : 1 / 2 ProgressionTime4: TeamA / Team B : 2 / 2 ProgressionTime5: TeamA / Team B : 3 / 2 FinalTime: TeamA / TeamB : 3 / 2

So the best possible output for the Strong Consistency when the game is In Progress will be,

Team A / Team B : 3 / 2

Eventual Consistency 🙏

Now let's consider the Eventual Consistency scenario,

At any point in time, you are allowed to display any value written in the past.
You are also allowed to return the initial state as well.

Now the same write operation mentioned above takes place. The read operations with Eventual Consistency provides the below possible output,

InitialTime: Team A / Team B : 0 / 0 ProgressionTime1: TeamA / Team B : {0,1,2,3} / {0,1,2} ProgressionTime2: TeamA / Team B : {0,1,2,3} / {0,1,2} ProgressionTime3: TeamA / Team B : {0,1,2,3} / {0,1,2} ProgressionTime4: TeamA / Team B : {0,1,2,3} / {0,1,2} ProgressionTime5: TeamA / Team B : {0,1,2,3} / {0,1,2} FinalTime: TeamA / TeamB : 3 / 2

This example systematically explains the behavior of eventual consistency although the final state and the initial state of the game don't modify.

So the best possible output for the Eventual Consistency when the game is In Progress will be the range of values,

Team A / Team B : {0,1,2,3} / {0,1,2}

Explore Further 🔭

If you want to know the type of consistency level opted for the different types of databases here I have linked a one-stop solution

Select the database you want to explore from the above link and check the table for the field Consistency concepts.

Some examples include,

MongoDB, Cassandra, Dynamo DB - Eventual Consistency, Immediate Consistency
PostgreSQL - Immediate Consistency
Microsoft Azure Cosmo DB - Bounded Staleness, Consistent Prefix, Eventual Consistency, Immediate Consistency, Session Consistency

Bear in mind: Strong and Eventual are not the only type of consistencies available. There are different levels of consistency that fall between the range of the spectrum that I have explained in this article. If you would like to know more about the different levels of consistencies, please do leave a comment so that I can write subsequent articles explaining them as well.

This post is a simpler version of the detailed article created by

Terry, D. (2013). Replicated data consistency explained through baseball. Communications of the ACM, 56(12), 82-89.)

For further detailed study visit the link here

Photo by Ak Ka on Unsplash

The Wrong Migration

Aravind Venkatesan — Sun, 14 Mar 2021 11:44:32 +0000

Imagine you are working on your first job, you make a mistake. Yes, it is acceptable. The team coordinates swiftly to help rectify your mistake.

Imagine you are 10+ years experienced senior engineer working on the most critical project of your company, you make the same mistake. Yes, it is still acceptable. The team again coordinates swiftly to help rectify your mistake.

A person who never made a mistake never tried anything new.
--Albert Einstein

Microsoft's open-source step has attracted more developers into the .NET Core community. Enterprise adoptions are also improving. Learning new things is one of the important aspects for developers to stay in the current trend.

And the courage to learn new things and the passion for learning them will eventually lead us to success. Of course, success is not achieved overnight. Making mistakes is one of the stepping stones to reach success.

Using dotnet-cli commands might look plain and straightforward. With the help of ef core additions, the database migrations have become easier compared to the legacy way of creating migrations.

To create a new migration: 🆕

dotnet ef migrations add <Migration-Name>

To update the migration to the database: 🚀

dotnet ef database update

To remove the wrong migration: ⛔

dotnet ef database remove

Seems the above commands look simple and straightforward. So the biggest question in your mind, "Why did I even create this article if applying migrations to the database is so simple?"

Here is the catch. Working on large-scale projects with multiple teams is different.

After updating the database, we cannot use the dotnet ef database remove command to remove the migration since it is already applied. 😫

If you are working independently on your project or learning from a tutorial, simply you can add an altering migration file or even drop the database delete the migration files, and start from scratch.

But do you really know how to handle the wrong migrations situation when working in teams or in your day job?

The purpose of the article is catered to handle this situation.

Situation: 💻

You have included a column blog_description with max_length(100) and created a migration file.
You applied the migration in your local database and pushed the code for review.
The reviewer says, "Hmmm, I want you to change the column max_length(100) to max_length(255)"

Possible problems you might face include, 🙄

Need to modify your local development database. (Other environments if any exists)
Notify your team members working on the same branch. (For whatsoever reasons)
Have a track of other team's migrations changes for the same or the related entities.

The easiest workaround for this situation is submitting another migration altering the max_length of the column blog_description. But this is not the right way to do it.

In this situation possibly you have not done a mistake but you have got an opportunity to learn how to manage this situation.

Resolution: ✅

First, pull the code from the master branch to get the latest good migrations if any committed by other teams.
Verify whether changes exist in the same or related entity. If any exists, contact the respective developer or team to arrive at a consensus about the entity.
Update the database with the latest good migration pulled from the master branch.

dotnet ef database update <Last-Good-Migration>

Remove the redundant migration you have added.

dotnet ef database remove

By applying the latest migrations to the database to the simply indicates that the latest one added by you is redundant or defunct. Now once you run the remove command, the ef core cli removes the "wrong" migration added by you.

Handling these types of situations in the workplace is an art. It can be learned only by the virtue of experience.

Finally, you might ask me, "Hey, what about the guy who was working on the same branch?" 😂

"Well, tell him not to 😈"

Learn More Here