Robert Heumüller

@inproceedings{Nielebock2020,
title = {Cooperative API Misuse Detection Using Correction Rules},
author = {Sebastian Nielebock and Robert Heum\"{u}ller and Jacob Kr\"{u}ger and Frank Ortmeier},
editor = {ACM},
url = {https://cse.cs.ovgu.de/cse-wordpress/wp-content/uploads/2020/02/cooperative-api-misuse-detection-1.pdf
https://bitbucket.org/SNielebock/icse-2020-nier-cooperative-api-misuse/src/master/},
doi = {10.1145/3377816.3381735},
year = {2020},
date = {2020-05-29},
booktitle = {Proccedings of the 42nd IEEE/ACM International Conference on Software Engineering - New Ideas and Emerging Results Track, ICSE-NIER},
publisher = {ACM},
keywords = {},
pubstate = {forthcoming},
tppubtype = {inproceedings}
}

@inproceedings{Kr\"{u}ger2020,
title = {How Can I Contribute? A Qualitative Analysis of Community Websites of 25 Unix-Like Distributions},
author = {Jacob Kr\"{u}ger and Sebastian Nielebock and Robert Heum\"{u}ller},
editor = {ACM },
url = {https://cse.cs.ovgu.de/cse-wordpress/wp-content/uploads/2020/02/docsAnalysis.pdf
https://doi.org/10.5281/zenodo.3665429},
doi = {10.1145/3383219.3383256},
year = {2020},
date = {2020-04-16},
booktitle = {Proceedings of the 24th International Conference on Evaluation and Assessment in Software Engineering, (EASE) - Short Papers Track},
journal = {Proceedings of the 24th International Conference on Evaluation and Assessment in Software Engineering, (EASE)},
keywords = {},
pubstate = {forthcoming},
tppubtype = {inproceedings}
}

@inproceedings{Heum\"{u}ller2019,
title = {SpecTackle - A Specification Mining Experimentation Platform},
author = {Robert Heum\"{u}ller and Sebastian Nielebock and Frank Ortmeier},
url = {https://cse.cs.ovgu.de/cse-wordpress/wp-content/uploads/2019/11/paper_spectackle_heumueller2019.pdf},
year = {2019},
date = {2019-08-30},
booktitle = {Proceedings of the 45th Euromicro Conference on Software Engineering and Advanced Applications (SEAA),Kallithea, Chalkidiki. Greece},
organization = {Euromicro},
abstract = {Nowadays, API Specification Mining is an important cornerstone of automated software engineering. In this paper, we
introduce SpecTackle, an IDE-based experimentation platform aiming to facilitate experimentation and validation of
specification mining algorithms and tools. SpecTackle strives toward (1) providing easy access to various specification
mining tools, (2) simplifying configuration and usage through a shared interface, and (3) in-code visualization of
pattern occurrences. The first version supports two heterogeneous mining tools, a third-party graph-based miner as well
as a custom sequence mining tool. In the long term, SpecTackle envisions to also provide ground-truth benchmark projects,
a unified pattern meta-model and parameter optimization for mining tools.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@inproceedings{NielebockAPIMisuseCommits2018,
title = {Commits as a Basis for API Misuse Detection},
author = {Sebastian Nielebock and Robert Heum\"{u}ller and Frank Ortmeier},
editor = {ACM},
url = {https://cse.cs.ovgu.de/cse-wordpress/wp-content/uploads/2018/08/nielebock-et-al-Commits_as_a_Basis_for_API_Misuse_Detection.pdf},
doi = {10.1145/3242887.3242890},
year = {2018},
date = {2018-09-03},
booktitle = {Proceedings of the 7th International Workshop on Software Mining (SoftwareMining ’18), September 3, 2018, Montpellier, France.},
journal = {Proceedings of the 7th International Workshop on Software Mining (SoftwareMining ’18), September 3, 2018, Montpellier, France.},
pages = {4},
publisher = {ACM},
address = {New York, NY, USA},
abstract = {Programmers frequently make use of APIs.
However, these usages can result in unintended, negative behavior, when developers are not aware of the correct usage or side effects of that API.
Detecting those API misuses by means of automatic testing is challenging, as many test suites do not cover this unintended behavior.

Instead, API usage patterns are used as specifications to verify the correctness of applications.
However, to find meaningful patterns, i.e., those capable of fixing the misuse, the context of the misuse must be considered.
Since the developer usually does not know which API is misused, a much larger code section has to be verified against many potential patterns.

In this paper, we present a new idea to enhance API misuse detection by means of commits.
We discuss the potential of using commits (1) to decrease the size of the code to be considered, (2) to identify suspicious commits, and (3) to contain API usages which can be used to shepherd API specification mining.

This paper shows first results on the usability of commits for API misuse detection and some insights into what makes a commit suspicious in terms of exhibiting potential API misuses.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@inproceedings{HeumuellerInteractionPatterns2018,
title = {Who plays with Whom? ... and How? Mining API Interaction Patterns from Source Code},
author = {Robert Heum\"{u}ller and Sebastian Nielebock and Frank Ortmeier},
editor = {ACM},
url = {https://cse.cs.ovgu.de/cse-wordpress/wp-content/uploads/2018/08/paper-mining-api-interactions.pdf},
doi = {10.1145/3242887.3242888},
year = {2018},
date = {2018-09-03},
booktitle = {Proceedings of the 7th International Workshop on Software Mining (SoftwareMining ’18)},
pages = {4},
publisher = {ACM},
address = {New York, NY, USA},
abstract = {State-of-science automated software engineering techniques increasingly rely on specification mining to provide API
usage patterns for numerous applications, e.g. context sensitive code-completion, bug-detection or bug-fixing
techniques. While some existing approaches already yield good results with respect to diverse tasks, the focus has
always been on the inference of high-quality, reusable specifications for single APIs. However, in contemporary software
development it is commonplace to combine a multitude of different libraries in order to increase efficiency by avoiding
the reimplementation of the wheel. In contrast to prior research, in this idea paper we propose to explicitly study the
patterns of interaction between multiple different APIs. First, we introduce a method for mining API interactions
patterns from existing applications. Then, we give an overview of our preliminary investigation, in which we applied the
method to a case-study of nearly 500 Android applications. The exemplary results show that there definitely exist
valuable interaction patterns which can be helpful for various traditional and automated software engineering tasks.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@article{NielebockLambda2018,
title = {Programmers do not Favor Lambda Expressions for Concurrent Object-Oriented Code},
author = {Sebastian Nielebock and Robert Heum\"{u}ller and Frank Ortmeier},
editor = {Springer},
url = {https://cse.cs.ovgu.de/cse-wordpress/wp-content/uploads/2018/11/2018-11-06-ESEC-FSE-Lambda-In-Concurrency_prepared_publication.pdf
https://cse.cs.ovgu.de/cse-wordpress/wp-content/uploads/2018/10/journal-emse-lambda-1.pdf
https://bitbucket.org/SNielebock/lambdainconcurrentdataset},
doi = {10.1007/s10664-018-9622-9},
issn = {1382-3256},
year = {2018},
date = {2018-05-02},
journal = {Springer Empirical Software Engineering (EMSE)},
volume = {24},
number = {1},
pages = {103--138},
abstract = {Lambda expressions have long been state-of-the-art in the functional programming paradigm.
Especially with regard to the use of higher-order functions, they provide developers with a means of defining predicate or projection functions locally, which greatly increases the comprehensibility of the resulting source code.
This benefit has motivated language designers to also incorporate lambda expressions into object-oriented (OO) programming languages.
In particular, they are claimed to facilitate concurrent programming.
One likely reason for this assumption is their purity: pure lambda expressions are free of side effects, and therefore cannot cause, e.g., race conditions.
In this paper, we present the first empirical analysis of whether or not this claim is true for OO projects.

For this purpose, we investigated the application of lambda expressions in 2,923 open-source projects, implemented in one of the most common OO programming languages: C#, C++, and Java.
We present three major findings.
First, the majority of lambda expressions are not applied in concurrent code and most concurrent code does not make use of lambda expressions.
Second, for all three of the languages, we observed that developers compromise their code by applying a significantly higher number of impure, capturing lambda expressions, which are capable of causing race conditions.
Finally, we explored further use cases of lambda expressions and found out that testing, algorithmic implementation, and UI are far more common use-cases for the application of lambda expressions.

Our results encourage to investigate in more detail the reasons that hinder programmers to apply lambda expressions in concurrent programming and to support developers, e.g., by providing automatic refactorings.},
keywords = {},
pubstate = {published},
tppubtype = {article}
}

@inproceedings{Heum\"{u}ller2018,
title = {Leveraging project-specificity to find suitable specifications: student research abstract},
author = {Robert Heum\"{u}ller},
editor = {ACM},
doi = {10.1145/3167132.3167455},
isbn = {978-1-4503-5191-1},
year = {2018},
date = {2018-04-09},
booktitle = {Proceedings of the 33rd Annual ACM Symposium on Applied Computing},
abstract = {Automated inference of API specifications is crucial for scaling various automated software engineering tasks such as bug-detection or bug-fixing. Prior research has therefore focused on techniques to improve the quality, diversity and availability of specifications. Consequently, efficient ways of retrieving the appropriate specifications for a particular task from a specification database will be necessary in future. In our research, we analyse projects using information retrieval techniques (tf-idf), to determine which specifications are characteristic for a project. Our hypothesis is that this knowledge can be exploited to significantly optimize the search process, by focussing on projects which are similar in terms of their characteristic API usages. Initial results indicate that a project-specificity based selection of specifications from different sources can produce candidate sets featuring a larger variety of interesting specifications than support-based, project-agnostic heuristics.},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@mastersthesis{Heum\"{u}ller2015,
title = {Multi-Abstraction Model Based Software Development for Embedded Low-Cost Applications},
author = {Robert Heum\"{u}ller},
url = {https://cse.cs.ovgu.de/cse-wordpress/wp-content/uploads/2017/01/thesis-1.pdf},
year = {2015},
date = {2015-11-06},
keywords = {},
pubstate = {published},
tppubtype = {mastersthesis}
}

@inproceedings{Heum\"{u}ller2014,
title = {Parsing Variant C Code: An Evaluation on Automotive Software},
author = {Robert Heum\"{u}ller and Jochen Quante and Andreas Thums},
editor = {GI},
year = {2014},
date = {2014-04-30},
booktitle = {16. Workshop Software-Reengineering & Evolution},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}

@mastersthesis{thesis-heumueller-2014,
title = {VECS Dataflow - A SAML Language Extension Allowing Intuitive Creation of Formal Automata Specifications},
author = {Robert Heum\"{u}ller},
url = {/cse/wp-content/uploads/2015/03/thesis.pdf},
year = {2014},
date = {2014-04-10},
type = {Bachelor\'s Thesis},
keywords = {},
pubstate = {published},
tppubtype = {mastersthesis}
}

@inproceedings{FODB:80901349,
title = {A Dataflow Notation for SAML - Formal Modeling Without Fearing Timing Constraints},
author = { Robert Heum\"{u}ller and Michael Lipaczewski and Frank Ortmeier},
year = {2014},
date = {2014-01-01},
booktitle = {IMBSA 2014: short & tutorial proceedings of the 4th international symposium on model based safety assessment. - Magdeburg : Univ.},
pages = {43-50},
keywords = {},
pubstate = {published},
tppubtype = {inproceedings}
}