DEV Community: Ankur Singh

I Tired of Trying to Read API Responses, So We Built This Free Tool

Ankur Singh — Sun, 08 Feb 2026 07:16:06 +0000

The Struggle is Real 😫

If you are a frontend, backend, or data engineer, you know this pain:

You get a massive API response. It’s 2MB of minified text. You paste it into an online formatter, but you still can't find that one specific ID. Or worse, you need to access a nested property like data.users[4].attributes.marketing.status, and you have to manually type out that path in your IDE, hoping you didn't make a typo.

console.log(JSON.stringify(data, null, 2)) only gets you so far before your terminal explodes.

So, We Built a Solution 🛠️

My team and I decided to fix this workflow. We built bigjson.online.

It is a free, web-based tool designed specifically for handling large JSON files, debugging API responses, and making data readable.

Killer Features 🚀

Here is why this is better than just pasting into a text editor:

1. The Tree View & Search 🔍

As you can see in the screenshot above, we parse your JSON into an interactive Tree. But the real magic is the Search. You don't just "Find" text. We built specific filters:

Search by Key: Find specific field names (e.g., questionId).
Search by Value: Find specific data points (e.g., that missing value 5).
Context: It highlights exactly where the data lives in the hierarchy.

2. "Copy Path" (My Favorite Feature) 📋

This was the main reason we built it. When you drill down into a nested object in the Tree View, you can simply click to copy the path.

Instead of manually typing:
response.data.results[0].deeply.nested.value

You just click the value in bigjson.online, paste it into VS Code, and you're done. It saves so many "undefined is not a function" errors.

3. Compare Mode ⚖️

Debugging a breaking behavior? Paste the "Old" JSON response and the "New" one side-by-side. We highlight exactly what changed so you don't have to play "spot the difference" by eye.

Try It Out!

It is live right now. It handles massive files, it's free, and frankly, I think the Dark Mode looks pretty slick.

👉 https://www.bigjson.online

We Want Your Feedback!

This is our first major release and engagement has been awesome so far. But we built this for devs, so we need devs to tell us how to make it better.

Does it handle your massive 10MB logs?
Is the search fast enough?
What feature is missing?

Let me know in the comments below! 👇

Happy Debugging! 💻
Contact me: ankursingh91002@gmail.com

Angular with Injectable Services

Ankur Singh — Sun, 03 Aug 2025 16:23:26 +0000

Ankur Singh

Aug 3 '25

Angular Injectable Services: Hogwarts Sorting Hat

#angular #beginners #web #typescript

Comments

4 min read

Angular Injectable Services: Hogwarts Sorting Hat

Ankur Singh — Sun, 03 Aug 2025 13:27:42 +0000

Introduction

Welcome 👋 to this blog. In this blog, we will be learning how the Angular DI(Dependency Injection) works by creating the Injectable Services and using them inside our components throughout the application. We'll be creating the popular Hogwarts Sorting Hat using the DI(Dependency Injection).

Are you ready? If yes, write gryffindor

Angular Component

Angular Components are responsible for the view that is shown to the user interface. The component task is to take care of User Experience and nothing more.

In simple terms, if you are visiting a web application, two things are happening underneath the hood: you are seeing what you need to see, the UI, and the web app is doing the business part, fetching the data from the server, cleaning it, formatting it, sometimes some calculation and so on.

So our components are responsible for showing the User Interface(data) to the user, and our Services are responsible for doing the other part I mentioned above.

Angular Dependency Injection(DI)

In Angular, the DI system comprises the dependency consumer, dependency provider & Injector. We didn't need to delve too deeply into the concepts of dependency consumer and provider.

All we need to know about dependency can be visualised as something we rely on [ like Harry Potter relies on their wand to cast the spell ].

Dependency consumer is who is requesting the dependency(data, function, property), Dependency Provider is who is providing these things and Injector helps to facilitate the interaction between dependency consumers and dependency providers.

Let's code it

1 First, make a new Angular Project

Run this script make sure you have Angular CLI installed.

ankur@ankur:~$ ng new learn-services

2 Then make the server run

learn-services$ npm start

3 Configure the project

Go to app.html file remove everything expect this line <router-outlet />

Create a new component

learn-services$ ng generate component components/main-page

Create a new service

learn-services$ ng generate service services/sorting-hat

4 Let's write some HTML Code in components/main-page.html

<div class="sorting-hat-container">
  <h2>🧙‍♂️ Hogwarts Sorting Hat</h2>
  <p>Enter your name to discover your Hogwarts House!</p>
  <input type="text" [(ngModel)]="userName" placeholder="Type your name..." class="name-input" />
  <button (click)="sorting_hat(userName)" class="sort-btn">Sort Me!</button>
  @if(houseName){
      <div class="result">
        <h3>Congratulations, {{userName}}!</h3>
        <p>You belong to <span class="house">{{houseName}}</span>!</p>
      </div>
  }
</div>

the CSS in components/main-page.css

.sorting-hat-container {
  max-width: 400px;
margin: 40px auto;
  padding: 24px;
  background: #f8f4e3;
  border-radius: 16px;
  box-shadow: 0 4px 16px rgba(0,0,0,0.12);
  text-align: center;
  font-family: 'Segoe UI', 'Arial', sans-serif;
}
.name-input {
  padding: 8px;
  width: 80%;
  margin-bottom: 16px;
  border-radius: 8px;
  border: 1px solid #bfa76f;
  font-size: 1rem;
}
.sort-btn {
  background: #7f5a36;
  color: #fff;
  border: none;
  padding: 10px 24px;
  border-radius: 8px;
  font-size: 1rem;
  cursor: pointer;
  transition: background 0.2s;
}
.sort-btn:hover {
  background: #a67c52;
}
.result {
  margin-top: 24px;
  background: #fffbe6;
  padding: 16px;
  border-radius: 8px;
  border: 1px solid #bfa76f;
}
.house {
  font-weight: bold;
  color: #7f5a36;
  font-size: 1.2em;
}

5 Now time to create the service and inject it inside our component

Open services/sorting-hat.ts and paste this

import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root'
})
export class SortingHat {
  houses: string[] = ['Gryffindor', 'Hufflepuff', 'Ravenclaw', 'Slytherin'];

  sorting_hat(){
    let index = Math.floor(Math.random() * (4 - 1 + 1)) + 1;
    return this.houses[index];
  }
}

It's basically a function which helps in sorting the students.

6 Inject services into the component

It's very easy, this one line is at all.

sortingFunction = inject(SortingHat);

7 Here is the full code of the main-page.ts file

import { Component, inject } from '@angular/core';
import { SortingHat } from '../../services/sorting-hat';
import { FormsModule } from '@angular/forms';

@Component({
  selector: 'app-main-page',
  imports: [FormsModule],
  templateUrl: './main-page.html',
  styleUrl: './main-page.css'
})
export class MainPage {
  userName: string = '';
  houseName: string = '';

  sortingFunction = inject(SortingHat);

  sorting_hat(name: string): void {
    this.houseName = this.sortingFunction.sorting_hat();
  }

}

Time to refresh the page

Nothing happens ;) Because we have not bound our main HTML file app.html yet.

Go to app.ts file

...
import { MainPage } from './components/main-page/main-page';
...
  imports: [RouterOutlet, MainPage],
...

Go to app.html file

<app-main-page />
<router-outlet />

Time to refresh the page again.

You nailed it

You have learned how to create your injectable services and inject with in different components and reuse it. I have share the code repository here for your reference.

Reference

https://angular.dev/guide/di/creating-injectable-service

📧 Email: ankursingh91002@gmail.com
🔗 LinkedIn: Ankur Singh
🔗Twitter: @ankur_136

Let's connect and create something great together!

Linux Insight Blogs: rsync

Ankur Singh — Sun, 06 Jul 2025 11:11:02 +0000

Introduction

Welcome 👋 to this blog. In this blog, we will learn about the rsync command-line utility on Unix/Linux systems. A command-line utility is a program or tool that you run using the CLI(Command Line Interface) instead of the GUI(Graphical User Interface)

rsync

rsync stands for remote sync. It is a fast and extraordinarily file-copying tool. It is capable of file transferring from a local host to any remote host. Rsync is most popular for its delta-transfer algorithm, which allows only to send data by sending only the differences between the source files and the existing files in the destination. Rsync finds files that need to be transferred using a lqquick checkrq algorithm.

Let's get our hands dirty with code

I have two folder directories with the name local and remote. I am treating local as the file system in my local computer and the remote as the server file system to transfer the data. Don't worry you can do the same for the server as well only a small syntax will change nothing else.

ankur:~/Desktop/local$ ls
file1.txt  file2.txt  file3.txt  file4.txt  file5.txt

ankur:~/Desktop/remote$ ls -a
.  ..

-r flag (recursive mode) This enables you to recurse into directories.

ankur:~/Desktop$ rsync -r local/ remote

Now

ankur:~/Desktop/remote$ ls
file1.txt  file2.txt  file3.txt  file4.txt  file5.txt

Mind the "/" after the local other wise, you output be like remote/local/file{1..5}.txt

-a flag (archive mode) This enables you to recurse and want to preserve almost everything(symbolic links, special and device files, modification times, groups, owners, and permissions)

ankur:~/Desktop$ rsync -a local/ remote

-P flag (partial mode) By default, rsync will delete any partially transferred file if the transfer is interrupted. In some circumstances it is more desirable to keep partially transferred files. The -P flag will help us to achieve this.

ankur:~/Desktop$ rsync -aP local/ remote
sending incremental file list

-h flag (human readdable mode)

ankur:~/Desktop$ rsync -aPh local/ remote
sending incremental file list

--delete flag

To keep the directories truly in sync file must be deleted from the destination directory as well if they are deleted from the source as rsync by default doesn't do it automatically but you can always overwrite this. Using --delete flag, we can achieve the same.

ankur:~/Desktop$ rsync -aPh --delete local/ remote
sending incremental file list
deleting file1.txt
./

-v flag increase verbosity in the output of the command.

ankur:~/Desktop$ rsync -aPhv --delete local/ remote
sending incremental file list
./
file1.txt
              0 100%    0.00kB/s    0:00:00 (xfr#1, to-chk=4/6)

sent 197 bytes  received 38 bytes  470.00 bytes/sec
total size is 0, speedup is 0.00

There are at least hundreds of flags you can use according to your needs. You are always welcome to check out the different commands from the man page.

For connecting server using SSH

rsync -avz local/ username@remote:/remote/destination/

🎉 You nailed it

You’ve now learned how to use the rsync command for syncing your remote server with your local directory. It’s time to open your terminal and try these commands on your own system. Play around, explore, and see what's happening under the hood of your machine. Got something cool or unexpected? Share it...

References

Let's connect
📧 Email: ankursingh91002@gmail.com
🔗 LinkedIn: Ankur Singh
🔗 Twitter: @ankur_136

Linux Insight Blogs: chmod

Ankur Singh — Sat, 28 Jun 2025 18:22:02 +0000

Introduction

Welcome 👋 to this blog. In this blog we will gonna be learning about the chmod a command-line utility on Unix/Linux systems. A command-line utility is a program or tool that you run using CLI(Command Line Interface) instead of GUI(graphical user interface)

chmod

chmod stands for change mode. It's a command-line utility which used to change the permissions of files and directories. In Unix/Linux or in general computer Science we can define permission following:

read(r), view file content
write(w), modify file content
execute(x), run as a program

With the help of this command, we can change the permissions of the files assigned to three user groups.

In Unix/Linux systems we have three user classes:

Owner(u), user who owns a file
group(g), users in the file group
other(o), other users

Let's get our hands dirty with code

Open your terminal by pressing CTRL + Alt + T.

We have 2 ways to use this commands

1. With symbols

In this we will be using these symbols +, - and = symbols to modify the permissions. The meaning of the symbols + (Add permission), - (Remove permission) and = (set exact permissioin).

Let's start typing the command in the terminal:

I have created a three files in the blog folder.

ankur@ankur:~/Desktop/blog$ ls
file1.txt  file2.txt  file3.txt

Let's check the permission of all the files by executing the ls commands with -l flag.

ankur@ankur:~/Desktop/blog$ ls -l
total 0
-rw-rw-r-- 1 ankur ankur 0 Jun 28 23:15 file1.txt
-rw-rw-r-- 1 ankur ankur 0 Jun 28 23:15 file2.txt
-rw-rw-r-- 1 ankur ankur 0 Jun 28 23:15 file3.txt

The -rw-rw-r-- part, which represents file permissions in Linux. This string has 10 characters, structured like this:

[Type][Owner][Group][Others]
 -     rw-     rw-    r--

Give execute permission to the owner

ankur@ankur:~/Desktop/blog$ chmod u+x file1.txt 
ankur@ankur:~/Desktop/blog$ ls -l
total 0
-rwxrw-r-- 1 ankur ankur 0 Jun 28 23:15 file1.txt

Now you can see the x in the owner string, which means it has execute privilege.

Removing execute permission from the owner

ankur@ankur:~/Desktop/blog$ chmod u-x file1.txt 
ankur@ankur:~/Desktop/blog$ ls -l
total 0
-rw-rw-r-- 1 ankur ankur 0 Jun 28 23:15 file1.txt

Now you can see the x vanishes in the owner string.

Set exact permission explicitily

ankur@ankur:~/Desktop/blog$ chmod u=rwx,g=r,o=wr file1.txt 
ankur@ankur:~/Desktop/blog$ ls -l
total 0
-rwxr--rw- 1 ankur ankur 0 Jun 28 23:15 file1.txt

You can see the string is changed.

2. With Numbers

Each permission is mapped to a numeric value.

r (read)    4
w (write)   2
x (execute) 1

So, everything worked the same expect in this method we passed the 3 string 1st one for owner, 2nd one for group and the 3rd one for others

for example

ankur@ankur:~/Desktop/blog$ chmod 755 file1.txt 
ankur@ankur:~/Desktop/blog$ ls -l
total 0
-rwxr-xr-x 1 ankur ankur 0 Jun 28 23:15 file1.txt

755 will be breaked into(7, 5, 5)
7 -> 4+2+1 (rwx)
5 -> 4+1 (r-x)
5 -> 4+1 (r-x)

You can visit link to see the mapping of permission with the numeric.

🎉 You nailed it

You’ve now learned how to use the chmod command to change the permission of the files with two methods symbolic and numerical. It’s time to open your terminal and try these commands on your own system. Play around, explore, and see what's happening under the hood of your machine. Got something cool or unexpected? Share your best use case of chmod commands in the comment section.

Let's connect
📧 Email: ankursingh91002@gmail.com
🔗 LinkedIn: Ankur Singh
🔗 Twitter: @ankur_136

Linux Insight Blogs: lsof

Ankur Singh — Mon, 23 Jun 2025 11:32:39 +0000

Introduction

Welcome 👋 to this blog. In this blog we will gonna be learning about the lsof a command-line utility on Unix/Linux systems. A command-line utility is a program or tool that you run using CLI(Command Line Interface) instead of GUI(graphical user interface).

lsof

lsof stands for "list open files". It's a powerful command-line utility on Unix/Linux systems that shows you which files are open by which processes, users, port, specific process and many more. In Linux, everything is treated as a file, so it's important to know how to list specific files.

Let's get our hand dirty with code

Open your terminal by pressing CTRL + Alt + T.

Check all open files

@Ankur:~$ lsof
COMMAND    PID  TID TASKCMD               USER   FD      TYPE DEVICE SIZE/OFF             NODE NAME
systemd      1                            root  cwd   unknown                                  /proc/1/cwd (readlink: Permission denied)
systemd      1                            root  rtd   unknown                                  /proc/1/root (readlink: Permission denied)
systemd      1                            root  txt   unknown                                  ...

You will get a long list of files that are currently open on your file system.

Check processes using a specific file

Ankur:~$ lsof /file/path

Check files using the given port

Ankur:~$ lsof -i :3000
COMMAND  PID  USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
node    3452 ankur   21u  IPv4  44686      0t0  TCP localhost:3000 (LISTEN)

Check files opened by a specific process

Ankur:~$ lsof -p 3452
@Ankur:~$ lsof -p 3452
COMMAND  PID  USER   FD      TYPE DEVICE  SIZE/OFF  NODE NAME
node    3452 ankur  cwd       DIR   8,64      4096 43479 /home/ankur/node-webserver
node    3452 ankur  rtd       DIR   8,64      4096     2 /
...

Check open network connections

Ankur:~$ lsof -i
COMMAND  PID  USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
node    3717 ankur   21u  IPv4  52033      0t0  TCP localhost:3000 (LISTEN)

Show process that uses the internet connection now

Ankur:~$ lsof -P -i -n
COMMAND  PID  USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
node    3725 ankur   21u  IPv4  44727      0t0  TCP 127.0.0.1:3000 (LISTEN)

Lists all listening ports together with the PID of the associated process

Ankur:~$ lsof -Pan -i tcp -i udp
COMMAND  PID  USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
node    3725 ankur   21u  IPv4  44727      0t0  TCP 127.0.0.1:3000 (LISTEN)

Show all open ports

Ankur:~$ lsof -Pnl -i
COMMAND  PID     USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
node    3725     1000   21u  IPv4  44727      0t0  TCP 127.0.0.1:3000 (LISTEN)

List all files opened by a particular command

@Ankur:~$ lsof -c "node"
COMMAND  PID  USER   FD      TYPE DEVICE  SIZE/OFF  NODE NAME
node    3725 ankur  cwd       DIR   8,64      4096 43479 /home/ankur/node-webserver
node    3725 ankur  rtd       DIR   8,64      4096     2 /

Show 10 largest open file

Ankur:~$ lsof / | \
awk '{ if($7 > 1048576) print $7/1048576 "MB" " " $9 " " $1 }' | \
sort -n -u | tail | column -t
0MB        NAME                                              COMMAND
1.37904MB  /usr/bin/bash                                     bash
2.02687MB  /usr/lib/x86_64-linux-gnu/libc.so.6               sh
2.47214MB  /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.33     node
5.05953MB  /usr/lib/x86_64-linux-gnu/libcrypto.so.3          sort
114.61MB   /home/ankur/.nvm/versions/node/v22.14.0/bin/node  node

Show current working directory of a process

Ankur:~$ lsof -p 3725 | grep cwd
node    3725 ankur  cwd       DIR   8,64      4096 43479 /home/ankur/node-webserver

🎉 You nailed it

You’ve now learned how to use the lsof command to inspect open files, network ports, and running processes like a pro. It’s time to open your terminal and try these commands on your own system. Play around, explore, and see what's happening under the hood of your machine. Got something cool or unexpected? Share your findings or favorite lsof tricks in the comments below!

Reference

📧 Email: ankursingh91002@gmail.com
🔗 LinkedIn: Ankur Singh
🔗Twitter: @ankur_136

Let's connect and create something great together!

[Boost]

Ankur Singh — Mon, 05 May 2025 17:19:36 +0000

Ankur Singh

May 3 '25

List of important Docker commands: Docker Series 03

#docker #devops #bash #webdev

Comments

2 min read

List of important Docker commands: Docker Series 03

Ankur Singh — Sat, 03 May 2025 18:08:57 +0000

Introduction

Welcome 👋 to this blog. If you want to learn about Docker and are a beginner, you have come to the right place. This blog series will cover everything from the very beginning to the end. This blog will teach us about the necessary and important Docker commands.

List of commands

List the containers that are actively running

$ docker ps

Note: If the Docker commands are not running in your system, it is not installed or does not have enough privileges to use it with sudo commands.

List all the containers irrespective of their running status

$ docker ps -all

Run a Docker container

Step 1: Create a container

$ docker container create hello-world:linux

Here, hello-world:linux is a hello world container image which is pulled from the docker hub

Step 2: Start the container

$ docker container start <Container ID>

Here, is the container ID which can be obtained by running the previous commands docker ps.

Running the Docker container(short way)

$ docker run hello-world:linux

docker run = docker container create + docker container start + docker container attach

Getting the log of the container

$ docker log <Container ID>

Run additional commands from the container

$ docker exec <Conatiner ID> <Commands>

Starting a interactive shell

$ docker exec --interactive --tty <Container ID>

Stop the container immediately

$ docker stop -t <ID>

Remove the container

$ docker rm <Container ID>

List all the docker image

$ docker images

Remove the Docker image

$ docker rmi <Image ID>

Remove the Docker Image forcefully

$ docker rmi -f <Image ID>

Binding ports to the container

$ docker run -p 5001:5000 our-server

Tagging the image name

$ docker tag <Local-image-name> username/your-image-name:0.0.01

Conclusion

In this blog, we explored different commands of Docker containers, images, emphasising their roles in container & image creation. In the next blog, we will delve deeper into the technical aspects. Stay tuned

Hire me: ankursingh91002@gmail.com
LinkedIn
Twitter

Docker Image, Container, Dockerfile: Docker Series for Beginners - 02

Ankur Singh — Tue, 26 Nov 2024 04:29:29 +0000

Introduction

Welcome 👋 to this blog. If you want to learn about Docker and are a beginner, you came to the right place. This blog series will cover everything from the very beginning to the end. In this blog, we will learn about the relationship between Docker Container, Images & Dockerfile. If these words seem very overwhelming then don't worry at the end of this blog, you will be able to know everything with the help of recipes & food examples. Please stick with me till the end.

Docker Images

In simple terms, a Docker image is like a recipe that tells the computer what files, tools, and instructions it needs to run an app. But just as a recipe needs to be cooked to make food, a Docker image needs to be "run" to create something useful—a Docker container!

A more precise definition will look something like this:
A Docker image is a lightweight, standalone, and immutable package that includes all the necessary components (such as code, runtime, libraries, dependencies, and configurations) to run a specific application. It serves as a blueprint or template for creating Docker containers, which are the executable instances of the image.

Docker Images are generally immutable.

Docker Container

A Docker container is like a finished dish made from a recipe. While the recipe (Docker image) tells you how to make the food, the container is the food ready to eat.

In the same way, a Docker container is a working app created from the Docker image, and it can do everything it was designed to do!

A more precise definition will look something like this:
A Docker container is a lightweight, standalone, and executable software package that includes everything needed to run an application: the code, runtime, system tools, libraries, and settings. It is a runtime instance of a Docker image that runs in an isolated environment, ensuring the application behaves the same regardless of where it is deployed.

We have two ways to create the Docker Container,

Docker Image
Dockerfile

We have already learnt about the Docker Image. If in any case, our image is not present in the system then it'll try to fetch from the Dockerhub, like we have Github & Gitlab for codes same as we have Dockerhub for the docker containers.

Now time to learn about Dockerfile

Dockerfile

A Dockerfile is a text file that contains instructions for building a Docker image. It acts like a blueprint or script, telling Docker step-by-step how to create the image, including which base image to use, what software or dependencies to install, and how to configure the application.

If you don't understand Dockerfile, don't worry. The next blog is completely dedicated to Dockerfile, how to create a container with image as well as from the Dockerfile.

Conclusion

In this blog, we explored Docker containers, images, and Dockerfiles, emphasizing their roles in container creation. In the next blog, we will delve deeper into the technical aspects, including commands related to Docker, and how to create containers from both images and Dockerfiles. Stay tuned

Hire me: ankursingh91002@gmail.com
LinkedIn
Twitter

How to undo the most recent local commits in Git?

Ankur Singh — Sun, 24 Nov 2024 05:38:23 +0000

Step 1:

git reset HEAD~

Step 2:

# Make the changes as necessary

Step 3:

git add .

Step 4:

git commit -c ORIG_HEAD

Docker Container: Docker Series 01

Ankur Singh — Sat, 23 Nov 2024 17:40:44 +0000

Introduction

Welcome 👋 to this blog. If you want to learn about Docker and are a complete beginner, you came to the right place. This blog series will cover everything from the very beginning to the end. This blog post will discuss what a container is, what Docker is, why Docker is necessary, and much more. So please stay with us until the end.

In software or application development we always have to face this problem:

"It works on my machine problem"

The main reasons for this problem are missing tools, different configurations, and hardware dependencies on different platforms.

Docker and container are the solutions to this problem.

Why we need Docker & Containers?

Suppose, my friend David and I are building a Flask web application I am using Ubuntu 22._ LTS and he is using Windows 11. I built the web app with some dependencies(e.g., Python version, Flask version, some run commands etc.) when I zipped the project folder and sent it to David, he called me and said It's not working on my machine then I replied It works on my machine problem. Can you guess why this happened?

[Think about it Comment below the answer]

The reason this happens is because of missing dependencies or conflicting dependencies. The simple meaning is that in the David system, there is a possibility that the dependency is not present(installed) or the version is not the same as my system's version. Then in this scenario, Docker and containers came into the picture.

Containers

Containers are like little boxes that hold an app and everything it needs to run, like tools and instructions. They help the app work the same way on any computer, without getting mixed up with other apps.

Don't confuse it with virtual machines, virtual machines are different things. Suppose in terms of the house, think of a virtual machine (VM) as a big house where each app gets its own full house with walls, a kitchen, and a bathroom—it takes up a lot of space and needs a lot of work to build.

A container is like a small apartment in a big building. Each app gets its own room, but they share the walls and the building’s kitchen and bathroom, so it’s quicker and uses less space.

Docker

Docker is a platform that allows developers to package applications and their dependencies into lightweight, portable containers. These containers run consistently across different environments, providing isolation and ensuring that the application functions the same on any system that supports Docker.

Installation

In Windows
You can download the exe file directly from the official website.

And install it manually.

In Linux

Step 1: Set up Docker apt repository

# Add Docker's official GPG key:
sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Step 2: Install the Docker package

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Step 3: Verify that the installation

sudo docker run hello-world

Conclusion

In this blog, we explored the basics of Docker and containers, highlighting their role in solving the "it works on my machine" problem by providing consistent application performance across environments. Containers are lightweight, efficient, and simpler to use than virtual machines, making them a valuable tool for developers.

Hire me: ankursingh91002@gmail.com
LinkedIn
Twitter

ChartDB: New Functionalities Unlocked! 🎉

Ankur Singh — Sat, 16 Nov 2024 09:28:45 +0000

Introduction

Welcome 👋 to this blog. This blog will introduce new functionalities of chartDB. We have just added some new functionality to the chatDB project. This new functionality helps us share our diagram with other features and duplicate the table.

Share Functionality Unlocked!

Hey, we are very happy to introduce our new functionality of sharing the project with other users or friends.

Here’s how it works:

For self-hosted users, simply run the latest update, and it’s ready to go!
For cloud-hosted users, we’ve added a sign-in requirement for some actions, like AI export, diagram export, and import. This helps prevent abuse and allows us to connect with you directly. We’d love to update you on new features and share our ChartDB journey!

To send the diagram you can Export it into JSON download it and send it to the recipient.

And if you have a JSON file you can upload it and see the output.

Table Duplication Unlocked! 🚀

You can now duplicate tables effortlessly! Just right-click on a table or hit the three dots (options) next to the table name in the side panel to give it a try. 🔄 It's all about making your life easier, and we hope you love it!

To duplicate the table follow:

First right click on the table which you want to duplicate
Then click on the duplicate table

Conclusion

You have now learned how to use the share and duplicate feature of the ChartDB.

Thank you for reading! If you enjoyed this content, feel free to connect to me:
📧 Email: ankursingh91002@gmail.com

🔗 LinkedIn: Ankur Singh

🔗 Twitter: @ankur_136

Let's connect and create something great together!