Kathirvel Rajmohan’s Post

You have written this line hundreds of times. But do you actually understand what each part does? Every Java developer has written this line countless times, but do you really understand what each keyword means? Here is a breakdown of the Java main method: public - Access modifier that makes the class and method accessible from outside the package. This allows the JVM to call the main method from anywhere. class - Keyword used to declare a class. Classes are blueprints used to represent anything in software and in the real world. MainClass - The name of your class. This is where your program logic lives. static - Method belongs to the class itself rather than an instance. This means the JVM can call the main method without creating an object of the class first. void - Return type indicating that the method does not return any value. The main method executes the program but does not return anything. main - Java's entry point where the program starts executing. When you run a Java program, the JVM looks for this method first. String[ ] args - Command-line arguments to the program when it is executed. This allows you to pass input to your program at runtime. System.out.println - Prints the string "Hello, World!" followed by a newline to the console. Why This Matters: Understanding these fundamentals helps you write better code and debug issues faster. When you know why each keyword exists, you can make better architectural decisions. What Java fundamental concepts do you think every developer should master? Share your thoughts below! #Java #Programming #SoftwareDevelopment #BackendDevelopment #LearningInPublic #Coding

You have written this line hundreds of times. But do you actually understand what each part does? Every Java developer has written this line countless times, but do you really understand what each keyword means? Here is a breakdown of the Java main method: public - Access modifier that makes the class and method accessible from outside the package. This allows the JVM to call the main method from anywhere. class - Keyword used to declare a class. Classes are blueprints used to represent anything in software and in the real world. MainClass - The name of your class. This is where your program logic lives. static - Method belongs to the class itself rather than an instance. This means the JVM can call the main method without creating an object of the class first. void - Return type indicating that the method does not return any value. The main method executes the program but does not return anything. main - Java's entry point where the program starts executing. When you run a Java program, the JVM looks for this method first. String[ ] args - Command-line arguments to the program when it is executed. This allows you to pass input to your program at runtime. System.out.println - Prints the string "Hello, World!" followed by a newline to the console. Why This Matters: Understanding these fundamentals helps you write better code and debug issues faster. When you know why each keyword exists, you can make better architectural decisions. What Java fundamental concepts do you think every developer should master? Share your thoughts below! #Java #Programming #SoftwareDevelopment #BackendDevelopment #LearningInPublic #Coding

Earlier I use to think writing more Java code meant being more productive. I was wrong. The real shift happened when I stopped focusing on writing code fast — and started focusing on writing code right. Here are the principles that changed how I write Java: ✅ Keep classes small and purposeful — the Single Responsibility Principle isn't just theory, it saves you hours of debugging. ✅ Never ignore exceptions — catch them intentionally, log them meaningfully, and handle them gracefully. ✅ Favor composition over inheritance — it keeps your architecture flexible as requirements evolve. ✅ Write tests as you code — not after. Your future self will thank you. ✅ Understand the JVM, not just the language — memory management, garbage collection, and thread behavior matter in production. Java is 30 years old and still powers some of the world's most critical systems. That longevity is no accident — it rewards discipline and craftsmanship. What principle do you wish you had learned earlier in your Java journey? #Java #SoftwareEngineering #BestPractices #TechLeadership #CleanCode

🚀 Day 19/100: The Grammar of Java – Writing Clean & Readable Code 🏷️✨ Today’s focus was on something often underestimated but critically important in software development—writing code that humans can understand. In a professional environment, code is not just for the compiler; it’s for collaboration. Here’s what I worked on: 🔍 1. Identifiers – Naming with Purpose Identifiers are the names we assign to variables, methods, classes, interfaces, packages, and constants. Good naming is not just syntax—it’s communication. 📏 2. The 5 Golden Rules for Identifiers To ensure correctness and avoid compilation errors, I reinforced these rules: Use only letters, digits, underscores (_), and dollar signs ($) Do not start with digits Java is case-sensitive (Salary ≠ salary) Reserved keywords cannot be used as identifiers No spaces allowed in names 🏗️ 3. Professional Naming Conventions This is where code quality truly improves. I practiced industry-standard naming styles: PascalCase → Classes & Interfaces (EmployeeDetails, PaymentGateway) camelCase → Variables & Methods (calculateSalary(), userAge) lowercase → Packages (com.project.backend) UPPER_CASE → Constants (MIN_BALANCE, GST_RATE) 💡 Key Takeaway: Clean and consistent naming transforms code from functional to professional and maintainable. Well-written identifiers reduce confusion, improve collaboration, and make debugging easier. 📈 Moving forward, my focus is not just on writing code that works—but code that is clear, scalable, and team-friendly. #Day19 #100DaysOfCode #Java #CleanCode #JavaDeveloper #NamingConventions #SoftwareEngineering #CodingJourney #LearningInPublic #JavaFullStack#10000coders

🚀 Exploring VS Code Extensions – Built a Practical Java Utility While working on improving my development workflow, I created a custom VS Code extension that reduces repetitive coding in Java. 👉 Instead of manually writing classes, you can simply write: abc.print("Hello"); And the extension automatically generates the required Java class in real-time. 💡 Key Capabilities: Detects any .print() usage Dynamically creates the corresponding class Works instantly while editing Java files Helps reduce boilerplate code ⚙️ Tech Stack: TypeScript • VS Code Extension API • Java 📦 How to Use (Important): Since this is not published on the VS Code Marketplace, you can use it locally: Download the .vsix file from GitHub Open VS Code Press Ctrl + Shift + P Select Install from VSIX Choose the downloaded file Start using it in any .java file 🔗 GitHub Repository: (https://lnkd.in/dnj575B3) I’m continuously working on improving this and adding more features. Feedback and suggestions are always welcome! #Java #VSCode #DeveloperTools #TypeScript #Coding #SoftwareDevelopment #BuildInPublic

Hi Friends 👋 Sharing a small but tricky Java concept that often confuses developers in real projects 😅 finally block vs return — who actually wins? public class Test { public static void main(String[] args) { System.out.println(getValue()); } static int getValue() { try { return 10; } finally { return 20; } } } 👉 What would you expect? Most people say: 10 👉 But the actual output is: 20 😳 --- Why does this happen? - The try block tries to return 10 - But before the method exits, the finally block always runs - If finally also has a return, it overrides the previous return 👉 So the final result becomes 20 --- Common mistakes: - Assuming the try return is final - Writing return inside finally for cleanup or logging --- Real-world impact: - Expected vs actual result mismatch - Hard-to-debug issues - Confusing behavior in production --- Best Practice: - Never use return inside a finally block ❌ - Use finally only for cleanup (like closing resources) --- Final Thought: In Java, small concepts can create big bugs. Understanding execution flow is what makes a real developer 🚀 Did you know this before? 🤔 #Java #BackendDevelopment #CodingMistakes #Learning #Developers

🏗️ **Day 9: Mastering Methods – Writing Organized & Reusable Java Code 💻🚀** Today marked a significant upgrade in my Java journey—from writing simple programs to structuring clean, reusable logic using **Methods**. --- 🔹 **1. User-Defined Methods (Created by Developer)** ✍️ I learned how to design my own methods to perform specific tasks and understood the difference between: ✔️ **Static Methods** * Belong to the class * Can be called directly using the class name * No object creation required ✔️ **Non-Static Methods** * Belong to objects (instances) * Require object creation using `new` * Useful for real-world, object-oriented design --- 🔹 **2. Predefined Methods (Built-in Java Power)** 🛠️ Java provides powerful inbuilt methods that simplify development: ✔️ `main()` → Entry point of program ✔️ `println()` → Output to console ✔️ `length()` → Find string size ✔️ `sqrt()` → Mathematical calculations ✔️ `parseInt()` → Convert String to int 🎯 **Key Takeaway:** Methods are the foundation of clean coding. They improve: ✔️ Code reusability ✔️ Readability ✔️ Maintainability Understanding when to use **static vs non-static methods** is crucial for writing scalable and professional Java applications. --- #JavaFullStack #MethodsInJava #CleanCode #ObjectOrientedProgramming #JavaLearning #BackendDeveloper #SoftwareEngineering #LearningInPublic #Day9 #10000Coders

I just wanted to share something that really changed my life recently while I was coding in Java. As someone who has been working with this language for a long time, I always hated how we had to handle long Strings, like SQL queries or JSONs. It was a mess of \n and + everywhere, right? But then I started using Java Text Blocks (which came out in Java 15), and wow... it’s so much better! Here is why I think they are awesome: No more + signs: You just use three double quotes """ and write your text normally. It looks exactly like the final result. Easy to read: Since you don't have all those concatenation symbols, your code stays clean. My eyes are very happy now! Smart spaces: Java is smart enough to manage the indentation, so your code stays aligned but the String doesn't get a bunch of unnecessary spaces at the beginning. Check out this quick example of how I'm writing my SQL now: If you are still using the old way, please do yourself a favor and try Text Blocks. It makes the developer's life much easier and the code way more clean. #Java #Backend #CodingTips #CleanCode #SoftwareEngineering

I mass deleted 20,000 lines of Java code last week. And it felt incredible. Here's what happened. I inherited a legacy Java service that hadn't been touched in three years. It worked, technically. But it was drowning in unnecessary abstractions — interfaces with single implementations, factories creating factories, layers upon layers that existed because someone once read a design patterns book and decided to use all of them at once. So I started removing things. Carefully, methodically, with tests backing every change. The result? Same functionality. Half the code. New team members can actually understand what it does now. This taught me something I wish I'd learned earlier in my career: writing Java doesn't mean you have to over-engineer everything. The language gets a reputation for being verbose and bloated, but that's often us, not Java. After 3 years of writing Java professionally, my biggest lesson is this — the best code I've written wasn't clever. It was obvious. It was boring. It was the code that someone at 2 AM during an outage could read and immediately understand. Good Java isn't about knowing every design pattern. It's about knowing when NOT to use one. What's the most over-engineered codebase you've ever worked on? #Java #SoftwareEngineering #Programming #CleanCode #BackendDevelopment