DEV Community: Chrise Nwachukwu

Fixing "DemoApplication.java is a Non-Project File"

Chrise Nwachukwu — Thu, 24 Oct 2024 14:36:10 +0000

If you’re seeing the error "DemoApplication.java is a non-project file, only syntax errors are reported", it means your IDE isn’t recognizing your file as part of the project. You could try any of these:

Mark Directory as Source Root: Right-click the folder containing the file, then select Mark Directory as Sources Root.
Reimport the Project: Right-click pom.xml (Maven) or build.gradle (Gradle) and select Reimport.
Check Project SDK: Ensure the correct JDK is configured in Project Structure.
Ensure File Belongs to a Module: Make sure the file is included in a valid module within your project.

These steps should help your IDE recognize the file as part of your project. Let me know if it works!

Handling Resource Leaks with Scanner and System.in in Java

Chrise Nwachukwu — Fri, 18 Oct 2024 16:23:50 +0000

If you’ve worked with Java’s Scanner, you know it’s important to close it to avoid resource leaks—especially when reading from files. But when it comes to System.in, it's different.

Should You Close System.in?

You generally don’t want to close System.in because doing so will stop any future input. This can create issues if other parts of your program still need user input.

The Safe Solution: try-with-resources

Java’s try-with-resources makes it easy. It automatically closes the Scanner without closing System.in, allowing you to safely read user input.

Why Do IDEs Warn About Resource Leaks?

Some IDEs (like Eclipse or IntelliJ) might flag a potential resource leak with Scanner, treating all instances the same. This can be misleading, especially when using System.in, but you can confidently ignore these warnings.

Best Practices:

Use try-with-resources to ensure the Scanner is closed properly while keeping System.in open.
Avoid manually closing System.in; let the JVM handle it.

Example Code:

try (Scanner objName = new Scanner(System.in)) {
    System.out.println("What's your name?");
    String userName = objName.nextLine();

    System.out.println("Hello, " + userName + "!");
}

Why Going Back in Git Doesn't Have to Be Scary

Chrise Nwachukwu — Thu, 10 Oct 2024 16:18:24 +0000

If you've ever been working on a project - like I totally have this week - made some changes, and suddenly realized you've gone down the wrong path—don't panic. Git has your back, and rolling back to an earlier point isn’t as complicated as it might seem.

Fellow earthlings, we all make mistakes. Maybe it was a bug you couldn't squash, or maybe you just want to rewind and try a different approach. With Git, it’s more like hitting "undo" than wiping the slate clean forever.

*The "Just Looking Around" Option
*
Ever wish you could check out how things were in the good old days (aka, before your code went haywire)? You can "borrow" an old commit without changing anything in your current branch. It's like flipping through the pages of a photo album, but in code.

You can quickly do this with:

git checkout <commit-hash>

This is a great way to peek at a past version, without committing (pun intended) to any changes. When you’re done reminiscing, just hop back to the latest version of your branch.

*Going Back, But Not All the Way
*
Maybe you messed something up, but you don’t want to wipe out all your recent work. This is where Git's "reset" or "revert" options come in. You can pick the level of rollback you need—soft resets let you keep your changes, while hard resets are for those "just nuke it" moments.

But here's a tip: don't jump to hard resets too quickly. Git revert might be your better friend—it leaves a record of what happened and why you decided to undo it. Plus, it makes you look super organized.

*Branching Out
*
Ever wish you could split the timeline and try something different? Git makes it easy. You can create a whole new branch from a previous commit and work on a new feature or fix without messing with your main branch. It's a great way to experiment without risk.

*The Bottom Line
*
Git isn’t just about version control; it's about freedom. Freedom to make mistakes, test new ideas, and confidently go back in time if needed. So next time you feel stuck or stressed, remember: Git’s got you covered!