CodeDrill：透過刻意練習掌握 Java Collections 與 DSA

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Meet CodeDrill — a deep learning and practice platform designed to help developers go beyond memorizing Java Collections and Data Structures & Algorithms (DSA).

Learning DSA isn't just about solving a problem once. It's about understanding why a solution works, knowing what's happening under the hood, and remembering those concepts when they matter most — during interviews, debugging sessions, and real-world development.

That's the problem I'm building CodeDrill to solve.

CodeDrill focuses on two important areas:

Java Collections internals: Understand memory models, HashMap bucketing, concurrency safety, iterator contracts, and the behavior of core collection classes.
DSA practice: Build problem-solving skills through structured questions, difficulty progression, and deliberate practice.
Spaced repetition: Use an SM-2-based revision strategy to help learners revisit concepts instead of forgetting them after a single study session.
Progress and mastery tracking: Turn learning progress and weak topics into actionable revision priorities.
Interactive coding: Integrate a browser-based coding experience with Monaco and a sandboxed Java execution architecture.

The philosophy is simple: don't just solve more problems; build knowledge that sticks.

CodeDrill is for students preparing for technical interviews, developers strengthening their Java fundamentals, and anyone tired of repeatedly learning the same concepts from scratch.

The long-term goal is to make consistent, focused practice easier — so developers can spend less time figuring out what to study next and more time actually learning.

Demo

🚧 A live demo or video walkthrough can be added here once available.

GitHub Repository: ashishkr710/CodeDrill

The repository includes the project specifications, architecture documentation, API contracts, data models, development roadmap, and separate frontend and backend applications.

Code

🔗 Explore the source code: CodeDrill on GitHub

The project follows a modular, two-application architecture:

Frontend: React 19, TypeScript, Vite, Tailwind CSS, Zustand, and Monaco Editor.
Backend: Node.js, Express, TypeScript, and MongoDB.
Supporting infrastructure: Docker Compose, Redis, and Judge0 Community Edition for isolated code execution.
Learning engine: Spaced repetition, mastery tracking, and weak-topic remediation.

One of my core architectural decisions is that untrusted code must never execute inside the API process. Code execution is delegated to a separate sandboxing service rather than allowing submitted code to run directly in the backend.

I've also documented the system before implementation through dedicated specifications for architecture, security, data models, API behavior, testing, and development milestones.

The intention is to build something maintainable, testable, and open to contributions — not just another collection of coding questions.

How I Built It

I approached CodeDrill as an engineering project first: define the learning experience, document the architecture, establish security boundaries, and then organize the implementation into manageable milestones.

1. Designed the learning workflow

I structured the platform around the idea that learning should be continuous rather than a one-time activity.

The revision system uses an SM-2-based spaced repetition approach to help determine when a learner should revisit a concept. Mastery tracking and weak-topic remediation are designed to make practice more focused.

2. Chose a modern TypeScript stack

I chose TypeScript across the frontend and backend to keep contracts consistent and catch errors early. The project emphasizes strict typing and avoiding any.

React and Monaco provide the foundation for the coding experience, while Express and MongoDB support the API and learning data.

3. Treated code execution as a security boundary

Running arbitrary Java code introduces real security risks. That's why the architecture separates code execution from the main API and uses Judge0 Community Edition as the execution service.

The intended deployment uses container isolation and resource restrictions rather than trusting submitted code.

4. Used documentation as an implementation tool

Before moving through implementation milestones, I organized the technical decisions into dedicated documents, including:

Product requirements and architecture decisions
Database schemas and API specifications
Backend security and frontend design
Code execution and testing strategies
Content planning and progress algorithms
Development milestones and engineering conventions

This makes it easier to reason about individual features, validate design decisions, and give future contributors a clear starting point.

5. Kept the AI direction open

For a platform like CodeDrill, open-source AI offers interesting possibilities: explaining tricky collection internals, generating alternative approaches to algorithm problems, creating hints that preserve active recall, and helping learners understand why a solution fails.

These are potential extensions of the platform, rather than features I'm claiming are already implemented. The goal is to explore AI in a way that supports learning instead of simply handing users the answers.

Why Does Open Innovation Matter?

I want CodeDrill to be more than a personal learning tool. I want its architecture and learning resources to be understandable, extensible, and open to community contributions.

Open innovation matters here for three reasons.

1. Learning tools should be adaptable.

Different learners struggle with different concepts. An open architecture makes it easier for contributors to add questions, improve explanations, expand topic taxonomies, and experiment with alternative learning workflows.

2. AI shouldn't have to be a black box.

Open-weight models and self-hosted inference can give developers greater control over model selection, deployment, privacy, and experimentation. They also make it possible to explore AI-assisted learning without making every feature dependent on a single proprietary provider.

For a learning platform, that flexibility could be valuable when experimenting with hints, explanations, and personalized revision.

3. Security and trust matter as much as intelligence.

An AI-powered coding platform still needs clear security boundaries, reliable evaluation, and predictable behavior. Open development makes architectural decisions easier to inspect and discuss, while a sandboxed execution service helps isolate untrusted code.

For me, open innovation means making it easier for others to inspect, improve, challenge, and build upon the work.

My Agent Session

I haven't linked a shareable agent session yet.

Once available, this section can include a DevRelay session showing how an AI coding agent helped with architecture exploration, implementation, testing, or documentation.

The Lazy Payoff

The real payoff I'm aiming for is reducing the mental overhead of learning consistently.

Instead of repeatedly asking:

What should I revise today?
Which Java Collection behavior do I keep forgetting?
Which DSA topics need more practice?
When should I revisit a concept I learned last week?

CodeDrill is designed to make revision and progress tracking more systematic.

Spaced repetition helps organize when to revisit material, while weak-topic remediation helps identify what deserves attention.

The idea is to replace some of the friction of planning a study session with a more structured workflow.

I haven't measured actual time savings yet, so I won't claim a specific number. For now, the goal is to make deliberate practice easier to sustain over weeks and months.

Because the best learning system isn't the one that helps you study intensely for one day. It's the one that helps you keep showing up.

Prize Categories

I'll select the applicable partner categories based on the open-source AI tools and agent workflows actually used in the project.

Update this section before publishing with the exact eligible categories from the challenge page.

Building CodeDrill has been an opportunity to combine Java fundamentals, learning science, secure code execution, and full-stack engineering into one project.

I'm excited about the possibility of making technical learning more structured, transparent, and community-driven.

If you're interested in Java Collections internals, DSA, spaced repetition, or developer learning tools, check out the repository and join me in building it.

⭐ Explore CodeDrill: https://github.com/ashishkr710/CodeDrill.git

Let's make learning a habit, not a sprint.