views:

139

answers:

2

Hi all,

I've noticed recently that there's a few java libs (the JDK, joda time, iText) that compile without some/all of the debugging information. Either the local variable info is missing, or the both the local variable info and line numbers are missing.

Is there any reason for this? I realise it makes compiled code larger but I don't believe that's a particular large consideration. Or is it just building with the default compile options?

Thanks.

+13  A: 

The default compile options don't include debugging information, you must specifically tell the compiler to include it. There are several reasons why most people omit it:

  • Some libraries are used in embedded systems (like mobile phones). Until recently, every bit counted. Today, most mobiles come with more memory than all computers in 1985 had together ;)
  • When compiled with debugging active, the code runs 5% slower. Not much but again, in some cases every cycle counts.
  • Today's Senior Developers were born in a time when 64KB of RAM was enormous. Yesterday, I added another 2TB drive to my server in the cellar. That's 7 orders of magnitude in 25 years. Humans need more time to adjust.

[EDIT] As John pointed out, Java bytecode isn't optimized (much) anymore today. So the output of the class files will be the same for both cases (only the class file with debug information will be bigger). The code is optimized in the JIT at runtime which allows the runtime to optimize the code for the CPU, memory (amount and layout), etc.

The mentioned 5% penalty is when you run the code and add the command line options to allow a remote debugger to attach to the process. If you don't enable remote debugging, there is no penalty (except for class loading but that happens only once).

Aaron Digulla
Awesome answer!
Adrian
Further to that, when you compile with debugging enabled, you also compile without optimising code (otherwise the line-numbers would make no sense), so you lose out on the performance benefits of (static / final / private) methods / properties
iAn
@iAn: In Java, compiling with optimisations is generally pointless anyway - IIRC they've either removed the option or made it a no-op. You don't lose out on performance, because the optimisations are performed by the JIT instead.
Jon Skeet
Yes, today, Java code is optimized at runtime. The 5% speed penalty is actually when *running* the code with options to attach a remote debugger.
Aaron Digulla
A: 

Probably size of installation. Debug information adds overhead to the jar-files which Sun probably didn't like.

I had to investigate a Java Web Start issue recently - no debug information available - so adding full tracing to the java console and downloading the source code helped some, but the code is rather tangled so I'd just like a debug build.

The JDK should be compiled with FULL debug information everywhere!

Thorbjørn Ravn Andersen
FYI there is a DEBUG jar of JDK6u18 which contains the debugging info. It's around 20mb larger than the alternative. See here: http://download.java.net/jdk6/
Brian Harris