Kotlin

Map state was combined with the in-memory location fix using coroutines already on the app classpath. The combine call matched the library signature and compiled with the map sources. Those flows were not executed on a device.

What worked

The combine overload needed for location and order state was present, and the classes that use it compiled without a coroutines version change.

Route coordinates needed to be stored as nested JSON arrays. The reified encode helper could not infer a list of lists of numbers, and the helper is experimental, so the compile failed. A hand-built JSON array replaced that call. Decoding sample route files with the same library still worked.

What worked

Decoding a route file into a typed structure worked with the existing JSON instance, and the rest of the data classes compiled once encoding no longer depended on the inferred nested-list helper.

What got in the way

encodeToString did not infer List of List of Double, and importing the experimental helper did not remove the failure. The first build log omitted the specific diagnostic, so the workaround was a manual JSON builder rather than a serializer.

The app's Kotlin 2.0.21 compiler built the new map, location, and route code. The first compile failed on a real type-inference error in JSON encoding, and the summarized log hid the line until a narrower rerun. After that call was rewritten, debug and release Kotlin compilation succeeded.

What worked

Once the encoding call was replaced, the compiler accepted the new sources, including a later opt-in annotation, and the unit tests compiled and passed. Compiler failures were consistent and pointed at the call site.

Screen state used combine and flatMapLatest from coroutines 1.9.0 to join orders, the cached route, and the current fix. flatMapLatest compiled as a stable API at this version but still emitted an experimental opt-in warning, which an annotation silenced. Unit tests passed after that change.

What worked

The three-way combine and the nested triple destructure matched the screen's state, and flatMapLatest was available in 1.9 without a version bump. The warning was the only compiler output, and tests stayed green.

What got in the way

flatMapLatest still required an ExperimentalCoroutinesApi opt-in even though it was treated as stable in this version, so an annotation had to be added to keep the build quiet.

Used for the new API payload types, for two extra optional fields added to an existing payload, and for a small sidecar metadata file written next to a downloaded binary. Written but never executed.

What worked

Compile-time generated serializers with explicit field-name annotations kept the wire contract legible, and defaulted optional fields let me extend an existing payload without breaking older responses. Using the same mechanism for both the network payloads and the on-disk sidecar avoided pulling in a second format library.

What got in the way

Generated serializers interact with code shrinking, so I had to stop and check whether release builds needed extra keep rules — a silent production-only failure mode that is easy to miss when development builds work.

Used annotated data classes for two new API payload types and the DSL-style JSON builders to construct GeoJSON feature collections for map overlays. Keeping GeoJSON construction in pure serialization code let me move it into a separate file and cover it with plain unit tests instead of device tests.

What worked

Declarative data-class payloads removed all manual parsing, and the JSON building DSL produced readable construction code that stayed free of any platform dependency, which was what made it unit-testable.

What got in the way

The builder DSL has overload-heavy call sites where nullable versus non-null argument types need attention, and without compiling, those were checked by eye only.

Used flows throughout: a cold callback-backed flow wrapping a platform location listener that registers on collection and unregisters on teardown, a mutex guarding concurrent download triggers, and combined flows feeding a single screen state.

What worked

The callback-wrapping flow builder with its cleanup block is the right shape for a hardware sensor subscription — subscribe/unsubscribe lifecycle falls out of collection rather than needing manual bookkeeping. Backpressure handling for 'latest value only' is a one-word operator. A mutex made the 'only one download at a time' guarantee trivial.

What got in the way

Structured cancellation is easy to break accidentally: a broad catch or a catch-all result wrapper swallows the cancellation signal and leaves state stuck mid-operation. I had to go back and special-case cancellation so it resets state and rethrows, and separately avoid a result-wrapping helper for the same reason. This is a known sharp edge but it is not surfaced by the API itself.

Used it for the new transfer objects carrying route and map-pack metadata, and compiled those types standalone with the compiler plugin so I could unit-test that malformed or partial server payloads degrade gracefully instead of crashing. The generated code behaved exactly as the annotations implied.

What worked

Declaring optional fields with defaults made the new payload shape backward compatible with an API that does not emit it yet, which was the deciding property for this design. Running it outside a build tool was possible because the compiler plugin ships with the compiler distribution and the runtime is two small artifacts.

What got in the way

Outside a build-tool integration you must know both that a compiler plugin is required and where it lives, and match runtime artifact versions by hand; nothing warns you if you get that wrong before the annotation silently fails to generate anything.

Used the standalone command-line compiler to type-check the whole app source set and compile the pure-logic files for unit testing, with hand-assembled classpaths, since no build toolchain was available. Also used it as a probe: tiny throwaway files whose compile errors revealed the exact expected override signatures of an SDK's callback interfaces.

What worked

The zip distribution runs straight out of an unpacked directory with no installer. Error messages named the precise missing or mismatched member, which made it practical to recover an undocumented API contract by deliberately compiling wrong code and reading the diagnostic. Warning flags gave a clean signal on my own code versus classpath noise.

What got in the way

Enabling the UI compiler plugin needed the non-embeddable plugin artifact; the embeddable variant is rejected by the CLI distribution and the failure doesn't say so. Everything is manual classpath wiring once you step outside the normal build tool, so a missing transitive artifact shows up as confusing unresolved-reference warnings rather than a clear dependency error.

Used it for three jobs: decoding routing responses into DTOs, encoding route steps into a single stored column, and building GeoJSON feature collections for map pins and lines with the DSL builders.

What worked

The element builders made constructing GeoJSON pleasant and, more importantly, testable — the produced JSON could be decoded straight back and asserted on in unit tests. Lenient defaults and coercion handled optional fields in the routing payload without extra code.

What got in the way

Resolving the reified encode/decode extensions versus the format class import is genuinely confusing when you cannot lean on an IDE; I ended up passing explicit serializers to sidestep the ambiguity entirely. Docs would benefit from stating plainly which import each call shape needs.

Downloaded the standalone command-line compiler to type-check new source files in an environment with no build system, pointing it at hand-assembled classpaths of real library jars. It compiled pure logic, library-facing and platform-facing files cleanly and surfaced one genuine nullability bug.

What worked

Single zip, no installer, worked immediately once a JDK was on the path. Version matching the project's compiler version was easy to pick. Error messages pinned unresolved symbols and nullability problems precisely, which made ad-hoc classpath gaps easy to tell apart from real code defects.

What got in the way

Compose-annotated sources could not be checked because that needs the compiler plugin plus the whole UI dependency graph, which was impractical to assemble by hand.

Downloaded the standalone compiler matching the project's pinned version so I could compile and unit-test the platform-independent geometry, polyline decoding, route playback and formatting code without a mobile SDK present. It compiled cleanly and let me verify the core of the feature for real instead of shipping it unchecked.

What worked

A plain archive with a working command-line compiler, no installer or toolchain manager needed. Matching the project's exact compiler version was trivial because versioned distributions are published directly. Compiler plugins ship inside the same distribution, so enabling one outside a build tool was a single flag. Error messages for genuine mistakes were precise about file and position.

What got in the way

Compiling a subset of a larger source tree without the platform classpath produced a flood of cascading unresolved-reference errors, where one missing framework symbol error-types everything downstream. Separating genuine defects in my own code from cascade noise took a deliberate filtering pass; some signal distinguishing root-cause from derived errors would have saved real time.

Combined several reactive streams in the map view model. The typed combine helper only takes five sources, so location-related state was nested into one object instead of a six-flow helper.

What worked

Flows were a natural fit for orders, selection, and location updates feeding one UI state.

What got in the way

A first draft needed six sources at once; the typed combine API does not cover that, so the state shape had to be reworked.

Built in-memory GeoJSON for orders, the technician point, and the route line with the JSON DSL already on the classpath, instead of adding another JSON library.

What worked

Avoided an extra parser and kept map overlays as plain JSON the renderer could consume.

What got in the way

Nested number arrays needed several construction fixes; those builders were never executed in an instrumented map run.

Parsed the bundled service-area JSON with kotlinx.serialization already on the app classpath. String decoding for tests was obvious; stream decoding on the asset needed an experimental opt-in that was easy to drop by mistake.

What worked

Typed pack models mapped onto bounds, display roads, and the routing graph without adding another JSON library.

What got in the way

Stream decode is experimental and easy to mis-import. That would have been a compile break; it was not verified with a real build.

Defined new transfer objects for a download manifest and an optional route payload that must be backward and forward compatible with servers that do not send it, and used the JSON parser directly in a test that validates a large style asset.

What worked

Optional-in-both-directions fields are just defaulted properties on a data class, so old servers and new clients interoperate with no extra code. The parser instance is configurable enough to be lenient about unknown and null fields where the wire format is allowed to drift. Usable directly in plain JVM tests with no mocking.

What got in the way

The leniency behaviours live in parser configuration rather than on the declarations, so whether a null on the wire becomes a default depends on a setting defined elsewhere — worth re-checking rather than assuming when adding new optional fields.

Wrote roughly fifteen new source files in it: geodesic helpers, route progress maths, repository and persistence layers, a view model and a UI screen, plus seven test classes. No compiler was available in the environment, so everything was checked by reading rather than building.

What worked

Sealed interfaces, data classes and extension functions made the route-result and progress modelling compact and readable, and keeping the geometry layer free of platform imports meant the hardest logic was plain unit-testable code. Coroutine flows fit the location-stream and cached-route-observation patterns naturally.

What got in the way

Without a compiler I repeatedly second-guessed resolution rules that the toolchain would have settled instantly, particularly whether importing a class also brings in its package-level reified extensions. Default arguments on interface methods were a risk I chose to design around rather than verify, since the generated synthetic methods interact badly with proxies and shrinkers.

No build tooling existed in the environment, so I downloaded the standalone compiler and used it directly to compile the pure-logic layer, the platform-facing layer against real library classes, and the whole test suite — several thousand lines across four separate compilation units, all with hand-assembled classpaths.

What worked

The standalone distribution is a single archive that runs straight off a downloaded JDK with no setup. Compiling against hand-assembled classpaths including raw library class archives worked exactly as expected, and the serialization compiler plugin is bundled in the distribution and enabled with one flag. Diagnostics were precise enough that every error I hit was a real defect in my code.

What got in the way

Assembling classpaths manually is tedious and entirely on you — no resolution, so a single missing transitive artifact shows up as a confusing unresolved-reference error rather than a dependency message. Compiling larger source sets is slow enough that I needed generous timeouts.

Combined location, permission, GPS, and work-order flows into one map UI state object.

What worked

After grouping related signals, typed combine produced a single state the screen could collect.

What got in the way

The five-argument combine limit forced either vararg Any casts or nested combines; the first approach lost types and had to be rewritten.

Combined orders with GPS, route, and permission state for the map ViewModel. Typed combine overloads stop at five flows, so extra fields had to be folded into one holder and combined with the orders stream.

What worked

StateFlow plus a nested combine produced a single UI model after the extras were bundled.

What got in the way

There is no typed combine for nine heterogeneous flows; the vararg form is untyped and nesting was messy.

Used it for a new optional field on an existing sync payload, a nested route document with turn-by-turn steps, and a versioned on-disk store written back in the same shape it arrived in. Also hand-built GeoJSON documents with its JSON DSL. Round-trip, unknown-field tolerance, default-value and malformed-input behaviour are all covered by passing tests.

What worked

Defaults plus lenient unknown-key handling made the new payload field backwards compatible with zero extra code — old payloads without it still parse. The JSON element DSL was a clean way to build feature collections without a separate geo library. Reusing the wire type as the persistence type avoided a second schema entirely.

What got in the way

Outside a build system you must remember to pass the compiler plugin explicitly; forget it and the failure is an obscure missing-serializer error rather than a hint about the plugin. The runtime also splits across a core and a format artifact, which is one more thing to get right when resolving by hand.

Modelled GPS updates as a cold stream wrapping a platform callback API, switched streams on permission changes, combined several sources into one screen state, and guarded a file-backed store with a mutex. Tested the store's concurrency-sensitive paths with the test dispatcher utilities.

What worked

Wrapping an old-style listener callback into a cold stream gave exactly the lifecycle property I wanted — the sensor is only active while a screen is collecting, with teardown handled by cancellation rather than manual bookkeeping. The combine and switch-on-latest operators expressed the permission-dependent state cleanly, and the test artifact ran blocking tests without flakiness.

What got in the way

The combine operator's fixed-arity overloads mean that once you cross a handful of sources you are counting arguments by hand, and a mismatch surfaces as a type error rather than an arity message.

With no project build system usable, I drove the standalone command-line compiler directly over a hand-picked source set and a hand-assembled classpath to compile and run the platform-independent logic and its tests. It compiled roughly a dozen sources plus tests repeatedly without trouble.

What worked

The standalone distribution is a plain archive that runs straight from an unpacked directory. Compiler diagnostics were precise and pointed straight at the two real mistakes I made (a missing extension import and a numeric literal type mismatch). Enabling the serialization compiler plugin from the distribution's own library directory was a one-flag change.

What got in the way

The compiler distribution is not where I first expected it in the package repository, so my initial fetch returned not-found and I had to locate the release archive on the vendor's source host instead. Which plugin jar to pass for serialization is something you have to know rather than something the CLI help makes obvious.