A Survey of Algorithmic Debugging

"© ACM, 2017. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version was published in ACM Computing Surveys, {50, 4, 2017} https://dl.acm.org/doi/10.1145/3106740"[EN] Algorithmic debugging is a technique proposed in 1982 by E. Y. Shapiro in the context of logic programming. This survey shows how the initial ideas have been developed to become a widespread debugging schema ftting many diferent programming paradigms and with applications out of the program debugging feld. We describe the general framework and the main issues related to the implementations in diferent programming paradigms and discuss several proposed improvements and optimizations. We also review the main algorithmic debugger tools that have been implemented so far and compare their features. From this comparison, we elaborate a summary of desirable characteristics that should be considered when implementing future algorithmic debuggers.This work has been partially supported by the EU (FEDER) and the Spanish Ministerio de Economia y Competitividad under grant TIN2013-44742-C4-1-R, TIN2016-76843-C4-1-R, StrongSoft (TIN2012-39391-C04-04), and TRACES (TIN2015-67522-C3-3-R) by the Generalitat Valenciana under grant PROMETEO-II/2015/013 (SmartLogic) and by the Comunidad de Madrid project N-Greens Software-CM (S2013/ICE-2731).Caballero, R.; Riesco, A.; Silva, J. (2017). A Survey of Algorithmic Debugging. ACM Computing Surveys. 50(4):1-35. https://doi.org/10.1145/3106740S135504Abramson, D., Foster, I., Michalakes, J., & Sosič, R. (1996). Relative debugging. Communications of the ACM, 39(11), 69-77. doi:10.1145/240455.240475K. R. Apt H. A. Blair and A. Walker. 1988. Towards a theory of declarative knowledge. In Foundations of Deductive Databases and Logic Programming J. Minker (Ed.). Morgan Kaufmann Publishers Inc. San Francisco CA 89--148. 10.1016/B978-0-934613-40-8.50006-3 K. R. Apt H. A. Blair and A. Walker. 1988. Towards a theory of declarative knowledge. In Foundations of Deductive Databases and Logic Programming J. Minker (Ed.). Morgan Kaufmann Publishers Inc. San Francisco CA 89--148. 10.1016/B978-0-934613-40-8.50006-3Arora, T., Ramakrishnan, R., Roth, W. G., Seshadri, P., & Srivastava, D. (1993). Explaining program execution in deductive systems. Lecture Notes in Computer Science, 101-119. doi:10.1007/3-540-57530-8_7E. Av-Ron. 1984. Top-Down Diagnosis of Prolog Programs. Ph.D. Dissertation. Weizmann Institute. E. Av-Ron. 1984. Top-Down Diagnosis of Prolog Programs. Ph.D. Dissertation. Weizmann Institute.A. Beaulieu. 2005. Learning SQL. O’Reilly Farnham UK. A. Beaulieu. 2005. Learning SQL. O’Reilly Farnham UK.D. Binks. 1995. Declarative Debugging in Gödel. Ph.D. Dissertation. University of Bristol. D. Binks. 1995. Declarative Debugging in Gödel. Ph.D. Dissertation. University of Bristol.B. Braßel and H. Siegel. 2008. Debugging Lazy Functional Programs by Asking the Oracle. Springer-Verlag Berlin 183--200. DOI:http://dx.doi.org/10.1007/978-3-540-85373-2_11 10.1007/978-3-540-85373-2_11 B. Braßel and H. Siegel. 2008. Debugging Lazy Functional Programs by Asking the Oracle. Springer-Verlag Berlin 183--200. DOI:http://dx.doi.org/10.1007/978-3-540-85373-2_11 10.1007/978-3-540-85373-2_11Caballero, R. (2005). A declarative debugger of incorrect answers for constraint functional-logic programs. Proceedings of the 2005 ACM SIGPLAN workshop on Curry and functional logic programming - WCFLP ’05. doi:10.1145/1085099.1085102Caballero, R., García-Ruiz, Y., & Sáenz-Pérez, F. (2012). Declarative Debugging of Wrong and Missing Answers for SQL Views. Lecture Notes in Computer Science, 73-87. doi:10.1007/978-3-642-29822-6_9Caballero, R., García-Ruiz, Y., & Sáenz-Pérez, F. (2015). Debugging of wrong and missing answers for datalog programs with constraint handling rules. Proceedings of the 17th International Symposium on Principles and Practice of Declarative Programming - PPDP ’15. doi:10.1145/2790449.2790522Caballero, R., Martin-Martin, E., Riesco, A., & Tamarit, S. (2015). A zoom-declarative debugger for sequential Erlang programs. Science of Computer Programming, 110, 104-118. doi:10.1016/j.scico.2015.06.011Caballero, R., & Rodríguez-Artalejo, M. (2002). A Declarative Debugging System for Lazy Functional Logic Programs. Electronic Notes in Theoretical Computer Science, 64, 113-175. doi:10.1016/s1571-0661(04)80349-9Ceri, S., Gottlob, G., & Tanca, L. (1989). What you always wanted to know about Datalog (and never dared to ask). IEEE Transactions on Knowledge and Data Engineering, 1(1), 146-166. doi:10.1109/69.43410Chen, M., Mao, S., & Liu, Y. (2014). Big Data: A Survey. Mobile Networks and Applications, 19(2), 171-209. doi:10.1007/s11036-013-0489-0Chitil, O., & Davie, T. (2008). Comprehending finite maps for algorithmic debugging of higher-order functional programs. Proceedings of the 10th international ACM SIGPLAN symposium on Principles and practice of declarative programming - PPDP ’08. doi:10.1145/1389449.1389475Chitil, O., Faddegon, M., & Runciman, C. (2016). A Lightweight Hat. Proceedings of the 28th Symposium on the Implementation and Application of Functional Programming Languages - IFL 2016. doi:10.1145/3064899.3064904O. Chitil C. Runciman and M. Wallace. 2001. Freja Hat and Hood—A Comparative Evaluation of Three Systems for Tracing and Debugging Lazy Functional Programs. Springer Berlin 176--193. O. Chitil C. Runciman and M. Wallace. 2001. Freja Hat and Hood—A Comparative Evaluation of Three Systems for Tracing and Debugging Lazy Functional Programs. Springer Berlin 176--193.O. Chitil C. Runciman and Malcolm Wallace. 2003. Transforming Haskell for Tracing. Springer-Verlag Berlin 165--181. DOI:http://dx.doi.org/10.1007/3-540-44854-3_11 10.1007/3-540-44854-3_11 O. Chitil C. Runciman and Malcolm Wallace. 2003. Transforming Haskell for Tracing. Springer-Verlag Berlin 165--181. DOI:http://dx.doi.org/10.1007/3-540-44854-3_11 10.1007/3-540-44854-3_11Minh Ngoc Dinh, Abramson, D., & Chao Jin. (2014). Scalable Relative Debugging. IEEE Transactions on Parallel and Distributed Systems, 25(3), 740-749. doi:10.1109/tpds.2013.86Faddegon, M., & Chitil, O. (2015). Algorithmic debugging of real-world haskell programs: deriving dependencies from the cost centre stack. ACM SIGPLAN Notices, 50(6), 33-42. doi:10.1145/2813885.2737985Faddegon, M., & Chitil, O. (2016). Lightweight computation tree tracing for lazy functional languages. Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation - PLDI 2016. doi:10.1145/2908080.2908104Ferrand, G. (1987). Error diagnosis in logic programming an adaptation of E.Y. Shapiro’s method. The Journal of Logic Programming, 4(3), 177-198. doi:10.1016/0743-1066(87)90001-xFritzson, P., Shahmehri, N., Kamkar, M., & Gyimothy, T. (1992). Generalized algorithmic debugging and testing. ACM Letters on Programming Languages and Systems, 1(4), 303-322. doi:10.1145/161494.161498Fromherz, M. P. J. (s. f.). Towards declarative debugging of concurrent constraint programs. Lecture Notes in Computer Science, 88-100. doi:10.1007/bfb0019403Harman, M., & Hierons, R. (2001). An overview of program slicing. Software Focus, 2(3), 85-92. doi:10.1002/swf.41F. Henderson T. Conway Z. Somogyi D. Jeffery P. Schachte S. Taylor C. Speirs T. Dowd R. Becket M. Brown and P. Wang. 2014. The Mercury Language Reference Manual (Version 14.01.1). The University of Melbourne. F. Henderson T. Conway Z. Somogyi D. Jeffery P. Schachte S. Taylor C. Speirs T. Dowd R. Becket M. Brown and P. Wang. 2014. The Mercury Language Reference Manual (Version 14.01.1). The University of Melbourne.C. Hermanns and H. Kuchen. 2013. Hybrid Debugging of Java Programs. Springer-Verlag Berlin 91--107. DOI:http://dx.doi.org/10.1007/978-3-642-36177-7_6 10.1007/978-3-642-36177-7_6 C. Hermanns and H. Kuchen. 2013. Hybrid Debugging of Java Programs. Springer-Verlag Berlin 91--107. DOI:http://dx.doi.org/10.1007/978-3-642-36177-7_6 10.1007/978-3-642-36177-7_6Hirunkitti, V., & Hogger, C. J. (s. f.). A generalised query minimisation for program debugging. Lecture Notes in Computer Science, 153-170. doi:10.1007/bfb0019407Hughes, J. (2010). Software Testing with QuickCheck. Lecture Notes in Computer Science, 183-223. doi:10.1007/978-3-642-17685-2_6G. Hutton. 2016. Programming in Haskell. Cambridge University Press Cambridge UK. G. Hutton. 2016. Programming in Haskell. Cambridge University Press Cambridge UK.Insa, D., & Silva, J. (2010). An algorithmic debugger for Java. 2010 IEEE International Conference on Software Maintenance. doi:10.1109/icsm.2010.5609661Insa, D., & Silva, J. (2011). Optimal Divide and Query. Lecture Notes in Computer Science, 224-238. doi:10.1007/978-3-642-24769-9_17Insa, D., & Silva, J. (2011). An optimal strategy for algorithmic debugging. 2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011). doi:10.1109/ase.2011.6100055D. Insa and J. Silva. 2011c. Scaling Up Algorithmic Debugging with Virtual Execution Trees. Springer-Verlag Berlin 149--163. DOI:http://dx.doi.org/10.1007/978-3-642-20551-4_10 10.1007/978-3-642-20551-4_10 D. Insa and J. Silva. 2011c. Scaling Up Algorithmic Debugging with Virtual Execution Trees. Springer-Verlag Berlin 149--163. DOI:http://dx.doi.org/10.1007/978-3-642-20551-4_10 10.1007/978-3-642-20551-4_10D. Insa and J. Silva. 2015a. Automatic transformation of iterative loops into recursive methods. Information 8 Software Technology 58 (2015) 95--109. DOI:http://dx.doi.org/10.1016/j.infsof.2014.10.001 10.1016/j.infsof.2014.10.001 D. Insa and J. Silva. 2015a. Automatic transformation of iterative loops into recursive methods. Information 8 Software Technology 58 (2015) 95--109. DOI:http://dx.doi.org/10.1016/j.infsof.2014.10.001 10.1016/j.infsof.2014.10.001Insa, D., & Silva, J. (2015). A Generalized Model for Algorithmic Debugging. Lecture Notes in Computer Science, 261-276. doi:10.1007/978-3-319-27436-2_16Insa, D., Silva, J., & Riesco, A. (2013). Speeding Up Algorithmic Debugging Using Balanced Execution Trees. Lecture Notes in Computer Science, 133-151. doi:10.1007/978-3-642-38916-0_8Insa, D., Silva, J., & Tomás, C. (2013). Enhancing Declarative Debugging with Loop Expansion and Tree Compression. Lecture Notes in Computer Science, 71-88. doi:10.1007/978-3-642-38197-3_6K. Jensen and N. Wirth. 1974. PASCAL User Manual and Report. Springer-Verlag Berlin. 10.1007/978-3-662-21554-8 K. Jensen and N. Wirth. 1974. PASCAL User Manual and Report. Springer-Verlag Berlin. 10.1007/978-3-662-21554-8Jia, Y., & Harman, M. (2011). An Analysis and Survey of the Development of Mutation Testing. IEEE Transactions on Software Engineering, 37(5), 649-678. doi:10.1109/tse.2010.62Kamkar, M., Shahmehri, N., & Fritzson, P. (s. f.). Bug localization by algorithmic debugging and program slicing. Lecture Notes in Computer Science, 60-74. doi:10.1007/bfb0024176S. Köhler B. Ludäscher and Y. Smaragdakis. 2012. Declarative Datalog Debugging for Mere Mortals. Springer-Verlag Berlin 111--122. S. Köhler B. Ludäscher and Y. Smaragdakis. 2012. Declarative Datalog Debugging for Mere Mortals. Springer-Verlag Berlin 111--122.Kouh, H.-J., & Yoo, W.-H. (2003). The Efficient Debugging System for Locating Logical Errors in Java Programs. Lecture Notes in Computer Science, 684-693. doi:10.1007/3-540-44839-x_72Benzmüller, C., & Miller, D. (2014). Automation of Higher-Order Logic. Handbook of the History of Logic, 215-254. doi:10.1016/b978-0-444-51624-4.50005-8Kowalski, R., & Kuehner, D. (1971). Linear resolution with selection function. Artificial Intelligence, 2(3-4), 227-260. doi:10.1016/0004-3702(71)90012-9K. Kuchcinski W. Drabent and J. Maluszynski. 1993. Automatic Diagnosis of VLSI Digital Circuits Using Algorithmic Debugging. Springer-Verlag Berlin 350--367. DOI:http://dx.doi.org/10.1007/BFb0019419 10.1007/BFb0019419 K. Kuchcinski W. Drabent and J. Maluszynski. 1993. Automatic Diagnosis of VLSI Digital Circuits Using Algorithmic Debugging. Springer-Verlag Berlin 350--367. DOI:http://dx.doi.org/10.1007/BFb0019419 10.1007/BFb0019419S. Liang. 1999. Java Native Interface: Programmer’s Guide and Reference (1st ed.). Addison-Wesley Longman Publishing Co. Inc. Boston MA. S. Liang. 1999. Java Native Interface: Programmer’s Guide and Reference (1st ed.). Addison-Wesley Longman Publishing Co. Inc. Boston MA.Lloyd, J. W. (1987). Declarative error diagnosis. New Generation Computing, 5(2), 133-154. doi:10.1007/bf03037396J. W. Lloyd. 1987b. Foundations of Logic Programming (2nd ed.). Springer-Verlag Berlin. 10.1007/978-3-642-83189-8 J. W. Lloyd. 1987b. Foundations of Logic Programming (2nd ed.). Springer-Verlag Berlin. 10.1007/978-3-642-83189-8W. Lux. 2006. Münster Curry User’s guide (Release 0.9.10 of May 10 2006). Retrieved from http://danae.uni-muenster.de/∼lux/curry/user.pdf. W. Lux. 2006. Münster Curry User’s guide (Release 0.9.10 of May 10 2006). Retrieved from http://danae.uni-muenster.de/∼lux/curry/user.pdf.Lux, W. (2008). Declarative Debugging Meets the World. Electronic Notes in Theoretical Computer Science, 216, 65-77. doi:10.1016/j.entcs.2008.06.034I. MacLarty. 2005. Practical Declarative Debugging of Mercury Programs. Ph.D. Dissertation. Department of Computer Science and Software Engineering The University of Melbourne. I. MacLarty. 2005. Practical Declarative Debugging of Mercury Programs. Ph.D. Dissertation. Department of Computer Science and Software Engineering The University of Melbourne.Naganuma, J., Ogura, T., & Hoshino, T. (s. f.). High-level design validation using algorithmic debugging. Proceedings of European Design and Test Conference EDAC-ETC-EUROASIC. doi:10.1109/edtc.1994.326833Naish, L. (1992). Declarative diagnosis of missing answers. New Generation Computing, 10(3), 255-285. doi:10.1007/bf03037939H. Nilsson. 1998. Declarative Debugging for Lazy Functional Languages. Ph.D. Dissertation. Linköping Sweden. H. Nilsson. 1998. Declarative Debugging for Lazy Functional Languages. Ph.D. Dissertation. Linköping Sweden.NILSSON, H. (2001). How to look busy while being as lazy as ever: the Implementation of a lazy functional debugger. Journal of Functional Programming, 11(6), 629-671. doi:10.1017/s095679680100418xNilsson, H., & Fritzson, P. (s. f.). Algorithmic debugging for lazy functional languages. Lecture Notes in Computer Science, 385-399. doi:10.1007/3-540-55844-6_149Nilsson, H., & Fritzson, P. (1994). Algorithmic debugging for lazy functional languages. Journal of Functional Programming, 4(3), 337-369. doi:10.1017/s095679680000109xNilsson, H., & Sparud, J. (1997). Automated Software Engineering, 4(2), 121-150. doi:10.1023/a:1008681016679Ostrand, T. J., & Balcer, M. J. (1988). The category-partition method for specifying and generating fuctional tests. Communications of the ACM, 31(6), 676-686. doi:10.1145/62959.62964Pereira, L. M. (1986). Rational debugging in logic programming. Third International Conference on Logic Programming, 203-210. doi:10.1007/3-540-16492-8_76B. Pope. 2006. A Declarative Debugger for Haskell. Ph.D. Dissertation. The University of Melbourne Australia. B. Pope. 2006. A Declarative Debugger for Haskell. Ph.D. Dissertation. The University of Melbourne Australia.Ramakrishnan, R., & Ullman, J. D. (1995). A survey of deductive database systems. The Journal of Logic Programming, 23(2), 125-149. doi:10.1016/0743-1066(94)00039-9Riesco, A., Verdejo, A., Martí-Oliet, N., & Caballero, R. (2012). Declarative debugging of rewriting logic specifications. The Journal of Logic and Algebraic Programming, 81(7-8), 851-897. doi:10.1016/j.jlap.2011.06.004DeRose, L., Gontarek, A., Vose, A., Moench, R., Abramson, D., Dinh, M. N., & Jin, C. (2015). Relative debugging for a highly parallel hybrid computer system. Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis on - SC ’15. doi:10.1145/2807591.2807605Runeson, P. (2006). A survey of unit testing practices. IEEE Software, 23(4), 22-29. doi:10.1109/ms.2006.91Russo, F., & Sancassani, M. (1992). A declarative debugging environment for DATALOG. Lecture Notes in Computer Science, 433-441. doi:10.1007/3-540-55460-2_32E. Y. Shapiro. 1982a. Algorithmic Program Debugging. MIT Press Cambridge MA. E. Y. Shapiro. 1982a. Algorithmic Program Debugging. MIT Press Cambridge MA.Shapiro, E. Y. (1982). Algorithmic program diagnosis. Proceedings of the 9th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL ’82. doi:10.1145/582153.582185Shmueli, O., & Tsur, S. (1991). Logical diagnosis ofLDL programs. New Generation Computing, 9(3-4), 277-303. doi:10.1007/bf03037166Silva, J. (s. f.). A Comparative Study of Algorithmic Debugging Strategies. Lecture Notes in Computer Science, 143-159. doi:10.1007/978-3-540-71410-1_11Silva, J. (2011). A survey on algorithmic debugging strategies. Advances in Engineering Software, 42(11), 976-991. doi:10.1016/j.advengsoft.2011.05.024Silva, J., & Chitil, O. (2006). Combining algorithmic debugging and program slicing. Proceedings of the 8th ACM SIGPLAN symposium on Principles and practice of declarative programming - PPDP ’06. doi:10.1145/1140335.1140355J. A. Silva E. R. Faria R. C. Barros E. R. Hruschka A. C. P. L. F. de Carvalho and J. Gama. 2013. Data stream clustering: A survey. Comput. Surv. 46 1 Article 13 (July 2013) 31 pages.DOI:http://dx.doi.org/10.1145/2522968.2522981 10.1145/2522968.2522981 J. A. Silva E. R. Faria R. C. Barros E. R. Hruschka A. C. P. L. F. de Carvalho and J. Gama. 2013. Data stream clustering: A survey. Comput. Surv. 46 1 Article 13 (July 2013) 31 pages.DOI:http://dx.doi.org/10.1145/2522968.2522981 10.1145/2522968.2522981SOSIČ, R., & ABRAMSON, D. (1997). Guard: A Relative Debugger. Software: Practice and Experience, 27(2), 185-206. doi:10.1002/(sici)1097-024x(199702)27:23.0.co;2-dL. Sterling and E. Shapiro. 1986. The Art of Prolog: Advanced Programming Techniques. The MIT Press Cambridge MA. L. Sterling and E. Shapiro. 1986. The Art of Prolog: Advanced Programming Techniques. The MIT Press Cambridge MA.P. Kambam Sugavanam. 2013. Debugging Framework for Attribute Grammars. Ph.D. Dissertation. University of Minnesota. P. Kambam Sugavanam. 2013. Debugging Framework for Attribute Grammars. Ph.D. Dissertation. University of Minnesota.Tamarit, S., Riesco, A., Martin-Martin, E., & Caballero, R. (2016). Debugging Meets Testing in Erlang. Lecture Notes in Computer Science, 171-180. doi:10.1007/978-3-319-41135-4_10A. Tessier and G. Ferrand. 2000. Declarative diagnosis in the CLP scheme. In Analysis and Visualization Tools for Constraint Programming: Constraint Debugging Pierre Deransart Manuel V. Hermenegildo and Jan Maluszynski (Eds.). Springer-Verlag Berlin 151--174. 10.1007/10722311_6 A. Tessier and G. Ferrand. 2000. Declarative diagnosis in the CLP scheme. In Analysis and Visualization Tools for Constraint Programming: Constraint Debugging Pierre Deransart Manuel V. Hermenegildo and Jan Maluszynski (Eds.). Springer-Verlag Berlin 151--174. 10.1007/10722311_6Zinn, C. (2013). Algorithmic Debugging for Intelligent Tutoring: How to Use Multiple Models and Improve Diagnosis. Lecture Notes in Computer Science, 272-283. doi:10.1007/978-3-642-40942-4_24Zinn, C. (2014). Algorithmic Debugging and Literate Programming to Generate Feedback in Intelligent Tutoring Systems. KI 2014: Advances in Artificial Intelligence, 37-48. doi:10.1007/978-3-319-11206-0_

A Generalized Model for Algorithmic Debugging

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-319-27436-2_16Algorithmic debugging is a semi-automatic debugging technique that is present in practically all mature programming languages. In this paper we claim that the state of the practice in algorithmic debugging is a step forward compared to the state of the theory. In particular, we argue that novel techniques for algorithmic debugging cannot be supported by the standard internal data structures used in this technique, and a generalization of the standard definitions and algorithms is needed. We identify two specific problems of the standard formulation and implementations of algorithmic debugging, and we propose a reformulation to solve both problems. The reformulation has been done in a paradigm-independent manner to make it useful and reusable in different programming languages.This work has been partially supported by the EU (FEDER) and the Spanish Ministerio de Economía y Competitividad (Secretaría de Estado de Investigación, Desarrollo e Innovación) under Grant TIN2013-44742-C4-1-R and by the Generalitat Valenciana under Grant PROMETEOII/2015/013. David Insa was partially supported by the Spanish Ministerio de Educación under FPU Grant AP2010-4415.Insa Cabrera, D.; Silva Galiana, JF. (2015). A Generalized Model for Algorithmic Debugging. En Logic-Based Program Synthesis and Transformation. Springer. 261-276. https://doi.org/10.1007/978-3-319-27436-2_16261276Eclipse (2003). http://www.eclipse.org/Barbour, T., Naish, L.: Declarative debugging of a logical-functional language. Technical report, University of Melbourne (1994)Braßel, B., Siegel, H.: Debugging lazy functional programs by asking the oracle. In: Chitil, O., Horváth, Z., Zsók, V. (eds.) IFL 2007. LNCS, vol. 5083, pp. 183–200. Springer, Heidelberg (2008)Caballero, R.: A declarative debugger of incorrect answers for constraint functional-logic programs. In: Proceedings of the 2005 ACM-SIGPLAN Workshop on Curry and Functional Logic Programming (WCFLP 2005), pp. 8–13. ACM Press, New York, USA (2005)Caballero, R., Martin-Martin, E., Riesco, A., Tamarit, S.: EDD: A declarative debugger for sequential erlang programs. In: Ábrahám, E., Havelund, K. (eds.) TACAS 2014 (ETAPS). LNCS, vol. 8413, pp. 581–586. Springer, Heidelberg (2014)Caballero, R., Riesco, A., Verdejo, A., Martí-Oliet, N.: Simplifying questions in maude declarative debugger by transforming proof trees. In: Vidal, G. (ed.) LOPSTR 2011. LNCS, vol. 7225, pp. 73–89. Springer, Heidelberg (2012)Cheda, D., Silva, J.: State of the practice in algorithmic debugging. Electron. Notes Theor. Comput. Sci. 246, 55–70 (2009)Davie, T., Chitil, O.: Hat-delta: one right does make a wrong. In: Butterfield, A., (ed.) Proceedings of the 17th International Workshop on Implementation and Application of Functional Languages (IFL 2005), p. 11, September 2005Davie, T., Chitil, O.: Hat-delta: One right does make a wrong. In: Proceedings of the 7th Symposium on Trends in Functional Programming (TFP 2006), April 2006Fritzson, P., Shahmehri, N., Kamkar, M., Gyimóthy, T.: Generalized algorithmic debugging and testing. ACM Lett. Program. Lang. Syst. (LOPLAS) 1(4), 303–322 (1992)González, J., Insa, D., Silva, J.: A new hybrid debugging architecture for eclipse. In: Gupta, G., Peña, R. (eds.) LOPSTR 2013, LNCS 8901. LNCS, vol. 8901, pp. 183–201. Springer, Heidelberg (2014)Hermanns, C., Kuchen, H.: Hybrid debugging of java programs. In: Escalona, M.J., Cordeiro, J., Shishkov, B. (eds.) ICSOFT 2011. CCIS, vol. 303, pp. 91–107. Springer, Heidelberg (2013)Insa, D., Silva, J.: An algorithmic debugger for java. In: Proceedings of the 26th IEEE International Conference on Software Maintenance (ICSM 2010), pp. 1–6 (2010)Insa, D., Silva, J.: Automatic transformation of iterative loops into recursive methods. Inf. Soft. Technol. 58, 95–109 (2015)Insa, D., Silva, J., Riesco, A.: Speeding up algorithmic debugging using balanced execution trees. In: Veanes, M., Viganò, L. (eds.) TAP 2013. LNCS, vol. 7942, pp. 133–151. Springer, Heidelberg (2013)Insa, D., Silva, J., Tomás, C.: Enhancing declarative debugging with loop expansion and tree compression. In: Albert, E. (ed.) LOPSTR 2012. LNCS, vol. 7844, pp. 71–88. Springer, Heidelberg (2013)Lloyd, J.: Declarative error diagnosis. New Gener. Comput. 5(2), 133–154 (1987)Lux, M.: Münster Curry User’s Guide, May 2006. http://danae.uni-muenster.de/lux/curry/user.pdf ,MacLarty, I.D.: Practical Declarative Debugging of Mercury Programs. Ph.D. thesis, University of Melbourne (2005)Naish, L., Dart, P.W., Zobel, J.: The NU-Prolog debugging environment. In: Porto, A. (ed.) Proceedings of the 6th International Conference on Logic Programming (ICLP 1989), pp. 521–536. Lisboa, Portugal (1989)Nilsson, H.: Declarative Debugging for Lazy Functional Languages. Ph.D. thesis, Linköping, Sweden, May 1998Nilsson, H.: How to look busy while being as lazy as ever: the implementation of a lazy functional debugger. J. Funct. Program. 11(6), 629–671 (2001)Nilsson, H., Fritzson, P.: Algorithmic debugging for lazy functional languages. J. Funct. Program. 4(3), 337–370 (1994)Nilsson, H., Sparud, J.: The evaluation dependence tree: an execution record for lazy functional debugging. Technical report, Department of Computer and Information Science, Linköping (1996)Nilsson, H., Sparud, J.: The evaluation dependence tree as a basis for lazy functional debugging. Autom. Softw. Eng. 4(2), 121–150 (1997)Pope, B.: A Declarative Debugger for Haskell. Ph.D. thesis, The University of Melbourne, Australia (2006)Shapiro, E.: Algorithmic Program Debugging. MIT Press, Cambridge (1982)Shapiro, E.Y.: Inductive inference of theories from facts. Technical report RR 192, Yale University (New Haven, CT US) (1981)Silva, J.: A survey on algorithmic debugging strategies. Adv. Eng. Softw. 42(11), 976–991 (2011)Silva, J.: A vocabulary of program slicing-based techniques. ACM Comput. Surv. 44(3), 1–12 (2012)Thompson, B., Naish, L.: A guide to the nu-prolog debugging environment. Technical report, University of Melbourne (1997

Lightweight Computation Tree Tracing for Lazy Functional Languages

A computation tree of a program execution describes computations of functions and their dependencies. A computation tree describes how a program works and is at the heart of algorithmic debugging. To generate a computation tree, existing algorithmic debuggers either use a complex implementation or yield a less informative approximation. We present a method for lazy functional languages that requires only a simple tracing library to generate a detailed computation tree. With our algorithmic debugger a programmer can debug any Haskell program by only importing our library and annotating suspected functions

A survey on algorithmic debugging strategies

Algorithmic debugging is a debugging technique that has been extended to practically all programming paradigms. Roughly speaking, the technique constructs an internal representation of all (sub)computations performed during the execution of a buggy program; and then, it asks the programmer about the correctness of such computations. The answers of the programmer guide the search for the bug until it is isolated by discarding correct parts of the program. After twenty years of research in algorithmic debugging many different techniques have appeared to improve the original proposal. Surprisingly, no study exists that joins together all these techniques and compares their advantages and their performance. This article presents a study that compares all current algorithmic debugging techniques and analyzes their differences and their costs. The research identifies the dimensions on which each strategy relies. This information allows us to combine the strong points of different strategies.This work has been partially supported by the Spanish Ministerio de Ciencia e Innovacion under Grant TIN2008-06622-C03-02 and by the Generalitat Valenciana under Grant PROMETEO/2011/052.Silva Galiana, JF. (2011). A survey on algorithmic debugging strategies. Advances in Engineering Software. 42(11):976-991. https://doi.org/10.1016/j.advengsoft.2011.05.024S976991421

A Generalization and Paradigm-Independent Reformulation of Algorithmic Debugging

The final publication is available at Springer via http://dx.doi.org/10.1007/978-3-319-27436-2_16Algorithmic debugging is a semi-automatic debugging technique that is present in practically all mature programming languages. In this paper we claim that the state of the practice in algorithmic debugging is a step forward compared to the state of the theory. In particular, we argue that novel techniques for algorithmic debugging cannot be supported by the standard internal data structures used in this technique, and a generalization of the standard definitions and algorithms is needed. We identify two specific problems of the standard formulation and implementations of algorithmic debugging, and we propose a reformulation to solve both problems. The reformulation has been done in a paradigm-independent manner to make it useful and reusable in different programming languages.This work has been partially supported by the EU (FEDER) and the Spanish Ministerio de Economía y Competitividad (Secretaría de Estado de Investigación, Desarrollo e Innovación) under Grant TIN2013-44742-C4-1-R and by the Generalitat Valenciana under Grant PROMETEOII/2015/013. David Insa was partially supported by the Spanish Ministerio de Educación under FPU Grant AP2010-4415.Insa Cabrera, D.; Silva, J. (2015). A Generalization and Paradigm-Independent Reformulation of Algorithmic Debugging. Springer. 261-276. http://hdl.handle.net/10251/71738S261276Eclipse (2003). http://www.eclipse.org/Barbour, T., Naish, L.: Declarative debugging of a logical-functional language. Technical report, University of Melbourne (1994)Braßel, B., Siegel, H.: Debugging lazy functional programs by asking the oracle. In: Chitil, O., Horváth, Z., Zsók, V. (eds.) IFL 2007. LNCS, vol. 5083, pp. 183–200. Springer, Heidelberg (2008)Caballero, R.: A declarative debugger of incorrect answers for constraint functional-logic programs. In: Proceedings of the 2005 ACM-SIGPLAN Workshop on Curry and Functional Logic Programming (WCFLP 2005), pp. 8–13. ACM Press, New York, USA (2005)Caballero, R., Martin-Martin, E., Riesco, A., Tamarit, S.: EDD: A declarative debugger for sequential erlang programs. In: Ábrahám, E., Havelund, K. (eds.) TACAS 2014 (ETAPS). LNCS, vol. 8413, pp. 581–586. Springer, Heidelberg (2014)Caballero, R., Riesco, A., Verdejo, A., Martí-Oliet, N.: Simplifying questions in maude declarative debugger by transforming proof trees. In: Vidal, G. (ed.) LOPSTR 2011. LNCS, vol. 7225, pp. 73–89. Springer, Heidelberg (2012)Cheda, D., Silva, J.: State of the practice in algorithmic debugging. Electron. Notes Theor. Comput. Sci. 246, 55–70 (2009)Davie, T., Chitil, O.: Hat-delta: one right does make a wrong. In: Butterfield, A., (ed.) Proceedings of the 17th International Workshop on Implementation and Application of Functional Languages (IFL 2005), p. 11, September 2005Davie, T., Chitil, O.: Hat-delta: One right does make a wrong. In: Proceedings of the 7th Symposium on Trends in Functional Programming (TFP 2006), April 2006Fritzson, P., Shahmehri, N., Kamkar, M., Gyimóthy, T.: Generalized algorithmic debugging and testing. ACM Lett. Program. Lang. Syst. (LOPLAS) 1(4), 303–322 (1992)González, J., Insa, D., Silva, J.: A new hybrid debugging architecture for eclipse. In: Gupta, G., Peña, R. (eds.) LOPSTR 2013, LNCS 8901. LNCS, vol. 8901, pp. 183–201. Springer, Heidelberg (2014)Hermanns, C., Kuchen, H.: Hybrid debugging of java programs. In: Escalona, M.J., Cordeiro, J., Shishkov, B. (eds.) ICSOFT 2011. CCIS, vol. 303, pp. 91–107. Springer, Heidelberg (2013)Insa, D., Silva, J.: An algorithmic debugger for java. In: Proceedings of the 26th IEEE International Conference on Software Maintenance (ICSM 2010), pp. 1–6 (2010)Insa, D., Silva, J.: Automatic transformation of iterative loops into recursive methods. Inf. Soft. Technol. 58, 95–109 (2015)Insa, D., Silva, J., Riesco, A.: Speeding up algorithmic debugging using balanced execution trees. In: Veanes, M., Viganò, L. (eds.) TAP 2013. LNCS, vol. 7942, pp. 133–151. Springer, Heidelberg (2013)Insa, D., Silva, J., Tomás, C.: Enhancing declarative debugging with loop expansion and tree compression. In: Albert, E. (ed.) LOPSTR 2012. LNCS, vol. 7844, pp. 71–88. Springer, Heidelberg (2013)Lloyd, J.: Declarative error diagnosis. New Gener. Comput. 5(2), 133–154 (1987)Lux, M.: Münster Curry User’s Guide, May 2006. http://danae.uni-muenster.de/lux/curry/user.pdf ,MacLarty, I.D.: Practical Declarative Debugging of Mercury Programs. Ph.D. thesis, University of Melbourne (2005)Naish, L., Dart, P.W., Zobel, J.: The NU-Prolog debugging environment. In: Porto, A. (ed.) Proceedings of the 6th International Conference on Logic Programming (ICLP 1989), pp. 521–536. Lisboa, Portugal (1989)Nilsson, H.: Declarative Debugging for Lazy Functional Languages. Ph.D. thesis, Linköping, Sweden, May 1998Nilsson, H.: How to look busy while being as lazy as ever: the implementation of a lazy functional debugger. J. Funct. Program. 11(6), 629–671 (2001)Nilsson, H., Fritzson, P.: Algorithmic debugging for lazy functional languages. J. Funct. Program. 4(3), 337–370 (1994)Nilsson, H., Sparud, J.: The evaluation dependence tree: an execution record for lazy functional debugging. Technical report, Department of Computer and Information Science, Linköping (1996)Nilsson, H., Sparud, J.: The evaluation dependence tree as a basis for lazy functional debugging. Autom. Softw. Eng. 4(2), 121–150 (1997)Pope, B.: A Declarative Debugger for Haskell. Ph.D. thesis, The University of Melbourne, Australia (2006)Shapiro, E.: Algorithmic Program Debugging. MIT Press, Cambridge (1982)Shapiro, E.Y.: Inductive inference of theories from facts. Technical report RR 192, Yale University (New Haven, CT US) (1981)Silva, J.: A survey on algorithmic debugging strategies. Adv. Eng. Softw. 42(11), 976–991 (2011)Silva, J.: A vocabulary of program slicing-based techniques. ACM Comput. Surv. 44(3), 1–12 (2012)Thompson, B., Naish, L.: A guide to the nu-prolog debugging environment. Technical report, University of Melbourne (1997

JWalk: a tool for lazy, systematic testing of java classes by design introspection and user interaction

Popular software testing tools, such as JUnit, allow frequent retesting of modified code; yet the manually created test scripts are often seriously incomplete. A unit-testing tool called JWalk has therefore been developed to address the need for systematic unit testing within the context of agile methods. The tool operates directly on the compiled code for Java classes and uses a new lazy method for inducing the changing design of a class on the fly. This is achieved partly through introspection, using Java’s reflection capability, and partly through interaction with the user, constructing and saving test oracles on the fly. Predictive rules reduce the number of oracle values that must be confirmed by the tester. Without human intervention, JWalk performs bounded exhaustive exploration of the class’s method protocols and may be directed to explore the space of algebraic constructions, or the intended design state-space of the tested class. With some human interaction, JWalk performs up to the equivalent of fully automated state-based testing, from a specification that was acquired incrementally

Algorithmic debugging for complex lazy functional programs

An algorithmic debugger finds defects in programs by systematic search. It relies on the programmer to direct the search by answering a series of yes/no questions about the correctness of specific function applications and their results. Existing algorithmic debuggers for a lazy functional language work well for small simple programs but cannot be used to locate defects in complex programs for two reasons: Firstly, to collect the information required for algorithmic debugging existing debuggers use different but complex implementations. Therefore, these debuggers are hard to maintain and do not support all the latest language features. As a consequence, programs with unsupported language features cannot be debugged. Also inclusion of a library using unsupported languages features can make algorithmic debugging unusable even when the programmer is not interested in debugging the library. Secondly, algorithmic debugging breaks down when the size or number of questions is too great for the programmer to handle. This is a pity, because, even though algorithmic debugging is a promising method for locating defects, many real-world programs are too complex for the method to be usuable. I claim that the techniques in in this thesis make algorithmic debugging useable for a much more complex lazy functional programs. I present a novel method for collecting the information required for algorithmically debugging a lazy functional program. The method is non-invasive, uses program annotations in suspected modules only and has a simple implementation. My method supports all of Haskell, including laziness, higher-order functions and exceptions. Future language extensions can be supported without changes, or with minimal changes, to the implementation of the debugger. With my method the programmer can focus on untrusted code -- lots of trusted libraries are unaffected. This makes traces, and hence the amount of questions that needs to be answered, more manageable. I give a type-generic definition to support custom types defined by the programmer. Furthermore, I propose a method that re-uses properties to answer automatically some of the questions arising during algorithmic debugging, and to replace others by simpler questions. Properties may already be present in the code for testing; the programmer can also encode a specification or reference implementation as a property, or add a new property in response to a statement they are asked to judge

Compositional Explanation of Types and Algorithmic Debugging of Type Errors

The type systems of most typed functional programming languages are based on the Hindley-Milner type system. A practical problem with these type systems is that it is often hard to understand why a program is not type correct or a function does not have the intended type. We suggest that at the core of this problem is the difficulty of explaining why a given expression has a certain type. The type system is not defined compositionally. We propose to explain types using a variant of the Hindley-Milner type system that defines a compositional type explanation graph of principal typings. We describe how the programmer understands types by interactive navigation through the explanation graph. Furthermore, the explanation graph can be the foundation for algorithmic debugging of type errors, that is, semi-automatic localisation of the source of a type error without even having to understand the type inference steps. We implemented a prototype of a tool to explore the usefulness of the proposed methods

An Analysis of the Current Program Slicing and Algorithmic Debugging Based Techniques

This thesis presents a classification of program slicing based techniques. The classification allows us to identify the differences between existing techniques, but it also allows us to predict new slicing techniques. The study identifies and compares the dimensions that influence current techniques.Silva Galiana, JF. (2008). An Analysis of the Current Program Slicing and Algorithmic Debugging Based Techniques. http://hdl.handle.net/10251/14300Archivo delegad