I got no answers on the compose channel, figured that maybe here I will have more luck and it seems to fit the theme. https://kotlinlang.slack.com/archives/CJLTWPH7S/p1693389803639179

Which do you prefer? When you use JPA in a Web MVC Spring framework application, what do you do when defining the

@ID

of an entity class? And

@Id

property is generated by database autoincrement. In this question, pk is not-null in the database, and there is discussion within the team about what value should be set as default before Entity persisted, so we are also asking the community's opinion. In this case, I dont discuss about using constructor each time when create instance.

1. nullable - var
@Entity
class Entity(
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  var id: Long? = null
)

2. nullable - val
@Entity
class Entity(
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  val id: Long? = null
)

3. non-null - var
@Entity
class Entity(
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  var id: Long = 0L
)

4. non-null - val
@Entity
class Entity(
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  val id: Long = 0L
)

Please share your voice and opinion free!

I'm using this class for Kafka deserialization and I'd like to wrap/extend it in some clean way so that result implements

Deserializer<GenericRecord>

instead of

Any

What approaches can I use for that?

I have this code snippet

.forEach {
    val (k, v) = it.split(':')
    meta[k.trim()] = v.trim()
}

I though I could make it more concise with

associateTo

, but I still need two lines

.associateTo(meta) {
    val (k, v) = it.split(':')
    k.trim() to v.trim()
}

unless I'm missing something, I'd revert to the first version

What's your opinion on using function/method references instead of lambdas for scope or library functions? Most of the code I've seen uses lambdas, e.g.

myList.map { transform(it) }
myString.takeIf { it.isNotEmpty() }

As an alternative, however, one could also use function/method references, e.g.

myList.map(::transform)
myString.takeIf(String::isNotEmpty)

Which convention do you prefer and why?

I have this class and a reified helper method:

package util
class JsonFetcher() {
...
    suspend fun <T> get(url: String, cls: TypeReference<T>): T {
        return mapper.readValue(diskCacheHttpClient.get(url), cls)
    }
}
suspend inline fun <reified T> JsonFetcher.get(content: String): T = get(content, jacksonTypeRef<T>())

but when I import the helper method I have to

import util.get

so its unclear that its the get method of JsonFetcher. is there a way to improve this?

If I have a generic function, is there a better way to type-bound it with unrelated types other than checking the instance of T to each possible bound? This is unrelated types like "could be an int, string, boolean, long, etc"

When using interfaces and implementations in Kotlin what is considered best practice?

interface UserRepository

and

class UserRepositoryImpl: UserRepository

or

interface IUserRepository

and

class UserRepository: IUserRepository

Or are there any alternative practices?

So no other way how to ensure new line at the end of file except .editorconfig file?

Do you prefer to use .editorconfig or codeStyle folder in git to have seamless shared formatting in the team?

I really wish there was a way to assure the compiler that this var will not be changed outside of this scope that way you didn't have to do !! for every call. Like it's a locally scoped var, its not going to get touched by another thread. to be clear - I 100% understand why an if statement vs a ?.let causes no smart cast vs a smart cast, I just wish there was a way you could do !! for an entire scope or something similar. Sure in this specific context of ksoup you could use a for loop and a safe called let, but it's just an example and I need to refer back to the last element for some processing so I can't do a for or a map. Or maybe some sort of loop where you do a snapshot inside. I guess I could write a scope function that does that, but all that does is move the silly while chained let somewhere else haha

Hey, a small question about variable naming. I have many

Endpoints

in my Multiplatform Project so that both js and jvm are always on the same page. For readability I have a singleton that just holds all the references to the actual

Endpoints

. Is there a more idiomatic way in general to do this or is this fine? Endpoints.kt

object Endpoints {
    // Keycloak
    val keyCloakNewToken = _keyCloakNewToken
    val keyCloakRefreshToken = _keyCloakRefreshToken
    val keyCloakUsers = _keyCloakUsers

    // Server
    val devices = _devices
    val changeDevice = _changeDevice
}

KeyCloakEndpoints.kt

val _keyCloakUsers = Endpoint(
    url = "/admin/realms/<realm>/users",
    method = EndpointMethod.GET,
    serializer = ArraySerializer(KeycloakUser.serializer())
)

val _keyCloakRefreshToken = Endpoint(
    url = "/realms/<realm>/protocol/openid-connect/token",
    method = <http://EndpointMethod.POST|EndpointMethod.POST>,
    serializer = AuthJwt.serializer(),
    header = mapOf(
        "Content-Type" to "application/x-www-form-urlencoded"
    ),
    requiredUrlEncodedBody = mapOf(
        "grant_type" to "refresh_token",
        "client_id" to "frontend",
        "refresh_token" to ""
    )
)

I read that only private Backingfields should start with an underscore, but I can't make them private here of course.

Is there a reason that neither an abstract function or it's eventual override implementation can supply default argument values?

Hey, currently I just give my Endpoint (think ktor and similar) a repository object. Now I want to put something in between because most calls need to do more than just save to repo, like auditing, sending MQTT, etc. What would you call that? Handler is a bit generic I feel.

Hey, which option do you think is better, or maybe you have another idea? a) Option A

class DoSomethingUseCase {

    fun handle(command: DoSomethingCommand) {
        TODO("not yet implemented")
    }
}

data class DoSomethingCommand(
    val someValue: String
)

b) Option B

class DoSomethingUseCase {

    fun handle(command: Command) {
        TODO("not yet implemented")
    }

    data class Command(
        val someValue: String
    )
}

Is there a standard idiom for making a range of a single value?

inline fun Char.toRange(): CharRange =
    this..this

@Test
fun `toRange creates a range with a single value`() {
    val range = 'Z'.toRange()
    assertEquals('Z', range.first)
    assertEquals('Z', range.last)
}

Is there a convention for getting all indices of a value in an array? I came up with this for ByteArrays, but wanted to make sure I wasn't missing a library method by an unfamiliar name

inline fun ByteArray.indicesOf(value: Byte): List<Int> =
    mapIndexed { index, byte -> index.takeIf { byte == value } }.filterNotNull()

I see that in the Google Style Guide it's recommended to use only lowercase for packages definition, is it also the case for module names, or is it fine to use camel case? I couldn't find a rule for #detekt about it, but with

PackageNaming

and

InvalidPackageDeclaration

, it seems that implicitly the convention is the same, just use lowercase

How do people handle wanting to add contextual information to an exception that is thrown? Say I have a function getUser() that can throw exceptions of various types for various (unknown) reasons. This function can be called multiple places, for example in getAdmins() and getCustomers() and I'd like to append contextual information in the callplace, to say what I was trying to do when the function failed

fun getAdmins(adminId: String) {
    try {
        getUsers(adminId)
    } catch (e: Exception) {
        // "Failed fetching admin by $adminId"
    }
}

Now I could wrap the existing exception in a new custom exception MyUserException("Failed ...", e) However this means I cannot catch the underlying exception specifically, and in most logging tools shows my wrapper rather than the often usefull underlying Exception. I could rethrow the exception, with a log statement

catch (e: Exception){
   log.error("Failed fetching admin...", e)
   throw e
}

However I dislike having multiple log entries from a single error, and puts the responsibility on me for "connecting the dots" of the different log statements.

How do you choose adding methods to dto/dao vs adding extension methods? My understanding is that everything should be an extension. But for some reason it feels like I am missing some good cases where it makes sense to add methods inside the dto/dao. Ps: I am not referring to complex business logic functions, these should reside elsewhere.

Do you prefer

if (rank == null) return BadRequest("Rank is missing")

or

rank ?: return BadRequest("Rank is missing")

?

How would you choose between the following two styles, factory functions ("from" functions) and extension functions ("to" functions)?

fun main() {
    val a = A(1)
    val b = B(2)
    
    println(b.toA()) //A(a=2)
    println(A.fromB(b)) //A(a=2)
}

data class B(val b: Int)
data class A(val a: Int){
    //1. "static converter" function
    companion object{
        fun fromB(b: B): A = A(b.b)
    }
}

//2. extension function
fun B.toA() = A(this.b)

Please let me know which KDoc you prefer or if you have better suggestions. It would be easier to write if the width and height parameters were named

width

(instead of

w

) and

height

(instead of

h

), but those are instance variables in the superclass (

JPanel

). I'm a professor creating a problem set, so there aren't team guidelines I can follow. I just want to set a good example. 1️⃣

/**
     * Draws a rectangle with the specified [x] and [y] coordinates,
     * [outlineColor], and [fillColor]. The parameters [w] and [h]
     * specify the width and height.
     */

2️⃣

/**
 * Draws a rectangle with width [w] and height [h] with the specified 
 * [x] and [y] coordinates,[outlineColor], and [fillColor].
 */

Is it correct formatting?

is String
                -> {
                0
            }

I would expect that closing bracket is on the level of arrow and body had indentation from arrow as well.

open class TestAbstract {
    
    init {
        onCreated()
    }
    
    open fun onCreated() {
        println("Applying base TestAbstract creation code on class '${this.javaClass.simpleName}'.")
    }
    
}

class Test1 : TestAbstract() {
    override fun onCreated() {
        super.onCreated()
        println("Applying Test1 specific creation code.")
    }
}

class Test2 : TestAbstract() {
    override fun onCreated() {
        super.onCreated()
        println("Applying Test2 specific creation code.")
    }
}

val test1 = Test1()
val test2 = Test2()

I know this is not encouraged, and the IDE shows a warning for calling

onCreated()

in the

init

block... although it seems to work on a simple class... i'm guessing on larger classes with more going on it could cause problems.... I'm curious though... if changing it to the following is just tricking the IDE to make the warning go away, or is it actually acceptable?

open class TestAbstract {
    init {
        created()
    }
    private fun created() {
        onCreated()
    }
    open fun onCreated() {
        println("Applying base TestAbstract creation code on class '${this.javaClass.simpleName}'.")
    }
}

This might be a useful convention: when creating a Composable that is only expected to function correctly in a certain scope such as BoxScope, we can make the Composable an extension function:

fun BoxScope.MyComposable()

even if the scope isn’t used, the constraint may be helpful

Which do you prefer? 1️⃣

if (isValidInput) {
    doSomething()
    doSomethingElse()
} else {
    handleInputError()
}

2️⃣

when {
    isValidInput -> {
        doSomething()
        doSomethingElse()
    }
    else -> handleInputError()
}

Is there a convention for deciding string forms of multiplicity? For instance,

0 Records

,

1 Record

,

2 Records

val recordSummary = listOf(records.size, records.singleOrNull()?.let { "Record" } ?: "Records").joinToString(separator = " ")

val recordSummary = listOf(records.size, if (records.size == 1) { "Record" } else { "Records" }).joinToString(separator = " ")

Which one do you prefer? 1️⃣

suspend fun <T : Any> handleApi(execute: suspend () -> T): Resource<T> {
    return try {
        val response = execute()
        Resource.Success(response)
    } catch (e: Exception) {
        Resource.Error(
            when (e) {
                is IOException -> ErrorType.Network
                is HttpException -> mapApiError(e.code())
                is SerializationException -> ErrorType.Serialization
                else -> ErrorType.Unknown
            }
        )
    }
}

2️⃣

suspend fun <T : Any> handleApi(execute: suspend () -> T): Resource<T> {
    return try {
        val response = execute()
        Resource.Success(response)
    } catch (e: IOException) {
        Resource.Error(ErrorType.Network)
    } catch (e: HttpException) {
        Resource.Error(mapApiError(e.code()))
    } catch (e: SerializationException) {
        Resource.Error(ErrorType.Serialization)
    } catch (e: Exception) {
        Resource.Error(ErrorType.Unknown)
    }
}

Hi! I'm wondering if there's any source or reference for the Documentation comments convention:

Generally, avoid using @param and @return tags

But why? Those tags seems useful for converting comments info other formats in my view