A modern programming language that makes developers happier.

kotlinlang

Hey guys,

is it ok to use kotlin getter like that (theoretical example):

```val isTooLate: Boolean
   get() = System.currentTimeMillis() &gt; someTimestamp```
I find it confusing that hovering over it in the IDE gives:

_public final val isTooLate: Boolean_

which gives an impression that this value is going to be always the same - but it's not.

By final the IDE means that you are not able to set it to a different value, _i.e._ you can't call `isTooLate = false` or `isTooLate = true`.
Its _*definition*_ is final, even thought its _*result*_ may change.

you are right it is about forbidding to override it!

but reading some answers on stackoverflow on a `val` bit of it:

_*val* is like *Final* variable and it's known as immutable in *kotlin* and can be initialized only single time._

They point out that it is _immutable_ but in reality it is just a read only *var*iable - so it seems that ppl wrongly expect it to be immutable

Regarding the example I provided - in that situation, would you use `val` with `get {}`  or would you use a function `fun isTooLate(): Boolean`  ?

and that raises another question:

when to use argument-less function syntax?

That's more a style choice but would recommend following kotlin's own guidelines: <https://kotlinlang.org/docs/coding-conventions.html#functions-vs-properties>

Clearly the third point (returns the same result over invocations if the object state hasn't changed) doesn't hold here so a fun makes more sense

In fact you actually have a hidden external dependency in System.currentTimeMillis()

May be clearer and better for testing to have  something like
```fun isTooLate(currentTime: Long = System.currentTimeMillis())```

thanks, this coding-convetions is a very useful link!

yea, i know it can be clearer, i wanted to give an example where the returned value changes over time based on external events