DEV Community: levi

How DNS works? : The Indian Post office analogy

levi — Wed, 20 Aug 2025 18:07:13 +0000

Have you ever wondered how your browser knows where to find www.dev.to?
Its all thanks to DNS (Domain Name System) — the phonebook or postal system of the internet.
Let me break it down using something we all understand in India — the PIN code system.

Imagine you want to send a letter to "www.dev.to"
But you don’t know the exact house (IP address), only the name.
Here's how the process unfolds:

Root DNS Server = Central Postal Director This is like India’s central postal directory. It doesn’t know where dev.to lives, but it knows:

"For .to domains, talk to the .to postal hub."

Just like the central system knows:
"For PINs starting with 1, go to Delhi. For 5, go to Hyderabad."
but dyk, there are onnly 13 such root servers.

TLD Server = Regional Postal Hub (like .to Office)
The .to server is like the regional hub for .to addresses.
It says:
"I know who handles dev.to. Go talk to that local post office (authoritative server)."
Authoritative DNS Server = Local Post Office
Now you're at the final post office — they know the exact house address:
And this is where like of AWS route 53 comes in picture, responds to DNS queries for your domain, telling users where to find your website or app.

"www.dev.to lives at 192.0.2.1".

That’s the IP your browser needs to load the site.

Day-7: InstanceOf and access modifiers: JAVA

levi — Tue, 12 Aug 2025 16:25:59 +0000

🔍 What is `instanceof`?

The instanceof operator checks whether an object is an instance of a specific class, subclass, or interface. It returns a boolean result.

📘 Summary of Key Concepts

Type Check: Checks if an object is of a given type.
Returns Boolean: Returns true if the object is of the specified type or a subtype.
Interfaces: Works with interfaces and superinterfaces.
Object Type Matters: Evaluates based on the actual object, not the declared variable type.
Superclass Match: Returns true if object is an instance of a superclass in the hierarchy.
Null Always False: instanceof always returns false when the object is null.
Compile-Time Safety: If the compiler knows the check is impossible (e.g., String instanceof Integer), it gives a compile error.
Safe Downcasting: Often used to check type before downcasting to avoid ClassCastException.
Pattern Matching: Allows type check and casting in one step: if (obj instanceof String s) { System.out.println(s.toUpperCase()); } 10.Short-Circuit Logic: Pattern variable can be used in same condition safely:

if (obj instanceof String s && s.length() > 5) {
    System.out.println(s);
}

TRICKY QUESTION

whats null instanceof null? Compile time error.instanceof requires the right-hand side to be a class or interface type.:
Can we check enum instanceof?

enum Color { RED, GREEN }
Color c = Color.RED;
System.out.println(c instanceof Color);

Yes,enums are classes and extend java.lang.Enum, so instanceof works with them.

whats int instanceof Integer? Compile-time error,instanceof cannot be used with primitives.

ACCESS MODIFIER:

Java provide 4 types of access modifiers, class/field/method defined as:

private: can only be accessed within same class not even in the subclasses. denoted by **private **keyword.
package-private: denoted by no keyword. this give visibility of entity through out same package.
protected : similar to package-private but its subclasses can also access protected entities. use **protected **keyword
public: can be accessed everywhere. use **public **keyword.

Day 6- Switch Smarter in Java 21

levi — Mon, 11 Aug 2025 17:27:27 +0000

Day 6: Learnt About Modern switch in Java 21

Goodbye Break, Hello ->

Modern switch in Java 21 allows using arrow syntax (->), so you can skip the break keyword and avoid accidental fall-throughs.

Without arrow syntax, you can use the yield keyword to return a value from a switch expression.

To group multiple case values, use a comma-separated list: case 1,2 ->
When using a sealed hierarchy, the compiler checks for exhaustiveness at compile time:

sealed interface Shape permits Circle, Square {}
final class Circle implements Shape {}
final class Square implements Shape {}

String result = switch (shape) {
    case Circle c -> "Circle!";
    case Square s -> "Square!";
};

it also supports null case unlike classic java.
case null->"no"
It supports pattern matching and guards (when), allowing type checks and additional conditions directly in switch:

Object obj = 10;

String result = switch (obj) {
    case Integer i when i > 5 -> "Large number";
    case Integer i -> "Small number";
    default -> "Other";
};

JUST STATIC it: Understanding static in Java

levi — Thu, 07 Aug 2025 17:45:55 +0000

DAY 5. I am trying to strength by Core java basic its one of the concepts I struggle to understand. here is everthing I learnt today about static keyword in java

Java Summary: Static, Class Loading & Execution Flow

1. `static` Keyword in Java

Definition:

The static keyword means the member belongs to the class itself, not to instances.

class CarFactory {
    // Static variable shared by all cars made by any factory
    static int totalCarsProduced = 0;

    // Static block: runs once when the class is loaded
    static {
        System.out.println("CarFactory class loaded. Initializing factory...");
    }

    // Instance variable (per car)
    String model;

    // Constructor increments total cars produced
    CarFactory(String model) {
        this.model = model;
        totalCarsProduced++;
    }

    // Static method: calculates price without needing an object
    static int calculatePrice(String model, int basePrice) {
        if ("Luxury".equalsIgnoreCase(model)) {
            return basePrice + 7000;
        } else {
            return basePrice;
        }
    }

    // Static nested class representing a part of the car
    static class Engine {
        void start() {
            System.out.println("Engine started.");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // Class loaded, static block runs first

        // Create cars (instances)
        CarFactory car1 = new CarFactory("Standard");
        CarFactory car2 = new CarFactory("Luxury");

        // Access static variable shared by all cars
        System.out.println("Total cars produced: " + CarFactory.totalCarsProduced); // 2

        // Call static method without creating an object
        int price = CarFactory.calculatePrice("Luxury", 25000);
        System.out.println("Price of Luxury car: $" + price);  // 32000

        // Create and use static nested class (no CarFactory instance needed)
        CarFactory.Engine engine = new CarFactory.Engine();
        engine.start();
    }
}

Where `static` Can Be Used:

Static variable → Shared among all instances (1 copy in memory)
Static method → Can be called without object creation; can't access instance members directly
Static block → Runs once when class is loaded; used to initialize static fields. they cant return anything.
Static nested class → Class inside another class; does NOT need outer class object

Static Nested Class vs Inner Class

Static Nested Class	Inner (Non-Static) Class
Access only static members of outer class	Can access all members of outer class
Does NOT require outer class instance	Requires outer class instance
Can be instantiated independently	Must be tied to an outer class object

Key Rules:

Static methods can't access instance fields or methods directly.
Static methods can't be abstract.
Static methods can't be overridden (they're hidden instead).
Static blocks and variables execute in order of appearance.

2. Class Loading & Initialization

What Is Class Loading?

Class loading is the process of bringing .class files into memory using a ClassLoader.

Class Loaders:

Bootstrap ClassLoader – loads core Java classes (e.g., java.lang)
Extension ClassLoader – loads JDK extensions
Application ClassLoader – loads user-defined classes

What Gets Loaded:

Class structure (fields, methods, hierarchy)
Constant pool
Static fields (with default values first)
Method bytecode
Static blocks

Phases of Class Loading:

Phase	Description
Loading	Reads `.class` file into memory
Linking	Verifies bytecode, allocates memory for statics
Initialization	Assigns actual static values, runs static blocks

3. JVM Memory Areas

Memory Area	What it Stores
Method Area	Class metadata, static variables, constant pool
Heap	Objects and instance variables
Stack	Method calls and local variables (per thread)
PC Register	Instruction pointer per thread
Native Method Stack	Native (non-Java) method calls

4. Java Program Execution Flow

Steps When Running a Program

Class is loaded
Static variables are initialized
Static blocks execute (in order)
main() method is called
If object is created:
- Instance variables init
- Instance block runs
Constructor runs

5. Final vs Static

we will cover final in depth another article.
any member declared as:

Feature	`static`	`final`
Belongs to	Class	Class or instance
Overriding	Static methods cannot be overridden (hidden)	Final methods cannot be overridden
Inheritance	N/A (related to members)	Final class cannot be extended
Usage	Share common data, utility methods, nested classes	Prevent modification of method/class inheritance

6. Where You Cannot Use static in Java?

Usage	Can you use `static` here?	Reason
Local variables inside methods	❌ No	Java does not allow `static` local variables
Constructors	❌ No	Constructors are always instance-level
Abstract methods	❌ No	`static` and `abstract` are contradictory
Interfaces (before Java 8)	❌ No	But Java 8+ allows static methods inside interfaces

Bulletproof Your APIs with Contract Testing

levi — Sun, 15 Jun 2025 18:48:57 +0000

🔍 Real-World Wake-Up Call
Once upon a time at work 😜, I was working on a project that heavily relied on multiple upstream services owned by different teams to process order data. One seemingly ordinary day, one of those services made a change to their API — they updated the productDescription field from a String to a List.

Our service, still expecting a String, started throwing 400 Bad Request errors out of nowhere. This seemingly small change caused unexpected failures and impacted our downstream processing.

This incident made it painfully clear: we needed a better way to catch breaking changes in API contracts early, before they hit production. That’s when we started exploring Contract Testing as a solution. Among the tools we considered were Spring Cloud Contract and Pact.
Here url for POC we created: https://github.com/levi-a07/contract-testing

Spring Cloud Contract is a testing framework that helps ensure reliable communication between microservices by using contract testing
A contract is a written agreement (in code) that defines:

What the producer (API provider) promises to return, based on what the consumer (API client) sends.

Spring Cloud Contract allows you to:

Write these contracts (in Groovy/YAML),
Automatically generate tests for the producer,
Automatically generate mock stubs for the consumer.

Sample looks like:

description: Should return order by id
request:
  method: GET
  url: /orders/1
response:
  status: 200
  headers:
    Content-Type: application/json
  body:
    orderId: "1"
    productId: "product-1234"
    quantity: 2
    price: 29.99
  matchers:
    body:
      - path: $.orderId
        type: by_regex
        value: "\\d+"   # Matches any numeric orderId
      - path: $.productId
        type: by_regex
        value: "product-\\d+"  # Matches a product ID like product-123
      - path: $.quantity
        type: by_type
        value: number       # Matches any numeric quantity
      - path: $.price
        type: by_type
        value: number       # Matches any numeric price

Types of Contract Testing

There are 3 type of contracts:
1. Consumer-Driven Contracts (CDC)
The contract is usually written from the consumer’s point of view, describing what it expects from the producer. The consumer service then uses a stub — an auto-generated mock server based on the contract — to simulate the producer’s behavior during testing.

This stub reflects the contract exactly, not the actual producer code. The consumer team can share the contract via a pull request to the producer repo or through a shared location. If the producer later changes the contract, the stub updates accordingly, and any mismatch will cause the consumer's test to fail, alerting the team to the breaking change early.

Based on the contract, Automatic Junit tests are created on Producer side.
The generated tests simulate requests described in the contract and verify that the producer's real implementation returns the expected response. This way we catch breaking changes early.

*Best for *

Systems with multiple consumers and independent teams.
Ensuring backward compatibility.

Tool

Spring cloud contract
Pact

2. Producer-Driven Contracts **
The producer defines the contract — the API specification — and shares it with consumers.
**How it works:
Producer publishes the OpenAPI/Swagger schema or a written contract.
Consumers build against this contract.

Best for

Where contracts are mostly controlled by producer service.

Tools
OpenAPI/Swagger

3. Bidirectional Contracts

A combination of consumer and producer contracts — both sides define expectations, and they are reconciled in a central place.

Best for:

Where contracts evolve from both sides.

Tools
PactFlow

Conclusion:
In a microservices architecture, communication contracts between services are critical — yet easy to break. By automating contract validation, generating stubs, and catching breaking changes early in the pipeline, contract testing boosts confidence, improves collaboration across teams, and helps deliver more reliable systems.
In the market we have different tools to use contracts based on your use case.

The Geometry Behind QR Codes: Exploring Matrix Rotation

levi — Fri, 06 Jun 2025 15:03:34 +0000

While practicing algorithm problems on LeetCode, I encountered the “Rotate Image” challenge. The problem is straightforward at first glance:

Given an n x n matrix, rotate it 90 degrees clockwise in-place — without allocating any additional matrix.

I started solving it as a pure coding exercise, focusing on swapping elements layer by layer or using the transpose-and-reverse trick. But then I wondered: Why does this matter beyond interviews? Where is this matrix rotation used in the real world?
At first glance, rotating an n x n matrix 90 degrees in-place might seem like just an exercise in array manipulation.

But here’s a twist: Matrix rotation isn’t just an abstract puzzle. It’s a fundamental operation used in real-world technologies — like QR code scanning!
Ever wondered how QR Codes store a phone number?
When you encode a phone number (or any data) into a QR code, it’s transformed into a pattern of black and white squares, called modules. Each module encodes a bit of information:

Black modules: Represent a 1
White modules: Represent a 0

As the amount of data increases, the QR code size (called the version) also grows. The smallest, version 1, is a 21x21 grid of modules, increasing in size for more complex data.

How does the QR code guide the scanner?

QR codes are clever. They contain specific patterns that help scanners locate, orient, and read the encoded data reliably—even if the QR code is tilted or partially distorted:

Finder Patterns: Three large squares at the top-left, top-right, and bottom-left corners. These help the scanner detect the QR code’s position and rotation.

Timing Patterns: A sequence of alternating black and white modules along the horizontal and vertical axes that help determine the grid structure.

Alignment Patterns: Smaller squares scattered through larger versions of QR codes that correct for distortions like curvature or perspective changes.

Quiet Zone: The blank margin around the QR code separating it from surrounding text or images so scanners can distinguish the code boundaries.

So, where does matrix rotation come in?
Imagine you scan a QR code tilted at an angle. Before decoding, the scanner must rotate the matrix of black and white modules to the correct orientation. This rotation is very much like the "Rotate Image" problem:

The scanner needs to transform the 2D array in-place to correct the orientation — often rotating it 90, 180, or 270 degrees.

This operation is critical for reliable decoding. Without it, the scanner might read the wrong bits or fail to find the finder patterns.

In essence:
Matrix Rotation may not fully power QR code scanning but it definitely is first step.The scanning process typically follows this order: Skew Correction → Rotation → Perspective Correction. Each step ensures that the QR code is properly aligned and readable, regardless of how it's captured.

How Joins work?

levi — Mon, 02 Jun 2025 16:02:15 +0000

Joins are like set operations.

I know math can be intimidating, but this part isn’t that scary.

INNER JOIN : get rows common to both table, matching key( primary and foreign key)

id	name
1	Alice

id	customer_id	product
10	1	Book
11	1	Laptop

SELECT c.name, o.product
FROM customers c
JOIN orders o ON c.id = o.customer_id;

output :

name	product
Alice	Book
Alice	Laptop

On clause specifies matching condition.

Intuition:

Identify the table join: Custumors and Orders
we compare each row of table 1 with table 2 and look for the matching condition
for every matching pair database combines the table columns
If it's an INNER JOIN, only matched pairs are included.
If it's a LEFT JOIN, all rows from the left table are included; if no match is found in the right table, NULLs fill the right side.
For other join types, the logic changes slightly (like including unmatched rows on either side).

For obvious reasons, databases don't compare every row with every other row blindly.

🔍 What Happens Under the Hood During a Join

Cost Estimation – The database estimates the CPU, memory, and I/O cost of different join strategies.
Join Reordering – It may reorder joins to start with the most selective table.
Bloom Filters – In some systems, these help reduce unnecessary data scanning.

What are strategies Db uses for Joins?

Nested Loop Join: for each row in outer table, the database searches for matching rows in inner table.
Con: can be very slow on large datasets.
Hash Joins: db creates hash table(usually smaller one) on the key used for join. and then we lookup other table key in hash table.

pro: No index required.
con: uses extra memory for hashtable

Drum roll ....

Merge-join: A merge join scans two sorted tables in order, comparing rows based on the join key. When keys match, it returns the joined rows, moving pointers forward to continue merging efficiently. example:

sale_id	store_id	amount
1	100	200
2	101	300
3	102	250

id	name
100	Store A
101	Store B
102	Store C

Start at the first row of sales (store_id = 100) and the first row of stores (id = 100).
Compare them:
100 = 100 → MATCH → return this joined row: sale_id=1, store_id=100, amount=200, name=Store A
Move both pointers forward.
101 = 101 → MATCH → return: sale_id=2, store_id=101, amount=300, name=Store B
Next: 102 = 102 → MATCH → return: sale_id=3, store_id=102, amount=250, name=Store C
Efficient, fast, and only one scan through each table.

✅ In Summary:

Joins combine tables by matching rows based on keys.
INNER JOIN returns only matching rows.
Different strategies (nested loop, hash, merge) help optimize performance behind the scenes.

Is Java Playing Favorites: Primitives vs. Objects?

levi — Thu, 13 Feb 2025 17:38:03 +0000

Ever wondered what would happen if you typed:

Date date; date.now();
Well, boom, instant compile-time error! Why? Because date is just a variable, not an object yet. It's like showing up at a party without your invitation—no object, no method access!

To make things right, you have to create an object first, like:

date = new Date();
Or, if you want to be fancy, you could:

Date yesterday = new Date(); date = yesterday;
But hold on a second—are these Java object variables the same as C++ pointers? Let’s dive into that. In Java, variables don’t work the same way they do in C++. Java variables are passed by value, and objects and variables are not the same thing.

In Java:

Objects are stored in heap memory.
Reference variables that point to objects live in the stack.
So, when it comes to passing by value, here’s how it goes down:

Passing Primitives: Let’s start with a classic—primitives. These little guys are pass-by-value champs.

public class PrimitivesUnitTest {
    @Test
    public void whenModifyingPrimitives_thenOriginalValuesNotModified() {
        int x = 1;
        int y = 2;

        // Before Modification
        assertEquals(x, 1);
        assertEquals(y, 2);

        modify(x, y);

        // After Modification
        assertEquals(x, 1);  // x stays unchanged!
        assertEquals(y, 2);  // y stays unchanged!
    }

    public static void modify(int x1, int y1) {
        x1 = 5;
        y1 = 10;
    }
}

In this case, the x and y are primitive types, so they’re like little treasure chests of value. When we pass them to modify(), we don’t send the chests—just copies of the values inside them. Any changes to x1 and y1 won’t affect the original treasure chests x and y. Magic!

Passing Objects: Now, things get more interesting with objects. In Java, objects live in the heap, and reference variables are the keys to access them (stored in the stack).

When you pass an object, Java doesn’t send the object itself—it sends a copy of the reference (aka the key) that points to the object in the heap. It’s like giving someone a copy of your house key. They can go into your house, but you both have the same key! So, any changes made inside the house (object) will be reflected in both places.

public class ModifyObjects {
    public static void main(String[] args) {
        Date date = new Date();
        modifyDate(date);
        System.out.println(date);  // Changes are reflected here!
    }

    public static void modifyDate(Date date) {
        date.setYear(2025);  // Modify the object in the heap
    }
}

Here, we’re passing the reference to the date object, not the actual object itself. Both the caller and the method share the same object in memory. Any change made to date in the method will show up everywhere.

Wrapping it Up: All About Passing by Value
So, what’s the takeaway? Everything in Java is passed by value—but, when we deal with objects, it’s the reference value that gets passed, not the actual object. Objects are passed by reference, but the reference itself is passed by value. Confused yet?

Here’s the recap:

Primitives: You’re passing copies of the actual values.
Objects: You’re passing copies of the reference to the object. You’re still sharing the same object in memory, though!
In Java, pass-by-value is the rule. But with objects, it’s like passing the key to the kingdom, not the whole castle.

So it was not that difficult posting my first article.