DEV Community: yash agarwal

🧠 What Is Immutability?

yash agarwal — Fri, 17 Oct 2025 18:19:13 +0000

An immutable object is one whose state cannot change after creation.
Once you create it, that’s it — no more modifications.

For example, Java’s String class is immutable:

String name = "Yash";
name.concat(" Agarwal");
System.out.println(name); // Still prints "Yash"

concat() creates a new String instead of modifying the original.

⚙ Why Immutability Matters

Here’s why immutable objects are a developer’s best friend:

✅ Thread-Safety – Immutable objects can be shared across threads safely without synchronization.

🧩 Predictable Behavior - Their state never changes, so debugging is easier.

🧠 Simpler Design – You don’t have to worry about side effects.

💡 Cache Friendly – Immutable objects can be cached or reused without fear of modification.

🧱 How to Make a Class Immutable

To make your own class immutable, follow these 5 golden rules:

Mark the class as final

So no one can subclass and modify its behavior.

public final class Employee {

Make all fields private and final

This ensures they can’t be reassigned after construction.

private final String name;
private final int id;

Initialize fields through the constructor only

All values should be set once, during object creation.

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

No setters!

Avoid any method that can modify the internal state.

❌ Bad:

public void setName(String name) { this.name = name; }

✅ Good:

public String getName() { return name; }

Return deep copies of mutable objects

If your class holds references to mutable objects, protect them.

private final Date joiningDate;

public Date getJoiningDate() {
return new Date(joiningDate.getTime()); // Defensive copy
}

This ensures outside code can’t modify your object indirectly.

🚀 Example: Immutable Class in Action
public final class Employee {
private final String name;
private final int id;
private final Date joiningDate;

public Employee(String name, int id, Date joiningDate) {
    this.name = name;
    this.id = id;
    this.joiningDate = new Date(joiningDate.getTime());
}

public String getName() { return name; }
public int getId() { return id; }

public Date getJoiningDate() {
    return new Date(joiningDate.getTime());
}

}

✅ Thread-safe
✅ No side effects
✅ Clean and predictable

🧩 Bonus: Records (Java 14+)

From Java 14 onward, records make creating immutable data classes effortless.

public record Employee(String name, int id, LocalDate joiningDate) {}

Records automatically:

Make fields final

Generate constructors & accessors

Prevent setters

This is the modern Java way to achieve immutability with minimal boilerplate.

🧭 Conclusion

Immutability isn’t just a design principle — it’s a mindset.
When you stop mutating state and start creating predictable, unchangeable objects, your code becomes:

Easier to reason about

Safer in concurrent environments

More reliable and bug-resistant

“Immutable code is clean code. And clean code scales.”

⚙ Handling Nulls the Smart Way in Java

yash agarwal — Fri, 17 Oct 2025 18:14:38 +0000

If you’ve written Java for a while, you’ve definitely seen it:

💥 NullPointerException: Cannot invoke method because "object" is null

It’s one of the most common and most annoying runtime errors in Java.
But the truth is, nulls themselves aren’t evil; the way we handle them usually is.

Let’s look at a few smart, modern ways to deal with nulls gracefully in Java 👇

🧩 1. Understand Why Nulls Exist

Java’s creator, Tony Hoare, once called null his “billion-dollar mistake.”
But nulls exist for a reason — to represent the absence of value.

The problem is when we forget to handle that absence and assume data is always there.
The goal isn’t to eliminate null it’s to control it safely.

✅ 2. Use Objects.requireNonNull() Early

If a method should never accept nulls, fail fast and loud.

public void sendEmail(String email) {
this.email = Objects.requireNonNull(email, "Email cannot be null");
}

This instantly catches the problem where it happens instead of breaking your app 50 lines later.

🧠 3. Use Optional (Smartly)

Java 8 introduced Optional to help represent “maybe present, maybe not” values safely.

✅ Good usage:

Optional userOpt = userRepository.findById(id);
userOpt.ifPresent(user -> sendEmail(user.getEmail()));

❌ Bad usage:

Optional user = Optional.ofNullable(null);

👉 Tip: Don’t use Optional for fields or parameters only for method return types.

🔍 4. Chain Safely with map() and flatMap()

Instead of writing multiple null checks, you can chain operations elegantly:

userRepository.findById(id)
.map(User::getAddress)
.map(Address::getCity)
.ifPresent(System.out::println);

This avoids deep nesting like:

if (user != null && user.getAddress() != null && user.getAddress().getCity() != null) ...

🧰 5. Use Default Values with orElse() and orElseGet()

When something’s missing, define a fallback value instead of breaking your flow.

User user = userRepository.findById(id)
.orElseGet(() -> new User("Guest"));

🧩 Difference:

orElse() → always executes the fallback

orElseGet() → executes it only if needed

🔒 6. Leverage @NonNull and @Nullable Annotations

Modern IDEs (like IntelliJ) can warn you about possible nulls if you annotate your code properly.

public void processOrder(@NonNull Order order) { ... }

Helps catch issues before you run the code.

🧹 7. Defensive Coding Mindset

When designing APIs or writing methods:

Be explicit about what can be null.

Validate inputs early.

Return empty lists instead of nulls when possible.

✅ Good practice:

return users != null ? users: Collections.emptyList();

🧭 Conclusion

Handling nulls smartly is all about predictability and intent.
Your code should never leave others guessing —“Can this be null or not?”

When you start using Optional, annotations, and defensive checks wisely,
You’ll find your code is cleaner, safer, and way easier to maintain.

How to Write Clean, Readable, and Maintainable Java Code

yash agarwal — Fri, 17 Oct 2025 18:11:59 +0000

As Java developers, we often focus on getting things to work. But over time, we realize that getting it to work and making it maintainable are two very different goals.
Clean code is not just about syntax, it’s about writing software that is easy to read, easy to change, and easy to trust.

Here’s how you can start writing cleaner, more maintainable Java code that even your future self will thank you for.

🧠 1. Follow Consistent Naming Conventions

Good naming makes your code self-explanatory.
Avoid using short or vague names like 'tmp', 'data', or 'val'. Instead, use meaningful and descriptive names that accurately reflect your intent.

✅ Good Example:

int retryCount = 3;
String customerEmail = "user@example.com";

❌ Bad Example:

int r = 3;
String e = "user@example.com";

A rule of thumb: if someone can guess what a variable does without reading comments, you’ve done well.

🧩 2. Keep Methods Small and Focused

A method should do one thing and do it well.
If your method exceeds 20–30 lines, chances are it’s handling multiple responsibilities.

✅ Better:

void sendEmailNotification(User user) { ... }
void logEmailStatus(User user) { ... }

❌ Worse:

void processUserEmail(User user) {
// send email + log status + update DB + error handling
}

Breaking down logic into smaller methods improves reusability and testability.

📦 3. Use Meaningful Comments (or None)

Comments should explain why, not what.
If your code is self-explanatory, extra comments often add noise.

✅ Good Comment:

// Retry three times because the email service is unstable
for (int i = 0; i < 3; i++) { ... }

❌ Bad Comment:

// increment i
i++;

If you need too many comments, consider refactoring instead.

🧰 4. Stick to SOLID Principles

These five principles are the backbone of maintainable object-oriented design:

Single Responsibility

Open/Closed

Liskov Substitution

Interface Segregation

Dependency Inversion

For example, instead of one giant UserService doing everything, split it into smaller services — each handling a single concern.

⚙ 5. Use Proper Exception Handling

Avoid blanket exception catches like catch (Exception e) unless necessary.
Be specific and log meaningful messages.

✅ Good:

try {
userRepository.save(user);
} catch (DataIntegrityViolationException e) {
log.error("Duplicate email: {}", user.getEmail());
}

❌ Bad:

try {
// risky code
} catch (Exception e) {
e.printStackTrace();
}

Specific exceptions make debugging faster and logs more useful.

🧩 6. Format and Organize Your Code

Use consistent indentation, spacing, and line breaks.
Follow a Java style guide (like Google Java Style or your company’s standards).
Also, leverage your IDE’s built-in formatter (Ctrl + Alt + L in IntelliJ).

Clean formatting doesn’t affect performance — but it massively affects readability.

🚦 7. Write Unit Tests

Well-tested code tends to be cleaner because tests force you to think modularly.
Use JUnit and Mockito to test small units of logic.
If your class is hard to test, it’s often a sign that it needs refactoring.

🧭 8. Refactor Regularly

Refactoring is not rewriting — it’s improving structure without changing behavior.
Small, regular refactors prevent big technical debt later.

Even five minutes a day of refactoring improves the overall health of your codebase.

✨ Conclusion

Clean code is not about perfection — it’s about clarity, simplicity, and empathy for other developers.
When your code reads like a story, you build trust with your team and with your future self.