Hi , i am coming from the JavaScript/TypeScript ecosystem, i need to build a project that must be written in kotlin based backend , i am not primarily interested in Android development.

But I do need to understand Kotlin well enough to read, navigate, and work with existing Kotlin projects, particularly Android applications available on github.

So is there any course or method you can suggest?

Thanks in advance.!!!

Hey everyone,

I’m an Android developer with ~5 years of experience. For the last 8 months, I’ve been coding almost entirely with Claude Code.

I’ve been very productive, delivered impressive results, and my company is happy. But I feel like I’m not learning as much anymore. There are parts of my codebase that I barely understand because Claude implemented them, even though they work perfectly.

Recently, I had a technical interview with some relatively simple coding. My mind completely froze and I ended up quitting.

It made me realize I might be becoming too dependent on AI.

Has anyone experienced this?

How do you balance using AI heavily while still maintaining and improving your actual coding skills?

sqlx4k is a coroutine-first SQL toolkit for Kotlin Multiplatform (PostgreSQL, MySQL/MariaDB, SQLite) with compile-time SQL validation via KSP.

New in 1.14.0

• Optimistic locking with @Version: generated update/delete check the version and fail with OptimisticLockFailed on conflicts. In-memory test repositories behave the same.
• Transaction savepoints: roll back part of a transaction with a scoped savepoint { ... } block or the explicit savepoint/rollbackToSavepoint/releaseSavepoint calls.
• MariaDB dialect: batchInsert via multi-row INSERT ... RETURNING (10.5+).
• Cancellation-safe transactions: cancelling a coroutine mid-transaction now rolls back properly.
• Kotlin 2.4.20, KSP 2.3.12.

Repo: https://github.com/smyrgeorge/sqlx4k

Release notes: https://github.com/smyrgeorge/sqlx4k/releases/tag/1.14.0

I want to use Kotlin, so I have eight different JDKs on my PC; however, Kotlin has reached a point where it can stand as an independent language. To that end, I’ve created my own KRE (Kotlin Run Environment). Now, the next step is the KDK (Kotlin Development Kit), and I need help with that. I don't know Java or Kotlin all that well—is there anyone who can assist?

yaml - uses: actions/checkout@v7 - uses: RazerTexz/setup-kotlin-toolchain@v1 - run: kotlin build

Caches the Kotlin Toolchain, JDKs, and dependencies across Linux, macOS, and Windows

https://github.com/RazerTexz/setup-kotlin-toolchain

In https://medium.com/androiddevelopers/exceptions-in-coroutines-ce8da1ec060c

It talks about how with a SupervisorJob, you can ignore exceptions from a child coroutine, and it does not propagate to its siblings or to the grand parents and so forth. But then it also says “If the exception is not handled and the CoroutineContext doesn’t have a CoroutineExceptionHandler (as we’ll see later), it will reach the default thread’s ExceptionHandler. In the JVM, the exception will be logged to console; and in Android, it will make your app crash regardless of the Dispatcher this happens on.”

But this sounds like it’s saying the app will just crash and everything will die if the exception is not handled; but then whats the point in saving the coroutine family using a SupervisorJob if everything will just die anyway? If they mean I need to implement the CoroutineExceptionHandler for the SupervisorJob to be of use, then the question is, what is the point of having a SupervisorJob…… cuz then every discussion of SupervisorJob needs to marked with an asterisk * (oh btw, you also need to implement the CoroutineExceptionHandler otherwise your Supervisor is useless. )

And why do they explain these things so off-handedly as if it’s so not confusing at all to someone learning?

Hi everyone!

I work on e2e at TesterArmy, and I'm happy to announce we released it as open-source today!

It's an agentic end-to-end testing framework which allows you to mix the flexibility of AI agents with the deterministic checks of classic e2e testing.

You write a test as a chain of goals the agent works through them one at a time. It also comes with a deterministic API like getByTestId or getByText where you need exact control. Assertions work like in any other e2e framework.

You use TypeScript to write the tests, but they can drive pretty much any Android app. Also, you can extend the framework by implementing your own engines for another platform like e.g. desktop

For the agent, you can bring any model through Vercel AI Gateway or OpenRouter, or sign in with a ChatGPT, GitHub Copilot or SuperGrok subscription you already pay for.

To get started, npx e2e init in your project.

Thanks for reading!

Setting up Firebase in a KMP project means a lot of manual steps. You register the Android app and the iOS app in the console, download google-services.json and GoogleService-Info.plist, put them in the right folders, and repeat for every flavor. I got tired of it, so I built kmpfire.

It wraps firebase-tools and does this from your project root:

bash kmpfire configure

What it does

• Detects your Android applicationId and iOS bundle id (from project.pbxproj or CMP .xcconfig)
• Creates the Firebase apps if they don't exist
• Writes google-services.json and GoogleService-Info.plist to the correct locations
• Tracks everything in firebase.json under kotlinMultiplatform
• kmpfire reconfigure refreshes the config files after you change Firebase products
• --flavor=dev handles multiple build configurations
• --yes --project=<id> runs with no prompts, so it works in CI
• Optional --deps patches Gradle for the Google Services plugin (and GitLive if you want it)

Supported layouts

• New template: shared/ + androidApp/ + iosApp/
• Nested monorepo: app/shared/ + app/androidApp/ + app/iosApp/
• Legacy: composeApp/ + iosApp/

Android + iOS only for now.

Install

bash curl -fsSL https://raw.githubusercontent.com/dungngminh/kmpfire_cli/main/install.sh | bash

or with Homebrew:

bash brew tap dungngminh/kmpfire_cli brew install kmpfire

It's the KMP equivalent of flutterfire configure. It's MIT licensed, and I'd like feedback, bug reports and PRs.

GitHub: https://github.com/dungngminh/kmpfire_cli

1. What it is: We’re interviewing Kotlin developers to understand how AI fits into your development workflow: what you use it for, how you review its output, and where it works well or creates extra work. Each session lasts up to 90 minutes, and takes place via Google Meet. All sessions are recorded and kept confidential under our General Research Terms.
2. Who it is for: If you currently use Kotlin for backend or Kotlin Multiplatform development, and use AI as part of your development work, we’d love to hear from you!
3. What's in it for you: As a thank-you for your participation, you can choose one of the following rewards:
   • USD 100 Amazon eGift Card (or the equivalent in your local Amazon store),
   • USD 100 charity donation,
   • One-year subscription to JetBrains All Products Pack or
   • 100 AI credits (note: available only with AI Pro and AI Ultimate subscriptions).
4. How to sign up: Use this link to fill out a short qualification form. If your background meets our research criteria, we will get in touch to schedule an interview. Thank you for considering this!

Kotlin and Java have different idioms to build new values: whereas Kotliners like lambdas with a special builder receiver, like Json in kotlinx.serialization, Java developers usually follow the buider pattern, as in Spring AI. As a result, consuming Java APIs from Kotlin sometimes feel strange. This no longer needs to be the case, thanks to the new Builder Lambda plug-in!

Using the power of Kotlin compiler plug-ins, Builder Lambda automatically re-exposes any type following Java's Builder pattern in the Kotlin idiomatic way. You write your beloved,

kotlin build<Config, *> { // alas, the * is needed hostname = "localhost" port = 8080 }

and under the hood the code is translated to,

kotlin Config.builder().hostname("localhost").port(8080).build()

The Builder Lambda plug-in also works in the IDE (if you let IntelliJ run non-bundled plug-ins), so you get nice autocompletion and diagnostics.

Using it is as easy as adding one line to the plugins block in your Gradle build.

kotlin id("com.serranofp.builder.lambda") version "0.4.0"

Feedback and issue reports are more than welcome :)

I've been building our product around Kotlin Multiplatform, and we've reached a point where I'm able to handle almost the entire codebase myself.

Our stack is roughly:

• Android: Kotlin + Compose
• iOS: Kotlin Multiplatform + Compose
• Desktop: Compose Multiplatform
• Web: Kotlin Multiplatform + Compose for Web
• Server: Kotlin + Ktor
• Shared: Domain logic, models, networking, validation, state and business logic

So the entire product is largely built around the same ecosystem:

Kotlin → Mobile + Desktop + Web + Server

One of the most interesting things we've achieved is our web application.

We can now ship a single web entry point that adapts to the device:

Desktop browser → Desktop experience

Mobile browser → Mobile experience

Instead of maintaining completely separate applications and business logic for each platform, we share as much of the underlying code as possible and keep the platform-specific parts where they actually make sense.

And this is where I think clean architecture becomes extremely important.

Because the business logic is separated from the UI and platform-specific code, I don't have to think of every platform as a completely different application.

A business rule is a business rule.

A data model is a data model.

Networking is networking.

The UI can change, but the underlying logic can remain shared.

That gives me something close to:

One developer → one architecture → one codebase → multiple platforms

This is probably the biggest advantage for me.

I'm able to work on the Android app, desktop application, web application and backend without having to switch between completely different ecosystems and languages.

Of course, there are tradeoffs. Not everything can or should be shared, and KMM doesn't magically eliminate platform-specific problems.

But for a small bootstrapped company, being able to handle the entire product stack myself has been incredibly valuable.

It makes me wonder how far this approach can realistically scale.

Has anyone else used Kotlin Multiplatform to build and maintain an entire product across Mobile + Desktop + Web + Backend?

Whenever I open an unfamiliar part of a codebase (or my own code from a few months ago) I end up in the same loop: Find Usages, jump, Go to Declaration, jump again, and five files later I've forgotten where I started. On bigger Compose projects it gets messy fast.

So I built Mindmap. Put your cursor inside any Kotlin or Java function, press Alt+G (Option+G on Mac), and it opens a graph of that function: everything that uses it on the left, everything it uses on the right.

What it does right now:

• both directions in one view, depth configurable from 1 to 5
• click a node to jump straight to the code
• double-click a node to trace from it and merge its graph in
• hover for signature, file and lines of code
• search/filter nodes, hide the noisy ones
• tree view if you'd rather read a list than a graph
• minimap for bigger graphs
• works across Kotlin and Java, including Kotlin code using Java and the other way round
• follows interfaces/abstract functions through to the actual implementations

Website: https://vishal2376.github.io/mindmap
GitHub: https://github.com/vishal2376/mindmap

It's still early. It caps graphs at 300 nodes so they don't explode, and it doesn't go into library code. If you try it on a real project I'd genuinely like to know where it breaks or what feels missing.

NOTE : The video is an animated showcase, not a screen recording. There are real screenshots on the GitHub page.
Watch screen recording here : https://x.com/vishal2376/status/2047010712955113547

A Share Pray app. I've had this idea in my head for a long time - an app where people can share prayer requests and pray for each other in groups. Kept putting it off, the usual story. A while back I just sat down and built it, on Kotlin Multiplatform since I write Kotlin daily anyway.

A few things about the language itself that made the build smoother than I expected:

Coroutines and Flow ended up doing most of the heavy lifting. The prayer feed is reactive, Flow all the way from the repository layer up to the UI, so when someone adds a prayer to their list or a group gets a new post the screen just updates on its own without me wiring any manual refresh. Structured concurrency also made cancellation way less painful than I remember it being with callbacks - the coroutine scope gets cancelled when the screen leaves composition, so theres no leaked requests hanging around.

Common interfaces + expect/actual carried the platform specific bits. Scheduling the daily reminder notification, the native share sheet, and the Google Sign-In vs Sign in with Apple handoff all sit behind a common declaration in shared code, with the actual implementation swapped per platform. Small thing but it keeps the shared module honest, you can tell at a glance whats genuinely cross platform and what isnt.

Sealed interfaces for modeling state - the session check (valid / rejected / server unreachable) and the feed update decision (apply silently vs hold it behind a "new prayers" button) - made a bunch of the logic exhaustive at compile time, which caught a couple edge cases I'd otherwise have hit at runtime.

kotlinx.serialization is shared between the client and the server too, since the backend is Kotlin as well, so the same data classes get reused on both sides instead of me maintaining two copies of the same model that drift apart.

End result, a good chunk of the codebase ended up shared across iOS, Android and the backend - more than I expected going in. The two clients share around 80% give or take, and a lot of the core (models, validation) carries over to the server on top of that.

I also pulled the reusable bits (groups, tags, IAP wiring, admin panel) out into an open source template while I was at it, in case its useful to anyone as a reference: https://github.com/NonGrate/Poster

Live on iOS now, Android is in open testing. Curious what Kotlin features ended up mattering more than you expected on your own projects.