Scala: call me by my name please?

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.
 

Reference: Scala: call me by my name please? from our JCG partner Alex Staveley at the Dublin’s Tech Blog blog.

Related Whitepaper:

Java Essential Training

Author David Gassner explores Java SE (Standard Edition), the language used to build mobile apps for Android devices, enterprise server applications, and more!

The course demonstrates how to install both Java and the Eclipse IDE and dives into the particulars of programming. The course also explains the fundamentals of Java, from creating simple variables, assigning values, and declaring methods to working with strings, arrays, and subclasses; reading and writing to text files; and implementing object oriented programming concepts. Exercise files are included with the course.

Get it Now!  

One Response to "Scala: call me by my name please?"

  1. Matthew Harrison says:

    For Java, check out java.util.logging.Logger.log(Level.INFO, “{0} {1}”, new Object[] { value1, value2 }) in the core,
    or log5j, or slf4j. (log4j is stuck where it is, as it is used by many legacy systems which are still stuck on Java 1.4. slf4j is the successor to log4j)

Leave a Reply


− 2 = four



Java Code Geeks and all content copyright © 2010-2014, Exelixis Media Ltd | Terms of Use
All trademarks and registered trademarks appearing on Java Code Geeks are the property of their respective owners.
Java is a trademark or registered trademark of Oracle Corporation in the United States and other countries.
Java Code Geeks is not connected to Oracle Corporation and is not sponsored by Oracle Corporation.

Sign up for our Newsletter

15,153 insiders are already enjoying weekly updates and complimentary whitepapers! Join them now to gain exclusive access to the latest news in the Java world, as well as insights about Android, Scala, Groovy and other related technologies.

As an extra bonus, by joining you will get our brand new e-books, published by Java Code Geeks and their JCG partners for your reading pleasure! Enter your info and stay on top of things,

  • Fresh trends
  • Cases and examples
  • Research and insights
  • Two complimentary e-books