Printf Debugging Revisited

gsasha writes "After long nights spent in debugging, w e have developed a C++ logging facility geared for debugging - and an article that describes our debugging methodology. The article consists of two parts: the first one describes the basics of the method, and the second one presents advanced techniques (to be completed if there is enough reader interest).
Happy debugging!"

Comments

C++ makes it hard

[YGingras]

It's hard to do a good printing debugger in C++. The lack of introspection throws most of the work in the hands of the pre-processor/developper.

When I learned Common Lisp, the first macro I did was for printing debugging. It reads the expresions it is debugging, prints it (and shortens it with "..." if needed), evaluates it, prints the results and returns the results.

What a monster you might say. Lets fist see an example of it's use:

CL-USER> (+ 16 34 (- 6 7 8) (/ (* 3 (expt 4 1/2)) 2 3))
42.0
CL-USER> (dbg (+ 16 34 (dbg (- 6 7 8)) (dbg (/ (* 3 (dbg (expt 4 (/ 1 2)))) 2 3))))
(- 6 7 8): -9
(EXPT 4 (/ 1 2)): 2.0
(/ (* 3 (DBG (EXPT 4 (/ 1 2)))) 2 3): 1.0
(+ 16 34 (DBG (- 6 7 [...] 4 (/ 1 2)))) 2 3))): 42.0
42.0

It's done like that (and it's actually readable when indented properly):

(defmacro dbg (expr)
`(let ((val ,expr)
(repr (format nil "~A" ',expr)))
(if (> (length repr) 50)
(format t "~A [...] ~A: ~A~%"
(subseq repr 0 20)
(subseq repr (- (length repr) 20))
val)
(format t "~A: ~A~%" repr val))
val))

Most of the hard work is taken away by the ability of the program to read itself, by dynamic typing and by the notion that there are no statements, only expressions. That being said, I don't claim that you should never use C++, just that it lacks introspection and that it makes printing debuging a lot harder.

Re:log4c++

[Mysteray]

we have developed a C++ logging facility geared for debugging

My first reaction to this was, who hasn't?

I agree with some of the other posters that their code has some, well, "interesting" features. I have to say it never would have occurred to me to use strcmp on a compile-time constant in a member initialization.

That they use, but don't derive from, std::ostream for this is another example. It's not exactly trivial to do so, but it's also hard to argue against not doing it for something like this without good reason. But since there's not a single comment in the source files except some revision control macros we're just left to wonder.