Error-correcting source code

Yasuhiro Ajiro, Kazunori Ueda, Kenta Cho

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

    5 Citations (Scopus)

    Abstract

    We study how constraint-based static analysis can be applied to the automated and systematic debugging of program errors. Strongly moding and constraint-based mode analysis are turning to play fundamental roles in debugging concurrent logic/constraint programs as well as in establishing the consistency of communication protocols and in optimization. Mode analysis of Moded Flat GHC is a constraint satisfaction problem with many simple mode constraints, and can be solved efficiently by unification over feature graphs. We have proposed a simple and efficient technique which, given a non-well-moded program, diagnoses the “reasons” of inconsistency by finding minimal inconsistent subsets of mode constraints. Since each constraint keeps track of the symbol occurrence in the program that imposed the constraint, a minimal subset also tells possible sources of program errors. The technique is quite general and can be used with other constraint-based frameworks such as strong typing. Based on the above idea, we study the possibility of automated debugging in the absence of mode/type declarations. The mode constraints are usually imposed redundantly, and the constraints that are considered correct can be used for correcting wrong symbol occurrences found by the diagnosis. As long as bugs are near-misses, the automated debugger can propose a rather small number of alternatives that include the intended program. Search space is kept small because constraints effectively prune many irrelevant alternatives. The paper demonstrates the technique by way of examples.

    Original languageEnglish
    Title of host publicationLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
    PublisherSpringer Verlag
    Pages40-54
    Number of pages15
    Volume1520
    ISBN (Print)3540652248, 9783540652243
    DOIs
    Publication statusPublished - 1998
    Event4th International Conference on Principles and Practice of Constraint Programming, CP 1998 - Pisa, Italy
    Duration: 1998 Oct 261998 Oct 30

    Publication series

    NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
    Volume1520
    ISSN (Print)03029743
    ISSN (Electronic)16113349

    Other

    Other4th International Conference on Principles and Practice of Constraint Programming, CP 1998
    CountryItaly
    CityPisa
    Period98/10/2698/10/30

    Fingerprint

    Constraint satisfaction problems
    Static analysis
    Network protocols
    Debugging
    Subset
    Alternatives
    Constraint Satisfaction Problem
    Communication Protocol
    Static Analysis
    Unification
    Inconsistency
    Inconsistent
    Search Space
    Concurrent
    Logic
    Optimization
    Graph in graph theory
    Demonstrate

    ASJC Scopus subject areas

    • Computer Science(all)
    • Theoretical Computer Science

    Cite this

    Ajiro, Y., Ueda, K., & Cho, K. (1998). Error-correcting source code. In Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics) (Vol. 1520, pp. 40-54). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 1520). Springer Verlag. https://doi.org/10.1007/3-540-49481-2_5

    Error-correcting source code. / Ajiro, Yasuhiro; Ueda, Kazunori; Cho, Kenta.

    Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). Vol. 1520 Springer Verlag, 1998. p. 40-54 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 1520).

    Research output: Chapter in Book/Report/Conference proceedingConference contribution

    Ajiro, Y, Ueda, K & Cho, K 1998, Error-correcting source code. in Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). vol. 1520, Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 1520, Springer Verlag, pp. 40-54, 4th International Conference on Principles and Practice of Constraint Programming, CP 1998, Pisa, Italy, 98/10/26. https://doi.org/10.1007/3-540-49481-2_5
    Ajiro Y, Ueda K, Cho K. Error-correcting source code. In Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). Vol. 1520. Springer Verlag. 1998. p. 40-54. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/3-540-49481-2_5
    Ajiro, Yasuhiro ; Ueda, Kazunori ; Cho, Kenta. / Error-correcting source code. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics). Vol. 1520 Springer Verlag, 1998. pp. 40-54 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
    @inproceedings{cbaaa1016d1c45b8962f39092f3d07da,
    title = "Error-correcting source code",
    abstract = "We study how constraint-based static analysis can be applied to the automated and systematic debugging of program errors. Strongly moding and constraint-based mode analysis are turning to play fundamental roles in debugging concurrent logic/constraint programs as well as in establishing the consistency of communication protocols and in optimization. Mode analysis of Moded Flat GHC is a constraint satisfaction problem with many simple mode constraints, and can be solved efficiently by unification over feature graphs. We have proposed a simple and efficient technique which, given a non-well-moded program, diagnoses the “reasons” of inconsistency by finding minimal inconsistent subsets of mode constraints. Since each constraint keeps track of the symbol occurrence in the program that imposed the constraint, a minimal subset also tells possible sources of program errors. The technique is quite general and can be used with other constraint-based frameworks such as strong typing. Based on the above idea, we study the possibility of automated debugging in the absence of mode/type declarations. The mode constraints are usually imposed redundantly, and the constraints that are considered correct can be used for correcting wrong symbol occurrences found by the diagnosis. As long as bugs are near-misses, the automated debugger can propose a rather small number of alternatives that include the intended program. Search space is kept small because constraints effectively prune many irrelevant alternatives. The paper demonstrates the technique by way of examples.",
    author = "Yasuhiro Ajiro and Kazunori Ueda and Kenta Cho",
    year = "1998",
    doi = "10.1007/3-540-49481-2_5",
    language = "English",
    isbn = "3540652248",
    volume = "1520",
    series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
    publisher = "Springer Verlag",
    pages = "40--54",
    booktitle = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",

    }

    TY - GEN

    T1 - Error-correcting source code

    AU - Ajiro, Yasuhiro

    AU - Ueda, Kazunori

    AU - Cho, Kenta

    PY - 1998

    Y1 - 1998

    N2 - We study how constraint-based static analysis can be applied to the automated and systematic debugging of program errors. Strongly moding and constraint-based mode analysis are turning to play fundamental roles in debugging concurrent logic/constraint programs as well as in establishing the consistency of communication protocols and in optimization. Mode analysis of Moded Flat GHC is a constraint satisfaction problem with many simple mode constraints, and can be solved efficiently by unification over feature graphs. We have proposed a simple and efficient technique which, given a non-well-moded program, diagnoses the “reasons” of inconsistency by finding minimal inconsistent subsets of mode constraints. Since each constraint keeps track of the symbol occurrence in the program that imposed the constraint, a minimal subset also tells possible sources of program errors. The technique is quite general and can be used with other constraint-based frameworks such as strong typing. Based on the above idea, we study the possibility of automated debugging in the absence of mode/type declarations. The mode constraints are usually imposed redundantly, and the constraints that are considered correct can be used for correcting wrong symbol occurrences found by the diagnosis. As long as bugs are near-misses, the automated debugger can propose a rather small number of alternatives that include the intended program. Search space is kept small because constraints effectively prune many irrelevant alternatives. The paper demonstrates the technique by way of examples.

    AB - We study how constraint-based static analysis can be applied to the automated and systematic debugging of program errors. Strongly moding and constraint-based mode analysis are turning to play fundamental roles in debugging concurrent logic/constraint programs as well as in establishing the consistency of communication protocols and in optimization. Mode analysis of Moded Flat GHC is a constraint satisfaction problem with many simple mode constraints, and can be solved efficiently by unification over feature graphs. We have proposed a simple and efficient technique which, given a non-well-moded program, diagnoses the “reasons” of inconsistency by finding minimal inconsistent subsets of mode constraints. Since each constraint keeps track of the symbol occurrence in the program that imposed the constraint, a minimal subset also tells possible sources of program errors. The technique is quite general and can be used with other constraint-based frameworks such as strong typing. Based on the above idea, we study the possibility of automated debugging in the absence of mode/type declarations. The mode constraints are usually imposed redundantly, and the constraints that are considered correct can be used for correcting wrong symbol occurrences found by the diagnosis. As long as bugs are near-misses, the automated debugger can propose a rather small number of alternatives that include the intended program. Search space is kept small because constraints effectively prune many irrelevant alternatives. The paper demonstrates the technique by way of examples.

    UR - http://www.scopus.com/inward/record.url?scp=84957647540&partnerID=8YFLogxK

    UR - http://www.scopus.com/inward/citedby.url?scp=84957647540&partnerID=8YFLogxK

    U2 - 10.1007/3-540-49481-2_5

    DO - 10.1007/3-540-49481-2_5

    M3 - Conference contribution

    AN - SCOPUS:84957647540

    SN - 3540652248

    SN - 9783540652243

    VL - 1520

    T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

    SP - 40

    EP - 54

    BT - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

    PB - Springer Verlag

    ER -