Skip to main content

Csaba Nagy

Followers

0

Following

1

Public Views

David Moreno Lumbreras

Susanna Ardigò

Roberto Minelli

Universita' della Svizzera Italiana

marjane namavar

Alison Fernandez

Marcus Ciolkowski

TU Kaiserslautern

University of Groningen

Faculdade Farias Brito

Badji Mokhtar - Annaba University

Interests

Uploads

Papers by Csaba Nagy

Visualizing Evolving Software Cities

2020 Working Conference on Software Visualization (VISSOFT), 2020

Visualization approaches that leverage a 3D city metaphor have become popular. Numerous variation... more Visualization approaches that leverage a 3D city metaphor have become popular. Numerous variations, including virtual and augmented reality have emerged. Despite its popularity, the city metaphor falls short when depicting the evolution of a system, which results in buildings and districts moving around in unpredictable ways. We present a novel approach to visualize software systems as evolving cities that treats evolution as a first-class concept. It renders with fidelity not only changes but also refactorings in a comprehensive way. To do so, we developed custom ways to traverse time. We implemented our approach in a publicly accessible web-based platform named m3triCity.

An Empirical Study of Quick Remedy Commits

Proceedings of the 28th International Conference on Program Comprehension, 2020

Software systems are continuously modified to implement new features, to fix bugs, and to improve... more Software systems are continuously modified to implement new features, to fix bugs, and to improve quality attributes. Most of these activities are not atomic changes, but rather the result of several related changes affecting different parts of the code. For this reason, it may happen that developers omit some of the needed changes and, as a consequence, leave a task partially unfinished, introduce technical debt or, in the worst case scenario, inject bugs. Knowing the changes that are mistakenly omitted by developers can help in designing recommender systems able to automatically identify risky situations in which, for example, the developer is likely to be pushing an incomplete change to the software repository. We present a qualitative study investigating "quick remedy commits" performed by developers with the goal of implementing changes omitted in previous commits. With quick remedy commits we refer to commits that (i) quickly follow a commit performed by the same developer in the same repository, and (ii) aim at remedying issues introduced as the result of code changes omitted in the previous commit (e.g., fix references to code components that have been broken as a consequence of a rename refactoring). Through a manual analysis of 500 quick remedy commits, we define a taxonomy categorizing the types of changes that developers tend to omit. The defined taxonomy can guide the development of tools aimed at detecting omitted changes, and possibly autocomplete them.

Visualizing GitHub Issues

The rise of distributed version control systems, such as git, and platforms built on top of it, s... more The rise of distributed version control systems, such as git, and platforms built on top of it, such as GitHub, has triggered a change in how software is developed. Most notably, state-of-the-art practice foresees the use of pull requests and issues, enriched by means to enable discussions among the involved people. Platforms like GitHub and GitLab have thus turned into comprehensive and cohesive modern software development environments, also offering additional mechanisms, such as code review tools and a transversal support for continuous integration and deployment. However, the plethora of concepts, mechanisms, and their interconnections are stored and presented in textual form, which makes the understanding of the underlying evolutionary processes difficult. We introduce the notion of an issue tale, a visual narrative of the events and actors revolving around any GitHub issue, and present an approach, implemented as an interactive visual analytics tool, to depict and analyze the relevant information pertaining to issue tales. We illustrate our approach and its implementation on several open-source software systems.

Visualizing Data in Software Cities

The city metaphor for visualizing software systems in 3D has been widely explored and it has led ... more The city metaphor for visualizing software systems in 3D has been widely explored and it has led to many diverse implementations and approaches. However, when looking at software systems in general, and when using specifically a city approach, it is evident that something is missing: The data. Indeed, software systems are intrinsically driven by data, which is usually managed using databases or often also simply stored in files coming in a variety of formats, such as CSV, XML, and JSON. While such data files are part of a project's file system and can thus be easily retrieved, the situation is different for databases: A database is usually not contained in the file system, and its presence can only be inferred from the source code which contains the database accesses. We present an extension of the CodeCity implementation, M3TRICITY2, with two new contributions: First, we consider data files and use simple metrics to integrate them in the visualization seamlessly. Second, we present a novel way to add a database to the visualization by making use of the one remaining space left unused: the sky and the underground. We present our contributions and illustrate them on various software systems.

On the Impact of Refactoring Operations on Code Naturalness

2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER), 2019

Recent studies have demonstrated that software is natural, that is, its source code is highly rep... more Recent studies have demonstrated that software is natural, that is, its source code is highly repetitive and predictable like human languages. Also, previous studies suggested the existence of a relationship between code quality and its naturalness, presenting empirical evidence showing that buggy code is "less natural" than non-buggy code. We conjecture that this qualitynaturalness relationship could be exploited to support refactoring activities (e.g., to locate source code areas in need of refactoring). We perform a first step in this direction by analyzing whether refactoring can improve the naturalness of code. We use state-of-the-art tools to mine a large dataset of refactoring operations performed in open source systems. Then, we investigate the impact of different types of refactoring operations on the naturalness of the impacted code. We found that (i) code refactoring does not necessarily increase the naturalness of the refactored code; and (ii) the impact on the code naturalness strongly depends on the type of refactoring operations.

Software Documentation Issues Unveiled

2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE), 2019

Software documentation provides developers and users with a description of what a software system... more Software documentation provides developers and users with a description of what a software system does, how it operates, and how it should be used. For example, technical documentation (e.g., an API reference guide) aids developers during evolution/maintenance activities, while a user manual explains how users are to interact with a system. Despite its intrinsic value, the creation and the maintenance of documentation is often neglected, negatively impacting its quality and usefulness, ultimately leading to a generally unfavorable take on documentation. Previous studies investigating documentation issues have been based on surveying developers, which naturally leads to a somewhat biased view of problems affecting documentation. We present a large scale empirical study, where we mined, analyzed, and categorized 878 documentation-related artifacts stemming from four different sources, namely mailing lists, Stack Overflow discussions, issue repositories, and pull requests. The result is a detailed taxonomy of documentation issues from which we infer a series of actionable proposals both for researchers and practitioners.

Beyond polyphagy and opportunism: natural prey of hunting spiders in the canopy of apple trees

PeerJ, 2020

Spiders (Araneae) form abundant and diverse assemblages in agroecosystems such as fruit orchards,... more Spiders (Araneae) form abundant and diverse assemblages in agroecosystems such as fruit orchards, and thus might have an important role as natural enemies of orchard pests. Although spiders are polyphagous and opportunistic predators in general, limited information exists on their natural prey at both species and community levels. Thus, the aim of this study was to assess the natural prey (realized trophic niche) of arboreal hunting spiders, their role in trophic webs and their biological control potential with direct observation of predation events in apple orchards. Hunting spiders with prey in their chelicerae were collected in the canopy of apple trees in organic apple orchards in Hungary during the growing seasons between 2013 and 2019 and both spiders and their prey were identified and measured. Among others, the composition of the actual (captured by spiders) and the potential (available in the canopy) prey was compared, trophic niche and food web metrics were calculated, and...

Designing and Implementing Control Flow Graph for Magic 4th Generation Language

Acta Cybernetica, 2014

A good compiler which implements many optimizations during its compilation phases must be able to... more A good compiler which implements many optimizations during its compilation phases must be able to perform several static analysis techniques such as control flow or data flow analysis. Besides compilers, these techniques are common for static analyzers as well to retrieve information from source code, for example for code auditing, quality assurance or testing purposes. Implementing control flow analysis requires handling many special structures of the target language. In our paper we present our experiences in implementing control flow graph (CFG) construction for a special 4th generation language called Magic. While we were designing and implementing the CFG for this language, we identified differences compared to 3rd generation languages mostly because of the unique programming technique of Magic (e.g. data access, parallel task execution, events). Our work was motivated by our industrial partner who needed precise static analysis tools (e.g. for quality assurance or testing purposes) for this language. We believe that our experiences for Magic, as a representative of 4GLs, might be generalized for other languages too.

Az invazív Lasius neglectus van Loon, Boomsma et Andrásfalvy, 1990 (Hymenoptera: Formicidae) szuperkolóniájának hatása az ízeltlábú közösségre a budatétényi kolónia területén

A Regression Test Selection Technique for Magic Systems

Regression testing is an important step to make sure that after committing a change to our softwa... more Regression testing is an important step to make sure that after committing a change to our software we do not make unwanted changes to other, untouched features. For larger and faster evolving soft- ware, however, executing all the test cases of a regression test and easily become a tremendous process which takes too much time to thoroughly test each change separately. In our paper, we present a method to support regression testing with impact analysis based test selection. As a result, we and show a limited set of test cases that must be re-executed after a change, to test the changed part of the code and its related code elements. Our technique is implemented for a special 4th-generation language, the Magi xpa development environment. The technique was implemented in cooperation with our industrial partner, SZEGED Software In, who has been developing Magi applications for more than a decade.

Can artificial nectaries outcompete aphids in ant-aphid mutualism? Applying artificial sugar sources for ants to support better biological control of rosy apple aphid, Dysaphis plantaginea Passerini in apple orchards

Crop Protection, 2015

The rosy apple aphid, Dysaphis plantaginea Passerini, is a serious pest in apple orchards. It est... more The rosy apple aphid, Dysaphis plantaginea Passerini, is a serious pest in apple orchards. It establishes close facultative mutualistic relationships with ants. An experiment manipulating the presence of the common black ant, Lasius niger (L.), in colonies of D. plantaginea in the canopy of apple trees by provision of ant-feeders (artificial nectaries) containing sucrose solution as an alternative sugar source were conducted in apple orchards in the United Kingdom and Hungary to test if this method can regulate densities of D. plantaginea below the threshold for economic damage through enhancing the activity of its natural enemies. Apple trees with physical ant-exclusion (sticky barriers) and without any treatment were used as controls. Ant-feeding with sucrose solution, in a similar way to physical ant exclusion, effectively reduced the numbers of ants tending D. plantaginea colonies and it consequently resulted in a reduction in D. plantaginea populations in both studies. In spite of marked differences in natural enemy abundance and composition found in UK and Hungary, both treatments caused significant increases in natural enemy (e.g. Dermaptera, Heteroptera, Coccinellidae, Syrphidae) pressure on D. plantaginea. Our results show that supplementary sugar feeding of ants is a successful method for supporting biocontrol of rosy apple aphid through enhancing the effectiveness of its natural enemies. This new biocontrol approach to control aphids in apple orchards is likely to substantially reduce the need for aphicide sprays in orchards and is compatible with organic pest control. The implications of these results for supporting better biological control of aphids in apple orchards are discussed.

A Case Study of Refactoring Large-Scale Industrial Systems to Efficiently Improve Source Code Quality

Computational Science and Its Applications – ICCSA 2014, 2014

A True Story of Refactoring a Large Oracle PL/SQL Banking System

It is common that due to the pressure of business, banking systems evolve and grow fast and even ... more It is common that due to the pressure of business, banking systems evolve and grow fast and even the slightest wrong decision may result in losing control over the codebase in long term. Once it happens, the business will not drive developments any more, but will be constrained by maintenance preoccupations. As easy is to lose control, as hard is to regain it again. Software comprehension and refactoring are the proper means for reestablishing governance over the system, but they require sophisticated tools and methods that help analyzing, understanding and refactoring the codebase. This paper tells a true story about how control has been lost and regained again in case of a real banking system written in PL/SQL programming language.

Static Security Analysis Based on Input-Related Software Faults

2009 13th European Conference on Software Maintenance and Reengineering, 2009

It is important to focus on security aspects during the development cycle to deliver reliable sof... more It is important to focus on security aspects during the development cycle to deliver reliable software. However, locating security faults in complex systems is difficult and there are only a few effective automatic tools available to help developers. In this paper we present an approach to help developers locate vulnerabilities by marking parts of the source code that involve user input. We focus on inputrelated code, since an attacker can usually take advantage of vulnerabilities by passing malformed input to the application. The main contributions of this work are two metrics to help locate faults during a code review, and algorithms to locate buffer overflow and format string vulnerabilities in C source code. We implemented our approach as a plugin to the Grammatech CodeSurfer tool. We tested and validated our technique on open source projects and we found faults in software that includes Pidgin and cyrus-imapd.

Complexity Measures in 4GL Environment

Lecture Notes in Computer Science, 2011

Numerical Simulation of the RMF Stirring of Molten Ga-In Alloy Using RANS K-ε and LES Turbulence Models

Materials Science Forum, 2014

A comparison of the results of RANS k-ε and LES turbulence models was done via the simulation of ... more A comparison of the results of RANS k-ε and LES turbulence models was done via the simulation of the electromagnetic stirring of liquid 75,5%Ga-24,5%In alloy (in a 10 mm diameter & 30 mm high crucible) using Ansys Fluent. Each velocity component, the distribution of eddies inside the melt and other flow parameters were compared respectively. The accuracy was checked with measured angular velocity data of A. Rónaföldi. The turbulent energy spectra were also produced to see the validity of the LES models.

CIASYS--Change Impact Analysis at System Level

2010 14th European Conference on Software Maintenance and Reengineering, 2010

The research field of change impact analysis plays an important role in software engineering theo... more The research field of change impact analysis plays an important role in software engineering theory and practice nowadays. Not only because it has many scientific challenges, but it has many industrial applications too (e. g., cost estimation, test optimization), and the current techniques are still not ready to fulfill the requirements of industry. Typically, the current solutions lack a whole-system view and give either precise results with high computation costs or less precise results with fast algorithms. For these reasons, they are not applicable to large industrial systems where both scalability and precision are very important. In this paper, we present a project whose main goal is to develop an innovative change impact analysis software-suit based on recent scientific results and modern technologies. The suite will use hybrid analysis techniques to benefit from all the advantages of static and dynamic analyses. In addition, it will be able to determine the dependencies at system level of software systems with heterogeneous architecture. The software is being developed by FrontEndART Ltd. while the theoretical and technological background is provided by the Department of Software Engineering at the University of Szeged. The project is funded by the Economic Development Operational Programme, New Hungary Development Plan.

Regional trends and preliminary results on the local expansion rate in the invasive garden ant, Lasius neglectus (Hymenoptera, Formicidae)

Insectes Sociaux, 2007

The expansion process of the invasive garden ant, Lasius neglectus in Europe and Asia is describe... more The expansion process of the invasive garden ant, Lasius neglectus in Europe and Asia is described in terms of: a) local expansion through colony growing measured on four supercolonies (Seva, Debrecen, Buda Castle and BudatØtØny) from two distant and climatically different countries (Spain, Hungary), and b) regional expansion, using data from all published and several new non-native localities. Short, local distance processes (few meters to 89 m year-1), as colony budding, are two to five orders of magnitude smaller than long regional distances (ten km to >1000 km). This suggests direct human intervention in the invasive spread. The regional trend also shows that the invasive garden ant has been quickly and steadily increasing the number of non native localities (77) and countries (14) it has reached during the last 30 years.

Extension of GCC with a fully manageable reverse engineering front end

In the open source community one of the most popular compilers is GNU GCC. It is a very complex a... more In the open source community one of the most popular compilers is GNU GCC. It is a very complex and robust compiler, but because of its working mechanism it has no ability for special transformations like interprocedural optimizations. A typical compiler has a three sided construction. It has a front end for analyzes and for building an abstract internal representation of the program, a middle for transformations (e.g. optimizations), and a back end for final code generation. However there are smaller but very useful projects for only front/middle/back ends too, it seems possible to achieve a more effective compiler by extending GCC with a front end which is capable of running special algorithms. This paper shows one solution for this extension. The described method is based on using Columbus/CAN instead of GCC's front end, and because Columbus has a well-structured schema for representing C++ sources, by this extension the compiler will have the ability to execute those special transformations on the code before the compiling phases. Furthermore this technique opens the possibility to connect other front ends-like Edison Design Group's C++ front end-to GCC and achieve a more powerful compiler, for example in code size optimizations. This approach has been tested on small C projects like bzip2 as a realworld system, and on parts of the official Code-Size Benchmark Environment (CSiBE) of GCC.

Code Factoring in GCC on Different Intermediate Languages

Today as handheld devices (smart phones, PDAs, etc.) are becoming increasingly popular, storage c... more Today as handheld devices (smart phones, PDAs, etc.) are becoming increasingly popular, storage capacity becomes more and more important. One way to increase capacity is to optimize static executables on the device. This resulted that code-size optimization gets bigger attention nowadays and new techniques are observed, like code factoring which is still under research. Although GNU GCC is the most common compiler in the open source community and has many implemented algorithms for code-size optimization, the compiler is still weak in these methods, which can be turned on using the '-Os' flag. In this article we would like to give an overview on implementation of different code factoring algorithms (local factoring, sequence abstraction, interprocedural abstraction) on the IPA, Tree, Tree SSA and RTL passes of GCC. The correctness of the implementation was checked, and the results were measured on different architectures with GCC's official Code-Size Benchmark Environment (CSiBE) as a real-world system. These results showed that on the ARM architecture we could achieve 61.53% maximum and 2.58% average extra code-size saving compared to the '-Os' flag of GCC.

Visualizing Evolving Software Cities

2020 Working Conference on Software Visualization (VISSOFT), 2020

Visualization approaches that leverage a 3D city metaphor have become popular. Numerous variation... more Visualization approaches that leverage a 3D city metaphor have become popular. Numerous variations, including virtual and augmented reality have emerged. Despite its popularity, the city metaphor falls short when depicting the evolution of a system, which results in buildings and districts moving around in unpredictable ways. We present a novel approach to visualize software systems as evolving cities that treats evolution as a first-class concept. It renders with fidelity not only changes but also refactorings in a comprehensive way. To do so, we developed custom ways to traverse time. We implemented our approach in a publicly accessible web-based platform named m3triCity.

An Empirical Study of Quick Remedy Commits

Proceedings of the 28th International Conference on Program Comprehension, 2020

Software systems are continuously modified to implement new features, to fix bugs, and to improve... more Software systems are continuously modified to implement new features, to fix bugs, and to improve quality attributes. Most of these activities are not atomic changes, but rather the result of several related changes affecting different parts of the code. For this reason, it may happen that developers omit some of the needed changes and, as a consequence, leave a task partially unfinished, introduce technical debt or, in the worst case scenario, inject bugs. Knowing the changes that are mistakenly omitted by developers can help in designing recommender systems able to automatically identify risky situations in which, for example, the developer is likely to be pushing an incomplete change to the software repository. We present a qualitative study investigating "quick remedy commits" performed by developers with the goal of implementing changes omitted in previous commits. With quick remedy commits we refer to commits that (i) quickly follow a commit performed by the same developer in the same repository, and (ii) aim at remedying issues introduced as the result of code changes omitted in the previous commit (e.g., fix references to code components that have been broken as a consequence of a rename refactoring). Through a manual analysis of 500 quick remedy commits, we define a taxonomy categorizing the types of changes that developers tend to omit. The defined taxonomy can guide the development of tools aimed at detecting omitted changes, and possibly autocomplete them.

Visualizing GitHub Issues

The rise of distributed version control systems, such as git, and platforms built on top of it, s... more The rise of distributed version control systems, such as git, and platforms built on top of it, such as GitHub, has triggered a change in how software is developed. Most notably, state-of-the-art practice foresees the use of pull requests and issues, enriched by means to enable discussions among the involved people. Platforms like GitHub and GitLab have thus turned into comprehensive and cohesive modern software development environments, also offering additional mechanisms, such as code review tools and a transversal support for continuous integration and deployment. However, the plethora of concepts, mechanisms, and their interconnections are stored and presented in textual form, which makes the understanding of the underlying evolutionary processes difficult. We introduce the notion of an issue tale, a visual narrative of the events and actors revolving around any GitHub issue, and present an approach, implemented as an interactive visual analytics tool, to depict and analyze the relevant information pertaining to issue tales. We illustrate our approach and its implementation on several open-source software systems.

Visualizing Data in Software Cities

The city metaphor for visualizing software systems in 3D has been widely explored and it has led ... more The city metaphor for visualizing software systems in 3D has been widely explored and it has led to many diverse implementations and approaches. However, when looking at software systems in general, and when using specifically a city approach, it is evident that something is missing: The data. Indeed, software systems are intrinsically driven by data, which is usually managed using databases or often also simply stored in files coming in a variety of formats, such as CSV, XML, and JSON. While such data files are part of a project's file system and can thus be easily retrieved, the situation is different for databases: A database is usually not contained in the file system, and its presence can only be inferred from the source code which contains the database accesses. We present an extension of the CodeCity implementation, M3TRICITY2, with two new contributions: First, we consider data files and use simple metrics to integrate them in the visualization seamlessly. Second, we present a novel way to add a database to the visualization by making use of the one remaining space left unused: the sky and the underground. We present our contributions and illustrate them on various software systems.

On the Impact of Refactoring Operations on Code Naturalness

2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER), 2019

Recent studies have demonstrated that software is natural, that is, its source code is highly rep... more Recent studies have demonstrated that software is natural, that is, its source code is highly repetitive and predictable like human languages. Also, previous studies suggested the existence of a relationship between code quality and its naturalness, presenting empirical evidence showing that buggy code is "less natural" than non-buggy code. We conjecture that this qualitynaturalness relationship could be exploited to support refactoring activities (e.g., to locate source code areas in need of refactoring). We perform a first step in this direction by analyzing whether refactoring can improve the naturalness of code. We use state-of-the-art tools to mine a large dataset of refactoring operations performed in open source systems. Then, we investigate the impact of different types of refactoring operations on the naturalness of the impacted code. We found that (i) code refactoring does not necessarily increase the naturalness of the refactored code; and (ii) the impact on the code naturalness strongly depends on the type of refactoring operations.

Software Documentation Issues Unveiled

2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE), 2019

Software documentation provides developers and users with a description of what a software system... more Software documentation provides developers and users with a description of what a software system does, how it operates, and how it should be used. For example, technical documentation (e.g., an API reference guide) aids developers during evolution/maintenance activities, while a user manual explains how users are to interact with a system. Despite its intrinsic value, the creation and the maintenance of documentation is often neglected, negatively impacting its quality and usefulness, ultimately leading to a generally unfavorable take on documentation. Previous studies investigating documentation issues have been based on surveying developers, which naturally leads to a somewhat biased view of problems affecting documentation. We present a large scale empirical study, where we mined, analyzed, and categorized 878 documentation-related artifacts stemming from four different sources, namely mailing lists, Stack Overflow discussions, issue repositories, and pull requests. The result is a detailed taxonomy of documentation issues from which we infer a series of actionable proposals both for researchers and practitioners.

Beyond polyphagy and opportunism: natural prey of hunting spiders in the canopy of apple trees

PeerJ, 2020

Spiders (Araneae) form abundant and diverse assemblages in agroecosystems such as fruit orchards,... more Spiders (Araneae) form abundant and diverse assemblages in agroecosystems such as fruit orchards, and thus might have an important role as natural enemies of orchard pests. Although spiders are polyphagous and opportunistic predators in general, limited information exists on their natural prey at both species and community levels. Thus, the aim of this study was to assess the natural prey (realized trophic niche) of arboreal hunting spiders, their role in trophic webs and their biological control potential with direct observation of predation events in apple orchards. Hunting spiders with prey in their chelicerae were collected in the canopy of apple trees in organic apple orchards in Hungary during the growing seasons between 2013 and 2019 and both spiders and their prey were identified and measured. Among others, the composition of the actual (captured by spiders) and the potential (available in the canopy) prey was compared, trophic niche and food web metrics were calculated, and...

Designing and Implementing Control Flow Graph for Magic 4th Generation Language

Acta Cybernetica, 2014

A good compiler which implements many optimizations during its compilation phases must be able to... more A good compiler which implements many optimizations during its compilation phases must be able to perform several static analysis techniques such as control flow or data flow analysis. Besides compilers, these techniques are common for static analyzers as well to retrieve information from source code, for example for code auditing, quality assurance or testing purposes. Implementing control flow analysis requires handling many special structures of the target language. In our paper we present our experiences in implementing control flow graph (CFG) construction for a special 4th generation language called Magic. While we were designing and implementing the CFG for this language, we identified differences compared to 3rd generation languages mostly because of the unique programming technique of Magic (e.g. data access, parallel task execution, events). Our work was motivated by our industrial partner who needed precise static analysis tools (e.g. for quality assurance or testing purposes) for this language. We believe that our experiences for Magic, as a representative of 4GLs, might be generalized for other languages too.

Az invazív Lasius neglectus van Loon, Boomsma et Andrásfalvy, 1990 (Hymenoptera: Formicidae) szuperkolóniájának hatása az ízeltlábú közösségre a budatétényi kolónia területén

A Regression Test Selection Technique for Magic Systems

Regression testing is an important step to make sure that after committing a change to our softwa... more Regression testing is an important step to make sure that after committing a change to our software we do not make unwanted changes to other, untouched features. For larger and faster evolving soft- ware, however, executing all the test cases of a regression test and easily become a tremendous process which takes too much time to thoroughly test each change separately. In our paper, we present a method to support regression testing with impact analysis based test selection. As a result, we and show a limited set of test cases that must be re-executed after a change, to test the changed part of the code and its related code elements. Our technique is implemented for a special 4th-generation language, the Magi xpa development environment. The technique was implemented in cooperation with our industrial partner, SZEGED Software In, who has been developing Magi applications for more than a decade.

Can artificial nectaries outcompete aphids in ant-aphid mutualism? Applying artificial sugar sources for ants to support better biological control of rosy apple aphid, Dysaphis plantaginea Passerini in apple orchards

Crop Protection, 2015

The rosy apple aphid, Dysaphis plantaginea Passerini, is a serious pest in apple orchards. It est... more The rosy apple aphid, Dysaphis plantaginea Passerini, is a serious pest in apple orchards. It establishes close facultative mutualistic relationships with ants. An experiment manipulating the presence of the common black ant, Lasius niger (L.), in colonies of D. plantaginea in the canopy of apple trees by provision of ant-feeders (artificial nectaries) containing sucrose solution as an alternative sugar source were conducted in apple orchards in the United Kingdom and Hungary to test if this method can regulate densities of D. plantaginea below the threshold for economic damage through enhancing the activity of its natural enemies. Apple trees with physical ant-exclusion (sticky barriers) and without any treatment were used as controls. Ant-feeding with sucrose solution, in a similar way to physical ant exclusion, effectively reduced the numbers of ants tending D. plantaginea colonies and it consequently resulted in a reduction in D. plantaginea populations in both studies. In spite of marked differences in natural enemy abundance and composition found in UK and Hungary, both treatments caused significant increases in natural enemy (e.g. Dermaptera, Heteroptera, Coccinellidae, Syrphidae) pressure on D. plantaginea. Our results show that supplementary sugar feeding of ants is a successful method for supporting biocontrol of rosy apple aphid through enhancing the effectiveness of its natural enemies. This new biocontrol approach to control aphids in apple orchards is likely to substantially reduce the need for aphicide sprays in orchards and is compatible with organic pest control. The implications of these results for supporting better biological control of aphids in apple orchards are discussed.

A Case Study of Refactoring Large-Scale Industrial Systems to Efficiently Improve Source Code Quality

Computational Science and Its Applications – ICCSA 2014, 2014

A True Story of Refactoring a Large Oracle PL/SQL Banking System

It is common that due to the pressure of business, banking systems evolve and grow fast and even ... more It is common that due to the pressure of business, banking systems evolve and grow fast and even the slightest wrong decision may result in losing control over the codebase in long term. Once it happens, the business will not drive developments any more, but will be constrained by maintenance preoccupations. As easy is to lose control, as hard is to regain it again. Software comprehension and refactoring are the proper means for reestablishing governance over the system, but they require sophisticated tools and methods that help analyzing, understanding and refactoring the codebase. This paper tells a true story about how control has been lost and regained again in case of a real banking system written in PL/SQL programming language.

Static Security Analysis Based on Input-Related Software Faults

2009 13th European Conference on Software Maintenance and Reengineering, 2009

It is important to focus on security aspects during the development cycle to deliver reliable sof... more It is important to focus on security aspects during the development cycle to deliver reliable software. However, locating security faults in complex systems is difficult and there are only a few effective automatic tools available to help developers. In this paper we present an approach to help developers locate vulnerabilities by marking parts of the source code that involve user input. We focus on inputrelated code, since an attacker can usually take advantage of vulnerabilities by passing malformed input to the application. The main contributions of this work are two metrics to help locate faults during a code review, and algorithms to locate buffer overflow and format string vulnerabilities in C source code. We implemented our approach as a plugin to the Grammatech CodeSurfer tool. We tested and validated our technique on open source projects and we found faults in software that includes Pidgin and cyrus-imapd.

Complexity Measures in 4GL Environment

Lecture Notes in Computer Science, 2011

Numerical Simulation of the RMF Stirring of Molten Ga-In Alloy Using RANS K-ε and LES Turbulence Models

Materials Science Forum, 2014

A comparison of the results of RANS k-ε and LES turbulence models was done via the simulation of ... more A comparison of the results of RANS k-ε and LES turbulence models was done via the simulation of the electromagnetic stirring of liquid 75,5%Ga-24,5%In alloy (in a 10 mm diameter & 30 mm high crucible) using Ansys Fluent. Each velocity component, the distribution of eddies inside the melt and other flow parameters were compared respectively. The accuracy was checked with measured angular velocity data of A. Rónaföldi. The turbulent energy spectra were also produced to see the validity of the LES models.

CIASYS--Change Impact Analysis at System Level

2010 14th European Conference on Software Maintenance and Reengineering, 2010

The research field of change impact analysis plays an important role in software engineering theo... more The research field of change impact analysis plays an important role in software engineering theory and practice nowadays. Not only because it has many scientific challenges, but it has many industrial applications too (e. g., cost estimation, test optimization), and the current techniques are still not ready to fulfill the requirements of industry. Typically, the current solutions lack a whole-system view and give either precise results with high computation costs or less precise results with fast algorithms. For these reasons, they are not applicable to large industrial systems where both scalability and precision are very important. In this paper, we present a project whose main goal is to develop an innovative change impact analysis software-suit based on recent scientific results and modern technologies. The suite will use hybrid analysis techniques to benefit from all the advantages of static and dynamic analyses. In addition, it will be able to determine the dependencies at system level of software systems with heterogeneous architecture. The software is being developed by FrontEndART Ltd. while the theoretical and technological background is provided by the Department of Software Engineering at the University of Szeged. The project is funded by the Economic Development Operational Programme, New Hungary Development Plan.

Regional trends and preliminary results on the local expansion rate in the invasive garden ant, Lasius neglectus (Hymenoptera, Formicidae)

Insectes Sociaux, 2007

The expansion process of the invasive garden ant, Lasius neglectus in Europe and Asia is describe... more The expansion process of the invasive garden ant, Lasius neglectus in Europe and Asia is described in terms of: a) local expansion through colony growing measured on four supercolonies (Seva, Debrecen, Buda Castle and BudatØtØny) from two distant and climatically different countries (Spain, Hungary), and b) regional expansion, using data from all published and several new non-native localities. Short, local distance processes (few meters to 89 m year-1), as colony budding, are two to five orders of magnitude smaller than long regional distances (ten km to >1000 km). This suggests direct human intervention in the invasive spread. The regional trend also shows that the invasive garden ant has been quickly and steadily increasing the number of non native localities (77) and countries (14) it has reached during the last 30 years.

Extension of GCC with a fully manageable reverse engineering front end

In the open source community one of the most popular compilers is GNU GCC. It is a very complex a... more In the open source community one of the most popular compilers is GNU GCC. It is a very complex and robust compiler, but because of its working mechanism it has no ability for special transformations like interprocedural optimizations. A typical compiler has a three sided construction. It has a front end for analyzes and for building an abstract internal representation of the program, a middle for transformations (e.g. optimizations), and a back end for final code generation. However there are smaller but very useful projects for only front/middle/back ends too, it seems possible to achieve a more effective compiler by extending GCC with a front end which is capable of running special algorithms. This paper shows one solution for this extension. The described method is based on using Columbus/CAN instead of GCC's front end, and because Columbus has a well-structured schema for representing C++ sources, by this extension the compiler will have the ability to execute those special transformations on the code before the compiling phases. Furthermore this technique opens the possibility to connect other front ends-like Edison Design Group's C++ front end-to GCC and achieve a more powerful compiler, for example in code size optimizations. This approach has been tested on small C projects like bzip2 as a realworld system, and on parts of the official Code-Size Benchmark Environment (CSiBE) of GCC.

Code Factoring in GCC on Different Intermediate Languages

Today as handheld devices (smart phones, PDAs, etc.) are becoming increasingly popular, storage c... more Today as handheld devices (smart phones, PDAs, etc.) are becoming increasingly popular, storage capacity becomes more and more important. One way to increase capacity is to optimize static executables on the device. This resulted that code-size optimization gets bigger attention nowadays and new techniques are observed, like code factoring which is still under research. Although GNU GCC is the most common compiler in the open source community and has many implemented algorithms for code-size optimization, the compiler is still weak in these methods, which can be turned on using the '-Os' flag. In this article we would like to give an overview on implementation of different code factoring algorithms (local factoring, sequence abstraction, interprocedural abstraction) on the IPA, Tree, Tree SSA and RTL passes of GCC. The correctness of the implementation was checked, and the results were measured on different architectures with GCC's official Code-Size Benchmark Environment (CSiBE) as a real-world system. These results showed that on the ARM architecture we could achieve 61.53% maximum and 2.58% average extra code-size saving compared to the '-Os' flag of GCC.