DEV Community: Akshata

Launch Your React Website on Netlify for Free: The Lazy Dev’s Guide 😪

Akshata — Wed, 20 Aug 2025 05:47:25 +0000

It feels so great when you buy a shirt, and while paying you find out another one is free. We all love free stuff, don’t we?

Now, when you’re just starting to build your website, do you really want to pay for hosting before you’ve even earned a single dollar from it? I know even wealthy people like you wouldn’t say no to free hosting 😂.

Luckily, there are several cloud platforms with free tiers. One of the best is Netlify.

Netlify is a platform to build, deploy, and manage modern web apps—and yes, you can deploy your React app there without paying a dime.

In this tutorial, I’ll show you how to do it. Don’t worry, I won’t be customizing the React app—we’ll stick with the boring default landing page. Why? Because I’m lazy 😪.

Steps:

Open your workspace in Visual Studio Code.
Open the terminal and create a new React App, using the command npx create-react-app app-name.
Go to your app folder and run the command npm start. React's default landing page should show up at http://localhost:3000.
Push your code to GitHub.
Login to Netlify using Github account.
Enter Signup Questions.
From the List of Git providers select GitHub.
Select and authorise Netlify to access your repository.
Start deploying your React project.
Below command is used to build your project
Once your build is successful your website will be published.
If you haven't given any name to your website Netlify will generate a random name. You can click on the link and open your website.
You can change the name of your website by navigating to Project Configuration-> Change Project Name.
Now click on your website link and share your website.

Boom! Your React app is online. And you didn’t even have to touch a server, configure domains, or sell your kidney for hosting fees. Netlify did all the heavy lifting while you sat back lazy (respect ✌️).

The HashSet Duplicate Illusion in Java 😏

Akshata — Wed, 13 Aug 2025 23:13:58 +0000

I came across this interesting question during a technical interview.

public class Employee {
    public int id;
    public String name;
    public int salary;

    public Employee(String name, int id, int salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, salary);
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", salary=" + salary + "]";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null || getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        return id == other.id && Objects.equals(name, other.name) && salary == other.salary;
    }
}

public class Main {
    public static void main(String[] args) {
        Employee e1 = new Employee("Sam", 1, 20000);
        Employee e2 = new Employee("Sam", 1, 20000);
        Employee e3 = new Employee("Sam", 2, 20000);

        HashSet<Employee> hs = new HashSet<>();
        hs.add(e1);
        hs.add(e2); // same as e1 → won't be added
        hs.add(e3); // different id → will be added

        System.out.println("Before update--->");
        for (Employee e : hs) {
            System.out.println(e);
        }

        // Change a field that is part of hashCode/equals
        e3.id = 1;

        System.out.println("After update--->");
        for (Employee e : hs) {
            System.out.println(e);
        }
    }
}

Expected Output

Before update--->
Employee [id=2, name=Sam, salary=20000]
Employee [id=1, name=Sam, salary=20000]

After update--->
Employee [id=1, name=Sam, salary=20000]
Employee [id=1, name=Sam, salary=20000]

(Order may vary as HashSet does not guarantee iteration order)

❓ Why Does This Happen?
We know HashSet doesn’t allow duplicates, so why does the second print still show two identical employees?

When you add an element, HashSet:

Calls hashCode() to find the correct bucket.
If there’s already an element with the same hash, it calls equals() to check for equality.
If they are equal, it does not add the element.

This check happens only at insertion.

When you change e3.id after it’s already in the set, it's hashCode() result changes.

However, the object remains in the bucket for its old hash value — HashSet does not automatically rehash or move elements when their data changes.

This causes the set to appear to contain duplicates and can also make contains() or remove() behave unexpectedly.

💯 How to Prevent This

The safest way is to make objects immutable when they are used as keys in hash-based collections.

Example fix:

public class Employee {
    private final int id;
    private final String name;
    private final int salary;

    public Employee(String name, int id, int salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, salary);
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", salary=" + salary + "]";
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null || getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        return id == other.id && Objects.equals(name, other.name) && salary == other.salary;
    }
}

✅ Changes:

Fields are private and final.
No setters provided → prevents accidental modification.

🔗 Takeaway
When using HashSet or any HashMap keys:

Never mutate fields that participate in equals() and hashCode() after insertion.
Prefer immutable classes for keys.
If mutation is unavoidable:
1. Remove the object from the set.
2. Update it.
3. Then re-add it.

Java String Behavior: Quick Guide

Akshata — Wed, 13 Aug 2025 21:21:57 +0000

🔆 What is the output of the following block of code?

String a1 = "Hello";
String a2 = "Hello";
System.out.println(a1 == a2);

✅ Output: true

Both a1 and a2 point to the same string in the String pool — so == returns true.

📌 What about this?

String b1 = new String("Hello");
String b2 = new String("Hello");
System.out.println(b1 == b2);

❌ Output: false

Each new String("Hello") creates a new object in the heap, so b1 and b2 are different objects — even though the text is the same.

📎 == checks if two variables point to the same object, not just equal text. Use .equals() to compare text.

📌 Another Example

String c1 = "Hi";
c1 = c1 + "There";
String c2 = "HiThere";
System.out.println(c1 == c2);

❌ Output: false

"Hi" is a string literal stored in the pool.
c1 + "There" is done at runtime, so a new string "HiThere" is created in the heap.
c1 and c2 have the same content, but point to different objects.

✔️ How to Make It True

String c1 = "Hi";
c1 = c1 + "There";
String c2 = "HiThere";
String c3 = c1.intern();
System.out.println(c3 == c2);

✅ Output: true

c1 is a heap object.
c2 is the pooled "HiThere" literal.
c1.intern() returns the pooled version, so now c3 == c2.

Java String Behavior: Quick Guide

Akshata — Sun, 03 Aug 2025 15:04:28 +0000

🔆 What is the output of the following block of code?

String a1 = "Hello";
String a2 = "Hello";
System.out.println(a1 == a2);

✅ Output: true

Both a1 and a2 point to the same string in the String pool — so == returns true.

📌 What about this?

String b1 = new String("Hello");
String b2 = new String("Hello");
System.out.println(b1 == b2);

❌ Output: false

Each new String("Hello") creates a new object in the heap, so b1 and b2 are different objects — even though the text is the same.

📎 == checks if two variables point to the same object, not just equal text. Use .equals() to compare text.

📌 Another Example

String c1 = "Hi";
c1 = c1 + "There";
String c2 = "HiThere";
System.out.println(c1 == c2);

❌ Output: false

"Hi" is a string literal stored in the pool.
c1 + "There" is done at runtime, so a new string "HiThere" is created in the heap.
c1 and c2 have the same content, but point to different objects.

✔️ How to Make It True

String c1 = "Hi";
c1 = c1 + "There";
String c2 = "HiThere";
String c3 = c1.intern();
System.out.println(c3 == c2);

✅ Output: true

c1 is a heap object.
c2 is the pooled "HiThere" literal.
c1.intern() returns the pooled version, so now c3 == c2.