[PPT] - 1 From Stack Traces to Lazy Rewriting Sequences Stephen Chang , Eli PowerPoint Presentation

SLIDE 1

1

SLIDE 2

From Stack Traces to Lazy Rewriting Sequences

Stephen Chang, Eli Barzilay, John Clements*, Matthias Felleisen Northeastern University *California Polytechnic State University

10/5/2011

2

SLIDE 3

Debugging lazy programs is hard.

3

SLIDE 4

Freja (Nilsson and Fritzson 1992) Hat (Sparud and Runciman, 1997) Buddha (Pope, 1998) HOOD (Gill, 2000) New Hat (Wallace et al., 2001) HsDebug (Ennals and Peyton Jones, 2003) Rectus (Murk and Kolmoldin, 2006) GHCi debugger (Marlow et al., 2007) StackTrace (Allwood et al., 2009)

4

SLIDE 5

Freja (Nilsson and Fritzson 1992) Hat (Sparud and Runciman, 1997) Buddha (Pope, 1998) HOOD (Gill, 2000) New Hat (Wallace et al., 2001) HsDebug (Ennals and Peyton Jones, 2003) Rectus (Murk and Kolmoldin, 2006) GHCi debugger (Marlow et al., 2007) StackTrace (Allwood et al., 2009)

What do you think is Haskell's most glaring weakness / blind spot / problem? [Tibell, Knowlson 2011]

Inadequate Tools (50%)

5

SLIDE 6

[State of Haskell Survey 2011]

6

SLIDE 7

[State of Haskell Survey 2011]

"A debugger adjusted to the complexity of debugging lazily evaluated structures." (weeks)

7

SLIDE 8

[State of Haskell Survey 2011]

"A debugger adjusted to the complexity of debugging lazily evaluated structures." (weeks) "Laziness is hard to come to grips with. It's powerful and good, but it also causes strange problems that a beginner often cannot diagnose." (months)

8

SLIDE 9

[State of Haskell Survey 2011]

"A debugger adjusted to the complexity of debugging lazily evaluated structures." (weeks) "Laziness is hard to come to grips with. It's powerful and good, but it also causes strange problems that a beginner often cannot diagnose." (months) "I think that a good debugger that lets me step through a program /quickly and comfortably/ would be a great help." (1yr)

9

SLIDE 10

[State of Haskell Survey 2011]

"A debugger adjusted to the complexity of debugging lazily evaluated structures." (weeks) "Laziness is hard to come to grips with. It's powerful and good, but it also causes strange problems that a beginner often cannot diagnose." (months) "I think that a good debugger that lets me step through a program /quickly and comfortably/ would be a great help." (1yr) "I'd love to see some debugging (~step by step evaluation/run tracing) support." (2yrs)

10

SLIDE 11

[State of Haskell Survey 2011]

"A debugger adjusted to the complexity of debugging lazily evaluated structures." (weeks) "Laziness is hard to come to grips with. It's powerful and good, but it also causes strange problems that a beginner often cannot diagnose." (months) "I think that a good debugger that lets me step through a program /quickly and comfortably/ would be a great help." (1yr) "I'd love to see some debugging (~step by step evaluation/run tracing) support." (2yrs) "Debugging lazy code" (4 yrs)

11

SLIDE 12

[State of Haskell Survey 2011]

"A debugger adjusted to the complexity of debugging lazily evaluated structures." (weeks) "Laziness is hard to come to grips with. It's powerful and good, but it also causes strange problems that a beginner often cannot diagnose." (months) "I think that a good debugger that lets me step through a program /quickly and comfortably/ would be a great help." (1yr) "I'd love to see some debugging (~step by step evaluation/run tracing) support." (2yrs) "Debugging lazy code" (4 yrs)

Better lazy step-based tools are needed.

12

SLIDE 13

What's a "step"?

13

SLIDE 14

HsDebug

[Ennals and Peyton Jones 2003]

14

SLIDE 15

HsDebug

[Ennals and Peyton Jones 2003]

Evaluate expressions optimistically.

15

SLIDE 16

HsDebug

[Ennals and Peyton Jones 2003]

Evaluate expressions optimistically.
To preserve lazy behavior, handle special cases:

non-termination errors

16

SLIDE 17

HsDebug

[Ennals and Peyton Jones 2003]

Evaluate expressions optimistically.
To preserve lazy behavior, handle special cases:

non-termination errors

Too difficult to implement.

17

SLIDE 18

Idea #1:

Debugger shouldn't change the program evaluation model.

18

SLIDE 19

GHCi Debugger

[Marlow et al. 2007]

19

SLIDE 20

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.

20

SLIDE 21

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

21

SLIDE 22

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

22

SLIDE 23

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

23

SLIDE 24

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

24

SLIDE 25

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

25

SLIDE 26

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

26

SLIDE 27

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

27

SLIDE 28

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

28

SLIDE 29

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

29

SLIDE 30

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

30

SLIDE 31

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

31

SLIDE 32

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

32

SLIDE 33

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

33

SLIDE 34

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

34

SLIDE 35

GHCi Debugger

[Marlow et al. 2007]

Shows the effects of laziness.
"having execution jump around can be distracting and confusing"

test1 x y = (test2 y) + x test2 x = x * 2 test3 x = x + 1 main = print $ test1 (1 + 2) (test3 (3 + 4))

Step semantics correspond to low-level implementation
- unfamiliar to programmers.

35

SLIDE 36

Idea #2: