@article{MTMT:31813117,
	title = {Type Inference of Simple Recursive Functions in Scala},
	url = {https://m2.mtmt.hu/api/publication/31813117},
	author = {Nagy, Gergely Attila and Oláh, Gábor and Porkoláb, Zoltán},
	doi = {10.14232/actacyb.282762},
	journal-iso = {ACTA CYBERN-SZEGED},
	journal = {ACTA CYBERNETICA},
	volume = {25},
	unique-id = {31813117},
	issn = {0324-721X},
	year = {2022},
	eissn = {2676-993X},
	pages = {797-815},
	orcid-numbers = {Nagy, Gergely Attila/0000-0002-0736-8903; Porkoláb, Zoltán/0000-0001-6819-0224}
}

@mastersthesis{MTMT:32475721,
	title = {Elements of multiparadigm programming in Scala},
	url = {https://m2.mtmt.hu/api/publication/32475721},
	author = {Nagy, Gergely Attila},
	doi = {10.15476/ELTE.2020.143},
	publisher = {Eötvös Loránd University},
	unique-id = {32475721},
	year = {2021}
}

@{MTMT:31064451,
	title = {Scala compiler optimization},
	url = {https://m2.mtmt.hu/api/publication/31064451},
	author = {Nagy, Gergely Attila},
	unique-id = {31064451},
	year = {2019}
}

@{MTMT:31064403,
	title = {Scala recursive function typer},
	url = {https://m2.mtmt.hu/api/publication/31064403},
	author = {Nagy, Gergely Attila},
	unique-id = {31064403},
	year = {2019}
}

@{MTMT:31064391,
	title = {Scala call graph analyzer},
	url = {https://m2.mtmt.hu/api/publication/31064391},
	author = {Nagy, Gergely Attila},
	unique-id = {31064391},
	year = {2019}
}

@inproceedings{MTMT:31046000,
	title = {Comparing Software Complexity of Monadic Error Handling and Using Exceptions},
	url = {https://m2.mtmt.hu/api/publication/31046000},
	author = {Nagy, Gergely Attila},
	booktitle = {2019 42nd International Convention on Information and Communication Technology, Electronics and Microelectronics (MIPRO)},
	doi = {10.23919/MIPRO.2019.8757213},
	unique-id = {31046000},
	abstract = {Exception handling has been the definitive way to handle errors of any kind and exceptional circumstances in modern software. Using exceptions ease comprehension of single-threaded software by reducing complexity, but concurrency and asynchronous programming models require other approaches as the stack at the state of an error may not hold semantically important information. A way to handle such cases has been introduced to standard libraries, for example in Scala, the Try and - to some extent - Option constructs help programmers. Since these display monadic behavior, they provide improved composability compared to exception-based methods.Measuring software complexity can be done using software metrics. There are several well-known definitions: lines of code, cyclomatic complexity or McCabe-metrics, Halstead complexity measures and A-V.In this paper, we use definitions of widely-known metrics that have been extended for the case of exception handling and compare complexity of monadic error handling with standard exception handling techniques.},
	keywords = {software metrics; exceptions; monadic error handling},
	year = {2019},
	pages = {1575-1580}
}

@{MTMT:30970214,
	title = {Analyzing Scale-Free Properties in Erlang and Scala},
	url = {https://m2.mtmt.hu/api/publication/30970214},
	author = {Oláh, Gábor and Nagy, Gergely Attila and Porkoláb, Zoltán},
	booktitle = {Central European Functional Programming School},
	doi = {10.1007/978-3-030-28346-9_10},
	unique-id = {30970214},
	abstract = {The optimal modularization and the right level of coupling between components are important for the overall quality of software systems. Although the generic suggestion is to minimize the coupling between modules, earlier research on object-oriented programming showed that there is a natural limit to eliminating dependencies between classes. In our research we extend these findings for non-OOP systems and show that this limitation seems to be paradigm-independent. For this purpose we define paradigm-agnostic metrics for coupling and evaluate them. Our results, measuring Scala and Erlang sources, prove that the coupling behavior shows scale-free properties. Our contribution could be useful to avoid unnecessary or harmful code refactors to chase overall low coupling in systems.},
	year = {2019},
	pages = {380-393},
	orcid-numbers = {Porkoláb, Zoltán/0000-0001-6819-0224}
}

@inproceedings{MTMT:30773500,
	title = {Tools supporting green computing in Erlang},
	url = {https://m2.mtmt.hu/api/publication/30773500},
	author = {Nagy, Gergely Attila and Mészáros, Áron Attila and Bozó, István and Tóth, Melinda},
	booktitle = {Proceedings of the 18th ACM SIGPLAN International Workshop on Erlang - Erlang 2019},
	doi = {10.1145/3331542.3342570},
	unique-id = {30773500},
	year = {2019},
	pages = {30-35},
	orcid-numbers = {Bozó, István/0000-0001-5145-9688; Tóth, Melinda/0000-0001-6300-7945}
}

@inproceedings{MTMT:30970372,
	title = {Read-Copy-Update as a Possible Locking Strategy in Scala},
	url = {https://m2.mtmt.hu/api/publication/30970372},
	author = {Nagy, Gergely Attila and Porkoláb, Zoltán},
	booktitle = {Proceedings of the Seventh Workshop on Software Quality Analysis, Monitoring, Improvement, and Applications, SQAMIA 2018},
	unique-id = {30970372},
	abstract = {Concurrent programming with classical mutex/lock techniques does not scale well when reads are way more frequent than writes. In such situations the read-copy-update (RCU) locking pattern guarantees minimal overhead for read operations and allows them to occur concurrently with write operations thus may outperform classical mutexes or reader-writer locks. RCU is well-known technique among C programmers implementing performance critical low level multithreaded applications, like operating system kernels. Up to now, RCU pattern was rarely applied for high level programming languages. In this paper, we argue in favor of applying RCU for higher level object-oriented constructions and present our experimental Scala RCU class library. The library has been carefully designed to optimize performance in a heavily multithreaded environment, in the same time providing high-level abstractions, applicable in the multiparadigm environment where Scala programming language is typically utilized. We evaluated our library implementing a concurrent HashMap container.},
	year = {2018},
	pages = {1-8},
	orcid-numbers = {Porkoláb, Zoltán/0000-0001-6819-0224}
}

@inproceedings{MTMT:30380175,
	title = {Performance Issues with Implicit Resolution in Scala},
	url = {https://m2.mtmt.hu/api/publication/30380175},
	author = {Nagy, Gergely Attila and Porkoláb, Zoltán},
	booktitle = {Proceedings of the 10th International Conference on Applied Informatics},
	doi = {10.14794/ICAI.10.2017.211},
	unique-id = {30380175},
	abstract = {Scala is an emerging programming language that supports multiple programming
		paradigms. It has been designed to support high levels of expressiveness
		and to allow writing concise code. To achieve this, it supports
		many features, including but not limited to macros, DSLs as well as implicit
		type conversions and implicit argument lists to functions. Due to the wide
		range of language features and the advanced static type system, the Scala
		compiler possesses a non-trivial implementation. We have analyzed the performance
		characteristics of the compiler and have found that the major part
		of compilation time is spent on typing syntax trees. This includes implicit
		resolution, thus we have focused our efforts on investigating this specific language
		feature. We have analyzed how typical usage patterns that involve
		implicit resolution affect compilation times. Based on this analysis we have
		managed to assemble a list of recommendations for programming style and
		code management that allow programmers to leverage implicits to their full
		potential, but lead to drastically reduced compilation times},
	year = {2018},
	pages = {211-223},
	orcid-numbers = {Porkoláb, Zoltán/0000-0001-6819-0224}
}