Armankumar's Blogs

Getting Started with cURL

ARMAN PATEL — Fri, 23 Jan 2026 00:35:16 GMT

What is cURL

cURL is a command-line tool. It lets you to send request to server and receive data from server, such as fetching a webpage or interacting with API directly from terminal.

Why programmers need cURL

Programmers can have direct and raw access with servers right from terminal with any GUI, revealing responses, status codes, headers, etc.

Making your first request using cURL

Open you terminal and typein curl https://example.com

~ $ curl https://example.com
Example DomainExample Domain
This domain is for use in documentation examples without needing permission. Avoid use in operations.
Learn more

cURL with -i flag curl -i https://example.com reveals full headers, incuding status code 200.

~ $ curl -i https://example.com
HTTP/2 200 
date: Wed, 21 Jan 2026 01:43:56 GMT
content-type: text/html
cf-ray: 9c131f9f9a143d2e-BLR
last-modified: Tue, 20 Jan 2026 21:08:27 GMT
allow: GET, HEAD
accept-ranges: bytes
age: 12864
cf-cache-status: HIT
server: cloudflare

Example DomainExample Domain
This domain is for use in documentation examples without needing permission. Avoid use in operations.
Learn more

Here, we get complete headers followed by a html webpage, mimicking browser.

Understanding Request and Response

Simple Request response cycle :

A Client (Browser, cURL or app) sends request (with request headers and body) to server.
Request travels to server that hosts webpage or API.
Server processes request and returns a response to Client with Status Code (Such as 200 for OK, 400, 500, etc), response headers (extra info) and actual response body (such as html, json or image etc).
Client uses that response and do whatever it is supposed to do such as rendering html on browser or using response data in app or printing on terminal.

For understanding complete request and response cycle, following command is useful : curl -v https://example.com. (v - verbose).

~ $ curl -v https://example.com   
* Host example.com:443 was resolved.
* IPv6: 2606:4700:9ae2:8c7c:3342:0:ccc4:a209
* IPv4: 104.18.26.120, 104.18.27.120
*   Trying [2606:4700:9ae2:8c7c:3342:0:ccc4:a209]:443...
* Connected to example.com (2606:4700:9ae2:8c7c:3342:0:ccc4:a209) port 443
* ALPN: curl offers h2,http/1.1
* (304) (OUT), TLS handshake, Client hello (1):
*  CAfile: /etc/ssl/cert.pem
*  CApath: none
* (304) (IN), TLS handshake, Server hello (2):
* (304) (IN), TLS handshake, Unknown (8):
* (304) (IN), TLS handshake, Certificate (11):
* (304) (IN), TLS handshake, CERT verify (15):
* (304) (IN), TLS handshake, Finished (20):
* (304) (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / AEAD-CHACHA20-POLY1305-SHA256 / [blank] / UNDEF
* ALPN: server accepted h2
* Server certificate:
*  subject: CN=example.com
*  start date: Dec 16 19:39:32 2025 GMT
*  expire date: Mar 16 18:32:44 2026 GMT
*  subjectAltName: host "example.com" matched cert's "example.com"
*  issuer: C=US; O=SSL Corporation; CN=Cloudflare TLS Issuing ECC CA 3
*  SSL certificate verify ok.
* using HTTP/2
* [HTTP/2] [1] OPENED stream for https://example.com/
* [HTTP/2] [1] [:method: GET]
* [HTTP/2] [1] [:scheme: https]
* [HTTP/2] [1] [:authority: example.com]
* [HTTP/2] [1] [:path: /]
* [HTTP/2] [1] [user-agent: curl/8.7.1]
* [HTTP/2] [1] [accept: */*]
> GET / HTTP/2
> Host: example.com
> User-Agent: curl/8.7.1
> Accept: */*
> 
* Request completely sent off
< HTTP/2 200 
< date: Wed, 21 Jan 2026 01:49:00 GMT
< content-type: text/html
< cf-ray: 9c13270fd8c947c0-BOM
< last-modified: Tue, 20 Jan 2026 21:08:27 GMT
< allow: GET, HEAD
< accept-ranges: bytes
< age: 13169
< cf-cache-status: HIT
< server: cloudflare
< 
Example DomainExample Domain
This domain is for use in documentation examples without needing permission. Avoid use in operations.
Learn more

In this verbose view, we can see detailed request-response cycle including DNS resolution, TLS handshake, headers exchange and html body delivery. It shows every step that can not be viewed in browser.

Using cURL to talk to APIs

cURL can talk to APIs with http request, with various methods such as GET and POST.

We shall utilise public API for demonstration.

GET method (reading or fetching data)

~ $ curl "https://api.freeapi.app/api/v1/public/randomjokes?limit=10&query=science&inc=categories%252Cid%252Ccontent&page=1"

{"statusCode":200,"data":{"page":1,"limit":10,"totalPages":1,"previousPage":false,"nextPage":false,"totalItems":4,"currentPageItems":4,"data":[{"categories":["science"],"id":140,"content":"Science Fact: Roundhouse kicks are comprised primarily of an element called Chucktanium."},{"categories":[],"id":456,"content":"All science students maybe aware about the fact that picochuck is the unit of manliness in the International System of Units (SI). An average man measures about 0.00073 pc. Chuck Norris measures 39,372 petachucks."},{"categories":[],"id":1073,"content":"The 7 wonders of the world were actually Chuck Norris' science fair projects. And Chuck Norris is the 8th wonder of the world."},{"categories":[],"id":1269,"content":"Larry the Cable Guy was a nuclear science physics professor at MIT for only 3 seconds more after he called Chuck Norris' mother a \"slutty beatch of a crack whore\"."}]},"message":"Random jokes fetched successfully","success":true}%

POST method (for sending data to server)

~ $ curl -d "hi" https://httpbin.org/post
{
  "args": {}, 
  "data": "", 
  "files": {}, 
  "form": {
    "hi": ""
  }, 
  "headers": {
    "Accept": "*/*", 
    "Content-Length": "2", 
    "Content-Type": "application/x-www-form-urlencoded", 
    "Host": "httpbin.org", 
    "User-Agent": "curl/8.7.1", 
    "X-Amzn-Trace-Id": "Root=1-6972bf37-19e5eaee0489d67632d84838"
  }, 
  "json": null, 
  "origin": "152.58.61.145", 
  "url": "https://httpbin.org/post"
}
This send "hi" as form data to `https://httpbin.org/post` and that form data is sent back by server as json.

Common mistakes beginners make with cURL

Using URLs that contains '?' and '&' without quotes
Forgetting HTTPS/443: curl http://example.com:443 fails. Fix: Use https:// prefix.
verbose debugging : add -v argument for verbose debugging if see TLS or DNS issues

Understanding How DNS Resolution Works

ARMAN PATEL — Wed, 21 Jan 2026 01:09:02 GMT

What is DNS

Let's start with full name of DNS. Domain Name System. It is a system which translate human readable Domain Names to Machine readable IP address.

Why need Domain Names

We need Domain Name of server in order to connect with it, in human readable format. For example google.com. One can simply understand that we want to connect with Google. One can also typein IP address of Google directly, but it is not human friendly and Google might change IP, which is troublesome. ### Why Domain Name Resolution Domain Name Resolution is a system that bridges between human-friendly Domain Names and machine-friendly IP addresses. It maps Domain Names to IP addresses. DNS is just like phonebook of internet.

DNS is centralised? Why ?

DNS is a system that is not centralised. Because one centralised system can't resolve all IPs on the internet, and it can't be scalable. DNS is De-centalised. Domain Name Resolution is iterative process.

How DNS works

We will see how DNS works. For this we shall use a command-line utility named dig (Domain Information Grapper). It is used to query DNS servers and inspect DNS records. Open a terminal of your choice and typein dig google.com. DNS is hierarchyal. Typically DNS resolution flows through three logical layers:

Root name servers :
- Root servers do not know IP of queried Domain Name (google.com), but they give IP of TLD servers, such as .com TLD server. This starting of recursion.
- There are 13 root servers. There are more than 1900 implementations of root servers.
- One can query root servers by running dig . NS in terminal.
TDL (Top Level Domain) name server : They are referred by root server.
- TLD servers maintain delegation of all TLD records r that particular TLD. Such as .com records are maintained by .com TLD servers. TLD server prrovide IP of Authoratative name server.
- dig com NS or dig in NS are the commands for querying TLD servers.
Authoratative name server :
- Authoratative name server holds DNS records such as A/AAA, proving final IP address.
- dig google.com NS returns IP of Authoratative Name Server. After all this recursion, requesting host gets resolved IP of desired server. Then TCP and TLS connection happens and then https request happens. All this recursive process happens only if resolved IP is not cached in requesting host.

Types of DNS Records

After this complete recursive DNS resolution, when one gets IP of Authoratative Name server, that Authoratative Name server holds DNS records. These DNS records tell which server t connect to or which who receives email for this server.

A record :
- A record simply maps domain or subdomain (example.com) to IPv4 address (like 172.23.46.107).Meaning if someone visits example.com, then they should connect to 172.23.46.107.
- Domain or subdomain can have multiple A records. For Load balancing and Fail over server.
AAAA Record :
- AAAA record is just like A record but for IPv6 addresses.
- AAAA record maps domain or subdomain to IPv6 address (such as 2001:db8::1).
- Domain or subdomain can have both A and AAAA record. Clients supported by IPv6 address shall prefer AAAA record, while others use A record.
CNAME Record :
- CNAME records points to another Name, which hold A/AAAA record.
- for example blog.xyz.in has CNAME record hashnode.network. This is just CNAME record. But actual IPv4 address is resolved on hashnode.network (which is holding A/AAAA record poining to IP of blog).
- CNAMEs simplify hosting with SaaS, as one can point own domain or subdomain to them and they handles IPs behind it.
MX Record :
- MX is for Mail Exchange.
- MX record holds hostname (such as mail.example.com) to which mail is to be delivered.
- MX record does not point to IP address, but points to hostname. That hostname must have its own A/AAAA records.
TXT record :
- TXT record stores free form text data associated with domain, for machines rather than humans.
- Common uses include SPF, DKIM, and DMARC email-authentication data, and ownership verification for services like Google Workspace or Microsoft 365.
NS Record :
- NS record points which Name Servers to use for your DNS Hosting.
- Usually your Domain Registry holds DNS records, but for reason you want another DNS hosting service, then you can add NS record (in your Domain Registry) pointing to Name Server of another DNS Hosting provider.

Git internals and Basic Commands

ARMAN PATEL — Sat, 17 Jan 2026 17:08:46 GMT

In this article we are going to take a look how git works internally. We shall learn some basic git commands on the go.

We shall start with empty project. In my case, have created a folder named "git-internals-learn-2", and opened that folder/project in VS Code. Keep the VS Code's integrated terminal open. There is no file or folder in the project now, one can check that by running following command in terminal.

ls -a

Output : 
git-internals-learn-2 $ ls -a
.  ..

Now let's initialise git. Meaning that as and when we create files and folders, it will be tracked by git in terms of version control & colloboration. In order to initialise git, run following command :

git init

Output :
git-internals-learn-2 $ git init
Initialized empty Git repository in xyz/git-internals-learn-2/.git/

This command has created a hidden folder named .git inside the project. One can check with following command :

ls -a

Output : 
git-internals-learn-2 $ ls -a
.    ..   .git

And initial folder structure inside .git folder is as under (can be checked via VS Code Explorer) :

.git/
├── HEAD
├── config
├── description
├── hooks/
│   ├── applypatch-msg.sample
│   ├── commit-msg.sample
│   ├── fsmonitor-watchman.sample
│   ├── post-update.sample
│   ├── pre-applypatch.sample
│   ├── pre-commit.sample
│   ├── pre-merge-commit.sample
│   ├── pre-push.sample
│   ├── pre-rebase.sample
│   ├── pre-receive.sample
│   ├── prepare-commit-msg.sample
│   └── update.sample
├── info/
│   └── exclude
├── objects/
│   ├── info/
│   └── pack/
└── refs/
    ├── heads/
    └── tags/

We have not learned anything yet but have a look at following Key Points, we shall revisit them as and when we learn and things will become clearer :

HEAD : In this file, it says "ref: refs/heads/main" which points to "refs/heads/main" . But right now "ref/head" is empty, there will be "main" when we shall add something in git.
config file contains some standard configuration.
description file's content says "Unnamed repository; edit this file 'description' to name the repository."
Sample hooks only: hooks/ contains only *.sample files; they are templates that become active if renamed (e.g., pre-commit). We shall keep any eye on them.
info/exclude file is local ignore file, in which we can add things which we don't want git to track and ignore (mostly files and folders which can be regenerated easily and does not make sense to track them).
No objects yet: objects/ is empty except for the info/ and pack/ directories because there are no commits or blobs until the first git add + git commit. We shall learn about these terms.
refs/heads and refs/tags exist but are empty until the first commit creates a branch reference (like refs/heads/main).

We have taken a look at directory structure and what files are there when we initialise a project. We have introduced terms like "add", "commit", "head", "main", "hooks", "objects", "blob", etc. These terms are not of same category and not of any order, but we have introduced while exploring .git folder.

Now lets create a file is our project folder. Either with VS Code Explorer or with following command in terminal :

cat > file1.txt << 'EOF'
This is first file1 creation. One can say it a "Title Line".
EOF

file1.txt is created with content we provided. Notice for any change in any file in .git folder. Right now even after file1.txt creation, there is not change in .git folder. This is because we have not yet asked git to track anything. By "tracking", I mean track file/folder for version controlling and colloboration, which are the things we want to use git for in the first place (we had discussed in a dedecated previous article). But how to ask git to track files. But first, let's check the status of the project by running following command :

git status

Output : 
git-internals-learn-2 $ git status
On branch main

No commits yet

Untracked files:
  (use "git add ..." to include in what will be committed)
        file1.txt

The output shows that our project is on main branch, there are no commits (we shall learn about it later) yet, and there is one file file1.txt is untracked, as we have discussed.

This is where our first git command comes into action. The command is git init . This shall tell git to track that particular file from now onwards, this is called moving the file into Staging Area. Let's put our file1.txt into a staging area and look for any changes in .git folder. Run following command :

git add file1.txt

The file1.txt is added into Staging Area. Check git status :

git status
Output : 
git-internals-learn-2 $ git status
On branch main

No commits yet

Changes to be committed:
  (use "git rm --cached ..." to unstage)
        new file:   file1.txt

And there are two changes is .git folder :

.git/index file is created.
git/objects/60/d0624e907d248246dd0a1824fd4dc9d3971629 is created.

Why Version Control Exists: The Pendrive Problem

ARMAN PATEL — Tue, 13 Jan 2026 00:46:26 GMT

Today I am going to write down about Version Control System. Why it exists, what is its importance and what problem it does solve.

Tracking Changes

We are going to discuss in term of software developement. Let’s say, we are writing a software of any kind. Typical folder with bunch of subfolders and files structured according to the project.

Any software is not build in one go. It is developed over many iterations over time. And there may be many contributors in the development of software.

Initially when the software is of not that big scale, it is ok (and easier) to remember changes made into code (or any format/file), and it is not even important to track changes (when it is not of big scale). But as and when complexities arise when project scales, it is really important to track changes.

Tracking Who Contributed

If there is no version control / collaborator System, when one (Let's say Person A) had to share project with colleage or friend (Let's say person B), he/she would have to copy entire project folder and send it over some media sharing device such as pendrive (or zip folder and send it over internet).

Then his/her friend/colleague would make changes in the project and send the entire project back over by any means (same pendrive). But now person A does not know what person B changed in the project, unless told personally/telephonically/emailly, but it is cumbersome everytime.

Moreover, untill project is got back from person B to person A, person A would not be able to do any changes in his copy of project because he will be out of sync.

Versioning before GIT

Imagine our scenario, after so many back and fourth, what would be space look like where project folder is saved. It would have proct folder name like project, project_version_1, project_version_2, project_final, project_final_version_2, etc.

This is unreadable, clumsy and hard to remember. And most important, it is not scalable.

This scenario we discussed only involved two persons. Image more people are in the development. What will be the problems.

Same code (or anything) edited by more than one persons would be hard to hande. There is no collaborative history is maintained. Losing code would be common problem.

Solution

In order to overcome all the problems and challenges, GIT was invented by legendary Linus Torvalds, the creator of Linux. This made software development more scalable, collaborative and tracking changes / contribution easier.

Plus, we have not discussed but branching of software development journey is also well handled by GIT. And merging also.

Future Article

We shall look into how internally GIT works and some basic commands and workflows of GIT.