Skip to main content
SpringerLink
Log in

Scaling Up Delta Debugging of Type Errors

Category: Research

  • Conference paper
  • First Online:
Book cover Trends in Functional Programming (TFP 2020)

Part of the book series: Lecture Notes in Computer Science ((LNTCS,volume 12222))

Included in the following conference series:

  • 596 Accesses

Abstract

Type error messages of compilers of statically typed functional languages are often inaccurate, making type error debugging hard. Many solutions to the problem have been proposed, but most have been evaluated only with short programs, that is, of fewer than 30 lines. In this paper we note that our own tool for delta debugging type errors scales poorly for large programs. In response we present a new tool that applies a new algorithm for segmenting a large program before the delta debugging algorithm is applied. We propose a framework for quantifying the quality of type error debuggers and apply it to our new tool demonstrating substantial improvement.

J. Sharrad—PhD Student.

This is a preview of subscription content, log in via an institution to check access.

Access this chapter

Log in via an institution
Chapter
USD 29.95
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
eBook
USD 39.99
Price excludes VAT (USA)
  • Available as EPUB and PDF
  • Read on any device
  • Instant download
  • Own it forever
Softcover Book
USD 54.99
Price excludes VAT (USA)
  • Compact, lightweight edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info

Tax calculation will be finalised at checkout

Purchases are for personal use only

Institutional subscriptions

Notes

  1. 1.

    With respect to the number of lines of the original ill-typed program.

  2. 2.

    https://www.haskell.org/ghc, version 8.4.3.

  3. 3.

    Removing single characters is another choice presented by Zeller [28].

  4. 4.

    Instead of removing the lines completely we still keep the empty lines to avoid undesirable changes of program layout.

  5. 5.

    This assumes similar run-time for every test, which may not be the case.

  6. 6.

    A proof is available on page 408 of ‘Why Programs Fail’ [28].

  7. 7.

    https://github.com/search?l=Haskell&q=Haskell&s=stars&type=Repositories.

  8. 8.

    https://www.merriam-webster.com/dictionary/moiety.

  9. 9.

    It should be noted when we talk about small programs in type error debugging we are discussing those that are used for evaluation and not those used for examples.

  10. 10.

    {[1],[2], [3],[4],[5],[6],[7],[8],[9]} represents the non-moiety failing configuration. Every line is an acceptable splitting location.

  11. 11.

    TcErrors is part of the Glasgow Haskell Compiler and states that type errors fall into one of 4 groups; more information about this can be found in: https://github.com/JoannaSharrad/ghcErrorsDoc/blob/master/RoughGuidetoGHCTcErrors.pdf.

  12. 12.

    https://www.haskell.org/cabal/.

References

  1. Artho, C.: Iterative delta debugging. STTT - Softw. Tools Technol. Transf. 13(3), 223–246 (2011). https://doi.org/10.1007/s10009-010-0139-9

    Article  Google Scholar 

  2. Bernstein, K.L., Stark, E.W.: Debugging type errors. Technical report, November 1995

    Google Scholar 

  3. Chen, S., Erwig, M.: Counter-factual typing for debugging type errors. In: Jagannathan, S., Sewell, P. (eds.) POPL 2014, pp. 583–594. ACM (2014)

    Google Scholar 

  4. Chen, S., Erwig, M.: Guided type debugging. In: Codish, M., Sumii, E. (eds.) FLOPS 2014. LNCS, vol. 8475, pp. 35–51. Springer, Cham (2014). https://doi.org/10.1007/978-3-319-07151-0_3

    Chapter  Google Scholar 

  5. Chitil, O.: Compositional explanation of types and algorithmic debugging of type errors. In: Pierce, B.C. (ed.) ICFP 2001, pp. 193–204. ACM (2001)

    Google Scholar 

  6. Cleve, H., Zeller, A.: Locating causes of program failures. In: Roman, G., Griswold, W.G., Nuseibeh, B. (eds.) 27th International Conference on Software Engineering, pp. 342–351. ACM (2005)

    Google Scholar 

  7. Haack, C., Wells, J.B.: Type error slicing in implicitly typed higher-order languages. Sci. Comput. Program. 50(1–3), 189–224 (2004)

    MathSciNet  MATH  Google Scholar 

  8. Kalhauge, C.G., Palsberg, J.: Binary reduction of dependency graphs. In: Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, pp. 556–566. ACM (2019)

    Google Scholar 

  9. Lerner, B.S., Grossman, D., Chambers, C.: Seminal: searching for ML type-error messages. In: Proceedings of the ACM Workshop on ML, pp. 63–73 (2006)

    Google Scholar 

  10. McAdam, B.J.: On the unification of substitutions in type inference. In: Hammond, K., Davie, T., Clack, C. (eds.) IFL 1998. LNCS, vol. 1595, pp. 137–152. Springer, Heidelberg (1999). https://doi.org/10.1007/3-540-48515-5_9

    Chapter  Google Scholar 

  11. Misherghi, G., Su, Z.: HDD: hierarchical delta debugging. In: ICSE 2006, pp. 142–151. ACM (2006)

    Google Scholar 

  12. Misherghi, G.S., HDD, Z.S.: Hierarchical delta debugging. Ph.D. thesis, University of California, Davis (2007). https://pdfs.semanticscholar.org/a337/e5ba5b18cc45fd4517b90c5ac92e8052b6d3.pdf

  13. Rahli, V., Wells, J.B., Pirie, J., Kamareddine, F.: Skalpel: a type error slicer for standard ML. Electron. Notes Theor. Comput. Sci. 312, 197–213 (2015)

    MathSciNet  MATH  Google Scholar 

  14. Regehr, J., Chen, Y., Cuoq, P., Eide, E., Ellison, C., Yang, X.: Test-case reduction for C compiler bugs. In: PLDI 2012, pp. 335–346. ACM (2012)

    Google Scholar 

  15. Schilling, T.: Constraint-free type error slicing. In: Peña, R., Page, R. (eds.) TFP 2011. LNCS, vol. 7193, pp. 1–16. Springer, Heidelberg (2012). https://doi.org/10.1007/978-3-642-32037-8_1

    Chapter  Google Scholar 

  16. Seidel, E.L., Jhala, R., Weimer, W.: Dynamic witnesses for static type errors (or, ill-typed programs usually go wrong). In: ICFP 2016, pp. 228–242. ACM (2016)

    Google Scholar 

  17. Seidel, E.L., Sibghat, H., Chaudhuri, K., Weimer, W., Jhala, R.: Learning to blame: Localizing novice type errors with data-driven diagnosis. CoRR abs/1708.07583 (2017). http://arxiv.org/abs/1708.07583

  18. Sharrad, J., Chitil, O., Wang, M.: Delta debugging type errors with a blackbox compiler. In: IFL 2018, pp. 13–24. ACM (2018)

    Google Scholar 

  19. Shung, K.P.: Accuracy, precision, recall or f1? November 2019. https://towardsdatascience.com/accuracy-precision-recall-or-f1-331fb37c5cb9

  20. Stuckey, P.J., Sulzmann, M., Wazny, J.: Interactive type debugging in Haskell. In: Proceedings of the ACM SIGPLAN Workshop on Haskell, pp. 72–83. ACM (2003)

    Google Scholar 

  21. Stuckey, P.J., Sulzmann, M., Wazny, J.: Improving type error diagnosis. In: Nilsson, H. (ed.) Workshop on Haskell 2004, pp. 80–91. ACM (2004). https://doi.org/10.1145/1017472.1017486

  22. Tip, F., Dinesh, T.B.: A slicing-based approach for locating type errors. ACM Trans. Softw. Eng. Methodol. 10(1), 5–55 (2001)

    Google Scholar 

  23. Tsushima, K., Asai, K.: An embedded type debugger. In: Hinze, R. (ed.) IFL 2012. LNCS, vol. 8241, pp. 190–206. Springer, Heidelberg (2013). https://doi.org/10.1007/978-3-642-41582-1_12

    Chapter  Google Scholar 

  24. Tsushima, K., Chitil, O.: Enumerating counter-factual type error messages with an existing type checker. In: PPL 2014 (2014)

    Google Scholar 

  25. Wand, M.: Finding the source of type errors. In: POPL 1986, pp. 38–43. ACM (1986)

    Google Scholar 

  26. Witten, I., Frank, E.: Data Mining: Practical Machine Learning Tools and Techniques. Morgan Kaufmann, Burlington (2005)

    MATH  Google Scholar 

  27. Zeller, A.: Yesterday, my program worked. Today, it does not. Why? In: Nierstrasz, O., Lemoine, M. (eds.) ESEC/SIGSOFT FSE -1999. LNCS, vol. 1687, pp. 253–267. Springer, Heidelberg (1999). https://doi.org/10.1007/3-540-48166-4_16

    Chapter  Google Scholar 

  28. Zeller, A.: Why Programs Fail Guide to Systematic Debugging, 2nd edn. Academic Press, Cambridge (2009)

    Google Scholar 

  29. Zeller, A., Hildebrandt, R.: Simplifying and isolating failure-inducing input. IEEE Trans. Softw. Eng. 28(2), 183–200 (2002)

    Google Scholar 

  30. Zhang, D., Myers, A.C., Vytiniotis, D., Peyton Jones, S.L.: Diagnosing type errors with class. In: Grove, D., Blackburn, S. (eds.) PLDI 2015, pp. 12–21. ACM (2015)

    Google Scholar 

Download references

Acknowledgements

We would like to thank all of the reviewers for their thorough feedback, which we incorporated into this paper.

Author information

Authors and Affiliations

  1. University of Kent, Canterbury, UK

    Joanna Sharrad & Olaf Chitil

Authors
  1. Joanna Sharrad
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Olaf Chitil
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to Joanna Sharrad .

Editor information

Editors and Affiliations

  1. AGH University of Science and Technology, Krakow, Poland

    Aleksander Byrski

  2. Chalmers University of Technology, Gothenburg, Sweden

    John Hughes

Rights and permissions

Reprints and permissions

Copyright information

© 2020 Springer Nature Switzerland AG

About this paper

Check for updates. Verify currency and authenticity via CrossMark

Cite this paper

Sharrad, J., Chitil, O. (2020). Scaling Up Delta Debugging of Type Errors. In: Byrski, A., Hughes, J. (eds) Trends in Functional Programming. TFP 2020. Lecture Notes in Computer Science(), vol 12222. Springer, Cham. https://doi.org/10.1007/978-3-030-57761-2_4

Download citation

  • DOI: https://doi.org/10.1007/978-3-030-57761-2_4

  • Published:

  • Publisher Name: Springer, Cham

  • Print ISBN: 978-3-030-57760-5

  • Online ISBN: 978-3-030-57761-2

  • eBook Packages: Computer ScienceComputer Science (R0)

Publish with us

Policies and ethics

Search

Navigation