Section outline

• Select section General

  Collapse Expand

  General

  Collapse all Expand all

  • Select activity Welcome to Iaido - Algorithms (FREE version)

    

  • Select activity Course Summary for Iaido – Algorithms

    Iaido – Algorithms

    AI can write code fast — but it can’t guarantee it’s correct, efficient, or scalable.
    Iaido is the art of the clean draw: one precise motion, no wasted movement. Algorithms are the same: the difference between “it works” and “it works fast, every time.”

    ---

    ✅ Start here (free)

    Start at Lesson 1 and move forward. Each lesson is broken into micro‑presentations (short, clear screens — one concept at a time). This makes daily training realistic even with school and distractions.

    1. Learn: read the micro‑presentations (short + focused)
    2. (Paid) Drill: take the quiz and record your score
    3. Prove: pass the belt exam to rank up

    Iaido rule: no wasted motion. In algorithms, wasted steps become wasted hours at scale.

    👨‍👩‍👧 For parents: why this course matters

    AI is commoditizing basic coding. The advantage shifts to teens who can design correct solutions, analyze efficiency, choose the right data structures, and defend their reasoning under pressure.

    Algorithms are a durable foundation behind software engineering interviews, competitive problem solving, and real system performance. Your teen isn’t just learning “how to code” — they’re learning how to think like a computer scientist.

    Disclaimer: This course builds skills and discipline. It does not guarantee jobs or outcomes.

    🎯 For teens: the mission

    Train like Iaido: calm, precise, and efficient. AI can generate answers — your job is to choose the right one, prove it, and make it scale.

    • You vs AI: don’t trust “looks correct” — verify correctness
    • Speed with precision: learn patterns that cut runtime
    • Edge cases: handle the weird inputs that break weak code
    • Belts: show real proof, not just “watched content”

    If you like brain‑combat, send this course to a friend who loves puzzles and “hard mode” thinking.

    🧠 What your teen will learn

    • Time and space complexity (what scales, what breaks)
    • Recursion and problem decomposition
    • Core data structures: arrays, linked lists, stacks, queues, trees, heaps, graphs
    • Hashing and fast lookup strategies
    • Algorithm paradigms: divide & conquer, greedy, dynamic programming, backtracking
    • How to verify correctness and handle edge cases

    🥋 How training works (simple + structured)

    • Short training slides (micro‑presentations; one idea per screen)
    • (Paid) Auto‑graded drills/quizzes with retries
    • (Paid) Belt exams to prove progress
    • Moodle tracking: scores, completion, progress history
    • No technical Q&A required — progress is designed to be independent

    This is a dojo: train → drill → test → rank up.

    🥋 Belt map

    Lesson ranges refer to the course training forms.

    • White Belt (Lessons 1–4) — Sheath & Stance
      Algorithm mindset, memory basics, ADT thinking, and complexity fundamentals.
    • Yellow Belt (Lessons 5–6) — The First Draw: Recursion Control
      Recursion tracing and recurrence relations for measuring cost.
    • Orange Belt (Lessons 7–10) — Clean Cuts: Arrays & Strings
      Arrays, searching, array techniques, and string problem patterns.
    • Green Belt (Lessons 11–15) — Structured Steel: Matrices to Queues
      Matrices, sparse structures, linked lists, stacks, and queues.
    • Blue Belt (Lessons 16–18) — Tree Line: Fast Structure
      Trees, binary search trees, and balanced tree thinking.
    • Brown Belt (Lessons 19–22) — Speed & Reach
      Heaps/priority queues, hashing, graphs, and divide & conquer.
    • Black Belt (Lessons 23–26) — One Cut: Strategy Mastery
      Greedy algorithms, dynamic programming, backtracking, and strategy selection.
      Black Belt Test: comprehensive final exam.

    Belts are proof. 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 + belt map
    • Preview the dojo structure

    Dojo Membership (Paid)

    • Full access to all drills, quizzes, and belt tests
    • Belt tracking and certificates
    • Parent visibility of progress and scores inside Moodle

    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.

    📚 Curriculum / Training Forms (26 lessons)

    1. The Iaido Mindset — why algorithms beat raw code at scale.
    2. Memory Basics — stack vs heap and performance implications.
    3. ADT Thinking — choose the right structure for the job.
    4. Complexity — time/space as your stopwatch.
    5. Recursion — tracing, stack behavior, and safe patterns.
    6. Recurrence Relations — measuring recursive cost.
    7. Arrays — indexing, resizing, and tradeoffs.
    8. Searching — linear vs binary and correctness.
    9. Array Techniques — merge, reverse, shifts, set operations.
    10. Strings — validation, comparison, and common patterns.
    11. Matrices — specialized representations for efficiency.
    12. Sparse Structures — compact storage for mostly-empty data.
    13. Linked Lists — dynamic structures and traversal patterns.
    14. Stacks — parsing and expression evaluation patterns.
    15. Queues — circular, priority, and scheduling logic.
    16. Trees — traversal, building, and height reasoning.
    17. Binary Search Trees — ordered storage operations.
    18. Balanced Trees — keeping performance stable.
    19. Heaps — priority queues and heapsort thinking.
    20. Hashing — fast lookup and collision reality.
    21. Graphs — BFS/DFS and reachability tools.
    22. Divide & Conquer — split, solve, combine.
    23. Greedy — when the clean cut works (and when it fails).
    24. Dynamic Programming — win by remembering.
    25. Backtracking — disciplined search and pruning.
    26. Strategy Selection — choose the right approach under pressure.

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

    ✅ Belt Test Rules (read before testing)

    Belts are proof of skill. Your teen earns belts through drills and belt tests.

    Passing score: 80%
    Retries: Unlimited
    Score policy: Best score counts (highest score recorded; retakes cannot lower record)

    Eligibility: completing the required drills unlocks the belt test.

    Optional anti‑spam cooldown (recommended): add a cooldown after failed attempts to reduce rapid guessing and encourage real review.

    Integrity Rules — “You vs AI”

    • No AI tools during belt tests. No chatbots, no code generators, no “explain this and give the answer.”
    • No outside help during belt tests (friends, tutors, siblings).
    • Parent presence encouraged during belt tests (nearby / same room).

    Notes Policy

    • Drills: open‑notes allowed.
    • Belt tests: closed‑notes or one‑page notes (dojo admin choice).

    Disclaimer: Belts and certificates verify training progress and do not guarantee job outcomes.

• Select section Lesson 1: The Iaido Mindset — why algorithms beat raw code at scale

  Collapse Expand

  Lesson 1: The Iaido Mindset — why algorithms beat raw code at scale

  • Select activity Micro-topic 1 A: Algorithm vs code vs “I tried it and it worked”

    Micro-topic 1 A: Algorithm vs code vs “I tried it and it worked”

    Goal: Build a clean definition of “algorithm,” “problem,” “instance,” and “correctness,” and treat correctness as non-negotiable.

  • Select activity Iaido Algorithms WB L1 1A FREE v2

    

    Iaido Algorithms WB L1 1A FREE v2 SCORM package
  • Select activity Micro-topic 1 B: Efficiency is not a detail — it’s the fight

    Micro-topic 1 B: Efficiency is not a detail — it’s the fight

    Goal: Internalize that time and memory are limited resources, and that algorithmic growth rate beats “clever coding” at scale.

  • Select activity Iaido Algorithms WB L1 1B FREE v2

    

    Iaido Algorithms WB L1 1B FREE v2 SCORM package
  • Select activity Micro-topic 1 C: Algorithms are bigger than “coding” — techniques and limits

    Micro-topic 1 C: Algorithms are bigger than “coding” — techniques and limits

    Goal: Make students fluent in the idea that algorithms are everywhere, and also that some problems resist fast solutions; this builds strategic realism.

  • Select activity Iaido Algorithms WB L1 1C FREE v2

    

    Iaido Algorithms WB L1 1C FREE v2 SCORM package
• Select section Lesson 2: Memory Basics — stack vs heap and performance implications

  Collapse Expand

  Lesson 2: Memory Basics — stack vs heap and performance implications

  This lesson links how programs live in memory to both correctness risks (like aliasing and recursion crashes) and performance reality (like what the RAM model hides).

  • Select activity Micro-topic 2 A: Values vs references — the silent source of bugs

    Micro-topic 2 A: Values vs references — the silent source of bugs

    Goal: Build a practical mental model: primitive values behave like copies; objects/arrays behave like references; assignments can create aliasing; bugs explode when you don’t notice.

  • Select activity Iaido Algorithms WB L2 2A FREE v2

    

    Iaido Algorithms WB L2 2A FREE v2 SCORM package
  • Select activity Micro-topic 2 B: Stack thinking — recursion, base cases, and crash discipline

    Micro-topic 2 B: Stack thinking — recursion, base cases, and crash discipline

    Goal: Understand recursion as a structured tool (not spooky magic): base case, smaller subproblem, and why runaway recursion causes failure.

  • Select activity Iaido Algorithms WB L2 2B FREE v2

    

    Iaido Algorithms WB L2 2B FREE v2 SCORM package
• Select section New section

  Collapse Expand

  New section
• Select section New section

  Collapse Expand

  New section