Simón Gutiérrez Brida

Simón Gutiérrez Brida

Auto-generated profile, based on publicly available information

Simón Gutiérrez Brida

Universidad Nacional de Río Cuarto, Río Cuarto, Argentina

Research Focus & Metrics

Academic Career Length

10Years (2017-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
10 October 2022
Verified
Conference Paper
Open access
SBSimón Gutiérrez Brida
Simón Gutiérrez Brida
GRGermán Regis
Germán Regis
GZGuolong Zheng
Guolong Zheng
HBHamid Bagheri
Hamid Bagheri
TNThanhvu Nguyen
Thanhvu Nguyen
MFMarcelo Frias
Marcelo Frias
Automated program repair (APR) techniques have shown great success in automatically finding fixes for programs in programming languages such as C or Java. In this work, we focus on repairing formal specifications, in particular for the Alloy specification language. As opposed to most APR tools, our approach to repair Alloy specifications, named ICEBAR, does not use test-based oracles for patch assessment. Instead, ICEBAR relies on the use of property-based oracles, commonly found in Alloy specifications as predicates and assertions. These property-based oracles define stronger conditions for patch assessment, thus reducing the notorious overfitting issue caused by using test-based oracles, typically observed in APR contexts. Moreover, as assertions and predicates are inherent to Alloy, whereas test cases are not, our tool is potentially more appealing to Alloy users than test-based Alloy repair tools. At a high level, ICEBAR is an iterative, counterexample-based process, that generates and validates repair candidates. ICEBAR receives a faulty Alloy specification with a failing property-based oracle, and uses Alloy’s counterexamples to build tests and feed ARepair, a test-based Alloy repair tool, in order to produce a repair candidate. The candidate is then checked against the property oracle for overfitting: if the candidate passes, a repair has been found; if not, further counterexamples are generated to construct tests and enhance the test suite, and the process is iterated. ICEBAR includes different mechanisms, with different degrees of reliability, to generate counterexamples from failing predicates and assertions. Our evaluation shows that ICEBAR significantly improves over ARepair, in both reducing overfitting and improving the repair rate. Moreover, ICEBAR shows that iterative refinement allows us to significantly improve a state-of-the-art tool for automated repair of Alloy specifications without any modifications to the tool.

21 August 2017
Verified
Conference Paper
Open access
GRGermán Regis
Germán Regis
CCCésar Cornejo
César Cornejo
SBSimón Gutiérrez Brida
Simón Gutiérrez Brida
MPMariano Politano
Mariano Politano
FRFernando Raverta
Fernando Raverta
MFMarcelo Frias
Marcelo Frias
We describe DynAlloy Analyzer, a tool that extends Alloy Analyzer with support for dynamic elements in Alloy models. The tool builds upon Alloy Analyzer in a way that makes it fully compatible with Alloy models, and extends their syntax with a particular idiom, inspired in dynamic logic, for the description of dynamic behaviours, understood as sequences of states over standard Alloy models, in terms of programs. The syntax is broad enough to accommodate abstract dynamic behaviours, e.g., using nondeterministic choice and finite unbounded iteration, as well as more concrete ones, using standard sequential programming constructions. The analysis of DynAlloy models resorts to the analysis of Alloy models, through an optimized translation that often makes the analysis more efficient than that of typical ad-hoc constructions to capture dynamism in Alloy. Tool screencast, binaries and further details available in: http://dc.exa.unrc.edu.ar/tools/dynalloy

1 May 2017
Verified
Conference Paper
Closed access
LZLuciano Zemin
Luciano Zemin
SBSimon Gutierrez Brida
Simon Gutierrez Brida
AGAriel Godio
Ariel Godio
CCCesar Cornejo
Cesar Cornejo
RDRenzo Degiovanni
Renzo Degiovanni
MFMarcelo Frias
Marcelo Frias
Program repair techniques attempt to fix programs by looking for patches within a search space of fix candidates. These techniques require a specification of the program to be repaired, used as an acceptance criterion for fix candidates, that often also plays an important role in guiding some search processes. Most tools use tests as specifications, which constitutes a risk, since the incompleteness of tests as specifications may lead one to obtain spurious repairs, that pass all tests but are in fact incorrect. This problem has been identified by various researchers, raising concerns about the validity of program fixes. More thorough studies have been proposed using different sets of tests for fix validation, and resorting to manual inspection, showing that while tools reduce their program fixing rate, they are still able to repair a significant number of cases. In this paper, we perform a different analysis of the suitability of tests as acceptance criteria for automated program fixes, by checking patches produced by automated repair tools using a bug-finding tool, as opposed to previous works that used tests or manual inspections. We develop a number of experiments in which faulty programs from a known benchmark are fed to the program repair tools GenProg, Angelix, AutoFix and Nopol, using test suites of varying quality and extension, including those accompanying the benchmark. We then check the produced patches against formal specifications using a bug-finding tool. Our results show that, in general, automated program repair tools are significantly more likely to accept a spurious program fix than producing an actual one, in the studied scenarios.

28 May 2018
Verified
Conference Paper
Open access
PDF file
PPPablo Ponzio
Pablo Ponzio
VBValeria Bengolea
Valeria Bengolea
SBSimón Gutiérrez Brida
Simón Gutiérrez Brida
GSGastón Scilingo
Gastón Scilingo
NANazareno Aguirre
Nazareno Aguirre
MFMarcelo Frias
Marcelo Frias

20 February 2025 in ACM Transactions on Software Engineering and Methodology
Verified
Journal Article
Open access
LZLuciano Zemín
Luciano Zemín
AGAriel Godio
Ariel Godio
CCCésar Cornejo
César Cornejo
RDRenzo Degiovanni
Renzo Degiovanni
SBSimón Gutiérrez Brida
Simón Gutiérrez Brida
MFMarcelo Fabián Frias
Marcelo Fabián Frias
In this article, we empirically study the suitability of tests as acceptance criteria for automated program fixes, by checking patches produced by automated repair tools using a bug-finding tool, as opposed to previous works that used tests or manual inspections. We develop a number of experiments in which faulty programs from IntroClass , a known benchmark for program repair techniques, are fed to the program repair tools GenProg, Angelix, AutoFix, and Nopol, using test suites of varying quality, including those accompanying the benchmark. We then check the produced patches against formal specifications using a bug-finding tool. Our results show that, in the studied scenarios, automated program repair tools are significantly more likely to accept a spurious program fix than producing an actual one. Using bounded-exhaustive suites larger than the originally given ones (with about 100 and 1,000 tests) we verify that overfitting is reduced but (a) few new correct repairs are generated and (b) some tools see their performance reduced by the larger suites and fewer correct repairs are produced. Finally, by comparing with previous work, we show that overfitting is underestimated in semantics-based tools and that patches not discarded using held-out tests may be discarded using a bug-finding tool.

1 September 2017
Verified
Conference Paper
Closed access
SBSimon Gutierrez Brida
Simon Gutierrez Brida
GSGaston Scilingo
Gaston Scilingo
The degree in which a software system is guaranteed to correctly provide its intended functionality, is one of the most relevant properties in the development of quality software, and the concern of software verification. Among the many techniques that approach software verification, testing, i.e., contrasting actual software behavior against expected behavior in a set of specific scenarios called test cases, is without any doubt the most widely used. Performing software testing appropriately demands evaluating the quality of the test cases, and mutation testing is a particularly relevant technique for evaluating the adequacy of test suites, that occupies us in this paper. Mutation testing proposes evaluating how good a set of test cases is by injecting artificial bugs in a program, and checking whether the suite is able to catch these buggy programs, called mutants. Mutation testing's performance is strongly related to the mutation operators considered, i.e., the set of changes that are applied to a program to generate mutants. We present a novel mutation operator whose main focus is boolean expressions, and that operates by strengthening and weakening such expressions. Although operators that perform this task already exist in the context of mutation testing, e.g. the COR operator, these do not provide finer-grained changes in expressions. The rationale behind our new operator is that performing finer-grained mutations in boolean expressions results in more “stubborn” mutants, i.e., more mutants that are difficult to kill. We present our novel mutation operator in detail, discuss its characteristics and rationale, and evaluate the impact of introducing this operator in mutation testing tools, with respect to how it performs in assessing test suite quality.