Kotlin Professional Certificate study plan

Write 20 small Kotlin programs that exercise val/var, type inference, string templates, ranges, and when expressions without IDE auto-completion.

Implement null-safety patterns using safe calls, elvis, and smart casts across 10 functions, then refactor two of them to avoid unnecessary !! operators.

Demonstrate the difference between expression-bodied and block-bodied functions by writing paired implementations and documenting return-type inference outcomes.

Build a CLI mini-calculator that parses integer input, handles invalid input with try/catch, and uses when for operator dispatch.

Define 8 classes covering primary/secondary constructors, init blocks, and property initializers, then explain initialization order in code comments.

Implement inheritance hierarchies with open classes, abstract members, and interface default implementations, verifying override behavior in a main function.

Convert three data classes into equivalent regular classes and document which generated methods (equals, hashCode, copy, componentN) are lost.

Write extension functions and properties for String and List that do not shadow existing members, and verify resolution order with a test.

Implement higher-order functions including a custom map, filter, and fold over a linked-list structure to prove understanding of function types.

Refactor a 100-line imperative block into idiomatic functional Kotlin using lambda expressions, method references, and trailing lambda syntax.

Apply scope functions (let, run, with, apply, also) in 10 distinct realistic scenarios and justify each choice in one sentence.

Design a sealed class hierarchy for a payment result type and handle every branch exhaustively in a when expression without an else clause.

Implement generic functions and classes with variance annotations (in, out, where) and demonstrate why List is covariant while MutableList is invariant.

Solve 15 collection-processing tasks using map, flatMap, groupBy, associateBy, partition, and zip, comparing eager versus lazy sequences for at least 3 of them.

Build a custom sequence pipeline that processes 1,000,000 generated integers and measure the performance difference against the equivalent list-based pipeline.

Write 10 unit tests using kotlin.test assertions that verify collection operation outputs, including edge cases with empty and single-element collections.

Implement coroutine-based concurrency using launch, async/await, and runBlocking, measuring total elapsed time for 10 simulated 100ms tasks run sequentially versus concurrently.

Apply structured concurrency with coroutineScope and supervisorScope, then intentionally trigger a child failure to observe and document cancellation propagation.

Handle exceptions in coroutines using CoroutineExceptionHandler, try/catch around await, and supervisorScope, documenting which approach catches which failure mode.

Use Flow to emit a stream of values, apply map and filter operators, and collect results with a timeout, verifying cancellation behavior.

Configure a Gradle Kotlin JVM project from scratch with the Kotlin plugin, JUnit 5, and a runnable application plugin entry point.

Write 20 unit tests covering previously built domain classes, achieving at least 80% line coverage measured by a coverage tool integrated into the build.

Set up a parameterized test and a test fixture using @BeforeTest and @AfterTest, verifying isolation between test cases.

Run the full build pipeline in CI mode locally (clean, compile, test, report) and fix every warning surfaced by the compiler.

Use IDE debugging features: set conditional breakpoints, evaluate expressions during a paused session, and step through a recursive function while recording observations.

Profile a slow collection-processing function using the IDE profiler and reduce its execution time by at least 30% through an identified optimization.

Resolve 10 deliberately introduced compiler errors spanning type mismatch, nullability, and unresolved references, documenting the diagnostic message and the fix for each.

Configure code style and static analysis rules in the build so that a deliberately non-idiomatic file fails the check.

Complete three timed practice sets of 30 mixed questions spanning all four domains and score at least 80% on each.

Rebuild a small end-to-end application (data layer, coroutine service layer, tested API) from an empty directory in under 90 minutes without consulting previous code.

Review every incorrect practice answer, write the correct reasoning for each, and re-test those specific concepts until no repeat errors occur.

Audit the week-by-week repository for missing deliverables and close any remaining gaps before a final full build and test run.