@misc{MTMT:2472708, title = {Debugging and Profiling C++ Template Metaprograms}, url = {https://m2.mtmt.hu/api/publication/2472708}, author = {Porkoláb, Zoltán and Zoltán, Borók-Nagy and Mihalicza, József}, editor = {David, Abrahams and Jon, Kalb and Hartmut, Kaiser}, unique-id = {2472708}, year = {2013}, orcid-numbers = {Porkoláb, Zoltán/0000-0001-6819-0224} } @article{MTMT:2774392, title = {Flow-mediated vasodilation pulse by pulse}, url = {https://m2.mtmt.hu/api/publication/2774392}, author = {László, G Mészáros and Mihalicza, József}, journal-iso = {ARTERY RES}, journal = {ARTERY RESEARCH}, volume = {6}, unique-id = {2774392}, issn = {1872-9312}, year = {2012}, eissn = {1876-4401}, pages = {173-174} } @inproceedings{MTMT:2115545, title = {Type-preserving heap profiler for C++}, url = {https://m2.mtmt.hu/api/publication/2115545}, author = {Mihalicza, József and Porkoláb, Zoltán and Ábel, Gábor}, booktitle = {Proceedings of the 27th IEEE International Conference on Software Maintenance}, doi = {10.1109/ICSM.2011.6080813}, unique-id = {2115545}, abstract = {Memory profilers are essential tools to understand the dynamic behaviour of complex modern programs. They help to reveal memory handling details: the wheres, the whens and the whats of memory allocations. Most heap profilers provide sufficient information about which part of the source code is responsible for the memory allocations by showing us the relevant call stacks. The sequence of allocations inform us about their order. However, in case of some strongly typed programming languages, like C++, the question what has been allocated is not trivial. Reporting the actual allocation size gives minimal or no information about the structure or type of the allocated objects. Though this information can be retrieved from the location and time of allocation, it cannot be easily automated, if at all. Therefore in large software systems programmers do not have an overall picture of which data structures are responsible for bottlenecks and have too few clues for pinpointing enhancement possibilities. In this paper we present a type-preserving heap profiler for C++. On top of the usual heap profiler features our allocation entries, including those of template constructs, contain exact type information about the allocated objects. We can extract information on individual memory operations as well as supply aggregated overview. Having such a type information in hand programmers can identify critical classes more easily and can perform optimizations based on evidence rather than speculations.}, year = {2011}, pages = {457-466}, orcid-numbers = {Porkoláb, Zoltán/0000-0001-6819-0224} } @inproceedings{MTMT:1996654, title = {Compiler Support for Profiling C++ Template Metaprograms}, url = {https://m2.mtmt.hu/api/publication/1996654}, author = {Mihalicza, József and Pataki, Norbert and Porkoláb, Zoltán}, booktitle = {12th Symposium on Programming Languages and Software Tools, SPLST 2011}, unique-id = {1996654}, year = {2011}, pages = {32-43}, orcid-numbers = {Pataki, Norbert/0000-0002-7519-3367; Porkoláb, Zoltán/0000-0001-6819-0224} } @article{MTMT:1993876, title = {Subtle Methods in C++}, url = {https://m2.mtmt.hu/api/publication/1993876}, author = {Szűgyi, Zalán and Pataki, Norbert and Mihalicza, József}, doi = {10.2478/v10198-011-0023-x}, journal-iso = {ACTA ELECTROTECH INF}, journal = {ACTA ELECTROTECHNICA ET INFORMATICA}, volume = {11}, unique-id = {1993876}, issn = {1335-8243}, abstract = {Nowadays complex software systems are designed and implemented with the help of the object-oriented paradigm principally. However, object-oriented languages support the object-oriented paradigm in different ways with different constructs. C++ has a sophisticated inheritence notation based on access modifiers. C++ distinguishes virtual, pure virtual and non-virtual methods. Java uses final classes and methods to disable inheritance. However, Java does not support multiple inheritance. Eiffel allows renaming inherited methods. In this paper we present some method utilites for C++ to create safer and more flexible object-oriented systems. We present how the method renaming can be implemented. We developed constructs to create final and unhidable methods. These constructs are implemented with the help of C++ template facilities. We present scenarios where one can write safer code with our constructs.}, year = {2011}, eissn = {1338-3957}, pages = {11-16}, orcid-numbers = {Pataki, Norbert/0000-0002-7519-3367} } @misc{MTMT:3234783, title = {Features of C++ Template Metaprograms}, url = {https://m2.mtmt.hu/api/publication/3234783}, author = {Pataki, Norbert and Mihalicza, József and Szűgyi, Zalán and Viktor, Májer and Porkoláb, Zoltán}, unique-id = {3234783}, year = {2010}, orcid-numbers = {Pataki, Norbert/0000-0002-7519-3367; Porkoláb, Zoltán/0000-0001-6819-0224} } @inproceedings{MTMT:2115554, title = {How #includes Affect Build Time in Large Systems}, url = {https://m2.mtmt.hu/api/publication/2115554}, author = {Mihalicza, József}, booktitle = {Proceedings of the 8th International Conference on Applied Informatics, ICAI 2010}, unique-id = {2115554}, abstract = {The #include concept, present in numerous mainstream languages like C, C++, Objective C, has unexpectedly bad effects on build times. Many current large systems using the #include technique suffer from unacceptable long build procedure. Long builds waste many valuable manhours or even man months, elongate development and as a result make keeping deadlines harder. Using a different approach in a large system is proven to result in even 10 times faster builds. This paper compares various widely used freeware software packages and shows both the overhead the #includes cause and the gain achieved by applying the mentioned approach.}, year = {2010}, pages = {343-350} } @{MTMT:1996678, title = {Features of C++ Template Metaprograms}, url = {https://m2.mtmt.hu/api/publication/1996678}, author = {Pataki, Norbert and Mihalicza, József and Szűgyi, Zalán and Májer, Viktor and Porkoláb, Zoltán}, booktitle = {Proceedings of the 8th International Conference on Applied Informatics, ICAI 2010}, unique-id = {1996678}, year = {2010}, pages = {451-451}, orcid-numbers = {Pataki, Norbert/0000-0002-7519-3367; Porkoláb, Zoltán/0000-0001-6819-0224} } @inproceedings{MTMT:1993867, title = {Visualization of C++ Template Metaprograms}, url = {https://m2.mtmt.hu/api/publication/1993867}, author = {Borók-Nagy, Zoltán and Májer, Viktor and Mihalicza, József and Pataki, Norbert and Porkoláb, Zoltán}, booktitle = {10th IEEE International Working Conference on Source Code Analysis and Manipulation, SCAM 2010}, doi = {10.1109/SCAM.2010.16}, unique-id = {1993867}, year = {2010}, pages = {167-176}, orcid-numbers = {Pataki, Norbert/0000-0002-7519-3367; Porkoláb, Zoltán/0000-0001-6819-0224} } @CONFERENCE{MTMT:2115558, title = {A practical generalisation of access categories in object-oriented languages}, url = {https://m2.mtmt.hu/api/publication/2115558}, author = {Mihalicza, József}, booktitle = {Informatics 2009: Proceedings of the 10th International Conference on Informatics}, unique-id = {2115558}, abstract = {In object-oriented languages information hiding has an important role. Most languages support it via three or four well defined access categories, like private, protected and public, sometimes package or published. Though this simplification is perfectly enough in many cases, there is definitely a need for a more detailed member and method access control. The existence of the friend keyword is a demonstrative example of this fact. A few languages already contain direct support for selective access specifiers. This paper presents a generalisation of the access category system, which is seamlessly integrating to the existing model and very easy to implement. With a working prototype the selective access specifiers are shown to be available for C++ programmers as well as for those programming in Eiffel.}, year = {2009}, pages = {100-105} }