LOCALIZING BUGS IN PROGRAMS - Or How to Use a Program’s Constraint Representation for Software Debugging?

Franz Wotawa

Abstract

The use of a program’s constraint representation for various purposes like testing and verification is not new. In this paper, we focus on the applicability of constraint representations to fault localization and discuss the underlying ideas. Given the source code of a program and a test case, which specifies the input parameters and the expected output, we are interested in localizing the root cause of the revealed misbehavior. We first show how programs can be compiled into their corresponding constraint representations. Based on the constraint representation we show how to compute root causes using constraint solver. Moreover, we discuss how the approach can be integrated with program assertions and unit tests.

References

  1. Aycock, J. and Horspool, N. (2000). Simple generation of static-single assignment form. In Proceedings of the 9th International Conference on Compiler Construction (CC), pages 110-124.
  2. Ceballos, R., Casca, R. M., Valle, C. D., and Borrego, D. (2006). Diagnosing errors in dbc programs using constraint programming. In Selected Papers from the 11th Conference of the Spanish Association for Artificial Intelligence (CAEPIA 2005), volume 4177 of Lecture Notes in Computer Science.
  3. Ceballos, R., Gasca, R., Valle, C. D., and Rosa, F. D. L. (2003). A constraint programming approach for software diagnosis. In Ronsse, M. and Bosschere, K. D., editors, Proceedings of the Fifth International Workshop on Automated Debugging, Ghent, Belgium.
  4. Collavizza, H. and Rueher, M. (2006). Exploration of the capabilities of constraint programming for software verification. In Proceedings of Tools and Algorithms for the Construction and Analysis of Systems (TACAS), pages 182-196. Springer, Vienna, Austria.
  5. Cytron, R., Ferrante, J., Rosen, B. K., Wegman, M. N., and Zadeck, F. K. (1991). Efficiently computing static single assignment form and the control dependence graph. ACM TOPLAS, 13(4):451-490.
  6. Dechter, R. (1992). Constraint networks. In Encyclopedia of Artificial Intelligence, pages 276-285. Wiley and Sons.
  7. Dechter, R. (2003). Constraint Processing. Morgan Kaufmann.
  8. Dechter, R. and Pearl, J. (1988). Network-based heuristics for constraint-satisfaction problems. Artificial Intelligence, 34:1-38.
  9. Dechter, R. and Pearl, J. (1989). Tree clustering for constraint networks. Artificial Intelligence, 38:353-366.
  10. DeMillo, R. A., Pan, H., and Spafford, E. H. (1996). Critical slicing for software fault localization. In International Symposium on Software Testing and Analysis (ISSTA), pages 121-134.
  11. Ducassé, M. (1993). A pragmatic survey of automatic debugging. In Proceedings of the 1st International Workshop on Automated and Algorithmic Debugging, AADEBUG 7893, Springer LNCS 749, pages 1-15.
  12. Freuder, E. C. (1982). A sufficient condition for backtrackfree search. Journal of the ACM, 29(1):24-32.
  13. Gotlieb, A., Botella, B., and Rueher, M. (1998). Automatic test data generation using constraint solving techniques. In Proc. ACM ISSTA, pages 53-62.
  14. Gupta, N., He, H., Zhang, X., and Gupta, R. (2005). Locating faulty code using failure-inducing chops. In Automated Software Engineering (ASE), pages 263-272.
  15. Jackson, D. (2006). Software abstractions: logic, language, and analysis. MIT Press.
  16. Kamkar, M. (1998). Application of program slicing in algorithmic debugging. Information and Software Technology, 40:637-645.
  17. Köb, D. and Wotawa, F. (2006). Fundamentals of debugging using a resolution calculus. In Baresi, L. and Heckel, R., editors, Fundamental Approaches to Software Engineering (FASE'06), volume 3922 of Lecture Notes in Computer Science, pages 278-292, Vienna, Austria. Springer.
  18. Mackworth, A. (1987). Constraint satisfaction. In Shapiro, S. C., editor, Encyclopedia of Artificial Intelligence, pages 205-211. John Wiley & Sons.
  19. Mayer, S. (2003). Static single-assignment form and two algorithms for its generation. Seminar Work, Winter Term 2002/03, University of Konstanz, http://www.inf.uni-konstanz.de/dbis/ teaching/ws0203/pathfinder/download/ mayersausarbeitung.pdf.
  20. Reiter, R. (1987). A theory of diagnosis from first principles. Artificial Intelligence, 32(1):57-95.
  21. Shahmehri, N., Kamkar, M., and Fritzson, P. (1995). Usability criteria for automated debugging systems. J. Systems Software, 31:55-70.
  22. Stumptner, M. and Wotawa, F. (1998). A Survey of Intelligent Debugging. AI Communications, 11(1).
  23. Zeller, A. (1999). Yesterday, my program worked. today, it doesn't. why? In Proceedings of the Seventh European Software Engineering Conference/Seventh ACM SIGSOFT Symposium on Foundations of Software Engineering (ESEC/FSE), pages 253-267.
  24. Zeller, A. and Hildebrandt, R. (2002). Simplifying and isolating failure-inducing input. IEEE Transactions on Software Engineering, 28(2).
  25. Zhang, X., He, H., Gupta, N., and Gupta, R. (2005). Experimental evaluation of using dynamic slices for fault localization. In Sixth International Symposium on Automated & Analysis-Driven Debugging (AADEBUG), pages 33-42.
Download


Paper Citation


in Harvard Style

Wotawa F. (2008). LOCALIZING BUGS IN PROGRAMS - Or How to Use a Program’s Constraint Representation for Software Debugging? . In Proceedings of the Third International Conference on Software and Data Technologies - Volume 2: ICSOFT, ISBN 978-989-8111-52-4, pages 88-95. DOI: 10.5220/0001890900880095


in Bibtex Style

@conference{icsoft08,
author={Franz Wotawa},
title={LOCALIZING BUGS IN PROGRAMS - Or How to Use a Program’s Constraint Representation for Software Debugging?},
booktitle={Proceedings of the Third International Conference on Software and Data Technologies - Volume 2: ICSOFT,},
year={2008},
pages={88-95},
publisher={SciTePress},
organization={INSTICC},
doi={10.5220/0001890900880095},
isbn={978-989-8111-52-4},
}


in EndNote Style

TY - CONF
JO - Proceedings of the Third International Conference on Software and Data Technologies - Volume 2: ICSOFT,
TI - LOCALIZING BUGS IN PROGRAMS - Or How to Use a Program’s Constraint Representation for Software Debugging?
SN - 978-989-8111-52-4
AU - Wotawa F.
PY - 2008
SP - 88
EP - 95
DO - 10.5220/0001890900880095