JEP: Allow debug tools to detect mismatch btwn sourcecode and bytecode

[Staffan Larsen]

Hi Bruno,

This is an interesting proposal and I guess it would avoid a lot of unnecessary confusion for developers. 

As I understand it, the exact algorithm used to compute the fingerprint would need to be known to debuggers, or at least an implementation of it would need to be provided by the JDK. 

The proposed solution would require an addition to the class file format to store the fingerprint. Most likely in the form of a new “attribute”.

It would be interesting to hear opinions from debugger developers (netbeans, eclipse, intellij…) on this proposal.

Thanks,
/Staffan


> On 29 nov 2014, at 23:45, Bruno Borges <bruno.borges at oracle.com> wrote:
> 
> Hi all,
> 
> Based on a common incident that happens not rarely among developers, and as recently felt by Martijn Dashort [1], it seems to be a good idea to: "Enable debugger to detect when there is a mismatch between source code and class being debugged" (thanks to Stuart Marks for the excellent problem statement [2]).
> 
> [1] https://twitter.com/dashorst/status/538329707549560832
> [2] https://twitter.com/stuartmarks/status/538722163700674561
> 
> So I came up with the following JEP draft, and I'd like to have your input in this matter as well any comments, suggestions, etc.
> 
> --- JEP DRAFT BEGIN ---
> 
> Summary
> -------
> Enable debugger to detect when there is a mismatch between source code and class being debugged
> 
> Goals
> -----
> * Detect mismatch between the source code and the class bytecode being debugged
> * Allow for IDEs to identify through Debugger API such mismatch, enabling development of extensions
> 
> Motivation
> ----------
> To increase development productivity by avoiding developers on wasting time debugging the wrong source code
> 
> Description
> -----------
> Developers often find themselves debugging a Java application attached to their IDE, where the source code used to compile the bytecode being debugged is similar, but not the same. This leads to time wasted in understanding why some things behave differently, and sometimes developers blame the JVM, or the application server, or something in the runtime environment.
> 
> By providing a fingerprint to the source code used to compile a bytecode, when javac is configured to do so (example: -g:sourcefingerprint), and injecting that fingerprint into the bytecode, the Debugger API can then expose such information to IDEs and Debugger agents. The jdb command and the Java Debug Interface API may need to be extended to add such information.
> 
> Testing
> -------
> A test use case to validate this JEP is in the form of:
> - compile a Java class
> - modify the source code
> - run the bytecode initially compiled
> - debug the application
> - identify the mismatch that source code has been modified
> 
> Debug with jdb.
> 
> Risks and Assumptions
> ---------------------
> There is a risk of the source code match the bytecode, but not inherited classes, which means not only the class being debugged but its structure and inherited graph must also match.
> 
> The fingerprint must consider multiple data from the source code in order to be stringent:
> - sourcecode checksum
> - Java class structure
> - inheritance graph
> 
> It may be required to considered other form of data to build the fingerprint.
> 
> Dependences
> -----------
> Beyond the jdb tool and the Java Debug Interface, there are no other identified dependencies.
> 
> --- JEP DRAFT END ---
> 
> -- Bruno Borges // +5511995649058 LAD Principal Product Manager Exalogic | Cloud | CAF | Java