Automatically add debug contents to a program

Question

Sometimes I'll use Print[1] or Print[n] to debug in a long loop, but it's really a boring job to add these sentence by sentence and removing them sentence by sentence. (It's already boring to read this first three lines sentence by sentence so you can imagine how boring it is to add these stuff sentence by sentence. :P) So my question is how to throw this job to a program?

Let's take this small (and stupid) program as an example:

Do[j=i^2;Thread[{{1},{2,3}}],{i,3}]

I would like to add two Print in this program to determin where the problem occurs.

Do[Print@1;j=i^2;Print@2;Thread[{{1},{2,3}}],{i,3}]

In this way I can know that it's the second step that goes wrong.

Any idea how to do this automatically?

Answer 1

In your example, a message is issued at the problem. You want to find out where the message comes from. The debugger is pretty good at this. Just enable the debugger, then enable Break at Messages, then evaluate your code.

• You get a nice display of the stack, which in itself allows you to localize the problem.

• Since this was an interactive evaluation, the problem is also highlighted in the notebook

• If we had a Module there, we could see its local variables in the Stack window, with their values.

• Evaluation is suspended in you're in a dialog. You can evaluate things and examine the kernel state. Evaluating i gives 1 (even though i is a local variable.

• You could even put Dynamic[i] in a new windows and watch i change live as you step through the code.

In my opinion, I think the debugger is way underrated. The big problem with it is that it has a breakpoints feature, like traditional debuggers, and people try to use this then get frustrated. There are many reasons why breakpoints just don't fit Mathematica well. Don't use them. The other features work well.

When I do need a breakpoint, I explicitly insert an Assert[False] in the code and enable Break at Asserts.

I know this does not answer your actual question, but I hope you will still find it useful to solve your problem ...

Answer 2

Actually form C.E.'s comment.

Make a custom function for this

SetAttributes[AddPrint, HoldFirst]
AddPrint[loopBody_] := 
 Module[{st = ToString[Unevaluated[loopBody], InputForm], i = 0}, 
  StringReplace[st, 
   RegularExpression["^|(?<=;)"] :> TemplateApply["Print[``];", ++i]]]

It can help you add Print into your loopBody automatically

loopBody = AddPrint[j = i^2; a + b; Thread[{{1}, {2, 3}}]]

Print[1];j = i^2;Print[2]; a + b;Print[3]; Thread[{{1}, {2, 3}}]

Answer 3

I often use the form

Block[{Print=Identity}, expr]

to suppress Print statements that I have added for debug purposes.

Answer 4

My code is executed in two distinct environments: inside WorkBench where I test it, and automatically by kernel. Inside WorkBench $Linked is True, so I set the following:

If[$Linked,
  dbPrint = Print;
];

Then, when I need a debug print out, I used dbPrint which only has a value when being run inside of WorkBench, and does not effect production code. Obviously, other environment specific code can be added to the If statement as needed.

Answer 5

Rather than mangling the code by inserting Print/Echo statements into it, you could modify CompoundExpression during run-time. Here is a function that does this:

SetAttributes[injectTiming, HoldFirst]

injectTiming[code_, instance_:Automatic] := Module[{ilevel = 1, target},
    target = Replace[instance, Except[_Integer?Positive] -> 1];
    Internal`InheritedBlock[{Internal`$ContextMarks=False, CompoundExpression},
        Unprotect[CompoundExpression];
        CompoundExpression[a__] /; (ilevel++ == target) := compoundExpression[a];
        code
    ]
]

SetAttributes[compoundExpression,HoldAll];

compoundExpression[a___, b_]  := Module[{last},
    Apply[
        List,
        Function[Null, Print[First @ AbsoluteTiming[#;], ": ", HoldForm[#]], HoldFirst] /@ Hold[a]
    ];
    last = AbsoluteTiming[b];
    Print[First @ last, ": ", HoldForm[b]];

    Last @ last
]

The second argument specifies which CompoundExpression instance should be modified with debug information, with default being the first. For your example:

injectTiming[Do[j=i^2; Thread[{{1},{2,3}}], {i,3}]]

3.*10^-6: j=i^2

Thread::tdlen: Objects of unequal length in {{1},{2,3}} cannot be combined.

0.00228: Thread[{{1},{2,3}}]

Thread::tdlen: Objects of unequal length in {{1},{2,3}} cannot be combined.

Thread::tdlen: Objects of unequal length in {{1},{2,3}} cannot be combined.

General::stop: Further output of Thread::tdlen will be suppressed during this calculation.

Answer 6

Yesterday I checked my account's question list again and find this question lying inside. After a year wrestling mostly with Hold stuffs, I think I finally found a, well, not that elegant solution. Any suggestions or new answers are surely welcomed!!!

It seems that this question is not that bad, actually I may say that It's quite hard for one to solve this problem using all sorts of evaluation manipulation techniques. and it has real applications sometimes.

---

As usual, my code first:

SetAttributes[adddebug, HoldFirst]
adddebug[orig_, func_: Echo, level_: {2}] :=
 Module[{$count = 1, tempf},
  Replace[
    Replace[Hold[orig], HoldPattern[CompoundExpression[comp__]] :> 
      Block[{}, 
       tempf @@ 
         Riffle[List @@ (Hold /@ Hold[comp]), 
          With[{$func = func, q = #}, Hold@$func@q] & /@ 
           Range[$count, ($count = $count + Length@Hold[comp] + 1) - 
             1], {2, -1, 2}] /; True],level], 
    tempf[seg__] :> 
     Block[{}, 
      tempf[Hold[CompoundExpression]] @@ (tempf /@ {seg}) /; True],level] /. tempf[Hold[seg_]] :> seg
  ]

adddebug[Do[j = i^2; Thread[{{1}, {2, 3}}], {i, 3}]]

The result is satisfying

Hold[Do[j = i^2; Echo[1]; Thread[{{1}, {2, 3}}]; Echo[2], {i, 3}]]

---

Some additional notes:

Why I say this question is not that trivial is because I should protect CompoundExpression and its content from evaluating while still need to operate on CompoundExpression's structure and use in place evaluation techniques extensively.

So I install protection in the following ways:

1. When pattern-matching, Use HoldPattern

2. Use unique symbol tempf as a medium to mark Where CompoundExpression previoulsly existed. Use tempf[Hold[CompoundExpression]].

3. make every element of CompoundExpression Hold at all times, and mark them using tempf[Hold[expr]]

4. I'm quite satisfied by the last ReplaceAll's design, as previously I’ve already make where should be CompoundExpression tempf[Hold[CompoundExpression]] and where should be CompoundExpression's element tempf[Hold[element]], Now I can safely use ReplaceAll once to make those stuffs back to their original form!

---

I still am looking foward to a better solution, so if anyone has any idea, post something, Thanks!