Am I correct in my understanding that

object

s have all the strengths and weaknesses of a regular Java static singleton?

One of the major problems of singletons is that they are accessible from anywhere and people don't inject them, so classes are coupled to the singleton implementation. If you use an interface, and you inject it, you can still declare an object as a default implementation.

Really hurting me now that the object is reading system variables to initialize itself but now I am starting some dockers using testcontainers and they get different ports and hosts and such but I can't set any of those system variables.

If the project is internal or bleeding-edge enough, you might also want to consider using

context

receivers as a mechanism to pass that object around. You'd simply make an

interface

out of the object, use that as a

context(MyInterface)

, and then at the very edge of your program you'd initialize the

MyInterface

object and use it in a

with

to pass it to those objects

Any example code I can look at @Youssef Shoaib [MOD]?

Very similar to extensions yes. I'll try to find some more meaningful example code, but it'd go something like this:

data class Config(val hostName: String, val port: Int)
class ConfigContext(val config: Config)
// Depending on taste, you might want to use just Config as a context, instead of a separate ConfigContext.
// It just depends on whether you want to access hostName directly, or you prefer to call config.hostName

context(ConfigContext)
fun connect() {
  makeConnectionWith("${config.hostName}:${config.port}")
}
context(Config)
fun shutdown() {
  shutdownServer("$hostName:$port")
}

// Usage

fun main() {
  with(ConfigContext(Config(/* query system properties */))) {
    connect()
    if(shouldShutdown) shutdown()
  }
}

@Henrik Johansson to introduce someone (including me) to context receivers.