brianguertin

A similar project is Mosaic.

It's exactly the same concept, but for Jetpack Compose, the primary toolkit used in modern Android apps.

You can use it in desktop JVM apps written in Kotlin.

https://github.com/JakeWharton/mosaic

Like this? https://www.ubisoft.com/en-us/game/assassins-creed/discovery...

There's an exciting desktop port of https://developer.android.com/jetpack/compose done by Jetbrains: https://github.com/JetBrains/compose-jb

> how do you distinguish 'telemetry' from 'surveillance'?

Granularity. Telemetry data can be privacy-respecting (e.g. anonymously aggregated) while still being useful.

E.g. "143 people flew from NYC to LA this month" vs. "John Smith flew from NYC to LA at 2:00 pm on Tuesday."

Also see Kotlin: https://kotlinlang.org/docs/multiplatform.html

In Kotlin you can write a library usable from C/C++/ObjC/Swift/Java/JavaScript.

Same thing happened while I worked at Turo. They pivoted from "If we all shared our cars, we won't need as many! Less traffic and better for the environment!" to "We need to optimize for people who are buying cars/fleets and renting them out like a business, as they bring us the most value"

Mac and Linux actually use the same printer stack: https://en.wikipedia.org/wiki/CUPS

Oh cool. And does that actually work? That's great.

And the syntax is surprisingly similar, especially considering we are supposedly comparing a low level language to a high level one.

You aren't the only one. In Kotlin, it's possible to use async/await without modifying your function signatures. Like this:

  val result = runBlocking {
    val one = async { doSomethingUsefulOne() }
    val two = async { doSomethingUsefulTwo() }
    one.await() + two.await()
  }

https://kotlinlang.org/docs/reference/coroutines/composing-s...

EDIT: actually this was wishful thinking, since both functions would block the main thread. The functions need to be modified to "suspend" for this to be truly async.

My ideal language would be something like Kotlin suspend semantics, except ALL functions were implicitly "suspend" functions. If that's even possible...