[Haskell-cafe] Re[2]: Debugging with GHCi.

[Bulat Ziganshin]

Hello Pepe,

Monday, July 3, 2006, 2:15:59 PM, you wrote:
> As you may know, this project was accepted for Google SoC and work started a
> few weeks ago. There are now some observable results that can be tested, and
> I have set up a wiki page at:
> http://haskell.org/haskellwiki/Ghci/Debugger

> As we are now approaching the less clear parts of the project your 
> impressions and ideas (either extense designs or small pointers) are very
> welcome. The designs for dynamic breakpoints and call traces are open issues
> yet.

i'm very pleased with this year's selection of SoC projects and
debugging is among the things i'm highly demanded. I personally
interested in debugging imperative C-like code, with abilities to set
breakpoints, watch (and change?) variable values, see "call stack"
(i think that closures stack should serve this need), see local
variables at each "call stack" level, evaluate expression and perform
IO actions

it's especially important for me to be able to use debugger inside
some IDE that will allow to set breakpoints and ask variables' values
directly inside the source code I'd written. i can recall the
following haskell IDEs: HIDE, EclipseFP, Haskell mode for Emacs,
Visual Haskell, WinGhci. I think their authors will say better what
kind of interface with debugger they prefer

imho, just console I/O interface should be enough for most IDEs, as
long as debugger's output can be non-ambiguously parsed. Gdb often
used to debug C++ programs inside IDEs in this way, i think that
cloning it's interface should make it easier to integrate GhcDebugger
support into IDEs

i also vote for simplest implementation of dynamic breakpoints - the
tight integration with IDEs, i.e. _features_, is more important than
efficiency (if i correctly understood that this may change only an
efficiency)

I also will appreciate ability to view call traces - it's the thing
that i really need sometimes, especially when debugging unexpected
exceptions like "head: empty list". It will be especially great to see
all variables' values at each execution moment. I don't have a great
ideas about representation of this trace. One obvious idea would be to
save some binary file and write special viewer for it, another
possible idea is to produce (gigantic) html with trace represented as
tree with usual '+' marks to expand each node.

ps: you will not get much answers - first, because it's a summer and
most Haskellers prefer at this time to set up breakpoints on bodies of
their girlfriends ;)  second - because this maillist don't have many
readers. i suggest you to dup your question into main Haskell list and
i cc'ed my answer to haskell-cafe in advance. but nevertheless your
project is really important to make Haskell more usable for everyday
work and Haskellers returned from their vacations will be glad to see
that their debugging tasks becomes much easier. please also write
exhaustive documentation at the end of your work so that ghci debugger
will not become "black hole" feature


-- 
Best regards,
 Bulat                            mailto:Bulat.Ziganshin at gmail.com