In real life, data rarely exists only in a primitive data type as a single value. It is manged with different types of data structures. An array is one of the most common data structure used in any programming language.

An array is an ordered collection of values (mostly of same data type but variable in JavaScript) stored in a single variable. Each value is stored at a specific position called an index.

In JavaScript ecosystem, Array is heavily used not only to store data but also to develop UI with libraries like React.

Some of the common use cases of array are:

• Sharing data as API response

• Managing and developing UI in libraries like React

• Database records in backend systems

• Handling collections of objects

Let's understand it and it's methods by using a real life example of a college library system. A college library system, for example, does not manage just one book. It manages thousands of books, each with details such as title, author, number of copies, and availability.

A example of such can look like following:

(Here we are storing array of objects. Each object contains data related to a book)

const libraryBooks = [
  { id: 1, title: "Introduction to Algorithms", author: "Thomas Cormen", copies: 4, issued: 2 },
  { id: 2, title: "Clean Code", author: "Robert Martin", copies: 3, issued: 1 },
  { id: 3, title: "JavaScript: The Good Parts", author: "Douglas Crockford", copies: 2, issued: 2 }
]

Array Operations In JavaScript

Let's consider a

Array operations can be categorized in following:

• Insertion (push, unshift)

• Deletion (pop, shift)

• Transformation (map, filter)

• Validations (forEach)

• Generating new data (reduce)

Let's dive into each each one of them:

Insertion Methods (Push, unshift)

NOTE: Both of the methods will modify the original array

Insertion methods add new elements to an array. In a library system, this might represent adding new books to the database.

For reference, considering an array of strings, containing name of books can look like following:

const books = [
  "Clean Code",
  "JavaScript: The Good Parts"
]

Push()

push() adds a new element to the end of an array. Imagine the library receives a new book.

Adding a new book to the catalog:

books.push("Design Patterns");

New array will now look like:

[
  "Clean Code",
  "JavaScript: The Good Parts",
  "Design Patterns"
]

unshift()

unshift() adds a new element at the beginning of an array. Suppose the librarian wants to prioritize newly donated books at the start of the list.

Adding a new book in first position of books array:

books.unshift("Introduction to Algorithms")

New array will now look like:

[
  "Introduction to Algorithms",
  "Clean Code",
  "JavaScript: The Good Parts",
  "Design Patterns"
]

Deletion Methods (pop, shift)

NOTE: Both of the methods will modify the original array

pop

pop() removes the last element from an array.

For reference, considering an array of strings, containing name of books can look like following:

const books = [
  "Introduction to Algorithms",
  "Clean Code",
  "Design Patterns"
]

Removing last book from the books array:

books.pop()

Now, the books array will look like:

[
  "Introduction to Algorithms",
  "Clean Code"
]

shfit

shift() removes the first element from an array.

Suppose the library removes an outdated book from the start of the catalog.

Removing first book from the books array:

books.shift()

The books array will now look like:

[
  "JavaScript: The Good Parts"
]

Transformation Methods

DNS stands for Domain Name System. Without this, we can’t access anything in internet. Let’s understand what it really does and concepts related to this technology.

Often times, we don’t remember contact number of people. When we want to calls someone, we would search their name in our contact list then we will call them. Here, by utilizing contact list of multiple people with their name and number, we are solving the complexity of having to remember number of people which is hard for us as compared to remembering their name.

Just like a phone number belongs to only one person and the phone number becomes point of contact to the person, websites also have an unique IP address through which we can access them through the internet. IP address is the point of contact for us to access the websites. But you may wonder that you never see IP address when you enter a website name.

Just like how a contact list in our phone has ability to get number of person by searching their name, DNS helps us find the IP address of the website using domain names.

Unlike a contact list sitting on our phone, DNS is a global service which is responsible for finding IP address of all the websites. This process look up process is called name resolution.

Now that we know what is DNS is and what is does, let’s try to understand how we can practically inspect how it really works.

DNS Resolution Layers

While DNS in simpler terms may seem like a simple give and take like process for domain name and IP address lookup, it is actually more complex and layered process. Each process doing a specific task, a DNS call takes multiple trips before finishing up the look up process.

The flow always follow the following pattern: Root → TLD → Authoritative Servers → Resolution

Let’s understand the steps one by one

Root layer

This is the first layer of the DNS query. It doesn’t have any data related to the domain and it’s respective IP address. Instead, it will have data TLD (Top level domains: .com, .org, .cloud, .ai) managers.

There are only 13 logical root server clusters spanning from a to m logical addresses. The DNS providers fork the logical root server cluster and create their own root serer resolver. Once the root layer will figure out who is managing the TLD of the requested domain, the flow moves to TLD Layer.

TLD Layer

The TLD layer also doesn’t hold any data about the domain and it’s IP address. Instead, it holds data about which authoritative servers manage each domain under the TLD. Once the authoritative server of the TLD is figured out, flow is then moved to authoritative servers.

Authoritative Servers

Once TLD layer figures out the respective authoritative server for the domain of the TLD, flow moves to the authoritative server which holds the source of truth about record of the domain. The authoritative server will then find out the A record of the domain which holds the IPV4 of the domain.

The authoritative server is where the DNS lookup will be resolved. It will get the A record of the domain which is nothing but IPV4 address of the server which is being pointed by a domain.

Inspecting DNS resolution with dig

dig is a diagnostic tool to inspect DNS resolution. It is a command line utility tool which can be used to send raw DNS query to a DNS server and get the response back. It is often used to check and validate any updates related to DNS records. It is available out of the box on Linux systems.

Understanding Usage Of Different dig Commands

Now that we know why dig is used, let’s try to understand different ways we can utilize it and understand it’s use cases. It comes with various usages. Based on different type of usages, we can utilize it in various ways.

Let’s explore different commands utilizing the dig command considering the same flow of DNS resolution we discussed above. Which is, Root → TLD → Authoritative servers → result

We will be referencing to google.com for the reference of domain name for all the examples.

Understanding Root of DNS with dig . NS

command:

dig . NS google.com

This command queries for root name servers of the root of DNS which are entry point for all the DNS resolution/lookup processes also referenced as Root. Root only holds data about the server which manages the TLD (Top Level Domain). The . in the command represents the DNS root zone.

example: Querying for root name servers for google.com

Notice how there are exactly 13 name servers listed, those are the universal logical group of root name servers.

➜  ~ dig . NS google.com 

; <<>> DiG 9.18.39-0ubuntu0.22.04.2-Ubuntu <<>> . NS google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 6445
;; flags: qr rd ra; QUERY: 1, ANSWER: 13, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;.                IN    NS

;; ANSWER SECTION:
.            7180    IN    NS    k.root-servers.net.
.            7180    IN    NS    c.root-servers.net.
.            7180    IN    NS    d.root-servers.net.
.            7180    IN    NS    e.root-servers.net.
.            7180    IN    NS    i.root-servers.net.
.            7180    IN    NS    m.root-servers.net.
.            7180    IN    NS    j.root-servers.net.
.            7180    IN    NS    a.root-servers.net.
.            7180    IN    NS    l.root-servers.net.
.            7180    IN    NS    f.root-servers.net.
.            7180    IN    NS    b.root-servers.net.
.            7180    IN    NS    h.root-servers.net.
.            7180    IN    NS    g.root-servers.net.

;; Query time: 0 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Jan 27 22:24:11 IST 2026
;; MSG SIZE  rcvd: 239

;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 63183
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;google.com.            IN    A

;; ANSWER SECTION:
google.com.        203    IN    A    142.250.205.110

;; Query time: 0 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Jan 27 22:24:11 IST 2026
;; MSG SIZE  rcvd: 55

Understanding TLD name servers dig com NS

command:

dig com NS google.com

This command queries for name servers responsible to resolve for the TLD of the requested domain. Since we are querying for google.com, it will list out the authoritative name servers which are responsible for resolving .com TLD. These name servers don’t hold any data records related to the TLD. It only knows only which authoritative manages each .com domain.

example: Querying for NS (name servers) records for google.com

Notice how there name servers listed for .com unlike . which was received from the root DNS query

➜  ~ dig com NS google.com 

; <<>> DiG 9.18.39-0ubuntu0.22.04.2-Ubuntu <<>> com NS google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 6740
;; flags: qr rd ra; QUERY: 1, ANSWER: 13, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;com.                IN    NS

;; ANSWER SECTION:
com.            21599    IN    NS    i.gtld-servers.net.
com.            21599    IN    NS    b.gtld-servers.net.
com.            21599    IN    NS    f.gtld-servers.net.
com.            21599    IN    NS    h.gtld-servers.net.
com.            21599    IN    NS    j.gtld-servers.net.
com.            21599    IN    NS    g.gtld-servers.net.
com.            21599    IN    NS    e.gtld-servers.net.
com.            21599    IN    NS    c.gtld-servers.net.
com.            21599    IN    NS    l.gtld-servers.net.
com.            21599    IN    NS    a.gtld-servers.net.
com.            21599    IN    NS    m.gtld-servers.net.
com.            21599    IN    NS    k.gtld-servers.net.
com.            21599    IN    NS    d.gtld-servers.net.

;; Query time: 52 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Jan 27 22:40:47 IST 2026
;; MSG SIZE  rcvd: 256

;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 60663
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;google.com.            IN    A

;; ANSWER SECTION:
google.com.        210    IN    A    142.250.205.110

;; Query time: 9 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Jan 27 22:40:47 IST 2026
;; MSG SIZE  rcvd: 55

Understanding Authoritative Name Servers With dig <domain> NS

command:

dig google.com NS

This command queries for authoritative server which resolves NS records for google.com. These servers are operated by google. Theser severs are the source of truth for google.com. It identifies where different type of DNS records lives but it doesn’t return the IP address of the site.

example: Querying for authoritative name servers records for google.com

Notice how instead of top level domain, it now includes the domain address and respective name server which holds different records to resolve the domain

; <<>> DiG 9.18.39-0ubuntu0.22.04.2-Ubuntu <<>> google.com NS
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 201
;; flags: qr rd ra; QUERY: 1, ANSWER: 4, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;google.com.            IN    NS

;; ANSWER SECTION:
google.com.        9394    IN    NS    ns1.google.com.
google.com.        9394    IN    NS    ns2.google.com.
google.com.        9394    IN    NS    ns3.google.com.
google.com.        9394    IN    NS    ns4.google.com.

;; Query time: 16 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Jan 27 22:59:16 IST 2026
;; MSG SIZE  rcvd: 111

Understanding Full DNS Resolution Flow With dig <domain>

command:

dig google.com

This command will perform full DNS resolution and gets back A record (IPV4) of the domain. It will perform all the recursive resolution and returns back the A record of the domain from the respective authoritative servers. In our case, it query for IPV4 of google.com from google authoritative servers.

example: full DNS resolution flow of google.com

Notice how we got an A record (IPV4) of google.com, that’s the result part of the DNS resolve cycle.

➜  ~ dig google.com 

; <<>> DiG 9.18.39-0ubuntu0.22.04.2-Ubuntu <<>> google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 42676
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;google.com.            IN    A

;; ANSWER SECTION:
google.com.        96    IN    A    142.251.223.14

;; Query time: 10 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Tue Jan 27 23:01:53 IST 2026
;; MSG SIZE  rcvd: 55

Conclusion: Order Of dig commands:

Each command reveals one layer:

1. dig . NS → Root server

2. dig com NS → TLD NS

3. dig google.com NS → Authoritative NS

4. dig google.com → End result after all layers

NS And It’s Importance

NS stands for Name Server. It is one of the critical part of DNS resolution. It holds information about the sever which is responsible for the domain. Which means, A NS record does not store IP addresses of websites. It stores names of DNS servers that are responsible to answer for a domain.

DNS is not a database. It is rather a reference system to find who has authority to store what information of the domain. It defines boundary and authority of:

1. Who is allowed to make requests to domain

2. Who’s responsibility spans from where to where

3. Who holds the reference of next reference.

Example: NS for google servers looks like following:

google.com  NS  ns1.google.com
google.com  NS  ns2.google.com

NS records drive this process:

1. Root NS records: Say who manages TLD( .com, .org, etc).

2. TLD NS records: Say who manages domains (google.com, amazon.com, etc.)

3. Domain NS records: Say which servers are authoritative for that domain

More content coming…

Let's learn about TCP and UDP which as a programmer all of us has heard once in a while but may not have studied it beyond textbook.

Internet Protocols

Before we jump into TCP and UDP, we need to first understand what are Internet protocol and it's importance. Protocols are nothing but set of rules one has to follow. Internet protocols are the set of rules for accessing and working with Internet. Imagine millions of devices communicating at the same time without any context on how and when to send or receive data. Messages would overlap, disappear, or arrive half-broken.

When you type a website name in a browser, the browser does not know where that site lives. Humans use domain names like google.com and computers use server IP addresses to locate the respective servers and all the operations like accessing the domain and serving back to us. The process of resolving domain name with IP address is done with DNS. DNS is the phonebook of the internet.

DNS is responsible for figuring out IP address of the server where the domain is pointing to.

DNS records store information about a domain. Each record has a specific job like pointing a website to a server or telling email where to move the traffic towards or where to go to find the IP address of that domain. It is one of the most important part of internet. Without DNS, we would have very hard time to navigate through websites this easily.

DNS In Real Life?

Let’s understand the separation of concerns about each layer by following real life example considering I’m sending a parcel to my friend from Bangalore to Delhi. (Each step in the process below is concerned and knows about the next stage and nothing beyond that and that is how DNS works too)

1. I’ll go to local courier office nearby from my home with address delivery indicated in the package.

2. The courier office will send the package to the cargo hub of my city which will to send the package to cargo hub in Delhi. The cargo operator doesn’t know where my package will be delivered to precisely. He only knows that he has to deliver it to cargo hub in Delhi.

3. Once the package is received in cargo hub in Delhi, it will be then forwarded to the respective courier office of the specific region where it is supposed to be delivered to. The hub only concerns about in which region of the Delhi it has to be sent and in which branch my package should be sent to for delivery.

4. Once the package is received in the responsible courier office branch, a delivery agent will then check which part of the area (based on pin code mostly) is my package is supposed to be delivered to and contact my friend that he is coming to deliver it and ask for his actual precise location.

5. Once delivery agent gets precise location, he will then deliver the package to my friends place.

If you want to know more about how dns works, check out my in-depth article on it here.

What Are NS Records ?

NS stands for ‘nameserver’ and the nameserver record indicates which DNS server is authoritative for that domain (server containing the actual DNS records for that domain).

These authoritative servers have the final answers about that domain name resolution. The final answer includes different DNS records like A record, AAAA record, MX record and so on…

If you want to know more about DNS records, check this article from cloudflare

Common DNS Records

Following is the list of the most commonly used record types

Comparing Common DNS Records

Let’s cover a bit more of some of the common DNS records which are slightly confusing and may appear as similar to someone who doesn’t have much hands on with the DNS.

A Record vs CNAME

A record is always the final source of truth of DNS lookup. It holds the IPV4 of the server from where the domain is being served where as CNAME record is like a another name we have given to the actual domain name. It will always comes and resolve back as the actual domain name.

CNAME record does not have to be in the same DNS zone as the domain it points to. It is a global pointer that can link an alias to any valid domain name on the internet.

For example: If I’ve hosted a pet project on netlify, it will give me a hosted domain in format of <somename>.netflity.app I can instead add a CNAME record and use somename.pank.cloud to point it from my own subdomain.

NS vs MX

MX records tell email where to go. It tell email servers where to deliver emails for a domain. They point to mail servers, not website servers. example: writing a special delivery office on a letter instead of a house address. On the other side, NS records say who controls the domain.

MX records say where emails should be delivered while NS controls the domain. MX controls email and receives. NS answers questions about authoritative servers.