Jumping among Kotlin snippets, Android and backend tutorials fragments the foundation. Build one Kotlin Practice Log in 12 weeks, moving from a JVM console core to tests, coroutines and one application stack. Use the Coding & Skills category only when a missing prerequisite blocks the next milestone.
1. Fix the 12-week finish line and weekly time box
Use an eight-hour rhythm: Tuesday and Thursday, 90 minutes each for reading, code tracing and an exercise; Saturday, three hours for the milestone; Sunday, two hours for tests, notes and repair. Allocate two hours to reading and six to coding, testing or debugging. Fixed gates: Week 2, correct console summary; Week 4, four transformed items; Week 6, six passing tests; Week 8, coroutine completion and cancellation; Week 10, one Android or backend slice; Week 12, README, test command and two-minute demo. The goal is a small, explainable project, not job readiness or mastery. Java developers may shorten familiar reading but must complete every exercise.
2. Weeks 1 and 2: learn Kotlin on the JVM through one console slice
Use the official Kotlin getting-started documentation for JVM setup. Learn only fun main, val and var, inferred and explicit types, expression-form if, functions, nullable types, data classes and basic list operations. Define data class PracticeBlock(val skill: String, val minutes: Int). With PracticeBlock("JVM setup", 30) and PracticeBlock("Functions", 45), calculate 30 + 45 = 75 and print exactly 2 blocks | 75 minutes. Filter with minutes >= 40; print Long blocks: [Functions]. Change 30 to 50; before running, predict 2 blocks | 95 minutes and Long blocks: [JVM setup, Functions]. Trace each expression. For missing JVM foundations, the Java course is adjacent, not Kotlin; the milestone remains Kotlin.
3. Weeks 3 and 4: make null safety and collection pipelines habitual
Replace the two-row smoke test with PracticeBlock(val skill: String, val minutes: Int, val reflection: String?). In order, make this read-only list: ("JVM setup", 30, "repeat compiler flags"), ("Functions", 25, null), ("Data classes", 40, "compare copy") and ("Collections", 55, null). Consult official documentation for nullable types, safe calls and Elvis behaviour. Evaluate: filter { it.minutes >= 40 }.map { it.skill } produces [Data classes, Collections]; sumOf { it.minutes } gives 30 + 25 + 40 + 55 = 150; reflection?.uppercase() ?: "NO REFLECTION" gives REPEAT COMPILER FLAGS for the first item and NO REFLECTION for the second. Explain every intermediate value. String Handling in Java offers comparison, not Kotlin authority. Change Functions from 25 to 50: predict total 175 and threshold result [Functions, Data classes, Collections].
4. Weeks 5 and 6: separate domain logic and prove it with tests
Refactor the four blocks. Create PracticeLogRepository with add(block) and all(), plus an in-memory implementation. Put totalMinutes() and skillsAtLeast(minimum: Int) in PracticeSummary. This separates responsibilities, an idea developed in Object Oriented Technology Explained. Exclude UI, storage and frameworks so either final stack can reuse the core.
Give six named tests exact expectations: empty repository totals 0; four blocks total 150; threshold 40 returns [Data classes, Collections]; threshold 56 returns []; null reflection formats as NO REFLECTION; minutes = 0 is rejected through one consistent project-defined validation result. Configure Kotlin testing. Week 6 requires one command passing every test, plus a note that changing >= 40 to > 40 breaks the threshold test because Data classes has exactly 40 minutes.
5. Weeks 7 and 8: learn coroutines through one timed data load
Study suspending functions, CoroutineScope, launch, async, Job, dispatchers and structured concurrency in official Kotlin coroutines documentation. Build loadSessionCount(), delaying 300 ms before returning 12, and loadStudyMinutes(), delaying 500 ms before returning 450. Start both with async under one coroutineScope, await both, then print 12 sessions | 450 minutes exactly. Wall-clock observations vary; the delays are an exercise, not a performance promise.
Wrap both children in a 400 ms timeout. Count produces 12 at 300 ms, but minutes cannot finish its 500 ms delay. At 400 ms the parent times out and cancels that child, so no success line prints. Test cancellation or timeout by type or state, never a platform-specific exception message. Remove the timeout and confirm exact successful output. Both paths must pass Week 8.
6. Weeks 9 and 10: choose Android or backend, then build one vertical slice
Choose Android for a phone-app portfolio goal or backend for an HTTP-service goal. Neither is universally better; splitting eight weekly hours weakens the evidence.
For Android, show four blocks, add PracticeBlock("Coroutines", 70, "structured cancellation"), and change 4 blocks | 150 minutes to 5 blocks | 220 minutes. For backend, GET /blocks/summary returns 200 with {"count":4,"minutes":150}; adding that block produces {"count":5,"minutes":220}. Keep all six core tests green. Week 9 assigns three hours to stack basics, three to the first screen or endpoint, two to integration repair. Week 10 gives four hours to the add-block flow, two to one boundary test, two to cleanup. Add no authentication, deployment, database migration or second stack before this slice passes.
7. Weeks 11 and 12: turn the slice into portfolio evidence
Week 11 gives four hours to regression and boundary tests, two to naming and dead-code cleanup, two to the README. Record the stack, one-sentence purpose, setup and test commands, exact dataset, expected 150 and 220 summaries, the 400 ms cancellation exercise, and one honest limitation. Make performance claims only from a recorded run.
Week 12 gives three hours to the last reproducible defect, three to a two-minute demo, two to explanation rehearsal. Show four blocks and 150 minutes; add the 70-minute Coroutines block; show five blocks and 220 minutes; run tests; explain the stack choice. Classic Programs in C, Java and Python adds predict-before-running practice. The DSA using Java course is later Java algorithm practice, not Kotlin. Neither is required.
8. Recover from missed days and take the next step without restarting
Miss Tuesday? Split its 90 minutes: 45 Thursday, 45 Sunday. Miss both weekdays? Cut optional comparison or README polish; borrow at most two hours next week. If a gate fails, repeat that two-week block. At each even-week gate, spend 20 minutes starting clean, running project/tests, recording exact output, explaining one concept unaided and noting one unresolved question. Java developers cannot skip null-safety or cancellation evidence.
Plan eight weekly hours around one project and six gates, complete the tests before coroutines, and choose one stack afterward. Coding & Skills offers broader routes without salary, placement or mastery promises.
