Otávio Augusto Lazzarini Lemos
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Previous Organizations / Institutes
The organizations / institutes from the scholar's other articles in the past ten years
Research Subjects
Otávio Augusto Lazzarini Lemos has a total of 75 co-authors. Here are the top co-authors by number of shared publications:
Paulo Cesar Masiero
8 shared publications- Fabiano Cutigi Ferrari
Computing Department, Federal University of São Carlos, São Carlos, Brazil
4 shared publications - Fábio Fagundes Silveira
Federal University of São Paulo
4 shared publications Joel Ossher
4 shared publicationsAlessandro Garcia
3 shared publicationsEduardo Figueiredo
3 shared publications
Latest Publications
- 25 June 2024
- Published by Springer Nature in Software Quality Journal
- Vol. 32 (3) , 1137-1174
Unraveling the code: an in-depth empirical study on the impact of development practices in auxiliary functions implementation
- 25 June 2024
- Published by Springer Nature in Software Quality Journal
- Vol. 32 (3) , 1137-1174
Unraveling the code: an in-depth empirical study on the impact of development practices in auxiliary functions implementation
- Open Access
- 30 March 2020
- Published by Association for Computing Machinery (ACM)
- p. 100-109
Comparing identifiers and comments in engineered and non-engineered code
Identifiers and comments are important sources of information to understand software. Approximately 70% of the code of a system consists of identifiers [1]. Identifier length and quality, as well as naming conventions overall, influence the difficulty and time required to complete maintenance tasks like code reading or debugging [2--4]. After the code itself, comments are the main source of documentation for software maintainers [5], and experiments show that commented code is easier to understand when compared to uncommented code [6]. Therefore these elements are of paramount importance for software development in general.
- 30 March 2020
- Published by Association for Computing Machinery (ACM)
- p. 100-109
Open AccessComparing identifiers and comments in engineered and non-engineered code
Identifiers and comments are important sources of information to understand software. Approximately 70% of the code of a system consists of identifiers [1]. Identifier length and quality, as well as naming conventions overall, influence the difficulty and time required to complete maintenance tasks like code reading or debugging [2--4]. After the code itself, comments are the main source of documentation for software maintainers [5], and experiments show that commented code is easier to understand when compared to uncommented code [6]. Therefore these elements are of paramount importance for software development in general.
- 1 September 2017
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 31-40
An Exploratory Study of Functional Redundancy in Code Repositories
In large code repositories, the probability of functions to repeat across projects is high. This type of functional redundancy (FR) is desirable for recent code reuse and repair approaches. Yet, FR is hard to measure because it is closely related to program equivalence, which is an undecidable problem. This is one of the reasons most studies that investigate redundancy focus on syntactic rather than semantic replication (e.g., cloning). In this paper we evaluate the extent of FR in a code repository with 68 Java projects taken randomly from SourceForge. Our technique approximates function similarity by first searching for methods that possess similar interfaces (return type, name, and parameter types). We then execute these methods to verify which candidate pairs have matching outputs for a given sample of inputs. Some recent studies have also focused on this type of semantic replication, but our detection approach is generally cheaper and more precise, because it focuses on methods and uses interfaces to reduce the search space. Although our scope is restricted to static methods, which makes our results conservative, our findings are promising. In particular, we found 984 pairs of redundant methods, and 28 out of the 68 (41.17%) projects in the repository presented redundancy. Moreover, the majority of redundant methods for which we had access to the source code did not refer to textual clones (only one redundant method pair referred to replicated code). Our study also indicates that the proposed redundancy detection approach has high precision and is generally inexpensive (only four executions were required per method to attain 100% precision).
- 1 September 2017
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 31-40
An Exploratory Study of Functional Redundancy in Code Repositories
In large code repositories, the probability of functions to repeat across projects is high. This type of functional redundancy (FR) is desirable for recent code reuse and repair approaches. Yet, FR is hard to measure because it is closely related to program equivalence, which is an undecidable problem. This is one of the reasons most studies that investigate redundancy focus on syntactic rather than semantic replication (e.g., cloning). In this paper we evaluate the extent of FR in a code repository with 68 Java projects taken randomly from SourceForge. Our technique approximates function similarity by first searching for methods that possess similar interfaces (return type, name, and parameter types). We then execute these methods to verify which candidate pairs have matching outputs for a given sample of inputs. Some recent studies have also focused on this type of semantic replication, but our detection approach is generally cheaper and more precise, because it focuses on methods and uses interfaces to reduce the search space. Although our scope is restricted to static methods, which makes our results conservative, our findings are promising. In particular, we found 984 pairs of redundant methods, and 28 out of the 68 (41.17%) projects in the repository presented redundancy. Moreover, the majority of redundant methods for which we had access to the source code did not refer to textual clones (only one redundant method pair referred to replicated code). Our study also indicates that the proposed redundancy detection approach has high precision and is generally inexpensive (only four executions were required per method to attain 100% precision).
- 1 April 2013
- Published by Elsevier in Journal of Systems and Software
- Vol. 86 (4) , 905-933
The crosscutting impact of the AOSD Brazilian research community
- 1 April 2013
- Published by Elsevier in Journal of Systems and Software
- Vol. 86 (4) , 905-933
The crosscutting impact of the AOSD Brazilian research community
- 11 December 2012
- Published by Elsevier in Journal of Systems and Software
- Vol. 86 (4) , 951-969
Evaluation studies of software testing research in Brazil and in the world: A survey of two premier software engineering conferences
- 11 December 2012
- Published by Elsevier in Journal of Systems and Software
- Vol. 86 (4) , 951-969
Evaluation studies of software testing research in Brazil and in the world: A survey of two premier software engineering conferences
- 1 June 2012
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- Vol. 51 (02705257) , 529-539
Development of auxiliary functions: Should you be agile? An empirical assessment of pair programming and test-first programming
A considerable part of software systems is comprised of functions that support the main modules, such as array or string manipulation and basic math computation. These auxiliary functions are usually considered less complex, and thus tend to receive less attention from developers. However, failures in these functions might propagate to more critical modules, thereby affecting the system's overall reliability. Given the complementary role of auxiliary functions, a question that arises is whether agile practices, such as pair programming and test-first programming, can improve their correctness without affecting time-to-market. This paper presents an empirical assessment comparing the application of these agile practices with more traditional approaches. Our study comprises independent experiments of pair versus solo programming, and test-first versus test-last programming. The first study involved 85 novice programmers who applied both traditional and agile approaches in the development of six auxiliary functions within three different domains. Our results suggest that the agile practices might bring benefits in this context. In particular, pair programmers delivered correct implementations much more often, and test-first programming encouraged the production of larger and higher coverage test sets. On the downside, the main experiment showed that both practices significantly increase total development time. A replication of the test-first experiment with professional developers shows similar results.
- 1 June 2012
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- Vol. 51 (02705257) , 529-539
Development of auxiliary functions: Should you be agile? An empirical assessment of pair programming and test-first programming
A considerable part of software systems is comprised of functions that support the main modules, such as array or string manipulation and basic math computation. These auxiliary functions are usually considered less complex, and thus tend to receive less attention from developers. However, failures in these functions might propagate to more critical modules, thereby affecting the system's overall reliability. Given the complementary role of auxiliary functions, a question that arises is whether agile practices, such as pair programming and test-first programming, can improve their correctness without affecting time-to-market. This paper presents an empirical assessment comparing the application of these agile practices with more traditional approaches. Our study comprises independent experiments of pair versus solo programming, and test-first versus test-last programming. The first study involved 85 novice programmers who applied both traditional and agile approaches in the development of six auxiliary functions within three different domains. Our results suggest that the agile practices might bring benefits in this context. In particular, pair programmers delivered correct implementations much more often, and test-first programming encouraged the production of larger and higher coverage test sets. On the downside, the main experiment showed that both practices significantly increase total development time. A replication of the test-first experiment with professional developers shows similar results.
- 1 September 2011
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 72-81
The AOSD Research Community in Brazil and Its Crosscutting Impact
In this paper, we present the birth, growth, and maturation of Aspect-Oriented Software Development (AOSD) research over the last years, with emphasis on the Brazilian AOSD community and its research contributions. These research contributions are illustrated from different perspectives: (i) an overview of the research work developed by our community in several prominent software engineering areas; (ii) a historical chronology of the community; and (iii) the growth, impact and quality of research outcomes.
- 1 September 2011
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 72-81
The AOSD Research Community in Brazil and Its Crosscutting Impact
In this paper, we present the birth, growth, and maturation of Aspect-Oriented Software Development (AOSD) research over the last years, with emphasis on the Brazilian AOSD community and its research contributions. These research contributions are illustrated from different perspectives: (i) an overview of the research work developed by our community in several prominent software engineering areas; (ii) a historical chronology of the community; and (iii) the growth, impact and quality of research outcomes.
- 1 September 2011
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 56-65
Evaluation Studies of Software Testing Research in the Brazilian Symposium on Software Engineering
Experimentation is the traditional way of identifying cause-effect relationships in scientific research. Lately, there has been an increasing understanding that experiments and other forms of evaluation should be more thoroughly disseminated among computer science and, in particular, Software Engineering (SE) researchers. Software testing (ST) is an important SE topic, where experiments are particularly valuable: since cost constraints and high effectiveness goals are common within this subfield, cost/benefit characteristics have to be adequately evaluated to deem a specific approach useful or not. This paper reports on a historical perspective of the evaluation studies present in ST research published in the Brazilian Symposium on Software Engineering (SBES). The survey characterizes the software testing-related papers published in the 24-year history of SBES, investigates the types of evaluation presented in these studies - when they were presented at all - and whether the number of evaluations has increased over the years. Additionally, the survey also brings a preliminary characterization of the Brazilian software testing community that adopts SBES as a vehicle to publish its research. Results show that the number of papers that present evaluation studies have significantly increased over the years. However, on the downside, amongst the papers that described some kind of evaluation, only 20% performed more rigorous evaluations (e.g. experiments or case studies in the industrial context), whereas 80% described exploratory, less rigorous case studies.
- 1 September 2011
- Published by Institute of Electrical and Electronics Engineers (IEEE)
- p. 56-65
Evaluation Studies of Software Testing Research in the Brazilian Symposium on Software Engineering
Experimentation is the traditional way of identifying cause-effect relationships in scientific research. Lately, there has been an increasing understanding that experiments and other forms of evaluation should be more thoroughly disseminated among computer science and, in particular, Software Engineering (SE) researchers. Software testing (ST) is an important SE topic, where experiments are particularly valuable: since cost constraints and high effectiveness goals are common within this subfield, cost/benefit characteristics have to be adequately evaluated to deem a specific approach useful or not. This paper reports on a historical perspective of the evaluation studies present in ST research published in the Brazilian Symposium on Software Engineering (SBES). The survey characterizes the software testing-related papers published in the 24-year history of SBES, investigates the types of evaluation presented in these studies - when they were presented at all - and whether the number of evaluations has increased over the years. Additionally, the survey also brings a preliminary characterization of the Brazilian software testing community that adopts SBES as a vehicle to publish its research. Results show that the number of papers that present evaluation studies have significantly increased over the years. However, on the downside, amongst the papers that described some kind of evaluation, only 20% performed more rigorous evaluations (e.g. experiments or case studies in the industrial context), whereas 80% described exploratory, less rigorous case studies.
- 1 July 2011
- Published by Elsevier in Information Sciences
- Vol. 181 (13) , 2721-2746
A pointcut-based coverage analysis approach for aspect-oriented programs
- 1 July 2011
- Published by Elsevier in Information Sciences
- Vol. 181 (13) , 2721-2746
A pointcut-based coverage analysis approach for aspect-oriented programs
- 1 April 2011
- Published by Elsevier in Information and Software Technology
- Vol. 53 (4) , 294-306
A test-driven approach to code search and its application to the reuse of auxiliary functionality
- 1 April 2011
- Published by Elsevier in Information and Software Technology
- Vol. 53 (4) , 294-306
A test-driven approach to code search and its application to the reuse of auxiliary functionality