Research

Profiles

Activities

Program Committee Member of the 16th BElgian-NEtherlands software eVOLution symposium (BENEVOL 2017), Antwerp, Belgium, December 4-5, 2017
Program Committee Member of the 33rd IEEE International Conference on Software Maintenance and Evolution (ICSME 2017) Industry Track, Shanghai, China, September 17-24, 2017
Program Committee Member of the 17th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2017) Engineering Track, Shanghai, China, September 17-18, 2017
Program Committee Member of the 25th IEEE International Conference on Program Comprehension (ICPC 2017) Tool Demo Track, Buenos Aires, Argentina, May 22-23, 2017
Program Committee Member of the 16th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2016) Engineering Track, Raleigh, North Carolina, USA, October 2-3, 2016
Program Committee Member of the 32nd IEEE International Conference on Software Maintenance and Evolution (ICSME 2016) Industry Track, Raleigh, North Carolina, USA, October 2-10, 2016
Program Committee Member of the 15th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2015) Tool Demo Track, Bremen, Germany, September 27-28, 2015
Program Committee Member of the 8th Seminar Series on Advanced Techniques & Tools for Software Evolution (SATToSE 2015), Mons, Belgium, July 6-8, 2015
Web & Publication co-Chair of the 16th European Conference on Software Maintenance and Reengineering (CSMR 2012), Szeged, Hungary, March 27-30, 2012
Social Chair of the 8th joint meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE 2011), Szeged, Hungary, September 5-9, 2011

Publications

Book Chapters

Loup Meurice, Mathieu Goeminne, Tom Mens, Csaba Nagy, Alexandre Decan and Anthony Cleve (2017). "Analyzing the Evolution of Database Usage in Data-Intensive Software Systems", In Software Technology: 10 Years of Innovation. John Wiley & Sons. [Abstract] [BibTex]
Abstract:

This chapter presents the research advancements in the field of data-intensive software system evolution, 5 years after the publication of our IEEE Computer column presenting the challenges in this field. We present the state-of-the-art in this research domain, and report on research on the evolution of open source Java projects relying on relational database technologies. We empirically analyse how the use of Java database technologies evolves over time. We report on a coarse-grained source-code analysis carried out over several thousands of Java projects, and complement this by a fine-grained longitudinal analysis of the co-evolution between database schema changes and source code changes within three large Java projects. The presented results are a first step towards a recommendation system supporting developers in writing database-centered code.
BibTex:
```
@inbook{Meurice2017,
  author = {Meurice, Loup and Goeminne, Mathieu and Mens, Tom and Nagy, Csaba and Decan, Alexandre and Cleve, Anthony},
  editor = {Hinchey, Mike},
  title = {Software Technology: 10 Years of Innovation},
  chapter = {Analyzing the Evolution of Database Usage in Data-Intensive Software Systems},
  publisher = {John Wiley & Sons},
  year = {2017}
}
```

Journal Articles

Gábor Szőke, Gábor Antal, Csaba Nagy, Rudolf Ferenc and Tibor Gyimóthy (2016). "Empirical study on refactoring large-scale industrial systems and its effects on maintainability ", Journal of Systems and Software. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

Abstract Software evolves continuously, it gets modified, enhanced, and new requirements always arise. If we do not spend time occasionally on improving our source code, its maintainability will inevitably decrease. The literature tells us that we can improve the maintainability of a software system by regularly refactoring it. But does refactoring really increase software maintainability? Can it happen that refactoring decreases the maintainability? Empirical studies show contradicting answers to these questions and there have been only a few studies which were performed in a large-scale, industrial context. In our paper, we assess these questions in an in vivo context, where we analyzed the source code and measured the maintainability of 6 large-scale, proprietary software systems in their manual refactoring phase. We analyzed 2.5 million lines of code and studied the effects on maintainability of 315 refactoring commits which fixed 1273 coding issues. We found that single refactorings only make a very little difference (sometimes even decrease maintainability), but a whole refactoring period, in general, can significantly increase maintainability, which can result not only in the local, but also in the global improvement of the code.
BibTex:
```
@article{Szoeke2016a,
  author = {Szőke, Gábor and Antal, Gábor and Nagy, Csaba and Ferenc, Rudolf and Gyimóthy, Tibor},
  title = {Empirical study on refactoring large-scale industrial systems and its effects on maintainability },
  journal = {Journal of Systems and Software},
  year = {2016},
  doi = {http://dx.doi.org/10.1016/j.jss.2016.08.071}
}
```
Richárd Dévai, Judit Jász, Csaba Nagy and Rudolf Ferenc (2014). "Designing and Implementing Control Flow Graph for Magic 4th Generation Language", Acta Cybernetica. Vol. 213, pp. 419-437. [Abstract] [BibTex] [PDF]
Abstract:

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.
BibTex:
```
@article{Devai2014,
  author = {Dévai, Richárd and Jász, Judit and Nagy, Csaba and Ferenc, Rudolf},
  title = {Designing and Implementing Control Flow Graph for Magic 4th Generation Language},
  journal = {Acta Cybernetica},
  year = {2014},
  volume = {21},
  number = {3},
  pages = {419-437}
}
```
Csaba Nagy, Gábor Lóki, Árpád Beszédes and Tibor Gyimóthy (2009). "Code factoring in GCC on different intermediate languages", ANNALES UNIVERSITATIS SCIENTIARUM BUDAPESTINENSIS DE ROLANDO EOTVOS NOMINATAE Sectio Computatorica - TOMUS XXX., pp. 79-96. [Abstract] [BibTex] [PDF]
Abstract:

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.
BibTex:
```
@article{Nagy2009a,
  author = {Nagy, Csaba and Lóki, Gábor and Beszédes, Árpád and Gyimóthy, Tibor},
  title = {Code factoring in GCC on different intermediate languages},
  journal = {ANNALES UNIVERSITATIS SCIENTIARUM BUDAPESTINENSIS DE ROLANDO EOTVOS NOMINATAE Sectio Computatorica - TOMUS XXX},
  year = {2009},
  pages = {79-96}
}
```

Conference Papers

Csaba Nagy and Anthony Cleve (2017). "Static Code Smell Detection in SQL Queries Embedded in Java Code", In Proceedings of the 17th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2017). IEEE Computer Society. [Abstract] [BibTex] [PDF]
Abstract:

A database plays a central role in the architecture of an information system, and the way it stores the data delimits its main features. However, it is not just the data that matters. The way it is handled, i.e., how the application communicates with the database is of critical importance too. Therefore the implementation of such a communication layer has to be reliable and efficient. SQL is a popular language to query a database, and modern technologies rely on it (or its dialects) as query strings embedded in the application code. In many languages (e.g. in Java), an embedded query is typically constructed through several string operations that obstruct developers in understanding the statement finally sent to the database. It is a potential source of fault-prone and inefficient database usage, i.e., code smells. In our paper, we present a tool for the identification of code smells in SQL queries embedded in Java code. Our tool implements a combined static analysis of the SQL statements embedded in the source code, the database schema, and the data in the database. We use a lightweight query extraction algorithm to extract SQL code from the Java code and implement smell detectors on the ASG of our fault-tolerant SQL parser. Depending on the context of the smell, its severity is also determined. Developers can examine the identified issues with the help of an Eclipse plug-in or through command line interfaces.
BibTex:
```
@inproceedings{Nagy2017,
  author = {Nagy, Csaba and Cleve, Anthony},
  title = {Static Code Smell Detection in SQL Queries Embedded in Java Code},
  booktitle = {Proceedings of the 17th IEEE International Working Conference on Source Code Analysis and Manipulation (SCAM 2017)},
  publisher = {IEEE Computer Society},
  year = {2017}
}
```
Gábor Szőke, Csaba Nagy, Rudolf Ferenc and Tibor Gyimóthy (2016). "Designing and Developing Automated Refactoring Transformations: An Experience Report", In Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2016). Osaka, Japan, mar, 2016. IEEE Computer Society. [Abstract] [BibTex] [PDF]
Abstract:

There are several challenges which should be kept in mind during the design and development phases of a refactoring tool, and one is that developers have several expectations that are quite hard to satisfy. In this report, we present our experiences of a two-year project where we attempted to create an automatic refactoring tool. In this project, we worked with five software development companies that wanted to improve the maintainability of their products. The project was designed to take into account the expectations of the developers of these companies and consisted of three main stages: a manual refactoring phase, a tool building phase, and an automatic refactoring phase. Throughout these stages we collected the opinions of the developers and faced several challenges on how to automate refactoring transformations, which we present and summarize.
BibTex:
```
@inproceedings{Szoeke2016,
  author = {Szőke, Gábor and Nagy, Csaba and Ferenc, Rudolf and Gyimóthy, Tibor},
  title = {Designing and Developing Automated Refactoring Transformations: An Experience Report},
  booktitle = {Proceedings of the 23rd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2016)},
  publisher = {IEEE Computer Society},
  year = {2016}
}
```
Loup Meurice, Csaba Nagy and Anthony Cleve (2016). "Detecting and Preventing Program Inconsistencies Under Database Schema Evolution", In Proceedings of the 2016 IEEE International Conference on Software Quality, Reliability & Security (QRS 2016). Vienna, Austria, aug, 2016. IEEE Computer Society. [Abstract] [BibTex] [Best Paper Award]
Abstract:

Nowadays, data-intensive applications tend to access their underlying database in an increasingly dynamic way. The queries that they send to the database server are usually built at runtime, through String concatenation, or Object-Relational-Mapping (ORM) frameworks. This level of dynamicity significantly complicates the task of adapting application programs to database schema changes. Failing to correctly adapt programs to an evolving database schema results in program inconsistencies, which in turn may cause program failures. In this paper, we present a tool-supported approach, that allows developers to (1) analyze how the source code and database schema co-evolved in the past and (2) simulate a database schema change and automatically determine the set of source code locations that would be impacted by this change. The developers are then provided with recommendations about what they should modify at those source code locations in order to avoid inconsistencies. The approach has been designed to deal with Java systems that use dynamic data access frameworks such as JDBC, Hibernate and JPA. We motivate and evaluate the proposed approach, based on three real-life systems of different size and nature.
BibTex:
```
@inproceedings{Meurice2016a,
  author = {Meurice, Loup and Nagy, Csaba and Cleve, Anthony},
  title = {Detecting and Preventing Program Inconsistencies Under Database Schema Evolution},
  booktitle = {Proceedings of the 2016 IEEE International Conference on Software Quality, Reliability & Security (QRS 2016)},
  publisher = {IEEE Computer Society},
  year = {2016}
}
```
Loup Meurice, Csaba Nagy and Anthony Cleve (2016). "Static Analysis of Dynamic Database Usage in Java Systems", In Proceedings of the 28th International Conference on Advanced Information Systems Engineering (CAiSE 2016). Ljubljana, Slovenia, jun, 2016. Springer LNCS. [Abstract] [BibTex] [PDF]
Abstract:

Understanding the links between application programs and their database is useful in various contexts such as migrating information systems towards a new database platform, evolving the database schema, or assessing the overall system quality. In the case of Java systems, identifying which portion of the source code accesses which portion of the database may prove challenging. Indeed, Java programs typically access their database in a dynamic way. The queries they send to the database server are built at runtime, through String concatenations, or Object-Relational Mapping frameworks like Hibernate and JPA. This paper presents a static analysis approach to program-database links recovery, speciﬁcally designed for Java systems. The approach allows developers to automatically identify the source code locations accessing given database tables and columns. It focuses on the combined analysis of JDBC, Hibernate and JPA invocations. We report on the use of our approach to analyse three real-life Java systems.
BibTex:
```
@inproceedings{Meurice2016,
  author = {Meurice, Loup and Nagy, Csaba and Cleve, Anthony},
  title = {Static Analysis of Dynamic Database Usage in Java Systems},
  booktitle = {Proceedings of the 28th International Conference on Advanced Information Systems Engineering (CAiSE 2016)},
  publisher = {Springer LNCS},
  year = {2016}
}
```
Gábor Szőke, Csaba Nagy, Péter Hegedűs, Rudolf Ferenc and Tibor Gyimóthy (2015). "Do Automatic Refactorings Improve Maintainability? An Industrial Case Study", In Proceedings of the 31st International Conference on Software Maintenance and Evolution (ICSME 2015). Bremen, Germany, sep, 2015., pp. 429-438. IEEE. [Abstract] [BibTex] [PDF]
Abstract:

Refactoring is often treated as the main remedy against the unavoidable code erosion happening during software evolution. Studies show that refactoring is indeed an elemental part of the developers' arsenal. However, empirical studies about the impact of refactorings on software maintainability still did not reach a consensus. Moreover, most of these empirical investigations are carried out on open-source projects where distinguishing refactoring operations from other development activities is a challenge in itself. We had a chance to work together with several software development companies in a project where they got extra budget to improve their source code by performing refactoring operations. Taking advantage of this controlled environment, we collected a large amount of data during a refactoring phase where the developers used a (semi)automatic refactoring tool. By measuring the maintainability of the involved subject systems before and after the refactorings, we got valuable insights into the effect of these refactorings on large-scale industrial projects. All but one company, who applied a special refactoring strategy, achieved a maintainability improvement at the end of the refactoring phase, but even that one company suffered from the negative impact of only one type of refactoring.
BibTex:
```
@inproceedings{Szoeke2015a,
  author = {Szőke, Gábor and Nagy, Csaba and Hegedűs, Péter and Ferenc, Rudolf and Gyimóthy, Tibor},
  title = {Do Automatic Refactorings Improve Maintainability? An Industrial Case Study},
  booktitle = {Proceedings of the 31st International Conference on Software Maintenance and Evolution (ICSME 2015)},
  publisher = {IEEE},
  year = {2015},
  pages = {429-438}
}
```
Gábor Szőke, Csaba Nagy, Lajos Jenő Fülöp, Rudolf Ferenc and Tibor Gyimóthy (2015). "FaultBuster: An Automatic Code Smell Refactoring Toolset", In Proceedings of the 15th International Working Conference on Source Code Analysis and Manipulation (SCAM 2015). Bremen, Germany, sep, 2015., pp. 253-258. IEEE. [Abstract] [BibTex] [PDF]
Abstract:

One solution to prevent the quality erosion of a software product is to maintain its quality by continuous refactoring. However, refactoring is not always easy. Developers need to identify the piece of code that should be improved and decide how to rewrite it. Furthermore, refactoring can also be risky; that is, the modified code needs to be re-tested, so developers can see if they broke something. Many IDEs offer a range of refactorings to support so-called automatic refactoring, but tools which are really able to automatically refactor code smells are still under research. In this paper we introduce FaultBuster, a refactoring toolset which is able to support automatic refactoring: identifying the problematic code parts via static code analysis, running automatic algorithms to fix selected code smells, and executing integrated testing tools. In the heart of the toolset lies a refactoring framework to control the analysis and the execution of automatic algorithms. FaultBuster provides IDE plugins to interact with developers via popular IDEs (Eclipse, Netbeans and IntelliJ IDEA). All the tools were developed and tested in a 2-year project with 6 software development companies where thousands of code smells were identified and fixed in 5 systems having altogether over 5 million lines of code.
BibTex:
```
@inproceedings{Szoeke2015,
  author = {Szőke, Gábor and Nagy, Csaba and Fülöp, Lajos Jenő and Ferenc, Rudolf and Gyimóthy, Tibor},
  title = {FaultBuster: An Automatic Code Smell Refactoring Toolset},
  booktitle = {Proceedings of the 15th International Working Conference on Source Code Analysis and Manipulation (SCAM 2015)},
  publisher = {IEEE},
  year = {2015},
  pages = {253-258}
}
```
Csaba Nagy and Anthony Cleve (2015). "Mining Stack Overflow for Discovering Error Patterns in SQL Queries", In Proceedings of the 31st International Conference on Software Maintenance and Evolution (ICSME 2015)., pp. 516-520. IEEE. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

Constructing complex queries in SQL sometimes necessitates the use of language constructs and the invocation of internal functions which inexperienced developers find hard to comprehend or which are unknown to them. In the worst case, bad usage of these constructs might lead to errors, to ineffective queries, or hamper developers in their tasks. This paper presents a mining technique for Stack Overflow to identify error-prone patterns in SQL queries. Identifying such patterns can help developers to avoid the use of error-prone constructs, or if they have to use such constructs, the Stack Overflow posts can help them to properly utilize the language. Hence, our purpose is to provide the initial steps towards a recommendation system that supports developers in constructing SQL queries. Our current implementation supports the MySQL dialect, and Stack Overflow has over 300,000 questions tagged with the MySQL flag in its database. It provides a huge knowledge base where developers can ask questions about real problems. Our initial results indicate that our technique is indeed able to identify patterns among them.
BibTex:
```
@inproceedings{Nagy2015a,
  author = {Nagy, Csaba and Cleve, Anthony},
  title = {Mining Stack Overflow for Discovering Error Patterns in SQL Queries},
  booktitle = {Proceedings of the 31st International Conference on Software Maintenance and Evolution (ICSME 2015)},
  publisher = {IEEE},
  year = {2015},
  pages = {516-520},
  doi = {10.1109/ICSM.2015.7332505}
}
```
Csaba Nagy, Loup Meurice and Anthony Cleve (2015). "Where Was This SQL Query Executed? A Static Concept Location Approach", In Proceedings of the 22nd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2015). Montréal, Québec, Canada, mar 2-6, 2015., pp. 580-584. IEEE Computer Society. [Abstract] [BibTex] [PDF]
Abstract:

Concept location in software engineering is the process of identifying where a specific concept is implemented in the source code of a software system. It is a very common task performed by developers during development or maintenance, and many techniques have been studied by researchers to make it more efficient. However, most of the current techniques ignore the role of a database in the architecture of a system, which is also an important source of concepts or dependencies among them. In this paper, we present a concept location technique for data-intensive systems, as systems with at least one database server in their architecture which is intensively used by its clients. Specifically, we present a static technique for identifying the exact source code location from where a given SQL query was sent to the database. We evaluate our technique by collecting and locating SQL queries from testing scenarios of two open source Java systems under active development. With our technique, we are able to successfully identify the source of most of these queries.
BibTex:
```
@inproceedings{Nagy2015,
  author = {Nagy, Csaba and Meurice, Loup and Cleve, Anthony},
  title = {Where Was This SQL Query Executed? A Static Concept Location Approach},
  booktitle = {Proceedings of the 22nd IEEE International Conference on Software Analysis, Evolution, and Reengineering (SANER 2015)},
  publisher = {IEEE Computer Society},
  year = {2015},
  pages = {580-584}
}
```
Gábor Szőke, Gábor Antal, Csaba Nagy, Rudolf Ferenc and Tibor Gyimóthy (2014). "Bulk Fixing Coding Issues and Its Effects on Software Quality: Is It Worth Refactoring?", In 14th IEEE International Working Conference on Source Code Analysis and Manipulation, SCAM 2014. Victoria, BC, Canada, sep 28-29, 2014., pp. 95-104. IEEE Computer Society. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

The quality of a software system is mostly defined by its source code. Software evolves continuously, it gets modified, enhanced, and new requirements always arise. If we do not spend time periodically on improving our source code, it becomes messy and its quality will decrease inevitably. Literature tells us that we can improve the quality of our software product by regularly refactoring it. But does refactoring really increase software quality? Can it happen that a refactoring decreases the quality? Is it possible to recognize the change in quality caused by a single refactoring operation? In our paper, we seek answers to these questions in a case study of refactoring large-scale proprietary software systems. We analyzed the source code of 5 systems, and measured the quality of several revisions for a period of time. We analyzed 2 million lines of code and identified nearly 200 refactoring commits which fixed over 500 coding issues. We found that one single refactoring only makes a small change (sometimes even decreases quality), but when we do them in blocks, we can significantly increase quality, which can result not only in the local, but also in the global improvement of the code.
BibTex:
```
@inproceedings{Szoke2014,
  author = {Szőke, Gábor and Antal, Gábor and Nagy, Csaba and Ferenc, Rudolf and Gyimóthy, Tibor},
  title = {Bulk Fixing Coding Issues and Its Effects on Software Quality: Is It Worth Refactoring?},
  booktitle = {14th IEEE International Working Conference on Source Code Analysis and Manipulation, SCAM 2014},
  publisher = {IEEE Computer Society},
  year = {2014},
  pages = {95-104},
  doi = {10.1109/SCAM.2014.18}
}
```
Gábor Szőke, Csaba Nagy, Rudolf Ferenc and Tibor Gyimóthy (2014). "A Case Study of Refactoring Large-Scale Industrial Systems to Efficiently Improve Source Code Quality", In Computational Science and Its Applications – ICCSA 2014. Guimarães, Portugal, jun, 2014. Vol. 8583, pp. 524-540. Springer International Publishing. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

Refactoring source code has many benefits (e.g. improving maintainability, robustness and source code quality), but it takes time away from other implementation tasks, resulting in developers neglecting refactoring steps during the development process. But what happens when they know that the quality of their source code needs to be improved and they can get the extra time and money to refactor the code? What will they do? What will they consider the most important for improving source code quality? What sort of issues will they address first or last and how will they solve them? In our paper, we look for answers to these questions in a case study of refactoring large-scale industrial systems where developers participated in a project to improve the quality of their software systems. We collected empirical data of over a thousand refactoring patches for 5 systems with over 5 million lines of code in total, and we found that developers really optimized the refactoring process to significantly improve the quality of these systems.
BibTex:
```
@inproceedings{Szoeke2014,
  author = {Szőke, Gábor and Nagy, Csaba and Ferenc, Rudolf and Gyimóthy, Tibor},
  editor = {Murgante, Beniamino and Misra, Sanjay and Rocha, AnaMariaA.C. and Torre, Carmelo and Rocha, JorgeGustavo and Falcão, MariaIrene and Taniar, David and Apduhan, BernadyO. and Gervasi, Osvaldo},
  title = {A Case Study of Refactoring Large-Scale Industrial Systems to Efficiently Improve Source Code Quality},
  booktitle = {Computational Science and Its Applications – ICCSA 2014},
  publisher = {Springer International Publishing},
  year = {2014},
  volume = {8583},
  pages = {524-540},
  doi = {10.1007/978-3-319-09156-3_37}
}
```
Gábor Novák, Csaba Nagy and Rudolf Ferenc (2013). "A Regression Test Selection Technique for Magic Systems", In Proceedings of the 13th Symposium on Programming Languages and Software Tools (SPLST 2013). Szeged, Hungary, aug 26-27, 2013., pp. 76-89. [Abstract] [BibTex] [PDF]
Abstract:

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.
BibTex:
```
@inproceedings{Novak2013,
  author = {Novák, Gábor and Nagy, Csaba and Ferenc, Rudolf},
  title = {A Regression Test Selection Technique for Magic Systems},
  booktitle = {Proceedings of the 13th Symposium on Programming Languages and Software Tools (SPLST 2013)},
  year = {2013},
  pages = {76-89}
}
```
Csaba Nagy (2013). "Static Analysis of Data-Intensive Applications", In Proceedings of the 17th European Conference on Software Maintenance and Reengineering (CSMR 2013). Genova, Italy, mar 5-8, 2013. IEEE Computer Society. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

Data-intensive systems are designed to handle data at massive scale, and during the years they might evolve to very large, complex systems. In order to support maintenance tasks of these systems several techniques have been developed to analyze the source code of applications or to analyze the underlying databases for the purpose of reverse engineering, e.g. quality assurance or program comprehension. However, only a few techniques take into account the specialties of data-intensive systems (e.g. dependencies arising via database accesses). In this thesis we conducted research to analyze and to improve data-intensive applications via different methods based on static analysis: methods for recovering architecture of data-intensive systems and a quality assurance methodology for applications developed in Magic 4GL. We targeted SQL as the most widespread databases are relational databases using certain dialect of SQL for their queries. With the proposed techniques we were able to analyze large scale industrial projects, such as banking systems with more than 3 million lines of code, and we successfully recovered architecture maps and quality issues of these systems.
BibTex:
```
@inproceedings{Nagy2013,
  author = {Nagy, Csaba},
  title = {Static Analysis of Data-Intensive Applications},
  booktitle = {Proceedings of the 17th European Conference on Software Maintenance and Reengineering (CSMR 2013)},
  publisher = {IEEE Computer Society},
  year = {2013},
  doi = {10.1109/CSMR.2013.66}
}
```
Dániel Fritsi, Csaba Nagy, Rudolf Ferenc and Tibor Gyimóthy (2013). "A Methodology and Framework for Automatic Layout Independent GUI Testing of Applications Developed in Magic xpa", In Proceedings of the 13th International Conference on Computational Science and Its Applications - ICCSA 2013 - Part II. Ho Chi Minh City, Vietnam, jun 24-27, 2013., pp. 513-528. Springer. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

Testing an application via its Graphical User Interface (GUI) requires lots of manual work, even if some steps of GUI testing can be automated. Test automation tools are great help for testers, particularly for regression testing. However these tools still lack some important features and still require manual work to maintain the test cases. For instance, if the layout of a window is changed without affecting the main functionality of the application, all test cases testing the window must be re-recorded again. This hard maintenance work is one of the greatest problems with the regression tests of GUI applications. In our paper we propose an approach to use the GUI information stored in the source code during automatic testing processes to create layout independent test scripts. The idea was motivated by testing an application developed in a fourth generation language, Magic. In this language the layout of the GUI elements (e.g. position and size of controls) are stored in the code and can be gathered via static code analysis. We implemented the presented approach for Magic xpa in a tool called Magic Test Automation, which is used by our industrial partner who has developed applications in Magic for more than a decade.
BibTex:
```
@inproceedings{Fritsi2013,
  author = {Fritsi, Dániel and Nagy, Csaba and Ferenc, Rudolf and Gyimóthy, Tibor},
  title = {A Methodology and Framework for Automatic Layout Independent GUI Testing of Applications Developed in Magic xpa},
  booktitle = {Proceedings of the 13th International Conference on Computational Science and Its Applications - ICCSA 2013 - Part II},
  publisher = {Springer},
  year = {2013},
  pages = {513-528},
  doi = {10.1007/978-3-642-39643-4_37}
}
```
Richárd Dévai, Judit Jász, Csaba Nagy and Rudolf Ferenc (2013). "Designing and Implementing Control Flow Graph for Magic 4th Generation Language", In Proceedings of the 13th Symposium on Programming Languages and Software Tools (SPLST 2013). Szeged, Hungary, aug 26-27, 2013., pp. 200-214. [Abstract] [BibTex] [PDF]
Abstract:

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 to retrieve information from the code for example 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. During designing and implementing the CFG for this language we identified differences compared to 3rd generation languages because the special programming technique of this language (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.
BibTex:
```
@inproceedings{Devai2013,
  author = {Dévai, Richárd and Jász, Judit and Nagy, Csaba and Ferenc, Rudolf},
  title = {Designing and Implementing Control Flow Graph for Magic 4th Generation Language},
  booktitle = {Proceedings of the 13th Symposium on Programming Languages and Software Tools (SPLST 2013)},
  year = {2013},
  pages = {200-214}
}
```
Csaba Nagy, László Vidács, Rudolf Ferenc, Tibor Gyimóthy, Ferenc Kocsis and István Kovács (2011). "Solutions for Reverse Engineering 4GL Applications, Recovering the Design of a Logistical Wholesale System", In Proceedings of the 15th European Conference on Software Maintenance and Reengineering (CSMR 2011)., mar, 2011., pp. 343 -346. IEEE Computer Society. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

Re-engineering a legacy software system to support new, modern technologies instead of old ones is not an easy task, especially for large systems with a complex architecture. The use of reverse engineering tools is crucial for different subtasks of the full process, such as re-documenting the old code or recovering its design. There are many tools available to assist developers, but most of these tools were designed to deal with third generation languages (e.g. Java, C, C++, C#). However, many large systems are developed in higher level languages (e.g. Magic, Informix, ABAP) and current tools are not able to support all the arising problems during re-engineering systems written in fourth generation languages. In this paper we present a project whose main goal is the development of a technologically and functionally renewed medicinal wholesale system. This system is developed in Magic 4GL, and its development is based on re-engineering an old Magic (version 5) system to uniPaaS, which is the current release version of Magic. In the early phases of this project we developed a reverse engineering toolset for Magic 4GL to support reverse engineering, recovering the design of the old system, and to support some forward engineering tasks too. Here we present a report on this project that was carried out in cooperation with SZEGED Software Zrt and the Department of Software Engineering at the University of Szeged. The project was partly funded by the Economic Development Operational Programme, New Hungary Development Plan.
BibTex:
```
@inproceedings{Nagy2011b,
  author = {Nagy, Csaba and Vidács, László and Ferenc, Rudolf and Gyimóthy, Tibor and Kocsis, Ferenc and Kovács, István},
  title = {Solutions for Reverse Engineering 4GL Applications, Recovering the Design of a Logistical Wholesale System},
  booktitle = {Proceedings of the 15th European Conference on Software Maintenance and Reengineering (CSMR 2011)},
  publisher = {IEEE Computer Society},
  year = {2011},
  pages = {343 -346},
  doi = {10.1109/CSMR.2011.66}
}
```
Csaba Nagy, László Vidács, Rudolf Ferenc, Tibor Gyimóthy, Ferenc Kocsis and István Kovács (2011). "Complexity measures in 4GL environment", In Proceedings of the 2011 International Conference on Computational Science and Its Applications - Volume Part V. Santander, Spain, jun 20-23, 2011., pp. 293-309. Springer-Verlag. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

Nowadays, the most popular programming languages are socalled third generation languages, such as Java, C# and C++, but higher level languages are also widely used for application development. Our work was motivated by the need for a quality assurance solution for a fourth generation language (4GL) called Magic. We realized that these very high level languages lie outside the main scope of recent static analysis techniques and researches, even though there is an increasing need for solutions in 4GL environment. During the development of our quality assurance framework we faced many challenges in adapting metrics from popular 3GLs and defining new ones in 4GL context. Here we present our results and experiments focusing on the complexity of a 4GL system. We found that popular 3GL metrics can be easily adapted based on syntactic structure of a language, however it requires more complex solutions to define complexity metrics that are closer to developers' opinion. The research was conducted in co-operation with a company where developers have been programming in Magic for more than a decade. As an outcome, the resulting metrics are used in a novel quality assurance framework based on the Columbus methodology.
BibTex:
```
@inproceedings{Nagy2011a,
  author = {Nagy, Csaba and Vidács, László and Ferenc, Rudolf and Gyimóthy, Tibor and Kocsis, Ferenc and Kovács, István},
  title = {Complexity measures in 4GL environment},
  booktitle = {Proceedings of the 2011 International Conference on Computational Science and Its Applications - Volume Part V},
  publisher = {Springer-Verlag},
  year = {2011},
  pages = {293-309},
  doi = {10.1007/978-3-642-21934-4_25}
}
```
Csaba Nagy, Rudolf Ferenc and Tibor Bakota (2011). "A true story of refactoring a large Oracle PL/SQL banking system", In European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE 2011). Szeged, Hungary, sep 5-9, 2011. [Abstract] [BibTex] [PDF]
Abstract:

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.
BibTex:
```
@inproceedings{Nagy2011,
  author = {Nagy, Csaba and Ferenc, Rudolf and Bakota, Tibor},
  title = {A true story of refactoring a large Oracle PL/SQL banking system},
  booktitle = {European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE 2011)},
  year = {2011}
}
```
Dániel Fritsi, Csaba Nagy, Rudolf Ferenc and Tibor Gyimóthy (2011). "A Layout Independent GUI Test Automation Tool for Applications Developed in Magic/uniPaaS", In Proceedings of the 12th Symposium on Programming Languages and Software Tools (SPLST 2011). Tallinn, Estonia, oct 4-7, 2011., pp. 248-259. [Abstract] [BibTex] [PDF]
Abstract:

A good software development process involves thorough testing phases, that are usually expensive, but necessary to deliver a reliable and high quality product. Testing an application via its graphical user interface requires lots of manual work, even if some steps of GUI testing can be automated. Test automation tools are a great help for testers, particularly for regression tests. However these tools still lack some important features and still require manual work to maintain the test cases. For instance, if the layout of a window is changed without affecting the main functionality of the application, all test cases testing the window must be re-recorded again. This hard maintenance work is one of the greatest problems with the regression tests of GUI applications. In our paper we propose an approach to use the GUI information stored in the source code during automatic testing processes to create layout independent test scripts. With this technique, the already recorded tests scripts will be unaffected by minor changes in the GUI. It reduces the maintenance effort of very expensive regression tests where thousands of test cases have to be maintained by testing teams. The idea was motivated by testing an application developed in a fourth generation language, Magic/uniPaaS. In this language the layout of the GUI elements (structure of the window, position and size of controls, etc.) are stored in the code and it can be gathered via static code analysis. We implemented the presented approach for Magic/uniPaaS, and our Magic Test Automation tool is used by our industrial partner who has developed applications in Magic/uniPaaS for more than a decade.
BibTex:
```
@inproceedings{Fritsi2011,
  author = {Fritsi, Dániel and Nagy, Csaba and Ferenc, Rudolf and Gyimóthy, Tibor},
  title = {A Layout Independent GUI Test Automation Tool for Applications Developed in Magic/uniPaaS},
  booktitle = {Proceedings of the 12th Symposium on Programming Languages and Software Tools (SPLST 2011)},
  year = {2011},
  pages = {248-259}
}
```
Gabriella Tóth, Csaba Nagy, Judit Jász, Árpád Beszédes and Fülöp Lajos (2010). "CIASYS--Change Impact Analysis at System Level", In Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR 2010). Madrid, Spain, mar 15-18, 2010., pp. 198-201. IEEE Computer Society. [Abstract] [BibTex] [DOI]
Abstract:

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.
BibTex:
```
@inproceedings{Toth2010,
  author = {Tóth, Gabriella and Nagy, Csaba and Jász, Judit and Beszédes, Árpád and Lajos, Fülöp},
  title = {CIASYS--Change Impact Analysis at System Level},
  booktitle = {Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR 2010)},
  publisher = {IEEE Computer Society},
  year = {2010},
  pages = {198-201},
  doi = {10.1109/CSMR.2010.35}
}
```
Csaba Nagy, János Pántos, Tamás Gergely and Árpád Beszédes (2010). "Towards a Safe Method for Computing Dependencies in Database-Intensive Systems", In Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR 2010). Madrid, Spain, mar 15-18, 2010., pp. 166-175. IEEE Computer Society. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

Determining dependencies between different components of an application is useful in lots of applications (e. g., architecture reconstruction, reverse engineering, regression test case selection, change impact analysis). However, implementing automated methods to recover dependencies has many challenges, particularly in systems using databases, where dependencies may arise via database access. Furthermore, it is especially hard to find safe techniques (which do not omit any important dependency) that are applicable to large and complex systems at the same time. We propose two techniques that can cope with these problems in most situations. These methods compute dependencies between procedures or database tables, and they are based on the simultaneous static analysis of the source code, the database schema and the SQL instructions. In this paper, we quantitatively and qualitatively evaluate the methods on real-life data, and also evaluate them on some of their potential applications.
BibTex:
```
@inproceedings{Nagy2010a,
  author = {Nagy, Csaba and Pántos, János and Gergely, Tamás and Beszédes, Árpád},
  title = {Towards a Safe Method for Computing Dependencies in Database-Intensive Systems},
  booktitle = {Proceedings of the 14th European Conference on Software Maintenance and Reengineering (CSMR 2010)},
  publisher = {IEEE Computer Society},
  year = {2010},
  pages = {166-175},
  doi = {http://doi.ieeecomputersociety.org/10.1109/CSMR.2010.29}
}
```
Csaba Nagy, László Vidacs, Rudolf Ferenc, Tibor Gyimóthy, Ferenc Kocsis and István Kovács (2010). "MAGISTER: Quality assurance of Magic applications for software developers and end users", In Proceedings of the 26th IEEE International Conference on Software Maintenance (ICSM 2010). Timisoara, Romania, sep 12-18, 2010., pp. 1-6. IEEE Computer Society. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

Nowadays there are many tools and methods available for source code quality assurance based on static analysis, but most of these tools focus on traditional software development techniques with 3GL languages. Besides procedural languages, 4GL programming languages such as Magic 4GL and Progress are widely used for application development. All these languages lie outside the main scope of analysis techniques. In this paper we present MAGISTER, which is a quality assurance framework for applications being developed in Magic, a 4GL application development solution created by Magic Software Enterprises. MAGISTER extracts data using static analysis methods from applications being developed in different versions of Magic (v5-9 and uniPaaS). The extracted data (including metrics, rule violations and dependency relations) is presented to the user via a GUI so it can be queried and visualized for further analysis. It helps software developers, architects and managers through the full development cycle by performing continuous code scans and measurements.
BibTex:
```
@inproceedings{Nagy2010,
  author = {Nagy, Csaba and Vidacs, László and Ferenc, Rudolf and Gyimóthy, Tibor and Kocsis, Ferenc and Kovács, István},
  title = {MAGISTER: Quality assurance of Magic applications for software developers and end users},
  booktitle = {Proceedings of the 26th IEEE International Conference on Software Maintenance (ICSM 2010)},
  publisher = {IEEE Computer Society},
  year = {2010},
  pages = {1-6},
  doi = {10.1109/ICSM.2010.5609550}
}
```
Csaba Nagy and Spiros Mancoridis (2009). "Static Security Analysis Based on Input-Related Software Faults", In Proceedings of the 13th European Conference on Software Maintenance and Reengineering (CSMR '09). Fraunhofer IESE, Kaiserslautern, Germany, mar 24-27, 2009., pp. 37-46. IEEE Computer Society. [Abstract] [BibTex] [DOI] [PDF]
Abstract:

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 input-related 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 plug in 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.
BibTex:
```
@inproceedings{Nagy2009,
  author = {Nagy, Csaba and Mancoridis, Spiros},
  title = {Static Security Analysis Based on Input-Related Software Faults},
  booktitle = {Proceedings of the 13th European Conference on Software Maintenance and Reengineering (CSMR '09)},
  publisher = {IEEE Computer Society},
  year = {2009},
  pages = {37-46},
  doi = {10.1109/CSMR.2009.51}
}
```

Csaba Nagy, Gábor Lóki, Árpád Beszédes and Tibor Gyimóthy (2007). "Code factoring in GCC on different intermediate languages", In Proceedings of the 10th Symposium on Programming Languages and Software Tools (SPLST 2007). Budapest, Hungary, jun 14-16, 2007., pp. 81-95. [BibTex]

Abstract:

BibTex:

@inproceedings{Nagy2007b,
  author = {Nagy, Csaba and Lóki, Gábor and Beszédes, Árpád and Gyimóthy, Tibor},
  title = {Code factoring in GCC on different intermediate languages},
  booktitle = {Proceedings of the 10th Symposium on Programming Languages and Software Tools (SPLST 2007)},
  year = {2007},
  pages = {81-95}
}

Csaba Nagy (2007). "Extension of GCC with a fully manageable reverse engineering front end", In Proceedings of the 7th International Conference on Applied Informatics (ICAI 2007). Eger, Hungary, jan 28-31, 2007. [Abstract] [BibTex] [PDF]
Abstract:

In the open source community one of the most popular compiler 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 (eg. 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 GCC's back end for code generation. As Columbus has a well-structured schema for the representation of C++ sources, by this transformation we will have the ability to execute those special transformations on the code before the compiling phases. Furthermore this technique opens the possibility to link other front ends (like EDG) with GCC to achieve a more powerful compiler, for example in code size optimizations. This approach has been tested on GCC's official Code-Size Benchmark Environment (CSiBE) as real-world system and for the testing diffeerent metrics have been measured on the compilation with this 'extended compiler' and with the official GCC.
BibTex:
```
@inproceedings{Nagy2007a,
  author = {Nagy, Csaba},
  title = {Extension of GCC with a fully manageable reverse engineering front end},
  booktitle = {Proceedings of the 7th International Conference on Applied Informatics (ICAI 2007)},
  year = {2007}
}
```

Theses

Csaba Nagy (2013). "Evaluating optimization and reverse engineering techniques on data-intensive systems". PhD Thesis, University of Szeged. Szeged, Hungary, dec, 2013. [BibTex] [PDF]

Abstract:

BibTex:

@phdthesis{Nagy2013a,
  author = {Nagy, Csaba},
  title = {Evaluating optimization and reverse engineering techniques on data-intensive systems},
  school = {University of Szeged},
  year = {2013}
}

Csaba Nagy (2007). "Extension of GCC with a fully manageable reverse engineering front end". Master's Thesis, University of Szeged. Szeged, Hungary [BibTex] [PDF]

Abstract:

BibTex:

@mastersthesis{Nagy2007,
  author = {Nagy, Csaba},
  title = {Extension of GCC with a fully manageable reverse engineering front end},
  school = {University of Szeged},
  year = {2007}
}

Miscellaneous

Csaba Nagy and Anthony Cleve (2015). "Parsing and Analyzing SQL Queries in Stack Overflow Questions", In Preproceedings of the Eight Seminar Series on Advanced Techniques & Tools for Software Evolution (SATToSE 2015). Mons, Belgium, jul 6-8, 2015. [Abstract] [BibTex] [PDF]
Abstract:

The rapid growth and increasing popularity of Stack Overflow made it a large knowledge base of several programming topics which also attracts researchers. To mention a few examples, they study actual trends that developers follow design questions of Q&A systems island parsing techniques to analyze posts, recommendation systems, and try model the quality of the posts. In our paper, we introduce an approach to parse and analyze SQL queries in Stack Overflow questions with the main goal to identify common patterns among them. Such similar structures in SQL statements can point to problematic language constructs (e.g. antipatterns) in SQL statements which should be avoided by developers.
BibTex:
```
@inproceedings{Nagy2015_misc,
  author = {Nagy, Csaba and Cleve, Anthony},
  title = {Parsing and Analyzing SQL Queries in Stack Overflow Questions},
  booktitle = {Preproceedings of the Eight Seminar Series on Advanced Techniques & Tools for Software Evolution (SATToSE 2015)},
  year = {2015}
}
```

Csaba Nagy (2014). "Adat-intenzív szoftverrendszerek", In SZTE Talent Press Az SZTE Tehetségpont disszeminációs és tudomány-népszerűsítő magazinja.VI University of Szeged. [BibTex] [PDF]

Abstract:

BibTex:

@incollection{Nagy2014a_misc,
  author = {Nagy, Csaba},
  title = {Adat-intenzív szoftverrendszerek},
  booktitle = {SZTE Talent Press Az SZTE Tehetségpont disszeminációs és tudomány-népszerűsítő magazinja},
  publisher = {University of Szeged},
  year = {2014},
  number = {VI}
}

Csaba Nagy and Anthony Cleve (2014). "A Static Concept Location Technique for Data-Intensive Systems: "Where Was This SQL Query Executed?"", In Proceedings of the Software Evolution in Belgium and the Netherlands seminar (BENEVOL 2014). Amsterdam, Netherland, nov 27-28, 2014. Centrum Wiskunde & Informatica (CWI). [Abstract] [BibTex] [PDF]
Abstract:

An evolving software system is incrementally modified, changed by its developers during the development and maintenance phases. Before the developers start working on a change they need to identify which parts of the source code implement the feature, and should be touched first during the change. In practice, what they do is a concept location task (also known as feature identification/location) which is 'the process that identifies where a software system implements a specific concept'. There are many existing approaches to support developers in concept location tasks starting from simple pattern matching (so-called `grep' techniques) to more sophisticated methods like IR- based techniques or dependency analyzes. However, none of the existing approaches consider when there is a database in the architecture, which adds further source artifacts or dependencies. Here, we investigate a concept location approach for data-intensive systems, as applications with at least one database server in their architecture which is intensively used by its clients. Specifically, we introduce a static technique to identify the location(s) in the source code where a given SQL query was potentially sent to the database server.
BibTex:
```
@inproceedings{Nagy2014_misc,
  author = {Nagy, Csaba and Cleve, Anthony},
  title = {A Static Concept Location Technique for Data-Intensive Systems: "Where Was This SQL Query Executed?"},
  booktitle = {Proceedings of the Software Evolution in Belgium and the Netherlands seminar (BENEVOL 2014)},
  publisher = {Centrum Wiskunde & Informatica (CWI)},
  year = {2014}
}
```

Csaba Nagy (2009). "Static Security Analysis Based on Input Related Software Faults", In Proceedings of the Hungarian-American Sholarship Fund (HAESF) Five Year Anniversary Conference. Hungarian Academy of Sciences, Budapest, Hungary, sep 18, 2009., pp. 12. HEASF, CIEE. [BibTex]

Abstract:

BibTex:

@conference{Nagy2009b_misc,
  author = {Nagy, Csaba},
  title = {Static Security Analysis Based on Input Related Software Faults},
  booktitle = {Proceedings of the Hungarian-American Sholarship Fund (HAESF) Five Year Anniversary Conference},
  publisher = {HEASF, CIEE},
  year = {2009},
  pages = {12}
}