What's the difference between string template and log framework's placeholder in Kotlin?

Question

And now, I am trying to rewrite my java application in Kotlin. And then, I met the log statement, like

log.info("do the print thing for {}", arg);

So I have two ways to do the log things in Kotlin like log.info("do the print thing for {}", arg) and log.info("do the print thing for $arg"). The 1st is delegate format to framework like Slf4j or Log4j; the 2nd is using Kotlin string template.

So what's the difference and which one's performance is better?

Answer 1

In general, these two ways produce the same log, unless the logging library is also configured to localise the message and parameters when formatting the message, which Kotlin's string interpolation does not do at all.

The crucial difference lies in the performance, when you turn off logging (at that particular level). As SLF4J's FAQ says:

There exists a very convenient alternative based on message formats. Assuming entry is an object, you can write:

Object entry = new SomeObject();
logger.debug("The entry is {}.", entry);

After evaluating whether to log or not, and only if the decision is affirmative, will the logger implementation format the message and replace the '{}' pair with the string value of entry. In other words, this form does not incur the cost of parameter construction in case the log statement is disabled.

The following two lines will yield the exact same output. However, the second form will outperform the first form by a factor of at least 30, in case of a disabled logging statement.

logger.debug("The new entry is "+entry+".");
logger.debug("The new entry is {}.", entry);

Basically, if the logging is disabled, the message won't be constructed if you use parameterised logging. If you use string interpolation however, the message will always be constructed.

Note that Kotlin's string interpolation compiles to something similar to what a series of string concatenation (+) in Java compiles to (though this might change in the future).

"foo $bar baz"

is translated into:

StringBuilder().append("foo ").append(bar).append(" baz").toString()

See also: Unable to understand why to use parameterized logging