DEV Community: Sandaruwan Wadiyage

THE JAVA TYPE CASTING BUG –YOU’VE PROBABLY OVERLOOKED

Sandaruwan Wadiyage — Mon, 21 Jul 2025 08:14:16 +0000

“A deep dive into how silently casting a long to float or double in Java can cause unexpected rounding — even when it looks like everything's working fine.”

While I was experimenting with Java's primitive data types, I stumbled across a strange behavior when casting a long value to a float. Initially, everything looked fine — until I tried a slightly different number. Let's dive into what I found!

🧪 The Case: Casting `long` to `float`

Here’s a small Java snippet that caught my attention:

class Example {
    public static void main(String args[]) {
        long original = Long.MAX_VALUE; // 9223372036854775807
        float x = original;
        long y = (long)x;
        System.out.println("Original : " + original);
        System.out.println("After storing the long value as float : " + x);
        System.out.println("Stored in float and cast back : " + y);
        System.out.println("Same? " + (original == y));
    }
}

Original : 9223372036854775807
After storing the long value as float : 9.223372E18
Stored in float and cast back : 9223372036854775807
Same? true

Looks good, right? Now let’s subtract just 1 from that original value:

class Example {
    public static void main(String args[]) {
        long original = Long.MAX_VALUE - 1; // 9223372036854775806
        float x = original;
        long y = (long)x;
        System.out.println("Original : " + original);
        System.out.println("After storing the long value as float : " + x);
        System.out.println("Stored in float and cast back : " + y);
        System.out.println("Same? " + (original == y));
    }
}

Original : 9223372036854775806
After storing the long value as float : 9.223372E18
Stored in float and cast back : 9223372036854775807
Same? false

🤔 What Just Happened?

float in Java is a 32-bit IEEE 754 floating-point number — it simply can’t hold the full precision of a 64-bit long (which has a 53-bit mantissa in double-precision, and only ~24 bits in single-precision).

So when you convert a long to float, you lose precision — and in some edge cases, this causes rounding to the nearest representable float, which might increase the number unexpectedly.

In our second example, 9223372036854775806L was rounded up to the same float representation as Long.MAX_VALUE — so when cast back to long, it became greater than it originally was.

🔍 Key Takeaways

✅ float cannot safely store large long values without precision loss.
⚠️ Be careful when comparing values after type casting.
💡 Use double or BigDecimal if you need more precise conversions or arithmetic.

🎯 Real-World Impact

Such subtle bugs can appear in:

Financial applications dealing with large monetary values
Timestamps or IDs stored as long
Scientific calculations where precision matters Always know your data types and limits before relying on direct conversions.

💬 Final Thoughts

This tiny experiment reminded me why understanding the limits of data types is crucial, even in the simplest programs. Java makes type casting easy — but sometimes too easy!

Have you encountered similar surprises in Java (or other languages)? I’d love to hear your thoughts in the comments.

Let’s keep learning, one line at a time! ✨

📣 Follow me on LinkedIn and GitHub for more Java insights and development experiments.

🧐 Why Does Java Give an Error for Uninitialized Variables, But C Just Runs?

Sandaruwan Wadiyage — Sun, 13 Jul 2025 18:04:55 +0000

As a beginner in Java programming, I recently faced a confusing situation that led me to understand something deeper about how different programming languages work under the hood.

Let me share this small but interesting learning experience.

🔍 The Problem: Java vs. C — Different Reactions``

Java Code:
class Example { public static void main(String[] args) { int x; System.out.print(x); } }
Result (Compile-Time Error):

Example.java:4: error: variable x might not have been initialized System.out.print(x); ^ 1 error

C Code:

`#include

int main() {
int x;
printf("%d", x);
}`

Result (Runtime Output):

0 Process returned 0 (0x0) execution time : 6.435 s Press any key to continue.
Or... sometimes it outputs random garbage values.

🛑 Why the Difference?

⚙️ How Java Works:

Java does not allow local variables to be used without initialization.
The compiler checks this for you to prevent bugs from undefined data.
This makes Java a "safer by design" language, especially for beginners.

// ✅ Correct way in Java int x = 0; System.out.print(x);

⚙️ How C Works:

C is a low-level language and trusts the programmer.
It allows variables to be used even if they contain garbage values (whatever was already in memory).
This can lead to unpredictable results if you're not careful.

// ✅ Better in C int x = 0; printf("%d", x);

💡 What I Learned:

Always initialize variables explicitly, regardless of the language.
Java protects you with compile-time safety.

🚀 Why I'm Sharing This

As I grow in my programming journey, these small "aha!" moments help me better understand how different languages shape how we think and code.
It's fascinating to see how language design affects both our code and our habits.

🤝 Your Thoughts?

If you’ve ever stumbled on a similar quirk between languages, I'd love to hear how it surprised or challenged you!

Boost Your Dev Workflow with AI Tools (Beginner-Friendly)

Sandaruwan Wadiyage — Sat, 28 Jun 2025 10:53:27 +0000

As a software engineering beginner, I recently attended a session titled "How to Use AI Assistants as a Software Engineering Beginner" by Mr. Dewmal Handapangoda – AI & Software Specialist from the University of Moratuwa. It was eye-opening and inspired me to dive deeper into AI tools specifically designed to support developers.

This article is a categorized guide to the most impactful AI tools that can supercharge your development workflow — from writing code and debugging to managing backend services and running AI models locally.

🔧 1. Coding Assistants (Auto-complete, Debug, Explain, Generate Code)

These tools help you write, understand, and optimize code faster with AI assistance.

🔍 2. Search & Documentation Assistants

These AI tools provide intelligent code search, documentation parsing, and faster answers than traditional search engines.

🧪 3. Local AI (Privacy-Focused & Experimental Dev)

Run models on your machine for privacy, experimentation, or low-latency workflows.

☁️ 4. Backend, DevOps, and Full Stack AI Help

Tools to support backend management, full-stack workflows, and low-code AI-enhanced platforms.

🎨 5. Creative AI Tools for Devs (Optional)

Niche but helpful tools for creative developers building audio, voice, or ideation-based apps.

🔥 Top Picks for Beginners

If you’re new and don’t want to be overwhelmed, here’s your starter pack by use case:

📌 Final Thoughts:

AI is now your development co-pilot. Whether you’re debugging your first React app, exploring Firebase, or running LLMs offline with Ollama, these tools can transform how you build, learn, and ship software.

Which tools have you tried? Did I miss your favorite?

Let me know in the comments — and stay tuned for a follow-up on setting up Cursor, Ollama, or using ChatGPT for real-world coding projects!

HOW TO UPLOAD YOUR PROJECT TO GITHUB – STEP-BY-STEP WITH CHEAT SHEET 🧩

Sandaruwan Wadiyage — Fri, 20 Jun 2025 16:11:47 +0000

📌 INTRODUCTION

Uploading your project to GitHub for the first time?

Here’s a clean, beginner-friendly walkthrough — plus a downloadable cheat sheet to keep handy.

🧠 STEP-BY-STEP GIT COMMANDS EXPLAINED

🔹 Step 1: Initialize Git
git init - This creates a .git folder in your directory and enables version tracking.
🔹 Step 2: Stage All Files
git add . - This stages all your changes for commit.
🔹 Step 3: Commit with a Message
git commit -m "Initial commit"
🔹 Step 4: Connect Remote Repository
git remote add origin https://github.com/your-username/your-repo.git
Tip: Already connected to another remote?
git remote set-url origin <new-link>
🔹 Step 5: Push to GitHub
git branch -M main
git push -u origin main
-u links to your local branch to remote branch.

🔁 AFTER MAKING CHANGES

git status git add . git commit -m "Updated section UI" git push origin main

🧹 OPTIONAL: DELETE ‘MASTER’ BRANCH

git push origin --delete master
✔ Confirm:

main has latest updates
GitHub default is main
No one using master

📎 CHEAT SHEET

Here’s a visual version to download and share 👇

🔚 FINAL THOUGHTS

If you're a beginner or just want to keep things simple, this is all you need to get your project onto GitHub.
Have any tips or favorite commands? Share them in the comments!