Haskell BerniePope.phd.Thesis

A Declarative Debugger forHaskell

Bernard James Pope

Submitted in total fulfilment of the requirements of

the degree of Doctor of Philosophy

December 2006

Department of Computer Science and Software Engineering

The University of Melbourne

Victoria, Australia

Abstract

This thesis is about the design and implementation of a debugging tool which helps

Haskell programmers understand why their programs do not work as intended. The

traditional debugging technique of examining the program execution step-by-step,

popular with imperative languages, is less suitable for Haskell because its unorthodox

evaluation strategy is difficult to relate to the structure of the original program

source code. We build a debugger which focuses on the high-level logical meaning

of a program rather than its evaluation order. This style of debugging is called

declarative debugging, and it originated in logic programming languages. At the

heart of the debugger is a tree which records information about the evaluation of

the program in a manner which is easy to relate to the structure of the program.

Links between nodes in the tree reflect logical relationships between entities in the

source code. An error diagnosis algorithm is applied to the tree in a top-down

fashion, searching for causes of bugs. The search is guided by an oracle, who knows

how each part of the program should behave. The oracle is normally a human

typically the person who wrote the program however, much of its behaviour can

be encoded in software.

An interesting aspect of this work is that the debugger is implemented by means

of a program transformation. That is, the program which is to be debugged is trans-

formed into a new one, which when evaluated, behaves like the original program

but also produces the evaluation tree as a side-effect. The transformed program is

augmented with code to perform the error diagnosis on the tree. Running the trans-

formed program constitutes the evaluation of the original program plus a debugging

iii

session. The use of program transformation allows the debugger to take advantage

of existing compiler technology a whole new compiler and runtime environment

does not need to be written which saves much work and enhances portability.

The technology described in this thesis is well-tested by an implementation in

software. The result is a useful tool, called buddha, which is publicly available and

supports all of the Haskell 98 standard.

iv

Declaration

This is to certify that

the thesis comprises only my original work towards the PhD except where

indicated in the Preface,

due acknowledgment has been made in the text to all other material used,

the thesis is less than 100,000 words in length, exclusive of tables, maps, bib-

liographies, and appendices.

v

Preface

This thesis is based in part on the original work presented in the following four peer

reviewed papers:

B. Pope. Declarative debugging with Buddha. In V. Vene and T. Uustalu,

editors, Advanced Functional Programming, 5th International School, volume

3622 of Lecture Notes in Computer Science, pages 273308. Springer-Verlag,

2005. (Invited paper).

The debugging example in Chapter 3 is taken from this paper.

The program transformation algorithm in Chapter 5 is an improved ver-

sion of the one discussed in this paper.

The method of observing values for printing in Chapter 6 is based on the

technique described in this paper, and also the following paper.

B. Pope and L. Naish. Practical aspects of declarative debugging in Haskell-

98. In Proceedings of the Fifth ACM SIGPLAN Conference on Principles and

Practice of Declarative Programming, pages 230240. ACM Press, 2003.

The re-evaluation scheme and method of debugging of I/O computations

in Chapter 7 are based on this paper, though greatly improved in the

current presentation.

vii

B. Pope and L. Naish. A program transformation for debugging Haskell-98.

Australian Computer Science Communications, 25(1):227236, 2003.

This paper describes an earlier version of the debugging program trans-

formation. The treatment of higher-order functions in this paper is the

basis of the scheme discussed in Chapter 5 and Chapter 6.

B. Pope and L. Naish. Specialisation of higher-order functions for debugging.

In M. Hanus, editor, Proceedings of the International Workshop on Functional

and (Constraint) Logic Programming (WFLP 2001), volume 64 of Electronic

Notes in Theoretical Computer Science. Elsevier Science Publishers, 2002.

This paper describes an earlier approach to transforming higher-order

functions. It is made obsolete by the new transformation described in

Chapter 5. We discuss this alternative approach in Chapter 8.

Lee Naish contributed to the development of this thesis. He was the secondary

author on three of the above-mentioned papers. In addition, the following parts are

based extensively on his work:

The definition of buggy nodes in Chapter 3.

The concepts of intended interpretations and inadmissibility in Chapter 4.

The use of quantifiers to handle partial values in derivations in Chapter 4.

The following items have not been previously published:

The more flexible definition of evaluation dependency in Chapter 3.

The performance measurements in Chapters 5 and 7.

The improved scheme for piecemeal EDT construction in Chapter 7.

viii

Acknowledgments

Lee Naish, my supervisor, is a pioneer in the field of declarative debugging and I

am honoured to work with him for so many years on this topic. Our relationship

began in 1997, when I was starting my honours year and keen to work in functional

programming. To my great fortune Lee had a project in debugging and was kind

enough to let me join in. It was quite clear that a single honours year was not

long enough, so I jumped at the chance to continue with a PhD. In my quest for

the elusive debugger I have stumbled, taken many wrong paths, and backtracked

frequently over well-trodden ground. Such meandering would test even the most

patient of souls, yet Lee was happy to let me explore, and always ready to offer

sound advice and directions when I needed them. Thank you Lee for supporting me

on this long journey, I have enjoyed your friendship and guidance every step of the

way.

I am also greatly indebted to Harald Sndergaard, my co-supervisor, for leading

me to functional programming so many years ago and showing me how stimulating

Computer Science can be. I will never forget the day that I became a functional

programmer. It was in Haralds class, he was explaining with his usual enthusiasm

the elegance of a line of Haskell code though he made it seem like it was a line

of poetry. From then on I was converted.

I must also thank Lee and Harald for proof reading earlier drafts of this thesis.

Along the way I have had many functional programming comrades and it would

be remiss of me not to give them praise. Foremost is Kevin Glynn, a truly great

friend, keen functional programmer, and Wolves supporter. I have many fond mem-

ix

ories of my time spent with Kevin, in the office, on the soccer pitch (or in the

stadium) and also in the pub. I hope that one day we will share the same continent

again. I would like to thank all the members of the functional programming group

for their support. A PhD can be an isolating experience and it was encouraging to

have so many people to lend their ears. Thanks also to the many Mercurians who

looked on with interest and provided much inspiration and competition to us lazy

Haskellites.

For almost all of this degree I lived with Steve Versteeg, a student himself,

who showed me how to live life to the fullest extent. We enjoyed many adventures

together and helped one another forget the harsh realities of deadlines and progress

reports.

Though there are many people to thank, none are more deserving of my gratitude

than my beloved family.

I am fortunate to have such kind and generous parents, Jan and Brian Pope.

They are my foundation in life and I am eternally indebted to them for their endless

support. I want to thank them for working so hard to allow me to pursue my

interests and encouraging me in whatever I choose to do (even when I go about it

so slowly). Thanks also to my sister Gabrielle Pope who has stood by me and urged

me along in a way that only a big sister can.

Outside of the offices and halls of the Computer Science department my life

changed in a most remarkable way. I met, and later married, my darling wife

Hui Nie Fu. She has been a constant source of love and happiness, and without

her help I would not have completed this thesis. I look forward to our life to-

gether, especially to exploring the world and visiting her family (my new family) in

Selatpanjang.

Finally, I would like to thank the Australian Federal Government for supporting

this thesis with an Australian Postgraduate Award.

x

Contents

1 Introduction 1

1.1 No silver bullet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2 Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.3 Debugging . . . . . . . . . .