Lectures

We break down extension functions in Kotlin: how the syntax fun Type . method () works, what a receiver is and what this means inside an extension, what restrictions visibility imposes ( private/ protected), why a member method wins on conflict, and why extensions are selected statically (this is not override). We illustrate all ideas with a mini CLI example for expense tracking.

We break down extension properties in Kotlin: why this is not “adding a field”, how get()/ set() work, where computed properties fit well (input normalization, money formatting, output strings), why “heavy” getters and side effects are dangerous, and also how (and why cautiously) to make a var via external storage like MutableMap.

We break down Kotlin operator conventions: how expressions like a + b are translated by the compiler into a call to a . plus ( b ), how += works (via plusAssign or via reassignment), and why comparisons </ > are based on compareTo. Using the Money type as an example, we discuss surprise-free design, readability, and common mistakes.

We break down how, in Kotlin, the square-bracket syntax is turned by the compiler into calls to get/ set, and why the operator modifier is needed. We look at indexers in the standard library ( List, MutableList, Map, MutableMap), design our own indexers using the sample learning app BudgetBuddy, discuss contracts (fail-fast vs nullable), and the multi-index variant obj[i, j].

We break down how to design a small “convenience layer” over a domain in Kotlin using extension functions and extension properties, operators ( += / +), and targeted infix calls. Using expense tracking as an example, we build a mini model ( Expense, Money), a report accumulator ( Report), and a readable scenario in main; we also discuss the criteria “cheap,” “no surprises,” and “the name makes the meaning obvious,” plus common mistakes when overloading conveniences.