oops | Short-lived , one-time access to secrets

Blessed Perl objects can't be stored in JSON without extra steps (mentioned by the error).

JsonUtility does not support nested json. So, modify your class properties and if you got rid of the nested json and your entire json simply looked like this, it should work (with the right quotes, etc):

I'm unsure if you want two columns or not, but with ms365:

Formula in D2:

In some sense, the mess you experience is a consequence of Kotlin coroutines having been an early success, before they became stable. In their experimental days, one thing they lacked was structured concurrency, and a ton of web material got written about them in that state (such as your link 1 from 2017). Some of the then-valid preconceptions remained with people even after their maturation, and got perpetuated in even more recent posts.

The actual situation is quite clear — all you have to understand is coroutine hierarchy, which is mediated through the Job objects. It doesn't matter whether it's a launch or an async, or any further coroutine builder — they all behave uniformly.

With this in mind, let's go through your examples:

First, there is actually a list of use cases for the motivation of the initial introduction of Result, if you find it interesting. Also in the same document:

The Result class is designed to capture generic failures of Kotlin functions for their latter processing and should be used in general-purpose API like futures, etc, that deal with invocation of Kotlin code blocks and must be able to represent both a successful and a failed result of execution. The Result class is not designed to represent domain-specific error conditions.

Most of what follows is my personal opinion. It's built from facts, but is still just an opinion, so take it with a grain of salt.

Note that runCatching catches all sorts of Throwable, including JVM errors like OutOfMemoryError, NoClassDefFoundError or StackOverflowError. IMO it is bad practice to use catch-all mechanisms like this unless you're implementing some kind of framework that needs to report errors in a different way (for instance Kotlinx Coroutines).

Apart from JVM errors, I believe exceptions due to programming errors shouldn't really be handled in a way that bloats the business code either (by this, I mean that result types are not very appropriate in this case). Using error(), check(), require() in the right places will make use of exceptions that often don't make sense to catch in business code (IllegalStateException, IllegalArgumentException). Again, maybe it could be relevant to catch them in framework code.

If you really need to express "I want to catch any exception for this piece of code in case there is a bug so I can still do that other thing", then it would make sense to use a try-catch(e: Exception) for this, but it shouldn't catch Throwable, so still no runCatching here.

That leaves business errors for result-like types. By business errors, I mean things like missing entities, unknown values from external systems, bad user input, etc. However, I usually find better ways to model them than using kotlin.Result (it's not meant for this, as the design document stipulates). Modelling the absence of value is usually easy enough with a nullable type fun find(username: String): User?. Modelling a set of outcomes can be done with a custom sealed class that cover different cases, like a result type but with specific error subtypes (and more interesting business data about the error than just Throwable).

So in short, in the end, I never use kotlin.Result myself in business code (I could consider it for generic framework code that needs to report all errors).

My adapters and services return a Result. Failures and stacktraces are logged but do nothing else

A side note on that. As you can see, you're logging errors in the service itself, but it's unclear from the service consumer's perspective. The consumer receives a Result, so who's reponsible with dealing with the error here? If it's a recoverable error then it may or may not be appropriate to log it as an error, and maybe it's better as a warning or not at all. Maybe the consumer knows better the severity of the problem than the service. Also, the service makes no difference between JVM errors, programming errors (IAE, ISE, etc.), and business errors in the way it logs them.

time.sleep is blocking, meaning that all code execution is stopped until the 5 seconds pass. Instead, use asyncio.sleep:

The buffer size of pipes isn't unlimited. You're creating a deadlock, where the child process is hanging because it's trying to write to a buffer that's full, and your parent process doesn't try to read anything from the buffer until the child process has completed. To fix the problem, you need to use another thread to read from the buffer while the child process is still running. The simplest way to do this is to use readProcess or a similar function in place of createProcess. If this doesn't give you enough flexibility to do what you want, then you'll need to create and manage the other thread yourself, which you can see how to do by looking at how readProcess is implemented.

For your first question try the following

Theoretically, if I understand the question right, you can just call stop() after x seconds when you call play()