DEV Community: Prasad

Architecting a Local Ansible Lab - A Professional Guide using WSL 2 and Docker

Prasad — Sat, 27 Dec 2025 17:39:17 +0000

In the world of DevOps, the "inner development loop"—the time between writing code and testing it—is critical. Waiting for cloud instances to provision or fighting with heavy virtual machines (VMs) adds unnecessary friction to this loop.

This guide details the architecture and implementation of a high-fidelity, local infrastructure lab using Windows Subsystem for Linux (WSL 2) and Docker. This setup allows engineers to simulate a multi-environment pipeline (TEST, UAT, PRD) with minimal resource overhead, perfect for developing and testing Ansible automation before deployment.

Who is this for? Complete beginners. You need zero prior knowledge of Ansible to follow this.

Prerequisites

Before we start, ensure you have the following installed:

WSL 2 (Windows Subsystem for Linux): We will use Ubuntu as our command center.
Ansible installed on WSL2
Docker Desktop for Windows: This runs our "servers."
VS Code: For editing files.

Critical Setup Step:

Try to check docker version from your WSL

If it is not showing as below then

Ensure Docker Desktop is talking to your WSL distro. Go to Settings > Resources > WSL Integration and toggle your Ubuntu distribution ON.

Open your Ubuntu terminal and verify everything is ready:

docker --version

Phase 1: Building Your "Data Center" (Infrastructure)

We need three servers. Instead of heavy VMs, we will use lightweight Docker containers. However, standard Docker containers are "stripped down" and don't allow SSH logins. We need to build a custom image that acts like a real server.

Step 1: Create Your Workspace

Open your WSL terminal and create a dedicated folder for this project.

mkdir -p ~/my-ansible-lab
cd ~/my-ansible-lab

Step 2: Create the "Server" Image

We will define a Docker image that has OpenSSH (so Ansible can log in), Python (so Ansible can run tasks), and Sudo (for admin rights).

Create a file named Dockerfile (no extension) in your folder:

# Use the official Ubuntu image as our foundation
FROM ubuntu:latest

# Install the "Plumbing" Ansible needs:
# 1. openssh-server: To allow remote login
# 2. python3: To execute Ansible modules
# 3. sudo: To perform admin tasks
RUN apt-get update && apt-get install -y openssh-server python3 sudo

# Configure 3 Users for our 3 Environments (Simulating Real World Access)
# We create users 'ansible-test', 'ansible-uat', and 'ansible-prd'
# We set the password 'password' for all of them for simplicity
RUN useradd -rm -d /home/ansible-test -s /bin/bash -g root -G sudo ansible-test && \
    echo 'ansible-test:password' | chpasswd

RUN useradd -rm -d /home/ansible-uat -s /bin/bash -g root -G sudo ansible-uat && \
    echo 'ansible-uat:password' | chpasswd

RUN useradd -rm -d /home/ansible-prd -s /bin/bash -g root -G sudo ansible-prd && \
    echo 'ansible-prd:password' | chpasswd

# Set up the SSH directory
RUN mkdir -p /run/sshd

# Expose Port 22 (The standard SSH port)
EXPOSE 22

# Start the SSH Daemon when the container boots
CMD ["/usr/sbin/sshd", "-D"]

Step 3: Build the Image

Run this command to build your custom server image. We will tag it ubuntu-base.

docker build -t ubuntu-base .

Step 4: Launch the Fleet

Now we spin up three separate containers. We map their internal SSH port (22) to different ports on your localhost so we can target them individually.

TEST Server: Accessible on port 2222
UAT Server: Accessible on port 2223
PRD Server: Accessible on port 2224

Run these three commands:

docker run -d -p 2222:22 --name test-server ubuntu-base
docker run -d -p 2223:22 --name uat-server ubuntu-base
docker run -d -p 2224:22 --name prd-server ubuntu-base

Verify they are running:

docker ps

Phase 2: Setting Up Ansible (The Control Center)

Now that we have servers, we need to configure Ansible to talk to them.

Step 1: Create Professional Folder Structure

We will use Ansible Roles, which is the industry standard for organizing code. Run these commands to create the folders:

# Create directories for roles
mkdir -p roles/common/tasks
mkdir -p roles/nginx/tasks

# Create directories for config and playbooks
mkdir -p inventory
mkdir -p playbooks

Step 2: The Inventory File (`hosts.ini`)

This file acts as an address book for Ansible. Create inventory/hosts.ini:

[test]
test-node ansible_host=localhost ansible_port=2222 ansible_user=ansible-test

[uat]
uat-node ansible_host=localhost ansible_port=2223 ansible_user=ansible-uat

[prd]
prd-node ansible_host=localhost ansible_port=2224 ansible_user=ansible-prd

# Create a group that contains all environments
[docker_lab:children]
test
uat
prd

# Define variables for the group
[docker_lab:vars]
# The password we baked into the Dockerfile
ansible_ssh_pass=password
ansible_become_pass=password
# Prevent "Host Verification" errors since these are local containers
ansible_ssh_common_args='-o StrictHostKeyChecking=no'
# Explicitly use Python 3
ansible_python_interpreter=/usr/bin/python3

Step 3: Ansible Configuration (`ansible.cfg`)

Create a file named ansible.cfg in the root folder (~/my-ansible-lab). This tells Ansible where to find everything.

[defaults]
inventory = ./inventory/hosts.ini
host_key_checking = False
# Use YAML format for cleaner output
stdout_callback = yaml
# Tell Ansible where to find our roles
roles_path = ./roles

Phase 3: Writing the Automation Code

We will create two "Roles". Roles are like functions in programming—reusable blocks of tasks.

Step 1: The 'Common' Role

This role installs basic utilities on every server. Create roles/common/tasks/main.yml:

---
- name: Install common utilities
  ansible.builtin.apt:
    name:
      - curl
      - wget
      - git
      - vim
    state: present

- name: Create a welcome message
  ansible.builtin.copy:
    content: "Welcome to {{ inventory_hostname }} environment!"
    dest: /etc/motd
    owner: root
    group: root
    mode: '0644'

Step 2: The 'Nginx' Role

This role installs the web server. Since Docker doesn't support systemd (the standard way to check services), we use a clever netstat command to verify the server is listening on port 80.

Create roles/nginx/tasks/main.yml:

---
- name: Update apt cache
  ansible.builtin.apt:
    update_cache: yes
    cache_valid_time: 3600

- name: Install nginx
  ansible.builtin.apt:
    name: nginx
    state: present

- name: Start nginx service
  ansible.builtin.service:
    name: nginx
    state: started
    enabled: yes

# Docker-specific check: Verify port 80 is open
- name: Verify nginx is listening on port 80
  ansible.builtin.shell: netstat -tuln | grep :80 || ss -tuln | grep :80
  register: nginx_check
  ignore_errors: yes

- name: Print nginx port check
  ansible.builtin.debug:
    msg: "Nginx is listening on port 80"
  when: nginx_check is succeeded

Step 3: The Playbook

The playbook ties everything together. It maps the roles to the hosts. Create playbooks/install-packages.yml:

---
- name: Configure all docker lab servers
  hosts: docker_lab
  become: yes  # Run as root (sudo)

  roles:
    - common
    - nginx

Phase 4: Execution and Verification

Step 1: Run the Playbook

This is the moment of truth. Run the following command from your project root:

ansible-playbook playbooks/install-packages.yml

You will see Ansible connect to all three containers, install the tools, set up Nginx, and verify the ports.

Step 2: Verify the Result

Let's manually log into the TEST environment to confirm Nginx is serving traffic.

# Log in via SSH (Password is 'password')
ssh ansible-test@localhost -p 2222

Once inside the container, run:

curl http://localhost

You should see the HTML for "Welcome to Nginx!".

Conclusion

You have successfully built a multi-environment infrastructure simulation and deployed software to it using Ansible—all without spending a dime on cloud costs.

You now have a portable lab where you can safely practice:

Writing complex playbooks.
Testing software upgrades.
Experimenting with network configurations.

My sample project is uploaded to Github repository

Feel free to download source code and try.

Happy Automating!

Trying to understand SOLID Principles with C#

Prasad — Sat, 13 Dec 2025 20:11:56 +0000

The SOLID Principles are five fundamental principles of object-oriented class design introduced by Robert C. Martin (also known as "Uncle Bob"). The acronym "SOLID" was later coined by Michael Feathers.

These principles provide guidelines and best practices for designing class structures that are:

Understandable - Easy to read and comprehend
Readable - Clear and well-organized code
Testable - Can be easily tested

The Five Principles

Principle	Full Name
S	Single Responsibility Principle
O	Open-Closed Principle
L	Liskov Substitution Principle
I	Interface Segregation Principle
D	Dependency Inversion Principle

Why SOLID Principles Matter

When working on large projects in a team environment, simply writing code that executes correctly is not enough. Your code must be:

Maintainable - Other developers on your team should understand your code
Testable - Code should be easy to test
Scalable - Code should support team collaboration on the same codebase

Following SOLID principles ensures that your codebase remains flexible, extensible, and maintainable as the project grows.

Single Responsibility Principle

Definition

A class should have only one responsibility and should have only one reason to change.

Problem Example

public class Circle
{
    public double Radius { get; set; }

    public double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}

public class Program
{
    static void Main()
    {
        Circle circle = new Circle { Radius = 5 };

        // Multiple responsibilities:
        // 1. Creating and managing the circle
        double area = circle.CalculateArea();  // Calculation responsibility

        Console.WriteLine($"Area: {area}");    // Printing responsibility
    }
}

Issues: The Program class has three responsibilities:

Core application logic
Area calculation
Printing output

Solution

Step 1: Move area calculation to the Circle class

public class Circle
{
    public double Radius { get; set; }

    public double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
}

Step 2: Create a separate Printer class for output responsibility

public class Printer
{
    public void PrintArea(Circle circle)
    {
        Console.WriteLine($"Area: {circle.GetArea()}");
    }
}

public class Program
{
    static void Main()
    {
        Circle circle = new Circle { Radius = 5 };
        Printer printer = new Printer();
        printer.PrintArea(circle);
    }
}

Result: Each class now has a single, well-defined responsibility:

Circle - Manages circle data and calculations
Printer - Handles output
Program - Orchestrates the application flow

Open-Closed Principle

Definition

A class should be open for extension but closed for modification.

This means adding new functionality should not require changing existing code.

Problem Example

public class Circle
{
    public double Radius { get; set; }
    public double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
}

public class Rectangle
{
    public double Length { get; set; }
    public double Width { get; set; }
    public double GetArea()
    {
        return Length * Width;
    }
}

public class Program
{
    static void Main()
    {
        Circle circle = new Circle { Radius = 5 };
        Rectangle rect = new Rectangle { Length = 4, Width = 6 };

        // Problem: Need separate methods for each shape
        CalculateArea(circle);
        CalculateArea(rect);  // This method doesn't exist - need to create new ones
    }
}

Issue: Every time you add a new shape, you must modify the Program and Printer classes to handle it.

Solution: Use Abstraction through Interface

Step 1: Create an interface for all shapes

public interface IShape
{
    double GetArea();
}

Step 2: Implement the interface in shape classes

public class Circle : IShape
{
    public double Radius { get; set; }

    public double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
}

public class Rectangle : IShape
{
    public double Length { get; set; }
    public double Width { get; set; }

    public double GetArea()
    {
        return Length * Width;
    }
}

Step 3: Update the Printer class to work with the interface

public class Printer
{
    public void PrintArea(IShape shape)
    {
        Console.WriteLine($"Area: {shape.GetArea()}");
    }
}

public class Program
{
    static void Main()
    {
        Circle circle = new Circle { Radius = 5 };
        Rectangle rect = new Rectangle { Length = 4, Width = 6 };

        Printer printer = new Printer();
        printer.PrintArea(circle);   // Works!
        printer.PrintArea(rect);     // Works!
    }
}

Step 4: Add new shapes without modifying existing code

public class Triangle : IShape
{
    public double Base { get; set; }
    public double Height { get; set; }

    public double GetArea()
    {
        return 0.5 * Base * Height;
    }
}

// No changes needed to Program or Printer classes!
public class Program
{
    static void Main()
    {
        Triangle triangle = new Triangle { Base = 5, Height = 10 };
        Printer printer = new Printer();
        printer.PrintArea(triangle);  // Works!
    }
}

Result: The code is now open for extension (add new shapes) without modification (no changes to existing classes).

Liskov Substitution Principle

Definition

Child classes (derived classes) must be able to substitute their parent classes without breaking the application.

In other words, derived classes should properly implement the contract of their base class.

Problem Example

public class Rectangle
{
    public double Length { get; set; }
    public double Width { get; set; }

    public double GetArea()
    {
        return Length * Width;
    }
}

public class Square : Rectangle
{
    // A square must have equal length and width
    // But Rectangle allows independent length and width
}

Issue: A Square inheriting from Rectangle creates a logical problem:

User expects to set Length and Width independently on a Rectangle
A Square must keep Length and Width equal
When user sets Length = 5 and Width = 3, it violates the square property
If we override Width to always equal Length, we violate Rectangle's contract

This violates the Liskov Substitution Principle because you cannot substitute a Square for a Rectangle without breaking expected behavior.

Solution

Step 1: Create a proper interface hierarchy

public interface IShape
{
    double GetArea();
}

public interface ITwoDShape : IShape
{
    // For 2D shapes
}

public interface IThreeDShape : IShape
{
    // For 3D shapes
}

Step 2: Implement shapes correctly based on their hierarchy

public class Rectangle : ITwoDShape
{
    public double Length { get; set; }
    public double Width { get; set; }

    public double GetArea()
    {
        return Length * Width;
    }
}

public class Square : ITwoDShape
{
    public double Side { get; set; }

    public double GetArea()
    {
        return Side * Side;
    }
}

Result: Now Square and Rectangle are independent implementations of IShape, each correctly implementing their own contract. Neither is a substitution for the other—they're separate shape types.

Interface Segregation Principle

Definition

Clients should not be forced to implement methods they don't use.

It's better to have many specific interfaces than one general-purpose interface.

Problem Example

public interface IShape
{
    double GetArea();
    double GetVolume();  // Not all shapes have volume!
}

public class Circle : IShape
{
    public double Radius { get; set; }

    public double GetArea()
    {
        return Math.PI * Radius * Radius;
    }

    public double GetVolume()
    {
        // Circle has no volume - forced to implement dummy method!
        throw new NotImplementedException("Circle is 2D and has no volume");
    }
}

public class Cube : IShape
{
    public double Side { get; set; }

    public double GetArea()
    {
        // Misleading - cube has surface area, not a single "area"
        return 6 * Side * Side;
    }

    public double GetVolume()
    {
        return Side * Side * Side;
    }
}

Issues:

Circle is forced to implement GetVolume() which is not applicable
Cube's GetArea() is ambiguous (surface area vs. 2D area concept)
Classes implement methods they don't logically need

Solution: Segregate Interfaces

Step 1: Create separate interfaces for different shape types

public interface ITwoDShape
{
    double GetArea();
}

public interface IThreeDShape
{
    double GetVolume();
    double GetSurfaceArea();
}

public interface IShape
{
    // Common interface with no methods or only essential ones
}

Step 2: Implement appropriately

public class Circle : ITwoDShape
{
    public double Radius { get; set; }

    public double GetArea()
    {
        return Math.PI * Radius * Radius;
    }
}

public class Rectangle : ITwoDShape
{
    public double Length { get; set; }
    public double Width { get; set; }

    public double GetArea()
    {
        return Length * Width;
    }
}

public class Cube : IThreeDShape
{
    public double Side { get; set; }

    public double GetVolume()
    {
        return Side * Side * Side;
    }

    public double GetSurfaceArea()
    {
        return 6 * Side * Side;
    }
}

Step 3: Use appropriate interfaces in methods

public class Printer
{
    public void PrintTwoDShape(ITwoDShape shape)
    {
        Console.WriteLine($"2D Area: {shape.GetArea()}");
    }

    public void PrintThreeDShape(IThreeDShape shape)
    {
        Console.WriteLine($"3D Volume: {shape.GetVolume()}");
        Console.WriteLine($"Surface Area: {shape.GetSurfaceArea()}");
    }
}

Result: Each class only implements the methods it needs. No forced implementations of irrelevant methods.

Dependency Inversion Principle

Definition

High-level classes should not depend directly on low-level classes. Both should depend on abstractions (interfaces).

Problem Example

public class Printer
{
    public void Print(IShape shape)
    {
        Console.WriteLine($"Area: {shape.GetArea()}");
    }
}

public class Program
{
    static void Main()
    {
        Printer printer = new Printer();
        Circle circle = new Circle { Radius = 5 };
        printer.Print(circle);
    }
}

Issue: If later you want to use a different printer (e.g., FilePrinter, CSVPrinter, ConsolePrinter), you must modify the Program class and update all dependencies. The method signature and class structure might differ across implementations.

Solution: Depend on Abstraction

Step 1: Create an interface for printers

public interface IPrinter
{
    void Print(ITwoDShape shape);
}

Step 2: Implement different printer types

public class ConsolePrinter : IPrinter
{
    public void Print(ITwoDShape shape)
    {
        Console.WriteLine($"Console Area: {shape.GetArea()}");
    }
}

public class FilePrinter : IPrinter
{
    public void Print(ITwoDShape shape)
    {
        File.WriteAllText("output.txt", $"File Area: {shape.GetArea()}");
    }
}

Step 3: Depend on the abstraction

public class Program
{
    static void Main()
    {
        IPrinter printer = new ConsolePrinter();  // Can easily swap implementations
        Circle circle = new Circle { Radius = 5 };
        printer.Print(circle);
    }
}

Result: Now you can:

Switch between different printer implementations easily
Add new printer types without modifying the Program class
Change implementation by modifying just one line
The method signature remains consistent across all implementations

Advanced: Dependency Injection

For even better decoupling, use dependency injection:

public class Program
{
    private readonly IPrinter _printer;

    public Program(IPrinter printer)
    {
        _printer = printer;
    }

    public void Run()
    {
        Circle circle = new Circle { Radius = 5 };
        _printer.Print(circle);
    }

    static void Main()
    {
        // Inject the dependency - Program doesn't create it
        IPrinter printer = new ConsolePrinter();
        Program program = new Program(printer);
        program.Run();
    }
}

The Program class doesn't even need to know which concrete printer is being used. It only knows about the IPrinter interface.

Summary

Principle	Key Concept	Benefit
SRP	One responsibility per class	Easy to understand and maintain
OCP	Open for extension, closed for modification	Add features without breaking existing code
LSP	Derived classes should substitute base classes	Proper inheritance hierarchies
ISP	Segregate interfaces by client needs	Classes implement only needed methods
DIP	Depend on abstractions, not concrete classes	Flexible and loosely coupled code

Best Practices

Apply gradually - Don't try to implement all principles at once
Use interfaces - They enable abstraction and flexibility
Keep it simple - Over-engineering with too many abstractions can make code complex
Review existing code - Identify which classes violate which principles
Refactor incrementally - Improve your codebase step by step
Consider Factory Pattern - Combine with SOLID for maximum decoupling
Use Dependency Injection - Frameworks like ASP.NET Core provide built-in DI containers

Trying to understand Constructors in c++

Prasad — Mon, 13 Oct 2025 17:10:32 +0000

This post is originally published to my blog site here

In this post we are trying to understand what is constructors in c++.

Lets create a basic example of class in c++

class Student
{
private:
    int myId;
    string myName;

public:     
    void printData()
    {
        cout << "Id : " << myId << " & Name: " << myName << endl; 
    }
};

Student class just have one method called printData which is just printing its variables.

Now, create an object in main function and try to run program.

int main()
{
    Student s;  
    s.printData();

    cin.get();
}

As you see, it has some random value assigned for int id which is not accepted value.

That means compiler has assigned some remaining or random value to our int variable.

To overcome this issue, lets assigned some value to our variables.

Modify out Student class and add init() method inside this as below


class Student
{
private:
    int myId;
    string myName;

public:
    void init(int id, string name) {        
        myId = id;
        myName = name;
    }   
    void printData()
    {
        cout << "Id : " << myId << " & Name: " << myName << endl; 
    }
};

In our init method, we have assigned value of our member variables.

Now, try to call printData() function in our main function.

int main()
{
    Student s;  
    s.init(1, "prasad");

    s.printData();

    cin.get();
}

Run program and check output.

this seems works well, as we can see values to variable id and name assiend correctly.

but there is an issue.
Everytime, when we are going to create an object of Student class, we need to call init function as below

int main()
{
    Student s1;     
    s1.init(1, "prasad");
    s1.printData();

  Student s2;   
    s2.init(2, "Saurabh");
    s2.printData();

    cin.get();
}

This is not the good way to handle and hence constructors come into picture.

What is Constructors?

A constructors is a special member function of class that is automatically called when object of that class created.

It's main job is to initilize the object by setting default values or allocating resources.

Key characteristics

Name of constructor function should be same as class name.
It does not have any return type.
It is automatically get invoked when an object is initilized
We can have overloaded method for constructors.

Let's continue to our example, modify our student class and add constructor function to it


class Student
{
private:
    int myId;
    string myName;

public:
    Student() {  // <--- this is constructor function
        myId = 1;
        myName = "Prasad Gavande";
    }
    void printData()
    {
        cout << "Id : " << myId << " & Name: " << myName << endl; 
    }
};


int main()
{
    Student s;   // <--- constructor function called when object is initilized 
    s.printData();

    cin.get();
}

As we can see, we have new public function with same name as of class, student

In that function we have just assiged values to our member functions.

Now, run this program to check output

As we can see, we can assign value without init function.

Types of constructors

Default constructor - it does not have any parameters
Parameterized constructor - it has arguments , it is overloaded method of default constructor
Copy constructor - it creates a copy of existing objects
Move constructor - Transfer resources from one object to another

I found that parameterized constructor is widely used, lets extend our example with parameterized constructor


class Student
{
private:
    int myId;
    string myName;

public: 
    Student() {  // <-- default constructor
        myId = 1;
        myName = "Prasad Gavande";
    }
    Student( int id, string name) // <-- parameterized constructor
    {
        myId = id;
        myName = name; 
    }
    void printData()
    {
        cout << "Id : " << myId << " & Name: " << myName << endl; 
    }
};

As we can see, we have added one more overloaded method of default constructor. Which has two parameters, id and name.

We have passed parameters to this function that's why it is called parameterized constructor.

Now, lets create an object in main method.

int main()
{   
    Student s(1, "Sachin");  //<-- initilize object 
    s.printData();

    cin.get();
}

Run this program and check output

This is how we can create constructor , use them to initilize the value and keep our code clean.

Hope you understand basics of constructors.

Happy Coding.

Trying to understand Pointers in c++

Prasad — Wed, 08 Oct 2025 23:09:07 +0000

This blog post originally posted to my blog site here.

In this blog post, we are trying to understand pointers.

Many people find this topic very confusing but actually, it is not that much complex or confusing. Let's deep dive into pointers.

Pointers are variable that stores memory address of another variable that's it. Do not overthink about pointers.

Declare pointer

* (asterisk) is used to declare pointer variable. We can use data type with * to declare pointer.

Data type is used only because compiler dont know what type of variable's address it has to store or we can say, this tell compiler that what kind of value the pointer is pointing to, and how much memory to read.
Example:

void* p1 = 0 ; // void pointer
void* p = NULL; // it is also mean to initilize as 0. 
void* p3 = nullptr  // this is also same, it is called null pointer
int* p4;  // pointer to an integer
float* p5; //pointer to  float
double * p6 ; pointer to double

NOTE
* meaning value at variable
& meaning address of variable

Why it is important to add data type ?

Memory interpretation : Data type tells compiler how many byte to read from the memory address . example: int* reads 4 bytes of memory
Pointer Arithmatic : When increment value of pointer , then compiler use data type to calculate example: if we increment int* variable, and int take 4 bytes, so next location will be 4 bytes forward to it. (We will look into this later in this post)
Type Safety : it helps to prevent bugs, we cannot accidentially treat float* as int* unless we type cast it.

Create first pointer

Let's create a code with pointers. Open your favorite code editor, I am using visual studio here for demo.

#include<iostream>
using namespace std;

int main()
{
    int i = 4;
    int* ptr = &i; 

    cin.get(); 
}

This is very simple code, we just have declared int variable and initilized it with some value.

Then we have created another pointer variable which is pointing to int variable. We have used opertor * to declare a pointer variable.
We use operator & to denote that it holds address of integer i .

I put break point in source code and then debug this.

Then run this program. As we hit breakpoint then watch value to variable ptr , it is showing some address in hex format.

Now, in visual studio, go to Debug -> Windows -> Memory -> Memory 1 , it will open new window where we can see the computer memory.
Copy value of ptr variable there and hit enter

As we can see, when we go that address in memory , it shows 04 00 00 00 which means value is 4 which we have set to int i and 4 byes of address assigned to this memory

Let's modify this code to print some output to understand more

#include<iostream>
using namespace std;

int main()
{
    int i = 4;
    int* ptr = &i; 
    cout << "value of i : " << i << endl;
    cout << "address of i : " << &i << endl;
    cout << "value at " << &i << ": " << *ptr << endl; 
    cout << "Size of i: " << sizeof(i) << endl;
    cout << "Size of ptr : " << sizeof(ptr) << endl; 

    cin.get(); 

}

as mentioned earlier,

use & operator to know the adderss of variable in memory
use * operator to get the value of that memory location , this is also called as dereferencing

Size of int is 4 bytes and size of pointer is 8 bytes always regardless of data type which we have assigned to that pointer. Because ultimatly it's a memory location

Run this program and check output

So now, we have basic understanding of what is pointers and how it can be used, let's deep dive into pointers.

Why do we need pointers ?

Why we need pointers is frequently asked question. Is cpp programing can be done without pointers? and answer is yes.

But pointers give us benefit of direct memory access. Take a simple example of incrememnt the value of variable.

Pass by Value

#include<iostream>
using namespace std;

int incrementValue(int num)
{
    num++; 
    return num; 
}
int main()
{
    int i = 4;
    cout << "value of i before increment :" << i << endl; 
    cout << "get incremented value: " << incrementValue(i) << endl; 
    cout << "value of i after increment :" << i << endl;

    cin.get(); 
}

Debug this code and try to understand whats happened behind the scene

When i has been initilized then check memory , enter &i in address then hit enter.

as we can see value 04 is assigned to this memory location.

then hit F10 to go to next step and go inside the incrementValue function where we can check address of num

as we can see value of num incremented by one which is showing 05 now.

and then go to next step and get back to our main function and check value of i at address &i

As you see value of at address of i is still 04.

Finally, check the output.

Value of variable i is still 04 because we have passed value not actual memory location to modify, so in this case, program has created new copy of variable.

It has not actully modify value at that memory location, it has modified the value of it's copy.

Pass by Reference

Now modify the code and this time we are going to pass the value by reference meaning we will pass the address of variable instead of variable directly.

#include<iostream>
using namespace std;

void incrementValue(int *num)
{
    (*num)++;       
}
int main()
{
    int i = 4;
    cout << "value of i before increment :" << i << endl; 
    incrementValue(&i); 
    cout << "value of i after increment :" << i << endl;

    cin.get(); 

}

As you see, we have passed &i to increamentValue function, that means we are now passing address of the variable.
When it will go to increamentValue function, then we will dereference this first because we want to increment the value (not memory location) and then we will increment the value.

Let's debug this code to understand what's happening behind the scene.

Debug the code, go to memory and enter &i to see the value of that addres.

As we can see value 04 is assigned to this memory location, now go to next step and check out the value at adress of i .

Now, value at address of i has been increased by 1 which is 05 now.

Finally, check the output

Value of variable i has been changed and this time, we have modify the value at the address directly.

This is main advantages of using pointers in cpp .

Hope you have basic understanding of pointers and how it works in cpp.

Happy Coding.

Csv file handling with shell script

Prasad — Mon, 16 Jun 2025 00:19:53 +0000

This post is originally posted on my blog site here

In this post, we are going to take a look on basic csv operations which includes read, write, find etc.

so let's get started with this.

Make sure, you have csv file with you in folder, you can refer to file handing post to learn more about it.

Create a file using editor of your choice, I am using vi editor for this

vi csvOperations.sh

This will create a file and open editor

Common declaration

first declare shebang as below

#!/bin/bash

then create variable which will hold csv file name

csvFile="data.csv"

Let's create a functions for basic operations

Function to read CSV file

readCsv()
{
        echo "Content in csv file as below"
        cat $csvFile
}

function count rows in file

We are going to use tail function with wc | -l options which can give us count of rows in file

countRows()
{
        echo "Number of rows in file: "
        tail data.csv | wc -l
}

Extract specific column values

We can use awk function to get column values

extractColumns(){
        echo "extracting second column"
        awk -F , '{print $2}' "$csvFile"
}

where:

-F , --> this will use as field seperator to comma , meaning awk will treat each comma-seperated value as different column

{print $2} --> this will tell awk command to print second column

$csvFile --> we are passing csv file to awk command for processing

Append data to csv file

We are going to ask user to enter value to append data to csv

appendData()
{
        echo "Enter below information to add new row to csv"
        read -p "Enter Id:" id
        read -p "Enter Name:" name
        read -p "Enter Dept:" dept

        echo "$id, $name, $dept" >> "$csvFile"
        echo " data added to csv file"
}

Get row by Id

We are going to ask user to enter row id which he wants to search for , We can get row by passing Id using awk command

getRowById()
{
        read -p "Enter Id of row you want to read" rowId
        awk -F , -v id="$rowId" '$1==id' "$csvFile"
}

Where:

-F , --> this will use as field seperator to comma , meaning awk will treat each comma-seperated value as different column

-v id="$rowId" --> this will define variable id inside awk command and assign value of rowId which passed by user

'$1==id' --> as we have stored Ids in first column in csv file, this will check if first column matched id from csv file

Function calling

Now, its time to call functions one by one.

readCsv
countRows
extractColumns
appendData
echo "Read Csv again after adding new row"
readCsv
getRowById

That's it, lets save this file , grant required permission.
Before run this, lets take a look on our data.csv file

id,name,dept
1,abc,IT
2,pqr,HR
3,xyz,Acc

Now, run our executable csv opeations file

File Operations with shell script

Prasad — Sun, 15 Jun 2025 23:37:51 +0000

This post is originally posted on my blog site here

In this tutorial we will try to perform basic file operations like create, write, read, delete file using shell script.
Let's get started with this.

As usual lets create new file using editor of your choice, I am using vi editor.

vi fileOps.sh

This will create new file and open editor for you.
We will create all function for common operations of file and then we will call them using switch cases, so that user can perform whatever operations he want!

Script will as user to enter file name first in which he want to perform operations

#!/bin/bash

# prompt user to enter file name

read -p "Enter file name: " fileName

Lets create functions first.

create function which will help us to create file

createFile() {
        touch "$fileName"
        echo "file created with name: $fileName"
}

Create function to read file

It's good habit to check if file is exists before perform operaitons, so lets check if file exists or not, then perform read operation
otherwise let user know that file does not exist

readFile(){
        if [ -f "$fileName" ]; then
                echo "content in file as below"
                cat $fileName
        else
                echo "file does not exists"
        fi
}

Create function to write file

writeFile(){
        echo "Enter content you want to write to file"
        read content
        echo "$content" >> "$fileName" ## append content mode
        echo "Content has been written to file"
}

here we are using append mode to write content in file, because we dont wan to loose old data.
if you dont want to use append mode then simply modify arraw operator as below
echo "$content" > "$fileName"

Create function to delete file
As mentioned above, first check if file exists or not before you delete the file

deleteFile(){
        if [ -f "$fileName" ]; then
                rm $fileName
                echo "file has been deleted"
        else
                echo "File does not exists"
        fi
}

Now, all our required functions are created, lets write function calling
Here we are going to as user which operations he want to perform using switch-case conditions

echo "Choice Operation you want to perform on file"
echo "1. Create File"
echo "2. Read file"
echo "3. Write file"
echo "4. Delete file"
read -p "Enter Choice" choice
case $choice in
        1) createFile ;;
        2) readFile ;;
        3) writeFile ;;
        4) deleteFile;;
        *) echo "Invalid choice"
esac

That's it, we are ready to execute this script
save the file, give required permissions to file

chmod 777 fileOps.sh

Now, run this executable using below command

./fileOps.sh
Once we run below command, it will run executable, let's create new file with name sample.txt

Enter file name: sample.txt
Choice Operation you want to perform on file
1. Create File
2. Read file
3. Write file
4. Delete file
Enter Choice 1
file created with name: sample.txt

check if file get created or not

root@Prabhu:~/shell# ls -ltr
total 12
-rwxrwxrwx 1 root root 916 Jun 15 23:15 fileOps.sh
-rw-r--r-- 1 root root   0 Jun 15 23:19 sample.txt
root@Prabhu:~/shell#

Run again to perform write operations

root@Prabhu:~/shell# ./fileOps.sh
Enter file name: sample.txt
Choice Operation you want to perform on file
1. Create File
2. Read file
3. Write file
4. Delete file
Enter Choice3
Enter content you want to write to file
this is sample content added in file
Content has been written to file
root@Prabhu:~/shell#

Run again to perform read operations

root@Prabhu:~/shell# ./fileOps.sh
Enter file name: sample.txt
Choice Operation you want to perform on file
1. Create File
2. Read file
3. Write file
4. Delete file
Enter Choice2
content in file as below
this is sample content added in file
root@Prabhu:~/shell#

Run again to perform delete operations

root@Prabhu:~/shell# ./fileOps.sh
Enter file name: sample.txt
Choice Operation you want to perform on file
1. Create File
2. Read file
3. Write file
4. Delete file
Enter Choice4
file has been deleted

check if file get deleted or not

root@Prabhu:~/shell# ls -ltr
total 11
-rwxrwxrwx 1 root root 916 Jun 15 23:15 fileOps.sh
root@Prabhu:~/shell#

Useful Linux commands

Prasad — Thu, 12 Jun 2025 23:37:15 +0000

This post has been originally posted on my blog site here

In this post, we are going to take a look on some essential and useful linux / unix commands that are being used for day to day operations

Commands for directory operations

ls

This command is use to list content in folder

ls [options] [directory or path]

example , if I am inside /etc/ folder, and if I execute command then I can see all folders inside /etc/ folder as below

root@Prabhu:/etc# ls
PackageKit              cron.daily      fstab       kernel          mime.types           polkit-1      selinux            sysctl.d
X11                     cron.hourly     fuse.conf   landscape       mke2fs.conf          profile       sensors.d          systemd
adduser.conf            cron.monthly    gai.conf    ld.so.cache     modprobe.d           profile.d     sensors3.conf      terminfo
alternatives            cron.weekly     glvnd       ld.so.conf      modules              protocols     services           timezone
apparmor                cron.yearly     gnutls      ld.so.conf.d    modules-load.d       python3       sgml               tmpfiles.d
apparmor.d              crontab         gprofng.rc  ldap            mtab                 python3.12    shadow             ubuntu-advantage

option : -la

ls command have many options, some useful options are as below

ls -la

where

-l : use a long listing format
-a, --all: do not ignore entries starting with .

Example:

root@Prabhu:/etc# ls -la
total 808
drwxr-xr-x 88 root  root       4096 Jun 11 22:51 .
drwxr-xr-x 22 root  root       4096 Jun 11 22:46 ..
-rw-------  1 root  root          0 Sep 27  2024 .pwd.lock
-rw-r--r--  1 root  root        837 Sep 27  2024 .resolv.conf.systemd-resolved.bak
-rw-r--r--  1 root  root        208 Sep 27  2024 .updated
drwxr-xr-x  2 root  root       4096 Sep 27  2024 PackageKit
drwxr-xr-x  7 root  root       4096 Sep 27  2024 X11
-rw-r--r--  1 root  root       3444 Jul  5  2023 adduser.conf
drwxr-xr-x  2 root  root       4096 Sep 27  2024 alternatives

option : -lt

if you want to sort the list content by time then use -lt option

ls -lt

where
-t: sort by time, newest first; see --time

Example:

root@Prabhu:/etc# ls -lt
total 792
-rw-r--r-- 1 root  root      17607 Jun 11 22:51 ld.so.cache
drwxr-xr-x 4 root  root       4096 Jun 11 22:51 ssl
drwxr-xr-x 2 root  root       4096 Jun 11 22:51 gnutls
drwxr-xr-x 2 root  root       4096 Jun 11 22:50 init.d

option: -ltr

if you want to sort the list content by time in reverse order then use -ltr option

ls -ltr

where

Example:

root@Prabhu:/etc# ls -ltr
total 792
-rw-r--r-- 1 root  root         45 Jan 24  2020 bash_completion
-rw-r--r-- 1 root  root      12813 Mar 27  2021 services
-rw-r--r-- 1 root  root         34 Aug  2  2022 ld.so.conf
-rw-r--r-- 1 root  root        367 Aug  2  2022 bindresvport.blacklist
-rw-r--r-- 1 root  root        552 Oct 13  2022 pam.conf
-rw-r--r-- 1 root  root       3144 Oct 17  2022 protocols

where:
-r, --reverse: reverse order while sorting

There are many other options, but I use above options in my day to day life

pwd

This command is used to print full path of current directory

pwd [options]

Example

root@Prabhu:/etc# pwd
/etc

It has several options as below
-L, --logical: use PWD from environment, even if it contains symlinks
-P, --physical: avoid all symlinks

cd

This command is used for navigation

cd [directory path where you want to go]

example, if I am inside /etc/ folder and I want to go to pm folder inside same directory then I will use following command

root@Prabhu:/etc# pwd
/etc
root@Prabhu:/etc# cd pm
root@Prabhu:/etc/pm#

if you want to go to some other folder of specific path then we can pass full directory path as below

root@Prabhu:/etc/pm# pwd
/etc/pm
root@Prabhu:/etc/pm# cd /var/run/log
root@Prabhu:/var/run/log#

cd command also provides some shortcuts as below

cd : returns to current user's home directory

cd .. : go to one level up

cd - : go to previous directory

mkdir

This command is used to create new directory

mkdir dir_name

Example

root@Prabhu:~/prasad# mkdir testing
root@Prabhu:~/prasad# ls
testing
root@Prabhu:~/prasad#

rmdir

This command is used to remove empty directory

rmdir dir_name

Example

root@Prabhu:~/prasad# ls
testing
root@Prabhu:~/prasad# rmdir testing
root@Prabhu:~/prasad# ls
root@Prabhu:~/prasad#

Note: this command can only delete empty folders, if you have any file / folder inside this folder then this command cannot be used.

Commands for file operations

touch

This command is used to create new empty file in folder or to update timestamp of existing file

touch [option] file_name.extension

Example:

root@Prabhu:~/prasad# ls
root@Prabhu:~/prasad#
root@Prabhu:~/prasad# touch test.txt
root@Prabhu:~/prasad# ls
test.txt
root@Prabhu:~/prasad#

cp

This command is used to copy files and folders from one location to another location

cp [options] source destination

Example

root@Prabhu:~# cp prasad/test.txt shell/
root@Prabhu:~# cd shell/
root@Prabhu:~/shell# ls -ltr
total 32
-rwxr-xr-x 1 root root  16 Jun 11 23:33 test.txt
root@Prabhu:~/shell#

If you want to copy whole directory including its files and sub folders then need to use option -r along with this.

Example: if I want to copy folder /etc/ssh along with its sub folders and files then execute commands as below

root@Prabhu:~#
root@Prabhu:~# cp -r /etc/ssh/ prasad
root@Prabhu:~# cd prasad
root@Prabhu:~/prasad# ls -ltr
total 8
-rwxrwxrwx 1 root root   16 Jun 11 23:31 test.txt
drwxr-xr-x 3 root root 4096 Jun 11 23:38 ssh
root@Prabhu:~/prasad# cd ssh
root@Prabhu:~/prasad/ssh# ls -ltr
total 8
drwxr-xr-x 2 root root 4096 Jun 11 23:38 ssh_config.d
-rw-r--r-- 1 root root 1649 Jun 11 23:38 ssh_config
root@Prabhu:~/prasad/ssh#

mv

This command is used to move the file or folder from one location to another or to rename the file

mv source destination

Example
if you want to move file from one folder to another

root@Prabhu:~# mv prasad/test.txt shell/test.txt
root@Prabhu:~# cd shell
root@Prabhu:~/shell# ls -ltr
total 12
-rwxrwxrwx 1 root root  16 Jun 11 23:31 test.txt
root@Prabhu:~/shell#

if you want to rename the file, then keep destnation same but change filename while execute mv command

root@Prabhu:~/shell# mv test.txt test2.txt
root@Prabhu:~/shell# ls -ltr
total 12
-rwxrwxrwx 1 root root  16 Jun 11 23:31 test2.txt

cat

This command is used to print the content of file

cat [options] filename

Example, if you want to see content in file

root@Prabhu:~/shell# cat file.txt
 this is prasad
root@Prabhu:~/shell#

Example, if you want to read the content of one file and put it into another file as below

root@Prabhu:~/shell# cat test2.txt > file.txt
root@Prabhu:~/shell# less file.txt

 this is prasad
file.txt (END)

grep (Global regualar expression print)

This command is very helpful if you want to search specific word from files

grep [options] pattern [filename]

Example: to search keyword in any specific file

root@Prabhu:~/shell# grep "prasad" file.txt
 this is prasad

if you want to display line number in search result

root@Prabhu:~/shell# grep -n "prasad" file.txt
1: this is prasad
root@Prabhu:~/shell#

if you want to display count of number matches your pattern then use command sa below

root@Prabhu:~/shell# grep -c "prasad" file.txt
1
root@Prabhu:~/shell#

if you want to check if any specific keyword exists in which all files in folder

root@Prabhu:~/shell# grep -l "prasad" *
exit.sh
file.txt
returnCode.sh
test2.txt

find

This command is used to search for file and directories based on name, type, size, data etc

find [path] -options [expression]

where
Path : where to start for sarch
Expression: Criteria like filename, size etc
Example, if you want to search if file with specific name in folder "shell"

root@Prabhu:~# find shell -name "file.txt"
shell/file.txt
root@Prabhu:~#

if you want to search by type/ extension

root@Prabhu:~# find shell -name *.txt
shell/file.txt
shell/test2.txt
root@Prabhu:~#

if you want to search all files with specific permissions

root@Prabhu:~# find shell -perm 777
shell/for.sh
shell/functions.sh
shell/if.sh
shell/returnCode.sh
shell/test2.txt
shell/exit.sh
root@Prabhu:~#

use grep and find together to search for specific keyword in file

root@Prabhu:~# find ./ -type f -name "*.txt" -exec grep "prasad" {} \;
 this is prasad
root@Prabhu:~#

awk

This command is used for pattern scanning and processing

awk options 'pattern {action}' input_file > output_file

Example
Print all lines in file

root@Prabhu:~/shell# awk '{print}' file.txt
 this is prasad
root@Prabhu:~/shell#

print specific column

root@Prabhu:~/prasad# awk '{print $1,$4}' sample.txt

What Ipsum?

Lorem simply
Why use

It long

Where come

Contrary belief,

The of
Where get

There variations
root@Prabhu:~/prasad#

sed

This command used to replace content in the file

sed 's/old_content/new_content/' file_name

Example, let's replace 'prasad' by 'prabhu' in file.txt

root@Prabhu:~/shell# cat file.txt
 this is prasad

as you see file contain this is prasad

now execute sed command to replace

root@Prabhu:~/shell# sed 's/prasad/prabhu/' file.txt
 this is prabhu
root@Prabhu:~/shell#

less

This command is used to read / print few lines in files, then we can enter space to remaining content and so on

Below is syntax

less file_name

1: enter q to exit fron reading mode
2: if you want to search anything, then enter / followed by keyword example /prasad then press enter
3: if you are in search mode, and you want to find next occurrence then press n
4: if you are in search mode, and you want to find previous occurrence then press shift + n

head

This command is used to print first few lines in file
Below is syntax

head file_name

tail

This command is used to print last few lines in file
Below is syntax

tail file_name

diff

This command is used to check difference in two files in same folder or different folder

diff file1 file2

example, if I want to find difference in file.txt and test2.txt in same folder

root@Prabhu:~/shell# diff file.txt test2.txt
1c1
<  this is prasad
---
>  this is prabhu
root@Prabhu:~/shell#

Access & User operations

sudo

This command enables non-root user who are part of sudo group to execute administrative operations
Syntax is as below

sudo [options] command

if you want to act as sudo then execute following command

sudo su

if you want to modify any file which need admin previlages then use command as below

sudo nano file.txt

We can perform many such operations using sudo but you should be part of sudo group in order to use this command

whoami

Use this command to check current logged in user

root@Prabhu:~/prasad# whoami
root
root@Prabhu:~/prasad#

chmod

this command used to change file/ directory permissions
Syntax

chmod [options][permission][file / directory]

Example if I want to modify permission for sample.txt, below is current permission befor change

root@Prabhu:~/prasad# ls -la
total 16
drwxr-xr-x 3 root root 4096 Jun 12 22:45 .
drwx------ 8 root root 4096 Jun 12 23:11 ..
-rw-r--r-- 1 root root 3094 Jun 12 22:37 sample.txt
root@Prabhu:~/prasad#

now read-write permissions to all users for this file

root@Prabhu:~/prasad# ls -la
total 16
drwxr-xr-x 3 root root 4096 Jun 12 22:45 .
drwx------ 8 root root 4096 Jun 12 23:11 ..
-rwxrwxrwx 1 root root 3094 Jun 12 22:37 sample.txt

chown

this command is used to change ownership of file / directory, below is its syntax

chown [options] newowner:newgroup [filename]

disk related operations

df

this command is used to check disk usage and used spaced in your machine
example

root@Prabhu:~# df
Filesystem      1K-blocks      Used  Available Use% Mounted on
none              5038196         0    5038196   0% /usr/lib/modules/6.6.87.1-microsoft-standard-WSL2
none              5038196         4    5038192   1% /mnt/wsl
drivers         123857916 121770020    2087896  99% /usr/lib/wsl/drivers
/dev/sdd       1055762868   1675256 1000384140   1% /
none              5038196        80    5038116   1% /mnt/wslg
none              5038196         0    5038196   0% /usr/lib/wsl/lib
rootfs            5033176      2664    5030512   1% /init
none              5038196       520    5037676   1% /run
none              5038196         0    5038196   0% /run/lock
none              5038196         0    5038196   0% /run/shm
none              5038196        76    5038120   1% /mnt/wslg/versions.txt
none              5038196        76    5038120   1% /mnt/wslg/doc
C:\             123857916 121770020    2087896  99% /mnt/c
D:\             976760828 350942804  625818024  36% /mnt/d
tmpfs             5038196        16    5038180   1% /run/user/0
root@Prabhu:~#

du

This command is used to check size of directory in KB
Example

root@Prabhu:~# cd shell/
root@Prabhu:~/shell# du
40      .
root@Prabhu:~/shell#

Process related operations

top

Command shows all running processes in system and their hardware consumption

root@Prabhu:~/shell# top
top - 23:26:44 up  1:29,  2 users,  load average: 0.01, 0.02, 0.00
Tasks:  30 total,   1 running,  29 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   9840.2 total,   9310.8 free,    493.3 used,    196.3 buff/cache
MiB Swap:   3072.0 total,   3072.0 free,      0.0 used.   9346.9 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
      1 root      20   0   21740  12240   9296 S   0.0   0.1   0:00.94 systemd
      2 root      20   0    3060   1792   1792 S   0.0   0.0   0:00.02 init-systemd(Ub
      7 root      20   0    3076   1792   1792 S   0.0   0.0   0:00.00 init
     65 root      19  -1   50420  15752  14984 S   0.0   0.2   0:00.48 systemd-journal
    118 root      20   0   25004   6272   4992 S   0.0   0.1   0:00.15 systemd-udevd
    192 systemd+  20   0   21452  12800  10624 S   0.0   0.1   0:00.11 systemd-resolve
    193 systemd+  20   0   91020   7552   6784 S   0.0   0.1   0:00.18 systemd-timesyn
    205 root      20   0    4236   2560   2432 S   0.0   0.0   0:00.01 cron

ps

this command shows summarized status of running processes in system

root@Prabhu:~/shell# ps
    PID TTY          TIME CMD
   1566 pts/2    00:00:00 sudo
   1567 pts/2    00:00:00 su
   1568 pts/2    00:00:00 bash
   1597 pts/2    00:00:00 ps
root@Prabhu:~/shell#

kill

This command is used to kill any process, we need to pass process id to kill that perticular process

kill PID

Other utility commands

uname

this command shows information about system

root@Prabhu:~/shell# uname
Linux

To display all setting, use -a

root@Prabhu:~/shell# uname -a
Linux Prabhu 6.6.87.1-microsoft-standard-WSL2 #1 SMP PREEMPT_DYNAMIC Mon Apr 21 17:08:54 UTC 2025 x86_64 x86_64 x86_64 GNU/Linux
root@Prabhu:~/shell#

hostname

Use this command to get hostname of your system

root@Prabhu:~/shell# hostname
Prabhu

time

Use this command to check system date time settings

root@Prabhu:~/shell# time
real    0m0.000s
user    0m0.000s
sys     0m0.000s
root@Prabhu:~/shell#

ip

this command is used to get list and manage network related parameters

ip [options] command

Example, To display ip address of current system

root@Prabhu:~/shell# ip address show
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet 10.255.255.254/32 brd 10.255.255.254 scope global lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:15:5d:48:7f:77 brd ff:ff:ff:ff:ff:ff
    inet 172.28.43.90/20 brd 172.28.47.255 scope global eth0
       valid_lft forever preferred_lft forever
    inet6 fe80::215:5dff:fe48:7f77/64 scope link
       valid_lft forever preferred_lft forever
root@Prabhu:~/shell#

Trying to understand Shell Scripting

Prasad — Tue, 10 Jun 2025 18:04:13 +0000

[This post originally posted to my blog here]

In this post, we are trying to understand about shell scripting. As per wikipedia, A shell script is a computer program designed to be run by a Unix shell, a command-line interpreter.
A script is command line program that contains a series of commands. The commands contained in the script are executed by interpreter. In case of shell scripts, the shell acts as interpreter and executes the commands listed in the script one after another.

Let's create our first shell script

Create a new file in your Unix / Linux operating system. I have ubuntu with me, so I will create new file using touch command

touch firstScript.sh

Then open file with your favorite editor, I am using VIM editor.

vim firstScript.sh

it will open file in edit mode, press "I" to go to insert mode

#!/bin/bash
echo "This is my first shell script"

Save the file, and go back to folder where you have saved this file
before you try to execute the script, make sure that it is executable and have enough permission to run
Enter following command

chmod 755 firstScript.sh

Now, this is time to run our first shell script
Enter file name directly

.\firstScript.sh

We have successfully run our first shell script

Let's further discuss more about shell scripting

Variables

You can use variables in shell script. Variables simply storage locations which have name. We can assign value to those variable for later use. Example, any operations, manipulation etc.
Syntaxt to create variable is very simple

Variable_name="some value"

Once variable created, you can retrieve value inside variable using ${variable_name}

let's create shell script with variable and try to retrieve that value

Create another shell script and write code as below

#!/bin/bash
MY_VAR="Bash"
echo "This is ${MY_VAR} command, running in shell scirpt"

Grant permission as we have given in previous example

then run this shell script

Conditional Statements

if statement

We can use if statement same as other programming languages in shell script.
In shell scripts, we have to use if-then-fi, fi is to tell interpreter that, if condition block has been ended.

below is syntax

if [ condition ]
then
  command 1
  command 2
  ...
fi

lets take an example

#!/bin/bash
firstNumber=10
secondNumber=10

if [ $firstNumber = $secondNumber ]
then
        echo "both numbers are equal"
fi

save the file , grant permission and try to run this shell script
you will see output as below

both numbers are equal

NOTE: Remember to add one space in between if and [ otherwise you will get an error

if-else statement

We can also add else statement along with if , below is its syntax

if [ condition ]
then
  command 1
  command 2
  ...
else
  command 3
  command 4
  ...
fi

let's continue to expand our previous example but here we will change value of variable firstNumber and secondNumber

#!/bin/bash
firstNumber=50
secondNumber=100

if [ $firstNumber = $secondNumber ]
then
        echo "both numbers are equal"
else
        echo "both numbers are not equal"
fi

Run this shell script and you will see results as below

both numbers are not equal

if- else if - else statements

Shell script also allow us for else-if with below syntax

if [ condition 1 ]
then
  command 1
  command 2
  ...
elif [ condition 2 ]
then
  command 3
  command 4
  ...
else
  command 5
  command 6
  ...
fi

lets further expand our previous example again

#!/bin/bash
firstNumber=10
secondNumber=100

if [ $firstNumber = $secondNumber ]
then
        echo "both numbers are equal"
elif [ $firstNumber = 10 ]
then
        echo "first number is 10"
else
        echo "both numbers are not equal"
fi

Now, as firstNumber assigned to 10, it will go to else-if statement block and result will be

first number is 10

Loops

for loop

if you want to perform any action number of times then, we can make use of for loop. Below is syntax for "For" loop

for variable_name in item1 item2 ... itemN
do
  command 1
  command 2
  ...
done

lets take an example of this

#!/bin/bash

for color in red green blue
do
        echo "Selected color in this iteration is: ${color}"
done

like before, you need to grant permission and then execute this shell script. Result will be as below

Comments

We can add comments in shell script using # symbol.
Anthing after # symbol is consider as comments and this command will not get executed
exmaple

#!/bin/bash
for color in red green blue # define the colors here 
do
        echo "Selected color in this iteration is: ${color}"
done

in above script at second line we have added comment as # define the colors here this is just comment, and this will not be executed

Return codes

Return code can be used in script for error checking, if return code is 0 meaning command executed successfully, if it is non-zero value, that means there is some error
We can use special variable $? to check return code if previously executed command.

let's take an example, if I try ls command for any such path which does not exist , then our script will return non-zero code.

#!/bin/bash
ls /prasad/test
echo "$?"

/prasad/test this directory does not exists in my machine, so when I run script, I will get output as below

As we can see it has return code as 2, as it is not zero, we can say there is some error in command execution.

Let's take another example, in this example we are going to create some file and try to see what it will return

#!/bin/bash
touch prasad.txt
echo "text file has been created"
echo "$?"

Run this script

as we can see it has returned code as 0 and created new file with name prasad.txt

Exit Command

We can defined our own exit codes in shell script, simply use exit command in script and follow it with number from 0 to 255.
We can add exit command anywhere in script. Whenever, script reached to exit command it will stop running.

#!/bin/bash
cat prasad.txt
if [ "$?" -eq "0" ]
then
        echo "Command success"
        exit 0
else
        echo "Command failed"
        exit 1
fi

In above example, we are using cat command to read content from file, if it is success then we are checking with return code.
If code returned as 0 that means we have successfully executed previous command and then we are using exit command by setting exit status as 0 , similarly if it is failed to read file then we are exiting with code as 1.

as file with name prasad.txt already present in directory, it will return output as

Command success

Functions

Functions is most importent topic in any programming language, this help to avoid code duplication ana make program well strucured, easy to read, easy to understand.

Below is syntax to create function in shell script

function Function_name() {
# do something
}

We can also write functions without specifying function before it's name as below

function_name(){
#do something
}

and simply use function name in your script file to call function
let's take an example

function add(){
        n1=1
        n2=2
        addition=$((n1+n2)) # add two numbers
        echo "Addition of two number is : ${addition} "
}

add  #<---function calling

this will return output as below

Addition of two number is : 3

NOTE: To perform arithmetic in Bash, you need to use either $(()) or the expr command.

Positional Parameters

We can pass parameters to our shell script and to our functions and those can be accessible using $ symbol example $1, $2 etc
Let's contunue to our above example of addition.

function add(){
        n1=$1
        n2=$2
        addition=$((n1+n2)) # add two numbers
        echo "Addition of two number is : ${addition} "
}

add 10 20 #<---function calling

This will return output as below
Addition of two number is : 30

We also can pass parameters to our shell script directly. lets modify our script and then pass parameters while running script

function add(){
        n1=$1
        n2=$2
        addition=$((n1+n2)) # add two numbers
        echo "Addition of two number is : ${addition} "
}

add $1 $2 #<---function calling

Now, we are going to pass parameters while running script, use below command to run script

This is how we can pass parameter to script and to the function.

Let me know your thought in comment section, Suggestions are welcome.

Happy coding !!

Boilerplate project to debug and run C++ code in VS Code

Prasad — Mon, 05 May 2025 22:21:59 +0000

This post is originally posted on my blog here

I found it little difficult to run CPP project in vs code always, we need to do lot of configuration, setting to debug the code.
In this post, you can find boilerplate to run cpp code in vs code.

Prerequisite

Make sure that CPP compiler already installed in your machine, I will use gcc but you can use any other compiler of your choice
VS Code should be installed in your machine.
(optional) Install plugin "C/C++ Extension Pack" , this will install C/C++ extension and CMAKE (We don't need CMAKE for now, I will write seperate tutorial to build project using CMAKE)

Create new folder for your CPP Project

I am going to follow below folder structure for my project and will follow same in rest of tutorial to write configuration files

Boilerplate
│   main.cpp             # CPP file contains main function
│
└───build                # Build file (Executable / Binary )
│   │   main.exe
└───include              # All header files in project
|    │   student.h
|    │   Employee.h
└───src                  # All source files in project
|   │   student.cpp
|   │   Employee.cpp
└───lib                  # Third party libraries
|   │   spdlog
|    └───include
│       │   spdlog
└───.vscode              # vscode default folder to save settings
|    │   c_cpp_properties.json 
|    │   launch.json           
|    │   tasks.json            
|    │   settings.json

Let's see use of each JSON file stored in .vscode folder mentioned above

c_cpp_properties.json - IntelliSense and Compiler Configuration

This is configuration file in vs code for intellisense, code suggestions and syntax highlighting for c/ c++ code.
It defines include paths, compiler settings, and standard versions.

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/**",
                "${workspaceFolder}/include",         // Add your header directory
                "${workspaceFolder}/libs/**"  // Add third party library directory
            ],
            "defines": [],
            "compilerPath": "D:\\Installation\\mingw\\mingw64\\bin\\g++.exe",   // Add path of your compiler
            "cppStandard": "c++20",
            "intelliSenseMode": "windows-gcc-x64"
        }
    ],
    "version": 4
}

tasks.json - Build Automation

This file defines how VS Code build and compiler your code and helps to automate compilation project.
We can use Ctrl + Shift + B to build cpp code.
This file contains path of header files, source files, third party libraries (if any) & output file.

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "shell",
            "label": "Build Main",
            "command": "D:\\Installation\\mingw\\mingw64\\bin\\g++.exe",  //add path of your compiler
            "args": [
                "-fdiagnostics-color=always",
                "-g",
                "main.cpp",   //by default run main file
                "${workspaceFolder}/src/*.cpp",   //additional files
                 "-I${workspaceFolder}/include",   // Include directory flag
                 "-I${workspaceFolder}/libs/spdlog/include",   // Include third party library
                "-o",
                "${workspaceFolder}/build/main.exe"
            ],
            "options": {
                "cwd": "${workspaceFolder}"
            },
            "problemMatcher": ["$gcc"],
            "group": "build",
            "detail": "Building main.exe in workspace root"
        }
    ]
}

IMPORTANT:

if you create tasks.json using vs code function, then it will have default type as cppbuild, in this case you need to add path of all source files one by one.

To make it more generic, we have added path of source file as "${workspaceFolder}/src/*.cpp" this does not work with cppbuild so changed the type to shell

Now, whenever we add new source file to project, we dont need to modify tasks.json file.

NOTE:

In args, we have passed -g, main.cpp to debug file. if you don't want to pass main.cpp , then we can also mention "$(file)" to debug current file.

launch.json - Debugger Setup

This file conatins configuration for debugging environment, this defines executable, debugger and how to launch a program.
Without this file, vs code will not know how to debug program.

Once we add this file, we can see debug option in dropdown in vs code with name C++ Debug (you can give any name) in below configuation

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "C++ Debug",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/build/main.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "D:\\Installation\\mingw\\mingw64\\bin\\gdb.exe",
            "preLaunchTask": "Build Main",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ]
        }
    ]
}

NOTE:

We have added "preLaunchTask": "Build Main", this name should be exactly same as which we have defined in tasks.json

launch.json will make sure that configuration which we have defined in tasks.json has been loaded completely.

settings.json - Workspace and Editor settings

This file defines workspace specific settings including formatting, linting and compiler warnings

{
    "files.associations": {
        "iostream": "cpp",
        "ostream": "cpp"
    },
   "editor.formatOnSave": true
}

NOTE:

This file also can be used to customize editor behaviours i.e. tabs, spaces, auto-save etc.

That's all, now let's write some simple code.

main.cpp

#include <iostream>
#include <stdio.h>
#include "school.h"

using namespace std;

int main(int argc, char const *argv[])
{
  school::student s;
  s.display(); // Call the display function from the student class
  return 0;
}

As mentioned above, all our header files will be inside "include" folder. so create one for school.h

school.h

#include<iostream>
using namespace std;

namespace school{
    class student{
        public:
            void display();
    };
}

then create it's source file inside "src" folder, create one source file called school.cpp

school.cpp

#include <iostream>
#include "../include/school.h"
using namespace std;
namespace school
{
    void student::display()
    {
        cout << "Hello from student class!" << endl;
    }
}

Our folder structure will be something as below.

Now, press F5 or go to Debug -> select "Debug C++" from dropdown and click on debug icon.
Project will compile and generate executable in build folder.

Great! we can now debug and run program in vs code.
What next ? if you want to create another program , just copy this project folder and replace your files to run & debug your program.

Let me know your thought on this, your suggestions are welcome.

Happy Coding !

Question: How to create APIs like ServiceNow ?

Prasad — Tue, 24 Aug 2021 08:01:14 +0000

I was reading REST API documentation on ServiceNow. They have Table API to perform CRUD Operations on database- Table API
They have created it so nice that we just need to pass the name of table in query params to get the data.
example:
GET/now/table/{tableName}

Similarly they have created this for other operations like GetbyId, Create, Update, Delete.

I was thinking , how this kind of common crud operations can be done in NodeJS using Express and sequelize?
How should I start for this? your guidance is appreciated.

what should be best technology stack for R project?

Prasad — Thu, 05 Dec 2019 12:14:14 +0000

I want to create an application which will generate the graphs using R in which I will take data from database and pass to R project, R will do some operation and pass it back to front end?

I have several questions before I start project

Which programming language/framework I should use (C#, Python, PHP, Node)?
Which database should I prefer?

In short, what should be technology stack for this kind of project?

DEV Community: Prasad

Architecting a Local Ansible Lab - A Professional Guide using WSL 2 and Docker

Prerequisites

Phase 1: Building Your "Data Center" (Infrastructure)

Step 1: Create Your Workspace

Step 2: Create the "Server" Image

Step 3: Build the Image

Step 4: Launch the Fleet

Phase 2: Setting Up Ansible (The Control Center)

Step 1: Create Professional Folder Structure

Step 2: The Inventory File (hosts.ini)

Step 3: Ansible Configuration (ansible.cfg)

Phase 3: Writing the Automation Code

Step 1: The 'Common' Role

Step 2: The 'Nginx' Role

Step 3: The Playbook

Phase 4: Execution and Verification

Step 1: Run the Playbook

Step 2: Verify the Result

Conclusion

Trying to understand SOLID Principles with C#

The Five Principles

Why SOLID Principles Matter

Single Responsibility Principle

Definition

Problem Example

Solution

Open-Closed Principle

Definition

Problem Example

Solution: Use Abstraction through Interface

Liskov Substitution Principle

Definition

Problem Example

Solution

Interface Segregation Principle

Definition

Problem Example

Solution: Segregate Interfaces

Dependency Inversion Principle

Definition

Problem Example

Solution: Depend on Abstraction

Advanced: Dependency Injection

Summary

Best Practices

Trying to understand Constructors in c++

What is Constructors?

Key characteristics

Types of constructors

Trying to understand Pointers in c++

Declare pointer

Why it is important to add data type ?

Create first pointer

Why do we need pointers ?

Pass by Value

Pass by Reference

Csv file handling with shell script

Common declaration

Function to read CSV file

function count rows in file

Extract specific column values

Append data to csv file

Get row by Id

Function calling

File Operations with shell script

Useful Linux commands

Commands for directory operations

ls

option : -la

option : -lt

option: -ltr

pwd

cd

mkdir

rmdir

Commands for file operations

touch

cp

mv

Step 2: The Inventory File (`hosts.ini`)

Step 3: Ansible Configuration (`ansible.cfg`)