Section outline

    • girl fighting against AI with jiu-jitsu

    • Jiu‑Jitsu – Java

      Java Jiu‑Jitsu: Use Structure as Leverage. Control Complexity. Win Against AI.
      Training teens to build real software systems — not just small scripts.

      ✅ Start here (free)

      Start at Lesson 1 and train forward in short, clear micro‑presentations. Java is not “quick hacks” — it’s leverage through structure.

      1. Begin Lesson 1: Enter the Dojo: Why Java Still Wins
      2. Train the slides (one concept per screen)
      3. (Paid members) Take the drill quiz / challenge and record your score
      4. Repeat daily — belt by belt

      Goal: become the kind of developer who can handle big systems — the kind AI can’t easily replace with shallow, repetitive code.

      👨‍👩‍👧 Why this course matters (for parents)

      AI will replace repetitive, shallow coding first. Your teen wins by learning structured software development: clean logic, strong design, testing, and real-world engineering discipline.

      Java is used in serious systems (enterprise software, large applications, backend services), and Jiu‑Jitsu is the art of leverage: you don’t win by brute force — you win by structure, control, and technique.

      Parent benefit: your teen builds skills that transfer into real jobs: problem-solving, engineering thinking, and the ability to work inside large codebases. Paid membership adds measurable progress (scores + belt exams).

      🔥 For teens (win with leverage)

      Most people “code” by copying snippets. AI can do that faster than them. Your advantage is to become someone who understands systems: structure, design, debugging, testing, and control.

      • Short missions (bite‑size training, not long boring lectures)
      • Belts that prove you’re leveling up
      • Retakes allowed (best score counts — improve without fear)
      • Real power: OOP, collections, streams, concurrency — the skills behind real software

      Challenge: earn White Belt (setup + first control) and build momentum. If you like this dojo, send it to a friend who wants to win too.

      🧠 What your teen will learn (high value targets)
      • Java 17 + IntelliJ setup (modern Java workflow)
      • Core syntax: variables, types, expressions, conditionals, loops
      • Methods + overloading (reusable thinking)
      • OOP: classes, encapsulation, constructors, inheritance, polymorphism
      • Data: arrays, lists, sets, maps, enums
      • Modern Java: generics, lambdas, streams, optionals
      • Professional topics: immutability, I/O, regex, concurrency
      • Real-world systems: databases, networking
      • Survival skills: debugging + unit testing
      🥋 Belt map (Jiu‑Jitsu ranks)
      • White Belt — Lessons 1–3: Setup & First Control
      • Yellow Belt — Lessons 4–9: Fundamentals
      • Orange Belt — Lessons 10–12: OOP Foundations
      • Green Belt — Lessons 13–14: Leverage & Design
      • Blue Belt — Lessons 15–16: Data Handling
      • Brown Belt — Lessons 17–22: Professional Java
      • Black Belt — Lessons 23–28: Systems Builder

      Belts are proof of progress. Parents get visibility. Teens get momentum.

      🏷️ Free vs Dojo Membership (paid)

      Free (Guest Training)

      • Access the free lesson content (training slides / micro‑presentations)
      • See the curriculum and belt map
      • Try sample drills (optional)

      Dojo Membership (Paid)

      • Full access to all drills, quizzes, and belt tests
      • Belt tracking and certificates
      • Parent progress tracking (scores + activity history)

      Founders / Inauguration Price: $5 per course for 30 days (about the price of a coffee). This is the launch price while the dojo is expanding — as more belts, exams, and courses are added, the price will rise.

      Optional later: “Master Check‑Ins” for motivation/accountability (not technical Q&A).

      📚 Curriculum (Training Forms)
      1. Enter the Dojo: Why Java Still Wins
      2. Gear Up: Install Java 17 + IntelliJ
      3. Hello World + Errors
      4. Variables, Types, and Precision
      5. Operators, Expressions, and Clean Code
      6. Conditionals that Don’t Lie
      7. Switch + Loops + Real Flow
      8. Input, Parsing, and Exceptions
      9. Methods + Overloading
      10. Classes, Objects, and Encapsulation
      11. Constructors, Records, and Modern Objects
      12. Inheritance + Overriding + java.lang.Object
      13. Composition (HAS-A) and Real Modeling
      14. Polymorphism in Action
      15. Arrays + 2D Arrays
      16. Lists, Iterators, Autoboxing, Enums
      17. Abstraction + Interfaces
      18. Generics + Comparators
      19. Lambdas + Method References
      20. Collections: Sets + Maps at Scale
      21. Streams + Optionals
      22. Immutability + final + Defensive Coding
      23. Regex + File I/O + Serialization
      24. Concurrency and Multithreading
      25. Databases (JDBC + JPA Concepts)
      26. Networking (TCP/UDP/HTTP/WebSockets)
      27. Debugging + Unit Testing (JUnit)
      28. Optional: JavaFX UI + Modules (JPMS)

      Disclaimer: This course provides education and training and cannot guarantee a specific job outcome.

      ✅ Belt Test Rules (read before testing)

      Passing score: 80%
      Retries: Unlimited
      Score policy: Best score counts

      How belts are earned

      1. Training Drills (Lesson Quizzes / Challenges) — short quizzes after lessons
      2. Belt Test (Rank Exam) — a larger exam covering the belt section

      Eligibility

      You must complete the drills for the lessons in that belt section to unlock the belt test.

      Integrity (important)

      • This is You vs AI: no AI tools or outside help during belt tests.
      • Drills are for learning; belt tests are for proof.
      • Parents are encouraged to be present or nearby during belt tests.

      Disclaimer: Belts and certificates recognize course progress and assessment performance. They do not guarantee a job outcome.