Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

Post-Hoc Tracing Using a Debugger

DZone's Guide to

Post-Hoc Tracing Using a Debugger

· DevOps Zone
Free Resource

Download the blueprint that can take a company of any maturity level all the way up to enterprise-scale continuous delivery using a combination of Automic Release Automation, Automic’s 20+ years of business automation experience, and the proven tools and practices the company is already leveraging.

One nice little feature of most debuggers that I have been exercising recently is the ability to log information on a breakpoint. This can be a really useful way to understand code without having to modify it or involve byte code modification.

Let's consider this very trivial and inefficient implementation of a function to return the n'th number in the Fibonacci sequence.

    public class Fib {  
      
      
      
        public long fib(long number) {  
            return number < 1 ? 0 :    // Breakpoint here  
                number < 2 ? 1 : fib(number - 2) + fib(number - 1);  
        }  
      
      
      
      
        public static void main(String[] args) {  
      
            Fib fib = new Fib();  
            System.out.println(fib.fib(10L));  
      
        }  
      
    }  

Now we add a simple breakpoint, I am going to modify it slightly so that it doesn't halt; but it will log a simple expression which gives us the current value of number

This gives you the following output for our rather inefficient code:

ebugger connected to local process.
Source breakpoint: Fib.java:11, evaluate(number)=10 (long)
Source breakpoint: Fib.java:11, evaluate(number)=8 (long)
Source breakpoint: Fib.java:11, evaluate(number)=6 (long)
Source breakpoint: Fib.java:11, evaluate(number)=4 (long)
Source breakpoint: Fib.java:11, evaluate(number)=2 (long)
Source breakpoint: Fib.java:11, evaluate(number)=0 (long)
Source breakpoint: Fib.java:11, evaluate(number)=1 (long)
Source breakpoint: Fib.java:11, evaluate(number)=3 (long)
Source breakpoint: Fib.java:11, evaluate(number)=1 (long)
Source breakpoint: Fib.java:11, evaluate(number)=2 (long)
... sometime later
Source breakpoint: Fib.java:11, evaluate(number)=1 (long)
Source breakpoint: Fib.java:11, evaluate(number)=2 (long)
Source breakpoint: Fib.java:11, evaluate(number)=0 (long)
Source breakpoint: Fib.java:11, evaluate(number)=1 (long)
55

So what we have done here is to add trace post-hoc, you might not even have access to the source and still be able to get useful information out of what the code is doing.

Now the obvious take away from the above example is that we are computing the same value over and over again. So here is another version of the code which instead uses a Map to store previously computed values in the sequence. Note also it is more of a pain to add trace to this code than in the previous case without making the Lambda less pretty.

    import java.util.HashMap;  
    import java.util.Map;  
      
    public class Fib {  
      
      
        Map<Long, Long> data = new HashMap<>();  
        {  
            data.put(1L, 1L);  
        }  
      
      
        public long fib(long number) {  
            return data.computeIfAbsent(number,  
                          n -> n < 1 ? 0 : fib(n - 2) + fib(n - 1)); // Breakpoint here  
        }  
      
      
      
      
        public static void main(String[] args) {  
      
            Fib fib = new Fib();  
            System.out.println(fib.fib(10L));  
      
        }  
      
    }  

It is worth noting two things here: first of all, your breakpoint log expression should be evaluating the value of the Lambda parameter n, and the second is that you should always put your expression on a new line so that future developers can easily breakpoint it. (Not matter now much smaller/ prettier/ clever it would look if you put the code on one).

So the trace output is now as follows, much better as each value is only computed the once.

Debugger connected to local process.
Source breakpoint: Fib.java:17, evaluate(n)=10
Source breakpoint: Fib.java:17, evaluate(n)=8
Source breakpoint: Fib.java:17, evaluate(n)=6
Source breakpoint: Fib.java:17, evaluate(n)=4
Source breakpoint: Fib.java:17, evaluate(n)=2
Source breakpoint: Fib.java:17, evaluate(n)=0
Source breakpoint: Fib.java:17, evaluate(n)=3
Source breakpoint: Fib.java:17, evaluate(n)=5
Source breakpoint: Fib.java:17, evaluate(n)=7
Source breakpoint: Fib.java:17, evaluate(n)=9
55

The screen grabs in this blog are from Jdeveloper; but similar features are available in Intelij, Netbeans and if you are a bit crafty you can get something similar in Eclipse.

Download the ‘Practical Blueprint to Continuous Delivery’ to learn how Automic Release Automation can help you begin or continue your company’s digital transformation.

Topics:

Published at DZone with permission of Gerard Davison, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}