Rung 1 — The 50 Programs Repo

Target month: Shipped by end of M2 = end of August 2026 Calendar deadline: August 31, 2026 Phase alignment: Phase 01 — Java Fundamentals Refresh Signal level: Beginner-accessible → shows commitment, fluency, and that you can actually finish something

What It Is

A single public GitHub repository containing all 50 programs from the challenge in 01_java_fundamentals_refresh/05_50_programs_challenge.md. Each program lives in its own file inside a package that matches its tier (warmup, fluency, combined, expert). Each program has:

  • A short README.md at the top of its folder describing what it tests

  • A main method you can run

  • At least one JUnit 5 test (even trivial programs — this builds the habit)

  • A commit message that names the concept it exercises

The repo has a top-level README.md that is a checklist table — 50 rows, each with a link to the program, the concepts it exercises, and the time it took you to write it. When someone opens this repo, the first thing they see is a table with 50 green checkmarks.

This is not an impressive project. It is not supposed to be. It is the “hello, I exist and I finished something” rung at the base of the ladder. Every other rung sits on top of it.

Where To Publish

  • Repo: github.com/RaghulR2003/java-50-drills (or a name you prefer — java-fluency-drills, modern-java-50 — pick one and stick with it)

  • Visibility: Public from commit #1

  • Pinned: Pin it on your GitHub profile the day you push commit #1, not the day you finish. The commit graph itself is part of the signal.

  • Announced: Single LinkedIn post on the day you ship program #50. Not a series of posts. One post, one graphic, one sentence.

Acceptance Criteria

You are done when all of these are true:

  • Repo exists at a public URL, pinned on your GitHub profile

  • All 50 programs from the challenge file are in the repo, each compilable and runnable

  • Every program has at least one JUnit 5 test, even if trivial

  • Top-level README.md has a 50-row table with links, concepts, and time-taken column

  • GitHub Actions CI runs mvn test (or gradle test) on push and shows a green badge in the README

  • Commit history has at least 25 dated commits spread across at least 20 different days in July-August 2026 (no single “megacommit” dumps)

  • The repo builds on a fresh clone with a single command (documented in README)

  • Zero AI-generated code. You typed every character. This is a rule you enforce on yourself.

Signal It Sends

To an study partner scrolling your profile:

  • You finish things. Fifty programs is not glamorous, but “finished” beats “ambitious and abandoned” every time.

  • You know modern Java. They’ll click into program #17 (Sealed Shape Hierarchy) or #25 (Pattern Matching Calculator) and see idiomatic Java 21, not Java 8.

  • You test your code. Even trivial tests signal that testing is your default posture, not an afterthought.

  • You care about tooling. CI badge in the README says “I set up the pipeline before I wrote the code.”

To yourself: you now have proof that you can carry a 6-8 week commitment across the finish line. This matters more for the rungs above than the signal it sends outward.

Common Failure Modes

  • The Megacommit Trap. You write all 50 programs in a Google Doc offline, then push them in a single commit. The commit graph is one green square. This is worse than not doing the challenge because it screams inauthentic to anyone who looks. Commit as you go — one program per commit, ideally.

  • The Perfectionism Trap. You spend 3 hours on program #4 refactoring it until it’s “portfolio quality.” Stop. The rung is fifty programs finished, not five programs polished. Ship, then iterate.

  • The Silent Ship. You finish the repo, never tell anyone, never pin it. It exists but produces zero signal. The ship-and-tell moment is part of the rung — write the LinkedIn post the day you push program #50.

  • The AI Slip. You get stuck on program #32 (thread-safe counter), open Claude “just for a hint,” paste the answer. Now the muscle memory this rung was supposed to build is fake. If you slip once, delete the program and redo it from a blank file.

  • Skipping the tests. “It’s just a hello world program, tests are silly here.” No. The habit is what matters. Two lines of JUnit is enough.

Time Estimate

  • Programs 1-15 (warm-up): 15 min average × 15 = ~4 hours

  • Programs 16-30 (fluency): 25 min average × 15 = ~6 hours

  • Programs 31-42 (combined): 45 min average × 12 = ~9 hours

  • Programs 43-50 (expert): 60-90 min average × 8 = ~10 hours

  • Test writing, README updates, CI setup: ~8 hours

  • Total: ~37 hours of pure coding, spread over 6-8 weeks

Realistically at 10-15 hrs/week with everything else in Phase 01 going on, this consumes ~40% of your Phase 01 time. Budget accordingly.

Prerequisites

  • All files in 01_java_fundamentals_refresh/ read and worked through, at least to the point where you understand the concepts in each program’s “What It Tests” column

  • JDK 21 installed, IntelliJ IDEA (or your editor) set up

  • Maven or Gradle familiarity (Maven is easier for this rung; you’ll switch to Gradle later)

  • Git and GitHub CLI set up, gh command working from terminal

Stretch Goals (Optional, Only If M2 Ends Early)

  1. Add a benchmarking harness for programs 32, 33, 34 (thread-safe counter, virtual thread fetcher, LRU cache). Publish results as a chart in the README. This gives you a soft preview of what Rung 5 will demand.

  2. Write one dev.to or Hashnode post titled “50 Java programs, no AI, one month — here’s what I re-learned.” This becomes your first blog post and preloads Rung 4’s blog-writing muscle.

  3. Add a Makefile with targets like make run PROGRAM=17 to let anyone (or a recruiter) run any single program without knowing your build layout.

Return to README.md · Next: 02_rung2_dsa_github.md