DEV Community: Mukesh Kuiry

Lets understand two phase commit of distributed system using Zomato's 10 minute food delivery.

Mukesh Kuiry — Thu, 19 Sep 2024 20:24:33 +0000

To achieve rapid delivery, quick-commerce companies such as Zomato rely on strategically located dark stores stocked with commonly ordered items. Orders are accepted only if the item is available in a nearby dark store. Zomato bulk-purchases commonly ordered food items and stores them in these dark locations, ensuring they are ready for quick delivery. Once an order is placed, the food is warmed and delivered quickly.

Business Requirements

In order to accept an order, Zomato needs two things:

Available food from the dark store.
A delivery partner ready to deliver.

If either of these services fails, the order must be canceled.

Atomicity in DBMS (Database Management System)

From a database perspective, ensuring atomicity means that both the food preparation and the delivery assignment must happen as one atomic transaction — meaning either both succeed, or neither does.

If the food is prepared but the delivery partner fails to show up, the food may spoil or need to be rewarmed.
If the delivery partner is ready but the food is unavailable, the delivery partner will waste time, leading to poor user experience.

Two-Phase Commit (2PC) Protocol

To handle this, both the food preparation and delivery service must be completed atomically, and this is where the Two-Phase Commit (2PC) protocol comes into play. The 2PC protocol ensures that both services either succeed or fail together.

The Two-Phase Commit Protocol consists of two steps:

Prepare Phase
Commit Phase

How It Works:

When an order is placed, Zomato reserves both the food packets and a delivery agent before confirming the order. This ensures that orders are only accepted when both the food and delivery partner are reserved.

Prepare Phase:

Both the food and delivery agent are reserved for a limited time (using a timeout to avoid deadlock).
If both reservations succeed, the system moves to the commit phase.
If either the reservation of food or the delivery agent fails, the transaction is canceled.
If one succeeds but the other fails, the reservation is canceled and resources are released.

Commit Phase:

If both the food and the delivery agent are successfully reserved, the order is committed.
If either reservation fails, the order is canceled, and any held resources (food and delivery agent) are released.

Advantages:

Guaranteed Atomicity: Ensures that either both the food and delivery are successfully reserved, or neither is.
Guaranteed Isolation: Each transaction operates independently and doesn't interfere with other transactions.

Disadvantages:

Slower Processing: Due to the steps required to ensure atomicity, the process may be slower than simpler approaches.
Potential for Deadlocks: With multiple transactions attempting to reserve resources, deadlocks can occur unless managed carefully using timeouts and other safeguards.

Stay tuned for the code implementation blog!

Thanks for reading.

Dragonfly DB: A Promising Alternative to Redis

Mukesh Kuiry — Tue, 17 Sep 2024 09:34:14 +0000

Dragonfly DB is a drop-in replacement for Redis.

It's known for its high operation rate.

Dragonfly DB is multi-threaded, and Redis is single-threaded, which makes it faster. For example, if your machine has 12 cores, Redis can only use 1 core, whereas Dragonfly DB is designed to use the maximum possible cores.

To scale Redis, we need to create multiple copies of it and scale horizontally, whereas in the case of Dragonfly DB, we can scale it vertically.

Dragonfly DB is written in C++ and uses the Boost.Fiber library to execute on multiple processes.

The architecture that makes Dragonfly DB possible is the "share-nothing" architecture.

In this architecture, the namespace is shared into n parts, where n is the number of logical CPU cores.

Each data block gets its own set of heap data structures to execute separately. You can say it's an orchestrated group of multiple Redis processes.

Now, in the case of multi-access architecture, the main problem is mutex locks. To solve this problem, they used a message bus where all the incoming connection requests are placed, and a connection pool is created. The message worker eventually picks the connections and pairs them with the suitable data block.

This beautiful architecture makes Dragonfly DB faster and more efficient.

Follow for upcoming posts to learn more!

9 Free VS Code Extensions to Boost Your Productivity! 🚀

Mukesh Kuiry — Sun, 21 Jan 2024 10:31:45 +0000

Hey DEV Fam! 🚀

Let's dive into the fantastic world of VS Code extensions! 🎉 One of the coolest aspects of Visual Studio Code is its extensive collection of extensions that can supercharge your coding experience without denting your wallet.

Today, I'm excited to share 10 incredible free extensions from the VS Code Marketplace to take your coding game to the next level. Let's jump right in!

1. VS Code Auto Rename Tag 🏷️

Say goodbye to tag renaming headaches! This nifty extension takes care of both opening and closing tags automatically.

2. Prettier in VS Code ✨

Make your code sparkle with the Prettier extension. It beautifies your code, ensuring readability. Choose to format on save or paste.

3. Convert Pixels to Rem in VS Code 🔄

No more unit conversion headaches! This extension effortlessly converts between pixels (px) and root em (rem). Just press alt + z to switch between the two.

4. VS Code Flexbox Cheatsheet 🤸‍♂️

Master Flexbox with this handy cheatsheet. Access it through shortcuts or by hovering over a flex display.

5. Grid Snippets VS Code Extension 📐

Level up your CSS Grid game with intuitive shortcuts for displaying grids and setting grid-template-columns.

6. Bracket Pair Colorizer 🌈

Eliminate brace confusion! This extension assigns vibrant colors to different types of braces, enhancing code clarity.

7. VS Code Icons 🖼️

Aesthetics matter! Elevate your coding experience with file icons reflecting the language or framework you're working in.

8. Polacode 📸

Capture the beauty of your code with Polacode. Take stunning screenshots effortlessly with a simple shortcut.

9. Code Time ⏰

Track your coding journey! Code Time provides insights into progress, metrics, and even team collaboration – all for free.

Thanks for exploring these awesome extensions with me!

Happy coding! 🚀💻

Overview of Basic Docker Terminologies

Mukesh Kuiry — Fri, 19 Jan 2024 00:29:46 +0000

Hello Dev friends! 👋

Welcome to the series of Beginner to Expert guide on Docker 🐋 & Kubernetes ☸️ 🚀

From our previous blog, I hope you got the idea of how Docker comes in the present.

If you haven't read it, I recommend you to read it before you jump into this article; it will ease your Docker journey.

Now, from this article, we will truly dive into Docker tutorials, not actually from this article, but from the next article 😁, in this article, we will know the terminologies involved in Docker (which is important) for a better understanding of the whole Docker article series.

Containerization 🛡️

Containerization is a modern technology that allows us to bind the whole binaries/libraries and source code into a single pot to run into any infrastructure.

For a practical example, we can say that we can deploy a node.js backend API into AWS EC2 infrastructure.

Here combining the node.js code and packages into a single container is called containerization.

Docker 🐳

People usually interchange the terms Docker and containerization, but both have different perspectives and use cases. While containerization is a technique, Docker is the popular toolkit to container an application.

Docker helps us to containerize the application and use this Docker container to deploy in any infrastructure efficiently.

Images 🖼️

I guess, you may often come across the term **docker image**, yes that is the image. Basically, an image is a file containing the information to build a container.

We usually start with a base image and modify it according to our project needs.

Container 🚢

A container is a lightweight portable instance of an image, which is usually deployed in any infrastructure to run any application.

Ports 🌐

Containers are usually deployed on a remote server and to communicate with that container, we need to define the port. So, a port is the container gateway that helps us to talk and use the deployed containerized application. 🚪

Volumes 💽

Volumes refer to the amount of disk storage allocated to the container during deployment. This volume helps us to run the application efficiently. Wisely calculating volume is crucial for efficient resource management.

Registry 📦

Registry refers to the store of different container images. It allows us to store our container images with versions. It stores each image with a unique name.

Docker hub is a popular Docker container registry to store Docker container images.

I guess these are enough for now to know; from the next post, we will jump into installation and then start with the main concepts of Docker and Kubernetes.

Till then see you Bye Bye! 👋

Follow for more @mukeshkuiry !

LinkedIn
X-(Twitter)

🎉 Celebrating 5000+ followers on DEV

Mukesh Kuiry — Mon, 15 Jan 2024 11:15:04 +0000

Hey DEV friends and followers! 🙌

I just wanted to take a moment to thank each and every one of you for being with me on this journey. 🎉

It brings me so much joy to share that we've surpassed 5000 followers! Your support means the world to me, and I'm genuinely grateful for this fantastic community. 🧑‍💻

Here's to more exciting times ahead! Cheers! 🍻🍺

How Docker Evolved | History of Containerization

Mukesh Kuiry — Thu, 11 Jan 2024 01:04:21 +0000

Hello, Dev Freinds! 💖

Welcome to the series of Beginner to Expert guide on Docker 🐋 & Kubernetes ☸️

From our previous blog, I hope you got the idea of why containers are used. If you haven't yet read it, do check it out before jumping here.

Now let's go way back to the past and understand how we came up with this idea of containers.

Bare Metal System

Before containerization, or even before virtualization, there is only one type of machine, which is usually called a bare-metal system.

In a bare-metal system, we usually have a host machine where we need to install OS, binaries, libraries, and dependencies, and then run applications on top of that.

But there are a lot of issues with this system.

Here in the figure, we can see the shared level of binaries and libraries. And now imagine you have two applications that require the same library but a different version. So, maintaining two versions of the same library is difficult. For that, we need to set different environment variables for different processes.
Due to these dependency issues, it's harder to manage multiple applications on the same machine. Which ultimately leads to low utilization of resources, which makes it an inefficient system.
As all the applications are running on the same host machine, the failure of one system can lead to the failure of multiple applications because they may share the same dependencies.
The start-up and shut-down times of these systems are usually high.
Provisioning a new system and decommissioning a system takes lots of time (hours).

Virtual Machine

Then, around 2000–2005, a new concept of virtual machines emerged to solve some of these problems.

In a virtual machine system, the system tries to divide the system resources into multiple parts and use them to run any application independently.

There are also two types of virtual machine concepts.

Type 1 virtual machines are basically where there is no underlying virtual machine, and in Type 2 virtual machines, there is an underlying operating system for the host machine.

So the main benefits of using a virtual machine rather than bare machines are:

No dependency conflict
Better utilization of resources, i.e., more efficiency.
Small bluster radius
Fast start-up and shut-down times
Fast provision and decommission time (minutes).

Container

To take the concept of virtual machines to the next level, we came across the concept of containers.

The main difference between a virtual machine and a container is that a virtual machine has its own kernel, while a container shares the kernel of the host machine.

The advantages of containers are:

It's taking advantage of virtual machines with faster startup, shutdown, provision (seconds), and decommission times. And also, it's lightweight to use in development.

Virtual Machine + Container

The most common configuration you can see in real-life applications is that it combines the concept of a virtual machine with containers for better performance and isolation.

Container Orchestration

To take it one step further, Container Orchestration like Kubernetes is used to manage multiple containers.

Here Node defines each independent container.

Trade-Off

To summarize them all, I've prepared a chart that shows the benefits and difficulties of all the types of systems mentioned.

I hope you liked the explanation of the history and evolution of virtualization.

So, buckle up and go through this series to understand better. 🚀

See you soon in the next blog. 👋

Connect with me on LinkedIn and Twitter for more. 🌐👩‍💻

Why You Should Learn Docker 🐋 & Kubernetes ☸️?

Mukesh Kuiry — Sun, 07 Jan 2024 00:01:22 +0000

If you are a developer, I'm sure you must have heard this phrase: "It works on my machine." It's heartbreaking when our code runs on your machine but behaves undesirable on a friend's machine.

There are multiple reasons for that.

It may happen because of a package error, like when you use a different version of a package and your friend is using an old version, so a feature is not accessible for your friend.

Or may happen due to the operating system. like you have MacOS but your friend has Windows OS, and the library or package you are using may not be present on your friend's operating system. blah blah blah!!

Why Docker?

Lemme give you some practical examples of what docker tries to solve. Surely this is going to blow 🤯 your mind.

Development

Install Postgres, MongoDB, Node.js, run multiple scripts, etc. Oh, wait, you are on macOS? Also, change these configurations. It sounds familiar, naa. Yeah, these are the steps involved in setting up the development environment.

What if I told you that you could do it in one step? Yes, you need to run the docker compose up command. Easy pisy.

It makes the development environment setup so easy.

Deployment

For deploying any project, you need to create a cloud instance, install OS, install libraries, install dependencies, copy binaries, and then run it with these options.

But wait, there is a simple process: just run the container image with options. Deployed 🎉

So now deployment process is no longer complex, docker solves this problem by creating easy-to-use portable containers.

Why Kubernetes?

Now you may ask, if docker solves this problem then, what Kubernetes does?

Imagine you have a web application that has gained popularity rapidly. Initially, running a single instance of your application on a server was sufficient.

However, as user traffic grows, a single server becomes insufficient to handle the load efficiently. Without Kubernetes, scaling your application manually would involve setting up additional servers, configuring load balancing, and managing traffic distribution a complex and time-consuming process.

Kubernetes helps here to automatically provision and remove server instances according to the load. It efficiently manages load balancers, ensures high availability, and seamlessly handles failures

So, I hope you now have the motivation to learn Docker and Kubernetes.

Believe me, it is going to help a lot in your development process. and also give you an edge over the hiring process.

So, buckle up and go through this series to understand better. 🚀

See you soon in the next blog. 👋

Connect with me on LinkedIn and Twitter for more. 🌐👩‍💻

Beginner to Expert guide on Docker 🐋 & Kubernetes ☸️ | Series

Mukesh Kuiry — Sat, 06 Jan 2024 23:02:20 +0000

Hello, techno-travelers! 🌐🚀

Welcome to the new blog series on Docker 🐋 & Kubernetes ☸️, where I'm going to unveil the mysterious power of containerization based on my 2 years of experience in developing containerized applications.

I'm confident that by the end of this series, you will be able to easily containerize and deploy 🎉 your projects.

Now, let's quickly provide you with an overview of what I'm going to teach you.

Table of blogs ✍️

Docker 🐋 Dive:

Motivation behind Containers
Docker's Evolution
Decoding Docker Terms
Setting Up Docker & Hello World
Navigating 3rd Party Containers
Creating a Demo with Docker
Building Docker Images 101
Understanding Container Registries
Running and Managing Containers
Container Security Essentials
Interacting with Docker Objects
Optimizing Development Workflow
Code to Cloud: Deploying Containers

Kubernetes ☸️ Journey:

Kubernetes Essentials
Building a Local Kubernetes Cluster
Creating and Scaling Deployments
Services and Deployments with YAML
Connecting Deployments
Switching Runtimes: Docker to CRI-O

Connect with me on LinkedIn and Twitter for more. 🌐👩‍💻

Stay tuned for upcoming blogs!

Till them keep coding! Bye 👋

10 Must-Know Git Commands for Every Developer

Mukesh Kuiry — Fri, 05 Jan 2024 19:20:41 +0000

Understanding Git and GitHub is crucial for any developer, providing effective version control and code management. Proficiency in these tools sets you apart and enhances your productivity. In this blog post, we will explore a set of Git commands to kickstart your journey into software development.

Git Vocabulary

Before delving into the commands, let's acquaint ourselves with some Git terminologies. This understanding will not only help you grasp Git better but also provide a foundation for your overall comprehension.

Repository

A repository, or repo, serves as a storage space where your project's source code and its version history are stored.

Working Directory

The working directory is where you currently make changes to your project, housing the files you are actively working on.

Staging

Staging acts as an intermediate area between the repository and your working directory. It's where you add changes before committing them to the main repository.

Commit

A commit is a snapshot of proposed changes to the stage, identified by a unique identifier (SHA-1 hash) and accompanied by a commit message.

Branch

A branch represents a parallel version of your repository, facilitating work on different features or bug fixes independently.

Merge

Merging involves combining proposed changes into the main repository, often utilized to integrate new features into the main project.

Pull

Pulling refers to fetching code from any remote repository and merging it into your local repository, i.e., working directory.

Push

Pushing involves sending your local changes to any remote branch of any repository.

Clone

Cloning is the process of creating a local copy of the main repository, establishing a connection for efficient pull and push.

Fetch

Fetching downloads changes from any remote repository to the local repository, without directly merging them into your local repository. It is useful for reviewing changes before merging.

Fork

Forking creates a personal copy of someone else's repository on your GitHub account, enabling changes without affecting the original repository.

Conflict

A conflict arises when two or more branches have changes in the same part of the code, and Git cannot directly merge them.

Head

In Git, HEAD is a pointer/reference always pointing to your latest commit in the current branch. When you make a new commit, HEAD moves to the top of your commit.

Now, let's explore the 10 Git commands one by one.

1 - Adding and Committing Files Together

Traditionally, in Git, we use the git add * command to stage all modified files for a subsequent commit. Subsequently, we use the git commit -m "commitMessage" command to commit these changes. However, a more streamlined command exists, achieving both tasks in a single step:



git commit -am "commitMessage"

The -am flag allows us to stage these changes and commit them in one efficient operation.

2 - Creating and Switching to a Git Branch

Similar to the previous scenario, another command combines the functionality of two commands. Instead of using separate commands, use git branch branchName to create a branch and git checkout branchName to switch to it. Achieve both tasks in a single step with the following command:



git checkout -b branchName

The -b flag with the git checkout command allows us to create a new branch and immediately switch to it.

3 - Delete a Git Branch

To delete a branch in Git, use the git branch -d or git branch -D command. The -d option is for a safe deletion, only deleting the branch if fully merged into the current branch. The -D option is for forceful deletion, regardless of whether it's fully merged. Here are the commands:

Safe deletion (checks for merge):



git branch -d branchName

Forceful deletion (doesn’t check for merge):



git branch -D branchName

4 - Renaming a Git Branch

To rename a branch, use the git branch -m command followed by the current branch name and the new desired branch name. For example, to rename a branch called oldBranch to newBranch, run:



git branch -m oldBranch newBranch

If you want to rename the current branch where you are working, without specifying the old name, use the following command:



git branch -m newBranchName

Here, you don’t need to specify the old branch name because Git will assume you want to rename the current branch to the new name.

5 - Unstaging a Specific File

Occasionally, you may want to remove a particular file from the staging area, allowing additional modifications before committing. Use:



git reset filename

This will un-stage that file while keeping your changes intact.

6 - Discarding Changes to a Specific File

To completely discard changes made to a specific file and revert it to its last committed state, use:



git checkout -- filename

This command ensures the file returns to its previous state, undoing recent modifications. It’s a helpful way to start fresh on a particular file without affecting the rest of your changes.

7 - Updating Your Last Git Commit

Imagine you’ve just made a commit in your Git repository, but then you realize that you forgot to include a change in that commit, or perhaps you want to fix the commit message itself. You don’t want to create a whole new commit for this small change. Instead, you want to add it to the previous commit. This is where you can use the command:



git commit --amend -m 'message'

This command modifies the most recent commit you made, combining any staged changes with your new comment to create an updated commit.

A thing to remember is that if you have already pushed the commit to a remote repository, you will need to force push the changes using git push --force to update the remote branch. A standard git push operation appends a new commit to your remote repository rather than modifying the last commit.

8 - Stashing Changes

Imagine you’re working on two different branches, A and B. While making changes in branch A, your team asks you to fix a bug in branch B. When you attempt to switch to branch B using git checkout B, Git prevents it, displaying an error:

We can commit our changes as suggested by the error message. But committing is

more like a fixed point in time, not an ongoing work in progress. This is where we can apply the error message’s second suggestion and use the stash feature. Use this command for stashing your changes:



git stash

git stash temporarily saves changes that you're not ready to commit, allowing you to switch branches or work on other tasks without committing incomplete work.

To reapply stashed changes in your branch, use git stash apply or git stash pop. Both commands restore the latest stashed changes. Stash applying simply restores the changes, while popping restores the changes and removes them from the stash. You can read more about stashing over here.

9 - Reverting Git Commits

Imagine you’re working on a Git project, and you discover that a particular commit introduced some undesirable changes. You need to reverse those changes without erasing the commit from history. Use the following command to undo that particular commit:



git revert commitHash

It’s a safe and non-destructive way to correct errors or unwanted alterations in your project.

For instance, let’s say you have a series of commits:

Commit A
Commit B (undesirable changes introduced here)
Commit C
Commit D

To reverse the effects of Commit B, run:



git revert commitHashOfB

Git will create a new commit, let’s call it Commit E, which negates the changes introduced by Commit B. Commit E becomes the latest commit in your branch, and the project now reflects the state it would have been in if Commit B had never happened.

If you’re wondering how to retrieve a commit hash, it’s straightforward using git reflog. In the screenshot below, the highlighted portions represent the commit hashes that you can easily copy:

10 - Resetting Git Commits

Let’s assume you’ve made a commit to your project. However, upon inspection, you realize that you need to adjust or completely undo your last commit. For such a scenario, Git provides these powerful commands:

Soft reset



git reset --soft HEAD^

When you use git reset --soft HEAD^, you are performing a soft reset. This command allows you to backtrack on your last commit while preserving all your changes in the staging area. In simple words, you can easily uncommit while retaining your code changes, using this command. It is handy when you need to revise the last commit, perhaps to add more changes before committing again.

Mixed reset



git reset --mixed HEAD^

This is the default behavior when you use git reset HEAD^ without specifying --soft or --hard. It un-commits the last commit and removes its changes from the staging area. However, it keeps these changes in your working directory. It is helpful when you want to un-commit the last commit and make changes from scratch while keeping the changes in your working directory before re-committing.

Hard reset



git reset --hard HEAD^

Now, let’s talk about git reset --hard HEAD^. It completely erases the last commit along with all the associated changes from your Git history. When you use --hard flag, there's no going back. So use this with extreme caution when you want to discard the last commit and all its changes permanently.

Thank you for reading. I hope this post is helpful, and you learned some new commands. If you have any further questions, don’t hesitate to reach out. Feel free to share any Git commands you tend to use in your daily routine and find super handy. :)

Connect with me
LinkedIn
X (formerly Twitter)

GO vs RUST speed test | Which one to choose in 2024

Mukesh Kuiry — Tue, 02 Jan 2024 20:58:46 +0000

TL;DR:

Go, developed by Google, is simple and readable, excelling in concurrency. Rust, from Mozilla, prioritizes memory safety and performance, making it great for systems programming. Go is simpler, Rust offers more control.

In performance, Go is efficient; Rust balances memory safety and performance.

According to Stack Overflow, 13.24% use Go, while 84.66% admire Rust.

Average salary: Golang - $92,760, Rust - $87,012.

Recommendation: Go is beginner-friendly, Rust for advanced control. Choose based on familiarity and project complexity.

Introduction

Go, developed by Google in 2007, emphasizes simplicity, efficiency, and readability. It excels in concurrent programming and scalability, with a straightforward syntax, making it popular for building distributed systems and web servers.

In contrast, Rust, introduced by **Mozilla** around 2010, prioritizes memory safety and performance. Ideal for systems programming, Rust's ownership system ensures memory safety without compromising performance, making it a powerful choice for building reliable and efficient systems.

Features

Go:

Simplicity and Readability: Go is designed with a straightforward and readable syntax, prioritizing ease of understanding and code maintenance.
Efficiency: Go achieves efficiency through a garbage collector, managing memory automatically to optimize resource utilization.
Concurrency: Go stands out for its built-in support for concurrent programming, offering goroutines and channels that simplify the development of scalable applications.

Rust:

Memory Safety: Rust places a robust emphasis on memory safety, incorporating features such as ownership and borrowing alongside a borrow checker to prevent common memory management errors.
Performance: Rust focuses on performance with zero-cost abstractions and low-level control, making it suitable for high-performance applications without compromising safety.
Fearless Concurrency: Rust provides a system for fearless concurrency, ensuring thread safety and empowering developers to write reliable and efficient concurrent code, particularly beneficial in systems programming scenarios.

In comparison, while Go excels in simplicity, readability, and efficient concurrency, Rust distinguishes itself with a strong commitment to memory safety, high performance, and a fearless approach to concurrency in the context of systems programming.

Performance

In the ever-evolving landscape of programming languages, developers often seek the right balance between simplicity, efficiency, and performance. In this exploration, we'll compare the performance of Go and Rust by measuring the time it takes to execute a seemingly simple task: printing numbers from 1 to 1 million.

Go: A Symphony of Simplicity and Concurrency



package main

import (
    "fmt"
    "time"
)

func main() {
    startTime := time.Now()

    for i := 1; i <= 1000000; i++ {
        fmt.Println(i)
    }

    duration := time.Since(startTime)
    fmt.Println("Execution time:", duration)
}

Execution time: 240.3113184s

Rust: A Dance of Safety and Performance



use std::time::Instant;

fn main() {
    let start_time = Instant::now();

    for i in 1..=1000000 {
        println!("{}", i);
    }

    let duration = start_time.elapsed();
    println!("Execution time: {:?}", duration);
}

Execution time: 313.9177696s

After running these programs separately, we observed the execution times. While the specific times may vary based on the environment and hardware, this simple experiment provides a glimpse into the relative performance of Go and Rust for a basic task.

In our test, Go demonstrated its efficiency in handling the task, leveraging its simplicity and built-in concurrency support. Rust, with its strong focus on memory safety and performance, showcased its capabilities even in a seemingly straightforward scenario.

It's important to note that performance considerations extend beyond a single task, and the choice between Go and Rust should be based on the specific requirements of your project. Whether you lean towards the simplicity of Go or the power of Rust, these languages offer unique advantages that cater to diverse programming needs.

Developer Opinion

In May 2023, more than 90,000 developers participated in Stack Overflow's annual survey, sharing insights into their learning methods, skill enhancement strategies, and tool preferences.

Among the 87,585 responses analyzed, 11,596 individuals, representing 13.24% of the respondents, reported using Go in the past year.

And, 11,429 participants, equivalent to 13.05%, indicated their usage of Rust over the same period.

Apart from documenting the technologies developers utilized in the past year, the survey also delves into the tools currently in use and those developers aspire to continue using in the future.

According to the survey findings, Rust is highly favored, with 84.66% of developers expressing admiration for the language, and 30.56% expressing a desire to continue using it. Go, while still popular, shows slightly lower figures, with 62.45% admiration and 20.59% expressing a desire to use it further.

As per the survey results, the average salary for a Golang developer is reported to be $92,760, while Rust developers have an average salary of $87,012. These figures provide insights into the compensation trends within the respective developer communities, with Golang developers commanding a slightly higher average salary compared to their Rust counterparts.

Read the whole survey here -

Stack Overflow Developer Survey 2023

In May 2023 over 90,000 developers responded to our annual survey about how they learn and level up, which tools they're using, and which ones they want.

survey.stackoverflow.co

My Recommendation

If you're new to coding, Go is a great pick with its simple and beginner-friendly features. Its clear syntax makes learning the basics a breeze, making it an ideal choice for those starting their programming journey.

On the flip side, if you're looking for a more advanced language that provides better control and performance, Rust is a compelling option. Despite a steeper learning curve, Rust's emphasis on memory safety and concurrency offers a powerful toolkit for experienced developers tackling complex projects.

Ultimately, the choice between Go and Rust hinges on your familiarity with coding and the complexity of the projects you aim to undertake. Go offers simplicity, while Rust provides a deeper understanding and greater control for those ready for a more advanced coding experience.

Follow for more such content. @mukeshkuiry :)

Do let me know your favorite programming language in the comment below.

Top 8 Tech Skills You Must Learn in 2024 to Get a Job in Today's Dynamic Job Market

Mukesh Kuiry — Sun, 31 Dec 2023 10:38:33 +0000

The world of work is changing rapidly, and with it, the skills that employers are looking for. To stay ahead of the curve and land your dream job in 2024, it's essential to identify the hottest tech skills in demand.

1. Leadership with Empathy: Forget the old-school, authoritarian leader. Today's successful leaders prioritize empathy, strategic thinking, and employee development. As AI and other disruptive technologies reshape the workplace, the ability to guide teams through change with compassion and understanding is crucial.

2. Artificial Intelligence (AI) Everywhere: AI is no longer science fiction; it's rapidly transforming every industry. Coursera saw a whopping 6.8 million enrollments in AI-related courses this year, with "Generative AI for Everyone" becoming the fastest-growing course ever. Mastering AI fundamentals will give you a significant edge in the job market.

3. Cybersecurity Fortress: With cyberattacks on the rise, cybersecurity skills are in high demand. Half of the top tech skills listed in the report are cybersecurity-related, and there's a global shortage of nearly 3.5 million cybersecurity professionals. Investing in these skills will open doors to exciting and well-paying opportunities.

4. Business Savvy in the Digital Age: The ability to navigate the digital landscape is essential for success in any field. Business skills, particularly in digital marketing and customer experience, are seeing explosive growth. Mastering these skills will make you a valuable asset to any organization.

5. Data Whisperer: Data is the new oil, and the ability to understand and communicate it effectively is a superpower. Data visualization, data analysis, and data storytelling are all top-growing skills. By investing in data literacy, you'll be able to unlock insights and make informed decisions, propelling yourself and your organization forward.

6. Web Development Prowess: The web is still the backbone of the digital world, and web development skills remain highly sought-after. Expertise in web frameworks like React and Angular, along with cloud computing skills, will keep you in demand across industries.

7. Compliance Captain: As AI raises new questions about data privacy and copyright, skills in audit and compliance are becoming increasingly important. This is particularly true for government institutions and organizations grappling with the ethical implications of emerging technologies.

8. Curated Learning Pathways: Forget about piecemeal learning. Professional Certificates and Specializations, which offer structured learning paths, are driving significant skill rank changes. These programs not only enhance your skills but also boost your employability and internal mobility, making you a more attractive candidate to employers.

By focusing on these eight in-demand skills, you'll be well-positioned to thrive in the ever-evolving job market of 2024. Remember, staying ahead of the curve requires continuous learning and upskilling. Embrace the exciting tech landscape, invest in your skillset, and watch your career skyrocket!

This blog post is just a starting point. Feel free to expand on each skill, provide specific learning resources, and share inspiring success stories to make your blog even more engaging and informative. Good luck!

What I'll be learning in 2024

Mukesh Kuiry — Fri, 29 Dec 2023 20:28:30 +0000

Hey fellow tech explorers! Buckle up, because I'm about to blast off on a journey through my coding adventures in 2023 and the exciting roadmap I've charted for 2024.

2023: Building a Solid Foundation

In 2023, I dove headfirst into the vibrant world of frontend development, mastering the art of crafting dynamic and interactive interfaces with React JS ⚛️, the king of component-based architecture.

To turbocharge my workflow, I embraced Next.js ⚡️, its superpowered framework that brought server-side rendering and static site generation to the party.

And to add some pizazz to my interfaces, I sprinkled in the magic of Tailwind CSS ✨, a utility-first approach to styling that let me whip up beautiful and responsive UIs in a flash.

To ensure my code stayed sparkling clean, I adopted TypeScript ️, adding a layer of type safety and sanity to my projects.

But the frontend was just the launchpad.

I craved the power of the backend, so I plunged into the world of Golang ⚡️. This versatile language, with its lightning-fast performance and concurrency magic, quickly became my go-to weapon for tackling everything from web development to system programming.

I also explored the vast realm of cloud computing with AWS ☁️. From storage with S3 to serverless magic with Lambda, I learned to build scalable and cost-effective solutions that could handle anything the digital universe threw at them. ✨

To keep things spicy, I sprinkled in some Firebase goodness, a one-stop shop for backend development and user authentication that made my life a breeze.

Finally, I rounded out my 2023 skillset with the ever-reliable MongoDB, a NoSQL database that became my trusty sidekick for managing all sorts of data beasts.

2024: Diving Deeper and Exploring New Horizons

In 2024, I'm gearing up for a full-fledged tech feast! Here's a taste of what's cooking:

Going Deep in Familiar Waters

Golang (Deep Dive) : Time to unlock the hidden potential of Go! I'm diving deep into its concurrency model, memory management, and advanced features to unleash its full power on even the most complex projects.
AWS (Deep Dive) ☁️: The cloud is vast, and I'm not done exploring! I'm gearing up to master advanced AWS services for networking, security, and containerization, building an even more robust and adaptable cloud toolkit.

Venturing into New Horizons

Rust : The whispers of Rust's memory safety and performance have been irresistible. In 2024, I'm taking the plunge to learn to build robust and reliable systems with this promising language. ️
AI/ML Integration : The future is AI, and I'm ready to join the party! I'm excited to explore how I can integrate AI and machine learning into my projects, adding intelligence and personalization to user experiences. ✨
Monorepos ️: Managing multiple projects can be a tangled mess. I'm intrigued by the potential of monorepos to streamline my development workflow and foster collaboration.
Prompt Engineering 🪄: The world of large language models is fascinating, and I'm curious to unlock their full potential. I'm diving into the art of crafting effective prompts to guide these AI beasts towards creative text generation and task completion. ✨

So, there you have it!

My tech odyssey continues, and I'm more excited than ever to explore the uncharted territories that 2024 holds.

Stay tuned as I document my journey, share insights, and hopefully inspire you to join me on this incredible adventure!

Remember, the only limit is your imagination (and maybe a few lines of code ).

Let's keep coding, keep learning, and keep pushing the boundaries of what's possible!