DEV Community: Vaibhav Thukral

Learn these 13 Git commands because you'll be using them 99% of the time:

Vaibhav Thukral — Sun, 18 Aug 2024 10:57:40 +0000

1) git init

Initialize a new Git repository.

This creates a new subdirectory named ".git" in the current directory, where Git stores all the metadata for the repository.

2) git clone

Clone an existing repository.

This creates a local copy of the repository, including all of its history and branches.

git clone <repo-link>

3) git add

Stage changes for the next commit.

This adds the specified file(s) to the staging area, where they will be included in the next commit.

git add file1.txt file2.txt

4) git commit

Create a new commit.

This records the staged changes and any additional changes made since the last commit, along with a commit message describing the changes.

git commit -m "Add new feature"

5) git push

Push commits to a remote repository.

This sends the local commits to the specified remote repository, updating the branch on the remote with the new commits.

git push origin main

6) git pull

Fetch and merge changes from a remote repository.

This retrieves the latest commits from the specified remote repository and merges them into the current branch.

git pull origin main

7) git branch

List, create, or delete branches.

This command can be used to list the available branches in a repository, create a new branch, or delete an existing branch.

git branch new-branch

8) git checkout

Switch to a different branch.

This command allows you to switch to a different branch in the repository and make it the current working branch.

git checkout main

9) git merge

Merge one branch into another.

This command combines the changes from one branch into another branch, creating a new commit that reflects the merged changes.

git merge new-branch

10) git status

Show the status of the repository.

This command displays the current branch, any staged or unstaged changes, and any untracked files.

git status

11) git rebase

Incorporate changes from one branch into another branch.

Let's say you have made some changes on an "XYZ" branch that you want to incorporate into the "main" branch. You can use git rebase to reapply your changes on top of the main branch.

12) git stash

Temporarily save changes that you are not yet ready to commit.

If your changes are not ready to commit but you want to work on a different branch, you can temporarily save your changes for later use and switch branches without losing your progress.

13) git revert

Let's say you have made a mistake in a previous commit and you need to undo it. You can use git revert to create a new commit that undoes the changes introduced by the previous commit.

git revert <commit1>..<commit2>

Lambda functions in Python clearly explained!!

Vaibhav Thukral — Thu, 08 Aug 2024 05:30:17 +0000

In this post we will explore Lambda functions in Python:

What exactly is lambda functions?
Why Do We Need Lambda Functions?
When to Use Lambda Functions?
Best Practices
Examples

What exactly is lambda functions?

In Python, a lambda function is a small, anonymous function that can take any number of arguments, but can only have one expression. It's a shorthand way to create a function without declaring it with the def keyword.

Still confused?

Let's understand in laymen's terms

A lambda function is a small, shortcut way to create a simple function. Think of it like a recipe:

Normal Function (Recipe)

Write down a list of steps (function name, ingredients, instructions)
Follow the steps to make the dish (call the function)

Lambda Function (Quick Recipe)

Write down just the essential steps (ingredients, instructions)
Use it to make the dish quickly (call the lambda function)

In programming, a lambda function is a concise way to:

Take some input (ingredients)
Do a simple task (instructions)
Return the result (dish)

It's like a quick, disposable recipe that you can use once or multiple times, without having to write down the full recipe book!

Syntax of Lambda Function

Where arguments is a comma-separated list of variables that will be passed to the function, and expression is the code that will be executed when the function is called.

Let's create a lambda function that takes one argument, x, and returns its square:

In this example, x is the argument, and x ** 2 is the expression that will be executed when the function is called. We can call this function like this:

print(square(5)) # Output: 25

Example: Lambda Function with Multiple Arguments

Let's create a lambda function that takes two arguments, x and y, and returns their sum:

In this example, x and y are the arguments, and x + y is the expression that will be executed when the function is called. We can call this function like this:

print(add(3, 4)) # Output: 7

Lambda functions are often used with the map(), filter(), and reduce() functions to perform operations on lists and other iterables.

Example: Using Lambda with Map

Let's use a lambda function with map() to square all numbers in a list:

In this example, the lambda function lambda x: x ** 2 is applied to each element in the numbers list using map().

Why Do We Need Lambda Functions?

Lambda functions are useful when we need to:

Create small, one-time use functions
Simplify code and reduce verbosity
Use functions as arguments to higher-order functions (like map(), filter(), and reduce())
Create anonymous functions (functions without a declared name)

When to Use Lambda Functions

Use lambda functions when:

You need a quick, one-time use function that doesn't warrant a full function declaration
You want to simplify code and reduce verbosity
You need to pass a function as an argument to another function (like map(), filter(), and reduce())
You want to create an anonymous function

Example Scenarios

Data processing: Use lambda functions to perform simple data transformations or filtering
Event handling: Use lambda functions as event handlers for GUI applications or web frameworks
Functional programming: Use lambda functions to create higher-order functions and functional pipelines

Best Practices

Keep lambda functions short and simple
Use lambda functions for one-time use cases
Avoid using lambda functions for complex logic or multiple statements
Use named functions for complex logic or reusable code

By understanding lambda functions and their use cases, you can write more concise, readable, and efficient Python code.

What Exactly Concurrency in Go?: Running Tasks in Parallel

Vaibhav Thukral — Sat, 03 Aug 2024 12:05:02 +0000

In this post we will explore about concurrency in Go:

Understanding Goroutines
Sending data to Channels
Controlling Code Flow and Simultaneous Tasks

Understanding Concurrency & Goroutines

What is concurrency in Go and what are these Goroutines?

Before understanding concurrency and Goroutines first understand how go program normally executes when we are not using any concurrency features because in a normal program if we have bunch of function calls that do stuff these functions are simply executes after each other in a below image

From this above image it will call from left to right in a sequence until all each function return something and most important thing is second function only start after the first function is finished and so on..

In Go you can run code in parallel and execute function concurrently by using a feature called Goroutines.

func main(){
greet("Nice to meet you!")
greet("How are you")
slowGreet("How...are...you?")
greet("I hope you're liking this content")
}

This above code will work in a sequence the function will call one by one when after completing the each function execution

Assume slowGreet() functions take more than 2 mins to complete the execution of function after that last greet() function will execute.

Now to make it more faster we can use feature called Goroutines

To run this above code parallel by adding the go keyword

func main(){
go greet("Nice to meet you!")
go greet("How are you")
go slowGreet("How...are...you?")
go greet("I hope you're liking this content")
}

By adding this built-in go keyword you tell go that you wanna run these functions as go routines which in end simply means they still will be execute but they now run in parallel instead of after each other.

We just added the go keyword here nothing else.

When you run this code it finishes instantly but you also see we don't get any output here in the console.

Why this happens?

To understand this it's important to understand and keep in mind the idea behind running function as goroutine is to run it in a non blocking way so that the next operation their after next function call their after and so on.. can immediately be invoked so if we run all four functions as goroutines as we doing it above then we essentially just dispatch these four goroutines task in above code then we are done in the main function.

And it also doesn't return a value and that's a place where a function called doesn't wait for the goroutine to complete that's the idea it's just dispatch and then it goes it's own.

Now you might think that these greet functions are so simple that they should immediately print something to the console but dispatching these four goroutines starting these four goroutines is faster that's why its program ends without output.

So what's the solution?

The solution for this problem is called channels

Channels are typed conduits that allow goroutines to exchange data. They're like pipes that connect goroutines, enabling them to send and receive values.

Typed: Channels are declared with a specific type, which determines the type of data that can be sent and received through the channel.

Conduits: Channels act as a pipeline or a communication channel between goroutines, allowing them to exchange data.

Think of a channel like a pipe that can only carry a specific type of fluid (data). Just as a water pipe can't carry oil, a channel declared with a specific type can only carry data of that type.

Declaring Channels

Channels are declared using the chan keyword followed by the type of data they'll carry:

ch := make(chan int) // declares a channel of integers

Sending and Receiving

Goroutines can send and receive values on channels using the <- operator:

ch <- 42 // send 42 on the channel x := <-ch // receive a value from the channel

Channel Types

There are two types of channels:

Unbuffered Channels: No capacity, sending and receiving blocks until the other side is ready.
Buffered Channels: Has a capacity, sending and receiving doesn't block until the buffer is full or empty.

Buffered Channels
Buffered channels are declared with a capacity:

ch := make(chan int, 10) // declares a buffered channel of integers with capacity 10

Range and Select
Channels can be used with the range keyword to iterate over received values:

for x := range ch { // iterates over received values fmt.Println(x) }

Best Practices

Use channels to communicate between goroutines.
Use buffered channels for performance-critical code.
Close channels to avoid deadlocks.
Use range and select to handle channel operations.
By mastering channels, you'll be able to write efficient, concurrent, and safe Go programs.

The Kubernetes Glossary Cheatsheet: Essential Terms to Know Before You Start

Vaibhav Thukral — Sun, 28 Jul 2024 10:09:12 +0000

Learning a new technology or tool can be overwhelming, especially when encountering unfamiliar terminology.

Even with documentation, understanding these terms can be a challenge.

To help you get started with Kubernetes, here is a comprehensive list of Kubernetes terminology, along with explanations and practical examples:

1. Cluster: A group of machines (nodes) that run containerized applications.

Example: A cluster consists of 3 nodes: node1, node2, and node3.

2. Node: A machine (physical or virtual) in a Kubernetes cluster.

3. Pod: A pod is the smallest deployable unit in Kubernetes and not containers.

In Laymen terms think Pod is like a home and rooms are containers

Example: A Pod named "my-app" runs 2 containers: "app" and "db". so "my-app" is a home and "app" and "db" are each different rooms i.e two different containers.

4. Container: A lightweight and portable way to package applications.

Example: The "app" container runs a web server.

5. Deployment: A way to manage rollouts and rollbacks of Pods.

Example: A Deployment named "my-app" manages 3 replicas of the "my-app" Pod.

In Kubernetes, Deployment ensures that your application ("my-app") is always running with 3 instances (replicas), and handles updates and failures automatically!

By default replicas will have horizontal scaling.

6. ReplicaSet: Ensures a specified number of replicas (Pods) are running at any given time.

Example: A ReplicaSet named "my-app" ensures 3 replicas of the "my-app" Pod.

7. Service: Provides a network identity and load balancing for accessing Pods.

Example: A Service named "my-app" exposes the "my-app" Pod on port 80.

If it still not make sense to you let's understand in laymen's terms

Try to visualize imagine you have a lemonade stand (Pod) called "my-app", but it's located in a busy market (cluster) with many other stands.

You want customers to easily find and access your stand, without having to know its exact location.

A Service named "my-app" is like a signboard that points to your lemonade stand.

It provides a easy-to-remember name ("my-app") and a clear direction (port 80) for customers to find your stand.

Here's what the signboard (Service) does:

Gives your stand a name ("my-app") that's easy to remember
Directs customers to your stand on a specific path (port 80)
If you have multiple stands (Pods) with the same name, the signboard will distribute customers evenly among them (load balancing)

In Kubernetes, a Service provides a network identity and load balancing for accessing Pods, making it easy for users to access your application without knowing the Pod's location or details!

8. Persistent Volume (PV): A storage resource that persists data beyond Pod lifetimes.

Example: A PV named "data" stores data for the "db" container.

Think of it like an external hard drive.

9. Persistent Volume Claim (PVC): Requests storage resources from a PV.

Example: A PVC named "data-claim" requests 1GB of storage from the "data" PV.

Think of it like asking for space on the external hard drive.

10. Namespace: A logical partitioning of resources and objects in a cluster.

Example: A Namespace named "dev" contains the "my-app" Deployment.

Why we need Namespace?

Namespaces help:

Keep resources organized and separated
Avoid naming conflicts between resources
Control access and permissions to resources

11. ConfigMap: A way to store configuration data as key-value pairs.

Example: A ConfigMap named "app-config" stores database credentials.

Think of it like a sticky note with important info.

12. Secret: A way to store sensitive data like passwords or API keys.

Example: A Secret named "db-password" stores the database password.

Think of it like a locked box with confidential info.

15. Ingress: A way to expose Services to external traffic.

Example: An Ingress named "my-app" exposes the "my-app" Service to the internet.

Think of it like a sign on the highway pointing to your lemonade stand.

17. Kubectl: The command-line tool for interacting with Kubernetes.

Example: kubectl get pods shows the list of running Pods.

Think of it like a remote control for your Kubernetes cluster.

18. Kube-Proxy: It's a network proxy that runs on each Node in a Kubernetes Cluster.

Its main purpose is to manage communication between Pods and the outside world.

Hope you like it!!

Understanding Pointers in GO: Devops Guide

Vaibhav Thukral — Wed, 24 Jul 2024 09:28:39 +0000

In this post we will explore about pointers in Go:

What are Pointers?
Why does feature exist?
How can you work with pointers?

We will work with addresses instead of values.

What exactly are "Pointers"?

Pointers are variables that store values addresses instead of values

It may sound confusing so let's look how your code affects your computer memory

Let's say you have create and initialize variable called age set the value of 32 that value 32 stored in a computer's memory that value in memory get automatically address and that address is required by the computer to be able to retrieve that value and work with it.

But in this case here this value 32 which in our code which stored in variable age is actually also stored in computer memory and every value use in Go is atleast for short period of time stored some where in your computer's memory.

Now a pointer then is variable where you don't store a value but where you instead use & -> 'ampersand' to get an store the address of value instead of the value itself so &age pointer would contain the address as value.

Why "Pointers"?

When working with pointers you can avoid unnecessary value copies and other benefit of pointers is you can use pointers to directly mutate values

but what exactly do i means with this above advantages? so let's start with these advantage

Avoid unnecessary value copies

By default,Go creates a copy when passing values to functions
For very large and complex values, this may take up too much memory space unnecessarily
With pointers, only one value is stored in memory(and the address is passed around)

Directly mutate values

Pass a pointer(address) instead of a value to a function
The function can then directly edit the underlying value - no return value is required
Can lead to a less code (but also to less understandable code or unexpected behaviours)

Pointers in Go (also known as Golang) are variables that store the memory address of another variable. Here's a simplified explanation:

Declaring Pointers

In Go, pointers are declared using the asterisk symbol (*) before the pointer name. For example:

var ptr *int

This declares a pointer named ptr that points to an int value.

Getting the Address of a Variable

To get the memory address of a variable, use the address-of operator (&). For example:

x := 10
ptr = &x

This sets the pointer ptr to the memory address of the variable x.

Dereferencing Pointers

To access the value stored at the memory address held by a pointer, use the dereference operator (*). For example:

y := *ptr

This sets the variable y to the value stored at the memory address held by ptr, which is 10.

Conclusion

Pointers in Go are used to:

Pass variables by reference to functions
Return multiple values from functions
Create data structures like linked lists and trees
Improve performance by avoiding copying large data structures

However, Go's pointers are:

Safe: Go's pointers are bounds-checked, preventing common errors like null pointer dereferences or out-of-bounds access.
Limited: Go's pointers cannot be arithmetic or cast to other types, making them less error-prone.

Why Would You Tag Your Images in Docker?

Vaibhav Thukral — Mon, 22 Jul 2024 17:40:32 +0000

We know that image name can include an optional tag.

In this lesson, we will discuss tags in a bit more detail and learn why they are important.

We knew that image names include a name and a tag. As a quick reminder, an image name is:

<repository_name>/<name>:<tag>

tag is optional; when missing, it is considered to be latest by default
repository_name can be a registry DNS or the name of a registry in the Docker Hub

While your images aren’t published to a registry, you don’t need to include a registry name. So, your image name is:

<name>:<tag>

The latest tag

I didn’t include a tag; therefore the default latest tag was used. For instance, the actual image name was test:latest when I ran the following command:

docker build -t test .

As long as you are creating simple software, running on a simple CI/CD pipeline, it can be fine to use the latest tag. In a simple scenario, you may:

Update the source code
Build a new image with the latest tag
Run a new container with the newest image
Kill the previous container

There’s a caveat with this however: when using the docker run test command on a distant machine (which actually means docker run test:latest), the distant machine has no means to know that there is a newer version of the hello:latest image.

You need to run the docker pull test command on the distant machine in order for the newest version of your image to be downloaded to that machine.

This may sound awkward, and that’s one reason for not just using the latest tag.

Why Would You Tag Your Images?

Other reasons come to mind once you become more serious with your CI/CD pipeline.

For instance, you may want any or all of the following features:

Be able to roll back to a previous version of an image if you detect a problem with the latest image.
Run different versions in different environments. For instance, the latest version in a test environment and the previous version in a production environment.
Run different versions at the same time, routing some users to the latest version and some to the previous versions. This is known as a canary release.
Deploy different versions to different users, and be able to run whatever version on your development machine while you support them.

These are all good reasons for tagging your images. If you ensure each released image has a different tag, you can run any of the scenarios mentioned above.

You’re free to tag your images however you want. Common tags include:

a version number, e.g. test:1.0, test:1.1, test:1.2
a Git commit tag, e.g. test:2cd7e376, test:b43a14bb

In order to apply a tag, just state it during your build command:

docker build -t hello:1.0 .

I recommend specifying the image tag. If you want to keep up to date with new releases of the base image, update the tag manually and make sure you test your image before releasing it.

What is Go lang? and why would you use it?

Vaibhav Thukral — Sat, 20 Jul 2024 15:59:54 +0000

Go is an open-source programming language developed by Google.Its a relatively new programming language it was developed in 2007 and made public in 2009 and extremely popular language.

What is open-source exactly?

Open source programming language are those that allow anyone to view, modify, and distribute their source code without restrictions.

They typically maintained by a community rather than a single entity, promoting collaboration and innovation.

Why extremely popular language because of it's:

Simplicity, clarity and scalability inspired by languages such as Python it aims to provide a clean, understandable syntax.
High performance and Focus on concurrency and quite similar to C or C++ running multiple task simultaneously.
Batteries included so lot of features built-in so you don't need to reach of third party libraries for basic tasks.
Statically typed language giving you extra type safety and most importantly allows you as a developer to catch many errors early during development.

Popular Use-cases

Networking and APIs
Microservices
CLI(Command line interface) Tools