Forem: Pratiksha Dixit

Why I Avoid `java.util.Date` and Use `java.time` Instead

Pratiksha Dixit — Wed, 16 Jul 2025 14:49:00 +0000

When I first started working with dates in Java, I came across java.util.Date, Calendar, and java.sql.Date. At first, I thought they were the standard way of doing things. But the more I used them, the more confusing and frustrating they became.

Here’s what I learned as a student and why I now use the java.time package for all my date-related logic.

1. `java.util.Date` Is Mutable and Confusing

One big issue with java.util.Date is that it’s mutable. That means if you pass it to a method, that method can change it without you even realizing it. This creates unexpected bugs.

Also, the way it handles years and months is just weird. For example:

Date d = new Date(2025, 7, 16); // Actually means year 3925, not 2025

(Yes, it adds 1900 to the year. Why? No idea.)

2. `Calendar` Was Meant to Fix It... But It Didn't

So Java introduced Calendar to fix the problems in Date. But honestly, it’s even harder to use. The syntax is bulky and just feels wrong:

java Calendar cal = Calendar.getInstance(); cal.set(2024, Calendar.JULY, 16); Date date = cal.getTime();

There’s too much going on for something that should be simple.

3. `java.sql.Date` Is Only for JDBC

At one point, I tried using java.sql.Date everywhere. But I found out it's only meant for JDBC, not for general use. If you use it in your normal application logic, you’re basically mixing database code with your core logic — and that’s not good practice.

4. The Better Way — `java.time.*`

Then I discovered java.time (available since Java 8). It just makes sense. Everything is clean, immutable, and easy to work with.

java LocalDate today = LocalDate.now(); LocalDate dob = LocalDate.of(2000, 1, 1); Period age = Period.between(dob, today);

This is how I expect a date API to work.

And if I need to use it with JDBC, I can convert it:

java LocalDate localDate = LocalDate.now(); java.sql.Date sqlDate = java.sql.Date.valueOf(localDate);

Final Thoughts

If you're a beginner like me, I really suggest skipping the old date/time classes unless you're working with legacy code. Stick to java.time — it’s clean, safe, and built for modern Java.

Just wanted to share this little realization in case it helps someone else struggling with Java date handling like I did.

Let me know if you faced something similar or found your own way to handle dates!

I Feel Behind in Programming... Am I the Only One?

Pratiksha Dixit — Fri, 11 Jul 2025 16:14:09 +0000

Because no one really talks about the silent phases of self-doubt, confusion, and slow progress.

Hey DEV community 👋,

This post isn’t about frameworks, tools, or algorithms.
It’s about that feeling you get when you open your laptop and ask yourself—

“Am I even doing enough?”
“Why am I not as fast as others?”
“Is it too late for me to become something?”

If you’ve ever felt like you're lagging behind in programming, your career, or just life in general—you're not alone.
I’ve been there. Maybe I still am. Maybe we all are, at different stages.

🌀 Let’s talk about the “invisible phases” of growth:

When you spend weeks learning, but build nothing.
When you doubt if you're even on the right track.
When your friends seem way ahead, and you feel... stuck.

You scroll LinkedIn or DEV posts and see success stories—
Meanwhile, you’re figuring out how to write a clean loop or push code to GitHub.

But here's the thing no one says enough:

Not every season is about output. Some are just about becoming.

🎓 To every student, learner, or career switcher reading this:

You’re not late. You’re on your path.
Everyone’s timeline is different—even if the internet says otherwise.
You’re allowed to feel lost, slow, unsure… and still be on track.

💬 Let’s open up:

What do you wish someone had told you earlier in your learning journey?
Or…
If you could go back in time, what would you say to your “just-starting-out” self?

Drop it in the comments—
Whether it’s a one-line reminder or a full story, your words matter.
You never know who needs to hear exactly your experience today.

Let’s be real. Let’s be kind. Let’s learn out loud.

"Why Every Beginner Should Build Console-Based Projects Before Moving to Backend Frameworks"

Pratiksha Dixit — Fri, 11 Jul 2025 04:28:32 +0000

Before jumping into server-side development with frameworks like Spring Boot or building APIs, it’s important to get hands-on with console-based projects.

Console applications may seem basic, but they help beginners understand how the core logic of a software system works — without the extra complexity of tools, servers, or frontends.

🧠 Why Start with Console-Based Projects?

Here are a few solid reasons:

1. 💡 Focus is on Logic, Not Setup

In frameworks, there’s a lot of setup — annotations, configurations, and external dependencies. But in console apps, the focus stays on writing logic.

It’s all about how the program flows, how data is managed, and how user input is handled.

2. 🧱 Strong Foundation in Core Java

Most console-based apps are written using core Java concepts:

Classes and Objects
Collections like ArrayList, Map, etc.
Input/output handling using Scanner
Working with LocalDate and other utility classes

This builds confidence before moving to more advanced topics.

3. 🔄 Real-World Flow Without a UI

Even though there’s no GUI, one can still create full workflows like:

Adding new records
Searching/filtering data
Updating and deleting records
Performing date-based logic (like warranty expiry)

These workflows are the same ones found in actual backend systems, just without the UI or API layer.

4. 🧪 Easier to Debug and Test

Since everything runs in the terminal, it’s easier to understand what the code is doing line by line.

No need to worry about servers crashing or tools misbehaving. The focus remains on problem-solving.

✅ Sample Project: Product Management System

A great example of a console project for practice is a Product Management System.

It can include features like:

Add new product
View all products
Search by product ID or location
Update warranty date
Find products with expired warranty
Delete product by name

Each product might contain:

Product ID, name, version, type
Purchase date, warranty expiry date
Storage location

Using ArrayList and Java Stream API, this kind of project helps practice filtering, updating, and displaying structured data — just like it’s done in real apps.

🔁 What Comes After Console Apps?

Once console-based logic is mastered, it becomes much easier to:

Build REST APIs using Spring Boot
Store data in databases (like MySQL, PostgreSQL)
Add a frontend (HTML, React, etc.)
Use tools like Postman for testing

🎯 Final Thoughts

Frameworks and tools are important — but without understanding the logic behind them, things can get confusing fast.

That’s why console-based Java projects are an ideal first step for anyone preparing to become a backend developer.

They make the path smoother by building a strong base in logic and problem-solving.

Want to try something today? Build a console app that manages products, books, students, or even tasks.

Once that feels easy — moving to Spring Boot or any framework will feel much more natural.

Programming Needs Patience — More Than You Think

Pratiksha Dixit — Tue, 01 Jul 2025 14:20:59 +0000

Introduction

When I started programming, I thought it was all about writing code and solving problems quickly.

But I was wrong.

The biggest part of programming is not just writing code. It’s fixing errors. It’s solving bugs. It’s waiting and trying again when things don’t work.

That’s when I realized — programming needs patience.

Why Patience is Important in Programming

1. Bugs Are a Part of the Process

No one writes perfect code in one go. Even expert developers face bugs.
The important thing is not to panic. Take your time. Understand the error. Try again.

2. It Takes Time to Learn

Sometimes, the code is fine, but we don’t understand how it works.
It’s okay. Learning takes time. Reading documentation and trying small examples really helps.

3. Frustration Makes It Worse

When we get angry or tired, we make more mistakes.
Patience helps us stay calm and think clearly. A cool mind finds better solutions.

Tips to Stay Patient

Take Short Breaks
If you’re stuck for too long, walk away. Come back after 10–15 minutes. It helps you think better.
Use Google and Stack Overflow Smartly
Don’t copy-paste everything. Read carefully. Try to understand the solution first.
Celebrate Small Wins
Even if you fix one small error, celebrate it. It keeps you motivated.
Write Down Errors You Solved
Make a note of problems and how you fixed them. It will save time in the future.

The Truth: It's Not a Race

You don’t need to be the fastest coder. You need to be the one who doesn’t give up.
Patience will make you better, even if it feels slow.

Conclusion

If you’re stuck on a bug today, remember:

"Good programmers don’t know everything. They just don’t quit easily."

Keep trying. Stay calm. Be patient. That’s how real programmers grow.

Struggling with Spring MVC XML config? This post solves the exact errors I faced—step by step.

Pratiksha Dixit — Fri, 27 Jun 2025 17:28:42 +0000

Pratiksha Dixit

Jun 27 '25

⚠️ How I Solved the Most Common XML Configuration Errors in Spring MVC (Spring 6+)

#webdev #spring #programming #beginners

Comments

3 min read

⚠️ How I Solved the Most Common XML Configuration Errors in Spring MVC (Spring 6+)

Pratiksha Dixit — Fri, 27 Jun 2025 17:26:09 +0000

🚀 A beginner’s survival guide to making Spring MVC work with XML configuration in 2024–25.

📌 Background

As a student and Java learner, I decided to build a Spring MVC project using Spring 6.2.7 with XML configuration (web.xml, springDispatcherServlet-servlet.xml, etc.).

But it wasn't easy! I ran into multiple errors—schema failures, prefix binding issues, Tomcat errors—almost everything a beginner could face.

In this post, I’m sharing each error I faced and how I fixed it, so you don’t waste hours the way I did.

❌ 1. `schema_reference.4` and `cvc-elt.1.a` Errors

❗ Error:


schema\_reference.4: Failed to read schema document '[http://www.springframework.org/schema/beans/spring-beans.xsd](http://www.springframework.org/schema/beans/spring-beans.xsd)'...
cvc-elt.1.a: Cannot find the declaration of element 'beans'

✅ Fix: Use HTTPS URLs for schema declarations

Replace the HTTP links with HTTPS in the <beans> header:

xml <beans xmlns="https://www.springframework.org/schema/beans" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:context="https://www.springframework.org/schema/context" xmlns:mvc="https://www.springframework.org/schema/mvc" xsi:schemaLocation=" https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">`

💡 Spring 5.3+ supports only HTTPS schema resolution from the classpath.

❌ 2. `The prefix "mvc" for element "mvc:annotation-driven" is not bound`

❗ Error:

`xml <mvc:annotation-driven/> `

Gives:

` The prefix "mvc" for element "mvc:annotation-driven" is not bound. `

✅ Fix: Add `xmlns:mvc` and its schema location

Make sure this is added in your XML:

`xml xmlns:mvc="https://www.springframework.org/schema/mvc" `

And in xsi:schemaLocation:

`xml https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd `

❌ 3. Tomcat Error: `The requested resource [/springMVC/] is not available`

✅ Fix checklist:

Check if web.xml contains correct servlet mapping:

`xml

springDispatcherServlet
org.springframework.web.servlet.DispatcherServlet
1

springDispatcherServlet
/

`

Ensure correct location:
Your springDispatcherServlet-servlet.xml must be inside /WEB-INF/
Project must be built correctly and deployed properly to Tomcat.

❌ 4. `Cannot invoke "Object.hashCode()" because "key" is null` in Jakarta Tomcat

✅ Fix:

Double-check web.xml mapping.
Use compatible versions of:
- Spring 6+
- Jakarta EE 10+
- Tomcat 10+

Mixing old versions causes reflection or namespace binding failures.

❌ 5. External Schema Download Disabled

If you're behind a proxy or working offline, Eclipse/STS cannot fetch .xsd files online.

✅ Fix Options:

Use HTTPS URLs so Spring resolves schemas from its own JAR files
Or: Add a manual mapping in Eclipse → XML Catalog
Or: Disable XML validation temporarily from Project → Properties → Validation

💡 Key Lessons I Learned

✅ Always use HTTPS URLs for all Spring XML schemas.
✅ Ensure schemaLocation URLs are on the same line (Eclipse hates broken lines).
✅ Use consistent and compatible Spring versions (don’t mix Spring 5 with 6).
✅ Prefer annotation-based config long-term—but mastering XML helps debug legacy code!

🧠 Final Thoughts

Dealing with XML in Spring MVC might feel outdated, but it's still worth understanding. Many enterprise projects still use XML config.

By solving these issues step-by-step, I learned how Spring’s internal schema resolution works, how Tomcat processes web.xml, and how to troubleshoot like a real developer.

🗨️ Have you faced similar XML issues while learning Spring?
Leave a comment and let's connect!

Fixing 'Dynamic Web Module cannot be uninstalled' Error in Spring Boot Maven Project (Eclipse)

Pratiksha Dixit — Sun, 22 Jun 2025 08:42:03 +0000

Introduction:

Today, I encountered a frustrating but educational error while working on a Spring Boot project in Eclipse. The error message read:

"One or more constraints have not been satisfied. Utility Module and Dynamic Web Module 6.0 cannot both be selected."

If you're new to Spring Boot or Maven, this might confuse you — here’s what it means and how I resolved it.

🔥 The Root of the Problem:

Spring Boot is designed to run as a standalone JAR with an embedded server (like Tomcat). It doesn't need or support legacy Java EE modules like the Dynamic Web Module.

Eclipse, however, sometimes misinterprets your project structure and adds these facets automatically, causing conflicts like:

Dynamic Web Module cannot be removed
Utility Module conflicts with Web Module
Spring Boot controllers not working

✅ Step-by-Step Solution:

Delete Eclipse’s Facet Metadata:

.settings/, .project, and .classpath from the project folder

Re-import Project:

File → Import → Maven → Existing Maven Project

Ensure Correct Maven Configuration:

   <packaging>jar</packaging>

Run the Project with:

mvn spring-boot:run
OR Run As → Java Application on your main class

Fix the Controller:


java
   @Controller
   public class HomeController {
       @RequestMapping("/")
       @ResponseBody
       public String home() {
           System.out.println("Hit HomeController");
           return "Welcome to Spring Boot!";
       }
   }

### 🔎 Lesson Learned:

* Don’t use `Dynamic Web Module` with Spring Boot
* Use embedded server – not external WAR deployment unless required
* Always check controller method return types and annotations
* Spring Boot thrives on simplicity — don’t force Java EE structures into it

### 💬 Final Words:

I faced this issue for hours and now fully understand why Spring Boot doesn't need the overhead of servlet container configuration. If you're facing the same — **delete Eclipse metadata, use pure Maven, and let Spring Boot do its magic.**

Restarting My Java Journey: From Exam-Oriented Learning to Becoming a Real Developer

Pratiksha Dixit — Sun, 22 Jun 2025 08:33:26 +0000

Introduction

Last year, I began my journey into Java programming. Like many students, I focused mainly on what was taught in the university syllabus—just enough to pass exams. I didn’t explore Java deeply, nor did I truly understand how to approach learning programming as a skill, rather than a subject.

Now, I’ve decided to start over, not because I failed, but because I finally understand what I want—to become a professional Java developer who writes clean, working code and can build real-world applications confidently.

Where I Was

When I first learned Java, my focus was limited to:

Clearing university exams
Memorizing definitions and syntax
Completing assignments just to get grades

I built a small project using Servlets, JSP, and Hibernate, but deep down, I felt unsure about how much I actually understood. I didn’t have that confidence in my skills.

What Changed?

What changed was my mindset.

I no longer want to be just a student who knows Java basics. I want to be a problem solver, a project builder, and someone who understands why and how things work in Java and programming in general.

So, I made a decision:

I would start again, from the basics—but this time, with purpose.

My New Approach

Here’s how I’m learning Java now:

1. Core Java – With a Fresh Mind

I’ve gone back to OOPs concepts, Exception Handling, File I/O, and Collections.
But now, I don’t just read; I write code, debug, and ask questions.

2. Advanced Java – With Real Practice

Learning Servlets, JSP, and JDBC by building small modules.
Understanding how web applications actually work, not just following tutorials.

3. Hibernate & Spring – Not Just Setup, But Flow

I already built a mini project with Hibernate + JSP + Servlet.
Now I’m reviewing it again to truly understand the data flow, annotations, and lifecycle.

4. Learning Beyond Java

I want to grow as a developer, not just as a Java coder.
So, I’m also learning about software development principles, problem-solving, communication, aptitude, and preparing for interviews.

Why I’m Writing This Blog

I’m writing this blog for two reasons:

To keep myself accountable.

Writing about my journey helps me track progress and reflect.
To inspire other beginners.

If you're also someone who learned Java for exams but now wants to become a real developer, you're not alone. Restarting isn’t failure—it’s the first step to growth.

What’s Next?

I’ve started a 21-Day Preparation Challenge for:

Java Concepts (Core + Advanced)
Aptitude and Problem Solving
Communication & Group Discussion Skills
Interview Readiness

I'll be posting weekly updates about what I’m learning, what challenges I face, and how I’m preparing myself for the job market.

Final Thoughts

It's okay to not know everything in the beginning. What matters is your intent to improve, your consistency, and your honesty with yourself.

This is my journey—from syllabus learning to skill-based learning. If you're on a similar path, feel free to connect or share your experience in the comments.

Let’s grow together.

Forem: Pratiksha Dixit

Why I Avoid `java.util.Date` and Use `java.time` Instead

1. java.util.Date Is Mutable and Confusing

2. Calendar Was Meant to Fix It... But It Didn't

3. java.sql.Date Is Only for JDBC

4. The Better Way — java.time.*

Final Thoughts

I Feel Behind in Programming... Am I the Only One?

🌀 Let’s talk about the “invisible phases” of growth:

🎓 To every student, learner, or career switcher reading this:

💬 Let’s open up:

"Why Every Beginner Should Build Console-Based Projects Before Moving to Backend Frameworks"

🧠 Why Start with Console-Based Projects?

1. 💡 Focus is on Logic, Not Setup

2. 🧱 Strong Foundation in Core Java

3. 🔄 Real-World Flow Without a UI

4. 🧪 Easier to Debug and Test

✅ Sample Project: Product Management System

🔁 What Comes After Console Apps?

🎯 Final Thoughts

Programming Needs Patience — More Than You Think

Introduction

Why Patience is Important in Programming

1. Bugs Are a Part of the Process

2. It Takes Time to Learn

3. Frustration Makes It Worse

Tips to Stay Patient

The Truth: It's Not a Race

Conclusion

Struggling with Spring MVC XML config? This post solves the exact errors I faced—step by step.

⚠️ How I Solved the Most Common XML Configuration Errors in Spring MVC (Spring 6+)

⚠️ How I Solved the Most Common XML Configuration Errors in Spring MVC (Spring 6+)

📌 Background

❌ 1. schema_reference.4 and cvc-elt.1.a Errors

❗ Error:

✅ Fix: Use HTTPS URLs for schema declarations

❌ 2. The prefix "mvc" for element "mvc:annotation-driven" is not bound

❗ Error:

✅ Fix: Add xmlns:mvc and its schema location

❌ 3. Tomcat Error: The requested resource [/springMVC/] is not available

✅ Fix checklist:

❌ 4. Cannot invoke "Object.hashCode()" because "key" is null in Jakarta Tomcat

✅ Fix:

❌ 5. External Schema Download Disabled

✅ Fix Options:

💡 Key Lessons I Learned

🧠 Final Thoughts

Fixing 'Dynamic Web Module cannot be uninstalled' Error in Spring Boot Maven Project (Eclipse)

🔥 The Root of the Problem:

✅ Step-by-Step Solution:

Restarting My Java Journey: From Exam-Oriented Learning to Becoming a Real Developer

Introduction

Where I Was

What Changed?

My New Approach

1. Core Java – With a Fresh Mind

2. Advanced Java – With Real Practice

3. Hibernate & Spring – Not Just Setup, But Flow

4. Learning Beyond Java

Why I’m Writing This Blog

What’s Next?

Final Thoughts

1. `java.util.Date` Is Mutable and Confusing

2. `Calendar` Was Meant to Fix It... But It Didn't

3. `java.sql.Date` Is Only for JDBC

4. The Better Way — `java.time.*`

❌ 1. `schema_reference.4` and `cvc-elt.1.a` Errors

❌ 2. `The prefix "mvc" for element "mvc:annotation-driven" is not bound`

✅ Fix: Add `xmlns:mvc` and its schema location

❌ 3. Tomcat Error: `The requested resource [/springMVC/] is not available`

❌ 4. `Cannot invoke "Object.hashCode()" because "key" is null` in Jakarta Tomcat