research-article

Finding the needle: stack traces for GHC

Authors:

Tristan O.R. Allwood,

Simon Peyton Jones,

Susan EisenbachAuthors Info & Claims

Haskell '09: Proceedings of the 2nd ACM SIGPLAN symposium on Haskell

Pages 129 - 140

https://doi.org/10.1145/1596638.1596654

Published: 03 September 2009 Publication History

Get Access

Abstract

Even Haskell programs can occasionally go wrong. Programs calling head on an empty list, and incomplete patterns in function definitions can cause program crashes, reporting little more than the precise location where error was ultimately called. Being told that one application of the head function in your program went wrong, without knowing which use of head went wrong can be infuriating. We present our work on adding the ability to get stack traces out of GHC, for example that our crashing head was used during the evaluation of foo, which was called during the evaluation of bar, during the evaluation of main. We provide a transformation that converts GHC Core programs into ones that pass a stack around, and a stack library that ensures bounded heap usage despite the highly recursive nature of Haskell. We call our extension to GHC StackTrace.

Supplementary Material

JPG File (findingtheneedle.jpg)

Download
21.96 KB

MP4 File (findingtheneedle.mp4)

Download
105.68 MB

References

[1]

T. Allwood, S. P. Jones, and S. Eisenbach. Explicit call stack paper resources. http://code.haskell.org/explicitCallStackPaper/.

Google Scholar

[2]

A. Gill and C. Runciman. Haskell program coverage. In G. Keller, editor, Haskell, pages 1--12. ACM, 2007.

Digital Library

Google Scholar

[3]

G. U. Guide. The ghci debugger. http://www.haskell.org/ghc/docs/latest/html/users_guide/ghci-debugger.h%tml.

Google Scholar

[4]

S. P. Jones and P. Wadler. A static semantics for haskell. Draft paper, Glasgow, 91.

Google Scholar

[5]

S. Marlow, J. Iborra, B. Pope, and A. Gill. A lightweight interactive debugger for haskell. In G. Keller, editor, Haskell, pages 13--24. ACM, 2007.

Digital Library

Google Scholar

[6]

J. Meacham. Jhc. http://repetae.net/computer/jhc/jhc.shtml.

Google Scholar

[7]

W. Partain. The nofib benchmark suite of haskell programs. In J. Launchbury and P. M. Sansom, editors, Functional Programming, Workshops in Computing, pages 195--202. Springer, 1992.

Digital Library

Google Scholar

[8]

P. Sansom and S. Peyton Jones. Formally based profiling for higher-order functional languages. ACM Transactions on Programming Langauges and Systems, 19(1), 1997.

Digital Library

Google Scholar

[9]

M. Sulzmann, M. M. T. Chakravarty, S. L. P. Jones, and K. Donnelly. System F with type equality coercions. In F. Pottier and G. C. Necula, editors, TLDI, pages 53--66. ACM, 2007.

Digital Library

Google Scholar

[10]

G. Trac. Annotations. http://hackage.haskell.org/trac/ghc/wiki/Annotations.

Google Scholar

[11]

M. Wallace, O. Chitil, T. Brehm, and C. Runciman. Multiple-view tracing for Haskell: a new Hat. In R. Hinze, editor, Preliminary Proceedings of the 2001 ACM SIGPLAN Haskell Workshop, pages 151--170, Firenze, Italy, Sept. 2001. Universiteit Utrecht UU-CS-2001-23. Final proceedings to appear in ENTCS 59(2).

Google Scholar

Cited By

View all

Gissurarson MApplis L(2023)CSI: Haskell - Tracing Lazy Evaluations in a Functional LanguageProceedings of the 35th Symposium on Implementation and Application of Functional Languages10.1145/3652561.3652562(1-13)Online publication date: 29-Aug-2023
https://dl.acm.org/doi/10.1145/3652561.3652562
Faddegon MChitil O(2015)Algorithmic debugging of real-world haskell programs: deriving dependencies from the cost centre stackACM SIGPLAN Notices10.1145/2813885.273798550:6(33-42)Online publication date: 3-Jun-2015
https://dl.acm.org/doi/10.1145/2813885.2737985
Faddegon MChitil OGrove DBlackburn S(2015)Algorithmic debugging of real-world haskell programs: deriving dependencies from the cost centre stackProceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation10.1145/2737924.2737985(33-42)Online publication date: 3-Jun-2015
https://dl.acm.org/doi/10.1145/2737924.2737985
Show More Cited By

Index Terms

Finding the needle: stack traces for GHC
1. Software and its engineering
  1. Software notations and tools
    1. General programming languages
      1. Language types

Recommendations

Declaratively defining domain-specific language debuggers
GCPE '11

Tool support is vital to the effectiveness of domain-specific languages. With language workbenches, domain-specific languages and their tool support can be generated from a combined, high-level specification. This paper shows how such a specification ...
Debugging native extensions of dynamic languages
ManLang '18: Proceedings of the 15th International Conference on Managed Languages & Runtimes

Many dynamic programming languages such as Ruby and Python enable developers to use so called native extensions, code implemented in typically statically compiled languages like C and C++. However, debuggers for these dynamic languages usually lack ...
Declaratively defining domain-specific language debuggers
GPCE '11: Proceedings of the 10th ACM international conference on Generative programming and component engineering

Tool support is vital to the effectiveness of domain-specific languages. With language workbenches, domain-specific languages and their tool support can be generated from a combined, high-level specification. This paper shows how such a specification ...

Comments

Information & Contributors

Information

Published In

Haskell '09: Proceedings of the 2nd ACM SIGPLAN symposium on Haskell

September 2009

148 pages

ISBN:9781605585086

DOI:10.1145/1596638

Program Chair:
Stephanie Weirich
University of Pennsylvania, USA

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 03 September 2009

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Conference

ICFP '09

Sponsor:

ICFP '09: ACM SIGPLAN International Conference on Functional Programming

September 3, 2009

Edinburgh, Scotland

Acceptance Rates

Overall Acceptance Rate 57 of 143 submissions, 40%

Upcoming Conference

ICFP '24

Sponsor:
sigplan

29th ACM SIGPLAN International Conference on Functional Programming

September 2 - 7, 2024

Milan , Italy

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

8
Total Citations
View Citations
267
Total Downloads

Downloads (Last 12 months)5
Downloads (Last 6 weeks)0

Reflects downloads up to 10 Aug 2024

Other Metrics

View Author Metrics

Citations

Cited By

View all

Gissurarson MApplis L(2023)CSI: Haskell - Tracing Lazy Evaluations in a Functional LanguageProceedings of the 35th Symposium on Implementation and Application of Functional Languages10.1145/3652561.3652562(1-13)Online publication date: 29-Aug-2023
https://dl.acm.org/doi/10.1145/3652561.3652562
Faddegon MChitil O(2015)Algorithmic debugging of real-world haskell programs: deriving dependencies from the cost centre stackACM SIGPLAN Notices10.1145/2813885.273798550:6(33-42)Online publication date: 3-Jun-2015
https://dl.acm.org/doi/10.1145/2813885.2737985
Faddegon MChitil OGrove DBlackburn S(2015)Algorithmic debugging of real-world haskell programs: deriving dependencies from the cost centre stackProceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation10.1145/2737924.2737985(33-42)Online publication date: 3-Jun-2015
https://dl.acm.org/doi/10.1145/2737924.2737985
Allwood TCadar CEisenbach SDwyer MTip F(2011)High coverage testing of Haskell programsProceedings of the 2011 International Symposium on Software Testing and Analysis10.1145/2001420.2001465(375-385)Online publication date: 17-Jul-2011
https://dl.acm.org/doi/10.1145/2001420.2001465
Chang SBarzilay EClements JFelleisen M(2011)From stack traces to lazy rewriting sequencesProceedings of the 23rd international conference on Implementation and Application of Functional Languages10.1007/978-3-642-34407-7_7(100-115)Online publication date: 3-Oct-2011
https://dl.acm.org/doi/10.1007/978-3-642-34407-7_7
Pop I(2010)Experience reportACM SIGPLAN Notices10.1145/1932681.186359545:9(369-374)Online publication date: 27-Sep-2010
https://dl.acm.org/doi/10.1145/1932681.1863595
Pop IHudak PWeirich S(2010)Experience reportProceedings of the 15th ACM SIGPLAN international conference on Functional programming10.1145/1863543.1863595(369-374)Online publication date: 27-Sep-2010
https://dl.acm.org/doi/10.1145/1863543.1863595
Schroter ASchröter ABettenburg NPremraj R(2010)Do stack traces help developers fix bugs?2010 7th IEEE Working Conference on Mining Software Repositories (MSR 2010)10.1109/MSR.2010.5463280(118-121)Online publication date: May-2010
https://doi.org/10.1109/MSR.2010.5463280

View Options

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Cited By

Index Terms

Recommendations

Declaratively defining domain-specific language debuggers

Debugging native extensions of dynamic languages

Declaratively defining domain-specific language debuggers