DEV Community: Priyanshu Raut

Learning Java becomes much easier....

Priyanshu Raut — Fri, 07 Aug 2026 15:46:18 +0000

Learning Java becomes much easier when you stop only watching tutorials and start writing code regularly.

That was the motivation behind Java Practice Lab, a project I have been building to give beginners a structured place to practise Java.

It currently includes:

• 265 interactive coding exercises
• 59 runnable examples
• An online Java 17 compiler
• Hints, test cases and expected outputs
• Topics covering core Java, arrays, strings, OOP, collections, exception handling, file I/O and DSA patterns
• Progress tracking without requiring an account

One of my main goals was to keep the learning loop simple:

Learn a concept → solve a small problem → run the code → understand the mistake → continue practising.

You can explore it here:

https://java-practice-lab.vercel.app/java-practice-online

I would especially appreciate feedback from Java learners and educators. Which feature or topic would make this more useful for beginners?

Java #Programming #SoftwareDevelopment #CodingPractice #WebDevelopment

The finally Block in Java: What It Guarantees and What It Does Not

Priyanshu Raut — Fri, 07 Aug 2026 15:45:00 +0000

The finally Block in Java: What It Guarantees and What It Does Not

Java’s finally block is commonly explained as “the code that always executes.” That description is useful for beginners, but it is not completely precise.

Let us examine what finally does, when it runs, and the situations where it may not execute.

Basic structure

A finally block is normally placed after a try block and its optional catch blocks.

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Inside try");
        } finally {
            System.out.println("Inside finally");
        }
    }
}

Output:

Inside try
Inside finally

The finally block executes after the try block finishes.

What happens when an exception occurs?

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println(result);
        } catch (ArithmeticException exception) {
            System.out.println("Cannot divide by zero");
        } finally {
            System.out.println("Cleanup completed");
        }
    }
}

Output:

Cannot divide by zero
Cleanup completed

The exception is handled by catch, and Java executes finally afterward.

Does `finally` execute after `return`?

Yes. Java executes the finally block before the method completes its return.

public class Main {
    static int calculate() {
        try {
            return 10;
        } finally {
            System.out.println("Finally executed");
        }
    }

    public static void main(String[] args) {
        System.out.println(calculate());
    }
}

Output:

Finally executed
10

This makes finally useful for cleanup that must happen before a method finishes.

Avoid returning from `finally`

Returning from a finally block is legal, but usually a mistake.

static int calculate() {
    try {
        return 10;
    } finally {
        return 20;
    }
}

This method returns 20. The return inside finally overrides the earlier return and can even hide exceptions.

For maintainable code, avoid return, break, continue, or new exceptions inside finally unless there is an exceptional reason.

Does `finally` always execute?

Not literally always.

It may not execute when:

The JVM is forcibly terminated
System.exit() stops the application
The operating system kills the process
The computer loses power
The JVM crashes before reaching the block
Execution never leaves the try block because of an infinite loop

Therefore, a more accurate rule is:

A finally block normally executes when control leaves its associated try or catch block.

Should `finally` be used to close files?

It can be, but modern Java generally prefers try-with-resources.

try (BufferedReader reader = new BufferedReader(
        new FileReader("input.txt"))) {
    System.out.println(reader.readLine());
}

Java automatically closes the resource, even if an exception occurs. This is usually clearer and safer than manually closing the resource in finally.

When is `finally` still useful?

It remains useful for cleanup that is not managed by try-with-resources, such as:

Restoring temporary program state
Releasing a lock
Recording completion information
Deleting temporary data
Resetting flags
Performing cleanup around legacy APIs

If you want to practise this concept using editable Java code, expected outputs and hints, I created an interactive exercise here:

Practice the Java finally block

The important lesson is not that finally “always runs.” It is that Java normally runs it when control exits the associated try statement, making it a reliable place for carefully designed cleanup.

🧰 Introducing IMTools India — A Free Online Toolkit for Developers & Designers

Priyanshu Raut — Sun, 05 Oct 2025 10:49:49 +0000

Hey devs 👋

I recently built IMTools India
— a collection of 35+ free online tools designed to make a developer’s daily workflow simpler, faster, and distraction-free.

Whether you’re formatting JSON, generating a QR code, compressing images, or converting between text formats — you can now do it all in one clean place.

⚡ Why I Built It

While working on projects, I kept jumping between dozens of random sites — one for encoding, one for conversion, one for compression — all cluttered with ads and popups.

So I decided to build a single place for all the essentials:

Fast ⚡ (powered by modern web tech)

Minimal 🧩 (no sign-ups, no tracking)

Useful 🧠 (focused on what devs actually use daily)

🧠 What’s Inside

Some of the most used tools include:

🖼️ Image Compressor

📦 JSON Formatter & Validator

🔐 Password Generator

📱 QR Code Generator

🔡 Base64 Encoder / Decoder

📄 PDF Tools (merge, split, compress)

…and I keep adding more every week.

📝 Blog & Tutorials

Each tool comes with a short how-to guide on the IMTools Blog
— explaining its use cases, examples, and practical applications for developers and designers.

You’ll find posts like:

“How to use JSON Formatter for debugging APIs”

“Simple ways to reduce image size without losing quality”

“Understanding Base64 encoding in web apps”

🌍 Tech Stack

Built with:

Vite + TypeScript

Tailwind CSS for clean UI

Vercel for deployment

Lightweight, responsive, and 100% client-side friendly

💡 What’s Next

I’m planning to add:

More dev-focused utilities (regex tester, diff checker, etc.)

🚀 Check It Out : https://imtools-india.vercel.app/

Try a few tools and let me know what you think!
Feedback, suggestions, or collaboration ideas are always welcome. 🙌

A single hub of free, fast, ad-free tools for developers and designers.
No signups, no fluff — just tools that get the job done.

DEV Community: Priyanshu Raut

Learning Java becomes much easier....

Java #Programming #SoftwareDevelopment #CodingPractice #WebDevelopment

The finally Block in Java: What It Guarantees and What It Does Not

Basic structure

What happens when an exception occurs?

Does finally execute after return?

Avoid returning from finally

Does finally always execute?

Should finally be used to close files?

When is finally still useful?

🧰 Introducing IMTools India — A Free Online Toolkit for Developers & Designers

Does `finally` execute after `return`?

Avoid returning from `finally`

Does `finally` always execute?

Should `finally` be used to close files?

When is `finally` still useful?