Alex Staveley is a software professional passionate about software engineering and technical architecture. He blogs about architectural approaches, Java topics, web solutions and various technical bits and pieces. Alex is a DZone MVB and is not an employee of DZone and has posted 48 posts at DZone. You can read more from them at their website. View Full User Profile

Scala: Call Me By My Name Please?

01.24.2013
| 3599 views |
  • submit to reddit

In Java, when frameworks such as log4J became popular in Java architectures it was a common occurence to see code such as: 

if (logger.isEnabledFor(Logger.INFO)) {
   // Ok to log now.
   logger.info("ok" + "to" + "concatenate"  + "string" + "to" + "log" + "message");
}

It was considered best practice to always check if your logging was enabled for the appropriate level before performing any String concatenation. I even remember working on a project ten years ago (a 3G radio network configuration tool for Ericsson) where String concatenation for logging actually resulted in noticeable performance degradation.

Since then, JVMs have been optimised and Moore's Law has continued so that String concatenation isn't as much of a worry as it used to be.  Many frameworks (for example Hibernate), if you check the source code you'll see logging code where there is no check to see if logging is enabled and the string concatenation happens regardless.  However, let's pretend concatenation is a performance issue.  What we'd really like to do is remove the need for the if statements in order to stop code bloat.

The nub of the issue here is that in Java, when you call a method with parameters the values of the parameters are all calculated before the method is called. This why the if statement is needed.

simpleComputation(expensiveComputation());// In Java, the expensive computation is called first.
logger.log(Level.INFO, "Log this " + message);// In Java, the String concatenation happens first

Scala provides a mechanism where you can defer parameter evaluation.  This is called call-by-name.

def log(level: Level, message: => String) = if (logger.level.intValue >= level.intValue) logger.log(level, msg)

The => before the String types means that the String parameter is not evaluated before invocation of the log function.  Instead, there is a check to confirm the logger level value is at the appropriate value and if so the String will then evaluated. This check happens within the log function so there is no need to put the check before every invocation of it. What about that for code re-use?

Anything else? Yes when pass-by-name is used, the parameter that is passed-by-name isn't just evaluated once but everytime it is referenced in the function it is passed to. Let's look at another example
scala> def nanoTime() = {
     |   println(">>nanoTime()")
     |   System.nanoTime // returns nanoTime
     | }
nanoTime: ()Long
 
scala> def printTime(time: => Long) = {    // => indicates a by name parameter
     |   println(">> printTime()")
     |   println("time= " + time)
     |   println("second time=" + time)
     |   println("third time=" + time)
     | }
printTime: (time: => Long)Unit
 
 
scala> printTime(nanoTime())
 
>> printTime()
>>nanoTime()
time= 518263321668117
>>nanoTime()
second time=518263324003767
>>nanoTime()
third time=518263324624587
In this example, we can see that nanoTime() isn't just executed once but everytime it is referenced in the function, printTime it is passed to.  This means it is executed three times in this function and hence we get three different times. 'Til the next time, take care of yourselves. 


Published at DZone with permission of Alex Staveley, author and DZone MVB. (source)

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)