Kodebits: September 2026: Day 100 and a Pause

Kodebit number 100 went out on September 30th, closing the month and, for now, the series. It’s a beginner Swift puzzle about enum cases—one of the simplest things we’ve published, and a chilled way to complete the century. We’re pausing here to look back over the hundred and work out what to keep and what to change, and we’d like your help with that. More on that at the end.

September itself brought 15 bits. Swift is back out in front with nine, after August’s Kotlin-led month, and it was a gentle one: nine of the fifteen are beginner level. The clearest thread is how functions take their arguments. Kotlin covered default parameters, named arguments and varargs; Swift covered default parameters and inout. Days 87 and 93 make a particularly tidy pair—the same feature in both languages, both demonstrated with a function called greet.

Below, the month is split by platform and sorted Beginner, Intermediate, Advanced. Each Kodebit page gives you the puzzle first, then the answer and an explanation, with a couple of links into the Kodeco library so you can dive deeper.

iOS & Swift

Nine Kodebits, and much of the month fills in gaps around topics we’d already touched. Enums get their basics, plain cases and raw values, to sit alongside the associated values covered in May and July. Properties get observers, joining the computed and lazy properties from earlier in the run. And operator overloading arrives two months after July’s custom operators, so Swift now has both halves: giving existing operators new meaning, and inventing new ones.

Beginner

• Day 86: Computed Property — A property that’s calculated from other state each time you read it, rather than stored. May’s Day 31 did this with a square; this one uses a rectangle, so it’s a quick check that the idea has stuck.
• Day 89: Enum Raw Values — Back an enum with an Int and each case carries an underlying value you can read with rawValue. Swift only numbers them automatically when you don’t assign them yourself, and this puzzle assigns them.
• Day 93: Default Parameter — Give a parameter a default and callers can leave it out. Read it next to Kotlin’s Day 87 from earlier in the month; the two languages handle this almost identically.
• Day 97: Enumerated Loop — enumerated() hands you a counter alongside each element. It always starts at zero, and strictly it’s an offset rather than the collection’s index — a distinction that only bites when you enumerate a slice.
• Day 98: Filter Evens — Keep only the elements that match a condition with filter. It also shows off isMultiple(of:), which reads a good deal better than % 2 == 0.
• Day 100: Enum Cases — The simplest form of enum: a fixed set of named cases, matched with dot syntax. With Day 89 and the earlier associated-values bits, that’s the full set of Swift enum basics covered.

Intermediate

• Day 88: Inout Parameter — An inout parameter lets a function change the caller’s variable rather than a copy of it. Swift makes you write & at the call site, so the mutation is visible where it happens, not just where it’s declared.
• Day 91: Property Observer — didSet runs code every time a property is assigned. Worth knowing alongside it: observers don’t fire for the property’s initial value, only for changes after that.
• Day 94: Operator Overloading — Define what + means for your own type with a static func. Kotlin’s version appeared in June, and July’s Day 58 covered declaring brand-new operators; this is the more everyday of the two.

Android & Kotlin

Five Kodebits, three of which are about the same thing: what a Kotlin function lets you do with its arguments. Defaults, names and varargs between them explain why Kotlin APIs rarely need the stacks of overloads you’d write in Java. The other two are the month’s only advanced bits, and both are about doing work efficiently.

Beginner

• Day 87: Default Parameters — Give a parameter a default value and callers can omit it. A single function with defaults replaces the run of overloads you’d otherwise need to cover each combination.
• Day 90: Named Arguments — Name your arguments at the call site and you can pass them in any order. The puzzle shuffles them deliberately, so you need to track names rather than positions.
• Day 96: Vararg Parameters — Accept any number of arguments with vararg, which arrive inside the function as an array. The Kotlin counterpart to Swift’s variadic sum back in June; if you already have an array to pass, the spread operator * unpacks it.

Advanced

• Day 95: Lazy Sequences — Turn a collection into a Sequence and each element passes through the whole chain before the next one starts, so take can stop the work early. A return to May’s Day 16, this time with a filter in the middle to make the order of evaluation matter.
• Day 99: Tail Recursion — Mark a function tailrec and the compiler turns the recursion into a loop, so deep inputs can’t overflow the stack. It only works when the recursive call is the very last thing the function does, which is why this one carries an accumulator.

Flutter & Dart

A single Kodebit this month, but it’s a useful one: the for counterpart to the collection if from Days 9 and 79, and the two together are the bread and butter of building widget children from data.

Intermediate

• Day 92: Collection For Loop — Put a for directly inside a list literal to build a new list from an existing one. The puzzle combines the length and the first element of the result, so you have to work out the whole list rather than guess one value.

A hundred, by the numbers

Exactly half of the hundred were Swift. Kotlin accounted for 33 and Dart for 17. On difficulty, 43 were beginner, 41 intermediate and 16 advanced, so roughly one in six was pitched at the deep end. If you’ve worked through all of them, that’s a fair amount of ground across three languages, a few lines of code at a time.