Standard

Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction. / Castro, Sergio; De Roover, Coen; Kellens, Andy; Lozano, Angela; Mens, Kim; D'Hondt, Theo.

In: Science of Computer Programming, Vol. 76, No. Special Issue on Software Evolution, Adaptability, 01.12.2011, p. 1113-1129.

Research output: Contribution to journalArticle

Harvard

Castro, S, De Roover, C, Kellens, A, Lozano, A, Mens, K & D'Hondt, T 2011, 'Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction', Science of Computer Programming, vol. 76, no. Special Issue on Software Evolution, Adaptability, pp. 1113-1129.

APA

Castro, S., De Roover, C., Kellens, A., Lozano, A., Mens, K., & D'Hondt, T. (2011). Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction. Science of Computer Programming, 76(Special Issue on Software Evolution, Adaptability), 1113-1129.

Vancouver

Castro S, De Roover C, Kellens A, Lozano A, Mens K, D'Hondt T. Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction. Science of Computer Programming. 2011 Dec 1;76(Special Issue on Software Evolution, Adaptability):1113-1129.

Author

Castro, Sergio ; De Roover, Coen ; Kellens, Andy ; Lozano, Angela ; Mens, Kim ; D'Hondt, Theo. / Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction. In: Science of Computer Programming. 2011 ; Vol. 76, No. Special Issue on Software Evolution, Adaptability. pp. 1113-1129.

BibTeX

@article{2491bf77c2f14b62b43c17f9854509e0,
title = "Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction",
abstract = "Correcting design decay in source code is not a trivial task. Diagnosing and subsequently correcting inconsistencies between a software systems's code and its design rules (e.g., database queries are only allowed in the persistence layer) and coding conventions can be complex, time-consuming and error-prone. Providing support for this process is therefore highly desirable, but of a far greater complexity than suggesting basic corrective actions for simplistic implementation problems (like the {"}declare a local variable for non-declared variable{"} suggested by Eclipse). We present an abductive reasoning approach to inconsistency correction that consists of (1) a means for developers to document and verify a system's design and coding rules, (2) an abductive logic reasoner that hypothesizes possible causes of inconsistencies between the system's code and the documented rules and (3) a library of corrective actions for each hypothesized cause. This work builds on our previous work, where we expressed design rules as equality relationships between sets of source code artifacts (e.g., the set of methods in the persistence layer is the same as the set of methods that query the database). In this paper, we generalize our approach to design rules expressed as user-defined binary relationships between two sets of source code artifacts (e.g., every state changing method should invoke a persistence method). We illustrate our approach on the design of IntensiVE, a tool suite that enables defining sets of source code artifacts intensionally (by means of logic queries) and verifying relationships between such sets.",
keywords = "Abductive reasoning, IntensiVE",
author = "Sergio Castro and {De Roover}, Coen and Andy Kellens and Angela Lozano and Kim Mens and Theo D'Hondt",
year = "2011",
month = "12",
day = "1",
language = "English",
volume = "76",
pages = "1113--1129",
journal = "Science of Computer Programming",
issn = "0167-6423",
publisher = "Elsevier",
number = "Special Issue on Software Evolution, Adaptability",

}

RIS

TY - JOUR

T1 - Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction

AU - Castro, Sergio

AU - De Roover, Coen

AU - Kellens, Andy

AU - Lozano, Angela

AU - Mens, Kim

AU - D'Hondt, Theo

PY - 2011/12/1

Y1 - 2011/12/1

N2 - Correcting design decay in source code is not a trivial task. Diagnosing and subsequently correcting inconsistencies between a software systems's code and its design rules (e.g., database queries are only allowed in the persistence layer) and coding conventions can be complex, time-consuming and error-prone. Providing support for this process is therefore highly desirable, but of a far greater complexity than suggesting basic corrective actions for simplistic implementation problems (like the "declare a local variable for non-declared variable" suggested by Eclipse). We present an abductive reasoning approach to inconsistency correction that consists of (1) a means for developers to document and verify a system's design and coding rules, (2) an abductive logic reasoner that hypothesizes possible causes of inconsistencies between the system's code and the documented rules and (3) a library of corrective actions for each hypothesized cause. This work builds on our previous work, where we expressed design rules as equality relationships between sets of source code artifacts (e.g., the set of methods in the persistence layer is the same as the set of methods that query the database). In this paper, we generalize our approach to design rules expressed as user-defined binary relationships between two sets of source code artifacts (e.g., every state changing method should invoke a persistence method). We illustrate our approach on the design of IntensiVE, a tool suite that enables defining sets of source code artifacts intensionally (by means of logic queries) and verifying relationships between such sets.

AB - Correcting design decay in source code is not a trivial task. Diagnosing and subsequently correcting inconsistencies between a software systems's code and its design rules (e.g., database queries are only allowed in the persistence layer) and coding conventions can be complex, time-consuming and error-prone. Providing support for this process is therefore highly desirable, but of a far greater complexity than suggesting basic corrective actions for simplistic implementation problems (like the "declare a local variable for non-declared variable" suggested by Eclipse). We present an abductive reasoning approach to inconsistency correction that consists of (1) a means for developers to document and verify a system's design and coding rules, (2) an abductive logic reasoner that hypothesizes possible causes of inconsistencies between the system's code and the documented rules and (3) a library of corrective actions for each hypothesized cause. This work builds on our previous work, where we expressed design rules as equality relationships between sets of source code artifacts (e.g., the set of methods in the persistence layer is the same as the set of methods that query the database). In this paper, we generalize our approach to design rules expressed as user-defined binary relationships between two sets of source code artifacts (e.g., every state changing method should invoke a persistence method). We illustrate our approach on the design of IntensiVE, a tool suite that enables defining sets of source code artifacts intensionally (by means of logic queries) and verifying relationships between such sets.

KW - Abductive reasoning

KW - IntensiVE

M3 - Article

VL - 76

SP - 1113

EP - 1129

JO - Science of Computer Programming

JF - Science of Computer Programming

SN - 0167-6423

IS - Special Issue on Software Evolution, Adaptability

ER -

ID: 2022320