@inproceedings{MTMT:34205378,
	title = {Towards Better Tool Support for Code Comprehension},
	url = {https://m2.mtmt.hu/api/publication/34205378},
	author = {Brunner, Tibor and Cserép, Máté and Fekete, Anett and Mészáros, Mónika and Porkoláb, Zoltán},
	booktitle = {Composability, Comprehensibility and Correctness of Working Software},
	doi = {10.1007/978-3-031-42833-3_6},
	unique-id = {34205378},
	abstract = {In software development, bug fixing and feature development requires a thorough understanding of all details and consequences of the planned changes. For long-existing large software systems, the code-base has been developed and maintained for decades by fluctuating teams, thus original intentions are lost, the documentation is untrustworthy or missing. Most times, the only reliable information is the code itself. Source code comprehension of such large software is an essential, but usually very challenging task. The comprehension process and approach of existing systems is fundamentally different from writing new software, and the usual development tools provide poor support in this area. Throughout the years, different tools have been developed with various complexity and feature set for code comprehension but none of them fulfilled all specific requirements yet. In this paper we discuss the most accepted models for code comprehension, the required feature set for tools supporting the comprehension process and the various approaches of existing solutions. We present CodeCompass – an open source LLVM/Clang based tool to help understanding large legacy software systems – in detail to analyse the required interface, possible design choices and implementation considerations. Based on the LLVM/Clang compiler infrastructure, CodeCompass gives exact information on complex C/C++ language elements such as inheritance, overloading, variable usage, possible function pointer and virtual function calls etc. These are all features for which various existing tools provide only partial support. Although CodeCompass supports mainly the C and C++ programming languages, it has a restricted support for Java and Python languages as well, therefore our investigation is language-independent.},
	keywords = {Static analysis; Code comprehension; Clang},
	year = {2023},
	pages = {165-201},
	orcid-numbers = {Cserép, Máté/0000-0002-3168-7736; Fekete, Anett/0000-0001-8466-7096; Mészáros, Mónika/0000-0002-6581-8263; Porkoláb, Zoltán/0000-0001-6819-0224}
}

@inproceedings{MTMT:30738594,
	title = {Delivering comprehension features into source code editors through LSP},
	url = {https://m2.mtmt.hu/api/publication/30738594},
	author = {Mészáros, Mónika and Cserép, Máté and Fekete, Anett},
	booktitle = {2019 42nd International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO)},
	doi = {10.23919/MIPRO.2019.8756695},
	unique-id = {30738594},
	abstract = {The maintenance of large, legacy software often results in higher development time and cost due to increasing size and complexity of the codebase and its documentation, their continuously eroding quality and fluctuation among developers.
		Code comprehension tools are designed to tackle this issue by providing various textual information, visualization views and source code metrics on multiple abstraction levels. These tools usually process not only the codebase, but also the build information, the version control repository and other available information sources. Meanwhile source code editors and integrated development environments (IDEs) are not performing well in the field of code comprehension as they are optimized for writing new code, not for effective browsing. This can easily result in frequent switching between environments during development, hindering effective programming and raising development cost.
		Language Server Protocol (LSP) is an open-source protocol to connect source code editors with servers that provide language-specific features. In this research we analyze how LSP can be utilized to improve the code comprehension experience inside code editors by integrating the features of such tools through remote procedure calls. As a prototype solution we showcase the integration of two open-source applications: Visual Studio Code and the CodeCompass code comprehension tool.},
	year = {2019},
	pages = {1581-1586},
	orcid-numbers = {Cserép, Máté/0000-0002-3168-7736}
}

@inproceedings{MTMT:2388143,
	title = {Layered representation of source code},
	url = {https://m2.mtmt.hu/api/publication/2388143},
	author = {Mészáros, Mónika and Horváth, Zoltán and Kovács, Andrea Erika and Leskó, Dániel},
	booktitle = {MaCS 2010},
	unique-id = {2388143},
	year = {2011},
	pages = {337-350},
	orcid-numbers = {Horváth, Zoltán/0000-0001-9213-2681; Leskó, Dániel/0000-0001-9886-9537}
}

@inproceedings{MTMT:2074366,
	title = {Detaching and reconstructing the documentary structure of source code},
	url = {https://m2.mtmt.hu/api/publication/2074366},
	author = {Góbi, Attila and Kovács, Andrea Erika and Leskó, Dániel and Mészáros, Mónika},
	booktitle = {Proceedings of the 8th International Conference on Applied Informatics, ICAI 2010},
	unique-id = {2074366},
	abstract = {Formattings, comments and whitespaces in source code, ie. the documentary structure of the source code should be preserved during program transformations if the produced source is for human consumption. However, program transformations are easier to be described if the documentary structure may be discarded.
		
		This paper presents a solution that the documentary structure is detached before the transformations and it is re-attached after the transformations. The detached information is stored in three layers: token formattings, comments, and layout, what we call layered representation. This representation is also suitable for analysing and refactoring the documentary structure of the source code. This model is worked out for the F# programming language, and it has been implemented in, too. The proposed approach can be adapted to other programming languages.},
	year = {2010},
	pages = {401-408},
	orcid-numbers = {Góbi, Attila/0000-0003-3276-0883; Leskó, Dániel/0000-0001-9886-9537}
}

@inproceedings{MTMT:1653146,
	title = {Untangling Type Inference and Scope Analysis},
	url = {https://m2.mtmt.hu/api/publication/1653146},
	author = {Góbi, Attila and Kozsik, Tamás and Mészáros, Mónika and Antyipin, Artyom Szergejevics and Batha, Dorián and Kiss, Tamás},
	booktitle = {Proceedings of the 8th International Conference on Applied Informatics, ICAI 2010},
	unique-id = {1653146},
	abstract = {Many modern functional programming languages support record 
		types, parametric polymorphism and type inference. Allowing the 
		same field name for two different records causes a problem in 
		these languages. Some languages (e.g. Haskell) do not let you 
		share the same field name among record types.
		Other languages (e.g. Clean) take the ambiguity of field names 
		into account when deciding the type of a record expression. In 
		the latter case the necessary static analysis performed by the 
		compiler tangles type inference and scope analysis, because the 
		scope analysis of field names needs type information and vice 
		versa. This can result in a complex type inference algorithm and 
		hardly maintainable code in the compiler of a language 
		supporting namespaces and records.
		This paper will provide a method to decouple type inference and 
		scope analysis by using the Bottom-Up algorithm. This way an 
		iterative algorithm with consecutive type inference and scope 
		analysis phases can be given.},
	year = {2010},
	pages = {157-164},
	orcid-numbers = {Góbi, Attila/0000-0003-3276-0883; Kozsik, Tamás/0000-0003-4484-9172}
}